/usr/lib/python3/dist-packages/landscape/lib/__pycache__
Edit: /usr/lib/python3/dist-packages/landscape/lib/__pycache__/reactor.cpython-310.pyc (10108B)
o
cl" @ s d Z ddlmZ ddlZddlZddlmZ ddlmZ G dd de Z
G dd d e Z G d
d d e Z
G d d
d
e ZG dd de ZG dd deZdS )zB
Extend the regular Twisted reactor with event-handling features.
)absolute_importN)
deferToThread)
format_objectc @ e Zd ZdZdS ) InvalidIDz=Raised when an invalid ID is used with reactor.cancel_call().N__name__
__module__ __qualname____doc__ r r 7/usr/lib/python3/dist-packages/landscape/lib/reactor.pyr r c @ r )
CallHookErrorz-Raised when hooking on a reactor incorrectly.Nr r r r r
r r r c @ s e Zd ZdZdd ZdS )EventIDzUnique identifier for an event handler.
@param event_type: Name of the event type handled by the handler.
@param pair: Binary tuple C{(handler, priority)} holding the handler
function and its priority.
c C s || _ || _d S N) _event_type_pair)self
event_typepairr r r
__init__ s
zEventID.__init__N)r r r
r r r r r r
r s r c s: e Zd ZdZ fddZd ddZdd Zd d
Z ZS ) EventHandlingReactorMixina Fire events identified by strings and register handlers for them.
Note that event handlers are executed synchronously when the C{fire} method
is called, so unit-tests can generally exercise events without needing to
run the real Twisted reactor (except of course if the event handlers
themselves contain asynchronous calls that need the Twisted reactor
running).
c s t t| i | _d S r )superr r _event_handlersr __class__r r
r - s
z"EventHandlingReactorMixin.__init__r c C s: ||f}| j |g }|| |jdd d t||S )a Register an event handler.
The handler will be invoked every time an event of the given type
is fired (there's no need to re-register the handler after the
event is fired).
@param event_type: The name of the event type to handle.
@param handler: The function handling the given event type.
@param priority: The priority of the given handler function.
@return: The L{EventID} of the registered handler.
c S s | d S )N r )r r r r
B s z3EventHandlingReactorMixin.call_on..)key)r
setdefaultappendsortr )r r handlerpriorityr handlersr r r
call_on1 s
z!EventHandlingReactorMixin.call_onc O s t d| g }t| j|d}|D ]D\}}zt dt||| |||i | W q tyD t dt|||| | t
yW t dt|||| Y qw t d| |S )ac Fire an event of a given type.
Call all handlers registered for the given C{event_type}, in order
of priority.
@param event_type: The name of the event type to fire.
@param args: Positional arguments to pass to the registered handlers.
@param kwargs: Keyword arguments to pass to the registered handlers.
zStarted firing %s.r z#Calling %s for %s with priority %d.zTKeyboard interrupt while running event handler %s for event type %r with args %r %r.zAError running event handler %s for event type %r with args %r %r.zFinished firing %s.) loggingdebuglistr getr r" KeyboardInterrupt exceptionstop Exception)r r argskwargsresultsr& r$ r% r r r
fireF s0
z EventHandlingReactorMixin.firec C s0 t |tu r| j|j |j dS td| )zfUnregister an event handler.
@param id: the L{EventID} of the handler to unregister.
z&EventID instance expected, received %rN)typer r r remover r r idr r r
cancel_callj s z%EventHandlingReactorMixin.cancel_call)r ) r r r
r r r' r3 r8
__classcell__r r r r
r # s
$r c @ s e Zd Zdd ZdS ) ReactorIDc C s
|| _ d S r )_timeout)r timeoutr r r
r w s
zReactorID.__init__N)r r r
r r r r r
r: u s r: c s e Zd ZdZ fddZdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd Zdd Z ZS ) EventHandlingReactora Wrap and add functionalities to the Twisted reactor.
This is essentially a facade around the twisted.internet.reactor and
will delegate to it for mostly everything except event handling features
which are implemented using EventHandlingReactorMixin.
c sF ddl m} ddlm} || _|| _| |j| _tt |
d S )Nr )reactor) LoopingCall) twisted.internetr> twisted.internet.taskr? _LoopingCall_reactor_cleanupcallFromThreadr r= r )r r> r? r r r
r s z EventHandlingReactor.__init__c C s t S )z5Get current time.
@see L{time.time}
)timer r r r
rF s zEventHandlingReactor.timec O s | j j|i |S )zCall a function later.
Simply call C{callLater(*args, **kwargs)} and return its result.
@see: L{twisted.internet.interfaces.IReactorTime.callLater}.
)rC callLater)r r0 r1 r r r
call_later s z EventHandlingReactor.call_laterc O s* | j |g|R i |}|j|dd |S )zCall a function repeatedly.
Create a new L{twisted.internet.task.LoopingCall} object and
start it.
@return: the created C{LoopingCall} object.
F)now)rB start)r secondsfr0 r1 lcr r r
call_every s z EventHandlingReactor.call_everyc C sB t |tr t| |S t || jr| S | r | dS dS )a Cancel a scheduled function or event handler.
@param id: The function call or handler to remove. It can be an
L{EventID}, a L{LoopingCall} or a C{IDelayedCall}, as returned
by L{call_on}, L{call_every} and L{call_later} respectively.
N)
isinstancer r r8 rB r. activecancelr6 r r r
r8 s
z EventHandlingReactor.cancel_callc C s | j | dS )zASchedule a function to be called when the reactor starts running.N)rC callWhenRunning)r rL r r r
call_when_running s z&EventHandlingReactor.call_when_runningc O s | j j|g|R i | dS )a1 Cause a function to be executed by the reactor thread.
@param f: The callable object to execute.
@param args: The arguments to call it with.
@param kwargs: The keyword arguments to call it with.
@see: L{twisted.internet.interfaces.IReactorThreads.callFromThread}
N)rC rE )r rL r0 r1 r r r
call_in_main s z!EventHandlingReactor.call_in_mainc sF fdd}fdd}t |g|R i |}|| || dS )a
Execute a callable object in a new separate thread.
@param callback: A function to call in case C{f} was successful, it
will be passed the return value of C{f}.
@param errback: A function to call in case C{f} raised an exception,
it will be pass a C{(type, value, traceback)} tuple giving
information about the raised exception (see L{sys.exc_info}).
@note: Both C{callback} and C{errback} will be executed in the
the parent thread.
c s r | S d S r r )result)callbackr r
on_success s z7EventHandlingReactor.call_in_thread..on_successc s6 | j | j| jf} r | d S tj|d |d d S )Nr )exc_info)r4 valuetbr( error)failurerX )errbackr r
on_failure s z7EventHandlingReactor.call_in_thread..on_failureN)r addCallback
addErrback) r rV r] rL r0 r1 rW r^ deferredr )rV r] r
call_in_thread s
z#EventHandlingReactor.call_in_threadc C s | j j||ddS )z!Start listening on a Unix socket.T)wantPID)rC
listenUNIXr socketfactoryr r r
listen_unix s z EventHandlingReactor.listen_unixc C s | j ||S )zConnect to a Unix socket.)rC connectUNIXre r r r
connect_unix s z!EventHandlingReactor.connect_unixc C s" | d | j | d dS )z2Start the reactor, a C{"run"} event will be fired.runr. N)r3 rC rk r r r r
rk s
zEventHandlingReactor.runc C s | j | dS )z2Stop the reactor, a C{"stop"} event will be fired.N)rC r. rD r r r r
r. s
zEventHandlingReactor.stopc C s$ | j D ]
}| r| qd S r )rC getDelayedCallsrP rQ )r callr r r
rD s
z EventHandlingReactor._cleanup)r r r
r r rF rH rN r8 rS rT rb rh rj rk r. rD r9 r r r r
r= { s
r= )r
__future__r r( rF twisted.internet.threadsr landscape.lib.formatr r/ r r objectr r r: r= r r r r
s
R