VhpT d Z ddlmZ ddlmZmZ ddlmZ ddlm Z m
Z
m Z m
Z
mZ ddlmZ ddlmZmZ ddlmZ dd lmZmZmZmZmZ dd
l m Z m Z m Z m Z m!Z!m"Z"m#Z# dd l$m%Z% dd l&m'Z' e
d
Z(d dZ) G d de Z* ee G d d Z+ ee G d d Z,d!dZ- e-e, e-e+ e G d d Z.d"dZ/dddef d#d Z0 e0 Z1 e/ Z2 G d d e Z3y )$z
Implementation of L{twisted.application.internet.ClientService}, particularly
its U{automat } state machine.
) annotations) dataclassfield)random)CallableOptionalProtocolTypeVarUnion) implementer)TypeMachineBuilderpep614)Service)CancelledErrorDeferredfail
maybeDeferredsucceed)IAddress IDelayedCall IProtocolIProtocolFactory IReactorTimeIStreamClientEndpoint
ITransport)Logger)FailureTc | ddl m} |S | S )zR
@return: the argument, or the global reactor if the argument is L{None}.
r )reactor)twisted.internetr ) maybeReactorr s S/home/dcms/DCMS/lib/python3.12/site-packages/twisted/application/_client_service.py_maybeGlobalReactorr$ ) s , c R e Zd Zd dZd
dZd dZd dZd
ddZd
ddZ d
ddZ y)_Clientc y)T
Start this L{ClientService}, initiating the connection retry loop.
N selfs r# startz
_Client.start6 r% c y)z
Stop trying to connect and disconnect any current connection.
@return: a L{Deferred} that fires when all outstanding connections are
closed and all in-progress connection attempts halted.
Nr* r+ s r# stopz _Client.stop; r. r% c y)zg
A connection has been made.
@param protocol: The protocol of the connection.
Nr* )r, protocols r# _connectionMadez_Client._connectionMadeC r. r% c y)z
Deliver connection failures to any L{ClientService.whenConnected}
L{Deferred}s that have met their failAfterFailures threshold.
@param failure: the Failure to fire the L{Deferred}s with.
Nr* r, failures r# _connectionFailedz_Client._connectionFailedJ r. r% Nc y)z?
The wait between connection attempts is done.
Nr* r5 s r#
_reconnectz_Client._reconnectR r. r% c y)z?
The current connection has been disconnected.
Nr* r5 s r# _clientDisconnectedz_Client._clientDisconnectedW r. r% c y)a-
Retrieve the currently-connected L{Protocol}, or the next one to
connect.
@param failAfterFailures: number of connection failures after which the
Deferred will deliver a Failure (None means the Deferred will only
fail if/when the service is stopped). Set this to 1 to make the
very first connection failure signal an error. Use 2 to allow one
failure but signal an error if the subsequent retry then fails.
@return: a Deferred that fires with a protocol produced by the factory
passed to C{__init__}. It may:
- fire with L{IProtocol}
- fail with L{CancelledError} when the service is stopped
- fail with e.g.
L{DNSLookupError} or
L{ConnectionRefusedError}
when the number of consecutive failed connection attempts
equals the value of "failAfterFailures"
Nr* r, failAfterFailuress r#
whenConnectedz_Client.whenConnected\ r. r% returnNonerA Deferred[None])r2 _ReconnectingProtocolProxyrA rB )r6 r rA rB N)r6 Optional[Failure]rA rB r>
Optional[int]rA Deferred[IProtocol])
__name__
__module__ __qualname__r- r0 r3 r7 r9 r; r? r* r% r# r' r' 5 s:
59 $1 r% r' c D e Zd ZdZ ddZd dZd
dZd dZd dZy)
rE z
A proxy for a Protocol to provide connectionLost notification to a client
connection service, in support of reconnecting when connections are lost.
c || _ || _ y)a
Create a L{_ReconnectingProtocolProxy}.
@param protocol: the application-provided L{interfaces.IProtocol}
provider.
@type protocol: provider of L{interfaces.IProtocol} which may
additionally provide L{interfaces.IHalfCloseableProtocol} and
L{interfaces.IFileDescriptorReceiver}.
@param lostNotification: a 1-argument callable to invoke with the
C{reason} when the connection is lost.
N) _protocol_lostNotification)r, r2 lostNotifications r# __init__z#_ReconnectingProtocolProxy.__init__ s "!1 r% c H || _ | j j | y rF )
_transportrP makeConnection)r, transports r# rV z)_ReconnectingProtocolProxy.makeConnection s # %%i0r% c | j j | | j | S # | j | w xY w)z
The connection was lost. Relay this information.
@param reason: The reason the connection was lost.
@return: the underlying protocol's result
)rP connectionLostrQ )r, reasons r# rY z)_ReconnectingProtocolProxy.connectionLost s6 +>>008 " "6 *D " "6 *s . Ac . t | j | S rF )getattrrP r, items r# __getattr__z&_ReconnectingProtocolProxy.__getattr__ s t~~t,,r% c P d| j j d| j dS )N) __class__rK rP r+ s r# __repr__z#_ReconnectingProtocolProxy.__repr__ s' 4>>**+:dnn5GqIIr% N)r2 r rR Callable[[Failure], None]rA rB )rW r rA rB )rZ r rA rB r^ strrA objectrA rg ) rK rL rM __doc__rS rV rY r_ rd r* r% r# rE rE x s9
2!25N2
2$1 +-Jr% rE c < e Zd ZdZ ddZddZd dZd
dZy) _DisconnectFactoryz
A L{_DisconnectFactory} is a proxy for L{IProtocolFactory} that catches
C{connectionLost} notifications and relays them.
c || _ || _ y rF )_protocolFactory_protocolDisconnected)r, protocolFactoryprotocolDisconnecteds r# rS z_DisconnectFactory.__init__ s
!0 %9"r% c j | j j | }|yt || j S )a2
Create a L{_ReconnectingProtocolProxy} with the disconnect-notification
callback we were called with.
@param addr: The address the connection is coming from.
@return: a L{_ReconnectingProtocolProxy} for a protocol produced by
C{self._protocolFactory}
N)rn
buildProtocolrE ro )r, addrbuilts r# rs z _DisconnectFactory.buildProtocol s5 %%33D9 =)%1K1KLLr% c . t | j | S rF )r\ rn r] s r# r_ z _DisconnectFactory.__getattr__ s t,,d33r% c b dj | j j | j S )Nz<{} wrapping {!r}>)formatrc rK rn r+ s r# rd z_DisconnectFactory.__repr__ s* #** NN # #T%:%:
r% N)rp r rq re rA rB )rt r rA zOptional[IProtocol]rf ri )rK rL rM rj rS rs r_ rd r* r% r# rl rl s8
:): 8:
:
M 4
r% rl c * dD ] }t | | y)z
Remove the special runtime attributes set by L{implementer} so that a class
can proxy through those attributes with C{__getattr__} and thereby forward
optionally-provided interfaces by the delegated class.
)__providedBy__ __provides____implemented__N)delattr)o zopeSpecials r# _deinterfacer s M ; r% c e Zd ZU dZded< ded< ded< ded < d
ed < ee Zd
ed< ee Zded< dZ ded< e
Z ded< ddZ d dZ
d dZd dZy) _Corez6
Shared core for ClientService state machine.
r endpointr factoryCallable[[int], float]timeoutForAttemptr clock'Optional[Callable[[IProtocol], object]]prepareConnection)default_factoryzlist[Deferred[None]] stopWaitersz/list[tuple[Deferred[IProtocol], Optional[int]]]awaitingConnectedr intfailedAttemptsr logc f | j j t | j d S )N)r appendr r+ s r# waitForStopz_Core.waitForStop s)
+ ##r% c b g | j c| _ }|D ] \ }}|j | y rF )r callback)r, valuewaitingw remainings r# unawaitz
_Core.unawait s6 *,d.D.D' # LAy
JJu r% c H | j t t y rF )r r r r+ s r# cancelConnectWaitersz_Core.cancelConnectWaiters s W^ -./r% c \ g | j c| _ }|D ] }|j d y rF )r r )r, r r s r# finishStoppingz_Core.finishStopping s2 $&(8(8!' A
JJt r% NrC )r zUnion[IProtocol, Failure]rA rB r@ )rK rL rM rj __annotations__r listr r r r r r r r r r* r% r# r r s|
$#
-- >> ).d(CK%CIN JF NC(C$
0 r% r c t t t } d dd} dd} d dd}| j d }| j d| }| j d }| j d| }| j d| }| j d } | j d
}
| j d }|j t j
j
| j d |j t j
j j d |j t j j
| j d |j t j
j j d |j t j j
| j d |j t j j
| j d |j t j
j j d |j t j j
| j d | j t j
j
|
j d |
j t j
j
|
j d |j t j
j
| j d t |j t j j
| t |j t j j
| d d } t |j t j j
| d d } t |j t j d
j
| d d }
t |j t j j
| d d }t |j t j j
| d d }t |j t j j d d!d }t | j t j j t |
j t j j
| d d }t | j t j j
| t | j t j j
| d d"d }t |j t j d
j t |j t j d
j t |j t j j
| t |
j t j j
|
t | j t j j
| d d#d }t |
j t j j
| dd"d }t |j t j j
| d d#d }| j! S )$Nc |xj dz
c_ |j |j }|j j d|j |j | |j
j
|| j S )N zDScheduling retry {attempt} to connect {endpoint} in {delay} seconds.)attemptr delay)r r r infor r callLaterr9 )csr6 r s r# waitForRetryz!makeMachine..waitForRetry ss
A ##A$4$45
R$$ZZ
ww 55r% c J d|_ |j |j |S )Nr )r r rP )r r r2 s r# rememberConnectionz'makeMachine..rememberConnection s# ($$%r% c t j | j }j j | } dfd }|}|j | j | j j | j |S )Nc j (t j j fd S t S )Nc S rF r* )_r2 s r# zImakeMachine..attemptConnection..prepare..' s h r% )r r addCallbackr )r2 r s `r# preparez7makeMachine..attemptConnection..prepare" sA "".$Q%8%8(COO& 8$ $r% )r2 rE rA $Deferred[_ReconnectingProtocolProxy]) rl r r; r connectr r3
addErrbackr7 )r r r6 factoryProxy
connectingr connectingProxys ` r# attemptConnectionz&makeMachine..attemptConnection s *!))Q5J5JK *+***<*<\*J
%0 %
1 % % ' ' 0
[**
+
Z++
, r% Init
ConnectingStoppedWaiting Connected
Disconnecting
Restartingc t d S rF )r r r s r#
immediateStopz"makeMachine..immediateStopO s t} r% c F |j }|j |S rF )r cancel)r r r waiteds r# connectingStopz#makeMachine..connectingStopT s
r% T)nodatac g }g }|j D ]H \ }}||j ||f |dk r|j | 3|j ||dz
f J ||_ |D ] }|j | y )Nr )r r r )r r r6 readynotReadyr r s r# failedWhenConnectingz)makeMachine..failedWhenConnecting\ s DF / / 4LAy I/a QIM 23
4 ' A
JJw r% c |j }|j |j |j |S rF )r r r r )r r futureRetryr s r# r0 zmakeMachine..stopk s6
r% c Z |j }|j j |S rF )r rU loseConnection)r r r2 r s r# stopWhileConnectedz'makeMachine..stopWhileConnecteds s& **,
r% c , t |j S rF )r rP )r r r2 r> s r# whenConnectedWhenConnectedz/makeMachine..whenConnectedWhenConnected{ s x))**r% c " |j S rF )r r s r# discoStopz makeMachine..discoStop s }} r% c D |j |j y rF )r r r r r6 s r# disconnectingFinishedz*makeMachine..disconnectingFinished s
r% c T t }|j j ||f |S rF )r r r )r r r> results r# awaitingConnectionz'makeMachine..awaitingConnection s* '/j ""F,=#>?
r% c $ |j y rF )r r s r# restartDonez makeMachine..restartDone s r% c ( t t S rF )r r )r r r> s r# notGoingToConnectz&makeMachine..notGoingToConnect s N$%%r% rF )r r' r r r6 rG rA r )r r' r r r2 rE rA rE )r r' r r r6 rG rA r )r r' r r rA rD )r r' r r r r rA rD )r r' r r r6 r rA rB )r r' r r r r rA rD )r r' r r r2 rE rA rD )
r r' r r r2 rE r> rI rA rJ )r r' r r r6 rG rA rB )r r' r r r> rI rA rJ )r
r' r stateuponr- toreturnsloopr3 r9 r7 r; r r0 r? build)machiner r r r r r r r r r r r r r0 r r r r r r r s r# makeMachiner s %0G <@ 6 6 6'8 6 6 (B # <@ '8 - 8 == D |->?JmmI&GmmI|4G
k+=>IMM/2M |,JmmI&G IIgmm
+33D9OOGMM"'')11$7OOG++,// :BB4H LL $$&..t4 LL##$''
3;;DA
NN7,,-009AA$G
NN7==!&&(006
NN7../227;CCDIw}}%((4< >w GH;? '8
I G JOOG 1 1$O ? D D FG GLL..tL < A A CD DIIg++ , / / 56 JOOG 1 1 2 5 5j AB M w 4 4 5 8 8 GHAE 1> I C 7 E H
JOOG 7 7 8 ; ;J GH I GLL.. / 2 27 ;& & =&
==?r% g ?g N@g ?c d fd }|S )a
A timeout policy for L{ClientService} which computes an exponential backoff
interval with configurable parameters.
@since: 16.1.0
@param initialDelay: Delay for the first reconnection attempt (default
1.0s).
@type initialDelay: L{float}
@param maxDelay: Maximum number of seconds between connection attempts
(default 60 seconds, or one minute). Note that this value is before
jitter is applied, so the actual maximum possible delay is this value
plus the maximum possible result of C{jitter()}.
@type maxDelay: L{float}
@param factor: A multiplicative factor by which the delay grows on each
failed reattempt. Default: 1.5.
@type factor: L{float}
@param jitter: A 0-argument callable that introduces noise into the delay.
By default, C{random.random}, i.e. a pseudorandom floating-point value
between zero and one.
@type jitter: 0-argument callable returning L{float}
@return: a 1-argument callable that, given an attempt count, returns a
floating point number; the number of seconds to delay.
@rtype: see L{ClientService.__init__}'s C{retryPolicy} argument.
c t t t d| z z }| z S # t $ r }Y w xY w)Nd )min
OverflowError)r r factor initialDelayjittermaxDelays r# policyz backoffPolicy..policy sJ #c72C(CDhOE vx E s ) 77)r r rA floatr* )r r r r r s ```` r#
backoffPolicyr s H Mr% c r e Zd ZdZ e Z d ddZ d d dZd
fd Zd fd Z xZ
S )
ClientServicez
A L{ClientService} maintains a single outgoing connection to a client
endpoint, reconnecting after a configurable timeout when a connection
fails, either before or after connecting.
@since: 16.1.0
c
t | }|t n|}t t |||||| j | _ y)a
@param endpoint: A L{stream client endpoint
} provider which will be used to
connect when the service starts.
@param factory: A L{protocol factory }
which will be used to create clients for the endpoint.
@param retryPolicy: A policy configuring how long L{ClientService} will
wait between attempts to connect to C{endpoint}; a callable taking
(the number of failed connection attempts made in a row (L{int}))
and returning the number of seconds to wait before making another
attempt.
@param clock: The clock used to schedule reconnection. It's mainly
useful to be parametrized in tests. If the factory is serialized,
this attribute will not be serialized, and the default value (the
reactor) will be restored when deserialized.
@param prepareConnection: A single argument L{callable} that may return
a L{Deferred}. It will be called once with the L{protocol
} each time a new connection is made. It may
call methods on the protocol to prepare it for use (e.g.
authenticate) or validate it (check its health).
The C{prepareConnection} callable may raise an exception or return
a L{Deferred} which fails to reject the connection. A rejected
connection is not used to fire an L{Deferred} returned by
L{whenConnected}. Instead, L{ClientService} handles the failure
and continues as if the connection attempt were a failure
(incrementing the counter passed to C{retryPolicy}).
L{Deferred}s returned by L{whenConnected} will not fire until any
L{Deferred} returned by the C{prepareConnection} callable fire.
Otherwise its successful return value is consumed, but ignored.
Present Since Twisted 18.7.0
N)r r )r$ _defaultPolicy
ClientMachiner _log_machine)r, r r retryPolicyr r s r# rS zClientService.__init__ sE \ $E*(3(;n !. "3II
"
r% c 8 | j j | S )ai
Retrieve the currently-connected L{Protocol}, or the next one to
connect.
@param failAfterFailures: number of connection failures after which
the Deferred will deliver a Failure (None means the Deferred will
only fail if/when the service is stopped). Set this to 1 to make
the very first connection failure signal an error. Use 2 to
allow one failure but signal an error if the subsequent retry
then fails.
@type failAfterFailures: L{int} or None
@return: a Deferred that fires with a protocol produced by the
factory passed to C{__init__}
@rtype: L{Deferred} that may:
- fire with L{IProtocol}
- fail with L{CancelledError} when the service is stopped
- fail with e.g.
L{DNSLookupError} or
L{ConnectionRefusedError}
when the number of consecutive failed connection attempts
equals the value of "failAfterFailures"
)r r? r= s r# r? zClientService.whenConnected# s : }}**+<==r% c | j r | j j d yt | | j
j
y)r) z1Duplicate ClientService.startService {log_source}N)runningr warnsuper startServicer r- r, rc s r# r zClientService.startServiceB s; << IINNN O
r% c T t | | j j S )z
Stop attempting to reconnect and close any existing connections.
@return: a L{Deferred} that fires when all outstanding connections are
closed and all in-progress connection attempts halted.
)r stopServicer r0 r s r# r zClientService.stopServiceL s# }}!!##r% )NNN)
r r r r r z Optional[Callable[[int], float]]r zOptional[IReactorTime]r r rF rH r@ rC ) rK rL rM rj r r rS r? r r
__classcell__)rc s @r# r r s| 8D 9=(,EI
:
':
":
6 :
& :
C
:
z 26 >!. > >> $ $r% r N)r" z Optional[T]rA r )r~ rh rA rB )rA zCallable[[_Core], _Client])
r r r r r r r zCallable[[], float]rA r )4rj
__future__r dataclassesr r r _goodEnoughRandomtypingr r r TypingProtocolr
r zope.interfacer automatr
r twisted.application.servicer twisted.internet.deferr r r r r twisted.internet.interfacesr r r r r r r twisted.loggerr twisted.python.failurer r r$ r' rE rl r r r r r r r r* r% r# r s>
# ( . Q Q & . / " * CL @ n @ F
Y-J -J -J`
#
#
#
L
' ( # # # LbL "3 +++
+
+
+\
x$G x$r%