o

�
b<8�@s|
dZd
dl
Z
d
dlZd
dlmZ
d
dlmZ
d
dlmZm	Z	
dZ
dZdZd	Z
d
ZdZdZd
ZdZdZdZdZdZdZdZdZdZdZdZdZe
eBZeeBZeeBZ eeBeBeBeBeBeBeBeBZ!e
dfedfedfe
dfedfedfed fed!fed"fed#fed$fed%fed&fed'fed(fed)fed*fed+fed,fed-fgZ"d.d/�Z#Gd0d1�d1�Z$Gd2d3�d3e�Z%ej&Z&gd4�
Z'dS)5a
This module provides support for Twisted to linux inotify API.

In order to use this support, simply do the following (and start a reactor
at some point)::

    from twisted.internet import inotify
    from twisted.python import filepath

    def notify(ignored, filepath, mask):
        """
        For historical reasons, an opaque handle is passed as first
        parameter. This object should never be used.

        @param filepath: FilePath on which the event happened.
        @param mask: inotify event as hexadecimal masks
        """
        print("event %s on %s" % (
            ', '.join(inotify.humanReadableMask(mask)), filepath))

    notifier = inotify.INotify()
    notifier.startReading()
    notifier.watch(filepath.FilePath("/some/directory"), callbacks=[notify])
    notifier.watch(filepath.FilePath(b"/some/directory2"), callbacks=[notify])

Note that in the above example, a L{FilePath} which is a L{bytes} path name
or L{str} path name may be used.  However, no matter what type of
L{FilePath} is passed to this module, internally the L{FilePath} is
converted to L{bytes} according to L{sys.getfilesystemencoding}.
For any L{FilePath} returned by this module, the caller is responsible for
converting from a L{bytes} path name to a L{str} path name.

@since: 10.1
�N)
�fdesc)
�FileDescriptor)�_inotify�log�
����� �@��
iiii i@i�i
ii i@l�access�modify�attrib�close_write�
close_nowrite�open�
moved_from�moved_to�create�delete�delete_self�	move_self�unmount�queue_overflow�ignored�only_dir�dont_follow�mask_add�is_dir�one_shotc
Cs(g}
tD]
\}}||@r|
�
|�

q|
S)
zh
    Auxiliary function that converts a hexadecimal mask into a series
    of human readable flags.
    )�_FLAG_TO_HUMAN�append)�mask�
s�
k�
v�r)�:/usr/lib/python3/dist-packages/twisted/internet/inotify.py�humanReadableMaskqs



�
r+c@s(eZ
dZd
Zeddfdd�
Zdd�ZdS)�_Watcha�

    Watch object that represents a Watch point in the filesystem. The
    user should let INotify to create these objects

    @ivar path: The path over which this watch point is monitoring
    @ivar mask: The events monitored by this watchpoint
    @ivar autoAdd: Flag that determines whether this watch point
        should automatically add created subdirectories
    @ivar callbacks: L{list} of callback functions that will be called
        when an event occurs on this watch.
    FNcCs,|
��|_
||_||_|durg}||_dS�
N)�asBytesMode�pathr%�autoAdd�	callbacks)�selfr/r%r0r1r)r)r*�__init__�s







z_Watch.__init__cCs$|
��}
|j
D]}|||
|�
qd
S)zL
        Callback function used by L{INotify} to dispatch an event.
        N)r.r1)r2�filepath�events�callbackr)r)r*�_notify�s


�z_Watch._notify)�__name__�
__module__�__qualname__�__doc__�
IN_WATCH_MASKr3r7r)r)r)r*r,}s
r,c@sxeZ
dZd
ZeZddd�
Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dd�Zdd�Ze
dddfdd�
Zdd�Zdd�ZdS)�INotifya�

    The INotify file descriptor, it basically does everything related
    to INotify, from reading to notifying watch points.

    @ivar _buffer: a L{bytes} containing the data read from the inotify fd.

    @ivar _watchpoints: a L{dict} that maps from inotify watch ids to
        watchpoints objects

    @ivar _watchpaths: a L{dict} that maps from watched paths to the
        inotify watch ids
    NcCsTtj
||
d
�
|j��|_t�|j�

t�|j�

d|_d|_	d|_
i|_i|_dS)N)
�reactorrT�)
rr3r�init�_fdr�setNonBlocking�_setCloseOnExec�	connected�_writeDisconnected�_buffer�_watchpoints�_watchpaths)r2r>r)r)r*r3�s





zINotify.__init__cCs@|
��}
|j
�|j|
|�}t|
|||�}||j|<||j|
<|S)
a~

        Private helper that abstracts the use of ctypes.

        Calls the internal inotify API and checks for any errors after the
        call. If there's an error L{INotify._addWatch} can raise an
        INotifyError. If there's no error it proceeds creating a watchpoint and
        adding a watchpath for inverse lookup of the file descriptor from the
        path.
        )r.r�addrAr,rGrH)r2r/r%r0r1�wd�iwpr)r)r*�	_addWatch�s




zINotify._addWatchcCs.|j�
|j|
�
|j�|
�
}|j�|j�

d
S)a

        Private helper that abstracts the use of ctypes.

        Calls the internal inotify API to remove an fd from inotify then
        removes the corresponding watchpoint from the internal mapping together
        with the file descriptor from the watchpath.
        N)r�removerArG�poprHr/)r2rJrKr)r)r*�_rmWatch�s

zINotify._rmWatchc
Cs`t�
||
�
|jd
kr.z	t�|j�

WdSty-
}
z
t�|d�
WYd}~dSd}~w
wdS)zR
        Release the inotify file descriptor and do the necessary cleanup
        r
z'Couldn't close INotify file descriptor.N)r�connectionLostrA�os�close�OSErrorr�err)r2�reason�
er)r)r*rP�s





���zINotify.connectionLostc


Cs|jS)
z�
        Get the underlying file descriptor from this inotify observer.
        Required by L{abstract.FileDescriptor} subclasses.
        )
rA�
r2r)r)r*�fileno�szINotify.filenoc

Cst�
|j|j�
d
S)zC
        Read some data from the observed file descriptors
        N)r�
readFromFDrA�_doReadrWr)r)r*�doRead�szINotify.doReadc
Cs*
|j|
7_t
|j�
d
kr�t�d|jdd
��\}}}}|r,|jd
d
|��d�
}nd}|jd
|d�|_z|j|}Wn	tyH


Yqw|j��}|rU|�	|�
}|�
||�
|jr}|t@r}|t
@r}|j||jd|jd�}	|j�d|j|j|	�
|t@r�|�|�

|��
t
|j�
d
ksdSdS)zF
        Work on the data just read from the file descriptor.
        r
z=LLLLr
�
NT�r%r0r1)rF�len�struct�unpack�rstriprG�KeyErrorr/r.�childr7r0�IN_ISDIR�	IN_CREATE�watchr%r1r>�	callLater�_addChildren�IN_DELETE_SELFrO�loseConnection)
r2�in_rJr%�cookie�size�namerKr/�new_wdr)r)r*rZ�s2




�





�	



�zINotify._doReadcCs�z|
j�
�}Wn
ty


Yd
Sw|D]1}|��r9|j||
jd|
jd�}|
�|tt	B�
|j
�d|j|j
|�
|��rE|
�|t	tB�
qd
S)a�

        This is a very private method, please don't even think about using it.

        Note that this is a fricking hack... it's because we cannot be fast
        enough in adding a watch to a directory and so we basically end up
        getting here too late if some operations have already been going on in
        the subdir, we basically need to catchup.  This eventually ends up
        meaning that we generate double events, your app must be resistant.
        NTr]r
)r/�childrenrS�isdirrfr%r1r7rdrer>rgrhrG�isfile�IN_CLOSE_WRITE)r2rK�listdir�
frJr)r)r*rh$
s


�	


��zINotify._addChildrenFcCs\|r|
��D]}|�
�r|j||||d
d�
qdS|�|
�
}|r"|S|tB}|�|
|||�S)aL
        Watch the 'mask' events in given path. Can raise C{INotifyError} when
        there's a problem while adding a directory.

        @param path: The path needing monitoring
        @type path: L{FilePath}

        @param mask: The events that should be watched
        @type mask: L{int}

        @param autoAdd: if True automatically add newly created
                        subdirectories
        @type autoAdd: L{bool}

        @param callbacks: A list of callbacks that should be called
                          when an event happens in the given path.
                          The callback should accept 3 arguments:
                          (ignored, filepath, mask)
        @type callbacks: L{list} of callables

        @param recursive: Also add all the subdirectories in this path
        @type recursive: L{bool}
        F)
�	recursiveN)�walkrqrf�
_isWatchedrirL)r2r/r%r0r1rvrcrJr)r)r*rfF
s

��


z
INotify.watchcCs6|
��}
|�
|
�
}|d
urt|
�d��
�
|�|�

d
S)z�
        Remove the watch point monitoring the given path

        @param path: The path that should be ignored
        @type path: L{FilePath}
        Nz is not watched)r.rxrbrO)r2r/rJr)r)r*�ignores
s




zINotify.ignorecCs|
��}
|j
�|
d
�S)z�
        Helper function that checks if the path is already monitored
        and returns its watchdescriptor if so or None otherwise.

        @param path: The path that should be checked
        @type path: L{FilePath}
        N)r.rH�get)r2r/r)r)r*rx�
s
zINotify._isWatchedr-)r8r9r:r;rr3rLrOrPrXr[rZrhr<rfryrxr)r)r)r*r=�s

,#
�-r=)r=r+r<�	IN_ACCESS�	IN_MODIFY�	IN_ATTRIB�IN_CLOSE_NOWRITErs�IN_OPEN�
IN_MOVED_FROM�IN_MOVED_TOre�	IN_DELETEri�IN_MOVE_SELF�
IN_UNMOUNT�
IN_Q_OVERFLOW�
IN_IGNORED�
IN_ONLYDIR�IN_DONT_FOLLOW�IN_MASK_ADDrd�
IN_ONESHOT�IN_CLOSE�IN_MOVED�
IN_CHANGED)(r;rQr_�twisted.internetr�twisted.internet.abstractr�twisted.pythonrrr{r|r}rsr~rr�r�rer�rir�r�r�r�r�r�r�rdr�r�r�r�r<r#r+r,r=�INotifyError�__all__r)r)r)r*�<module>
s�$























���������


















�s