R?gSrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK J r J r SSKJr SSKJr SSKJrJrJr SSKJr SSKrSSKJrJrJrJrJrJrJrJ r J!r! SS K"J#r# \RH(a SS KJ%r%J&r&J'r' \ "S S S 9r(\RR\RT\RV\RX4r-\."\S5(a&\-\R^\R`\Rb4- r-\ RdS:Xa\-\Rf4- r-\ RdRiS5r5"SS\65r7"SS\85r9"SS\85r:"SS\;5r<"SS\;5r="SS \=5r>"SS\>5r?"SS\=5r@S \4S!jrAg)"aBUtility 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. N)Future"future_set_result_unless_cancelled)ioloop)gen_log)ssl_wrap_socket_client_ssl_defaults_server_ssl_defaults)errno_from_exception) UnionOptional AwaitableCallablePatternAnyDictTypeVarTuple) TracebackType)DequeListType _IOStreamTypeIOStream)bound WSAECONNRESETdarwinwincB^\rSrSrSrSS\\SS4U4SjjjrSrU=r $) StreamClosedErrorTaException 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. N real_errorreturnc0>[TU]S5 Xlg)NzStream is closed)super__init__r!)selfr! __class__s 2/usr/lib/python3/dist-packages/tornado/iostream.pyr%StreamClosedError.__init__bs +,$r!N) __name__ __module__ __qualname____firstlineno____doc__r BaseExceptionr%__static_attributes__ __classcell__r's@r(rrTs% %8M#:%d%%r*rc\rSrSrSrSrg)UnsatisfiableReadErrorgzException raised when a read cannot be satisfied. Raised by ``read_until`` and ``read_until_regex`` with a ``max_bytes`` argument. Nr-r.r/r0r1r3r9r*r(r7r7gs   r*r7c\rSrSrSrSrg)StreamBufferFullErrorqz?Exception raised by `IOStream` methods when the buffer is full.r9Nr:r9r*r(r<r<qsIr*r<cv\rSrSrSrSSjrS\4SjrSrS\ \ \ \ 4SS4S jr S \S\ 4S jrS \SS4S jrS rg) _StreamBufferuz\ A specialized buffer that tries to avoid copies when large pieces of data are encountered. r"NcT[R"5UlSUlSUlgNr) collectionsdeque_buffers _first_pos_sizer&s r(r%_StreamBuffer.__init__{s'      r*cUR$r,)rGrHs r(__len___StreamBuffer.__len__s zzr*idatac[U5nX R:a>[U[5(d [U5nURR SU45 OUS:ayUR(a3URSup4U=(d [U5UR:nOSnU(a'URR S[ U545 OWU- nU=RU- slg)zH Append the given piece of data (should be a buffer-compatible object). TrFN)len_large_buf_threshold isinstance memoryviewrEappend bytearrayrG)r&rMsize is_memviewbnew_bufs r(rT_StreamBuffer.appends4y ++ +dJ//!$' MM $ . AX}} $ b 1 $KA$2K2K(K $$eYt_%=>T  d r*rVcUS:deURSup#URnU(a[R "[X4XA-5$[U5XDU-$![a [S5s$f=f)zY Get a view over at most ``size`` bytes (possibly fewer) at the current buffer position. rr*)rE IndexErrorrSrFtypingcast)r&rVrWrXposs r(peek_StreamBuffer.peeksx axx # MM!,MJoo ;;z13:+>? ?a=Tz2 2 #c? " #sAA54A5cSUs=:aUR::de eU=RU-slURnURnU(aUS:aUSupE[U5U- U- nUS::a$UR 5 U[U5U- -nSnO4U(aX!- nSnO&X!- n[ R "[U5SU2 SnSnU(aUS:aMUS:XdeX lg)z8 Advance the current buffer position by ``size`` bytes. rN)rGrFrErPpopleftr]r^rU)r&rVr_buffersis_largerXb_remains r(advance_StreamBuffer.advances4%4::%%%%% d oo--$(!!*KH1v}s*H1}!A $  KK 1-dsd3$( qyyr*)rErFrGr"N)r-r.r/r0r1r%intrKrQr bytesrUrSrTr`rgr3r9r*r(r?r?use   5 :!=>4,333"CDr*r?c f\rSrSrSrS@S\\S\\S\\SS4SjjrS\\\ R44S jr SAS jr S \ S\4S jrS \\\ 4S\\4SjrS\\4SjrSBS\S\\S\\4SjjrSBS\S\\S\\4SjjrSCS\S\S\\4SjjrSCS \S\S\\4SjjrS\\4SjrS \\\ 4SS4SjrS\\/S4SS4SjrSCS\S\\\S\\\\ 44SS4S jjr!SAS!jr"S\4S"jr#S\4S#jr$S\4S$jr%S%\SS4S&jr&SAS'jr'S(\\\ R4S)\SS4S*jr(S\\4S+jr)SAS,jr*S\+4S-jr,S.\SS4S/jr-SAS0jr.S\\4S1jr/S2\SS4S3jr0S\\4S4jr1S\\\24S.\SS4S5jr3SAS6jr4S7\S\4S8jr5SAS9jr6SAS:jr7S;\SS4S<jr8S=\S\4S>jr9S?r:g)D BaseIOStreamaA 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. When the operation completes, the ``Awaitable`` will resolve with the data read (or ``None`` for ``write()``). All outstanding ``Awaitables`` will resolve with a `StreamClosedError` when the stream is closed; `.BaseIOStream.set_close_callback` can also be used to be notified of a closed stream. 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`. Nmax_buffer_sizeread_chunk_sizemax_write_buffer_sizer"c>[RR5UlU=(d SUl[ U=(d SURS-5UlX0lSUl[5Ul SUl SUl SUl [5UlSUlSUlSUlSUlSUlSUlSUlSUlSUl[2R4"5UlSUlSUlSUlSUlSUl SUl!g)a`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@iNrF)"rIOLoopcurrentio_looprominrprqerrorrU _read_buffer_read_buffer_size_user_read_buffer_after_user_read_bufferr? _write_buffer_total_write_index_total_write_done_index_read_delimiter _read_regex_read_max_bytes _read_bytes _read_partial_read_until_close _read_futurerCrD_write_futures_close_callback_connect_future_ssl_connect_future _connecting_state_closed)r&rorprqs r(r%BaseIOStream.__init__s,}},,. .;) #?#;eT=Q=QUV=VW%:" %K!"!&'+$*_"#'($##"!&       $# $(    r*c[5e)z,Returns the file descriptor for this stream.NotImplementedErrorrHs r(filenoBaseIOStream.filenos !##r*c[5e)zCloses the file underlying this stream. ``close_fd`` is called by `BaseIOStream` and should not be called elsewhere; other users should call `close` instead. rrHs r(close_fdBaseIOStream.close_fds "##r*rMc[5e)zYAttempts to write ``data`` to the underlying file. Returns the number of bytes written. rr&rMs r( write_to_fdBaseIOStream.write_to_fd&s "##r*bufc[5e)aAttempts 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. rr&rs r( read_from_fdBaseIOStream.read_from_fd-s "##r*cg)aReturns 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. Nr9rHs r( get_fd_errorBaseIOStream.get_fd_error<sr*regex max_bytesc2UR5n[R"U5UlX lUR 5 U$![ a4n[R"SU-5 URUS9 UsSnA$SnAf URS5 e=f)a,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 ``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. .. versionchanged:: 6.0 The ``callback`` argument was removed. Use the returned `.Future` instead. *Unsatisfiable read, closing connection: %sexc_infoNc"UR5$r, exceptionfs r(/BaseIOStream.read_until_regex..i q{{}r*) _start_readrecompilerr_try_inline_readr7rinfocloseadd_done_callback)r&rrfuturees r(read_until_regexBaseIOStream.read_until_regexFs,!!#::e,(   ! ! # &  LLEI J JJJ "M   $ $%< = sA B)A>8B>B delimitercUR5nXlX lUR5 U$![a4n[ R "SU-5 URUS9 UsSnA$SnAf URS5 e=f)aAsynchronously read until we have found the given delimiter. The result includes all the data read including the delimiter. 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. .. versionchanged:: 6.0 The ``callback`` argument was removed. Use the returned `.Future` instead. rrNc"UR5$r,rrs r(r)BaseIOStream.read_until..rr*) rrrrr7rrrr)r&rrrrs r( read_untilBaseIOStream.read_untilms(!!#((   ! ! # &  LLEI J JJJ "M   $ $%< = s0 B)A)#B)B num_bytespartialcUR5n[U[R5(deXlX lUR 5 U$! URS5 e=f)aAsynchronously read a number of bytes. If ``partial`` is true, data is returned 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. .. versionchanged:: 6.0 The ``callback`` and ``streaming_callback`` arguments have been removed. Use the returned `.Future` (and ``partial=True`` for ``streaming_callback``) instead. c"UR5$r,rrs r(r)BaseIOStream.read_bytes..rr*)rrRnumbersIntegralrrrr)r&rrrs r( read_bytesBaseIOStream.read_bytessh"!!#)W%5%56666$$   ! ! #    $ $%< = s AA&cUR5nURn[U5nXE:a<[UR5SUUSS&URSU2 URUlO!US:a[UR5SSUSU&SUlXlX@lXPlX lUR5 U$! URS5 e=f)aAsynchronously read a number of bytes. ``buf`` must be a writable buffer into which data will be read. 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 .. versionchanged:: 6.0 The ``callback`` argument was removed. Use the returned `.Future` instead. NrTc"UR5$r,rrs r(r(BaseIOStream.read_into..rr*) rrzrPrSryr|r{rrrr)r&rrravailable_bytesns r( read_intoBaseIOStream.read_intos"!!#00 H   1 122A6CF!!"1"%+/+<+` instead. .. versionchanged:: 4.0 The callback argument is now optional and a `.Future` will be returned if it is omitted. .. versionchanged:: 6.0 The ``callback`` and ``streaming_callback`` arguments have been removed. Use the returned `.Future` (and `read_bytes` with ``partial=True`` for ``streaming_callback``) instead. Tc"UR5$r,rrs r(r/BaseIOStream.read_until_close..rr*)rclosed _finish_readrzrrrr&rs r(read_until_closeBaseIOStream.read_until_closeso$!!# ;;==   d44 5M!%   ! ! #    $ $%< = s AA2z Future[None]cUR5 U(a[U[5(a[U5RS5nURb:[ UR 5[ U5-UR:a [S5eUR RU5 U=R[ U5- sl [5nURS5 URRURU45 UR(dVUR5 UR (a%URUR R"5 UR%5 U$)aAsynchronously write the given data to this stream. 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. .. versionchanged:: 6.0 The ``callback`` argument was removed. Use the returned `.Future` instead. Bz!Reached maximum write buffer sizec"UR5$r,rrs r(r$BaseIOStream.write..s 1;;=r*) _check_closedrRrSr^rqrPr}r<rTr~rrrr _handle_write _add_io_statervWRITE_maybe_add_error_listener)r&rMrs r(writeBaseIOStream.writes(  $ ++!$',,S1**6**+c$i7$:T:TT+,OPP    % %d +  # #s4y 0 #  !89 ""D$;$;V#DE    !!""4<<#5#56  * * , r*callbackc0XlUR5 g)aCall 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`` was not removed in Tornado 6.0. N)rr)r&rs r(set_close_callbackBaseIOStream.set_close_callback!s ( &&(r*rzOptional[Type[BaseException]]cUR5(Gd,U(ak[U[5(a USUlOK[U[5(aXlO/[ R "5n[U5(a USUlUR(a#SUlURUR5 O2URb%UR5nUbURU5 URb0UR R#UR%55 SUlUR'5 SUlUR+5 g![a Nqf=f)zClose 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`). FNT)rrRtuplerxr2sysranyrrrzr_find_read_pos_read_from_bufferr7rrvremove_handlerrrr_signal_closed)r&rr_s r(rBaseIOStream.close0s &{{}}h..!)!DJ-88!)J"||~H8}}%-a[ %%).&!!$"8"89"".4--/C..s3{{& ++DKKM:" MMODL .s E E! E!c/nURb"URUR5 SUlXRVVs/sHup#UPM snn- nURR5 URb"URUR5 SUlUHKnUR 5(d"UR [URS95 UR5 MM URbURR 5(dVURb&URR UR5 O#URR [55 URR5 SUl URb.URnSUl URRU5 SUlgs snnf![Ra GMSf=fNr+)rrTrclearrdone set_exceptionrrxrasyncioCancelledErrorrrrv add_callbackr})r&futures_rcbs r(rBaseIOStream._signal_closed`s    ( NN4,, - $D ,?,?@,?yqF,?@@ !!#    + NN4// 0#'D F;;==$$%6$**%MN   "  # # /++0022::),,::4::F,,::;L;NO  $ $ . . 0'+D $    +%%B#'D LL % %b )"AA))  sGGG43G4cURSL$)z=Returns ``True`` if we are currently reading from the stream.N)rrHs r(readingBaseIOStream.readings  ,,r*c,[UR5$)z;Returns ``True`` if we are currently writing to the stream.)boolr}rHs r(writingBaseIOStream.writingsD&&''r*cUR$)z/Returns ``True`` if the stream has been closed.)rrHs r(rBaseIOStream.closeds ||r*valuecg)aSets 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 Nr9)r&rs r( set_nodelayBaseIOStream.set_nodelays r*c[5er,rrHs r(_handle_connectBaseIOStream._handle_connects !##r*fdeventscUR5(a[R"SU5 gUR(aUR 5 UR5(agX R R -(aUR5 UR5(agX R R-(aUR5 UR5(agX R R-(a;UR5Ul UR RUR5 gUR RnUR5(aX0R R -nUR!5(aX0R R-nX0R R:Xa(UR"S:XaX0R R -nX0R$:waOUR$cS5eX0lUR R'UR)5UR$5 gg![*a2n[R,"SU-5 URUS9 SnAgSnAf[.a*n[R"SSS9 URUS9 eSnAff=f)NzGot events for closed stream %srz4shouldn't happen: _handle_events without self._staterrz'Uncaught exception, closing connection.T)rrwarningrr rvREAD _handle_readrrERRORrrxrrrrrzrupdate_handlerrr7r Exception)r&rrstaters r(_handle_eventsBaseIOStream._handle_eventss ;;== OO=r B /  $$&{{}} )))!!#{{}} ***""${{}} ***!..0  ))$**5LL&&E||~~***||~~+++ ***t/E/E/J *** #KK+JIJ+#  ++DKKM4;;G $ & # LLEI J JJJ "  MMCd S JJJ "  s?6I&AI)AI,AIDI K(J  K%J==KcURb URnO4URb URnOUR5(aSnOSnSnUR5(dUR 5S:XaUR 5$Ub!UR U:aUR 5$UR U:a$UR 5nUbU$UR S-nUR5(dMUR 5$)Nrrs)rrrr_read_to_bufferrzr)r& target_bytes next_find_posr_s r(_read_to_buffer_loop!BaseIOStream._read_to_buffer_loops    '++L  ! ! -//L \\^^ LL ++-- ##%*$""$$'D,B,Bl,R""$$ %%6))+?J $ 6 6 : 1++--2""$$r*c UR5nUbURU5 gg![a e[Ra e[a2n[ R "SU-5 URUS9 SnAgSnAff=f)Nzerror on read: %sr) rr7rrrrrrr)r&r_rs r(rBaseIOStream._handle_reads ++-C ?  " "3 ' &  %%    OO/!3 4 JJJ "  s((B(A==BcURb$UR5 URbS5e[5UlUR$)NzAlready reading)rrrrHs r(rBaseIOStream._start_readsJ    ("    $$, ?.? ?,"H   r*rVcXUR(aMUR=(d [5UlSUl[ UR5UlSUlUnOUR U5nURbURnSUl[X25 UR5 gNF) r{r|rUryrPrz_consumerrr)r&rVresultrs r(rBaseIOStream._finish_read(s  ! ! $ < < K D +/D (%():):%;D "%*D "F]]4(F    (&&F $D  .v > &&(r*c6UR5nUbURU5 gUR5 UR5nUbURU5 gUR 5(d*UR [ RR5 gg)zAttempt 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) rrrrrrrrtrr&r_s r(rBaseIOStream._try_inline_read7s!!# ?  " "3 '  '') ?  " "3 ' {{}}   v}}11 2r*cUR(a#[UR5URSnO[ UR 5nUR U5nUcAgUS:XaUR5 AgUR(d!U=R[U5SU- slU=RU- slAURUR:a1[R"S5 UR5 [S5eU$![R[[4a@nURU5(aURUS9 SnAAgURUS9 eSnAff=f!Af=f)zReads 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. Nrrz Reached maximum read buffer size)r{rSryrzrUrprsocketrxIOErrorOSError _is_connresetrrorr<)r&r bytes_readrs r(rBaseIOStream._read_to_bufferMs` --():):; 224((<(<=!%!2!23!7J!q  ))!!Z_[j%AA!  " "j 0 "  ! !D$8$8 8 MM< = JJL'(JK K7 gw7 ))!,, A .#JJJ* ,sHE5ADE5%E5>AE5E22%E-E5E--E22E55E8r_c^S=Ul=UlUlSUlUR U5 g)zAttempts 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. NF)rrrrrr+s r(rBaseIOStream._read_from_buffer{s4 FJII4/$2B" #r*cZURb]URUR:d!UR(a2URS:a"[URUR5nU$URbUR (aUR R UR5nUS:wa7[UR5nURURX#-5 X#-$URURUR5 gURbUR (a|URRUR 5nUb.UR5nURURU5 U$URURUR5 g)zAttempts 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. NrrO) rrzrrwrryfindrP_check_max_bytesrsearchend)r&rloc delimiter_lenms r(rBaseIOStream._find_read_possb    '  " "d&6&6 6""t'='='AD,,d.D.DEI   ! ! -  '',,T-A-AB"9$'(<(<$=M))$*>*>@ST..%%d&:&:D=%%'C))$*:*:C@J%%d&6&68N8NOr*cpURb)X R:a[SXR4-5egg)Nz&delimiter %r not found within %d bytes)rr7)r&rrVs r(r8BaseIOStream._check_max_bytessC    +7K7K0K(82234 1L +r*c[UR5nU(dOyUS:de[(aSnURURR U55nUS:XaO2URR U5 U=R U- slMUR"(a[UR"SupEX@R :agUR"R%5 ['US5 UR"(aMZgg![a Mz[R[[4aUnURU5(d&[R"SUR5U5 UR!US9 SnAgSnAff=f)NrizWrite error on %s: %sr)rPr}_WINDOWSrr`rgrBlockingIOErrorr.rxr/r0r1rrrrrrcr)r&rVrrindexrs r(rBaseIOStream._handle_writesEt))*D!8O8 8 &D ,,T-?-?-D-DT-JK >""**95,, 9,%<!! //2ME333    ' ' ) .vt < !!!# LL'73 ))!,,OO$;T[[]AN A & s$=D&0D FF0A FFr;cUS:XagXR::de[UR5SUR5nU=RU-slURSU2 U$)Nrr*)rzrSrytobytes)r&r;rXs r(r'BaseIOStream._consumesf !8,,,,, )) *4C 0 9 9 ; #%   dsd #r*cTUR5(a[URS9egr)rrrxrHs r(rBaseIOStream._check_closeds! ;;==#tzz: : r*c,URb(UR[RR:Xa_UR 5(dIUR S:Xa8UR b*UR[RR5 gggggrB) rrrtrrrzrrrrHs r(r&BaseIOStream._maybe_add_error_listenersu ;; $++1D1D"DKKMM**a/((4""6==#5#5650"#Er*rcUR5(agURcb[RRU-UlUR R UR5URUR5 gURU-(dIURU-UlUR RUR5UR5 gg)aAdds `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. 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. 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. TODO: reevaluate this now that callbacks are gone. N) rrrrtrrv add_handlerrrr)r&rs r(rBaseIOStream._add_io_states& ;;==  ;;  ----5DK LL $ $T[[]D4G4G Uu$++-DK LL ' ' t{{ C%r*excct[U[R[45=(a [ U5[ ;$)zVReturn ``True`` if exc is ECONNRESET or equivalent. May be overridden in subclasses. )rRr.rxr/r _ERRNO_CONNRESET)r&rPs r(r1BaseIOStream._is_connresets/ sV\\73 4 >$S)-== r*)r|rrrrryrzrrrrrrrrrrr~r{r}rrxrvrorqrp)NNNrir,)F);r-r.r/r0r1r rjr%r r _SelectablerrrSrrUrrrrkr rrrrrrrrrr2rrrrrrrr r rrrrrrrrrrrr8rr'rrrr1r3r9r*r(rmrms3&*.)-/3 7!#7"#7 (} 7  7r$c6#5#556$$$ $s$ $i&; < $# $hy18<%%'/}% 5 %P<@!!+3C=! 5 !FC$9UCS8+Y++)C.+Z)E"2<(%z 12(~(T )8HRX4F+G )D )4 .    /'')    . .`%"N--((    $  $3sF,>,>'>!?33QU3j'%hsm'%R (!V!. ) ) )3,,#,\ST% %N%w*?st$=L C E ; 7D3D4D:  4 r*rmc p^\rSrSrSrS\R S\S\SS4U4SjjrS\\ \ R44S jr SS jr S\\4S jrS \\\4S\\ 4S jrS\S\ 4SjrSS\S\S\\SS4SjjrSS\S\\\\\4\R64S\\S\S4SjjrSSjrS\SS4SjrSr U=r!$) ria!Socket-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 socket import tornado 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__': asyncio.run(main()) .. testoutput:: :hide: r.argskwargsr"Nch>XlURRS5 [TU] "U0UD6 gr&)r. setblockingr$r%)r&r.rVrWr's r(r%IOStream.__init__Js,  & $)&)r*cUR$r,)r.rHs r(rIOStream.filenoOs {{r*cFURR5 SUlgr,)r.rrHs r(rIOStream.close_fdRs  r*cURR[R[R5n[R"U[ R "U55$r,)r. getsockopt SOL_SOCKETSO_ERRORrxosstrerror)r&errnos r(rIOStream.get_fd_errorVs< &&v'8'8&//J||E2;;u#566r*rc~URRU[U55A$![a Agf=f!Af=fr,)r. recv_intorPrCrs r(rIOStream.read_from_fdZsA ;;((c#h7  s$( 6969<rMcHURRU5A$!Af=fr,)r.sendrs r(rIOStream.write_to_fdbs" ;;##D)s!r&addressserver_hostnamezFuture[_IOStreamType]cSUl[5n[R"SU5UlUR R U5 URURR5 U$![a N3[ RaNnUc0[R"SUR R5U5 URUS9 UsSnA$SnAff=f)aConnects 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. .. versionchanged:: 6.0 The ``callback`` argument was removed. Use the returned `.Future` instead. TzFuture[IOStream]NConnect error on fd %s: %sr)rrr]r^rr.connectrCrxrrrrrrvr)r&rmrnrrs r(rqIOStream.connectjs^ %{{+=vF  KK   ( 4<<--.   ||  ~ P>P>RTUV JJJ "M s$A11 C=CACCC server_side ssl_options SSLIOStreamcJUR(dUUR(dDUR(d3UR(d"UR(dUR (a [ S5eUcU(a[nO[nURnURRU5 SUl [UUUUSS9nURnSUl [5n[XBS9nUR!U5 XglUR$UlUR&UlU$)aConvert 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.SSLContext.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. z+IOStream is not idle; cannot convert to SSLNF)rnrsdo_handshake_on_connect)rt)rrrrryr} ValueErrorr rr.rvrrrrrurrrorp)r&rsrtrnr.orig_close_callbackr ssl_streams r( start_tlsIOStream.start_tlssR   ""##||  !!JK K  2 2  ##F+   +#$)  #22# A %%&9:)/&%)%9%9 "%)%9%9 " r*cURR[R[R5nWS:wa[R"U[R"U55UlURcA[R"SURR5[ RU5 UR5 gURbURnSUl [!X05 SUlg![Ra*n[ U5[ R:XaSnSnAGNSnAff=f)NrrpF)r.r`rarbrxr re ENOPROTOOPTrcrdrrrr errorcoderrr)r&errrrs r(r IOStream._handle_connects ++(():):FOOLC !8c2;;s+; (   &&&&(:(:AA ( "<< 77ell*43E3Ea3H3H4I*  sAB C$ 5CC$)rrrrxr.rir,)NN)"r-r.r/r0r1r.rr%r rjrrTrrr rrrUrSrrrstrrqrrssl SSLContextr r{r r r3r4r5s@r(rrsF(T*v}}*S*C*D* c6#5#5567hy17i&; <# sMQBB&)BURS[5Ul[TU]"U0UD6 SUlSUlSUlSUlURR5 URURR5 g![Ra gf=f)zThe ``ssl_options`` keyword argument may either be an `ssl.SSLContext` object or a dictionary of keywords arguments for `ssl.SSLContext.wrap_socket` rtTFN)popr _ssl_optionsr$r%_ssl_accepting_handshake_reading_handshake_writing_server_hostnamer. getpeernamerrvrrx)r&rVrWr's r(r%SSLIOStream.__init__5s #JJ}6JK $)&)""'"' $ 3 KK # # %   t||11 2 ||   s B B! B!cF>UR=(d [TU] 5$r,)rr$rr&r's r(rSSLIOStream.readingL&&;%'/*;;r*cF>UR=(d [TU] 5$r,)rr$rrs r(rSSLIOStream.writingOrr*cSUlSUlURR5 SUl[ R (deUR5 g![ RGaHnURS[ R:Xa SUlSnAgURS[ R:Xa SUlSnAgURS[ R[ R4;aURUS9sSnA$URS[ R[ R 4;arURR#5nO![$a SnOf=f[&R("SURR+5X!5 URUS9sSnA$eSnAf[ R,anURUS9sSnA$SnAf[R.abnUR1U5(d2URSS[2R4[2R64;aURUS9sSnA$eSnAf[8anURUS9sSnA$SnAff=f)NFrTrz(not connected)zSSL Error on %s %s: %s)rrr. do_handshakerrHAS_SNI_finish_ssl_connectSSLErrorrVSSL_ERROR_WANT_READSSL_ERROR_WANT_WRITE SSL_ERROR_EOFSSL_ERROR_ZERO_RETURNr SSL_ERROR_SSLSSL_ERROR_SYSCALLrrrrrCertificateErrorrxr1reEBADFENOTCONNAttributeError)r&rpeers r(_do_ssl_handshakeSSLIOStream._do_ssl_handshakeRs5 '&+D #&+D # KK $ $ &\#(D ;; ;  $ $ &c|| xx{c555*.'! 8 88*.'!!2!2C4M4M NNzz3z//!!2!2C4I4I JJ-;;224D -,D-,dkk.@.@.BDzz3z// ## , ::s:+ +|| !!#&&#((1+ :+ zz3z//  ,::s:+ +  ,s(AI6.(F1(F1?F1I6 1F1?EF1 E)&F1(E))AF1*I60F11I6GI6I63AI I6I I6I1+I61I6c\URbURnSUl[X5 ggr,)rrrs r(rSSLIOStream._finish_ssl_connects.  # # /--F'+D $ .v < 0r*cf>UR(aUR5 g[TU] 5 gr,)rrr$rrs r(rSSLIOStream._handle_reads&     " " $  r*cf>UR(aUR5 g[TU] 5 gr,)rrr$rrs r(rSSLIOStream._handle_writes&     " " $  r*rmrnFuture[SSLIOStream]cr>X l[TU] U5nURS5 UR 5$)Nc"UR5$r,rrs r(r%SSLIOStream.connect..s  r*)rr$rqrwait_for_handshake)r&rmrnfutr's r(rqSSLIOStream.connects9!0gog& 56&&((r*cJ>[TU]5 UR5(agURR UR 5 UR nUceSUl[UR URURSSS9UlURU5 g)NF)rnrwrs) r$r rrvrr.rrrrr)r& old_stater's r(r SSLIOStream._handle_connects ! ;;==  ##DKK0KK $$$ % KK    11$)    9%r*cURb [S5e[5=olUR(dUR 5 U$)aWait 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 .. versionchanged:: 6.0 The ``callback`` argument was removed. Use the returned `.Future` instead. zAlready waiting)r RuntimeErrorrrrrs r(rSSLIOStream.wait_for_handshakesC2  # # /01 1,2H4)""  $ $ & r*rMc[U5S- (a[U5SSnURRU5A$![R a-nUR S[R:XaSnAAgeSnAff=f!Af=fNi@r)rPrSr.rkrrrVr)r&rMrs r(rSSLIOStream.write_to_fds} t9?d#Ig.D ;;##D)|| vvayC444   s-?B!A;4B:A;;BBBrchUR(aAg[U5S- (a[U5SSnURR U[U55A$![ R a-nURS[ R:XaSnAAgeSnAf[a Agf=f!Af=fr) rrPrSr.rhrrrVrrCr&rrs r(rSSLIOStream.read_from_fds ""$3x2~ oi0 {{,,S#c(;<< 66!9 7 77  "  sEB.!B.$AB+2!BB.B B+'B.*B++B..B1rc>[U[R5(a"URS[R:Xag[ TU]U5$)NrT)rRrrrVrr$r1)r&rr's r(r1SSLIOStream._is_connresets< a & &166!98I8I+Iw$Q''r*)rrrrrrrr.rir,)r"r)r-r.r/r0r1r.rr%rrrrrrrrr rrqr rrSrjrr rUrr2r1r3r4r5s@r(ruru's F3c3S3T3.<<<<7'r=   @D))/7}) ))&&8@ s.i&; <#4(}(((r*ruc^\rSrSrSrS\S\S\SS4U4SjjrS\4S jrSS jr S \ S\4S jr S \ \ \ 4S\\4SjrSrU=r$) PipeIOStreami#a=Pipe-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. ``PipeIOStream`` is only available on Unix-based platforms. rrVrWr"Nc>Xl[R"URS5Ul[R S:Xa [ S5e[R"US5 [TU]("U0UD6 g)Nzr+win32z(PipeIOStream is not supported on WindowsF) rioFileIO_fiorplatformAssertionErrorrc set_blockingr$r%)r&rrVrWr's r(r%PipeIOStream.__init__.sXIIdggt, <<7 " !!KL L E" $)&)r*cUR$r,)rrHs r(rPipeIOStream.fileno;s wwr*c8URR5 gr,)rrrHs r(rPipeIOStream.close_fd>s r*rMcT[R"URU5A$!Af=fr,)rcrrrs r(rPipeIOStream.write_to_fdAs" 88DGGT*s $'rcURRU5A$![[4a8n[ U5[ R :XaURUS9 SnAAgeSnAff=f!Af=f)Nr)rreadintor/r0r rerrrs r(rPipeIOStream.read_from_fdIsi 99%%c*! #A&%++5 A & s,A&,A!A) A!!A&&A))A,)rrri)r-r.r/r0r1rjrr%rrrSrr rUr rr3r4r5s@r(rr#ss *3 *s *c *d * s i&; < #  r*rr"c*SSKnUR5$rB)doctest DocTestSuite)rs r(doctestsrXs    !!r*)Br1rrCrerrrcr.rrrtornado.concurrentrrtornador tornado.logrtornado.netutilrrr tornado.utilr r]r r r rrrrrrtypesr TYPE_CHECKINGrrrr ECONNRESET ECONNABORTEDEPIPE ETIMEDOUTrRhasattrrWSAECONNABORTED WSAETIMEDOUTr EPROTOTYPE startswithrBr/rrr7r<objectr?rmrrurrr9r*r(rs~   IWW-      ((z: $$e&8&8%++uW 5/""    <<8 ))++ << " "5 )%%& Y JIJWFWtM  6M  `E|EPy((y(x2<2j"#"r*