\dFdZddlZ ddlmZn #e$rYnwxYwddlmZmZddl m Z m Z ddl m Z mZddlmZddlmZmZdd lmZdd lmZGd d Zee jGd dZee je jGddZdZdZGddZ ddZ!eeddfdZ"dZ#GddZ$ddZ%dS)z0 Utilities and helpers for simulating a network N)Error)directlyProvides implementer)error interfaces)TCP4ClientEndpointTCP4ServerEndpoint)ConnectionRefusedError)FactoryProtocol)MemoryReactorClock)Failurec&eZdZdZdefdZdZdS)TLSNegotiationc>||_||_d|_||_dS)NF)obj connectStatesent readyToSend)selfrrs 2lib/python3.11/site-packages/twisted/test/iosim.py__init__zTLSNegotiation.__init__s&( 'returncd|jdS)NzTLSNegotiation())rrs r__repr__zTLSNegotiation.__repr__"s.....rc|j|js)t|_|dSdSN)r iosimVerifyNativeOpenSSLErrordisconnectReasonloseConnection)rothertpts rpretendToVerifyzTLSNegotiation.pretendToVerify%sNx##EI.. !#5#7#7C     ! !rN)__name__ __module__ __qualname__rstrrr'rrrrsM((( /#////!!!!!rrceZdZdZdS) FakeAddressz] The default address type for the host and peer of L{FakeTransport} connections. N)r(r)r*__doc__r,rrr.r..srr.c eZdZdZeejfdZdZdZ dZ e j dZ dZdZdZd!dZdefdZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZ dZ!dZ"d"dZ#dZ$dZ%dZ&dZ'dZ(dZ)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. c:tt|Sr )intnext)counters rzFakeTransport.?sT']]ASASrrzConnection doneNc||_||_g|_||_|t }||_|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)protocolisServerstream _nextserialserialr. hostAddress peerAddress)rr8r9r=r>s rrzFakeTransport.__init__Hs`"!    &&((  %--K&  %--K&rrcjd|jrdpd|j|jjjS)NzFakeTransport<{},{},{}>SC)formatr9r<r8 __class__r(rs rrzFakeTransport.__repr__ds9(// M !c (S K M # ,   rc|jrdS|j|j|dS|j|dSr ) disconnectingtlstlsbufappendr:)rdatas rwritezFakeTransport.writeksR    F 8  K  t $ $ $ $ $ K  t $ $ $ $ $rc\|jr"|js|jdSdSdSr producerstreamingProducerresumeProducingrs r_checkProducerzFakeTransport._checkProducerusF = ,!7 , M ) ) + + + + + , , , ,rcR||_||_|s|dSdS)z. From abstract.FileDescriptor NrL)rrM streamings rregisterProducerzFakeTransport.registerProducer{s=! !* '  $ $ & & & & & ' 'rcd|_dSr )rMrs runregisterProducerz FakeTransport.unregisterProducers  rcV||dSr )rUr$rs r stopConsumingzFakeTransport.stopConsumings, !!! rcV|d|dS)Nr)rJjoin)riovecs r writeSequencezFakeTransport.writeSequences$ 388E??#####rcd|_dSNTrErs rr$zFakeTransport.loseConnections!rcd|_dS)zp For the time being, this is the same as loseConnection; no buffered data will be lost. TNr^rs rabortConnectionzFakeTransport.abortConnections "rc|jt}n|j}|jt |dSr )rFr"r#r8connectionLostr)rerrs rreportDisconnectzFakeTransport.reportDisconnectsC 8 %&&CC'C $$WS\\22222rcdS)zM Identify this transport/event source to the logging system. iosimr,rs r logPrefixzFakeTransport.logPrefixs wrc|jSr )r>rs rgetPeerzFakeTransport.getPeer rc|jSr )r=rs rgetHostzFakeTransport.getHostrjrcdSr r,rs rrOzFakeTransport.resumeProducing rcdSr r,rs rpauseProducingzFakeTransport.pauseProducingrnrc.|dSr )r$rs r stopProducingzFakeTransport.stopProducings rTcR|j|z }t|||_g|_dSr )r9rrFrG)rcontextFactorybeNormalrs rstartTLSzFakeTransport.startTLSs,}x/ !.,?? rc|j}|rg|_d|S|j!|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} rNT)r:rYrFrr)rr@s r getOutBufferzFakeTransport.getOutBuffersY K DK88A;;  X !x#  $ xt4rcnt|tr|jJ|jjrb|j||d|_|jdc}|_||t|tj dSd|j_ dS|j |dSr]) isinstancerrFrr'rGr[rr ISSLTransportrr8 dataReceived)rbufbs rbufferReceivedzFakeTransport.bufferReceiveds c> * * ,8'''x} ,((d333"&d4;""1%%% z'?@@@@@(,$$$ M & &s + + + + +rcdSr r,rs rgetTcpKeepAlivezFakeTransport.getTcpKeepAlivernrcdSr r,rs r getTcpNoDelayzFakeTransport.getTcpNoDelayrnrcdSr r,rs rloseWriteConnectionz!FakeTransport.loseWriteConnectionrnrcdSr r,renableds rsetTcpKeepAlivezFakeTransport.setTcpKeepAlivernrcdSr r,rs r setTcpNoDelayzFakeTransport.setTcpNoDelayrnr)NN)T)+r(r)r*r/ staticmethod itertoolscountr;closedrE disconnectedrConnectionDoner#rMrNrFrr+rrJrPrSrUrWr[r$r`rdrgrirlrOrprrrvrxrrrrrrr,rrr1r16s,oio.?.?SSSTTK FML+u+,=>>H C''''8 #    %%%,,, '''$$$""""""333             ,,,,&                 rr1c$t|dS)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} Fr9r1)clientProtocols rmakeFakeClientrs % 8 8 88rc$t|dS)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} Trr)serverProtocols rmakeFakeServerr s $ 7 7 77rc(eZdZdZdZddZddZdS)IOPumpz Utility to pump data between clients and servers for protocol testing. Perhaps this is a utility worthy of being in protocol.py? cL||_||_||_||_||_dSr )clientserverclientIOserverIOdebug)rrrrrrs rrzIOPump.__init__s)       rFctd}tdD]}||rd}n Jd|S)zk Pump until there is no more input or output. Returns whether any data was moved. FiTrzToo long)rangepump)rrresultxs rflushz IOPump.flush&sQ t ! !Ayy  j  rc|js|rtd|j}|j}|j|j|js|rQtd|rtdt |z|rtdt |z|r|j||r|j||s|rdS|jjrW|jj sK|js|rtdd|j_ d|j_|j dS|jjrW|jj sK|js|rtdd|j_ d|j_|j dSdS) zX Move data back and forth. Returns whether any data was moved. z -- GLUG --.zC: zS: Tz* Cz* SF) rprintrrxrrPreprrrErrd)rrsDatacDatas rrz IOPump.pump6s :  ,    **,, **,, $$&&& $$&&& : + + #JJJ +ed5kk)*** +ed5kk)***  0 M ( ( / / /  0 M ( ( / / /  E 4 = & t}/I z U e )-DM &*.DM ' M * * , , ,4 = & t}/I z U e )-DM &*.DM ' M * * , , ,4urNF)r(r)r*r/rrrr,rrrrsU  ''''''rrFTc||||t|||||}|r||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 } 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} )makeConnectionrr)rserverTransportrclientTransportrgreetrs rconnectr`scL!!/222!!/222 %  D  Krc |}|}||}||} ||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 } 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} )r) ServerClass ClientClassclientTransportFactoryserverTransportFactoryrrcsciosios rconnectedServerAndClientrsZT  A A  # #C  # #C aCC66 66rc8|\}}}}}|\}}} } ||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 serverBacklogserverInterfaces r_factoriesShouldConnectrsD.  BL?Z Zm++trcLeZdZdZdZddZeefdZdS)ConnectionCompleterz A L{ConnectionCompleter} can cause synthetic TCP connections established by L{MemoryReactor.connectTCP} and L{MemoryReactor.listenTCP} to succeed or fail. c||_dS)z Create a L{ConnectionCompleter} from a L{MemoryReactor}. @param memoryReactor: The reactor to attach to. @type memoryReactor: L{MemoryReactor} N)_reactor)r memoryReactors rrzConnectionCompleter.__init__s& rFc |j}t|jD]\}}|jD]}t ||}|r|j||j||\}}|d} |d} t| } t| } t| | | | |ccSdS)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) r enumerate tcpClients tcpServersrremove connectorspop buildProtocolrrr) rrr clientIdxrr factoriesrrrrrrs r succeedOncezConnectionCompleter.succeedOnces %.}/G%H%H   !Iz+6   3J KK !,33J???!,00;;;3<0M=%2%@%@%F%FN%2%@%@%F%FN&4^&D&DO&4^&D&DO"&'&'    rc|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. @type reason: L{Failure} rN)rrrclientConnectionFailedr)rreasons rfailOncezConnectionCompleter.failOncesV  $$Q''*AA M $ ( ( + +V     rNr) r(r)r*r/rrrr rr,rrrrso &&&B&g&<&<&>&>??       rrct}t|dd}t|d}|t jt |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 rr listenr forProtocolr r)rreactorclientEndpointserverEndpoints rconnectableEndpointrsb!""G'DAAN'66N'-h77888 .w77 77r)FTr)&r/r OpenSSL.SSLrr" ImportErrorzope.interfacerrtwisted.internetrrtwisted.internet.endpointsrr twisted.internet.errorr twisted.internet.protocolr r twisted.internet.testingr twisted.python.failurerrIAddressr. ITransport ITLSTransportr1rrrrrrrrr,rrrs   7777777   D 98888888........MMMMMMMM99999977777777777777******!!!!!!!!& Z !!"! Z "J$<==D D D D D D D >=D N 9 9 9 8 8 8EEEEEEEEZ   ....h*)   .7.7.7.7b>; ; ; ; ; ; ; ; |888888s