�
�~�e�" � � � d Z ddlZddlZddlmZ ddlmZ G d� de� Z G d� de� Z G d � d
� Z
G d � d � Z G d
� d� Z G d� de � Z
y)zB
Extend the regular Twisted reactor with event-handling features.
� N)�
deferToThread)�
format_objectc � � e Zd ZdZy)� InvalidIDz=Raised when an invalid ID is used with reactor.cancel_call().N��__name__�
__module__� __qualname__�__doc__� � �7/usr/lib/python3/dist-packages/landscape/lib/reactor.pyr r s � �Gr
r c � � e Zd ZdZy)�
CallHookErrorz-Raised when hooking on a reactor incorrectly.Nr r r
r r r s � �7r
r c � � e Zd ZdZd� Zy)�EventIDz�Unique 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 � � || _ || _ y �N)� _event_type�_pair)�self�
event_type�pairs r �__init__zEventID.__init__ s � �%�����
r
N)r r r
r r r r
r r r s � ��r
r c �6 � � e Zd ZdZ� fd�Zdd�Zd� Zd� Z� xZS )�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 �0 �� t �| � � i | _ y r )�superr �_event_handlers)r � __class__s �r r z"EventHandlingReactorMixin.__init__+ s �� �
���� !�� r
c � � ||f}| j j |g � }|j |� |j 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 � � | d S )N� r )r s r �<lambda>z3EventHandlingReactorMixin.call_on.<locals>.<lambda>@ s
� �t�A�w� r
)�key)r �
setdefault�append�sortr )r r �handler�priorityr �handlerss r �call_onz!EventHandlingReactorMixin.call_on/ sN � � ��"���'�'�2�2�:�r�B������ ��
�
�.�
�/��z�4�(�(r
c �
� t j d|� g }t | j j |d� � }|D ]> \ }} t j dt |� ||� |j
||i |��� �@ t j d|� |S # t $ r4 t j dt |� |||� | j � � t $ r% t j dt |� |||� Y ��w xY w)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.) �logging�debug�listr �getr r' �KeyboardInterrupt� exception�stop� Exception)r r �args�kwargs�resultsr+ r) r* s r �firez EventHandlingReactorMixin.fireD s � � �
�
�*�J�7��� ��,�,�0�0��R�@�A��!)� � �G�X�
��
�
�9�!�'�*� � � � ���w�� 7�� 7�8� �< �
�
�+�Z�8����- %�
��!�!�"� "�'�*� ���� � � � �� �
��!�!�5�!�'�*� ���
�
�s �8B�A&D�Dc � � t |� t u r3| j |j j |j
� yt
d|��� �)zfUnregister an event handler.
@param id: the L{EventID} of the handler to unregister.
z$EventID instance expected, received N)�typer r r �remover r �r �ids r � cancel_callz%EventHandlingReactorMixin.cancel_callu sD � �
��8�w� � � � �� � � 0� 7� 7���� A�� B�2�&� I�J� Jr
)r ) r r r
r r r, r9 r? �
__classcell__�r s @r r r ! s �� ��"�)�*/�bKr
r c � � e Zd Zd� Zy)� ReactorIDc � � || _ y r )�_timeout)r �timeouts r r zReactorID.__init__� s � � ��
r
N)r r r
r r r
r rC rC � s � � r
rC c �j � � e Zd ZdZ� fd�Zd� Zd� Zd� Zd� Zd� Z d� Z
d � Z d
� Z d � Z
d � Zd
� Zd� Z� xZS )�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 � �� ddl m} ddlm} || _ || _ | j
� |j | _ t �| �% � y )Nr )�reactor)� LoopingCall)
�twisted.internetrJ �twisted.internet.taskrK � _LoopingCall�_reactor�_cleanup�callFromThreadr r )r rJ rK r s �r r z EventHandlingReactor.__init__� s: �� �,�5� '��� ��
� �
�
�� %� 4� 4���
���r
c �* � t j � S )z5Get current time.
@see L{time.time}
)�time�r s r rS zEventHandlingReactor.time� s � �
�y�y�{�r
c �: � | j j |i |��S )z�Call a function later.
Simply call C{callLater(*args, **kwargs)} and return its result.
@see: L{twisted.internet.interfaces.IReactorTime.callLater}.
)rO � callLater)r r6 r7 s r �
call_laterz EventHandlingReactor.call_later� s � � '�t�}�}�&�&��7��7�7r
c �X � | j |g|��i |��}|j |d�� |S )z�Call a function repeatedly.
Create a new L{twisted.internet.task.LoopingCall} object and
start it.
@return: the created C{LoopingCall} object.
F)�now)rN �start)r �seconds�fr6 r7 �lcs r �
call_everyz EventHandlingReactor.call_every� s5 � � �T�
�
�q�
2�4�
2�6�
2��
����e��$�� r
c �� � t |t � rt j | |� S t || j � r|j � S |j
� r|j � yy)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 r? rN r4 �active�cancelr= s r r? z EventHandlingReactor.cancel_call� sT � � �b�'� "�,�8�8��r�B� B� �b�$�+�+� ,��7�7�9� �
�9�9�;� �I�I�K� r
c �: � | j j |� y)zASchedule a function to be called when the reactor starts running.N)rO �callWhenRunning)r r\ s r �call_when_runningz&EventHandlingReactor.call_when_running� s � � �
�
�%�%�a�(r
c �D � | j j |g|��i |�� y)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)rO rQ )r r\ r6 r7 s r � call_in_mainz!EventHandlingReactor.call_in_main� s" � � %��
�
�$�$�Q�8��8��8r
c �~ ��� �fd�}�fd�}t |g|��i |��}|j |� |j |� y)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 � �� �r �| � S y r r )�result�callbacks �r �
on_successz7EventHandlingReactor.call_in_thread.<locals>.on_success� s �� �� ��'�'� r
c � �� | j | j | j f}�r �|� y t j |d |�� y )Nr# )�exc_info)r; �value�tbr. �error)�failurern �errbacks �r �
on_failurez7EventHandlingReactor.call_in_thread.<locals>.on_failure� s8 �� � � � �g�m�m�W�Z�Z�@�H����"��
�
�h�q�k�H�=r
N)r � addCallback�
addErrback) r rk rs r\ r6 r7 rl rt �deferreds `` r �call_in_threadz#EventHandlingReactor.call_in_thread� s? �� � (� >� !��4�T�4�V�4��� � �Z�(����J�'r
c �> � | j j ||d�� S )z!Start listening on a Unix socket.T)�wantPID)rO �
listenUNIX�r �socket�factorys r � listen_unixz EventHandlingReactor.listen_unix� s � ��}�}�'�'����'�F�Fr
c �: � | j j ||� S )zConnect to a Unix socket.)rO � connectUNIXr| s r � connect_unixz!EventHandlingReactor.connect_unix� s � ��}�}�(�(���9�9r
c �| � | j d� | j j � | j d� y)z2Start the reactor, a C{"run"} event will be fired.�runr4 N)r9 rO r� rT s r r� zEventHandlingReactor.run� s, � �
� � �%�� �
�
���� � � �&�r
c �X � | j j � | j � y)z2Stop the reactor, a C{"stop"} event will be fired.N)rO r4 rP rT s r r4 zEventHandlingReactor.stop� s � � �
�
��� � �
�
�r
c � � | j j � D ]# }|j � s�|j � �% y r )rO �getDelayedCallsra rb )r �calls r rP z EventHandlingReactor._cleanup s2 � � �M�M�1�1�3� �D��{�{�}�� � �
� r
)r r r
r r rS rW r^ r? re rg rx r r� r� r4 rP r@ rA s @r rH rH � sJ �� ����8�
� � )� 9�(�:G�:���
r
rH )r r. rS �twisted.internet.threadsr �landscape.lib.formatr r5 r r r r rC rH r r
r �<module>r� sd ��� � � 2� .�H� � H�8�I� 8�
�
�\K� \K�~ � �
B �4� B r
|