o 9Bi J@sPdZddlmZddlZzddlmZWn eyYnwddlm Z m Z ddl m Z m Z ddlmZmZddlmZdd lmZmZdd lmZmZdd lmZGd d d Ze e jGdddZe e je je j GdddZ!ddZ"ddZ#GdddZ$   d$ddZ%e"e#dddfddZ&ddZ'Gd d!d!Z(d%d"d#Z)dS)&z0 Utilities and helpers for simulating a network ) annotationsN)Error)directlyProvides implementer)error interfaces)TCP4ClientEndpointTCP4ServerEndpoint)ConnectionRefusedError)FactoryProtocol) MemoryReactorMemoryReactorClock)Failurec@s&eZdZddZd ddZddZd S) TLSNegotiationcCs||_||_d|_||_dS)NF)obj connectStatesent readyToSend)selfrrrR/var/www/html/Trade-python/venv/lib/python3.10/site-packages/twisted/test/iosim.py__init__s zTLSNegotiation.__init__returnstrcCsd|jdS)NzTLSNegotiation())rrrrr__repr__"szTLSNegotiation.__repr__cCs&|j|jst|_|dSdSN)r iosimVerifyNativeOpenSSLErrordisconnectReasonloseConnection)rothertptrrrpretendToVerify%s zTLSNegotiation.pretendToVerifyNrr)__name__ __module__ __qualname__rrr%rrrrrs  rc@seZdZdZdS) FakeAddressz] The default address type for the host and peer of L{FakeTransport} connections. N)r'r(r)__doc__rrrrr*.sr*c@seZdZdZeefddZdZdZ dZ e dZ dZdZdZdd,d-Z"d.d/Z#d0d1Z$d2d3Z%d4d5Z&d6d7Z'd8d9Z(d:d;Z)dS)? 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. cCs tt|Sr)intnext)counterrrr?s zFakeTransport.rzConnection doneNcCsH||_||_g|_||_|durt}||_|durt}||_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)protocolisServerstream _nextserialserialr* hostAddress peerAddress)rr1r2r6r7rrrrHs  zFakeTransport.__init__rrcCs d|jrdpd|j|jjjS)NzFakeTransport<{},{},{}>SC)formatr2r5r1 __class__r'rrrrrds  zFakeTransport.__repr__cCs4|jrdS|jdur|j|dS|j|dSr) disconnectingtlstlsbufappendr3)rdatarrrwriteks  zFakeTransport.writecCs"|jr |js|jdSdSdSrproducerstreamingProducerresumeProducingrrrr_checkProducerus zFakeTransport._checkProducercCs ||_||_|s|dSdS)z. From abstract.FileDescriptor NrB)rrC streamingrrrregisterProducer{s  zFakeTransport.registerProducercCs d|_dSr)rCrrrrunregisterProducer z FakeTransport.unregisterProducercCs||dSr)rIr"rrrr stopConsumings zFakeTransport.stopConsumingcCs|d|dS)N)rAjoin)riovecrrr writeSequenceszFakeTransport.writeSequencecCs d|_dSNTr<rrrrr"rJzFakeTransport.loseConnectioncCs d|_dS)zp For the time being, this is the same as loseConnection; no buffered data will be lost. TNrQrrrrabortConnections zFakeTransport.abortConnectioncCs,|jdur t}n|j}|jt|dSr)r=r r!r1connectionLostr)rerrrrrreportDisconnects zFakeTransport.reportDisconnectcCsdS)zM Identify this transport/event source to the logging system. iosimrrrrr logPrefixszFakeTransport.logPrefixcC|jSr)r7rrrrgetPeerzFakeTransport.getPeercCrXr)r6rrrrgetHostrZzFakeTransport.getHostcCdSrrrrrrrEzFakeTransport.resumeProducingcCr\rrrrrrpauseProducingr]zFakeTransport.pauseProducingcCs |dSr)r"rrrr stopProducings zFakeTransport.stopProducingTcCs |j|A}t|||_g|_dSr)r2rr=r>)rcontextFactorybeNormalrrrrstartTLSs   zFakeTransport.startTLScCsB|j}|r g|_d|S|jdur|jjrd|j_|jSdSdS)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} rLNT)r3rMr=rr)rr8rrr getOutBuffers  zFakeTransport.getOutBuffercCsxt|tr4|jdus J|jjr.|j||d|_|jd}|_||t|tj dSd|j_ dS|j |dSrP) isinstancerr=rr%r>rOrr ISSLTransportrr1 dataReceived)rbufbrrrbufferReceiveds   zFakeTransport.bufferReceivedcCr\rrrrrrgetTcpKeepAliver]zFakeTransport.getTcpKeepAlivecCr\rrrrrr getTcpNoDelayr]zFakeTransport.getTcpNoDelaycCr\rrrrrrloseWriteConnectionr]z!FakeTransport.loseWriteConnectioncCr\rrrenabledrrrsetTcpKeepAliver]zFakeTransport.setTcpKeepAlivecCr\rrrmrrr setTcpNoDelayr]zFakeTransport.setTcpNoDelay)NNr&)T)*r'r(r)r+ staticmethod itertoolscountr4closedr< disconnectedrConnectionDoner!rCrDr=rrrArFrHrIrKrOr"rRrUrWrYr[rEr^r_rbrcrirjrkrlrorprrrrr,6sF        r,cC t|ddS)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} Fr2r,)clientProtocolrrrmakeFakeClient r{cCrw)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} Trxry)serverProtocolrrrmakeFakeServer r|r~c@s.eZdZdZd ddZd ddZd d d ZdS) IOPumpz Utility to pump data between clients and servers for protocol testing. Perhaps this is a utility worthy of being in protocol.py? NcCs6||_||_||_||_||_|durt}||_dSr)clientserverclientIOserverIOdebugrclock)rrrrrrrrrrrs zIOPump.__init__FTcCs0d}tdD] }|||rd}q|SJd)zk Pump until there is no more input or output. Returns whether any data was moved. FiTrzToo long)rangepump)rr advanceClockresult_rrrflush)s  z IOPump.flushcCs4|r|jd|js |rtd|j}|j}|j|j|js*|rBtd|r8tdt||rBtdt||rJ|j ||rR|j ||sV|rXdS|jj rx|jj sx|jse|ritdd|j_ d|j_ |j dS|jj r|jj s|js|rtdd|j_ d|j_ |j dSd S) z Move data back and forth, while also triggering any currently pending scheduled calls (i.e. C{callLater(0, f)}). Returns whether any data was moved. rz -- GLUG --.zC: zS: Tz* Cz* SF) radvancerprintrrcrrFreprrir<rurU)rrrsDatacDatarrrr9sF             z IOPump.pumprFT)r'r(r)r+rrrrrrrrs   rFTcCs8||||t||||||d}|r||S)a 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 } once before returning to put the protocols into their post-handshake or post-server-greeting state? @type greet: L{bool} @param clock: An optional L{Clock}. Pumping the resulting L{IOPump} will also increase clock time by a small increment. @return: An L{IOPump} which connects C{serverProtocol} and C{clientProtocol} and delivers bytes between them when it is pumped. @rtype: L{IOPump} r)makeConnectionrr)r}serverTransportrzclientTransportrgreetrrrrrconnectfs * rc Cs8|}|}||} ||} ||t|| || |||dfS)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 } once before returning to put the protocols into their post-handshake or post-server-greeting state? @type greet: L{bool} @param clock: An optional L{Clock}. Pumping the resulting L{IOPump} will also increase clock time by a small increment. @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} r)r) ServerClass ClientClassclientTransportFactoryserverTransportFactoryrrrcsciosiorrrconnectedServerAndClients .rc Cs.|\}}}}}|\}}} } ||kr||fSdS)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 serverInfo clientHost clientPort clientFactory clientTimeoutclientBindAddress serverPort serverFactory serverBacklogserverInterfacerrr_factoriesShouldConnects rc@s:eZdZdZdddZddddZeefdddZdS)ConnectionCompleterz A L{ConnectionCompleter} can cause synthetic TCP connections established by L{MemoryReactor.connectTCP} and L{MemoryReactor.listenTCP} to succeed or fail. memoryReactorr rNonecCs ||_dS)z Create a L{ConnectionCompleter} from a L{MemoryReactor}. @param memoryReactor: The reactor to attach to. N)_reactor)rrrrrrs zConnectionCompleter.__init__FTrboolr IOPump | Nonec Cs|j}t|jD]C\}}|jD];}t||}|rJ|j||j||\}} |d} | d} t | } t | } t | | | | ||d}|SqqdS)aQ 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. @return: a pump for the connection, or L{None} if no connection could be established. N)r) r enumerate tcpClients tcpServersrremove connectorspop buildProtocolr~r{r)rrrr clientIdxrr factoriesrrrzr}rrrrrr succeedOnces0        zConnectionCompleter.succeedOncereasonrcCs(|jjdd|jjd|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. rN)rrrclientConnectionFailedr)rrrrrfailOnce%szConnectionCompleter.failOnceN)rr rrr)rrrrrr)rrrr) r'r(r)r+rrrr rrrrrrs   "rcCs8t}t|dd}t|d}|tt|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)rrr listenr forProtocolr r)rreactorclientEndpointserverEndpointrrrconnectableEndpoint1s    r)FTN)F)*r+ __future__rrr OpenSSL.SSLrr ImportErrorzope.interfacerrtwisted.internetrrtwisted.internet.endpointsrr twisted.internet.errorr twisted.internet.protocolr r twisted.internet.testingr rtwisted.python.failurerrIAddressr* ITransport ITLSTransport IConsumerr,r{r~rrrrrrrrrrsJ    H  S = 5=