tf tUdZddlZddlZddlZddlmZmZddlmZm Z m Z ddl m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd l&m'Z(m)Z*m+Z,dd l-m.Z.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?dd l@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZJddlKmLZLmMZNddlOmPZPmQZQmRZRerddlSmTZTddlDmUZUeLjVrddlWmXZXndZXeCZYeYZdZ[eYZdZ\eYZdZ]ee3GddZ^ee=GddZ_ee=Gdd Z`ed!efZaeeaeebd!feecebffZded"eeceaeebd!feecebffZeGd#d$Zfee8e9Gd%d&Zged'eeceefZheed!efeebd!feecebffZiee6e;e?Gd(d)egZjeLjVr eeje:ee2Gd*d+eZkGd,d-e jlZmgZneeceod.<dS)/z8 Very basic functionality for a Reactor implementation. N)ABCabstractmethod)heapifyheappopheappush) format_stack) FrameType) TYPE_CHECKINGAnyCallableDictListNewTypeOptionalSequenceSetTupleUnioncast)classImplements implementer)abstractdefererrorfdescmainthreads)ComplexResolverSimplifier GAIResolverSimpleResolverComplexifier)Deferred DeferredList)IAddress IConnector IDelayedCallIHostnameResolver IProtocol IReactorCoreIReactorFromThreadsIReactorPluggableNameResolverIReactorPluggableResolverIReactorThreads IReactorTimeIReadDescriptorIResolverSimpleIWriteDescriptor_ISupportsExitSignalCapturing) ClientFactory)Logger)reflect)Failure)callWithLogger)platformseconds)SignalHandling_WithoutSignalHandling_WithSignalHandling)Client) threadable) ThreadPoolzUnexpected error in main loopzwhile calling from threadz*While calling system event trigger handlercTeZdZUdZdZeeed<dZee eed<e fde de de fde ed eeefd e dgdfd e dgdfd e ge fd dfdZd e fdZddZde d dfdZde d dfdZddZd efdZded efdZded efdZd efdZdS) DelayedCallFN_reprcreatortimefunc.argskwcancelresetr8returnc||||f\|_|_|_|_||_||_||_dx|_|_d|_ |j rtdd|_ dSdS)aR @param time: Seconds from the epoch at which to call C{func}. @param func: The callable to call. @param args: The positional arguments to pass to the callable. @param kw: The keyword arguments to pass to the callable. @param cancel: A callable which will be called with this DelayedCall before cancellation. @param reset: A callable which will be called with this DelayedCall after changing this DelayedCall's scheduled execution time. The callable should adjust any necessary scheduling details to ensure this DelayedCall is invoked at the new appropriate time. @param seconds: If provided, a no-argument callable which will be used to determine the current time any time that information is needed. rN) rDrErFrGresetter cancellerr8 cancelledcalled delayed_timedebugrrC)selfrDrErFrGrHrIr8s T/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/twisted/internet/base.py__init__zDelayedCall.__init__asz448tR3G0 49di  '(( : /'>>#2#.DLLL / /c |j|jzS)z Return the time at which this call will fire @return: The number of seconds after the epoch at which this call is scheduled to be made. rDrRrTs rUgetTimezDelayedCall.getTimesy4,,,rWc|jr tj|jr tj||d|_|jrt||_|` |` |` dS)z Unschedule this call @raise AlreadyCancelled: Raised if this call has already been unscheduled. @raise AlreadyCalled: Raised if this call has already been made. r9N) rPrAlreadyCancelledrQ AlreadyCalledrOrSreprrBrErFrGrZs rUrHzDelayedCall.cancelsk > .( ( [ .% % NN4 DNz (!$ZZ  49dgggrWsecondsFromNowc|jr tj|jr tj||z}||jkr%d|_||_||dS||jz |_dS)aY Reschedule this call for a different time @param secondsFromNow: The number of seconds from the time of the C{reset} call at which this call will be scheduled. @raise AlreadyCancelled: Raised if this call has been cancelled. @raise AlreadyCalled: Raised if this call has already been made. rLN) rPrr]rQr^r8rDrRrN)rTr`newTimes rUrIzDelayedCall.resets > 8( ( [ 8% %llnn~5G""$'!#  d#####$+di$7!!!rW secondsLaterc|jr tj|jr tj|xj|z c_|jdkr+|||dSdS)aQ Reschedule this call for a later time @param secondsLater: The number of seconds after the originally scheduled time for which to reschedule this call. @raise AlreadyCancelled: Raised if this call has been cancelled. @raise AlreadyCalled: Raised if this call has already been made. rLN)rPrr]rQr^rRactivate_delayrN)rTrcs rUdelayzDelayedCall.delays~ > $( ( [ $% %    -   3&&##%%% d#####'&rWc>|xj|jz c_d|_dS)NrLrYrZs rUrezDelayedCall.activate_delays# T&& rWc |jp|j S)zDetermine whether this call is still pending @return: True if this call has not yet been made or cancelled, False otherwise. )rPrQrZs rUactivezDelayedCall.actives N1dk22rWothercZt|tr|j|jkStS)z Implement C{<=} operator between two L{DelayedCall} instances. Comparison is based on the C{time} attribute (unadjusted by the delayed time).  isinstancerArDNotImplementedrTrjs rU__le__zDelayedCall.__le__s+ e[ ) ) "9 * *! !rWcZt|tr|j|jkStS)z Implement C{<} operator between two L{DelayedCall} instances. Comparison is based on the C{time} attribute (unadjusted by the delayed time). rlros rU__lt__zDelayedCall.__lt__s+ e[ ) ) "9uz) )! !rWc|j|jSt|drkt|jdd}|7t|jdd}|t|jdd}||d|}|t j|j}nd}|}dt||j|z |j |j fzg}|| d|d f|j rS| d d |j D|jr| d |jrI| d d |jD| d |j0| dd|jz| dd|S)z Implement C{repr()} for L{DelayedCall} instances. @returns: String containing details of the L{DelayedCall}. NrE __qualname____name__im_class.z.z(DelayedCall.__repr__..s##L#L#LQG$5a$8$8#L#L#LrWcFg|]\}}|dtj|S)=r|)r~kvs rUrz(DelayedCall.__repr__..s5UUU6AqA66 1! 4 466UUUrW)z traceback at creation: %sz >)rBhasattrgetattrrEr4r}r8idrDrQrPextendrFappendjoinrGitemsrC)rTrEimClassnowLs rU__repr__zDelayedCall.__repr__s : !:  4 49nd;;D|ty*d;;#%diTBBG*")22D22|(33Dllnn <$xxS$+t~F G    HHc4% & & &y ##L#L$)#L#L#LMMNNN7#HHTNNNw IIUUTW]]__UUU HHSMMM < # HH8FKK >?????rWresultcP |j|\}}|j|=|t|tr=||||dS||dS#t$rYdSwxYwr) rrHrmr5rrgetErrorMessagecallbackKeyError)rTrrrrrs rU _checkTimeoutzThreadedResolver._checkTimeout=s .'+';N'K $L*$^4      &'** .$$TZZf6L6L6N6N%O%OPPPPP%%f-----    DD sB B%$B%r9 -timeoutc|rt|}nd}t}tjt t |jt t|jtj |}t t|j ||j ||}||f|j|<||j||}|S)a1 See L{twisted.internet.interfaces.IResolverSimple.getHostByName}. Note that the elements of C{timeout} are summed and the result is used as a timeout for the lookup. Any intermediate timeout or retry logic is left up to the platform via L{socket.gethostbyname}. <)sumr!rdeferToThreadPoolrr)rr, getThreadPoolsocket gethostbynamer- callLaterrraddBothr)rTrr timeoutDelayrrr_s rU getHostByNamezThreadedResolver.getHostByNameMs  w<eZdZ ddedeedeefdZdS)BlockingResolverrrrrJc tj|}tj|S#t$r1d|d}t j|}tj|cYSwxYw)Nrz not found)rrrsucceedOSErrorrrfail)rTrraddressmsgrs rUrzBlockingResolver.getHostByNamensz **400G =)) )  # # #/T///C&s++C:c?? " " " #s*8A%$A%Nr)rurrtrrrr!rr{rWrUrrlsS3A * * *"*3- * # * * * * * *rWr._ThreePhaseEventTriggerHandlec ~eZdZdZddZdededededef d Z d eddfd Z d eddfd Z d eddfd Z ddZ deddfdZdS)_ThreePhaseEventa Collection of callables (with arguments) which can be invoked as a group in a particular order. This provides the underlying implementation for the reactor's system event triggers. An instance of this class tracks triggers for all phases of a single type of event. @ivar before: A list of the before-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar finishedBefore: A list of the before-phase triggers which have already been executed. This is only populated in the C{'BEFORE'} state. @ivar during: A list of the during-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar after: A list of the after-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar state: A string indicating what is currently going on with this object. One of C{'BASE'} (for when nothing in particular is happening; this is the initial value), C{'BEFORE'} (when the before-phase triggers are in the process of being executed). rJNc>g|_g|_g|_d|_dS)NBASE)beforeduringafterstaterZs rUrVz_ThreePhaseEvent.__init__s"57 57 46  rWphasecallablerFkwargsc|dvrtdt|||||ft||||fS)a Add a trigger to the indicate phase. @param phase: One of C{'before'}, C{'during'}, or C{'after'}. @param callable: An object to be called when this event is triggered. @param args: Positional arguments to pass to C{callable}. @param kwargs: Keyword arguments to pass to C{callable}. @return: An opaque handle which may be passed to L{removeTrigger} to reverse the effects of calling this method. rrr invalid phase)rrrr)rTrrrFrs rU addTriggerz_ThreePhaseEvent.addTriggersZ& 5 5 5?++ +e##XtV$<===,eXtV-LMMMrWhandlecHt|d|jz|dS)aS Remove a previously added trigger callable. @param handle: An object previously returned by L{addTrigger}. The trigger added by that call will be removed. @raise ValueError: If the trigger associated with C{handle} has already been removed or if C{handle} is not a valid handle. removeTrigger_N)rr)rTrs rU removeTriggerz_ThreePhaseEvent.removeTriggers, 5&344V<<<<e?Z@ded/e5d0e6fd1e7d9e7deAf d:ZBd;eAddfd<ZCd;eAddfd=ZDde(eEfd>ZFdNd?ZGdeefd@ZHdNdAZIeJjKrTeLJdZMdZNdZOdNdBZPdCe5d0e6fd1e7d2e7ddfdDZQdNdEZRdNdFZSdNdGZTdeLfdHZUdIe5d0e6fd1e7d2e7ddfdJZVdKe)ddfdLZWxZXSdCe5d0e6fd1e7d2e7ddfdMZQxZXS)Sra Default base class for Reactors. @ivar _stopped: A flag which is true between paired calls to C{reactor.run} and C{reactor.stop}. This should be replaced with an explicit state machine. @ivar _justStopped: A flag which is true between the time C{reactor.stop} is called and the time the shutdown system event is fired. This is used to determine whether that event should be fired after each iteration through the mainloop. This should be replaced with an explicit state machine. @ivar _started: A flag which is true from the time C{reactor.run} is called until the time C{reactor.run} returns. This is used to prevent calls to C{reactor.run} on a running reactor. This should be replaced with an explicit state machine. @ivar running: See L{IReactorCore.running} @ivar _registerAsIOThread: A flag controlling whether the reactor will register the thread it is running in as the I/O thread when it starts. If C{True}, registration will be done, otherwise it will not be. @ivar _exitSignal: See L{_ISupportsExitSignalCapturing._exitSignal} @ivar _installSignalHandlers: A flag which indicates whether any signal handlers will be installed during startup. This includes handlers for SIGCHLD to monitor child processes, and SIGINT, SIGTERM, and SIGBREAK @ivar _signals: An object which knows how to install and uninstall the reactor's signal-handling behavior. TFN_signalstwisted.internet.reactorrJctg|_i|_g|_g|_d|_d|_d|_d|_ d|_ t|_ d|_ |dd|j|dd|j|dd|jt%jr||dS)NrFrstartupshutdown)superrVthreadCallQueue_eventTriggers_pendingTimedCalls_newTimedCalls_cancellationsrunning_started _justStopped_startedBeforeset_internalReaderswakeraddSystemEventTrigger_reallyStartRunningcrash disconnectAllr7supportsThreads _initThreads installWaker)rT __class__s rUrVzReactorBase.__init__ss 24;=5713  !#+.%% ""8Y8PQQQ ""8ZDDD ""8Z9KLLL  # % %       rW_installSignalHandlersinstallSignalHandlerscJ|r|StS)z Get an appropriate signal handling object. @param installSignalHandlers: Indicate whether to even try to do any signal handling. If C{False} then the result will be a no-op implementation. )_signalsFactoryr;rTr+s rU_makeSignalHandlingzReactorBase._makeSignalHandlings* ! *'')) )%'''rWcBt|j|j|jS)z Get a signal handling object that implements the basic behavior of stopping the reactor on SIGINT, SIGBREAK, and SIGTERM. )r<sigIntsigBreaksigTermrZs rUr-zReactorBase._signalsFactorys% # K M L   rWreadercd|j|||dS)z Add a read descriptor which is part of the implementation of the reactor itself. The read descriptor will not be removed by L{IReactorFDSet.removeAll}. N)r add addReaderrTr4s rU_addInternalReaderzReactorBase._addInternalReaders3 !!&))) vrWcd|j|||dS)zm Remove a read descriptor which is part of the implementation of the reactor itself. N)r r removeReaderr8s rU_removeInternalReaderz!ReactorBase._removeInternalReaders5 $$V,,, &!!!!!rWc|| ||jdS#|jwxYw)N)r+) startRunningmainLoopr uninstallr.s rUrunzReactorBase.runs` 0EFFF & MMOOO M # # % % % % %DM # # % % % %s AA"c |jrlt5||}|jo|}||dddn #1swxYwY|jlt ddS)NzMain loop terminated.)r _topHandlerrunUntilCurrentrr doIteration_loginfo)rTt2ts rUr?zReactorBase.mainLoopsm $ $ $$$&&&\\^^L'R  ###  $ $ $ $ $ $ $ $ $ $ $ $ $ $ $m $ )*****sAA""A&)A&cTttj|jdz)Nz did not implement installWakerNotImplementedErrorr4qualr)rZs rUr(zReactorBase.installWaker)! L ( (+L L   rWcJ|jr|jdSdS)z) Wake up the event loop. N)r!wakeUprZs rUrPzReactorBase.wakeUps2 : J         rWrfcTttj|jdz)zV Do one iteration over the readers and writers which have been added. z did not implement doIterationrKrTrfs rUrEzReactorBase.doIterations+" L ( (+K K   rWcTttj|jdz)Nz did not implement addReaderrKr8s rUr7zReactorBase.addReader)! L ( (+I I   rWwritercTttj|jdz)Nz did not implement addWriterrKrTrUs rU addWriterzReactorBase.addWriterrTrWcTttj|jdz)Nz did not implement removeReaderrKr8s rUr;zReactorBase.removeReaderrNrWcTttj|jdz)Nz did not implement removeWriterrKrWs rU removeWriterzReactorBase.removeWriterrNrWcTttj|jdz)Nz did not implement removeAllrKrZs rU removeAllzReactorBase.removeAllrTrWcTttj|jdz)Nz did not implement getReadersrKrZs rU getReaderszReactorBase.getReaders)! L ( (+J J   rWcTttj|jdz)Nz did not implement getWritersrKrZs rU getWriterszReactorBase.getWritersr`rWrrrc|stjdStj|rtj|S|j||S)z8 Return a Deferred that will resolve a hostname.z0.0.0.0)rrr isIPAddressrr)rTrrs rUresolvezReactorBase.resolve sW  ,=++ +   % % '=&& &}**4999rWcf|jrtjdd|_d|_d|_dS)zD See twisted.internet.interfaces.IReactorCore.stop. z&Can't stop reactor that isn't running.TN)_stoppedrReactorNotRunningrrrZs rUstopzReactorBase.stops> = T)*RSS S  "rWcZd|_d|_|dd|jdS)z See twisted.internet.interfaces.IReactorCore.crash. Reset reactor state tracking attributes and re-initialize certain state-transition helpers which were set up in C{__init__} but later destroyed (through use). FrrN)rrr"r#rZs rUr$zReactorBase.crashs3   ""8Y8PQQQQQrWnumberframec|td||j||_dS)z Handle a SIGINT interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} zReceived SIGINT, shutting down.NrFrGcallFromThreadri _exitSignalrTrkrls rUr1zReactorBase.sigInt+s; 3444 DI&&&!rWc|td||j||_dS)z Handle a SIGBREAK interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} z!Received SIGBREAK, shutting down.Nrnrqs rUr2zReactorBase.sigBreak6s; 5666 DI&&&!rWc|td||j||_dS)z Handle a SIGTERM interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} z Received SIGTERM, shutting down.Nrnrqs rUr3zReactorBase.sigTermAs; 4555 DI&&&!rWc|}|D]/}t||jttj0dS)z2Disconnect every reader, and writer in the system.N)r]_callWithLoggerconnectionLostr5rCONNECTION_LOST)rT selectablesr4s rUr%zReactorBase.disconnectAllLsVnn&& !  F -wt7K/L/L      rWrLcX|||dS)zG See twisted.internet.interfaces.IReactorCore.iterate. N)rDrErRs rUiteratezReactorBase.iterateTs0  rW eventTypecj|j|}||dSdS)zO See twisted.internet.interfaces.IReactorCore.fireSystemEvent. N)rgetr)rTr{events rUfireSystemEventzReactorBase.fireSystemEvent[s>#'' 22   OO       rWrr.rFrctj|s J|d||jvrt|j|<t ||j|j||g|Ri|fS)zU See twisted.internet.interfaces.IReactorCore.addSystemEventTrigger.  is not callable)builtinsrrrrr)rTrr{rrFrs rUr"z!ReactorBase.addSystemEventTriggercs **IIx,I,I,IIII D/ / /-=-?-?D  *9#I.98&*.4    rW triggerIDcP|\}}|j||dS)zX See twisted.internet.interfaces.IReactorCore.removeSystemEventTrigger. N)rr)rTrr{rs rUremoveSystemEventTriggerz$ReactorBase.removeSystemEventTriggerzs0& 6 I&44V<<<<registerAsIOThreadrr.s rUr>zReactorBase.startRunnings = 0-// /   0-// / !!!&;#001FGG    # ,  ) + + + Y'''''rWcXd|_|jr|jdSdS)z Method called to transition to the running state. This should happen in the I{during startup} event trigger phase. TN)rr*rinstallrZs rUr#zReactorBase._reallyStartRunnings<   & $ M ! ! # # # # # $ $rWrGc tj|s J|d|dks J|dt||z||||j|j|j}|j||S)zI See twisted.internet.interfaces.IReactorTime.callLater. rrz* is not greater than or equal to 0 seconds)r8)rrrAr8_cancelCallLater_moveCallLaterSoonerrr)rTrfrrFrG delayedCalls rUrzReactorBase.callLaters  **IIx,I,I,IIIIzzzeOOOzzz! LLNNU "     !  %L    "";///rWrc|j} ||}||}|dkr(|dz dz}|||krn||||<|}|dk(|||<dS#t$rYdSwxYw)Nrr9)rindexr)rTrheapposeltparents rUrz ReactorBase._moveCallLaterSooners& **[))Cs)C(('a<3&& LS  ((DIII    DD sAA A)(A)c&|xjdz c_dSNr9)r)rTrs rUrzReactorBase._cancelCallLaters q rWc4d|j|jzDS)zQ See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls} c g|] }|j | Sr{rPr~xs rUrz/ReactorBase.getDelayedCalls..s0   ;    rW)rrrZs rUgetDelayedCallszReactorBase.getDelayedCallss.  -0CC    rWc|jD]C}|jr|xjdzc_|t |j|Dg|_dSr)rrPrrerr)rTcalls rU_insertNewDelayedCallsz"ReactorBase._insertNewDelayedCallssk' 8 8D~ 8##q(#####%%%0$7777 rWc||jsdS|jdj|z }d}t dt ||S)z Determine the longest time the reactor may sleep (waiting on I/O notification, perhaps) before it must wake up to service a time-related event. @return: The maximum number of seconds the reactor may sleep. Nri )rrrDr8maxmin)rTrflongests rUrzReactorBase.timeoutsf ##%%%& 4'*/$,,..@1c'5))***rWcJ|jr}d}t|j}|jD]:\}}}t5||i|dddn #1swxYwY|dz }||krn;|jd|=|jr|||}|jr|jdj|krt|j}|j r|xj dzc_ I|j dkr*| t|j|~td|jfd5d|_|j|ji|jdddn #1swxYwY|jr|jdj|k|j dkrQ|j t|jdz kr1d|_ d |jD|_t+|j|jrd |_|d dSdS) z. Run all pending timed calls. rNr9rLz&while handling timed call {previous()}c|dn@dd|ddzdzS)Nrz) C: from a DelayedCall created here: C: z C:)rrstripreplace)rCs rUz-ReactorBase.runUntilCurrent..@sUBggg&&--//77gFFG rW)previous2c g|] }|j | Sr{rrs rUrz/ReactorBase.runUntilCurrent..Rs/'''!+''''rWFr)rlen_threadCallHandlerrPrr8rrDrrPrrRrerrFfailuresHandledrCrQrErFrGrrr)rTcounttotalfarGrrs rUrDzReactorBase.runUntilCurrents   E,--E 0  1b'  AqKBKKK                E>>E"$VeV,#   ##%%%llnn% 14+B1+E+Jc+Q+Q4233D~ ##q(## 3&&##%%%0$777%%8(, &   1 1   490000 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1% 14+B1+E+Jc+Q+Q6  " $ $#c$*A&B&Ba&GGG"#D ''2'''D # D+ , , ,   - %D    , , , , , - -s# AA A E::E>E>c|ttt||jd|_dS)NT)r  _GAIResolverrr,r usingThreadsrZs rUr'zReactorBase._initThreadsesD  $ $T/488$:LMM   !%D   rWrct|s J|d|j|||f|dS)zl See L{twisted.internet.interfaces.IReactorFromThreads.callFromThread}. rN)rrrrPrTrrFrs rUrozReactorBase.callFromThreadnsXA;; 6 61 6 6 6 6 6 6  ' 'D&(9 : : : KKMMMMMrWctddd|_||jj|_|dd|j|_dS)zO Create the threadpool accessible with callFromThread. r rrrN)r? threadpoolrstart_threadpoolStartupIDr"_stopThreadPoolthreadpoolShutdownIDrZs rU_initThreadPoolzReactorBase._initThreadPool|s[)B0JKKDO(,(<(r# staticmethodrr8rArrrr%rrrrDr7r&r?rrrr'rorrrrrr __classcell__)r)s@rUrrEs:HILK 6577Hn777)H8$)D((( ( (. ( ( ( (       T"O"""""&&&&&&&++++ E         % T      D     0 T     ? t     #3      4o7G&G HI     D1     D!12    3A : : :"*3- : # : : : :#### R R R R " "S "))< " " " " " " "s "8I+> "$ " " " " " "c "(9*= " " " " "  U T       38$           .=.=T====  c* 39 EK  . !    (($($((((> $ $ $ $"l>**G&.sCx&8AGOU ( (!K!D!!!! ,!7    !!!!+%++++8>->->->-B x!!a;%%% ## % % % % c3h' 06 BH           & & & & # # # #& #: # # # # J%c3h/ J8> JJP J  J J J J Ac Ad A A A A A A A A ;c3h' ;06 ;BH ;  ; ; ; ; ; ; ; ;rWrceZdZdZdZdZdedededdfdZ dd Z e dd Z dd Z dd ZddZdedeefdZdeddfdZdeddfdZdefdZdefdZdS) BaseConnectorzm Basic implementation of L{IConnector}. State can be: "connecting", "connected", "disconnected" NrfactoryrrrJc>d|_||_||_||_dS)N disconnected)rrrr)rTrrrs rUrVzBaseConnector.__init__s$$    rWc|jdkr|dS|jdkr$|jJ|jdSdS)z!Disconnect whatever our state is. connecting connectedN)rstopConnecting transportloseConnectionrZs rU disconnectzBaseConnector.disconnectsd : % %    ! ! ! ! ! Z; & &>--- N ) ) + + + + +' &rWr=cdSrr{rZs rU_makeTransportzBaseConnector._makeTransports rWc|jdkrtdd|_|js |jd|_||_|jA|j |j|jj tj |_ |j|dS)z"Start connection to remote server.rzcan't connect in this staterr9N)r RuntimeErrorfactoryStartedrdoStartrrrrrfailIfNotConnectedr TimeoutError timeoutIDstartedConnectingrZs rUconnectzBaseConnector.connects : ' '<== =! " $ L " " ""#D +/+>+>+@+@ < #!\33 dn?ASAUAUDN &&t,,,,,rWc|jdkrtjd|jJd|_|jtj|`dS)zStop attempting to connect.rzwe're not trying to connectNr)rrNotConnectingErrorrr UserErrorrZs rUrzBaseConnector.stopConnectings] : % %*+HII I~)))#  ))%/*;*;<<< NNNrWcr|j/ |jn#t$rYnwxYw|`dSdSr)rrHrrZs rU cancelTimeoutzBaseConnector.cancelTimeoutsW > % %%''''     & %s # 00addrcld|_||j|S)Nr)rrr buildProtocol)rTrs rUrzBaseConnector.buildProtocols1   |))$///rWreasonc|d|_d|_|j|||jdkr"|jd|_dSdSNrr)rrrrclientConnectionFaileddoStoprrTrs rUconnectionFailedzBaseConnector.connectionFailed sq #  ++D&999 : ' ' L   ! ! !"#D    ( 'rWcd|_|j|||jdkr"|jd|_dSdSr)rrclientConnectionLostrrrs rUrvzBaseConnector.connectionLostsX#  ))$777 : ' ' L   ! ! !"#D    ( 'rWcTttj|jdz)Nz! did not implement getDestinationrKrZs rUgetDestinationzBaseConnector.getDestinations)! L ( (+Q Q   rWcdtj|jt ||j|S)Nz<{} instance at 0x{:x} {} {}>)formatr4rMr)rrrrZs rUrzBaseConnector.__repr__!sF.55 L ( ( tHH J    ! !    rWr)rJr=)rurrtrrrr2rrrVrrrrrrr#rr'rr5rrvrrrr{rWrUrrso IN$/4?J ,,,,   ^ ---- 0(0x /B0000 $w$4$$$$$W$$$$$      #      rWrcreZdZUdZdZejed<dZej ed<dejfdZ de e fdZ dS)BasePortziBasic implementation of a ListeningPort. Note: This does not actually implement IListeningPort. N addressFamily socketTyperJctj|j|j}|dt j||S)NF)rrr  setblockingr_setCloseOnExecfileno)rTss rUcreateInternetSocketzBasePort.createInternetSocket3sH M$,do > > e ahhjj)))rWcTtdtj|jz)zRaises a RuntimeErrorzdoWrite called on a %s)rr4rMr)rZs rUdoWritezBasePort.doWrite9s"3gl4>6R6RRSSSrW)rurrtrrr AddressFamilyrr  SocketKindrrr5rr{rWrUrr*s +/M6'...$(J!(((fm T'*TTTTTTrWr__all__)prrrrabcrrheapqrrr tracebackrtypesr typingr r r r rrrrrrrrzope.interfacerrtwisted.internetrrrrrrtwisted.internet._resolverrrrrr rtwisted.internet.deferr!r"twisted.internet.interfacesr#r$r%r&r'r(r)r*r+r,r-r.r/r0r1twisted.internet.protocolr2twisted.loggerr3twisted.pythonr4twisted.python.failurer5twisted.python.logr6rutwisted.python.runtimer7r8rrr:r;r<twisted.internet.tcpr=r>r&twisted.python.threadpoolr?rFfailureHandlerrCrrrArrrrr_ThreePhaseEventTriggerrrrr _ThreadCallrrFileDescriptorrrrr{rWrUr+s   ########,,,,,,,,,,""""""                            87777777IIIIIIIIIIIIIIII :9999999"433333!!!!!!""""""******@@@@@@FFFFFFFFQQQQQQQQQQ,++++++&%%%%%84444444J vxx!!"ABB (()DEE))*VWW \FFFFFFFFR _GGGGGGGGT _ * * * * * * * *#+38"4#U63;%7c6k9JJ!(# #.fck0BDfDU UV!! G.G.G.G.G.G.G.G.T  *,EFF."."."."."."."GF."b)56S1S+TUUHS#X&fck(:Df