twisted.application.internet._ClientMachine : API documentation

class documentation

class _ClientMachine: (source)

State machine for maintaining a single outgoing connection to an endpoint.

See Also ClientService

Method	`__init__`
Method	`start`	Start this `ClientService`, initiating the connection retry loop.
Method	`stop`	Stop trying to connect and disconnect any current connection.
Method	`whenConnected`	Retrieve the currently-connected `Protocol`, or the next one to connect.
Instance Variable	`_awaitingConnected`	notifications to make when connection succeeds, fails, or is cancelled
Class Variable	`_machine`	Undocumented
Instance Variable	`_endpoint`	Undocumented
Instance Variable	`_failedAttempts`	Undocumented
Method	`_stopped`	The service has been stopped and is disconnected.
Instance Variable	`_factory`	Undocumented
Instance Variable	`_timeoutForAttempt`	Undocumented
Instance Variable	`_clock`	Undocumented
Instance Variable	`_prepareConnection`	Undocumented
Instance Variable	`_connectionInProgress`	Undocumented
Instance Variable	`_stopWaiters`	Undocumented
Instance Variable	`_log`	Undocumented
Method	`_init`	The service has not been started.
Method	`_connecting`	The service has started connecting.
Method	`_waiting`	The service is waiting for the reconnection period before reconnecting.
Method	`_connected`	The service is connected.
Method	`_disconnecting`	The service is disconnecting after being asked to shutdown.
Method	`_restarting`	The service is disconnecting and has been asked to restart.
Method	`_connect`	Start a connection attempt.
Method	`_runPrepareConnection`	Run any `prepareConnection` callback with the connected protocol, ignoring its return value but propagating any failure.
Method	`_resetFailedAttempts`	Reset the number of failed attempts.
Method	`_waitForStop`	Return a deferred that will fire when the service has finished disconnecting.
Method	`_stopConnecting`	Stop pending connection attempt.
Method	`_stopRetrying`	Stop pending attempt to reconnect.
Method	`_disconnect`	Disconnect the current connection.
Method	`_connectionMade`	A connection has been made.
Method	`_notifyWaiters`	Notify all pending requests for a connection that a connection has been made.
Method	`_currentConnection`	Return the currently connected protocol.
Method	`_connectionFailed`	The current connection attempt failed.
Method	`_wait`	Schedule a retry attempt.
Method	`_ignoreAndWait`	Schedule a retry attempt, and ignore the Failure passed in.
Method	`_doWait`	Undocumented
Instance Variable	`_retryCall`	Undocumented
Method	`_reconnect`	The wait between connection attempts is done.
Method	`_clientDisconnected`	The current connection has been disconnected.
Method	`_forgetConnection`	Forget the current connection.
Method	`_cancelConnectWaiters`	Notify all pending requests for a connection that no more connections are expected.
Method	`_ignoreAndCancelConnectWaiters`	Notify all pending requests for a connection that no more connections are expected, after ignoring the Failure passed in.
Method	`_finishStopping`	Notify all deferreds waiting on the service stopping.
Method	`_ignoreAndFinishStopping`	Notify all deferreds waiting on the service stopping, and ignore the Failure passed in.
Method	`_doFinishStopping`	Undocumented
Method	`_noConnection`	Notify the caller that no connection is expected.
Method	`_awaitingConnection`	Return a deferred that will fire with the next connected protocol.
Method	`_deferredSucceededWithNone`	Return a deferred that has already fired with `None`.
Method	`_unawait`	Fire all outstanding `ClientService.whenConnected` `Deferred`s.
Method	`_deliverConnectionFailure`	Deliver connection failures to any `ClientService.whenConnected` `Deferred`s that have met their failAfterFailures threshold.

_awaitingConnected = (source)

notifications to make when connection succeeds, fails, or is cancelled

(type: list of (Deferred, count) tuples)

_machine = (source)

Undocumented

def __init__(self, endpoint, factory, retryPolicy, clock, prepareConnection, log): (source)

Parameters	endpoint	Undocumented
	factory	Undocumented
	retryPolicy	Undocumented
	clock	Undocumented
	prepareConnection	Undocumented
	log	The logger for the `ClientService` instance this state machine is associated to. (type: `Logger`)
See Also	`ClientService.__init__`

_endpoint = (source)

Undocumented

_failedAttempts = (source)

Undocumented

(type: int)

@_machine.state()
def _stopped(self): (source)

The service has been stopped and is disconnected.

_factory = (source)

Undocumented

_timeoutForAttempt = (source)

Undocumented

_clock = (source)

Undocumented

_prepareConnection = (source)

Undocumented

_connectionInProgress = (source)

Undocumented

_stopWaiters = (source)

Undocumented

_log = (source)

Undocumented

@_machine.state(initial=True)
def _init(self): (source)

The service has not been started.

@_machine.state()
def _connecting(self): (source)

The service has started connecting.

@_machine.state()
def _waiting(self): (source)

The service is waiting for the reconnection period before reconnecting.

@_machine.state()
def _connected(self): (source)

The service is connected.

@_machine.state()
def _disconnecting(self): (source)

The service is disconnecting after being asked to shutdown.

@_machine.state()
def _restarting(self): (source)

The service is disconnecting and has been asked to restart.

@_machine.input()
def start(self): (source)

Start this ClientService, initiating the connection retry loop.

@_machine.output()
def _connect(self): (source)

Start a connection attempt.

def _runPrepareConnection(self, protocol): (source)

Run any prepareConnection callback with the connected protocol, ignoring its return value but propagating any failure.

Parameters	protocol	The protocol of the connection. (type: `IProtocol`)
Returns	Either: A `Deferred` that succeeds with the protocol when the `prepareConnection` callback has executed successfully. A `Deferred` that fails when the `prepareConnection` callback throws or returns a failed `Deferred`. The protocol, when no `prepareConnection` callback is defined.

@_machine.output()
def _resetFailedAttempts(self): (source)

Reset the number of failed attempts.

@_machine.input()
def stop(self): (source)

Stop trying to connect and disconnect any current connection.

Returns a Deferred that fires when all outstanding connections are closed and all in-progress connection attempts halted.

@_machine.output()
def _waitForStop(self): (source)

Return a deferred that will fire when the service has finished disconnecting.

Returns Deferred that fires when the service has finished disconnecting.

@_machine.output()
def _stopConnecting(self): (source)

Stop pending connection attempt.

@_machine.output()
def _stopRetrying(self): (source)

Stop pending attempt to reconnect.

@_machine.output()
def _disconnect(self): (source)

Disconnect the current connection.

@_machine.input()
def _connectionMade(self, protocol): (source)

A connection has been made.

Parameters protocol The protocol of the connection. (type: IProtocol)

@_machine.output()
def _notifyWaiters(self, protocol): (source)

Notify all pending requests for a connection that a connection has been made.

Parameters protocol The protocol of the connection. (type: IProtocol)

@_machine.output()
def _currentConnection(self, failAfterFailures=None): (source)

Return the currently connected protocol.

Returns Deferred that is fired with currently connected protocol.

@_machine.input()
def _connectionFailed(self, f): (source)

The current connection attempt failed.

@_machine.output()
def _wait(self): (source)

Schedule a retry attempt.

@_machine.output()
def _ignoreAndWait(self, f): (source)

Schedule a retry attempt, and ignore the Failure passed in.

def _doWait(self): (source)

Undocumented

_retryCall = (source)

Undocumented

@_machine.input()
def _reconnect(self): (source)

The wait between connection attempts is done.

@_machine.input()
def _clientDisconnected(self): (source)

The current connection has been disconnected.

@_machine.output()
def _forgetConnection(self): (source)

Forget the current connection.

@_machine.output()
def _cancelConnectWaiters(self): (source)

Notify all pending requests for a connection that no more connections are expected.

@_machine.output()
def _ignoreAndCancelConnectWaiters(self, f): (source)

Notify all pending requests for a connection that no more connections are expected, after ignoring the Failure passed in.

@_machine.output()
def _finishStopping(self): (source)

Notify all deferreds waiting on the service stopping.

@_machine.output()
def _ignoreAndFinishStopping(self, f): (source)

Notify all deferreds waiting on the service stopping, and ignore the Failure passed in.

def _doFinishStopping(self): (source)

Undocumented

@_machine.input()
def whenConnected(self, failAfterFailures=None): (source)

Retrieve the currently-connected Protocol, or the next one to connect.

Parameters	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: `int` or None)
Returns	a Deferred that fires with a protocol produced by the factory passed to `__init__` (type: `Deferred` that may: fire with `IProtocol` fail with `CancelledError` when the service is stopped fail with e.g. `DNSLookupError` or `ConnectionRefusedError` when the number of consecutive failed connection attempts equals the value of "failAfterFailures" )

@_machine.output()
def _noConnection(self, failAfterFailures=None): (source)

Notify the caller that no connection is expected.

Returns Deferred that is fired with CancelledError.

@_machine.output()
def _awaitingConnection(self, failAfterFailures=None): (source)

Return a deferred that will fire with the next connected protocol.

Returns Deferred that will fire with the next connected protocol.

@_machine.output()
def _deferredSucceededWithNone(self): (source)

Return a deferred that has already fired with None.

Returns A Deferred that has already fired with None.

def _unawait(self, value): (source)

Fire all outstanding ClientService.whenConnected Deferreds.

Parameters value the value to fire the Deferreds with.

@_machine.output()
def _deliverConnectionFailure(self, f): (source)

Deliver connection failures to any ClientService.whenConnected Deferreds that have met their failAfterFailures threshold.

Parameters f the Failure to fire the Deferreds with.

API Documentation for Twisted, generated by pydoctor 21.2.2 at 2021-06-04 02:13:44.