/usr/lib/python3/dist-packages/landscape/lib/__pycache__
Edit: /usr/lib/python3/dist-packages/landscape/lib/__pycache__/amp.cpython-310.pyc (21783B)
o
cT @ s0 d Z ddlmZ ddlmZmZmZ ddlmZm Z ddl
m Z ddl m
Z
ddlmZmZmZmZmZmZmZ ddlmZ G d d
d
eZG d d d eZG d
d deZG dd deZ G dd deZ G dd de Z G dd deZ G dd deZ!G dd de Z"G dd d eZ#G d d d e Z$d S ) a> Expose the methods of a remote object over AMP.
This module implements an AMP-based protocol for performing remote procedure
calls in a convenient and easy way. It's conceptually similar to DBus in that
it supports exposing a Python object to a remote process, with communication
happening over any Twisted-supported transport, e.g. Unix domain sockets.
For example let's say we have a Python process "A" that creates an instance of
this class::
class Greeter(object):
def hello(self, name):
return "hi %s!" % name
greeter = Greeter()
Process A can "publish" the greeter object by defining which methods are
exposed remotely and opening a Unix socket for incoming connections::
factory = MethodCallServerFactory(greeter, ["hello"])
reactor.listenUNIX("/some/socket/path", factory)
Then a second Python process "B" can connect to that socket and build a
"remote" greeter object, i.e. a proxy that forwards method calls to the
real greeter object living in process A::
factory = MethodCallClientFactory()
reactor.connectUNIX("/some/socket/path", factory)
def got_remote(remote_greeter):
deferred = remote_greeter.hello("Ted")
deferred.addCallback(lambda result: ... # result == "hi Ted!")
factory.getRemoteObject().addCallback(got_remote)
Note that when invoking a method via the remote proxy, the parameters
are required to be serializable with bpickle, so they can be sent over
the wire.
See also::
http://twistedmatrix.com/documents/current/core/howto/amp.html
for more details about the Twisted AMP protocol.
)uuid4)Deferred
maybeDeferredsucceed)
ServerFactoryReconnectingClientFactory)Failure)xrange)ArgumentStringIntegerCommandAMPMAX_VALUE_LENGTHCommandLocator)bpicklec @ s, e Zd ZdZdd Zdd Zedd ZdS ) MethodCallArgumentz A bpickle-compatible argument.c C
t |S )zSerialize an argument.)r dumps)selfinObject r 3/usr/lib/python3/dist-packages/landscape/lib/amp.pytoString?
zMethodCallArgument.toStringc C r )zUnserialize an argument.)r loads)r inStringr r r
fromStringC r z MethodCallArgument.fromStringc C s t |tjv S )z%Check if an argument is serializable.)typer dumps_table)clsr r r r checkG s zMethodCallArgument.checkN)__name__
__module__ __qualname____doc__r r classmethodr! r r r r r < s r c @ s e Zd ZdZdS )MethodCallErrorz*Raised when a L{MethodCall} command fails.N)r" r# r$ r% r r r r r' M s r' c @ s@ e Zd ZdZde fde fde fgZde fgZe diZ
dS )
MethodCalla Call a method on the object exposed by a L{MethodCallServerFactory}.
The command arguments have the following semantics:
- C{sequence}: An integer uniquely indentifying a the L{MethodCall}
being issued. The name 'sequence' is a bit misleading because it's
really a uuid, since its values in practice are not in sequential
order, they are just random values. The name is kept just for backward
compatibility.
- C{method}: The name of the method to invoke on the remote object.
- C{arguments}: A BPickled binary tuple of the form C{(args, kwargs)},
where C{args} are the positional arguments to be passed to the method
and C{kwargs} the keyword ones.
sequences methods arguments result METHOD_CALL_ERRORN) r" r# r$ r% r r argumentsr responser' errorsr r r r r( Q s r( c @ s8 e Zd ZdZde fde fgZde fgZediZ dS )MethodCallChunka Send a chunk of L{MethodCall} containing a portion of the arguments.
When a the arguments of a L{MethodCall} are bigger than 64k, they get split
in several L{MethodCallChunk}s that are buffered on the receiver side.
The command arguments have the following semantics:
- C{sequence}: The unique integer associated with the L{MethodCall} that
this L{MethodCallChunk} is part of.
- C{chunk}: A portion of the big BPickle C{arguments} string which is
being split and buffered.
r) s chunkr* r+ N)
r" r# r$ r% r r r, r- r' r. r r r r r/ l s r/ c @ s< e Zd ZdZdd Zejdd Zejdd Z dd Z
d
S ) MethodCallReceiverzExpose methods of a local object over AMP.
@param obj: The Python object to be exposed.
@param methods: The list of the object's methods that can be called
remotely.
c C s t | || _|| _i | _d S N)r __init___object_methods_pending_chunksr objmethodsr r r r2 s
zMethodCallReceiver.__init__c s j |d}|dur|| d|}tj|dd\}}|d}| jvr.td| t j
|} fdd}d d
} t |g|R i |}
|
| |
| |
S ) a Call an object's method with the given arguments.
If a connected client sends a L{MethodCall} for method C{foo_bar}, then
the actual method C{foo_bar} of the object associated with the protocol
will be called with the given C{args} and C{kwargs} and its return
value delivered back to the client as response to the command.
@param sequence: The integer that uniquely identifies the L{MethodCall}
being received.
@param method: The name of the object's method to call.
@param arguments: A bpickle'd binary tuple of (args, kwargs) to be
passed to the method. In case this L{MethodCall} has been preceded
by one or more L{MethodCallChunk}s, C{arguments} is the last chunk
of data.
N T)as_isutf-8zForbidden method '%s'c s d | iS Nresult)
_check_result)r= r r r
handle_result s z=MethodCallReceiver.receive_method_call.
.handle_resultc S s
t | jr1 )r' value)failurer r r handle_failure s
z>MethodCallReceiver.receive_method_call..handle_failure)r5 popappendjoinr r decoder4 r' getattrr3 r addCallback
addErrback) r sequencemethodr, chunksargskwargs method_funcr@ rC deferredr r? r receive_method_call s
z&MethodCallReceiver.receive_method_callc C s | j |g | d|iS )zReceive a part of a multi-chunk L{MethodCall}.
Add the received C{chunk} to the buffer of the L{MethodCall} identified
by C{sequence}.
r= )r5
setdefaultrE )r rK chunkr r r receive_method_call_chunk s z,MethodCallReceiver.receive_method_call_chunkc C s t |s td|S )zCheck that the C{result} we're about to return is serializable.
@return: The C{result} itself if valid.
@raises: L{MethodCallError} if C{result} is not serializable.
zNon-serializable result)r r! r' )r r= r r r r> s
z MethodCallReceiver._check_resultN) r" r# r$ r% r2 r( responderrR r/ rU r> r r r r r0 s
,
r0 c @ s6 e Zd ZdZdZeZdd Zdd Zg i fddZ d S )
MethodCallSendera Call methods on a remote object over L{AMP} and return the result.
@param protocol: A connected C{AMP} protocol.
@param clock: An object implementing the C{IReactorTime} interface.
@ivar timeout: A timeout for remote method class, see L{send_method_call}.
< c C s || _ || _d S r1 ) _protocol_clock)r protocolclockr r r r2 s
zMethodCallSender.__init__c sR t fdd}fdd}| j| j| | jj|fi |}|| S )a Send an L{AMP} command that will errback in case of a timeout.
@return: A deferred resulting in the command's response (or failure) if
the peer responds within C{self.timeout} seconds, or that errbacks
with a L{MethodCallError} otherwise.
c s" sd S | d S r1 )activecancelcallbackr- callrQ r r handle_response s zCMethodCallSender._call_remote_with_timeout..handle_responsec s td d S )Ntimeout)errbackr' r rQ r r handle_timeout s zBMethodCallSender._call_remote_with_timeout..handle_timeout)r rZ callLaterrd rY
callRemoteaddBoth)r commandrO rc rg r= r ra r _call_remote_with_timeout s
z*MethodCallSender._call_remote_with_timeoutc s t ||f t jd fddtdt jD t }tdkrAdd D ]}fdd }| || q0fd
d }| | | d d
|
d |S )a Send a L{MethodCall} command with the given arguments.
If a response from the server is not received within C{self.timeout}
seconds, the returned deferred will errback with a L{MethodCallError}.
@param method: The name of the remote method to invoke.
@param args: The positional arguments to pass to the remote method.
@param kwargs: The keyword arguments to pass to the remote method.
@return: A C{Deferred} firing with the return value of the method
invoked on the remote object. If the remote method itself returns
a deferred, we fire with the callback value of such deferred.
r; c s g | ] } ||j qS r ) _chunk_size).0i)r, r r r
s z5MethodCallSender.send_method_call..r Nc s fdd}|S )Nc s j jt dS )N)rK rT )rY ri r/ )x)rT r rK r r s zNMethodCallSender.send_method_call..create_send_chunk..r )rK rT
send_chunkr? )rT rK r create_send_chunk s z.create_send_chunkc s d }j t|dS )Nrr )rK rL r, )rl r( )ignoredrT )rM rL r rK r r send_last_chunk! s z:MethodCallSender.send_method_call..send_last_chunkc S s | d S r< r r` r r r rt ' s z3MethodCallSender.send_method_call..) r r r intencoder lenrm r rI r_ )r rL rN rO r= rT rv rx r )r, rM rL r rK r send_method_call s
z!MethodCallSender.send_method_callN)
r" r# r$ r% rd r rm r2 rl r| r r r r rW s rW c @ s e Zd ZdZdd ZdS )MethodCallServerProtocolzCReceive L{MethodCall} commands over the wire and send back results.c C s t j| t||d d S )N)locator)r r2 r0 r6 r r r r2 / s z!MethodCallServerProtocol.__init__N)r" r# r$ r% r2 r r r r r} , s r} c @ s e Zd ZdZdZdd ZdS )MethodCallClientProtocolzASend L{MethodCall} commands over the wire using the AMP protocol.Nc C s | j dur
| j | dS dS )z*Notify our factory that we're ready to go.N)factoryclientConnectionMader? r r r connectionMade8 s
z'MethodCallClientProtocol.connectionMade)r" r# r$ r% r r r r r r r 3 s r c @ sP e Zd ZdZdd Zdd ZdddZdd d
Z dd d Zd
d Z dd Z
dS ) RemoteObjecta An object able to transparently call methods on a remote object.
Any method call on a L{RemoteObject} instance will return a L{Deferred}
resulting in the return value of the same method call performed on
the remote object exposed by the peer.
c C s$ d| _ i | _|| _| j| j dS )z
@param factory: The L{MethodCallClientFactory} used for connecting to
the other peer. Look there if you need to tweak the behavior of
this L{RemoteObject}.
N)_sender_pending_requests_factorynotifyOnConnect_handle_connect)r r r r r r2 F s zRemoteObject.__init__c s fdd}|S )a^ Return a function sending a L{MethodCall} for the given C{method}.
When the created function is called, it sends the an appropriate
L{MethodCall} to the remote peer passing it the arguments and
keyword arguments it was called with, and returning a L{Deferred}
resulting in the L{MethodCall}'s response value.
c s t } | || |S r1 )r _send_method_call)rN rO rQ rL r r r r| Y s z2RemoteObject.__getattr__..send_method_callr )r rL r| r r r __getattr__Q s zRemoteObject.__getattr__Nc C s\ | j j|||d}|j| j||d |j| j|||||d | jjdur,| jj dS dS )zASend a L{MethodCall} command, adding callbacks to handle retries.)rL rN rO rb N) r r| rI _handle_resultrJ _handle_failurer fake_connectionflush)r rL rN rO rQ rb r= r r r r ` s z RemoteObject._send_method_callc C s |dur| || dS )a& Handles a successful C{send_method_call} result.
@param response: The L{MethodCall} response.
@param deferred: The deferred that was returned to the caller.
@param call: If not C{None}, the scheduled timeout call associated with
the given deferred.
N)r^ r_ )r r= rQ rb r r r r p s zRemoteObject._handle_resultc
C s |j tu }| jjdu }|s|r'|| jv r| j| |r | || dS | jjrF|du rFt td} | jj
j | jj| j | ||||d}||||f| j|< dS )a+ Called when a L{MethodCall} command fails.
If a failure is due to a connection error and if C{retry_on_reconnect}
is C{True}, we will try to perform the requested L{MethodCall} again
as soon as a new connection becomes available, giving up after the
specified C{timeout}, if any.
@param failure: The L{Failure} raised by the requested L{MethodCall}.
@param name: The method name associated with the failed L{MethodCall}.
@param args: The positional arguments of the failed L{MethodCall}.
@param kwargs: The keyword arguments of the failed L{MethodCall}.
@param deferred: The deferred that was returned to the caller.
@param call: If not C{None}, the scheduled timeout call associated with
the given deferred.
FNrd rf )
r r' r retryOnReconnectr rD r^ re retryTimeoutr r\ rh r )
r rB rL rN rO rQ rb is_method_call_error
dont_retryrd r r r r | s"
z RemoteObject._handle_failurec C s( t || jj| _| jjr| dS dS )zaHandles a reconnection.
@param protocol: The newly connected protocol instance.
N)rW r r\ r r _retry)r r[ r r r r s z RemoteObject._handle_connectc C sL | j }| j |r$| \}\}}}}| j|||||d |s dS dS )z*Try to perform again requests that failed.r N)r copyclearpopitemr )r requestsrQ rL rN rO rb r r r r s
zRemoteObject._retryr1 ) r" r# r$ r% r2 r r r r r r r r r r r > s
+ r c @ s$ e Zd ZdZeZdd Zdd ZdS )MethodCallServerFactoryz@Expose a Python object using L{MethodCall} commands over C{AMP}.c C s || _ || _dS )a
@param object: The object exposed by the L{MethodCallProtocol}s
instances created by this factory.
@param methods: A list of the names of the methods that remote peers
are allowed to call on the C{object} that we publish.
N)objectr8 r6 r r r r2 s
z MethodCallServerFactory.__init__c C s | | j| j}| |_|S r1 )r[ r r8 r r addrr[ r r r
buildProtocol s z%MethodCallServerFactory.buildProtocolN)r" r# r$ r% r} r[ r2 r r r r r r s
r c @ sl e Zd ZdZdZdZeZeZ dZ
dZ dZ dd Z
dd Zd
d Zd d
Zdd Zdd Zdd Zdd ZdS )MethodCallClientFactorya
Factory for L{MethodCallClientProtocol}s exposing an object or connecting
to L{MethodCall} servers.
When used to connect, if the connection fails or is lost the factory
will keep retrying to establish it.
@ivar factor: The time factor by which the delay between two subsequent
connection retries will increase.
@ivar maxDelay: Maximum number of seconds between connection attempts.
@ivar protocol: The factory used to build protocol instances.
@ivar remote: The factory used to build remote object instances.
@ivar retryOnReconnect: If C{True}, the remote object returned by the
C{getRemoteObject} method will retry requests that failed, as a
result of a lost connection, as soon as a new connection is available.
@param retryTimeout: A timeout for retrying requests, if the remote object
can't perform them again successfully within this number of seconds,
they will errback with a L{MethodCallError}.
gw? FNc C s$ || _ | j| _g | _g | _d| _dS )z
@param object: The object exposed by the L{MethodCallProtocol}s
instances created by this factory.
@param reactor: The reactor used by the created protocols
to schedule notifications and timeouts.
N)r\ initialDelaydelay _connects _requests_remote)r r\ r r r r2 s
z MethodCallClientFactory.__init__c C s* | j dur
t| j S t }| j| |S )zGet a L{RemoteObject} as soon as the connection is ready.
@return: A C{Deferred} firing with a connected L{RemoteObject}.
N)r r r r rE )r rQ r r r getRemoteObject s
z'MethodCallClientFactory.getRemoteObjectc C | j | dS )zAInvoke the given C{callback} when a connection is re-established.N)r rE r r_ r r r r z'MethodCallClientFactory.notifyOnConnectc C r )z,Remove the given C{callback} from listeners.N)r remover r r r dontNotifyOnConnect r z+MethodCallClientFactory.dontNotifyOnConnectc C s: | j du r | | | _ | jD ]}|| q| | j dS )z2Called when a newly built protocol gets connected.N)r remoter _fire_requests)r r[ r_ r r r r s
z,MethodCallClientFactory.clientConnectionMadec C s* t | || | jdu r| | dS dS )z0Try to connect again or errback pending request.N)r clientConnectionFailed_callIDr )r connectorreasonr r r r $ s
z.MethodCallClientFactory.clientConnectionFailedc C s | t| |}|S r1 )
resetDelayr r r r r r r , s z%MethodCallClientFactory.buildProtocolc C s, | j dd }g | _ |D ]}|| q dS )zY
Fire all pending L{getRemoteObject} deferreds with the given C{result}.
N)r r_ )r r= r rQ r r r r 1 s
z&MethodCallClientFactory._fire_requests)r" r# r$ r% factormaxDelayr r[ r r r r r r2 r r r r r r r r r r r r s"
r N)%r% uuidr twisted.internet.deferr r r twisted.internet.protocolr r twisted.python.failurer twisted.python.compatr twisted.protocols.ampr
r r r
r r r
landscape.libr r Exceptionr' r( r/ r0 r rW r} r r r r r r r r s( . $ PY