�
Ϫ�f� � � � d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z m
Z
mZmZmZ ddlmZ dd lmZ dd
lmZ d � Z G d � d
ej0 � Z G d� de� Z G d� de� ZdZ dZ G d� de� Z G d� de� Z G d� de� Z G d� de� Z! G d � d e� Z" G d � d e� Z# G d � d!e� Z$ G d"� d#e� Z% G d$� d%e� Z& G d&� d'e� Z' G d(� d)e� Z( G d*� d+ej0 � Z) G d,� d-ej0 � Z* G d.� d/� Z+ G d0� d1� Z,d2d3d4efd5�Z- e-� Z.d6� Z/ G d7� d8� Z0 G d9� d:ej0 � Z1g d;�Z2y<)=a�
Reactor-based Services
Here are services to run clients, servers and periodic services using
the reactor.
If you want to run a server service, L{StreamServerEndpointService} defines a
service that can wrap an arbitrary L{IStreamServerEndpoint
<twisted.internet.interfaces.IStreamServerEndpoint>}
as an L{IService}. See also L{twisted.application.strports.service} for
constructing one of these directly from a descriptive string.
Additionally, this module (dynamically) defines various Service subclasses that
let you represent clients and servers in a Service hierarchy. Endpoints APIs
should be preferred for stream server services, but since those APIs do not yet
exist for clients or datagram services, many of these are still useful.
They are as follows::
TCPServer, TCPClient,
UNIXServer, UNIXClient,
SSLServer, SSLClient,
UDPServer,
UNIXDatagramServer, UNIXDatagramClient,
MulticastServer
These classes take arbitrary arguments in their constructors and pass
them straight on to their respective reactor.listenXXX or
reactor.connectXXX calls.
For example, the following service starts a web server on port 8080:
C{TCPServer(8080, server.Site(r))}. See the documentation for the
reactor.listen/connect* methods for more information.
� )�random)�List)�MethodicalMachine)�service)�task)�CancelledError�Deferred�fail�
maybeDeferred�succeed)�Logger)�log)�Failurec � � | �ddl m} |S | S )zR
@return: the argument, or the global reactor if the argument is L{None}.
r )�reactor)�twisted.internetr )� maybeReactorr s �>/usr/lib/python3/dist-packages/twisted/application/internet.py�_maybeGlobalReactorr < s � � ��,����� c �( � e Zd ZU g Zee ed< d� Zy)�_VolatileDataService�volatilec �v � t j j | � }| j D ]
}||v s�||= � |S �N)r �Service� __getstate__r )�self�d�attrs r r z!_VolatileDataService.__getstate__K s> � � �O�O� (� (�� .���M�M� �D��q�y��d�G� � �r N)�__name__�
__module__� __qualname__r r �str�__annotations__r � r r r r H s � � �H�d�3�i� �r r c �L � e Zd ZU dZdgZdZeed< dZdZ d� Z
d� Z d� Z d � Z
d
� Zy) �_AbstractServera
@cvar volatile: list of attribute to remove from pickling.
@type volatile: C{list}
@ivar method: the type of method to call on the reactor, one of B{TCP},
B{UDP}, B{SSL} or B{UNIX}.
@type method: C{str}
@ivar reactor: the current running reactor.
@type reactor: a provider of C{IReactorTCP}, C{IReactorUDP},
C{IReactorSSL} or C{IReactorUnix}.
@ivar _port: instance of port set when the service is started.
@type _port: a provider of L{twisted.internet.interfaces.IListeningPort}.
�_port� �methodNc �T � || _ d|v r|j d� | _ || _ y �Nr ��args�popr �kwargs�r r/ r1 s r �__init__z_AbstractServer.__init__j �( � ��� � �� �!�:�:�i�0�D�L� �� r c �l � t j j | � | j � | _ y r )r r �privilegedStartService�_getPortr) �r s r r6 z&_AbstractServer.privilegedStartServicep s! � ����.�.�t�4��]�]�_��
r c � � t j j | � | j �| j � | _ y y r )r r � startServicer) r7 r8 s r r: z _AbstractServer.startServicet s0 � ����$�$�T�*� �:�:� � � � � �D�J� r c � � t j j | � | j � | j j � }| `|S y r )r r � stopServicer) �
stopListening)r r s r r< z_AbstractServer.stopServicey sA � ����#�#�D�)� �:�:� !��
�
�(�(�*�A��
��H� "r c � � t t | j � dj | j � � | j
i | j ��S )z�
Wrapper around the appropriate listen method of the reactor.
@return: the port object returned by the listen method.
@rtype: an object providing
L{twisted.internet.interfaces.IListeningPort}.
zlisten{})�getattrr r �formatr+ r/ r1 r8 s r r7 z_AbstractServer._getPort� sP � �
�w� �� � � -� � � �� � �
�
�
�9�9� %�
� � � %� %r )r! r" r# �__doc__r r+ r$ r% r r) r3 r6 r: r< r7 r& r r r( r( S s= � �� �y�H��F�C���G� �E� � %�)�
�
%r r( c �F � e Zd ZU dZdgZdZeed< dZdZ d� Z
d� Z d� Z d � Z
y)
�_AbstractClienta&
@cvar volatile: list of attribute to remove from pickling.
@type volatile: C{list}
@ivar method: the type of method to call on the reactor, one of B{TCP},
B{UDP}, B{SSL} or B{UNIX}.
@type method: C{str}
@ivar reactor: the current running reactor.
@type reactor: a provider of C{IReactorTCP}, C{IReactorUDP},
C{IReactorSSL} or C{IReactorUnix}.
@ivar _connection: instance of connection set when the service is started.
@type _connection: a provider of L{twisted.internet.interfaces.IConnector}.
� _connectionr* r+ Nc �T � || _ d|v r|j d� | _ || _ y r- r. r2 s r r3 z_AbstractClient.__init__� r4 r c �l � t j j | � | j � | _ y r )r r r: �_getConnectionrD r8 s r r: z _AbstractClient.startService� s% � ����$�$�T�*� �.�.�0��r c � � t j j | � | j � | j j � | `y y r )r r r< rD �
disconnectr8 s r r< z_AbstractClient.stopService� s= � ����#�#�D�)� � � � '� � � � '� '� )�� � (r c � � t t | j � d| j � �� | j i | j
��S )z�
Wrapper around the appropriate connect method of the reactor.
@return: the port object returned by the connect method.
@rtype: an object providing L{twisted.internet.interfaces.IConnector}.
�connect)r? r r r+ r/ r1 r8 s r rG z _AbstractClient._getConnection� sC � � S�w�*�4�<�<�8�G�D�K�K�=�:Q�R�
�Y�Y�
� �+�+�
�
r )r! r" r# rA r r+ r$ r% r rD r3 r: r< rG r& r r rC rC � s8 � �� ��H��F�C���G��K� � 1�!�
r rC ztConnect to {tran}
Call reactor.connect{tran} when the service starts, with the
arguments given to the constructor.
z�Serve {tran} clients
Call reactor.listen{tran} when the service starts, with the
arguments given to the constructor. When the service stops,
stop listening. See twisted.internet.interfaces for documentation
on arguments to the reactor method.
c �4 � e Zd Zej d�� ZdZy)� TCPServer�TCP��tranN�r! r" r# �
_serverDocr@ rA r+ r& r r rM rM � � � �� � �U� �+�G�
�Fr rM c �4 � e Zd Zej d�� ZdZy)� TCPClientrN rO N�r! r" r# �
_clientDocr@ rA r+ r& r r rU rU � rS r rU c �4 � e Zd Zej d�� ZdZy)�
UNIXServer�UNIXrO NrQ r& r r rY rY � � � �� � �V� �,�G�
�Fr rY c �4 � e Zd Zej d�� ZdZy)�
UNIXClientrZ rO NrV r& r r r] r] � r[ r r] c �4 � e Zd Zej d�� ZdZy)� SSLServer�SSLrO NrQ r& r r r_ r_ � rS r r_ c �4 � e Zd Zej d�� ZdZy)� SSLClientr` rO NrV r& r r rb rb � rS r rb c �4 � e Zd Zej d�� ZdZy)� UDPServer�UDPrO NrQ r& r r rd rd � rS r rd c �4 � e Zd Zej d�� ZdZy)�UNIXDatagramServer� UNIXDatagramrO NrQ r& r r rg rg � � � �� � �^� �4�G�
�Fr rg c �4 � e Zd Zej d�� ZdZy)�UNIXDatagramClientrh rO NrV r& r r rk rk � ri r rk c �4 � e Zd Zej d�� ZdZy)�MulticastServer� MulticastrO NrQ r& r r rm rm s � �� � �[� �1�G�
�Fr rm c �0 � e Zd ZdZddgZd� Zd� Zd� Zd� Zy) � TimerServicea�
Service to periodically call a function
Every C{step} seconds call the given function with the given arguments.
The service starts the calls when it starts, and cancels them
when it stops.
@ivar clock: Source of time. This defaults to L{None} which is
causes L{twisted.internet.reactor} to be used.
Feel free to set this to something else, but it probably ought to be
set *before* calling L{startService}.
@type clock: L{IReactorTime<twisted.internet.interfaces.IReactorTime>}
@ivar call: Function and arguments to call periodically.
@type call: L{tuple} of C{(callable, args, kwargs)}
�_loop�
_loopFinishedc �4 � || _ |||f| _ d| _ y)a+
@param step: The number of seconds between calls.
@type step: L{float}
@param callable: Function to call
@type callable: L{callable}
@param args: Positional arguments to pass to function
@param kwargs: Keyword arguments to pass to function
N)�step�call�clock)r rt �callabler/ r1 s r r3 zTimerService.__init__ s � � �� � �t�V�,�� ���
r c � � t j j | � | j \ }}}t j
|g|��i |��| _ t | j � | j _ | j j | j d�� | _ | j j | j � y )NT)�now)r r r: ru r � LoopingCallrq r rv �startrt rr �
addErrback�_failed)r rw r/ r1 s r r: zTimerService.startService) s� � ����$�$�T�*�!%��� ��$��
�%�%�h�@��@��@��
�.�t�z�z�:��
�
�� !�Z�Z� -� -�d�i�i�T� -� B��� ���%�%�d�l�l�3r c �P � d| j _ t j |� y �NF)rq �runningr �err)r �whys r r} zTimerService._failed5 s � � #��
�
�� ���� r c � � � � j j r� j j � � j j � fd�� � j S )z�
Stop the service.
@rtype: L{Deferred<defer.Deferred>}
@return: a L{Deferred<defer.Deferred>} which is fired when the
currently running call (if any) is finished.
c �B �� t j j �� S r )r r r< ��_r s �r �<lambda>z*TimerService.stopService.<locals>.<lambda>F s �� �� � �1L�1L�T�1R� r )rq r� �stoprr � addCallbackr8 s `r r< zTimerService.stopService< sA �� � �:�:� � � �J�J�O�O� � ���&�&�'R�S��!�!�!r N) r! r" r# rA r r3 r: r} r< r& r r rp rp s' � ��" � �)�H�
�
4�� "r rp c �( � e Zd ZdZd� Zd� Zd� Zd� Zy)�CooperatorServicezb
Simple L{service.IService} which starts and stops a L{twisted.internet.task.Cooperator}.
c �: � t j d�� | _ y )NF)�started)r �
Cooperator�coopr8 s r r3 zCooperatorService.__init__O s � ��O�O�E�2�� r c �8 � | j j |� S r )r� � coiterate)r �iterators r r� zCooperatorService.coiterateR s � ��y�y�"�"�8�,�,r c �8 � | j j � y r )r� r{ r8 s r r: z CooperatorService.startServiceU s � � � � ���r c �8 � | j j � y r )r� r� r8 s r r< z CooperatorService.stopServiceX s � � � � ���r N)r! r" r# rA r3 r� r: r< r& r r r� r� J s � ��3�-��r r� c �, � e Zd ZdZdZd� Zd� Zd� Zd� Zy)�StreamServerEndpointServiceaP
A L{StreamServerEndpointService} is an L{IService} which runs a server on a
listening port described by an L{IStreamServerEndpoint
<twisted.internet.interfaces.IStreamServerEndpoint>}.
@ivar factory: A server factory which will be used to listen on the
endpoint.
@ivar endpoint: An L{IStreamServerEndpoint
<twisted.internet.interfaces.IStreamServerEndpoint>} provider
which will be used to listen when the service starts.
@ivar _waitingForPort: a Deferred, if C{listen} has yet been invoked on the
endpoint, otherwise None.
@ivar _raiseSynchronously: Defines error-handling behavior for the case
where C{listen(...)} raises an exception before C{startService} or
C{privilegedStartService} have completed.
@type _raiseSynchronously: C{bool}
@since: 10.2
Fc �. � || _ || _ d | _ y r )�endpoint�factory�_waitingForPort)r r� r� s r r3 z$StreamServerEndpointService.__init__w s � � ��
� �� � #�� r c � � �� t j j � � � j j � j
� � _ g ��� fd�}� j j |� �r�d j � d� _ y)z2
Start listening on the endpoint.
c � �� �j r�j | � y | j t � st j
| � y y r )�_raiseSynchronously�append�checkr r r� )r� � raisedNowr s ��r �handleItzDStreamServerEndpointService.privilegedStartService.<locals>.handleIt� s6 �� ��'�'�� � ��%��Y�Y�~�.����� � /r r FN)
r r r6 r� �listenr� r� r| �raiseExceptionr� )r r� r� s ` @r r6 z2StreamServerEndpointService.privilegedStartService| sm �� � ���.�.�t�4� #�}�}� 3� 3�D�L�L� A�� �� � �
� � �'�'��1� � �a�L� '� '� )�#(�� r c �| � t j j | � | j �| j � yy)zu
Start listening on the endpoint, unless L{privilegedStartService} got
around to it already.
N)r r r: r� r6 r8 s r r: z(StreamServerEndpointService.startService� s3 � �
���$�$�T�*� � � � '� � '� '� )� (r c � � � � j j � d� }� j j |� }� fd�}|j |� |S )a
Stop listening on the port if it is already listening, otherwise,
cancel the attempt to listen.
@return: a L{Deferred<twisted.internet.defer.Deferred>} which fires
with L{None} when the port has stopped listening.
c �( � | �| j � S y r )r= )�ports r �stopItz7StreamServerEndpointService.stopService.<locals>.stopIt� s � �� ��)�)�+�+� r c � �� d�_ | S r )r� )� passthroughr s �r r� z5StreamServerEndpointService.stopService.<locals>.stop� s �� � �D�L� � r )r� �cancelr� �addBoth)r r� r r� s ` r r< z'StreamServerEndpointService.stopService� sK �� �
� � �#�#�%� ,�
� � � ,� ,�V� 4�� �
� � �$���r N) r! r" r# rA r� r3 r6 r: r< r& r r r� r� \ s# � ��0 ��$�
)�&*�r r� c �. � e Zd ZdZd� Zd� Zd� Zdefd�Zy)�_ReconnectingProtocolProxyz�
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 �protocol�lostNotifications r r3 z#_ReconnectingProtocolProxy.__init__� s � � "���!1�� r 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
)r� �connectionLostr� )r �reasons r r� z)_ReconnectingProtocolProxy.connectionLost� s6 � � +��>�>�0�0��8� � "� "�6� *��D� "� "�6� *�s �. �Ac �. � t | j |� S r )r? r� �r �items r � __getattr__z&_ReconnectingProtocolProxy.__getattr__� s � ��t�~�~�t�,�,r �returnc �P � d| j j � d| j �d�S )N�<z
wrapping �>)� __class__r! r� r8 s r �__repr__z#_ReconnectingProtocolProxy.__repr__� s' � ��4�>�>�*�*�+�:�d�n�n�5G�q�I�Ir N) r! r" r# rA r3 r� r� r$ r� r& r r r� r� � s$ � ��
2� +�-�J�#� Jr r� c �. � e Zd ZdZd� Zd� Zd� Zdefd�Zy)�_DisconnectFactoryz�
A L{_DisconnectFactory} is a proxy for L{IProtocolFactory} that catches
C{connectionLost} notifications and relays them.
c � � || _ || _ y r )�_protocolFactory�_protocolDisconnected)r �protocolFactory�protocolDisconnecteds r r3 z_DisconnectFactory.__init__� s � � /�� �%9��"r c �` � t | j j |� | 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}
)r� r� �
buildProtocolr� )r �addrs r r� z _DisconnectFactory.buildProtocol� s- � � *� � !� !� /� /�� 5�t�7Q�7Q�
�
r c �. � t | j |� S r )r? r� r� s r r� z _DisconnectFactory.__getattr__� s � ��t�,�,�d�3�3r r� c �b � dj | j j | j � S )Nz<{} wrapping {!r}>)r@ r� r! r� r8 s r r� z_DisconnectFactory.__repr__� s* � �#�*�*� �N�N� #� #�T�%:�%:�
�
r N) r! r" r# rA r3 r� r� r$ r� r& r r r� r� � s" � ��
:�
� 4�
�#�
r r� g �?g N@g �?c � � ���� �� ��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)N�d )�min�
OverflowError)�attempt�delay�factor� initialDelay�jitter�maxDelays ����r �policyz backoffPolicy.<locals>.policy sJ �� � �� ��#�c�7�2C�(C�D�h�O�E� �v�x� � �� � � �E� �s � ) � 7�7r& )r� r� r� r� r� s ```` r �
backoffPolicyr� � s �� �B � �Mr c � � t | � d S )aO
Return the first element of a generator and exhaust it.
C{MethodicalMachine.upon}'s C{collector} argument takes a generator of
output results. If the generator is exhausted, the later outputs aren't
actually run.
@param gen: Generator to extract values from
@return: The first element of the generator.
r )�list)�gens r � _firstResultr� ) s � � ��9�Q�<�r c �
� e Zd ZdZ e� Zd� Zej d�� d� � Zej � d� � Z ej � d� � Z
ej � d� � Z ej � d � � Z ej � d
� � Z
ej � d � � Zej � d � � Zej# � d
� � Zd� Zej# � d� � Zej � d� � Zej# � d� � Zej# � d� � Zej# � d� � Zej# � d� � Zej � d� � Zej# � d� � Zej � d� � Z ej# � d� � Z ej# � d� � Z d� Z ej � d� � Z ej � d � � Z!ej# � d � � Z"ej# � d � � Z#ej# � d � � Z$ej# � d � � Z%ej# � d!� � Z&d"� Z'ej � d-d$�� Z(ej# � d-d%�� Z)ej# � d-d&�� Z*ej# � d-d'�� Z+ej# � d(� � Z,d)� Z-ej# � d*� � Z.ej_ ee eg�+� ej_ eee,ge0�,� e j_ ee g �+� e j_ ee eege0�,� e j_ ee eg�+� e j_ e e
e e.g�+� e
j_ ee
g �+� e
j_ eeee#ee%ge0�,� e
j_ e e eg�+� e j_ ee g �+� e j_ ee eege0�,� e j_ e!e
e"e g�+� e j_ ee
eg�+� e j_ ee ege0�,� e j_ e!ee#e%e"g�+� e j_ e ee$e&g�+� e
j_ ee
g �+� e
j_ ee ege0�,� e
j_ e!e e%eg�+� ej_ ee eg�+� ej_ eee,ge0�,� ej_ e(ee+ge0�,� e j_ e(e e+ge0�,� e
j_ e(e
e+ge0�,� e j_ e(e e)ge0�,� e j_ e(e e+ge0�,� e
j_ e(e
e+ge0�,� ej_ e(ee*ge0�,� y#).�_ClientMachinea
State machine for maintaining a single outgoing connection to an endpoint.
@ivar _awaitingConnected: notifications to make when connection
succeeds, fails, or is cancelled
@type _awaitingConnected: list of (Deferred, count) tuples
@see: L{ClientService}
c � � || _ d| _ d| _ || _ || _ || _ || _ t d� | _ g | _ g | _
|| _ y)z�
@see: L{ClientService.__init__}
@param log: The logger for the L{ClientService} instance this state
machine is associated to.
@type log: L{Logger}
r FN) � _endpoint�_failedAttempts�_stopped�_factory�_timeoutForAttempt�_clock�_prepareConnectionr �_connectionInProgress�_awaitingConnected� _stopWaiters�_log)r r� r� � retryPolicyrv �prepareConnectionr s r r3 z_ClientMachine.__init__E s[ � � "��� �� � ��
� ��
�"-�� ��� �"3�� �%,�T�]��"�"$�� � ����� r T)�initialc � � y)z3
The service has not been started.
Nr& r8 s r �_initz_ClientMachine._init[ � � r c � � y)z5
The service has started connecting.
Nr& r8 s r � _connectingz_ClientMachine._connectinga r� r c � � y)za
The service is waiting for the reconnection period
before reconnecting.
Nr& r8 s r �_waitingz_ClientMachine._waitingg r� r c � � y)z+
The service is connected.
Nr& r8 s r �
_connectedz_ClientMachine._connectedn r� r c � � y)zM
The service is disconnecting after being asked to shutdown.
Nr& r8 s r �_disconnectingz _ClientMachine._disconnectingt r� r c � � y)zM
The service is disconnecting and has been asked to restart.
Nr& r8 s r � _restartingz_ClientMachine._restartingz r� r c � � y)zC
The service has been stopped and is disconnected.
Nr& r8 s r r� z_ClientMachine._stopped� r� r c � � y)�T
Start this L{ClientService}, initiating the connection retry loop.
Nr& r8 s r r{ z_ClientMachine.start� r� r c � � � t � j � fd�� }� j j |� j � j
� j � j � j � j � � _ y)z-
Start a connection attempt.
c �$ �� �j � S r )�_clientDisconnectedr� s �r r� z)_ClientMachine._connect.<locals>.<lambda>� s �� �T�%=�%=�%?� r N)
r� r� r� rK r� �_runPrepareConnection�_connectionMader| �_connectionFailedr� )r � factoryProxys ` r �_connectz_ClientMachine._connect� se �� �
*� �M�M�?�
� �
�N�N� "� "�<� 0�
�[��3�3�
4�
�[��-�-�
.�
�Z��.�.�
/�
�"r c �p �� | j r(t | j �� j �fd�� S �S )am
Run any C{prepareConnection} callback with the connected protocol,
ignoring its return value but propagating any failure.
@param protocol: The protocol of the connection.
@type protocol: L{IProtocol}
@return: Either:
- A L{Deferred} that succeeds with the protocol when the
C{prepareConnection} callback has executed successfully.
- A L{Deferred} that fails when the C{prepareConnection} callback
throws or returns a failed L{Deferred}.
- The protocol, when no C{prepareConnection} callback is defined.
c � �� �S r r& )r� r� s �r r� z6_ClientMachine._runPrepareConnection.<locals>.<lambda>� s �� �(� r )r� r r� �r r� s `r r z$_ClientMachine._runPrepareConnection� s8 �� �$ � "� "� ��!8�!8�(�C�O�O�"��
� �r c � � d| _ y)z6
Reset the number of failed attempts.
r N)r� r8 s r �_resetFailedAttemptsz#_ClientMachine._resetFailedAttempts� s � �
!�� 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& r8 s r r� z_ClientMachine.stop� r� r c �f � | j j t � � | j d S )z�
Return a deferred that will fire when the service has finished
disconnecting.
@return: L{Deferred} that fires when the service has finished
disconnecting.
���)r� r� r r8 s r � _waitForStopz_ClientMachine._waitForStop� s+ � �
��� � ���,�� � ��$�$r c �8 � | j j � y)z2
Stop pending connection attempt.
N)r� r� r8 s r �_stopConnectingz _ClientMachine._stopConnecting� s � �
�"�"�)�)�+r c �< � | j j � | ` y)z4
Stop pending attempt to reconnect.
N)�
_retryCallr� r8 s r �
_stopRetryingz _ClientMachine._stopRetrying� s � �
��� � � � �Or c �L � | j j j � y)z4
Disconnect the current connection.
N)�_currentConnection� transport�loseConnectionr8 s r � _disconnectz_ClientMachine._disconnect� s � �
� � �)�)�8�8�:r c � � y)z�
A connection has been made.
@param protocol: The protocol of the connection.
@type protocol: L{IProtocol}
Nr& r s r r z _ClientMachine._connectionMade� r� r c �j � d| _ |j | _ | j | j � y)z�
Notify all pending requests for a connection that a connection has been
made.
@param protocol: The protocol of the connection.
@type protocol: L{IProtocol}
r N)r� r� r �_unawaitr s r �_notifyWaitersz _ClientMachine._notifyWaiters� s, � � !�� �"*�"4�"4�� � �
�
�d�-�-�.r c � � y)z8
The current connection attempt failed.
Nr& �r �fs r r z _ClientMachine._connectionFailed� r� r c �$ � | j � y)z+
Schedule a retry attempt.
N��_doWaitr8 s r �_waitz_ClientMachine._wait s
� �
� � �r c �" � | j � S )zM
Schedule a retry attempt, and ignore the Failure passed in.
r" r s r �_ignoreAndWaitz _ClientMachine._ignoreAndWait s � �
�|�|�~� r c � � | xj dz
c_ | j | j � }| j j d| j | j |�� | j
j
|| j � | _ y )N� zDScheduling retry {attempt} to connect {endpoint} in {delay} seconds.)r� r� r� ) r� r� r� �infor� r� � callLater�
_reconnectr )r r� s r r# z_ClientMachine._doWait sr � � � � ��!� ��'�'��(<�(<�=�� � � ��� U��(�(��^�^�� �
� �+�+�/�/��t���G��r c � � y)z?
The wait between connection attempts is done.
Nr& r8 s r r+ z_ClientMachine._reconnect r� r c � � y)z?
The current connection has been disconnected.
Nr& r8 s r r z"_ClientMachine._clientDisconnected$ r� r c � � | ` y)z0
Forget the current connection.
N)r r8 s r �_forgetConnectionz _ClientMachine._forgetConnection* s
� �
� #r c �H � | j t t � � � y)zm
Notify all pending requests for a connection that no more connections
are expected.
N�r r r r8 s r �_cancelConnectWaitersz$_ClientMachine._cancelConnectWaiters1 � � �
�
�
�g�n� .�/�0r c �H � | j t t � � � y)z�
Notify all pending requests for a connection that no more connections
are expected, after ignoring the Failure passed in.
Nr1 r s r � _ignoreAndCancelConnectWaitersz-_ClientMachine._ignoreAndCancelConnectWaiters9 r3 r c �$ � | j � y)zG
Notify all deferreds waiting on the service stopping.
N��_doFinishStoppingr8 s r �_finishStoppingz _ClientMachine._finishStoppingA s � �
� � � r c �$ � | j � y)zq
Notify all deferreds waiting on the service stopping, and ignore the
Failure passed in.
Nr7 r s r �_ignoreAndFinishStoppingz'_ClientMachine._ignoreAndFinishStoppingH s � �
� � � r c �\ � g | j c| _ }|D ] }|j d � � y r )r� �callback)r �waiting�ws r r8 z _ClientMachine._doFinishStoppingP s2 � �%'��):�):�"���7�� �A�
�J�J�t� � r Nc � � y)�i
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<twisted.internet.error.DNSLookupError>} or
L{ConnectionRefusedError<twisted.internet.error.ConnectionRefusedError>}
when the number of consecutive failed connection attempts
equals the value of "failAfterFailures"
Nr& �r �failAfterFailuress r �
whenConnectedz _ClientMachine.whenConnectedU r� r c �, � t | j � S )z�
Return the currently connected protocol.
@return: L{Deferred} that is fired with currently connected protocol.
)r r rB s r r z!_ClientMachine._currentConnectionr s � � �t�.�.�/�/r c �( � t t � � S )z�
Notify the caller that no connection is expected.
@return: L{Deferred} that is fired with L{CancelledError}.
)r
r rB s r �
_noConnectionz _ClientMachine._noConnection{ s � � �N�$�%�%r c �T � t � }| j j ||f� |S )z�
Return a deferred that will fire with the next connected protocol.
@return: L{Deferred} that will fire with the next connected protocol.
)r r� r� )r rC �results r �_awaitingConnectionz"_ClientMachine._awaitingConnection� s* � � ��� � � �&�&��0A�'B�C��
r c � � t d� S )z�
Return a deferred that has already fired with L{None}.
@return: A L{Deferred} that has already fired with L{None}.
N)r r8 s r �_deferredSucceededWithNonez)_ClientMachine._deferredSucceededWithNone� s � � �t�}� r c �b � g | j c| _ }|D ] \ }}|j |� � y)z�
Fire all outstanding L{ClientService.whenConnected} L{Deferred}s.
@param value: the value to fire the L{Deferred}s with.
N)r� r= )r �valuer> r? � remainings r r z_ClientMachine._unawait� s8 � � ,.�t�/F�/F�(�� �� #� �L�A�y�
�J�J�u� � r c � � g }g }| j D ]H \ }}|�|j ||f� � |dk r|j |� �3|j ||dz
f� �J || _ |D ] }|j |� � y)z�
Deliver connection failures to any L{ClientService.whenConnected}
L{Deferred}s that have met their failAfterFailures threshold.
@param f: the Failure to fire the L{Deferred}s with.
Nr( )r� r� r= )r r �ready�notReadyr? rO s r �_deliverConnectionFailurez(_ClientMachine._deliverConnectionFailure� s� � � ���� � 3� 3� 4�L�A�y�� �����I��/��a� �� � �Q������I��M� 2�3�
4� #+�� �� �A�
�J�J�q�M� r )�enter�outputs)rT rU � collectorr )1r! r" r# rA r �_machiner3 �stater� r� r� r� r� r� r� �inputr{ �outputr r r r� r r r r r r r r$ r& r# r+ r r/ r2 r5 r9 r; r8 rD r rG rJ rL r rS �uponr� r& r r r� r� 8 s� � �� !�"�H��, �^�^�D�^�!� � "� �
�^�^�� � � �
�^�^�� � � � �^�^�� � � �
�^�^�� � � �
�^�^�� � � �
�^�^�� � � �
�^�^�� � � �
�_�_��
� �
� �0 �_�_��!� �!� �^�^�� � � � �_�_�� %� � %� �_�_��,� �,� �_�_�� � � � �_�_��;� �;� �^�^�� � � � �_�_��
/� �
/� �^�^�� � � �
�_�_��� �� �_�_�� � � � H� �^�^�� � � �
�^�^�� � � �
�_�_��$� �$� �_�_��1� �1� �_�_��1� �1� �_�_��!� �!� �_�_��!� �!� �
�^�^�� � � �8 �_�_��0� �0� �_�_��&� �&� �_�_��� �� �_�_�� � � � � �_�_��� ��,
�J�J�u�K�(��J�<� �J�J� ��+�,� � � � ���U�+�r��:� ��� � � ��/� � � � ���_�J� �@P��Q������ �!:�;� � �
�M�M�%�x��M�4� �M�M� �� � 4�m�_�U� � � �
�M�M�*�K�(��M�D��O�O�E��R�O�8��O�O� � � �{�+� � � � �O�O��8�6G��5O� � � ����[�;O�:P��Q���� �N�\�N�l� � � �����&��9J�K� � � �����/�1I�J� � � ���U�+�r��:���� �N�\�N�l� � � ����;� �(�8S� � �
�M�M�%�{�X�J�M�?� �M�M� ��+�,� � � �
�J�J���$�%� � � � �����$�%� � � �
�M�M���$�%� � � � �O�O���#�$� � � � ���� �$�%� � � � �����$�%� � � �
�M�M��X�
��,� � r r� c �L � � e Zd ZdZ e� Z dd�Zdd�Z� fd�Z� 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 �n � t |� }|�t n|}t |||||| j �� | _ y)aZ
@param endpoint: A L{stream client endpoint
<interfaces.IStreamClientEndpoint>} provider which will be used to
connect when the service starts.
@param factory: A L{protocol factory <interfaces.IProtocolFactory>}
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}.
@type retryPolicy: 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.
@type clock: L{IReactorTime}
@param prepareConnection: A single argument L{callable} that may return
a L{Deferred}. It will be called once with the L{protocol
<interfaces.IProtocol>} 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
@type prepareConnection: L{callable}
N)r� r )r �_defaultPolicyr� r� rW )r r� r� r� rv r� s r r3 zClientService.__init__: s= � �\ $�E�*��(3�(;�n�� �&� � � � � /�� � �
��
r c �8 � | j j |� S )rA )rW rD rB s r rD zClientService.whenConnectedt s � �6 �}�}�*�*�+<�=�=r c � �� | j r | j j d� yt �| � � | j
j
� y)r� z1Duplicate ClientService.startService {log_source}N)r� r� �warn�superr: rW r{ �r r� s �r r: zClientService.startService� s; �� � �<�<� �I�I�N�N�N� 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.
)rc r< rW r� rd s �r r< zClientService.stopService� s# �� � ��� ��}�}�!�!�#�#r )NNNr ) r! r" r# rA r
r� r3 rD r: r< �
__classcell__)r� s @r r] r] / s2 �� �� �8�D� RV�8
�t>�: �$� $r r] )rp r� rm r� rd r] rM rU rY r] r_ rb rg rk N)3rA r �_goodEnoughRandom�typingr �automatr �twisted.applicationr r r �twisted.internet.deferr r r
r r �twisted.loggerr
�twisted.pythonr �twisted.python.failurer r r r r( rC rW rR rM rU rY r] r_ rb rd rg rk rm rp r� r� r� r� r� r_ r� r� r] �__all__r& r r �<module>rp sz ��
!�H /� � %� '� !�� � "� � *� ��7�?�?� �<%�*� <%�~0
�*� 0
�f�
� �
��� �
�� �
� � �
� � �
�� �
�� �
�� �
� � �
� � �
�o� �
A"�'� A"�H���� �$Q�'�/�/� Q�h'J� 'J�T
�
�D �t�C�8I�(�V � �� � t� t�nt$�G�O�O� t$�n �r |