Your IP : 216.73.216.213
B
;��]�E � @ sV d Z ddlmZmZmZ ddlZyddlmZ W n e k
rD Y nX ddl
m Z m Z ddl
mZmZ ddlmZmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ G d
d� d�Z e ej �G dd� de ��Z e ej ej!�G dd� d��Z"dd� Z#dd� Z$G dd� d�Z%d%dd �Z&e#e$ddfd d �Z'd d � Z(G d!d"� d"e �Z)d&d#d$�Z*dS )'z0
Utilities and helpers for simulating a network
� )�absolute_import�division�print_functionN)�Error)� implementer�directlyProvides)�TCP4ClientEndpoint�TCP4ServerEndpoint)�Factory�Protocol)�ConnectionRefusedError)�Failure)�error)�
interfaces)�MemoryReactorClockc @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�TLSNegotiationc C s || _ || _d| _|| _d S )NF)�obj� connectState�sent� readyToSend)�selfr r � r �E/opt/alt/python37/lib64/python3.7/site-packages/twisted/test/iosim.py�__init__ s zTLSNegotiation.__init__c C s d| j f S )NzTLSNegotiation(%r))r )r r r r �__repr__& s zTLSNegotiation.__repr__c C s" | j �|j �s t� |_|�� d S )N)r Z iosimVerify�NativeOpenSSLError�disconnectReason�loseConnection)r �otherZtptr r r �pretendToVerify* s z TLSNegotiation.pretendToVerifyN)�__name__�
__module__� __qualname__r r r r r r r r s r c @ s e Zd ZdZdS )� FakeAddressz]
The default address type for the host and peer of L{FakeTransport}
connections.
N)r r! r" �__doc__r r r r r# 4 s r# c @ s� e Zd ZdZee�� fdd��ZdZdZ dZ
e � d�Z
dZdZdZd0dd�Zd d
� Zd d � Zd
d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Z d d � Z d!d"� Z d#d$� Z d%d&� Z d'd(� Z!d1d*d+�Z"d,d-� Z#d.d/� Z$dS )2�
FakeTransportz�
A wrapper around a file-like object to make it behave as a Transport.
This doesn't actually stream the file to the attached protocol,
and is thus useful mainly as a utility for debugging protocols.
c C s t | �S )N)�next)�counterr r r �<lambda>G � zFakeTransport.<lambda>r zConnection doneNc C sH || _ || _g | _| �� | _|dkr*t� }|| _|dkr>t� }|| _dS )a�
@param protocol: This transport will deliver bytes to this protocol.
@type protocol: L{IProtocol} provider
@param isServer: C{True} if this is the accepting side of the
connection, C{False} if it is the connecting side.
@type isServer: L{bool}
@param hostAddress: The value to return from C{getHost}. L{None}
results in a new L{FakeAddress} being created to use as the value.
@type hostAddress: L{IAddress} provider or L{None}
@param peerAddress: The value to return from C{getPeer}. L{None}
results in a new L{FakeAddress} being created to use as the value.
@type peerAddress: L{IAddress} provider or L{None}
N)�protocol�isServer�stream� _nextserial�serialr# � hostAddress� peerAddress)r r* r+ r/ r0 r r r r P s
zFakeTransport.__init__c C s d| j r dpd| j| jjjf S )NzFakeTransport<%s,%s,%s>�S�C)r+ r. r* � __class__r )r r r r r m s zFakeTransport.__repr__c C s2 | j r
d S | jd k r"| j�|� n | j�|� d S )N)�
disconnecting�tls�tlsbuf�appendr, )r �datar r r �writes s
zFakeTransport.writec C s | j r| js| j �� d S )N)�producer�streamingProducer�resumeProducing)r r r r �_checkProducer~ s z FakeTransport._checkProducerc C s || _ || _|s|�� dS )z.
From abstract.FileDescriptor
N)r: r; r< )r r: Z streamingr r r �registerProducer� s z FakeTransport.registerProducerc C s
d | _ d S )N)r: )r r r r �unregisterProducer� s z FakeTransport.unregisterProducerc C s | � � | �� d S )N)r? r )r r r r �
stopConsuming� s zFakeTransport.stopConsumingc C s | � d�|�� d S )Nr) )r9 �join)r Ziovecr r r �
writeSequence� s zFakeTransport.writeSequencec C s
d| _ d S )NT)r4 )r r r r r � s z FakeTransport.loseConnectionc C s
d| _ dS )zp
For the time being, this is the same as loseConnection; no buffered
data will be lost.
TN)r4 )r r r r �abortConnection� s z FakeTransport.abortConnectionc C s, | j d k rt� }n| j}| j�t|�� d S )N)r5 r r r* ZconnectionLostr
)r �errr r r �reportDisconnect� s
z FakeTransport.reportDisconnectc C s dS )zM
Identify this transport/event source to the logging system.
Ziosimr )r r r r � logPrefix� s zFakeTransport.logPrefixc C s | j S )N)r0 )r r r r �getPeer� s zFakeTransport.getPeerc C s | j S )N)r/ )r r r r �getHost� s zFakeTransport.getHostc C s d S )Nr )r r r r r< � s z FakeTransport.resumeProducingc C s d S )Nr )r r r r �pauseProducing� s z FakeTransport.pauseProducingc C s | � � d S )N)r )r r r r �
stopProducing� s zFakeTransport.stopProducingTc C s | j |A }t||�| _g | _d S )N)r+ r r5 r6 )r ZcontextFactoryZbeNormalr r r r �startTLS� s
zFakeTransport.startTLSc C sH | j }|rg | _ d�|�S | jdk r@| jjr:d| j_| jS dS ndS dS )z�
Get the pending writes from this transport, clearing them from the
pending buffer.
@return: the bytes written with C{transport.write}
@rtype: L{bytes}
r) NT)r, rA r5 r r )r r1 r r r � getOutBuffer� s
zFakeTransport.getOutBufferc C st t |t�rd| jd k st�| jjrZ| j�|| � d | _| jd }| _| �|� t| t j
� qpd| j_ n | j �
|� d S )NT)�
isinstancer r5 �AssertionErrorr r r6 rB r r Z
ISSLTransportr r* Z dataReceived)r �buf�br r r �bufferReceived� s
z FakeTransport.bufferReceived)NN)T)%r r! r" r$ � staticmethod� itertools�countr- �closedr4 � disconnectedr ZConnectionDoner r: r; r5 r r r9 r= r> r? r@ rB r rC rE rF rG rH r< rI rJ rK rL rQ r r r r r% = s:
r% c C s t | dd�S )z�
Create and return a new in-memory transport hooked up to the given protocol.
@param clientProtocol: The client protocol to use.
@type clientProtocol: L{IProtocol} provider
@return: The transport.
@rtype: L{FakeTransport}
F)r+ )r% )�clientProtocolr r r �makeFakeClient s
rX c C s t | dd�S )z�
Create and return a new in-memory transport hooked up to the given protocol.
@param serverProtocol: The server protocol to use.
@type serverProtocol: L{IProtocol} provider
@return: The transport.
@rtype: L{FakeTransport}
T)r+ )r% )�serverProtocolr r r �makeFakeServer s
rZ c @ s, e Zd ZdZdd� Zd
dd�Zd dd�Zd S ) �IOPumpz�
Utility to pump data between clients and servers for protocol testing.
Perhaps this is a utility worthy of being in protocol.py?
c C s" || _ || _|| _|| _|| _d S )N)�client�server�clientIO�serverIO�debug)r r\ r] r^ r_ r` r r r r & s
zIOPump.__init__Fc C s8 d}x.t d�D ]}| �|�r"d}qP qW ds4td��|S )zk
Pump until there is no more input or output.
Returns whether any data was moved.
Fi� Tr zToo long)�range�pumprN )r r` �result�xr r r �flush. s
z IOPump.flushc C s, | j s
|rtd� | j�� }| j�� }| j�� | j�� | j sD|rttd� |r`tdt|� � |rttdt|� � |r�| j�|� |r�| j�|� |s�|r�dS | jjr�| jj s�| j s�|r�td� d| j_ d| j_| j�
� dS | jj�r(| jj �s(| j �s|�r
td� d| j_ d| j_| j�
� dS dS ) zX
Move data back and forth.
Returns whether any data was moved.
z
-- GLUG --�.zC: zS: Tz* Cz* SF) r` �printr_ rL r^ r= �reprrQ r4 rV rE )r r` ZsDataZcDatar r r rb ? sD
z IOPump.pumpN)F)F)r r! r" r$ r re rb r r r r r[ s
r[ FTc C s4 | � |� |� |� t|| |||�}|r0|�� |S )aN
Create a new L{IOPump} connecting two protocols.
@param serverProtocol: The protocol to use on the accepting side of the
connection.
@type serverProtocol: L{IProtocol} provider
@param serverTransport: The transport to associate with C{serverProtocol}.
@type serverTransport: L{FakeTransport}
@param clientProtocol: The protocol to use on the initiating side of the
connection.
@type clientProtocol: L{IProtocol} provider
@param clientTransport: The transport to associate with C{clientProtocol}.
@type clientTransport: L{FakeTransport}
@param debug: A flag indicating whether to log information about what the
L{IOPump} is doing.
@type debug: L{bool}
@param greet: Should the L{IOPump} be L{flushed <IOPump.flush>} once before
returning to put the protocols into their post-handshake or
post-server-greeting state?
@type greet: L{bool}
@return: An L{IOPump} which connects C{serverProtocol} and
C{clientProtocol} and delivers bytes between them when it is pumped.
@rtype: L{IOPump}
)ZmakeConnectionr[ re )rY �serverTransportrW �clientTransportr` �greetrb r r r �connectk s
rl c
C s4 |� }| � }||�}||�} ||t || ||||�fS )a
Connect a given server and client class to each other.
@param ServerClass: a callable that produces the server-side protocol.
@type ServerClass: 0-argument callable returning L{IProtocol} provider.
@param ClientClass: like C{ServerClass} but for the other side of the
connection.
@type ClientClass: 0-argument callable returning L{IProtocol} provider.
@param clientTransportFactory: a callable that produces the transport which
will be attached to the protocol returned from C{ClientClass}.
@type clientTransportFactory: callable taking (L{IProtocol}) and returning
L{FakeTransport}
@param serverTransportFactory: a callable that produces the transport which
will be attached to the protocol returned from C{ServerClass}.
@type serverTransportFactory: callable taking (L{IProtocol}) and returning
L{FakeTransport}
@param debug: Should this dump an escaped version of all traffic on this
connection to stdout for inspection?
@type debug: L{bool}
@param greet: Should the L{IOPump} be L{flushed <IOPump.flush>} once before
returning to put the protocols into their post-handshake or
post-server-greeting state?
@type greet: L{bool}
@return: the client protocol, the server protocol, and an L{IOPump} which,
when its C{pump} and C{flush} methods are called, will move data
between the created client and server protocol instances.
@rtype: 3-L{tuple} of L{IProtocol}, L{IProtocol}, L{IOPump}
)rl )
Z ServerClassZ ClientClassZclientTransportFactoryZserverTransportFactoryr` rk �c�sZcio�sior r r �connectedServerAndClient� s
&rp c C s2 | \}}}}}|\}}} }
||kr*||fS dS dS )a'
Should the client and server described by the arguments be connected to
each other, i.e. do their port numbers match?
@param clientInfo: the args for connectTCP
@type clientInfo: L{tuple}
@param serverInfo: the args for listenTCP
@type serverInfo: L{tuple}
@return: If they do match, return factories for the client and server that
should connect; otherwise return L{None}, indicating they shouldn't be
connected.
@rtype: L{None} or 2-L{tuple} of (L{ClientFactory},
L{IProtocolFactory})
Nr ) �
clientInfo�
serverInfoZ
clientHostZ
clientPort�
clientFactoryZ
clientTimeoutZclientBindAddressZ
serverPort�
serverFactoryZ
serverBacklogZserverInterfacer r r �_factoriesShouldConnect� s
ru c @ s4 e Zd ZdZdd� Zd
dd�Zee� �fdd�Zd S ) �ConnectionCompleterz�
A L{ConnectionCompleter} can cause synthetic TCP connections established by
L{MemoryReactor.connectTCP} and L{MemoryReactor.listenTCP} to succeed or
fail.
c C s
|| _ dS )z�
Create a L{ConnectionCompleter} from a L{MemoryReactor}.
@param memoryReactor: The reactor to attach to.
@type memoryReactor: L{MemoryReactor}
N)�_reactor)r �
memoryReactorr r r r � s z ConnectionCompleter.__init__Fc
C s� | j }x�t|j�D ]z\}}xp|jD ]f}t||�}|r"|j�|� |j�|� |\}}|�d�} |�d�}
t |
�} t
| �} t |
| | | |�S q"W qW dS )a�
Complete a single TCP connection established on this
L{ConnectionCompleter}'s L{MemoryReactor}.
@param debug: A flag; whether to dump output from the established
connection to stdout.
@type debug: L{bool}
@return: a pump for the connection, or L{None} if no connection could
be established.
@rtype: L{IOPump} or L{None}
N) rw � enumerate�
tcpClientsZ
tcpServersru �remove�
connectors�popZ
buildProtocolrZ rX rl )
r r` rx Z clientIdxrq rr Z factoriesrs rt rW rY ri rj r r r � succeedOnce� s
z ConnectionCompleter.succeedOncec C s( | j j�d�d �| j j�d�|� dS )z�
Fail a single TCP connection established on this
L{ConnectionCompleter}'s L{MemoryReactor}.
@param reason: the reason to provide that the connection failed.
@type reason: L{Failure}
r � N)rw rz r} ZclientConnectionFailedr| )r �reasonr r r �failOnce s z ConnectionCompleter.failOnceN)F) r r! r" r$ r r~ r
r r� r r r r rv � s
rv c C s8 t � }t|dd�}t|d�}|�t�t�� |t|�fS )a�
Create an endpoint that can be fired on demand.
@param debug: A flag; whether to dump output from the established
connection to stdout.
@type debug: L{bool}
@return: A client endpoint, and an object that will cause one of the
L{Deferred}s returned by that client endpoint.
@rtype: 2-L{tuple} of (L{IStreamClientEndpoint}, L{ConnectionCompleter})
z0.0.0.0i� )r r r �listenr
Z forProtocolr rv )r` ZreactorZclientEndpointZserverEndpointr r r �connectableEndpoint s
r� )FT)F)+r$ �
__future__r r r rS Z OpenSSL.SSLr r � ImportErrorZzope.interfacer r Ztwisted.internet.endpointsr r Ztwisted.internet.protocolr
r Ztwisted.internet.errorr Ztwisted.python.failurer
Ztwisted.internetr r Ztwisted.internet.testingr r ZIAddress�objectr# Z
ITransportZ
ITLSTransportr% rX rZ r[ rl rp ru rv r� r r r r �<module> s< GL
,+ <