Current File : //lib64/python2.7/site-packages/tornado/iostream.pyc
�
��L]c @� s� d Z d d l m Z m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l
Z
d d l Z d d l Z d d l
m Z d d l m Z d d l m Z m Z d d l m Z m Z m Z m Z m Z d d l m Z d d l m Z y d d
l m Z Wn e k
r'e Z n Xy d d l! Z! Wn e k
rQe Z! n Xe j" e j# f Z$ e% e d � r�e$ e j& f 7Z$ n e j' e j( e j) e j* f Z+ e% e d � r�e+ e j, e j- e j. f 7Z+ n e j/ d
k r�e+ e j0 f 7Z+ n e j1 f Z2 e% e d � r"e2 e j3 f 7Z2 n d e4 f d � � YZ5 d e6 f d � � YZ7 d e6 f d � � YZ8 d e9 f d � � YZ: d e: f d � � YZ; d e; f d � � YZ< d e: f d � � YZ= d � Z> d � Z? d � Z@ d S( sB Utility 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 ( t absolute_importt divisiont print_functiont with_statementN( t TracebackFuture( t ioloop( t gen_logt app_log( t ssl_wrap_sockett ssl_match_hostnamet SSLCertificateErrort _client_ssl_defaultst _server_ssl_defaults( t
stack_context( t errno_from_exception( t _set_nonblockingt WSAEWOULDBLOCKt
WSAECONNRESETt darwint WSAEINPROGRESSt StreamClosedErrorc B� s e Z d Z RS( s Exception 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.
( t __name__t
__module__t __doc__( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR U s t UnsatisfiableReadErrorc B� s e Z d Z RS( s� Exception raised when a read cannot be satisfied.
Raised by ``read_until`` and ``read_until_regex`` with a ``max_bytes``
argument.
( R R R ( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR _ s t StreamBufferFullErrorc B� s e Z d Z RS( sD Exception raised by `IOStream` methods when the buffer is full.
( R R R ( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR h s t BaseIOStreamc B� s e Z d Z d% d% d% d% d � Z d � Z d � Z d � Z d � Z d � Z d% d% d � Z
d% d% d � Z d% d% e d � Z
d% d% d
� Z d% d � Z d � Z e d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" 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`.
c C� s@ | p t j j � | _ | p! d | _ t | p3 d | j d � | _ | | _ d | _ t
j � | _ t
j � | _
d | _ d | _ t | _ d | _ d | _ d | _ d | _ t | _ t | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ t | _! d | _" d | _# t | _$ d S( s� `BaseIOStream` constructor.
:arg io_loop: The `.IOLoop` to use; defaults to `.IOLoop.current`.
Deprecated since Tornado 4.1.
: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.
i @i i i N(% R t IOLoopt currentt io_loopt max_buffer_sizet mint read_chunk_sizet max_write_buffer_sizet Nonet errort collectionst dequet _read_buffert
_write_buffert _read_buffer_sizet _write_buffer_sizet Falset _write_buffer_frozent _read_delimitert _read_regext _read_max_bytest _read_bytest
_read_partialt _read_until_closet _read_callbackt _read_futuret _streaming_callbackt _write_callbackt
_write_futuret _close_callbackt _connect_callbackt _connect_futuret _ssl_connect_futuret _connectingt _statet _pending_callbackst _closed( t selfR R R R! ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt __init__ s< c C� s
t � � d S( s, Returns the file descriptor for this stream.N( t NotImplementedError( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt fileno� s c C� s
t � � d S( s� Closes the file underlying this stream.
``close_fd`` is called by `BaseIOStream` and should not be called
elsewhere; other users should call `close` instead.
N( RA ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt close_fd� s c C� s
t � � d S( si Attempts to write ``data`` to the underlying file.
Returns the number of bytes written.
N( RA ( R? t data( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt write_to_fd� s c C� s
t � � d S( s- Attempts to read from the underlying file.
Returns ``None`` if there was nothing to read (the socket
returned `~errno.EWOULDBLOCK` or equivalent), otherwise
returns the data. When possible, should return no more than
``self.read_chunk_size`` bytes at a time.
N( RA ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt read_from_fd� s c C� s d S( 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? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt get_fd_error� s c C� s� | j | � } t j | � | _ | | _ y | j � Wn] t k
ro } t j d | � | j d t
� | S| d k r� | j d � � n � n X| 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.
s* Unsatisfiable read, closing connection: %st exc_infoc S� s
| j � S( N( t exception( t f( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt <lambda>� s N(
t _set_read_callbackt ret compileR- R. t _try_inline_readR R t infot closet TrueR" t add_done_callback( R? t regext callbackt max_bytest futuret e( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt read_until_regex� s c C� s� | j | � } | | _ | | _ y | j � Wn] t k
rf } t j d | � | j d t � | S| d k r� | j
d � � n � n X| S( si 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.
s* Unsatisfiable read, closing connection: %sRH c S� s
| j � S( N( RI ( RJ ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRK s N( RL R, R. RO R R RP RQ RR R" RS ( R? t delimiterRU RV RW RX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt
read_until� s c C� s� | j | � } t | t j � s' t � | | _ | | _ t j | � | _ y | j
� Wn) | d k r~ | j d � � n � n X| S( s� Asynchronously 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.
c S� s
| j � S( N( RI ( RJ ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRK 7 s N(
RL t
isinstancet numberst Integralt AssertionErrorR/ R0 R
t wrapR4 RO R" RS ( R? t num_bytesRU t streaming_callbackt partialRW ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt
read_bytes s c C� s� | j | � } t j | � | _ | j � ri | j d k rR | j | j t � n | j | j t � | St | _
y | j � Wn | j d � � � n X| S( s{ Asynchronously 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.
c S� s
| j � S( N( RI ( RJ ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRK Z s N(
RL R
R` R4 t closedR" t _run_read_callbackR( RR R* R1 RO RS ( R? RU Rb RW ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt read_until_close; s c C� sE t | t � s t � | j � | r� | j d k r_ | j t | � | j k r_ t d � � n d } x; t d t | � | � D]! } | j
j | | | | !� q~ W| j t | � 7_ n | d k r� t j
| � | _ d } n t � } | _ | j d � � | j sA| j � | j
r4| j | j j � n | j � n | S( s� Asynchronously 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. If `write` is called again before that `.Future` has
resolved, the previous future will be orphaned and will never resolve.
.. versionchanged:: 4.0
Now returns a `.Future` if no callback is given.
s! Reached maximum write buffer sizei� i i c S� s
| j � S( N( RI ( RJ ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRK � s Ni ( R\ t bytesR_ t
_check_closedR! R" R) t lenR t rangeR' t appendR
R` R5 R R6 RS R; t
_handle_writet
_add_io_stateR t WRITEt _maybe_add_error_listener( R? RD RU t WRITE_BUFFER_CHUNK_SIZEt iRW ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt write^ s*
c C� s t j | � | _ | j � d S( s� Call the given callback when the stream is closed.
This is not necessary for applications that use the `.Future`
interface; all outstanding ``Futures`` will resolve with a
`StreamClosedError` when the stream is closed.
N( R
R` R7 Rp ( R? RU ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt set_close_callback� s c C� s� | j � s� | rO t | t � s0 t j � } n t | � rO | d | _ qO n | j r� | j d k r� | j
r� | j | j
t � n t
| _ | j | j
t
� n | j d k r� | j j | j � � d | _ n | j � t | _ n | j � d S( s� Close 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`).
i N( Re R\ t tuplet sysRH t anyR# R1 R4 R" R( Rf RR R* R< R t remove_handlerRB RC R> t _maybe_run_close_callback( R? RH ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRQ � s$
c C� sm | j � ri| j d k rig } | j d k rL | j | j � d | _ n | j d k rw | j | j � d | _ n | j d k r� | j | j � d | _ n | j d k r� | j | j � d | _ n xL | D]D } | j | j � r� | j
t � � q� | j
| j pt � � q� W| j d k rM| j } d | _ | j
| � n d | _ | _ d | _ n d S( Ni ( Re R= R3 R" Rl R6 R9 R: t
_is_connresetR# t
set_exceptionR R7 t
_run_callbackR2 R5 R' ( R? t futuresRW t cb( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRy � s0
c C� s | j d k p | j d k S( s9 Returns true if we are currently reading from the stream.N( R2 R" R3 ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt reading� s c C� s
t | j � S( s7 Returns true if we are currently writing to the stream.( t boolR' ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt writing� s c C� s | j S( s+ Returns true if the stream has been closed.( R> ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRe � s c C� s d S( s� Sets 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( ( R? t value( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt set_nodelay� s
c C� s | j � r t j d | � d Sy�| j r9 | j � n | j � rI d S| | j j @rf | j � n | j � rv d S| | j j @r� | j � n | j � r� d S| | j j
@r� | j � | _ | j j
| j � d S| j j
} | j � r| | j j O} n | j � r#| | j j O} n | | j j
k rW| j d k rW| | j j O} n | | j k r�| j d k s�t d � � | | _ | j j | j � | j � n Wnj t k
r�} t j d | � | j d t � n7 t k
rt j d d t �| j d t � � n Xd S( Ns Got events for closed stream %si s4 shouldn't happen: _handle_events without self._states* Unsatisfiable read, closing connection: %sRH s' Uncaught exception, closing connection.( Re R t warningR; t _handle_connectR t READt _handle_readRo Rm t ERRORRG R# t add_callbackRQ R R� R( R< R" R_ t update_handlerRB R RP RR t Exception( R? t fdt eventst stateRX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt _handle_events� sP
! #
c � sK � � � f d � } t j � �$ � j d 7_ � j j | � Wd QXd S( Nc � sm � j d 8_ zL y � � � SWn7 t k
rY t j d d t �� j d t � � n XWd � j � Xd S( Ni s' Uncaught exception, closing connection.RH ( R= R� R R# RR RQ Rp ( ( t argsRU R? ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt wrapper# s
i ( R
t NullContextR= R R� ( R? RU R� R� ( ( R� RU R? s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR| " s
c C� s z| j d k r | j } n6 | j d k r9 | j } n | j � rN d } n d } d } | j d 7_ x� | j � s� | j � d k r� Pn | j � | d k r� | j | k r� Pn | j | k rl | j � } | d k r� | S| j d } ql ql W| j � SWd | j d 8_ Xd S( Ni i i (
R/ R" R. R R= Re t _read_to_buffert _run_streaming_callbackR( t _find_read_pos( R? t target_bytest
next_find_post pos( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt _read_to_buffer_loopE s0
c C� s� y | j � } WnH t k
r& � n5 t k
rZ t j d d t �| j d t � d SX| d k rx | j | � d S| j � d S( Ns
error on readRH (
R� R R� R R� RR RQ R" t _read_from_bufferRy ( R? R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s
c C� sj | j d k s t d � � | j d k s6 t d � � | d k rW t j | � | _ n t � | _ | j S( Ns Already reading( R2 R" R_ R3 R
R` R ( R? RU ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRL � s c C� s� | r | j } ne | j } d | _ | _ | j d k rw | d k sL t � | j } d | _ | j | j | � � n | d k r� | j d k s� | s� t � | j | | j | � � n
| j � d S( N( R4 R2 R" R3 R_ t
set_resultt _consumeR| Rp ( R? t sizet streamingRU RW ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRf � s c C� s� | j � | j � } | d k r3 | j | � d S| j � y | j � } Wn t k
rm | j � � n X| d k r� | j | � d S| j � r� | j � n | j t
j j � d S( s Attempt 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(
R� R� R" R� Ri R� R� Ry Re Rn R R R� ( R? R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRO � s"
c C� s� y | j � } WnU t j t t f k
rg } | j | � rQ | j d t � d S| j d t � � n X| d k rx d S| j j
| � | j t | � 7_ | j | j
k r� t j d � | j � t d � � n t | � S( s Reads 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.
RH Ni s Reached maximum read buffer size( RF t socketR# t IOErrort OSErrorRz RQ RR R" R& Rl R( Rj R R R ( R? t chunkRX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s"
c C� sk | j d k rg | j rg | j } | j d k rT t | j | � } | j | 8_ n | j | t � n d S( N( R4 R" R( R/ R Rf RR ( R? t bytes_to_consume( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s c C� s4 d | _ | _ | _ t | _ | j | t � d S( s� Attempts 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( R" R/ R, R- R* R0 Rf ( R? R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s c C� s� | j d k rR | j | j k s9 | j rR | j d k rR t | j | j � } | S| j d k r| j r�x� t r� | j d j | j � } | d k r� t | j � } | j
| j | | � | | St | j � d k r� Pn t | j � qm W| j
| j t | j d � � q�n� | j d k r�| j r�xx t r�| j j
| j d � } | d k r| j
| j | j � � | j � St | j � d k r�Pn t | j � q1W| j
| j t | j d � � q�n d S( s� Attempts 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.
i i����i N( R/ R" R( R0 R R, R& RR t findRj t _check_max_bytest _double_prefixR- t searcht end( R? Ra t loct
delimiter_lent m( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s@
c C� s> | j d k r: | | j k r: t d | | j f � � n d S( Ns& delimiter %r not found within %d bytes( R. R" R ( R? RZ R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� , s
c C� s{ x| j ry� | j s+ t | j d � n | j | j d � } | d k rZ t | _ Pn t | _ t | j | � | j j � | j | 8_ Wq t j t
t f k
r} | j d t
k r� t | _ Pq| j | � s� t j d | j � | � n | j d t � d Sq Xq W| j sw| j rI| j } d | _ | j | � n | j rw| j } d | _ | j d � qwn d S( Ni� i i s Write error on %s: %sRH i ( R' R+ t
_merge_prefixRE RR R* t popleftR) R� R# R� R� R� t _ERRNO_WOULDBLOCKRz R R� RB RQ R5 R" R| R6 R� ( R? Ra RX RU RW ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRm 3 s<
c C� s< | d k r d St | j | � | j | 8_ | j j � S( Ni t ( R� R& R( R� ( R? R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� d s
c C� s | j � r t d � � n d S( Ns Stream is closed( Re R ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRi k s c C� s� | j d k r d S| j d k s7 | j t j j k r� | j � rP | j � q� | j d k r� | j d k r� | j
t j j � q� n d S( Ni ( R= R< R" R R R� Re Ry R( R7 Rn R� ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRp o s $
c C� s� | j � r d S| j d k rj t j j | B| _ t j � �' | j j | j
� | j | j � Wd QXn< | j | @s� | j | B| _ | j j | j
� | j � n d S( sJ Adds `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(
Re R< R" R R R� R
R� R t add_handlerRB R� R� ( R? R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRn s
"
c C� s( t | t j t f � o' t | � t k S( sb Return true if exc is ECONNRESET or equivalent.
May be overridden in subclasses.
( R\ R� R# R� R t _ERRNO_CONNRESET( R? t exc( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRz � s N() R R R R" R@ RB RC RE RF RG RY R[ R* Rd Rg Rs Rt RQ Ry R R� Re R� R� R| R� R� RL Rf RO R� R� R� R� R� Rm R� Ri Rp Rn Rz ( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR m sN 5
" # ,
$ 5 # < !
0 1 !t IOStreamc B� st e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d d d � Z
d d d � Z d � Z d
� Z
RS( s* 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 <socket.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
def send_request():
stream.write(b"GET / HTTP/1.0\r\nHost: friendfeed.com\r\n\r\n")
stream.read_until(b"\r\n\r\n", on_headers)
def on_headers(data):
headers = {}
for line in data.split(b"\r\n"):
parts = line.split(b":")
if len(parts) == 2:
headers[parts[0].strip()] = parts[1].strip()
stream.read_bytes(int(headers[b"Content-Length"]), on_body)
def on_body(data):
print(data)
stream.close()
tornado.ioloop.IOLoop.current().stop()
if __name__ == '__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:
c O� s6 | | _ | j j t � t t | � j | | � d S( N( R� t setblockingR* t superR� R@ ( R? R� R� t kwargs( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR@ � s c C� s | j S( N( R� ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRB � s c C� s | j j � d | _ d S( N( R� RQ R" ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRC � s
c C� s4 | j j t j t j � } t j | t j | � � S( N( R� t
getsockoptt
SOL_SOCKETt SO_ERRORR# t ost strerror( R? t errno( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRG � s c C� sd y | j j | j � } Wn0 t j k
rK } | j d t k rE d S� n X| s` | j � d S| S( Ni ( R� t recvR R# R� R� R" RQ ( R? R� RX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRF � s
c C� s | j j | � S( N( R� t send( R? RD ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRE � s c C� s� t | _ | d k r0 t j | � | _ d } n t � } | _ y | j j | � Wny t j
k
r� } t | � t k r� t | � t
k r� | d k r� t j d | j j � | � n | j d t � | Sn X| j | j j � | S( s0 Connects 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 <socket.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
<BaseIOStream.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.
s Connect error on fd %s: %sRH N( RR R; R" R
R` R8 R R9 R� t connectR# R t _ERRNO_INPROGRESSR� R R� RB RQ Rn R Ro ( R? t addressRU t server_hostnameRW RX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s" ' c � sY | j sZ | j sZ | j sZ | j sZ | j sZ | j sZ | j sZ | j sZ | j sZ | j ri t
d � � n | d k r� | r� t } q� t
} n | j } | j j | � d | _ t | | d | d | d t �} | j � d | _ t � � t | d | d | j �� � � � f d � } � j | � � � f d � � _ | j � _ | j � _ � S(
s� Convert 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 SSLR� t server_sidet do_handshake_on_connectt ssl_optionsR c � sB � j � s( � j � j p! t � � n � d k r> � � n d S( N( t doneR{ R# R R" ( ( RW t orig_close_callbackt
ssl_stream( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt close_callback| s c � s
� j � � S( N( R� ( ( RW R� ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRK � s N( R2 R3 R5 R6 R8 R9 R= R> R& R' t
ValueErrorR" R R R� R Rx R R* R7 R t SSLIOStreamRt t _ssl_connect_callbackR R ( R? R� R� R� R� R� ( ( RW R� R� s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt start_tls; s8 #
c C� s� | j j t j t j � } | d k r� t j | t j | � � | _ | j d k rz t j
d | j j � t j
| � n | j � d S| j d k r� | j } d | _ | j | � n | j d k r� | j } d | _ | j | � n t | _ d S( Ni s Connect error on fd %s: %s( R� R� R� R� R# R� R� R9 R" R R� RB R� t errorcodeRQ R8 R| R� R* R; ( R? t errRU RW ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s"
c C� s� | j d k r� | j j t j t j f k r� y, | j j t j t j | rQ d n d � Wq� t j k
r� } | j t j
k r� | j | � r� � q� q� Xn d S( Ni i ( R� R" t familyt AF_INETt AF_INET6t
setsockoptt IPPROTO_TCPt TCP_NODELAYR# R� t EINVALRz ( R? R� RX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s "N( R R R R@ RB RC RG RF RE R" R� R� R� R� ( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s /
AL R� c B� s� e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d d d � Z d
� Z
d d � Z d � Z d
� Z d � Z RS( sn A 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.
c O� s� | j d t � | _ t t | � j | | � t | _ t | _ t | _
d | _ d | _
y | j j � Wn t j k
r� n X| j | j j � d S( s� The ``ssl_options`` keyword argument may either be an
`ssl.SSLContext` object or a dictionary of keywords arguments
for `ssl.wrap_socket`
R� N( t popR t _ssl_optionsR� R� R@ RR t _ssl_acceptingR* t _handshake_readingt _handshake_writingR" R� t _server_hostnameR� t getpeernameR# Rn R Ro ( R? R� R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR@ � s c C� s | j p t t | � j � S( N( R� R� R� R ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR � s c C� s | j p t t | � j � S( N( R� R� R� R� ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s c C� s� y# t | _ t | _ | j j � Wnjt j k
r%} | j d t j k r[ t | _ d S| j d t j
k r~ t | _ d S| j d t j t j f k r� | j
d t � S| j d t j k r y | j j � } Wn t k
r� d } n Xt j d | j j � | | � | j
d t � S� n� t j k
rr} | j | � s\| j d t j k rl| j
d t � S� nW t k
r�| j
d t � SXt | _ | j | j j � � s�| j
� d S| j � d S( Ni RH s (not connected)s SSL Error on %s %s: %s( R* R� R� R� t do_handshaket sslt SSLErrorR� t SSL_ERROR_WANT_READRR t SSL_ERROR_WANT_WRITEt
SSL_ERROR_EOFt SSL_ERROR_ZERO_RETURNRQ t
SSL_ERROR_SSLR� R� R R� RB R# Rz R� t EBADFt AttributeErrorR� t _verify_certt getpeercertt _run_ssl_connect_callback( R? R� t peer( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt _do_ssl_handshake� sD
%
c C� sf | j d k r1 | j } d | _ | j | � n | j d k rb | j } d | _ | j | � n d S( N( R� R" R| R: R� ( R? RU RW ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� s c C� s t | j t � r- | j j d t j � } n$ t | j t j � rQ | j j } n | t j t j t j f k su t
� | t j k s� | j d k r� t
S| j j � } | d k r� | t j k r� t j d � t Sy t | | j � Wn% t k
r
t j d d t
�t SXt
Sd S( s Returns 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_reqss No SSL certificate givens Invalid SSL certificateRH N( R\ R� t dictt getR� t CERT_NONEt
SSLContextt verify_modet
CERT_REQUIREDt
CERT_OPTIONALR_ R� R" RR R� R� R R� R* R R
( R? t peercertR� t cert( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� s" $
c C� s. | j r | j � d St t | � j � d S( N( R� R� R� R� R� ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� ' s
c C� s. | j r | j � d St t | � j � d S( N( R� R� R� R� Rm ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRm - s
c C� s5 | | _ t t | � j | d d � �| j | � S( NRU c S� s d S( N( R" ( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRK 7 s ( R� R� R� R� t wait_for_handshake( R? R� RU R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� 3 s c C� s� t t | � j � | j � r# d S| j j | j � | j } d | _ t | j | j
d | j d t �| _ | j
| � d S( NR� R� ( R� R� R� Re R Rx R� R< R" R R� R� R* Rn ( R? t old_state( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� : s c C� s~ | j d k s | j d k r- t d � � n | d k rT t j | � | _ d } n t � } | _ | j sz | j � n | S( s� Wait 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
s Already waitingN( R� R" R: t RuntimeErrorR
R` R R� R� ( R? RU RW ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� Q s
c C� sN y | j j | � SWn3 t j k
rI } | j d t j k rC d S� n Xd S( Ni ( R� R� R� R� R� R� ( R? RD RX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRE p s c C� s� | j r
d Sy | j j | j � } Wnb t j k
r[ } | j d t j k rU d S� n0 t j k
r� } | j d t
k r� d S� n X| s� | j � d S| S( Ni ( R� R" R� t readR R� R� R� R� R# R� RQ ( R? R� RX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRF ~ s
c C� sB t | t j � r, | j d t j k r, t St t | � j | � S( Ni ( R\ R� R� R� R� RR R� R� Rz ( R? RX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRz � s (N( R R R R@ R R� R� R� R� R� Rm R" R� R� R� RE RF Rz ( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s
-
t PipeIOStreamc B� s; e Z d Z d � Z d � Z d � Z d � Z d � Z RS( s 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.
c O� s0 | | _ t | � t t | � j | | � d S( N( R� R R� R� R@ ( R? R� R� R� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR@ � s
c C� s | j S( N( R� ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRB � s c C� s t j | j � d S( N( R� RQ R� ( R? ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRC � s c C� s t j | j | � S( N( R� Rs R� ( R? RD ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRE � s c C� s� y t j | j | j � } Wn[ t t f k
ry } t | � t k rJ d St | � t j
k rs | j d t � d S� n X| s� | j � d S| S( NRH (
R� R� R� R R� R� R R� R" R� R� RQ RR ( R? R� RX ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyRF � s
( R R R R@ RB RC RE RF ( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s c C� sF t t | d � d t | d � t | d � � } t | | � d S( s` Grow by doubling, but don't split the second chunk just because the
first one is small.
i i i N( t maxRj R� ( R% t new_len( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s !c C� s� t | � d k r, t | d � | k r, d Sg } | } xo | r� | d k r� | j � } t | � | k r� | j | | � | | } n | j | � | t | � 8} q; W| r� | j t | d � � j | � � n | s� | j d � n d S( s Replace the first entries in a deque of strings with a single
string of up to size bytes.
>>> d = collections.deque(['abc', 'de', 'fghi', 'j'])
>>> _merge_prefix(d, 5); print(d)
deque(['abcde', 'fghi', 'j'])
Strings will be split as necessary to reach the desired size.
>>> _merge_prefix(d, 7); print(d)
deque(['abcdefg', 'hi', 'j'])
>>> _merge_prefix(d, 3); print(d)
deque(['abc', 'defg', 'hi', 'j'])
>>> _merge_prefix(d, 100); print(d)
deque(['abcdefghij'])
i i NR� ( Rj R� t
appendleftRl t typet join( R% R� t prefixt remainingR� ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyR� � s (
&c C� s d d l } | j � S( Ni ( t doctestt DocTestSuite( R ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt doctests� s (A R t
__future__R R R R R$ R� R] R� R� Rv RM t tornado.concurrentR t tornadoR t tornado.logR R t tornado.netutilR R R
R R R
t tornado.utilR t tornado.platform.posixR t ImportErrorR" R� t EWOULDBLOCKt EAGAINR� t hasattrR t
ECONNRESETt ECONNABORTEDt EPIPEt ETIMEDOUTR� R t WSAECONNABORTEDt WSAETIMEDOUTt platformt
EPROTOTYPEt EINPROGRESSR� R R� R R� R R t objectR R� R� R� R� R� R ( ( ( s6 /usr/lib64/python2.7/site-packages/tornado/iostream.pyt <module> s` " (
� � � ?� �) &
Mini Shell