[c@`sdZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlmZddlmZmZddlmZmZmZddlmZdd lmZydd lmZWnek r-eZnXyddl Z Wnek rWeZ nXej!ej"fZ#e$ed re#ej%f7Z#nej&ej'ej(ej)fZ*e$ed re*ej+ej,ej-f7Z*ne j.d kre*ej/f7Z*nej0fZ1e$edr(e1ej2f7Z1ne j.j3dZ4de5fdYZ6de7fdYZ8de7fdYZ9de:fdYZ;de:fdYZ<de<fdYZ=de=fdYZ>de<fdYZ?d Z@dS(!sBUtility classes to write to and read from non-blocking files and sockets. Contents: * `BaseIOStream`: Generic interface for reading and writing. * `IOStream`: Implementation of BaseIOStream using non-blocking sockets. * `SSLIOStream`: SSL-aware version of IOStream. * `PipeIOStream`: Pipe-based IOStream implementation. i(tabsolute_importtdivisiontprint_functionN(tFuture(tioloop(tgen_logtapp_log(tssl_wrap_sockett_client_ssl_defaultst_server_ssl_defaults(t stack_context(terrno_from_exception(t_set_nonblockingtWSAEWOULDBLOCKt WSAECONNRESETtdarwintWSAEINPROGRESStwintStreamClosedErrorcB`seZdZddZRS(sException raised by `IOStream` methods when the stream is closed. Note that the close callback is scheduled to run *after* other callbacks on the stream (to allow for buffered data to be processed), so you may see this error before you see the close callback. The ``real_error`` attribute contains the underlying error that caused the stream to close (if any). .. versionchanged:: 4.3 Added the ``real_error`` attribute. cC`s#tt|jd||_dS(NsStream is closed(tsuperRt__init__t real_error(tselfR((s/lib/python2.7/site-packages/tornado/iostream.pyRfsN(t__name__t __module__t__doc__tNoneR(((s/lib/python2.7/site-packages/tornado/iostream.pyRYs tUnsatisfiableReadErrorcB`seZdZRS(sException raised when a read cannot be satisfied. Raised by ``read_until`` and ``read_until_regex`` with a ``max_bytes`` argument. (RRR(((s/lib/python2.7/site-packages/tornado/iostream.pyRkstStreamBufferFullErrorcB`seZdZRS(sDException raised by `IOStream` methods when the buffer is full. (RRR(((s/lib/python2.7/site-packages/tornado/iostream.pyRtst _StreamBuffercB`sAeZdZdZdZdZdZdZdZRS(sh A specialized buffer that tries to avoid copies when large pieces of data are encountered. cC`s%tj|_d|_d|_dS(Ni(t collectionstdequet_bufferst _first_post_size(R((s/lib/python2.7/site-packages/tornado/iostream.pyRs cC`s|jS(N(R"(R((s/lib/python2.7/site-packages/tornado/iostream.pyt__len__sicC`st|}||jkrRt|ts9t|}n|jjt|fn~|dkr|jr|jd\}}|pt||jk}nt}|r|jjtt|fq||7}n|j |7_ dS(sX Append the given piece of data (should be a buffer-compatible object). iiN( tlent_large_buf_thresholdt isinstancet memoryviewR tappendtTruetFalset bytearrayR"(Rtdatatsizet is_memviewtbtnew_buf((s/lib/python2.7/site-packages/tornado/iostream.pyR(s    cC`s{|dksty|jd\}}Wntk rCtdSX|j}|rb||||!St||||!SdS(sq Get a view over at most ``size`` bytes (possibly fewer) at the current buffer position. itN(tAssertionErrorR t IndexErrorR'R!(RR-R.R/tpos((s/lib/python2.7/site-packages/tornado/iostream.pytpeeks   cC`s$d|ko|jkns%t|j|8_|j}|j}x|r|dkr|d\}}t|||}|dkr|j|t||8}d}qI|r||7}d}qI||7}t|d|kr||4d}nd}qIW|dkst||_dS(sH Advance the current buffer position by ``size`` bytes. iiN(R"R2R!R R$tpopleft(RR-R4tbufferstis_largeR/tb_remain((s/lib/python2.7/site-packages/tornado/iostream.pytadvances*%          ( RRRRR#R%R(R5R:(((s/lib/python2.7/site-packages/tornado/iostream.pyRys    t BaseIOStreamcB`seZdZd&d&d&dZdZdZdZdZdZ d&d&dZ d&d&dZ d&d&e d Z d&e d Zd&d&d Zd&d Zd Ze dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#d Z$d!Z%d"Z&d#Z'd$Z(d%Z)RS('s]A utility class to write to and read from a non-blocking file or socket. We support a non-blocking ``write()`` and a family of ``read_*()`` methods. All of the methods take an optional ``callback`` argument and return a `.Future` only if no callback is given. When the operation completes, the callback will be run or the `.Future` will resolve with the data read (or ``None`` for ``write()``). All outstanding ``Futures`` will resolve with a `StreamClosedError` when the stream is closed; users of the callback interface will be notified via `.BaseIOStream.set_close_callback` instead. When a stream is closed due to an error, the IOStream's ``error`` attribute contains the exception object. Subclasses must implement `fileno`, `close_fd`, `write_to_fd`, `read_from_fd`, and optionally `get_fd_error`. cC`sUtjj|_|pd|_t|p-d|jd|_||_d|_ t |_ d|_ d|_ t|_d|_t|_d|_d|_d|_d|_d|_d|_t|_t|_d|_d|_d|_d|_tj |_!d|_"d|_#d|_$d|_%t|_&d|_'d|_(t|_)dS(s`BaseIOStream` constructor. :arg max_buffer_size: Maximum amount of incoming data to buffer; defaults to 100MB. :arg read_chunk_size: Amount of data to read at one time from the underlying transport; defaults to 64KB. :arg max_write_buffer_size: Amount of outgoing data to buffer; defaults to unlimited. .. versionchanged:: 4.0 Add the ``max_write_buffer_size`` parameter. Changed default ``read_chunk_size`` to 64KB. .. versionchanged:: 5.0 The ``io_loop`` argument (deprecated since version 4.1) has been removed. i@iiiN(*RtIOLooptcurrenttio_looptmax_buffer_sizetmintread_chunk_sizetmax_write_buffer_sizeRterrorR+t _read_buffert_read_buffer_post_read_buffer_sizeR*t_user_read_buffert_after_user_read_bufferRt _write_buffert_total_write_indext_total_write_done_indext_read_delimitert _read_regext_read_max_bytest _read_bytest _read_partialt_read_until_closet_read_callbackt _read_futuret_streaming_callbackt_write_callbackRRt_write_futurest_close_callbackt_connect_callbackt_connect_futuret_ssl_connect_futuret _connectingt_statet_pending_callbackst_closed(RR?RARB((s/lib/python2.7/site-packages/tornado/iostream.pyRsB                            cC`s tdS(s,Returns the file descriptor for this stream.N(tNotImplementedError(R((s/lib/python2.7/site-packages/tornado/iostream.pytfilenoscC`s tdS(sCloses the file underlying this stream. ``close_fd`` is called by `BaseIOStream` and should not be called elsewhere; other users should call `close` instead. N(R_(R((s/lib/python2.7/site-packages/tornado/iostream.pytclose_fd#scC`s tdS(siAttempts to write ``data`` to the underlying file. Returns the number of bytes written. N(R_(RR,((s/lib/python2.7/site-packages/tornado/iostream.pyt write_to_fd+scC`s tdS(sAttempts to read from the underlying file. Reads up to ``len(buf)`` bytes, storing them in the buffer. Returns the number of bytes read. Returns None if there was nothing to read (the socket returned `~errno.EWOULDBLOCK` or equivalent), and zero on EOF. .. versionchanged:: 5.0 Interface redesigned to take a buffer and return a number of bytes instead of a freshly-allocated object. N(R_(Rtbuf((s/lib/python2.7/site-packages/tornado/iostream.pyt read_from_fd2s cC`sdS(s>Returns information about any error on the underlying file. This method is called after the `.IOLoop` has signaled an error on the file descriptor, and should return an Exception (such as `socket.error` with additional information, or None if no such information is available. N(R(R((s/lib/python2.7/site-packages/tornado/iostream.pyt get_fd_errorAscC`s|j|}tj||_||_y|jWn]tk ro}tjd||j d||S|dk r|j dnnX|S(s,Asynchronously read until we have matched the given regex. The result includes the data that matches the regex and anything that came before it. If a callback is given, it will be run with the data as an argument; if not, this method returns a `.Future`. If ``max_bytes`` is not None, the connection will be closed if more than ``max_bytes`` bytes have been read and the regex is not satisfied. .. versionchanged:: 4.0 Added the ``max_bytes`` argument. The ``callback`` argument is now optional and a `.Future` will be returned if it is omitted. .. deprecated:: 5.1 The ``callback`` argument is deprecated and will be removed in Tornado 6.0. Use the returned `.Future` instead. s*Unsatisfiable read, closing connection: %stexc_infocS`s |jS(N(t exception(tf((s/lib/python2.7/site-packages/tornado/iostream.pytosN( t_set_read_callbacktretcompileRMRNt_try_inline_readRRtinfotcloseRtadd_done_callback(Rtregextcallbackt max_bytestfuturete((s/lib/python2.7/site-packages/tornado/iostream.pytread_until_regexKs  cC`s|j|}||_||_y|jWn]tk rf}tjd||jd||S|dk r|j dnnX|S(s Asynchronously read until we have found the given delimiter. The result includes all the data read including the delimiter. If a callback is given, it will be run with the data as an argument; if not, this method returns a `.Future`. If ``max_bytes`` is not None, the connection will be closed if more than ``max_bytes`` bytes have been read and the delimiter is not found. .. versionchanged:: 4.0 Added the ``max_bytes`` argument. The ``callback`` argument is now optional and a `.Future` will be returned if it is omitted. .. deprecated:: 5.1 The ``callback`` argument is deprecated and will be removed in Tornado 6.0. Use the returned `.Future` instead. s*Unsatisfiable read, closing connection: %sRfcS`s |jS(N(Rg(Rh((s/lib/python2.7/site-packages/tornado/iostream.pyRisN( RjRLRNRmRRRnRoRRp(Rt delimiterRrRsRtRu((s/lib/python2.7/site-packages/tornado/iostream.pyt read_untilss   cC`s|j|}t|tjs't||_||_|dk rjtj dt t j ||_ ny|jWn)|dk r|jdnnX|S(sAsynchronously read a number of bytes. If a ``streaming_callback`` is given, it will be called with chunks of data as they become available, and the final result will be empty. Otherwise, the result is all the data that was read. If a callback is given, it will be run with the data as an argument; if not, this method returns a `.Future`. If ``partial`` is true, the callback is run as soon as we have any bytes to return (but never more than ``num_bytes``) .. versionchanged:: 4.0 Added the ``partial`` argument. The callback argument is now optional and a `.Future` will be returned if it is omitted. .. deprecated:: 5.1 The ``callback`` and ``streaming_callback`` arguments are deprecated and will be removed in Tornado 6.0. Use the returned `.Future` (and ``partial=True`` for ``streaming_callback``) instead. s5streaming_callback is deprecated, use partial insteadcS`s |jS(N(Rg(Rh((s/lib/python2.7/site-packages/tornado/iostream.pyRisN(RjR&tnumberstIntegralR2RORPRtwarningstwarntDeprecationWarningR twrapRTRmRp(Rt num_bytesRrtstreaming_callbacktpartialRt((s/lib/python2.7/site-packages/tornado/iostream.pyt read_bytess     cC`s |j|}|j}t|}||krp|j|}t|j|j|!|(|j|4|j|_n)|dkrt|j|j||*nt|_||_d|_||_||_ ||_ y|j Wn)|dk r|j dnnX|S(sAsynchronously read a number of bytes. ``buf`` must be a writable buffer into which data will be read. If a callback is given, it will be run with the number of read bytes as an argument; if not, this method returns a `.Future`. If ``partial`` is true, the callback is run as soon as any bytes have been read. Otherwise, it is run when the ``buf`` has been entirely filled with read data. .. versionadded:: 5.0 .. deprecated:: 5.1 The ``callback`` argument is deprecated and will be removed in Tornado 6.0. Use the returned `.Future` instead. icS`s |jS(N(Rg(Rh((s/lib/python2.7/site-packages/tornado/iostream.pyRisN(RjRFR$RER'RDRHR)RGRORPRmRRp(RRcRrRRttavailable_bytestntend((s/lib/python2.7/site-packages/tornado/iostream.pyt read_intos.             cC`s|j|}|dk r@tjdttj||_n|jr|jdk rq|j |j t n|j |j t |St |_ y|jWn)|dk r|jdnnX|S(sAsynchronously reads all data from the socket until it is closed. If a ``streaming_callback`` is given, it will be called with chunks of data as they become available, and the final result will be empty. Otherwise, the result is all the data that was read. If a callback is given, it will be run with the data as an argument; if not, this method returns a `.Future`. Note that if a ``streaming_callback`` is used, data will be read from the socket as quickly as it becomes available; there is no way to apply backpressure or cancel the reads. If flow control or cancellation are desired, use a loop with `read_bytes(partial=True) <.read_bytes>` instead. .. versionchanged:: 4.0 The callback argument is now optional and a `.Future` will be returned if it is omitted. .. deprecated:: 5.1 The ``callback`` and ``streaming_callback`` arguments are deprecated and will be removed in Tornado 6.0. Use the returned `.Future` (and `read_bytes` with ``partial=True`` for ``streaming_callback``) instead. sFstreaming_callback is deprecated, use read_bytes(partial=True) insteadcS`s |jS(N(Rg(Rh((s/lib/python2.7/site-packages/tornado/iostream.pyRisN(RjRR{R|R}R R~RTtclosedt_run_read_callbackRFR)R*RQRmRp(RRrRRt((s/lib/python2.7/site-packages/tornado/iostream.pytread_until_closes$     cC`s$|j|rx|jdk rPt|jt||jkrPtdn|jj||jt|7_n|dk rtj dt t j ||_ d}n2t}|jd|jj|j|f|js |j|jr|j|jjn|jn|S(sAsynchronously write the given data to this stream. If ``callback`` is given, we call it when all of the buffered write data has been successfully written to the stream. If there was previously buffered write data and an old write callback, that callback is simply overwritten with this new callback. If no ``callback`` is given, this method returns a `.Future` that resolves (with a result of ``None``) when the write has been completed. The ``data`` argument may be of type `bytes` or `memoryview`. .. versionchanged:: 4.0 Now returns a `.Future` if no callback is given. .. versionchanged:: 4.5 Added support for `memoryview` arguments. .. deprecated:: 5.1 The ``callback`` argument is deprecated and will be removed in Tornado 6.0. Use the returned `.Future` instead. s!Reached maximum write buffer sizes<callback argument is deprecated, use returned Future insteadcS`s |jS(N(Rg(Rh((s/lib/python2.7/site-packages/tornado/iostream.pyRiHsN(t _check_closedRBRR$RIRR(RJR{R|R}R R~RURRpRVR[t _handle_writet _add_io_stateR>tWRITEt_maybe_add_error_listener(RR,RrRt((s/lib/python2.7/site-packages/tornado/iostream.pytwrite s* "        cC`s tj||_|jdS(sCall the given callback when the stream is closed. This mostly is not necessary for applications that use the `.Future` interface; all outstanding ``Futures`` will resolve with a `StreamClosedError` when the stream is closed. However, it is still useful as a way to signal that the stream has been closed while no other read or write is in progress. Unlike other callback-based interfaces, ``set_close_callback`` will not be removed in Tornado 6.0. N(R R~RWR(RRr((s/lib/python2.7/site-packages/tornado/iostream.pytset_close_callbackQs cC`s"|js|rwt|tr1|d|_qwt|trL||_qwtj}t|rw|d|_qwn|jr|j dk r|j r|j |j t nt|_|j |j tn|jdk r|jj|jd|_n|jt |_n|jdS(sClose this stream. If ``exc_info`` is true, set the ``error`` attribute to the current exception from `sys.exc_info` (or if ``exc_info`` is a tuple, use that instead of `sys.exc_info`). iN(RR&ttupleRCt BaseExceptiontsysRftanyRQRTRRFRR)R*R\R>tremove_handlerR`RaR^t_maybe_run_close_callback(RRf((s/lib/python2.7/site-packages/tornado/iostream.pyRo`s*          cC`sZ|jrV|jdkrVg}|jdk rL|j|jd|_n|g|jD]\}}|^qY7}|jj|jdk r|j|jd|_n|jdk r|j|jd|_nx1|D])}|j t d|j |j qW|j dk r:|j }d|_ |j|nd|_|_d|_ndS(NiR(RR]RSRR(RVtclearRYRZt set_exceptionRRCRgRWt _run_callbackRRRURI(Rtfuturest_Rttcb((s/lib/python2.7/site-packages/tornado/iostream.pyR~s, &      cC`s|jdk p|jdk S(s9Returns true if we are currently reading from the stream.N(RRRRS(R((s/lib/python2.7/site-packages/tornado/iostream.pytreadingscC`s t|jS(s7Returns true if we are currently writing to the stream.(tboolRI(R((s/lib/python2.7/site-packages/tornado/iostream.pytwritingscC`s|jS(s+Returns true if the stream has been closed.(R^(R((s/lib/python2.7/site-packages/tornado/iostream.pyRscC`sdS(sSets the no-delay flag for this stream. By default, data written to TCP streams may be held for a time to make the most efficient use of bandwidth (according to Nagle's algorithm). The no-delay flag requests that data be written as soon as possible, even if doing so would consume additional bandwidth. This flag is currently defined only for TCP-based ``IOStreams``. .. versionadded:: 3.1 N((Rtvalue((s/lib/python2.7/site-packages/tornado/iostream.pyt set_nodelays cC`s|jr tjd|dSy|jr9|jn|jrIdS||jj@rf|jn|jrvdS||jj@r|j n|jrdS||jj @r|j |_ |jj |jdS|jj }|jr||jjO}n|jr#||jjO}n||jj krW|jdkrW||jjO}n||jkr|jdk std||_|jj|j|jnWnltk r}tjd||jd|n9tk r}tj ddt|jd|nXdS(NsGot events for closed stream %sis4shouldn't happen: _handle_events without self._states*Unsatisfiable read, closing connection: %sRfs'Uncaught exception, closing connection.(RRtwarningR[t_handle_connectR>tREADt _handle_readRRtERRORReRCt add_callbackRoRRRFR\RR2tupdate_handlerR`RRnt ExceptionR)(RtfdteventststateRu((s/lib/python2.7/site-packages/tornado/iostream.pyt_handle_eventssP           !  # c`sKfd}tj$jd7_jj|WdQXdS(Nc`sojd8_zNySWn9tk r[}tjddtjd|nXWdjXdS(Nis'Uncaught exception, closing connection.Rf(R]RRRCR)RoR(Ru(targsRrR(s/lib/python2.7/site-packages/tornado/iostream.pytwrappers  i(R t NullContextR]R>R(RRrRR((RRrRs/lib/python2.7/site-packages/tornado/iostream.pyRs cC`sz|jdk r|j}n6|jdk r9|j}n|jrNd}nd}d}|jd7_x|js|jdkrPn|j|dk r|j|krPn|j|krl|j }|dk r|S|jd}qlqlW|j SWd|jd8_XdS(Niii( RORRNRR]Rt_read_to_buffert_run_streaming_callbackRFt_find_read_pos(Rt target_bytest next_find_posR4((s/lib/python2.7/site-packages/tornado/iostream.pyt_read_to_buffer_loops0         cC`sy|j}WnHtk r&n5tk rZ}tjd||jd|dSX|dk rx|j|dS|jdS(Nserror on read: %sRf( RRRRRRoRt_read_from_bufferR(RR4Ru((s/lib/python2.7/site-packages/tornado/iostream.pyRKs   cC`sz|jdkstd|jdks6td|dk rgtjdttj||_n t |_|jS(NsAlready readings5callbacks are deprecated, use returned Future instead( RRRR2RSR{R|R}R R~R(RRr((s/lib/python2.7/site-packages/tornado/iostream.pyRjZs   cC`s|jrT|jpt|_d|_d|_t|j|_t|_|}n|j |}|ru|j }n\|j }d|_ |_ |j dk r|dkst |j }d|_ |j|n|dk r |j dks|st |j||n |jdS(Ni(RGRHR+RDRRER$RFR*t_consumeRTRRRSR2t set_resultRR(RR-t streamingtresultRrRt((s/lib/python2.7/site-packages/tornado/iostream.pyRes*          cC`s|j|j}|dk r3|j|dS|jy|j}Wntk rm|jnX|dk r|j|dS|jr|jn|j t j j dS(sAttempt to complete the current read operation from buffered data. If the read can be completed without blocking, schedules the read callback on the next IOLoop iteration; otherwise starts listening for reads on the socket. N( RRRRRRRRRRRR<R(RR4((s/lib/python2.7/site-packages/tornado/iostream.pyRms"           cC`smz'xtryD|jr1t|j|j}nt|j}|j|}Wnptj t t fk r}t |t jkrqn|j|r|jd|dS|jd|nXPqW|dkrdS|dkr|jdS|js|jt|| 7_n|j|7_Wdd}X|j|jkritj d|jtdn|S(sReads from the socket and appends the result to the read buffer. Returns the number of bytes read. Returns 0 if there is nothing to read (i.e. the read returns EWOULDBLOCK or equivalent). On error closes the socket and raises an exception. RfNis Reached maximum read buffer size(R)RGR'RDRFR+RARdtsocketRCtIOErrortOSErrorR terrnotEINTRt _is_connresetRoRR?RR(RRct bytes_readRu((s/lib/python2.7/site-packages/tornado/iostream.pyRs<        cC`sk|jdk rg|jrg|j}|jdk rTt|j|}|j|8_n|j|tndS(N(RTRRFROR@RR)(Rtbytes_to_consume((s/lib/python2.7/site-packages/tornado/iostream.pyRs  cC`s4d|_|_|_t|_|j|tdS(sAttempts to complete the currently-pending read from the buffer. The argument is either a position in the read buffer or None, as returned by _find_read_pos. N(RRORLRMR*RPR(RR4((s/lib/python2.7/site-packages/tornado/iostream.pyRs cC`sq|jdk rR|j|jks9|jrR|jdkrRt|j|j}|S|jdk r|jrm|jj|j|j}|dkr||j8}t |j}|j |j||||S|j |j|jqmn|j dk rm|jrm|j j |j|j}|dk rQ|j |j}|j |j ||S|j |j |jqmndS(sAttempts to find a position in the read buffer that satisfies the currently-pending read. Returns a position in the buffer if the current read can be satisfied, or None if it cannot. iiN(RORRFRPR@RLRDtfindRER$t_check_max_bytesRMtsearchR(RRtloct delimiter_lentm((s/lib/python2.7/site-packages/tornado/iostream.pyRs6          cC`s>|jdk r:||jkr:td||jfndS(Ns&delimiter %r not found within %d bytes(RNRR(RRwR-((s/lib/python2.7/site-packages/tornado/iostream.pyRs cC`sx tr t|j}|s"Pn|dks4ty]trFd}n|j|jj|}|dkrqPn|jj||j|7_Wqt j t t fk r}|j dtkrPq |j|stjd|j|n|jd|dSqXqWxM|jr\|jd\}}||jkr?Pn|jj|jdqWt|js|jr|j}d|_|j|qndS(NiiisWrite error on %s: %sRfi(R)R$RIR2t_WINDOWSRbR5R:RKRRCRRRt_ERRNO_WOULDBLOCKRRRR`RoRVR6RRRUR(RR-RRutindexRtRr((s/lib/python2.7/site-packages/tornado/iostream.pyRs@          cC`s|dkrdS||jks%tt|j|j|j|!j}|j|7_|j|8_|j|jkr|j|j4d|_n|S(NiR1(RFR2R'RDREttobytes(RRR/((s/lib/python2.7/site-packages/tornado/iostream.pyRCs    cC`s%|jr!td|jndS(NR(RRRC(R((s/lib/python2.7/site-packages/tornado/iostream.pyRVs cC`s|jdkrdS|jdks7|jtjjkr|jrP|jq|jdkr|j dk r|j tjj qndS(Ni( R]R\RRR<RRRRFRWRR(R((s/lib/python2.7/site-packages/tornado/iostream.pyRZs$  cC`s|jrdS|jdkrjtjj|B|_tj'|jj |j |j |jWdQXn<|j|@s|j|B|_|jj |j |jndS(sJAdds `state` (IOLoop.{READ,WRITE} flags) to our event handler. Implementation notes: Reads and writes have a fast path and a slow path. The fast path reads synchronously from socket buffers, while the slow path uses `_add_io_state` to schedule an IOLoop callback. Note that in both cases, the callback is run asynchronously with `_run_callback`. To detect closed connections, we must have called `_add_io_state` at some point, but we want to delay this as much as possible so we don't have to set an `IOLoop.ERROR` listener that will be overwritten by the next slow-path operation. As long as there are callbacks scheduled for fast-path ops, those callbacks may do more reads. If a sequence of fast-path ops do not end in a slow-path op, (e.g. for an @asynchronous long-poll request), we must add the error handler. This is done in `_run_callback` and `write` (since the write callback is optional so we can have a fast-path write with no `_run_callback`) N( RR\RRR<RR RR>t add_handlerR`RR(RR((s/lib/python2.7/site-packages/tornado/iostream.pyRjs   " cC`s(t|tjtfo't|tkS(sbReturn true if exc is ECONNRESET or equivalent. May be overridden in subclasses. (R&RRCRR t_ERRNO_CONNRESET(Rtexc((s/lib/python2.7/site-packages/tornado/iostream.pyRsN(*RRRRRR`RaRbRdReRvRxR*RRRRRRoRRRRRRRRRRjRRmRRRRRRRRRRR(((s/lib/python2.7/site-packages/tornado/iostream.pyR;sP9     ($ (2. 1        5 # <   ! .  +  .    !tIOStreamcB`steZdZdZdZdZdZdZdZd d dZ d d dZ d Z d Z RS( sSocket-based `IOStream` implementation. This class supports the read and write methods from `BaseIOStream` plus a `connect` method. The ``socket`` parameter may either be connected or unconnected. For server operations the socket is the result of calling `socket.accept `. For client operations the socket is created with `socket.socket`, and may either be connected before passing it to the `IOStream` or connected with `IOStream.connect`. A very simple (and broken) HTTP client using this class: .. testcode:: import tornado.ioloop import tornado.iostream import socket async def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) stream = tornado.iostream.IOStream(s) await stream.connect(("friendfeed.com", 80)) await stream.write(b"GET / HTTP/1.0\r\nHost: friendfeed.com\r\n\r\n") header_data = await stream.read_until(b"\r\n\r\n") headers = {} for line in header_data.split(b"\r\n"): parts = line.split(b":") if len(parts) == 2: headers[parts[0].strip()] = parts[1].strip() body_data = await stream.read_bytes(int(headers[b"Content-Length"])) print(body_data) stream.close() if __name__ == '__main__': tornado.ioloop.IOLoop.current().run_sync(main) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) stream = tornado.iostream.IOStream(s) stream.connect(("friendfeed.com", 80), send_request) tornado.ioloop.IOLoop.current().start() .. testoutput:: :hide: cO`s6||_|jjttt|j||dS(N(Rt setblockingR*RRR(RRRtkwargs((s/lib/python2.7/site-packages/tornado/iostream.pyRs cC`s|jS(N(R(R((s/lib/python2.7/site-packages/tornado/iostream.pyR`scC`s|jjd|_dS(N(RRoR(R((s/lib/python2.7/site-packages/tornado/iostream.pyRas cC`s4|jjtjtj}tj|tj|S(N(Rt getsockoptt SOL_SOCKETtSO_ERRORRCtoststrerror(RR((s/lib/python2.7/site-packages/tornado/iostream.pyRes cC`sYzKy|jj|SWn0tjk rI}|jdtkrCdSnXWdd}XdS(Ni(Rt recv_intoRCRRR(RRcRu((s/lib/python2.7/site-packages/tornado/iostream.pyRds cC`sz|jj|SWd~XdS(N(Rtsend(RR,((s/lib/python2.7/site-packages/tornado/iostream.pyRbscC`st|_|dk r@tjdttj||_d}nt }|_ y|j j |Wnyt j k r}t|tkrt|tkr|dkrtjd|j j|n|jd||SnX|j|jj|S(sConnects the socket to a remote address without blocking. May only be called if the socket passed to the constructor was not previously connected. The address parameter is in the same format as for `socket.connect ` for the type of socket passed to the IOStream constructor, e.g. an ``(ip, port)`` tuple. Hostnames are accepted here, but will be resolved synchronously and block the IOLoop. If you have a hostname instead of an IP address, the `.TCPClient` class is recommended instead of calling this method directly. `.TCPClient` will do asynchronous DNS resolution and handle both IPv4 and IPv6. If ``callback`` is specified, it will be called with no arguments when the connection is completed; if not this method returns a `.Future` (whose result after a successful connection will be the stream itself). In SSL mode, the ``server_hostname`` parameter will be used for certificate validation (unless disabled in the ``ssl_options``) and SNI (if supported; requires Python 2.7.9+). Note that it is safe to call `IOStream.write ` while the connection is pending, in which case the data will be written as soon as the connection is ready. Calling `IOStream` read methods before the socket is connected works on some platforms but is non-portable. .. versionchanged:: 4.0 If no callback is given, returns a `.Future`. .. versionchanged:: 4.2 SSL certificates are validated by default; pass ``ssl_options=dict(cert_reqs=ssl.CERT_NONE)`` or a suitably-configured `ssl.SSLContext` to the `SSLIOStream` constructor to disable. .. deprecated:: 5.1 The ``callback`` argument is deprecated and will be removed in Tornado 6.0. Use the returned `.Future` instead. s<callback argument is deprecated, use returned Future insteadsConnect error on fd %s: %sRfN(R)R[RR{R|R}R R~RXRRYRtconnectRCR t_ERRNO_INPROGRESSRRRR`RoRR>R(RtaddressRrtserver_hostnameRtRu((s/lib/python2.7/site-packages/tornado/iostream.pyRs&-      c `sP|jsZ|jsZ|jsZ|jsZ|jsZ|jsZ|jsZ|jsZ|jsZ|j rit dn|dkr|rt }qt }n|j}|jj|d|_t||d|d|dt}|jd|_tt|d|fd}j|fd_|j_|j_S( sConvert this `IOStream` to an `SSLIOStream`. This enables protocols that begin in clear-text mode and switch to SSL after some initial negotiation (such as the ``STARTTLS`` extension to SMTP and IMAP). This method cannot be used if there are outstanding reads or writes on the stream, or if there is any data in the IOStream's buffer (data in the operating system's socket buffer is allowed). This means it must generally be used immediately after reading or writing the last clear-text data. It can also be used immediately after connecting, before any reads or writes. The ``ssl_options`` argument may be either an `ssl.SSLContext` object or a dictionary of keyword arguments for the `ssl.wrap_socket` function. The ``server_hostname`` argument will be used for certificate validation unless disabled in the ``ssl_options``. This method returns a `.Future` whose result is the new `SSLIOStream`. After this method has been called, any other operation on the original stream is undefined. If a close callback is defined on this stream, it will be transferred to the new stream. .. versionadded:: 4.0 .. versionchanged:: 4.2 SSL certificates are validated by default; pass ``ssl_options=dict(cert_reqs=ssl.CERT_NONE)`` or a suitably-configured `ssl.SSLContext` to disable. s+IOStream is not idle; cannot convert to SSLRt server_sidetdo_handshake_on_connectt ssl_optionsc`sBjs(jjp!tndk r>ndS(N(tdoneRRCRR((Rttorig_close_callbackt ssl_stream(s/lib/python2.7/site-packages/tornado/iostream.pytclose_callbackps  c`s jS(N(R((RtR(s/lib/python2.7/site-packages/tornado/iostream.pyRisN(RRRSRURVRXRYR]R^RDRIt ValueErrorRR RRR>RRR*RWRt SSLIOStreamRt_ssl_connect_callbackR?RA(RRRRRR((RtRRs/lib/python2.7/site-packages/tornado/iostream.pyt start_tls0s6#             cC`s2y|jjtjtj}Wn4tjk rU}t|tjkrVd}qVnX|dkrtj|tj ||_|j dkrt j d|jjtj|n|jdS|jdk r|j}d|_|j|n|j dk r%|j }d|_ |j|nt|_dS(NisConnect error on fd %s: %s(RRRRRCR Rt ENOPROTOOPTRRRYRRRR`t errorcodeRoRXRRR*R[(RterrRuRrRt((s/lib/python2.7/site-packages/tornado/iostream.pyRs*        cC`s|jdk r|jjtjtjfkry,|jjtjtj|rQdndWqtjk r}|j t j kr|j | rqqXndS(Nii( RRtfamilytAF_INETtAF_INET6t setsockoptt IPPROTO_TCPt TCP_NODELAYRCRtEINVALR(RRRu((s/lib/python2.7/site-packages/tornado/iostream.pyRs"N(RRRRR`RaReRdRbRRRRR(((s/lib/python2.7/site-packages/tornado/iostream.pyRs.     IT RcB`seZdZdZdZdZdZdZdZdZ dZ ddd Z d Z dd Zd Zd ZdZRS(snA utility class to write to and read from a non-blocking SSL socket. If the socket passed to the constructor is already connected, it should be wrapped with:: ssl.wrap_socket(sock, do_handshake_on_connect=False, **kwargs) before constructing the `SSLIOStream`. Unconnected sockets will be wrapped when `IOStream.connect` is finished. cO`s|jdt|_tt|j||t|_t|_ t|_ d|_ d|_ y|jjWntjk rnX|j|jjdS(sThe ``ssl_options`` keyword argument may either be an `ssl.SSLContext` object or a dictionary of keywords arguments for `ssl.wrap_socket` RN(tpopRt _ssl_optionsRRRR)t_ssl_acceptingR*t_handshake_readingt_handshake_writingRRt_server_hostnameRt getpeernameRCRR>R(RRR((s/lib/python2.7/site-packages/tornado/iostream.pyRs     cC`s|jptt|jS(N(RRRR(R((s/lib/python2.7/site-packages/tornado/iostream.pyRscC`s|jptt|jS(N(RRRR(R((s/lib/python2.7/site-packages/tornado/iostream.pyRscC`sy#t|_t|_|jjWnutjk r%}|jdtjkr[t |_dS|jdtj kr~t |_dS|jdtj tj fkr|j d|S|jdtjkry|jj}Wntk rd}nXtjd|jj|||j d|Sntjk r{}|j|se|jdtjtjfkru|j d|SnYtk r}|j d|SXt|_|j|jjs|j dS|jdS(NiRfs(not connected)sSSL Error on %s %s: %s(R*RRRt do_handshaketssltSSLErrorRtSSL_ERROR_WANT_READR)tSSL_ERROR_WANT_WRITEt SSL_ERROR_EOFtSSL_ERROR_ZERO_RETURNRot SSL_ERROR_SSLRRRRR`RCRRtEBADFtENOTCONNtAttributeErrorRt _verify_certt getpeercertt_run_ssl_connect_callback(RRtpeer((s/lib/python2.7/site-packages/tornado/iostream.pyt_do_ssl_handshakesF         cC`sf|jdk r1|j}d|_|j|n|jdk rb|j}d|_|j|ndS(N(RRRRZR(RRrRt((s/lib/python2.7/site-packages/tornado/iostream.pyRs    cC`st|jtr-|jjdtj}n$t|jtjrQ|jj}n|tjtjtj fksut |tjks|j dkrt S|jj}|dkr|tjkrtjdtSytj||j Wn(tjk r}tjd|tSXt SdS(sReturns True if peercert is valid according to the configured validation mode and hostname. The ssl handshake already tested the certificate for a valid CA signature; the only thing that remains is to check the hostname. t cert_reqssNo SSL certificate givensInvalid SSL certificate: %sN(R&RtdicttgetRt CERT_NONEt SSLContextt verify_modet CERT_REQUIREDt CERT_OPTIONALR2RRR)RRRRR*tmatch_hostnametCertificateError(RtpeercertRtcertRu((s/lib/python2.7/site-packages/tornado/iostream.pyRs"$ cC`s.|jr|jdStt|jdS(N(RR RRR(R((s/lib/python2.7/site-packages/tornado/iostream.pyR+s  cC`s.|jr|jdStt|jdS(N(RR RRR(R((s/lib/python2.7/site-packages/tornado/iostream.pyR1s  cC`s>||_tt|j|}|jd|j|S(NcS`s |jS(N(Rg(Rh((s/lib/python2.7/site-packages/tornado/iostream.pyRi?s(RRRRRptwait_for_handshake(RRRrRtfut((s/lib/python2.7/site-packages/tornado/iostream.pyR7s cC`stt|j|jr#dS|jj|j|j}d|_t |j|j d|j dt |_|j |dS(NRR(RRRRR>RRR\RRRRR*R(Rt old_state((s/lib/python2.7/site-packages/tornado/iostream.pyRBs      cC`s|jdk s|jdk r-tdn|dk rdtjdttj||_d}nt }|_|j s|j n|S(sWait for the initial SSL handshake to complete. If a ``callback`` is given, it will be called with no arguments once the handshake is complete; otherwise this method returns a `.Future` which will resolve to the stream itself after the handshake is complete. Once the handshake is complete, information such as the peer's certificate and NPN/ALPN selections may be accessed on ``self.socket``. This method is intended for use on server-side streams or after using `IOStream.start_tls`; it should not be used with `IOStream.connect` (which already waits for the handshake to complete). It may only be called once per stream. .. versionadded:: 4.2 .. deprecated:: 5.1 The ``callback`` argument is deprecated and will be removed in Tornado 6.0. Use the returned `.Future` instead. sAlready waitings<callback argument is deprecated, use returned Future insteadN( RRRZt RuntimeErrorR{R|R}R R~RRR(RRrRt((s/lib/python2.7/site-packages/tornado/iostream.pyRYs     cC`sYzNy|jj|SWn3tjk rL}|jdtjkrFdSnXWd~XdS(Ni(RRRRRR(RR,Ru((s/lib/python2.7/site-packages/tornado/iostream.pyRbs cC`sz|jrdSy|jj|SWnbtjk rY}|jdtjkrSdSn0tjk r}|jdt krdSnXWdd}XdS(Ni( RRRRRRRRRCR(RRcRu((s/lib/python2.7/site-packages/tornado/iostream.pyRds  cC`sBt|tjr,|jdtjkr,tStt|j|S(Ni( R&RRRRR)RRR(RRu((s/lib/python2.7/site-packages/tornado/iostream.pyRs(N(RRRRRRR RRRRRRRRRbRdR(((s/lib/python2.7/site-packages/tornado/iostream.pyRs     .     '  t PipeIOStreamcB`s;eZdZdZdZdZdZdZRS(sPipe-based `IOStream` implementation. The constructor takes an integer file descriptor (such as one returned by `os.pipe`) rather than an open file object. Pipes are generally one-way, so a `PipeIOStream` can be used for reading or writing but not both. cO`sH||_tj|jd|_t|tt|j||dS(Nsr+(RtiotFileIOt_fioR RRR(RRRR((s/lib/python2.7/site-packages/tornado/iostream.pyRs  cC`s|jS(N(R(R((s/lib/python2.7/site-packages/tornado/iostream.pyR`scC`s|jjdS(N(RRo(R((s/lib/python2.7/site-packages/tornado/iostream.pyRascC`s"ztj|j|SWd~XdS(N(RRR(RR,((s/lib/python2.7/site-packages/tornado/iostream.pyRbscC`snz`y|jj|SWnEttfk r^}t|tjkrX|jd|dSnXWdd}XdS(NRf( RtreadintoRRR RRRoR(RRcRu((s/lib/python2.7/site-packages/tornado/iostream.pyRds (RRRRR`RaRbRd(((s/lib/python2.7/site-packages/tornado/iostream.pyRs     cC`sddl}|jS(Ni(tdoctestt DocTestSuite(R ((s/lib/python2.7/site-packages/tornado/iostream.pytdoctestss (ARt __future__RRRRRRRyRRRRkR{ttornado.concurrentRttornadoRt tornado.logRRttornado.netutilRRR R t tornado.utilR ttornado.platform.posixR t ImportErrorRRt EWOULDBLOCKtEAGAINRthasattrR t ECONNRESETt ECONNABORTEDtEPIPEt ETIMEDOUTRRtWSAECONNABORTEDt WSAETIMEDOUTtplatformt EPROTOTYPEt EINPROGRESSRRt startswithRRRRRRtobjectRR;RRRR"(((s/lib/python2.7/site-packages/tornado/iostream.pytsf                Z+