From 9a413c1d5dd497b3dab0cc09865d53ccf79566db Mon Sep 17 00:00:00 2001 From: Sebastien Martini Date: Thu, 4 Jun 2015 17:59:20 +0200 Subject: API documentation version 0.9.6 --- api-objects.txt | 17 +- class-tree.html | 8 +- help.html | 2 +- identifier-index.html | 118 +- module-tree.html | 2 +- pyinotify-module.html | 14 +- pyinotify-pysrc.html | 4403 ++++++++++---------- pyinotify.AsyncNotifier-class.html | 11 +- pyinotify.AsyncioNotifier-class.html | 5 +- pyinotify.ChainIfTrue-class.html | 2 +- pyinotify.ColoredOutputFormat-class.html | 2 +- pyinotify.Event-class.html | 2 +- pyinotify.EventsCodes-class.html | 2 +- pyinotify.ExcludeFilter-class.html | 2 +- pyinotify.INotifyWrapper-class.html | 2 +- pyinotify.InotifyBindingNotFoundError-class.html | 2 +- pyinotify.Notifier-class.html | 44 +- pyinotify.NotifierError-class.html | 2 +- pyinotify.PrintAllEvents-class.html | 2 +- pyinotify.ProcINotify-class.html | 429 ++ pyinotify.ProcessEvent-class.html | 32 +- pyinotify.ProcessEventError-class.html | 6 +- pyinotify.PyinotifyError-class.html | 46 +- pyinotify.RawOutputFormat-class.html | 6 +- pyinotify.Stats-class.html | 6 +- pyinotify.SysCtlINotify-class.html | 527 --- pyinotify.ThreadedNotifier-class.html | 24 +- pyinotify.TornadoAsyncNotifier-class.html | 5 +- pyinotify.UnsupportedPythonVersionError-class.html | 2 +- pyinotify.Watch-class.html | 2 +- pyinotify.WatchManager-class.html | 8 +- pyinotify.WatchManagerError-class.html | 2 +- pyinotify._CtypesLibcINotifyWrapper-class.html | 19 +- pyinotify._Event-class.html | 2 +- pyinotify._INotifySyscallsWrapper-class.html | 2 +- pyinotify._ProcessEvent-class.html | 32 +- pyinotify._RawEvent-class.html | 2 +- pyinotify._SysProcessEvent-class.html | 2 +- redirect.html | 2 +- toc-everything.html | 6 +- toc-pyinotify-module.html | 6 +- uml_class_diagram_for_pyinotif_11.gif | Bin 14214 -> 13999 bytes uml_class_diagram_for_pyinotif_14.gif | Bin 11199 -> 3108 bytes uml_class_diagram_for_pyinotif_15.gif | Bin 10612 -> 11180 bytes uml_class_diagram_for_pyinotif_16.gif | Bin 15275 -> 10612 bytes uml_class_diagram_for_pyinotif_17.gif | Bin 6634 -> 15375 bytes uml_class_diagram_for_pyinotif_18.gif | Bin 9512 -> 6634 bytes uml_class_diagram_for_pyinotif_19.gif | Bin 4578 -> 9512 bytes uml_class_diagram_for_pyinotif_24.gif | Bin 15628 -> 15562 bytes uml_class_diagram_for_pyinotif_30.gif | Bin 7864 -> 7556 bytes uml_class_diagram_for_pyinotif_31.gif | Bin 6388 -> 6362 bytes 51 files changed, 2829 insertions(+), 2981 deletions(-) create mode 100644 pyinotify.ProcINotify-class.html delete mode 100644 pyinotify.SysCtlINotify-class.html diff --git a/api-objects.txt b/api-objects.txt index 30073bd..ccde0ab 100644 --- a/api-objects.txt +++ b/api-objects.txt @@ -6,6 +6,7 @@ pyinotify.max_queued_events pyinotify-module.html#max_queued_events pyinotify.IN_ONESHOT pyinotify-module.html#IN_ONESHOT pyinotify.COMPATIBILITY_MODE pyinotify-module.html#COMPATIBILITY_MODE pyinotify.IN_DELETE pyinotify-module.html#IN_DELETE +pyinotify.inotify_syscalls pyinotify-module.html#inotify_syscalls pyinotify.IN_CLOSE_WRITE pyinotify-module.html#IN_CLOSE_WRITE pyinotify.name pyinotify-module.html#name pyinotify.logger_init pyinotify-module.html#logger_init @@ -36,7 +37,6 @@ pyinotify.IN_ATTRIB pyinotify-module.html#IN_ATTRIB pyinotify.IN_ACCESS pyinotify-module.html#IN_ACCESS pyinotify.flagc pyinotify-module.html#flagc pyinotify.IN_MASK_ADD pyinotify-module.html#IN_MASK_ADD -pyinotify.inotify_syscalls pyinotify-module.html#inotify_syscalls pyinotify.IN_DELETE_SELF pyinotify-module.html#IN_DELETE_SELF pyinotify.AsyncNotifier pyinotify.AsyncNotifier-class.html pyinotify.Notifier.proc_fun pyinotify.Notifier-class.html#proc_fun @@ -149,6 +149,12 @@ pyinotify._ProcessEvent.__repr__ pyinotify._ProcessEvent-class.html#__repr__ pyinotify.PrintAllEvents.process_default pyinotify.PrintAllEvents-class.html#process_default pyinotify.ProcessEvent.__call__ pyinotify.ProcessEvent-class.html#__call__ pyinotify.ProcessEvent.__init__ pyinotify.ProcessEvent-class.html#__init__ +pyinotify.ProcINotify pyinotify.ProcINotify-class.html +pyinotify.ProcINotify.set_val pyinotify.ProcINotify-class.html#set_val +pyinotify.ProcINotify.value pyinotify.ProcINotify-class.html#value +pyinotify.ProcINotify.get_val pyinotify.ProcINotify-class.html#get_val +pyinotify.ProcINotify.__repr__ pyinotify.ProcINotify-class.html#__repr__ +pyinotify.ProcINotify.__init__ pyinotify.ProcINotify-class.html#__init__ pyinotify.ProcessEvent pyinotify.ProcessEvent-class.html pyinotify.ProcessEvent.my_init pyinotify.ProcessEvent-class.html#my_init pyinotify.ProcessEvent.nested_pevent pyinotify.ProcessEvent-class.html#nested_pevent @@ -180,14 +186,6 @@ pyinotify.ProcessEvent.__call__ pyinotify.ProcessEvent-class.html#__call__ pyinotify.ProcessEvent.nested_pevent pyinotify.ProcessEvent-class.html#nested_pevent pyinotify.Stats.process_default pyinotify.Stats-class.html#process_default pyinotify.Stats.__repr__ pyinotify.Stats-class.html#__repr__ -pyinotify.SysCtlINotify pyinotify.SysCtlINotify-class.html -pyinotify.SysCtlINotify.create pyinotify.SysCtlINotify-class.html#create -pyinotify.SysCtlINotify.set_val pyinotify.SysCtlINotify-class.html#set_val -pyinotify.SysCtlINotify.value pyinotify.SysCtlINotify-class.html#value -pyinotify.SysCtlINotify.get_val pyinotify.SysCtlINotify-class.html#get_val -pyinotify.SysCtlINotify.__repr__ pyinotify.SysCtlINotify-class.html#__repr__ -pyinotify.SysCtlINotify.inotify_attrs pyinotify.SysCtlINotify-class.html#inotify_attrs -pyinotify.SysCtlINotify.__init__ pyinotify.SysCtlINotify-class.html#__init__ pyinotify.ThreadedNotifier pyinotify.ThreadedNotifier-class.html pyinotify.Notifier.read_events pyinotify.Notifier-class.html#read_events pyinotify.Notifier.check_events pyinotify.Notifier-class.html#check_events @@ -257,7 +255,6 @@ pyinotify.INotifyWrapper.get_errno pyinotify.INotifyWrapper-class.html#get_errno pyinotify._CtypesLibcINotifyWrapper.init pyinotify._CtypesLibcINotifyWrapper-class.html#init pyinotify._CtypesLibcINotifyWrapper._inotify_add_watch pyinotify._CtypesLibcINotifyWrapper-class.html#_inotify_add_watch pyinotify.INotifyWrapper.inotify_rm_watch pyinotify.INotifyWrapper-class.html#inotify_rm_watch -pyinotify._CtypesLibcINotifyWrapper._sysctl pyinotify._CtypesLibcINotifyWrapper-class.html#_sysctl pyinotify._CtypesLibcINotifyWrapper._inotify_rm_watch pyinotify._CtypesLibcINotifyWrapper-class.html#_inotify_rm_watch pyinotify.INotifyWrapper.inotify_add_watch pyinotify.INotifyWrapper-class.html#inotify_add_watch pyinotify._CtypesLibcINotifyWrapper._inotify_init pyinotify._CtypesLibcINotifyWrapper-class.html#_inotify_init diff --git a/class-tree.html b/class-tree.html index d422c03..5286f9e 100644 --- a/class-tree.html +++ b/class-tree.html @@ -135,6 +135,9 @@ +
  • pyinotify.ProcINotify: + Access (read, write) inotify's variables through /proc/sys/. +
  • pyinotify.RawOutputFormat: Format string representations.
    • -
  • pyinotify.SysCtlINotify: - Access (read, write) inotify's variables through sysctl. -
  • pyinotify.Watch: Represent a watch, i.e.
    • @@ -232,7 +232,7 @@ @@ -217,8 +216,8 @@ - + @@ -250,45 +249,53 @@ - + - - + - - - + - - + + + + + + - @@ -296,7 +303,7 @@ (in INotifyWrapper) - @@ -304,7 +311,7 @@ (in pyinotify) - @@ -312,27 +319,13 @@ (in pyinotify) - - - - - - - - - - -
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:52 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015 - +
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:52 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015 (in _SysProcessEvent) command_line()
    (in pyinotify)    		create()
    -(in SysCtlINotify)    		 
    get_fd()
    (in WatchManager)    		get_val()
    -(in SysCtlINotify)    		get_val()
    +(in ProcINotify)    		  
    ignore_events
    (in WatchManager)    		IN_ISDIR
    +    		IN_IGNORED
    +(in pyinotify)    		IN_Q_OVERFLOW
    (in pyinotify)    		init()
    -(in _CtypesLibcINotifyWrapper)
    IN_ACCESS
    (in pyinotify)    		IN_MASK_ADD
    +    		IN_ISDIR
    +(in pyinotify)    		IN_UNMOUNT
    (in pyinotify)    		init()
    -(in _INotifySyscallsWrapper)
    IN_ATTRIB
    (in pyinotify)    		IN_MODIFY
    +    		IN_MASK_ADD
    (in pyinotify)    		inotify_add_watch()
    -(in INotifyWrapper)    		init()
    +(in _CtypesLibcINotifyWrapper)
    IN_CLOSE_NOWRITE
    (in pyinotify)    		IN_MOVE_SELF
    +    		IN_MODIFY
    (in pyinotify)    		inotify_attrs
    -(in SysCtlINotify)    		init()
    +(in _INotifySyscallsWrapper)
    IN_CLOSE_WRITE
    (in pyinotify)    		IN_MOVE_SELF
    +(in pyinotify)    		inotify_add_watch()
    +(in INotifyWrapper)
    IN_CREATE
    +(in pyinotify)    		 IN_MOVED_FROM
    (in pyinotify)    		 inotify_init()
    (in INotifyWrapper)
    IN_CREATE
    +    		IN_DELETE
    (in pyinotify)    		 IN_MOVED_TO
    (in pyinotify)
    IN_DELETE
    +    		IN_DELETE_SELF
    (in pyinotify)    		 IN_ONESHOT
    (in pyinotify)
    IN_DELETE_SELF
    +    		IN_DONT_FOLLOW
    (in pyinotify)    		 IN_ONLYDIR
    (in pyinotify)
    IN_DONT_FOLLOW
    +    		IN_EXCL_UNLINK
    (in pyinotify)    		 IN_OPEN
    (in pyinotify)    		 INotifyWrapper
    (in pyinotify)
    IN_EXCL_UNLINK
    -(in pyinotify)    		IN_Q_OVERFLOW
    -(in pyinotify)    		 
    IN_IGNORED
    -(in pyinotify)    		IN_UNMOUNT
    -(in pyinotify)    		 

    L

    @@ -455,30 +448,31 @@ (in Notifier) process_IN_IGNORED()
    (in _SysProcessEvent) -punctuation()
    -(in RawOutputFormat) +ProcINotify
    +(in pyinotify) process_default()
    (in ChainIfTrue) process_IN_MOVE_SELF()
    (in _SysProcessEvent) -pyinotify +punctuation()
    +(in RawOutputFormat) process_default()
    (in PrintAllEvents) process_IN_MOVED_FROM()
    (in _SysProcessEvent) -PyinotifyError
    -(in pyinotify) +pyinotify process_default()
    (in ProcessEvent) process_IN_MOVED_TO()
    (in _SysProcessEvent) -  +PyinotifyError
    +(in pyinotify) @@ -513,8 +507,8 @@ (in TornadoAsyncNotifier) -set_val()
    -(in SysCtlINotify) +set_val()
    +(in ProcINotify) stop()
    (in AsyncioNotifier) str_errno()
    @@ -525,8 +519,7 @@ (in RawOutputFormat) stop()
    (in Notifier) -SysCtlINotify
    -(in pyinotify) +  SPECIAL_FLAGS
    @@ -571,8 +564,8 @@ (in pyinotify) valc
    (in pyinotify) -value
    -(in SysCtlINotify) +value
    +(in ProcINotify)     @@ -604,8 +597,8 @@ __add_watch()
    (in WatchManager) -__init__()
    -(in SysCtlINotify) +__init__()
    +(in RawOutputFormat) __walk_rec()
    (in WatchManager) @@ -708,16 +701,16 @@ __init__()
    (in Event) -__repr__()
    -(in Stats) +__repr__()
    +(in ProcINotify) _match()
    (in ExcludeFilter) __init__()
    (in ExcludeFilter) -__repr__()
    -(in SysCtlINotify) +__repr__()
    +(in Stats) _ProcessEvent
    (in pyinotify) @@ -746,24 +739,23 @@ (in Stats) -__init__()
    -(in ProcessEvent) +__init__()
    +(in ProcINotify) __str__()
    (in Stats) -_sysctl()
    -(in _CtypesLibcINotifyWrapper) +_SysProcessEvent
    +(in pyinotify) -__init__()
    -(in ProcessEventError) +__init__()
    +(in ProcessEvent) __str__()
    (in _Event) -_SysProcessEvent
    -(in pyinotify) +  -__init__()
    -(in RawOutputFormat) +__init__()
    +(in ProcessEventError) __str__()
    (in _RawEvent)   @@ -797,7 +789,7 @@ @@ -634,21 +634,21 @@ @@ -799,7 +799,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:52 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:52 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015

    Version: - 0.9.5 + 0.9.6

    @@ -137,8 +137,8 @@     		  - SysCtlINotify
    - Access (read, write) inotify's variables through sysctl. + ProcINotify
    + Access (read, write) inotify's variables through /proc/sys/.
      - max_queued_events = ?? + max_queued_events = <max_queued_events=16385>
      - max_user_instances = ?? + max_user_instances = <max_user_instances=128>
      - max_user_watches = ?? + max_user_watches = <max_user_watches=65536>
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:52 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015 43 @type version: string 44 """ 45 err = 'Python %s is unsupported, requires at least Python 2.4' - 46 PyinotifyError. 46 PyinotifyError. 95 96 __author__ = "seb@dbzteam.org (Sebastien Martini)" 97 - 98 __version__ = "0.9.5" + 98 __version__ = "0.9.6" 99 100 __metaclass__ = type # Use new-style classes by default 101 @@ -199,10 +199,10 @@ pyinotify.ExcludeFilter.__init__ pyinotify.InotifyBindingNotFoundError.__init__ pyinotify.Notifier.__init__ pyinotify.NotifierError.__init__ +pyinotify.ProcINotify.__init__ pyinotify.ProcessEvent.__init__ pyinotify.ProcessEventError.__init__ pyinotify.RawOutputFormat.__init__ -pyinotify.SysCtlINotify.__init__ pyinotify.ThreadedNotifier.__init__ pyinotify.TornadoAsyncNotifier.__init__ pyinotify.UnsupportedPythonVersionError.__init__ @@ -328,7 +328,7 @@ pyinotify._INotifySyscallsWrapper._inotify_rm_watch" class="py-name" href="#" on 221 try: 222 location = self._libc.__errno_location 223 location.restype = ctypes.POINTER(ctypes.c_int) - 224 self._get_errno_func = lambda: location().contents.value + 224 self._get_errno_func = lambda: location().contents.value 225 except AttributeError: 226 pass 227 @@ -364,331 +364,293 @@ pyinotify._INotifySyscallsWrapper._inotify_rm_watch" class="py-name" href="#" on
    257 - def _inotify_rm_watch(self, fd, wd):
    258 assert self._libc is not None 259 return self._libc.inotify_rm_watch(fd, wd) -
    260 -
    261 - def _sysctl(self, *args): -
    262 assert self._libc is not None - 263 return self._libc.sysctl(*args) -
    264 -
    265 - 266 # Logging - 267 -def logger_init(): -
    268 """Initialize logger instance.""" - 269 log = logging.getLogger("pyinotify") - 270 console_handler = logging.StreamHandler() - 271 console_handler.setFormatter( - 272 logging.Formatter("[%(asctime)s %(name)s %(levelname)s] %(message)s")) - 273 log.addHandler(console_handler) - 274 log.setLevel(20) - 275 return log -
    276 - 277 log = logger_init() -
    278 - 279 - 280 # inotify's variables - 281 -class SysCtlINotify: -
    282 """ - 283 Access (read, write) inotify's variables through sysctl. Usually it - 284 requires administrator rights to update them. - 285 - 286 Examples: - 287 - Read max_queued_events attribute: myvar = max_queued_events.value - 288 - Update max_queued_events attribute: max_queued_events.value = 42 - 289 """ - 290 - 291 inotify_attrs = {'max_user_instances': 1, - 292 'max_user_watches': 2, - 293 'max_queued_events': 3} - 294 -
    295 - def __init__(self, attrname, inotify_wrapper): -
    296 # FIXME: right now only supporting ctypes - 297 assert ctypes - 298 self._attrname = attrname - 299 self._inotify_wrapper = inotify_wrapper - 300 sino = ctypes.c_int * 3 - 301 self._attr = sino(5, 20, SysCtlINotify.inotify_attrs[attrname]) -
    302 - 303 @staticmethod -
    304 - def create(attrname): -
    305 """ - 306 Factory method instanciating and returning the right wrapper. - 307 """ - 308 # FIXME: right now only supporting ctypes - 309 if ctypes is None: - 310 return None - 311 inotify_wrapper = _CtypesLibcINotifyWrapper() - 312 if not inotify_wrapper.init(): - 313 return None - 314 return SysCtlINotify(attrname, inotify_wrapper) -
    315 -
    316 - def get_val(self): -
    317 """ - 318 Gets attribute's value. Raises OSError if the operation failed. - 319 - 320 @return: stored value. - 321 @rtype: int - 322 """ - 323 oldv = ctypes.c_int(0) - 324 size = ctypes.c_int(ctypes.sizeof(oldv)) - 325 sysctl = self._inotify_wrapper._sysctl - 326 res = sysctl(self._attr, 3, - 327 ctypes.c_voidp(ctypes.addressof(oldv)), - 328 ctypes.addressof(size), - 329 None, 0) - 330 if res == -1: - 331 raise OSError(self._inotify_wrapper.get_errno(), - 332 self._inotify_wrapper.str_errno()) - 333 return oldv.value -
    334 -
    335 - def set_val(self, nval): -
    336 """ - 337 Sets new attribute's value. Raises OSError if the operation failed. - 338 - 339 @param nval: replaces current value by nval. - 340 @type nval: int - 341 """ - 342 oldv = ctypes.c_int(0) - 343 sizeo = ctypes.c_int(ctypes.sizeof(oldv)) - 344 newv = ctypes.c_int(nval) - 345 sizen = ctypes.c_int(ctypes.sizeof(newv)) - 346 sysctl = self._inotify_wrapper._sysctl - 347 res = sysctl(self._attr, 3, - 348 ctypes.c_voidp(ctypes.addressof(oldv)), - 349 ctypes.addressof(sizeo), - 350 ctypes.c_voidp(ctypes.addressof(newv)), - 351 sizen) - 352 if res == -1: - 353 raise OSError(self._inotify_wrapper.get_errno(), - 354 self._inotify_wrapper.str_errno()) -
    355 - 356 value = property(get_val, set_val) - 357 -
    358 - def __repr__(self): -
    359 return '<%s=%d>' % (self._attrname, self.get_val()) -
    360 - 361 - 362 # Inotify's variables - 363 # - 364 # FIXME: currently these variables are only accessible when ctypes is used, - 365 # otherwise there are set to None. - 366 # - 367 # read: myvar = max_queued_events.value - 368 # update: max_queued_events.value = 42 - 369 # - 370 for attrname in ('max_queued_events', 'max_user_instances', 'max_user_watches'): - 371 globals()[attrname] = SysCtlINotify.create(attrname) -
    372 - 373 - 374 -class EventsCodes: -
    375 """ - 376 Set of codes corresponding to each kind of events. - 377 Some of these flags are used to communicate with inotify, whereas - 378 the others are sent to userspace by inotify notifying some events. - 379 - 380 @cvar IN_ACCESS: File was accessed. - 381 @type IN_ACCESS: int - 382 @cvar IN_MODIFY: File was modified. - 383 @type IN_MODIFY: int - 384 @cvar IN_ATTRIB: Metadata changed. - 385 @type IN_ATTRIB: int - 386 @cvar IN_CLOSE_WRITE: Writtable file was closed. - 387 @type IN_CLOSE_WRITE: int - 388 @cvar IN_CLOSE_NOWRITE: Unwrittable file closed. - 389 @type IN_CLOSE_NOWRITE: int - 390 @cvar IN_OPEN: File was opened. - 391 @type IN_OPEN: int - 392 @cvar IN_MOVED_FROM: File was moved from X. - 393 @type IN_MOVED_FROM: int - 394 @cvar IN_MOVED_TO: File was moved to Y. - 395 @type IN_MOVED_TO: int - 396 @cvar IN_CREATE: Subfile was created. - 397 @type IN_CREATE: int - 398 @cvar IN_DELETE: Subfile was deleted. - 399 @type IN_DELETE: int - 400 @cvar IN_DELETE_SELF: Self (watched item itself) was deleted. - 401 @type IN_DELETE_SELF: int - 402 @cvar IN_MOVE_SELF: Self (watched item itself) was moved. - 403 @type IN_MOVE_SELF: int - 404 @cvar IN_UNMOUNT: Backing fs was unmounted. - 405 @type IN_UNMOUNT: int - 406 @cvar IN_Q_OVERFLOW: Event queued overflowed. - 407 @type IN_Q_OVERFLOW: int - 408 @cvar IN_IGNORED: File was ignored. - 409 @type IN_IGNORED: int - 410 @cvar IN_ONLYDIR: only watch the path if it is a directory (new - 411 in kernel 2.6.15). - 412 @type IN_ONLYDIR: int - 413 @cvar IN_DONT_FOLLOW: don't follow a symlink (new in kernel 2.6.15). - 414 IN_ONLYDIR we can make sure that we don't watch - 415 the target of symlinks. - 416 @type IN_DONT_FOLLOW: int - 417 @cvar IN_EXCL_UNLINK: Events are not generated for children after they - 418 have been unlinked from the watched directory. - 419 (new in kernel 2.6.36). - 420 @type IN_EXCL_UNLINK: int - 421 @cvar IN_MASK_ADD: add to the mask of an already existing watch (new - 422 in kernel 2.6.14). - 423 @type IN_MASK_ADD: int - 424 @cvar IN_ISDIR: Event occurred against dir. - 425 @type IN_ISDIR: int - 426 @cvar IN_ONESHOT: Only send event once. - 427 @type IN_ONESHOT: int - 428 @cvar ALL_EVENTS: Alias for considering all of the events. - 429 @type ALL_EVENTS: int - 430 """ - 431 - 432 # The idea here is 'configuration-as-code' - this way, we get our nice class - 433 # constants, but we also get nice human-friendly text mappings to do lookups - 434 # against as well, for free: - 435 FLAG_COLLECTIONS = {'OP_FLAGS': { - 436 'IN_ACCESS' : 0x00000001, # File was accessed - 437 'IN_MODIFY' : 0x00000002, # File was modified - 438 'IN_ATTRIB' : 0x00000004, # Metadata changed - 439 'IN_CLOSE_WRITE' : 0x00000008, # Writable file was closed - 440 'IN_CLOSE_NOWRITE' : 0x00000010, # Unwritable file closed - 441 'IN_OPEN' : 0x00000020, # File was opened - 442 'IN_MOVED_FROM' : 0x00000040, # File was moved from X - 443 'IN_MOVED_TO' : 0x00000080, # File was moved to Y - 444 'IN_CREATE' : 0x00000100, # Subfile was created - 445 'IN_DELETE' : 0x00000200, # Subfile was deleted - 446 'IN_DELETE_SELF' : 0x00000400, # Self (watched item itself) - 447 # was deleted - 448 'IN_MOVE_SELF' : 0x00000800, # Self (watched item itself) was moved - 449 }, - 450 'EVENT_FLAGS': { - 451 'IN_UNMOUNT' : 0x00002000, # Backing fs was unmounted - 452 'IN_Q_OVERFLOW' : 0x00004000, # Event queued overflowed - 453 'IN_IGNORED' : 0x00008000, # File was ignored - 454 }, - 455 'SPECIAL_FLAGS': { - 456 'IN_ONLYDIR' : 0x01000000, # only watch the path if it is a - 457 # directory - 458 'IN_DONT_FOLLOW' : 0x02000000, # don't follow a symlink - 459 'IN_EXCL_UNLINK' : 0x04000000, # exclude events on unlinked objects - 460 'IN_MASK_ADD' : 0x20000000, # add to the mask of an already - 461 # existing watch - 462 'IN_ISDIR' : 0x40000000, # event occurred against dir - 463 'IN_ONESHOT' : 0x80000000, # only send event once - 464 }, - 465 } - 466 -
    467 - def maskname(mask): -
    468 """ - 469 Returns the event name associated to mask. IN_ISDIR is appended to - 470 the result when appropriate. Note: only one event is returned, because - 471 only one event can be raised at a given time. - 472 - 473 @param mask: mask. - 474 @type mask: int - 475 @return: event name. - 476 @rtype: str - 477 """ - 478 ms = mask - 479 name = '%s' - 480 if mask & IN_ISDIR: - 481 ms = mask - IN_ISDIR - 482 name = '%s|IN_ISDIR' - 483 return name % EventsCodes.ALL_VALUES[ms] -
    484 - 485 maskname = staticmethod(maskname) -
    486 - 487 - 488 # So let's now turn the configuration into code - 489 EventsCodes.ALL_FLAGS = {} - 490 EventsCodes.ALL_VALUES = {} - 491 for flagc, valc in EventsCodes.FLAG_COLLECTIONS.items(): - 492 # Make the collections' members directly accessible through the - 493 # class dictionary - 494 setattr(EventsCodes, flagc, valc) - 495 - 496 # Collect all the flags under a common umbrella - 497 EventsCodes.ALL_FLAGS.update(valc) - 498 - 499 # Make the individual masks accessible as 'constants' at globals() scope - 500 # and masknames accessible by values. - 501 for name, val in valc.items(): - 502 globals()[name] = val - 503 EventsCodes.ALL_VALUES[val] = name - 504 - 505 - 506 # all 'normal' events - 507 ALL_EVENTS = reduce(lambda x, y: x | y, EventsCodes.OP_FLAGS.values()) - 508 EventsCodes.ALL_FLAGS['ALL_EVENTS'] = ALL_EVENTS - 509 EventsCodes.ALL_VALUES[ALL_EVENTS] = 'ALL_EVENTS' -
    510 - 511 - 512 -class _Event: -
    513 """ - 514 Event structure, represent events raised by the system. This - 515 is the base class and should be subclassed. - 516 - 517 """ -
    518 - def __init__(self, dict_): -
    519 """ - 520 Attach attributes (contained in dict_) to self. - 521 - 522 @param dict_: Set of attributes. - 523 @type dict_: dictionary - 524 """ - 525 for tpl in dict_.items(): - 526 setattr(self, *tpl) -
    527 -
    528 - def __repr__(self): -
    529 """ - 530 @return: Generic event string representation. - 531 @rtype: str - 532 """ - 533 s = '' - 534 for attr, value in sorted(self.__dict__.items(), key=lambda x: x[0]): - 535 if attr.startswith('_'): - 536 continue - 537 if attr == 'mask': - 538 value = hex(getattr(self, attr)) - 539 elif isinstance(value, basestring) and not value: - 540 value = "''" - 541 s += ' %s%s%s' % (output_format.field_name(attr), - 542 output_format.punctuation('='), - 543 output_format.field_value(value)) - 544 - 545 s = '%s%s%s %s' % (output_format.punctuation('<'), - 546 output_format.class_name(self.__class__.__name__), - 547 s, - 548 output_format.punctuation('>')) - 549 return s -
    550 -
    551 - def __str__(self): -
    552 return repr(self) -
    553 -
    554 - 555 -class _RawEvent(_Event): -
    556 """ - 557 Raw event, it contains only the informations provided by the system. - 558 It doesn't infer anything. - 559 """ -
    560 - def __init__(self, wd, mask, cookie, name): -
    561 """ - 562 @param wd: Watch Descriptor. - 563 @type wd: int - 564 @param mask: Bitmask of events. - 565 @type mask: int - 566 @param cookie: Cookie. - 567 @type cookie: int - 568 @param name: Basename of the file or directory against which the - 569 event was raised in case where the watched directory - 570 is the parent directory. None if the event was raised - 571 on the watched item itself. - 572 @type name: string or None - 573 """ - 574 # Use this variable to cache the result of str(self), this object - 575 # is immutable. - 576 self._str = None - 577 # name: remove trailing '\0' - 578 d = {'wd': wd, - 579 'mask': mask, - 580 'cookie': cookie, - 581 'name': name.rstrip('\0')} - 582 _Event. 260 +
    261 + 262 # Logging + 263 -def logger_init(): +
    264 """Initialize logger instance.""" + 265 log = logging.getLogger("pyinotify") + 266 console_handler = logging.StreamHandler() + 267 console_handler.setFormatter( + 268 logging.Formatter("[%(asctime)s %(name)s %(levelname)s] %(message)s")) + 269 log.addHandler(console_handler) + 270 log.setLevel(20) + 271 return log +
    272 + 273 log = logger_init() +
    274 + 275 + 276 # inotify's variables + 277 -class ProcINotify: +
    278 """ + 279 Access (read, write) inotify's variables through /proc/sys/. Note that + 280 usually it requires administrator rights to update them. + 281 + 282 Examples: + 283 - Read max_queued_events attribute: myvar = max_queued_events.value + 284 - Update max_queued_events attribute: max_queued_events.value = 42 + 285 """ +
    286 - def __init__(self, attr): +
    287 self._base = "/proc/sys/fs/inotify" + 288 self._attr = attr +
    289 +
    290 - def get_val(self): +
    291 """ + 292 Gets attribute's value. + 293 + 294 @return: stored value. + 295 @rtype: int + 296 @raise IOError: if corresponding file in /proc/sys cannot be read. + 297 """ + 298 file_obj = file(os.path.join(self._base, self._attr), 'r') + 299 try: + 300 val = int(file_obj.readline()) + 301 finally: + 302 file_obj.close() + 303 return val +
    304 +
    305 - def set_val(self, nval): +
    306 """ + 307 Sets new attribute's value. + 308 + 309 @param nval: replaces current value by nval. + 310 @type nval: int + 311 @raise IOError: if corresponding file in /proc/sys cannot be written. + 312 """ + 313 file_obj = file(os.path.join(self._base, self._attr), 'w') + 314 try: + 315 file_obj.write(str(nval) + '\n') + 316 finally: + 317 file_obj.close() +
    318 + 319 value = property(get_val, set_val) + 320 +
    321 - def __repr__(self): +
    322 return '<%s=%d>' % (self._attr, self.get_val()) +
    323 + 324 + 325 # Inotify's variables + 326 # + 327 # Note: may raise IOError if the corresponding value in /proc/sys + 328 # cannot be accessed. + 329 # + 330 # Examples: + 331 # - read: myvar = max_queued_events.value + 332 # - update: max_queued_events.value = 42 + 333 # + 334 for attrname in ('max_queued_events', 'max_user_instances', 'max_user_watches'): + 335 globals()[attrname] = ProcINotify(attrname) +
    336 + 337 + 338 -class EventsCodes: +
    339 """ + 340 Set of codes corresponding to each kind of events. + 341 Some of these flags are used to communicate with inotify, whereas + 342 the others are sent to userspace by inotify notifying some events. + 343 + 344 @cvar IN_ACCESS: File was accessed. + 345 @type IN_ACCESS: int + 346 @cvar IN_MODIFY: File was modified. + 347 @type IN_MODIFY: int + 348 @cvar IN_ATTRIB: Metadata changed. + 349 @type IN_ATTRIB: int + 350 @cvar IN_CLOSE_WRITE: Writtable file was closed. + 351 @type IN_CLOSE_WRITE: int + 352 @cvar IN_CLOSE_NOWRITE: Unwrittable file closed. + 353 @type IN_CLOSE_NOWRITE: int + 354 @cvar IN_OPEN: File was opened. + 355 @type IN_OPEN: int + 356 @cvar IN_MOVED_FROM: File was moved from X. + 357 @type IN_MOVED_FROM: int + 358 @cvar IN_MOVED_TO: File was moved to Y. + 359 @type IN_MOVED_TO: int + 360 @cvar IN_CREATE: Subfile was created. + 361 @type IN_CREATE: int + 362 @cvar IN_DELETE: Subfile was deleted. + 363 @type IN_DELETE: int + 364 @cvar IN_DELETE_SELF: Self (watched item itself) was deleted. + 365 @type IN_DELETE_SELF: int + 366 @cvar IN_MOVE_SELF: Self (watched item itself) was moved. + 367 @type IN_MOVE_SELF: int + 368 @cvar IN_UNMOUNT: Backing fs was unmounted. + 369 @type IN_UNMOUNT: int + 370 @cvar IN_Q_OVERFLOW: Event queued overflowed. + 371 @type IN_Q_OVERFLOW: int + 372 @cvar IN_IGNORED: File was ignored. + 373 @type IN_IGNORED: int + 374 @cvar IN_ONLYDIR: only watch the path if it is a directory (new + 375 in kernel 2.6.15). + 376 @type IN_ONLYDIR: int + 377 @cvar IN_DONT_FOLLOW: don't follow a symlink (new in kernel 2.6.15). + 378 IN_ONLYDIR we can make sure that we don't watch + 379 the target of symlinks. + 380 @type IN_DONT_FOLLOW: int + 381 @cvar IN_EXCL_UNLINK: Events are not generated for children after they + 382 have been unlinked from the watched directory. + 383 (new in kernel 2.6.36). + 384 @type IN_EXCL_UNLINK: int + 385 @cvar IN_MASK_ADD: add to the mask of an already existing watch (new + 386 in kernel 2.6.14). + 387 @type IN_MASK_ADD: int + 388 @cvar IN_ISDIR: Event occurred against dir. + 389 @type IN_ISDIR: int + 390 @cvar IN_ONESHOT: Only send event once. + 391 @type IN_ONESHOT: int + 392 @cvar ALL_EVENTS: Alias for considering all of the events. + 393 @type ALL_EVENTS: int + 394 """ + 395 + 396 # The idea here is 'configuration-as-code' - this way, we get our nice class + 397 # constants, but we also get nice human-friendly text mappings to do lookups + 398 # against as well, for free: + 399 FLAG_COLLECTIONS = {'OP_FLAGS': { + 400 'IN_ACCESS' : 0x00000001, # File was accessed + 401 'IN_MODIFY' : 0x00000002, # File was modified + 402 'IN_ATTRIB' : 0x00000004, # Metadata changed + 403 'IN_CLOSE_WRITE' : 0x00000008, # Writable file was closed + 404 'IN_CLOSE_NOWRITE' : 0x00000010, # Unwritable file closed + 405 'IN_OPEN' : 0x00000020, # File was opened + 406 'IN_MOVED_FROM' : 0x00000040, # File was moved from X + 407 'IN_MOVED_TO' : 0x00000080, # File was moved to Y + 408 'IN_CREATE' : 0x00000100, # Subfile was created + 409 'IN_DELETE' : 0x00000200, # Subfile was deleted + 410 'IN_DELETE_SELF' : 0x00000400, # Self (watched item itself) + 411 # was deleted + 412 'IN_MOVE_SELF' : 0x00000800, # Self (watched item itself) was moved + 413 }, + 414 'EVENT_FLAGS': { + 415 'IN_UNMOUNT' : 0x00002000, # Backing fs was unmounted + 416 'IN_Q_OVERFLOW' : 0x00004000, # Event queued overflowed + 417 'IN_IGNORED' : 0x00008000, # File was ignored + 418 }, + 419 'SPECIAL_FLAGS': { + 420 'IN_ONLYDIR' : 0x01000000, # only watch the path if it is a + 421 # directory + 422 'IN_DONT_FOLLOW' : 0x02000000, # don't follow a symlink + 423 'IN_EXCL_UNLINK' : 0x04000000, # exclude events on unlinked objects + 424 'IN_MASK_ADD' : 0x20000000, # add to the mask of an already + 425 # existing watch + 426 'IN_ISDIR' : 0x40000000, # event occurred against dir + 427 'IN_ONESHOT' : 0x80000000, # only send event once + 428 }, + 429 } + 430 +
    431 - def maskname(mask): +
    432 """ + 433 Returns the event name associated to mask. IN_ISDIR is appended to + 434 the result when appropriate. Note: only one event is returned, because + 435 only one event can be raised at a given time. + 436 + 437 @param mask: mask. + 438 @type mask: int + 439 @return: event name. + 440 @rtype: str + 441 """ + 442 ms = mask + 443 name = '%s' + 444 if mask & IN_ISDIR: + 445 ms = mask - IN_ISDIR + 446 name = '%s|IN_ISDIR' + 447 return name % EventsCodes.ALL_VALUES[ms] +
    448 + 449 maskname = staticmethod(maskname) +
    450 + 451 + 452 # So let's now turn the configuration into code + 453 EventsCodes.ALL_FLAGS = {} + 454 EventsCodes.ALL_VALUES = {} + 455 for flagc, valc in EventsCodes.FLAG_COLLECTIONS.items(): + 456 # Make the collections' members directly accessible through the + 457 # class dictionary + 458 setattr(EventsCodes, flagc, valc) + 459 + 460 # Collect all the flags under a common umbrella + 461 EventsCodes.ALL_FLAGS.update(valc) + 462 + 463 # Make the individual masks accessible as 'constants' at globals() scope + 464 # and masknames accessible by values. + 465 for name, val in valc.items(): + 466 globals()[name] = val + 467 EventsCodes.ALL_VALUES[val] = name + 468 + 469 + 470 # all 'normal' events + 471 ALL_EVENTS = reduce(lambda x, y: x | y, EventsCodes.OP_FLAGS.values()) + 472 EventsCodes.ALL_FLAGS['ALL_EVENTS'] = ALL_EVENTS + 473 EventsCodes.ALL_VALUES[ALL_EVENTS] = 'ALL_EVENTS' +
    474 + 475 + 476 -class _Event: +
    477 """ + 478 Event structure, represent events raised by the system. This + 479 is the base class and should be subclassed. + 480 + 481 """ +
    482 - def __init__(self, dict_): +
    483 """ + 484 Attach attributes (contained in dict_) to self. + 485 + 486 @param dict_: Set of attributes. + 487 @type dict_: dictionary + 488 """ + 489 for tpl in dict_.items(): + 490 setattr(self, *tpl) +
    491 +
    492 - def __repr__(self): +
    493 """ + 494 @return: Generic event string representation. + 495 @rtype: str + 496 """ + 497 s = '' + 498 for attr, value in sorted(self.__dict__.items(), key=lambda x: x[0]): + 499 if attr.startswith('_'): + 500 continue + 501 if attr == 'mask': + 502 value = hex(getattr(self, attr)) + 503 elif isinstance(value, basestring) and not value: + 504 value = "''" + 505 s += ' %s%s%s' % (output_format.field_name(attr), + 506 output_format.punctuation('='), + 507 output_format.field_value(value)) + 508 + 509 s = '%s%s%s %s' % (output_format.punctuation('<'), + 510 output_format.class_name(self.__class__.__name__), + 511 s, + 512 output_format.punctuation('>')) + 513 return s +
    514 +
    515 - def __str__(self): +
    516 return repr(self) +
    517 +
    518 + 519 -class _RawEvent(_Event): +
    520 """ + 521 Raw event, it contains only the informations provided by the system. + 522 It doesn't infer anything. + 523 """ +
    524 - def __init__(self, wd, mask, cookie, name): +
    525 """ + 526 @param wd: Watch Descriptor. + 527 @type wd: int + 528 @param mask: Bitmask of events. + 529 @type mask: int + 530 @param cookie: Cookie. + 531 @type cookie: int + 532 @param name: Basename of the file or directory against which the + 533 event was raised in case where the watched directory + 534 is the parent directory. None if the event was raised + 535 on the watched item itself. + 536 @type name: string or None + 537 """ + 538 # Use this variable to cache the result of str(self), this object + 539 # is immutable. + 540 self._str = None + 541 # name: remove trailing '\0' + 542 d = {'wd': wd, + 543 'mask': mask, + 544 'cookie': cookie, + 545 'name': name.rstrip('\0')} + 546 _Event.__init__(self, d) - 583 log.debug(str(self)) -
    584 -
    585 - def __str__(self): -
    586 if self._str is None: - 587 self._str = _Event.__init__(self, d) + 547 log.debug(str(self)) +
    548 +
    549 - def __str__(self): +
    550 if self._str is None: + 551 self._str = _Event.__str__(self) - 588 return self._str -
    589 -
    590 - 591 -class Event(_Event): -
    592 """ - 593 This class contains all the useful informations about the observed - 594 event. However, the presence of each field is not guaranteed and - 595 depends on the type of event. In effect, some fields are irrelevant - 596 for some kind of event (for example 'cookie' is meaningless for - 597 IN_CREATE whereas it is mandatory for IN_MOVE_TO). - 598 - 599 The possible fields are: - 600 - wd (int): Watch Descriptor. - 601 - mask (int): Mask. - 602 - maskname (str): Readable event name. - 603 - path (str): path of the file or directory being watched. - 604 - name (str): Basename of the file or directory against which the - 605 event was raised in case where the watched directory - 606 is the parent directory. None if the event was raised - 607 on the watched item itself. This field is always provided - 608 even if the string is ''. - 609 - pathname (str): Concatenation of 'path' and 'name'. - 610 - src_pathname (str): Only present for IN_MOVED_TO events and only in - 611 the case where IN_MOVED_FROM events are watched too. Holds the - 612 source pathname from where pathname was moved from. - 613 - cookie (int): Cookie. - 614 - dir (bool): True if the event was raised against a directory. - 615 - 616 """ -
    617 - def __init__(self, raw): -
    618 """ - 619 Concretely, this is the raw event plus inferred infos. - 620 """ - 621 _Event.__str__(self) + 552 return self._str +
    553 +
    554 + 555 -class Event(_Event): +
    556 """ + 557 This class contains all the useful informations about the observed + 558 event. However, the presence of each field is not guaranteed and + 559 depends on the type of event. In effect, some fields are irrelevant + 560 for some kind of event (for example 'cookie' is meaningless for + 561 IN_CREATE whereas it is mandatory for IN_MOVE_TO). + 562 + 563 The possible fields are: + 564 - wd (int): Watch Descriptor. + 565 - mask (int): Mask. + 566 - maskname (str): Readable event name. + 567 - path (str): path of the file or directory being watched. + 568 - name (str): Basename of the file or directory against which the + 569 event was raised in case where the watched directory + 570 is the parent directory. None if the event was raised + 571 on the watched item itself. This field is always provided + 572 even if the string is ''. + 573 - pathname (str): Concatenation of 'path' and 'name'. + 574 - src_pathname (str): Only present for IN_MOVED_TO events and only in + 575 the case where IN_MOVED_FROM events are watched too. Holds the + 576 source pathname from where pathname was moved from. + 577 - cookie (int): Cookie. + 578 - dir (bool): True if the event was raised against a directory. + 579 + 580 """ +
    581 - def __init__(self, raw): +
    582 """ + 583 Concretely, this is the raw event plus inferred infos. + 584 """ + 585 _Event.__init__(self, raw) - 622 self.maskname = EventsCodes.maskname(self.mask) - 623 if COMPATIBILITY_MODE: - 624 self.event_name = self.maskname - 625 try: - 626 if self.name: - 627 self.pathname = os.path.abspath(os.path.join(self.path, - 628 self.name)) - 629 else: - 630 self.pathname = os.path.abspath(self.path) - 631 except AttributeError, err: - 632 # Usually it is not an error some events are perfectly valids - 633 # despite the lack of these attributes. - 634 log.debug(err) -
    635 -
    636 - 637 -class ProcessEventError(PyinotifyError): -
    638 """ - 639 ProcessEventError Exception. Raised on ProcessEvent error. - 640 """ -
    641 - def __init__(self, err): -
    642 """ - 643 @param err: Exception error description. - 644 @type err: string - 645 """ - 646 PyinotifyError.__init__(self, raw) + 586 self.maskname = EventsCodes.maskname(self.mask) + 587 if COMPATIBILITY_MODE: + 588 self.event_name = self.maskname + 589 try: + 590 if self.name: + 591 self.pathname = os.path.abspath(os.path.join(self.path, + 592 self.name)) + 593 else: + 594 self.pathname = os.path.abspath(self.path) + 595 except AttributeError, err: + 596 # Usually it is not an error some events are perfectly valids + 597 # despite the lack of these attributes. + 598 log.debug(err) +
    599 +
    600 + 601 -class ProcessEventError(PyinotifyError): +
    602 """ + 603 ProcessEventError Exception. Raised on ProcessEvent error. + 604 """ +
    605 - def __init__(self, err): +
    606 """ + 607 @param err: Exception error description. + 608 @type err: string + 609 """ + 610 PyinotifyError.__init__(self, err) -
    647 -
    648 - 649 -class _ProcessEvent: -
    650 """ - 651 Abstract processing event class. - 652 """ -
    653 - def __call__(self, event): -
    654 """ - 655 To behave like a functor the object must be callable. - 656 This method is a dispatch method. Its lookup order is: - 657 1. process_MASKNAME method - 658 2. process_FAMILY_NAME method - 659 3. otherwise calls process_default - 660 - 661 @param event: Event to be processed. - 662 @type event: Event object - 663 @return: By convention when used from the ProcessEvent class: - 664 - Returning False or None (default value) means keep on - 665 executing next chained functors (see chain.py example). - 666 - Returning True instead means do not execute next - 667 processing functions. - 668 @rtype: bool - 669 @raise ProcessEventError: Event object undispatchable, - 670 unknown event. - 671 """ - 672 stripped_mask = event.mask - (event.mask & IN_ISDIR) - 673 maskname = EventsCodes.ALL_VALUES.get(stripped_mask) - 674 if maskname is None: - 675 raise ProcessEventError("Unknown mask 0x%08x" % stripped_mask) - 676 - 677 # 1- look for process_MASKNAME - 678 meth = getattr(self, 'process_' + maskname, None) - 679 if meth is not None: - 680 return meth(event) - 681 # 2- look for process_FAMILY_NAME - 682 meth = getattr(self, 'process_IN_' + maskname.split('_')[1], None) - 683 if meth is not None: - 684 return meth(event) - 685 # 3- default call method process_default - 686 return self.__init__(self, err) +
    611 +
    612 + 613 -class _ProcessEvent: +
    614 """ + 615 Abstract processing event class. + 616 """ +
    617 - def __call__(self, event): +
    618 """ + 619 To behave like a functor the object must be callable. + 620 This method is a dispatch method. Its lookup order is: + 621 1. process_MASKNAME method + 622 2. process_FAMILY_NAME method + 623 3. otherwise calls process_default + 624 + 625 @param event: Event to be processed. + 626 @type event: Event object + 627 @return: By convention when used from the ProcessEvent class: + 628 - Returning False or None (default value) means keep on + 629 executing next chained functors (see chain.py example). + 630 - Returning True instead means do not execute next + 631 processing functions. + 632 @rtype: bool + 633 @raise ProcessEventError: Event object undispatchable, + 634 unknown event. + 635 """ + 636 stripped_mask = event.mask - (event.mask & IN_ISDIR) + 637 maskname = EventsCodes.ALL_VALUES.get(stripped_mask) + 638 if maskname is None: + 639 raise ProcessEventError("Unknown mask 0x%08x" % stripped_mask) + 640 + 641 # 1- look for process_MASKNAME + 642 meth = getattr(self, 'process_' + maskname, None) + 643 if meth is not None: + 644 return meth(event) + 645 # 2- look for process_FAMILY_NAME + 646 meth = getattr(self, 'process_IN_' + maskname.split('_')[1], None) + 647 if meth is not None: + 648 return meth(event) + 649 # 3- default call method process_default + 650 return self.process_default(event) -
    687 -
    688 - def __repr__(self): -
    689 return '<%s>' % self.__class__.__name__ -
    690 -
    691 - 692 -class _SysProcessEvent(_ProcessEvent): -
    693 """ - 694 There is three kind of processing according to each event: - 695 - 696 1. special handling (deletion from internal container, bug, ...). - 697 2. default treatment: which is applied to the majority of events. - 698 3. IN_ISDIR is never sent alone, he is piggybacked with a standard - 699 event, he is not processed as the others events, instead, its - 700 value is captured and appropriately aggregated to dst event. - 701 """ -
    702 - def __init__(self, wm, notifier): -
    703 """ - 704 - 705 @param wm: Watch Manager. - 706 @type wm: WatchManager instance - 707 @param notifier: Notifier. - 708 @type notifier: Notifier instance - 709 """ - 710 self._watch_manager = wm # watch manager - 711 self._notifier = notifier # notifier - 712 self._mv_cookie = {} # {cookie(int): (src_path(str), date), ...} - 713 self._mv = {} # {src_path(str): (dst_path(str), date), ...} -
    714 -
    715 - def cleanup(self): -
    716 """ - 717 Cleanup (delete) old (>1mn) records contained in self._mv_cookie - 718 and self._mv. - 719 """ - 720 date_cur_ = datetime.now() - 721 for seq in [self._mv_cookie, self._mv]: - 722 for k in seq.keys(): - 723 if (date_cur_ - seq[k][1]) > timedelta(minutes=1): - 724 log.debug('Cleanup: deleting entry %s', seq[k][0]) - 725 del seq[k] -
    726 -
    727 - def process_IN_CREATE(self, raw_event): -
    728 """ - 729 If the event affects a directory and the auto_add flag of the - 730 targetted watch is set to True, a new watch is added on this - 731 new directory, with the same attribute values than those of - 732 this watch. - 733 """ - 734 if raw_event.mask & IN_ISDIR: - 735 watch_ = self._watch_manager.get_watch(raw_event.wd) - 736 created_dir = os.path.join(watch_.path, raw_event.name) - 737 if watch_.auto_add and not watch_.exclude_filter(created_dir): - 738 addw = self._watch_manager.add_watch - 739 # The newly monitored directory inherits attributes from its - 740 # parent directory. - 741 addw_ret = addw(created_dir, watch_.mask, - 742 proc_fun=watch_.proc_fun, - 743 rec=False, auto_add=watch_.auto_add, - 744 exclude_filter=watch_.exclude_filter) - 745 - 746 # Trick to handle mkdir -p /d1/d2/t3 where d1 is watched and - 747 # d2 and t3 (directory or file) are created. - 748 # Since the directory d2 is new, then everything inside it must - 749 # also be new. - 750 created_dir_wd = addw_ret.get(created_dir) - 751 if ((created_dir_wd is not None) and (created_dir_wd > 0) and - 752 os.path.isdir(created_dir)): - 753 try: - 754 for name in os.listdir(created_dir): - 755 inner = os.path.join(created_dir, name) - 756 if self._watch_manager.get_wd(inner) is not None: - 757 continue - 758 # Generate (simulate) creation events for sub- - 759 # directories and files. - 760 if os.path.isfile(inner): - 761 # symlinks are handled as files. - 762 flags = IN_CREATE - 763 elif os.path.isdir(inner): - 764 flags = IN_CREATE | IN_ISDIR - 765 else: - 766 # This path should not be taken. - 767 continue - 768 rawevent = _RawEvent(created_dir_wd, flags, 0, name) - 769 self._notifier.append_event(rawevent) - 770 except OSError, err: - 771 msg = "process_IN_CREATE, invalid directory %s: %s" - 772 log.debug(msg % (created_dir, str(err))) - 773 return self.process_default(event) +
    651 +
    652 - def __repr__(self): +
    653 return '<%s>' % self.__class__.__name__ +
    654 +
    655 + 656 -class _SysProcessEvent(_ProcessEvent): +
    657 """ + 658 There is three kind of processing according to each event: + 659 + 660 1. special handling (deletion from internal container, bug, ...). + 661 2. default treatment: which is applied to the majority of events. + 662 3. IN_ISDIR is never sent alone, he is piggybacked with a standard + 663 event, he is not processed as the others events, instead, its + 664 value is captured and appropriately aggregated to dst event. + 665 """ +
    666 - def __init__(self, wm, notifier): +
    667 """ + 668 + 669 @param wm: Watch Manager. + 670 @type wm: WatchManager instance + 671 @param notifier: Notifier. + 672 @type notifier: Notifier instance + 673 """ + 674 self._watch_manager = wm # watch manager + 675 self._notifier = notifier # notifier + 676 self._mv_cookie = {} # {cookie(int): (src_path(str), date), ...} + 677 self._mv = {} # {src_path(str): (dst_path(str), date), ...} +
    678 +
    679 - def cleanup(self): +
    680 """ + 681 Cleanup (delete) old (>1mn) records contained in self._mv_cookie + 682 and self._mv. + 683 """ + 684 date_cur_ = datetime.now() + 685 for seq in [self._mv_cookie, self._mv]: + 686 for k in seq.keys(): + 687 if (date_cur_ - seq[k][1]) > timedelta(minutes=1): + 688 log.debug('Cleanup: deleting entry %s', seq[k][0]) + 689 del seq[k] +
    690 +
    691 - def process_IN_CREATE(self, raw_event): +
    692 """ + 693 If the event affects a directory and the auto_add flag of the + 694 targetted watch is set to True, a new watch is added on this + 695 new directory, with the same attribute values than those of + 696 this watch. + 697 """ + 698 if raw_event.mask & IN_ISDIR: + 699 watch_ = self._watch_manager.get_watch(raw_event.wd) + 700 created_dir = os.path.join(watch_.path, raw_event.name) + 701 if watch_.auto_add and not watch_.exclude_filter(created_dir): + 702 addw = self._watch_manager.add_watch + 703 # The newly monitored directory inherits attributes from its + 704 # parent directory. + 705 addw_ret = addw(created_dir, watch_.mask, + 706 proc_fun=watch_.proc_fun, + 707 rec=False, auto_add=watch_.auto_add, + 708 exclude_filter=watch_.exclude_filter) + 709 + 710 # Trick to handle mkdir -p /d1/d2/t3 where d1 is watched and + 711 # d2 and t3 (directory or file) are created. + 712 # Since the directory d2 is new, then everything inside it must + 713 # also be new. + 714 created_dir_wd = addw_ret.get(created_dir) + 715 if ((created_dir_wd is not None) and (created_dir_wd > 0) and + 716 os.path.isdir(created_dir)): + 717 try: + 718 for name in os.listdir(created_dir): + 719 inner = os.path.join(created_dir, name) + 720 if self._watch_manager.get_wd(inner) is not None: + 721 continue + 722 # Generate (simulate) creation events for sub- + 723 # directories and files. + 724 if os.path.isfile(inner): + 725 # symlinks are handled as files. + 726 flags = IN_CREATE + 727 elif os.path.isdir(inner): + 728 flags = IN_CREATE | IN_ISDIR + 729 else: + 730 # This path should not be taken. + 731 continue + 732 rawevent = _RawEvent(created_dir_wd, flags, 0, name) + 733 self._notifier.append_event(rawevent) + 734 except OSError, err: + 735 msg = "process_IN_CREATE, invalid directory %s: %s" + 736 log.debug(msg % (created_dir, str(err))) + 737 return self.process_default(raw_event) -
    774 -
    775 - def process_IN_MOVED_FROM(self, raw_event): -
    776 """ - 777 Map the cookie with the source path (+ date for cleaning). - 778 """ - 779 watch_ = self._watch_manager.get_watch(raw_event.wd) - 780 path_ = watch_.path - 781 src_path = os.path.normpath(os.path.join(path_, raw_event.name)) - 782 self._mv_cookie[raw_event.cookie] = (src_path, datetime.now()) - 783 return self.process_default(raw_event) +
    738 +
    739 - def process_IN_MOVED_FROM(self, raw_event): +
    740 """ + 741 Map the cookie with the source path (+ date for cleaning). + 742 """ + 743 watch_ = self._watch_manager.get_watch(raw_event.wd) + 744 path_ = watch_.path + 745 src_path = os.path.normpath(os.path.join(path_, raw_event.name)) + 746 self._mv_cookie[raw_event.cookie] = (src_path, datetime.now()) + 747 return self.process_default(raw_event, {'cookie': raw_event.cookie}) -
    784 -
    785 - def process_IN_MOVED_TO(self, raw_event): -
    786 """ - 787 Map the source path with the destination path (+ date for - 788 cleaning). - 789 """ - 790 watch_ = self._watch_manager.get_watch(raw_event.wd) - 791 path_ = watch_.path - 792 dst_path = os.path.normpath(os.path.join(path_, raw_event.name)) - 793 mv_ = self._mv_cookie.get(raw_event.cookie) - 794 to_append = {'cookie': raw_event.cookie} - 795 if mv_ is not None: - 796 self._mv[mv_[0]] = (dst_path, datetime.now()) - 797 # Let's assume that IN_MOVED_FROM event is always queued before - 798 # that its associated (they share a common cookie) IN_MOVED_TO - 799 # event is queued itself. It is then possible in that scenario - 800 # to provide as additional information to the IN_MOVED_TO event - 801 # the original pathname of the moved file/directory. - 802 to_append['src_pathname'] = mv_[0] - 803 elif (raw_event.mask & IN_ISDIR and watch_.auto_add and - 804 not watch_.exclude_filter(dst_path)): - 805 # We got a diretory that's "moved in" from an unknown source and - 806 # auto_add is enabled. Manually add watches to the inner subtrees. - 807 # The newly monitored directory inherits attributes from its - 808 # parent directory. - 809 self._watch_manager.add_watch(dst_path, watch_.mask, - 810 proc_fun=watch_.proc_fun, - 811 rec=True, auto_add=True, - 812 exclude_filter=watch_.exclude_filter) - 813 return self.process_default(raw_event, {'cookie': raw_event.cookie}) +
    748 +
    749 - def process_IN_MOVED_TO(self, raw_event): +
    750 """ + 751 Map the source path with the destination path (+ date for + 752 cleaning). + 753 """ + 754 watch_ = self._watch_manager.get_watch(raw_event.wd) + 755 path_ = watch_.path + 756 dst_path = os.path.normpath(os.path.join(path_, raw_event.name)) + 757 mv_ = self._mv_cookie.get(raw_event.cookie) + 758 to_append = {'cookie': raw_event.cookie} + 759 if mv_ is not None: + 760 self._mv[mv_[0]] = (dst_path, datetime.now()) + 761 # Let's assume that IN_MOVED_FROM event is always queued before + 762 # that its associated (they share a common cookie) IN_MOVED_TO + 763 # event is queued itself. It is then possible in that scenario + 764 # to provide as additional information to the IN_MOVED_TO event + 765 # the original pathname of the moved file/directory. + 766 to_append['src_pathname'] = mv_[0] + 767 elif (raw_event.mask & IN_ISDIR and watch_.auto_add and + 768 not watch_.exclude_filter(dst_path)): + 769 # We got a diretory that's "moved in" from an unknown source and + 770 # auto_add is enabled. Manually add watches to the inner subtrees. + 771 # The newly monitored directory inherits attributes from its + 772 # parent directory. + 773 self._watch_manager.add_watch(dst_path, watch_.mask, + 774 proc_fun=watch_.proc_fun, + 775 rec=True, auto_add=True, + 776 exclude_filter=watch_.exclude_filter) + 777 return self.process_default(raw_event, to_append) -
    814 -
    815 - def process_IN_MOVE_SELF(self, raw_event): -
    816 """ - 817 STATUS: the following bug has been fixed in recent kernels (FIXME: - 818 which version ?). Now it raises IN_DELETE_SELF instead. - 819 - 820 Old kernels were bugged, this event raised when the watched item - 821 were moved, so we had to update its path, but under some circumstances - 822 it was impossible: if its parent directory and its destination - 823 directory wasn't watched. The kernel (see include/linux/fsnotify.h) - 824 doesn't bring us enough informations like the destination path of - 825 moved items. - 826 """ - 827 watch_ = self._watch_manager.get_watch(raw_event.wd) - 828 src_path = watch_.path - 829 mv_ = self._mv.get(src_path) - 830 if mv_: - 831 dest_path = mv_[0] - 832 watch_.path = dest_path - 833 # add the separator to the source path to avoid overlapping - 834 # path issue when testing with startswith() - 835 src_path += os.path.sep - 836 src_path_len = len(src_path) - 837 # The next loop renames all watches with src_path as base path. - 838 # It seems that IN_MOVE_SELF does not provide IN_ISDIR information - 839 # therefore the next loop is iterated even if raw_event is a file. - 840 for w in self._watch_manager.watches.values(): - 841 if w.path.startswith(src_path): - 842 # Note that dest_path is a normalized path. - 843 w.path = os.path.join(dest_path, w.path[src_path_len:]) - 844 else: - 845 log.error("The pathname '%s' of this watch %s has probably changed " - 846 "and couldn't be updated, so it cannot be trusted " - 847 "anymore. To fix this error move directories/files only " - 848 "between watched parents directories, in this case e.g. " - 849 "put a watch on '%s'.", - 850 watch_.path, watch_, - 851 os.path.normpath(os.path.join(watch_.path, - 852 os.path.pardir))) - 853 if not watch_.path.endswith('-unknown-path'): - 854 watch_.path += '-unknown-path' - 855 return self.process_default(raw_event, to_append) +
    778 +
    779 - def process_IN_MOVE_SELF(self, raw_event): +
    780 """ + 781 STATUS: the following bug has been fixed in recent kernels (FIXME: + 782 which version ?). Now it raises IN_DELETE_SELF instead. + 783 + 784 Old kernels were bugged, this event raised when the watched item + 785 were moved, so we had to update its path, but under some circumstances + 786 it was impossible: if its parent directory and its destination + 787 directory wasn't watched. The kernel (see include/linux/fsnotify.h) + 788 doesn't bring us enough informations like the destination path of + 789 moved items. + 790 """ + 791 watch_ = self._watch_manager.get_watch(raw_event.wd) + 792 src_path = watch_.path + 793 mv_ = self._mv.get(src_path) + 794 if mv_: + 795 dest_path = mv_[0] + 796 watch_.path = dest_path + 797 # add the separator to the source path to avoid overlapping + 798 # path issue when testing with startswith() + 799 src_path += os.path.sep + 800 src_path_len = len(src_path) + 801 # The next loop renames all watches with src_path as base path. + 802 # It seems that IN_MOVE_SELF does not provide IN_ISDIR information + 803 # therefore the next loop is iterated even if raw_event is a file. + 804 for w in self._watch_manager.watches.values(): + 805 if w.path.startswith(src_path): + 806 # Note that dest_path is a normalized path. + 807 w.path = os.path.join(dest_path, w.path[src_path_len:]) + 808 else: + 809 log.error("The pathname '%s' of this watch %s has probably changed " + 810 "and couldn't be updated, so it cannot be trusted " + 811 "anymore. To fix this error move directories/files only " + 812 "between watched parents directories, in this case e.g. " + 813 "put a watch on '%s'.", + 814 watch_.path, watch_, + 815 os.path.normpath(os.path.join(watch_.path, + 816 os.path.pardir))) + 817 if not watch_.path.endswith('-unknown-path'): + 818 watch_.path += '-unknown-path' + 819 return self.process_default(raw_event) -
    856 -
    857 - def process_IN_Q_OVERFLOW(self, raw_event): -
    858 """ - 859 Only signal an overflow, most of the common flags are irrelevant - 860 for this event (path, wd, name). - 861 """ - 862 return Event({'mask': raw_event.mask}) -
    863 -
    864 - def process_IN_IGNORED(self, raw_event): -
    865 """ - 866 The watch descriptor raised by this event is now ignored (forever), - 867 it can be safely deleted from the watch manager dictionary. - 868 After this event we can be sure that neither the event queue nor - 869 the system will raise an event associated to this wd again. - 870 """ - 871 event_ = self.process_default(raw_event) +
    820 +
    821 - def process_IN_Q_OVERFLOW(self, raw_event): +
    822 """ + 823 Only signal an overflow, most of the common flags are irrelevant + 824 for this event (path, wd, name). + 825 """ + 826 return Event({'mask': raw_event.mask}) +
    827 +
    828 - def process_IN_IGNORED(self, raw_event): +
    829 """ + 830 The watch descriptor raised by this event is now ignored (forever), + 831 it can be safely deleted from the watch manager dictionary. + 832 After this event we can be sure that neither the event queue nor + 833 the system will raise an event associated to this wd again. + 834 """ + 835 event_ = self.process_default(raw_event) - 872 self._watch_manager.del_watch(raw_event.wd) - 873 return event_ -
    874 -
    875 - def process_default(self, raw_event, to_append=None): -
    876 """ - 877 Commons handling for the followings events: - 878 - 879 IN_ACCESS, IN_MODIFY, IN_ATTRIB, IN_CLOSE_WRITE, IN_CLOSE_NOWRITE, - 880 IN_OPEN, IN_DELETE, IN_DELETE_SELF, IN_UNMOUNT. - 881 """ - 882 watch_ = self._watch_manager.get_watch(raw_event.wd) - 883 if raw_event.mask & (IN_DELETE_SELF | IN_MOVE_SELF): - 884 # Unfornulately this information is not provided by the kernel - 885 dir_ = watch_.dir - 886 else: - 887 dir_ = bool(raw_event.mask & IN_ISDIR) - 888 dict_ = {'wd': raw_event.wd, - 889 'mask': raw_event.mask, - 890 'path': watch_.path, - 891 'name': raw_event.name, - 892 'dir': dir_} - 893 if COMPATIBILITY_MODE: - 894 dict_['is_dir'] = dir_ - 895 if to_append is not None: - 896 dict_.update(to_append) - 897 return Event(dict_) -
    898 -
    899 - 900 -class ProcessEvent(_ProcessEvent): -
    901 """ - 902 Process events objects, can be specialized via subclassing, thus its - 903 behavior can be overriden: - 904 - 905 Note: you should not override __init__ in your subclass instead define - 906 a my_init() method, this method will be called automatically from the - 907 constructor of this class with its optionals parameters. - 908 - 909 1. Provide specialized individual methods, e.g. process_IN_DELETE for - 910 processing a precise type of event (e.g. IN_DELETE in this case). - 911 2. Or/and provide methods for processing events by 'family', e.g. - 912 process_IN_CLOSE method will process both IN_CLOSE_WRITE and - 913 IN_CLOSE_NOWRITE events (if process_IN_CLOSE_WRITE and - 914 process_IN_CLOSE_NOWRITE aren't defined though). - 915 3. Or/and override process_default for catching and processing all - 916 the remaining types of events. - 917 """ - 918 pevent = None - 919 -
    920 - def __init__(self, pevent=None, **kargs): -
    921 """ - 922 Enable chaining of ProcessEvent instances. - 923 - 924 @param pevent: Optional callable object, will be called on event - 925 processing (before self). - 926 @type pevent: callable - 927 @param kargs: This constructor is implemented as a template method - 928 delegating its optionals keyworded arguments to the - 929 method my_init(). - 930 @type kargs: dict - 931 """ - 932 self.pevent = pevent - 933 self.process_default(raw_event) + 836 self._watch_manager.del_watch(raw_event.wd) + 837 return event_ +
    838 +
    839 - def process_default(self, raw_event, to_append=None): +
    840 """ + 841 Commons handling for the followings events: + 842 + 843 IN_ACCESS, IN_MODIFY, IN_ATTRIB, IN_CLOSE_WRITE, IN_CLOSE_NOWRITE, + 844 IN_OPEN, IN_DELETE, IN_DELETE_SELF, IN_UNMOUNT. + 845 """ + 846 watch_ = self._watch_manager.get_watch(raw_event.wd) + 847 if raw_event.mask & (IN_DELETE_SELF | IN_MOVE_SELF): + 848 # Unfornulately this information is not provided by the kernel + 849 dir_ = watch_.dir + 850 else: + 851 dir_ = bool(raw_event.mask & IN_ISDIR) + 852 dict_ = {'wd': raw_event.wd, + 853 'mask': raw_event.mask, + 854 'path': watch_.path, + 855 'name': raw_event.name, + 856 'dir': dir_} + 857 if COMPATIBILITY_MODE: + 858 dict_['is_dir'] = dir_ + 859 if to_append is not None: + 860 dict_.update(to_append) + 861 return Event(dict_) +
    862 +
    863 + 864 -class ProcessEvent(_ProcessEvent): +
    865 """ + 866 Process events objects, can be specialized via subclassing, thus its + 867 behavior can be overriden: + 868 + 869 Note: you should not override __init__ in your subclass instead define + 870 a my_init() method, this method will be called automatically from the + 871 constructor of this class with its optionals parameters. + 872 + 873 1. Provide specialized individual methods, e.g. process_IN_DELETE for + 874 processing a precise type of event (e.g. IN_DELETE in this case). + 875 2. Or/and provide methods for processing events by 'family', e.g. + 876 process_IN_CLOSE method will process both IN_CLOSE_WRITE and + 877 IN_CLOSE_NOWRITE events (if process_IN_CLOSE_WRITE and + 878 process_IN_CLOSE_NOWRITE aren't defined though). + 879 3. Or/and override process_default for catching and processing all + 880 the remaining types of events. + 881 """ + 882 pevent = None + 883 +
    884 - def __init__(self, pevent=None, **kargs): +
    885 """ + 886 Enable chaining of ProcessEvent instances. + 887 + 888 @param pevent: Optional callable object, will be called on event + 889 processing (before self). + 890 @type pevent: callable + 891 @param kargs: This constructor is implemented as a template method + 892 delegating its optionals keyworded arguments to the + 893 method my_init(). + 894 @type kargs: dict + 895 """ + 896 self.pevent = pevent + 897 self.my_init(**kargs) -
    934 -
    935 - def my_init(self, **kargs): -
    936 """ - 937 This method is called from ProcessEvent.__init__(). This method is - 938 empty here and must be redefined to be useful. In effect, if you - 939 need to specifically initialize your subclass' instance then you - 940 just have to override this method in your subclass. Then all the - 941 keyworded arguments passed to ProcessEvent.__init__() will be - 942 transmitted as parameters to this method. Beware you MUST pass - 943 keyword arguments though. - 944 - 945 @param kargs: optional delegated arguments from __init__(). - 946 @type kargs: dict - 947 """ - 948 pass -
    949 -
    950 - def __call__(self, event): -
    951 stop_chaining = False - 952 if self.pevent is not None: - 953 # By default methods return None so we set as guideline - 954 # that methods asking for stop chaining must explicitely - 955 # return non None or non False values, otherwise the default - 956 # behavior will be to accept chain call to the corresponding - 957 # local method. - 958 stop_chaining = self.pevent(event) - 959 if not stop_chaining: - 960 return _ProcessEvent.my_init(**kargs) +
    898 +
    899 - def my_init(self, **kargs): +
    900 """ + 901 This method is called from ProcessEvent.__init__(). This method is + 902 empty here and must be redefined to be useful. In effect, if you + 903 need to specifically initialize your subclass' instance then you + 904 just have to override this method in your subclass. Then all the + 905 keyworded arguments passed to ProcessEvent.__init__() will be + 906 transmitted as parameters to this method. Beware you MUST pass + 907 keyword arguments though. + 908 + 909 @param kargs: optional delegated arguments from __init__(). + 910 @type kargs: dict + 911 """ + 912 pass +
    913 +
    914 - def __call__(self, event): +
    915 stop_chaining = False + 916 if self.pevent is not None: + 917 # By default methods return None so we set as guideline + 918 # that methods asking for stop chaining must explicitely + 919 # return non None or non False values, otherwise the default + 920 # behavior will be to accept chain call to the corresponding + 921 # local method. + 922 stop_chaining = self.pevent(event) + 923 if not stop_chaining: + 924 return _ProcessEvent.__call__(self, event) -
    961 -
    962 - def nested_pevent(self): -
    963 return self.pevent -
    964 -
    965 - def process_IN_Q_OVERFLOW(self, event): -
    966 """ - 967 By default this method only reports warning messages, you can overredide - 968 it by subclassing ProcessEvent and implement your own - 969 process_IN_Q_OVERFLOW method. The actions you can take on receiving this - 970 event is either to update the variable max_queued_events in order to - 971 handle more simultaneous events or to modify your code in order to - 972 accomplish a better filtering diminishing the number of raised events. - 973 Because this method is defined, IN_Q_OVERFLOW will never get - 974 transmitted as arguments to process_default calls. +pyinotify._ProcessEvent.__call__" class="py-name" href="#" onclick="return doclink('link-268', '__call__', 'link-268');">__call__(self, event) +
    925 +
    926 - def nested_pevent(self): +
    927 return self.pevent +
    928 +
    929 - def process_IN_Q_OVERFLOW(self, event): +
    930 """ + 931 By default this method only reports warning messages, you can overredide + 932 it by subclassing ProcessEvent and implement your own + 933 process_IN_Q_OVERFLOW method. The actions you can take on receiving this + 934 event is either to update the variable max_queued_events in order to + 935 handle more simultaneous events or to modify your code in order to + 936 accomplish a better filtering diminishing the number of raised events. + 937 Because this method is defined, IN_Q_OVERFLOW will never get + 938 transmitted as arguments to process_default calls. + 939 + 940 @param event: IN_Q_OVERFLOW event. + 941 @type event: dict + 942 """ + 943 log.warning('Event queue overflowed.') +
    944 +
    945 - def process_default(self, event): +
    946 """ + 947 Default processing event method. By default does nothing. Subclass + 948 ProcessEvent and redefine this method in order to modify its behavior. + 949 + 950 @param event: Event to be processed. Can be of any type of events but + 951 IN_Q_OVERFLOW events (see method process_IN_Q_OVERFLOW). + 952 @type event: Event instance + 953 """ + 954 pass +
    955 +
    956 + 957 -class PrintAllEvents(ProcessEvent): +
    958 """ + 959 Dummy class used to print events strings representations. For instance this + 960 class is used from command line to print all received events to stdout. + 961 """ +
    962 - def my_init(self, out=None): +
    963 """ + 964 @param out: Where events will be written. + 965 @type out: Object providing a valid file object interface. + 966 """ + 967 if out is None: + 968 out = sys.stdout + 969 self._out = out +
    970 +
    971 - def process_default(self, event): +
    972 """ + 973 Writes event string representation to file object provided to + 974 my_init(). 975 - 976 @param event: IN_Q_OVERFLOW event. - 977 @type event: dict - 978 """ - 979 log.warning('Event queue overflowed.') -
    980 -
    981 - def process_default(self, event): -
    982 """ - 983 Default processing event method. By default does nothing. Subclass - 984 ProcessEvent and redefine this method in order to modify its behavior. - 985 - 986 @param event: Event to be processed. Can be of any type of events but - 987 IN_Q_OVERFLOW events (see method process_IN_Q_OVERFLOW). - 988 @type event: Event instance - 989 """ - 990 pass -
    991 -
    992 - 993 -class PrintAllEvents(ProcessEvent): -
    994 """ - 995 Dummy class used to print events strings representations. For instance this - 996 class is used from command line to print all received events to stdout. - 997 """ -
    998 - def my_init(self, out=None): -
    999 """ -1000 @param out: Where events will be written. -1001 @type out: Object providing a valid file object interface. -1002 """ -1003 if out is None: -1004 out = sys.stdout -1005 self._out = out -
    1006 -
    1007 - def process_default(self, event): -
    1008 """ -1009 Writes event string representation to file object provided to -1010 my_init(). -1011 -1012 @param event: Event to be processed. Can be of any type of events but -1013 IN_Q_OVERFLOW events (see method process_IN_Q_OVERFLOW). -1014 @type event: Event instance + 976 @param event: Event to be processed. Can be of any type of events but + 977 IN_Q_OVERFLOW events (see method process_IN_Q_OVERFLOW). + 978 @type event: Event instance + 979 """ + 980 self._out.write(str(event)) + 981 self._out.write('\n') + 982 self._out.flush() +
    983 +
    984 + 985 -class ChainIfTrue(ProcessEvent): +
    986 """ + 987 Makes conditional chaining depending on the result of the nested + 988 processing instance. + 989 """ +
    990 - def my_init(self, func): +
    991 """ + 992 Method automatically called from base class constructor. + 993 """ + 994 self._func = func +
    995 +
    996 - def process_default(self, event): +
    997 return not self._func(event) +
    998 +
    999 +1000 -class Stats(ProcessEvent): +
    1001 """ +1002 Compute and display trivial statistics about processed events. +1003 """ +
    1004 - def my_init(self): +
    1005 """ +1006 Method automatically called from base class constructor. +1007 """ +1008 self._start_time = time.time() +1009 self._stats = {} +1010 self._stats_lock = threading.Lock() +
    1011 +
    1012 - def process_default(self, event): +
    1013 """ +1014 Processes |event|. 1015 """ -1016 self._out.write(str(event)) -1017 self._out.write('\n') -1018 self._out.flush() -
    1019 -
    1020 -1021 -class ChainIfTrue(ProcessEvent): -
    1022 """ -1023 Makes conditional chaining depending on the result of the nested -1024 processing instance. -1025 """ -
    1026 - def my_init(self, func): -
    1027 """ -1028 Method automatically called from base class constructor. -1029 """ -1030 self._func = func +1016 self._stats_lock.acquire() +1017 try: +1018 events = event.maskname.split('|') +1019 for event_name in events: +1020 count = self._stats.get(event_name, 0) +1021 self._stats[event_name] = count + 1 +1022 finally: +1023 self._stats_lock.release() +
    1024 +
    1025 - def _stats_copy(self): +
    1026 self._stats_lock.acquire() +1027 try: +1028 return self._stats.copy() +1029 finally: +1030 self._stats_lock.release()
    1031 -
    1032 - def process_default(self, event): -
    1033 return not self._func(event) -
    1034 -
    1035 -1036 -class Stats(ProcessEvent): -
    1037 """ -1038 Compute and display trivial statistics about processed events. -1039 """ -
    1040 - def my_init(self): -
    1041 """ -1042 Method automatically called from base class constructor. -1043 """ -1044 self._start_time = time.time() -1045 self._stats = {} -1046 self._stats_lock = threading.Lock() -
    1047 -
    1048 - def process_default(self, event): -
    1049 """ -1050 Processes |event|. -1051 """ -1052 self._stats_lock.acquire() -1053 try: -1054 events = event.maskname.split('|') -1055 for event_name in events: -1056 count = self._stats.get(event_name, 0) -1057 self._stats[event_name] = count + 1 -1058 finally: -1059 self._stats_lock.release() -
    1060 -
    1061 - def _stats_copy(self): -
    1062 self._stats_lock.acquire() -1063 try: -1064 return self._stats.copy() -1065 finally: -1066 self._stats_lock.release() +
    1032 - def __repr__(self): +
    1033 stats = self._stats_copy() +1034 +1035 elapsed = int(time.time() - self._start_time) +1036 elapsed_str = '' +1037 if elapsed < 60: +1038 elapsed_str = str(elapsed) + 'sec' +1039 elif 60 <= elapsed < 3600: +1040 elapsed_str = '%dmn%dsec' % (elapsed / 60, elapsed % 60) +1041 elif 3600 <= elapsed < 86400: +1042 elapsed_str = '%dh%dmn' % (elapsed / 3600, (elapsed % 3600) / 60) +1043 elif elapsed >= 86400: +1044 elapsed_str = '%dd%dh' % (elapsed / 86400, (elapsed % 86400) / 3600) +1045 stats['ElapsedTime'] = elapsed_str +1046 +1047 l = [] +1048 for ev, value in sorted(stats.items(), key=lambda x: x[0]): +1049 l.append(' %s=%s' % (output_format.field_name(ev), +1050 output_format.field_value(value))) +1051 s = '<%s%s >' % (output_format.class_name(self.__class__.__name__), +1052 ''.join(l)) +1053 return s +
    1054 +
    1055 - def dump(self, filename): +
    1056 """ +1057 Dumps statistics. +1058 +1059 @param filename: filename where stats will be dumped, filename is +1060 created and must not exist prior to this call. +1061 @type filename: string +1062 """ +1063 flags = os.O_WRONLY|os.O_CREAT|os.O_NOFOLLOW|os.O_EXCL +1064 fd = os.open(filename, flags, 0600) +1065 os.write(fd, str(self)) +1066 os.close(fd)
    1067 -
    1068 - def __repr__(self): -
    1069 stats = self._stats_copy() -1070 -1071 elapsed = int(time.time() - self._start_time) -1072 elapsed_str = '' -1073 if elapsed < 60: -1074 elapsed_str = str(elapsed) + 'sec' -1075 elif 60 <= elapsed < 3600: -1076 elapsed_str = '%dmn%dsec' % (elapsed / 60, elapsed % 60) -1077 elif 3600 <= elapsed < 86400: -1078 elapsed_str = '%dh%dmn' % (elapsed / 3600, (elapsed % 3600) / 60) -1079 elif elapsed >= 86400: -1080 elapsed_str = '%dd%dh' % (elapsed / 86400, (elapsed % 86400) / 3600) -1081 stats['ElapsedTime'] = elapsed_str -1082 -1083 l = [] -1084 for ev, value in sorted(stats.items(), key=lambda x: x[0]): -1085 l.append(' %s=%s' % (output_format.field_name(ev), -1086 output_format.field_value(value))) -1087 s = '<%s%s >' % (output_format.class_name(self.__class__.__name__), -1088 ''.join(l)) -1089 return s -
    1090 -
    1091 - def dump(self, filename): -
    1092 """ -1093 Dumps statistics. -1094 -1095 @param filename: filename where stats will be dumped, filename is -1096 created and must not exist prior to this call. -1097 @type filename: string -1098 """ -1099 flags = os.O_WRONLY|os.O_CREAT|os.O_NOFOLLOW|os.O_EXCL -1100 fd = os.open(filename, flags, 0600) -1101 os.write(fd, str(self)) -1102 os.close(fd) -
    1103 -
    1104 - def __str__(self, scale=45): -
    1105 stats = self._stats_copy() -1106 if not stats: -1107 return '' -1108 -1109 m = max(stats.values()) -1110 unity = float(scale) / m -1111 fmt = '%%-26s%%-%ds%%s' % (len(output_format.field_value('@' * scale)) -1112 + 1) -1113 def func(x): -1114 return fmt % (output_format.field_name(x[0]), -1115 output_format.field_value('@' * int(x[1] * unity)), -1116 output_format.simple('%d' % x[1], 'yellow')) -
    1117 s = '\n'.join(map(func, sorted(stats.items(), key=lambda x: x[0]))) -1118 return s -
    1119 -
    1120 -1121 -class NotifierError(PyinotifyError): -
    1122 """ -1123 Notifier Exception. Raised on Notifier error. -1124 -1125 """ -
    1126 - def __init__(self, err): -
    1127 """ -1128 @param err: Exception string's description. -1129 @type err: string -1130 """ -1131 PyinotifyError.
    1068 - def __str__(self, scale=45): +
    1069 stats = self._stats_copy() +1070 if not stats: +1071 return '' +1072 +1073 m = max(stats.values()) +1074 unity = float(scale) / m +1075 fmt = '%%-26s%%-%ds%%s' % (len(output_format.field_value('@' * scale)) +1076 + 1) +1077 def func(x): +1078 return fmt % (output_format.field_name(x[0]), +1079 output_format.field_value('@' * int(x[1] * unity)), +1080 output_format.simple('%d' % x[1], 'yellow')) +
    1081 s = '\n'.join(map(func, sorted(stats.items(), key=lambda x: x[0]))) +1082 return s +
    1083 +
    1084 +1085 -class NotifierError(PyinotifyError): +
    1086 """ +1087 Notifier Exception. Raised on Notifier error. +1088 +1089 """ +
    1090 - def __init__(self, err): +
    1091 """ +1092 @param err: Exception string's description. +1093 @type err: string +1094 """ +1095 PyinotifyError.__init__(self, err) -
    1132 -
    1133 -1134 -class Notifier: -
    1135 """ -1136 Read notifications, process events. -1137 -1138 """ -
    1139 - def __init__(self, watch_manager, default_proc_fun=None, read_freq=0, -1140 threshold=0, timeout=None): -
    1141 """ -1142 Initialization. read_freq, threshold and timeout parameters are used -1143 when looping. -1144 -1145 @param watch_manager: Watch Manager. -1146 @type watch_manager: WatchManager instance -1147 @param default_proc_fun: Default processing method. If None, a new -1148 instance of PrintAllEvents will be assigned. -1149 @type default_proc_fun: instance of ProcessEvent -1150 @param read_freq: if read_freq == 0, events are read asap, -1151 if read_freq is > 0, this thread sleeps -1152 max(0, read_freq - timeout) seconds. But if -1153 timeout is None it may be different because -1154 poll is blocking waiting for something to read. -1155 @type read_freq: int -1156 @param threshold: File descriptor will be read only if the accumulated -1157 size to read becomes >= threshold. If != 0, you likely -1158 want to use it in combination with an appropriate -1159 value for read_freq because without that you would -1160 keep looping without really reading anything and that -1161 until the amount of events to read is >= threshold. -1162 At least with read_freq set you might sleep. -1163 @type threshold: int -1164 @param timeout: -1165 https://docs.python.org/3/library/select.html#polling-objects -1166 @type timeout: int -1167 """ -1168 # Watch Manager instance -1169 self._watch_manager = watch_manager -1170 # File descriptor -1171 self._fd = self._watch_manager.get_fd() -1172 # Poll object and registration -1173 self._pollobj = select.poll() -1174 self._pollobj.register(self._fd, select.POLLIN) -1175 # This pipe is correctely initialized and used by ThreadedNotifier -1176 self._pipe = (-1, -1) -1177 # Event queue -1178 self._eventq = deque() -1179 # System processing functor, common to all events -1180 self._sys_proc_fun = _SysProcessEvent(self._watch_manager, self) -1181 # Default processing method -1182 self._default_proc_fun = default_proc_fun -1183 if default_proc_fun is None: -1184 self._default_proc_fun = PrintAllEvents() -1185 # Loop parameters -1186 self._read_freq = read_freq -1187 self._threshold = threshold -1188 self._timeout = timeout -1189 # Coalesce events option -1190 self._coalesce = False -1191 # set of str(raw_event), only used when coalesce option is True -1192 self._eventset = set() -
    1193 -
    1194 - def append_event(self, event): -
    1195 """ -1196 Append a raw event to the event queue. -1197 -1198 @param event: An event. -1199 @type event: _RawEvent instance. -1200 """ -1201 self._eventq.append(event) -
    1202 -
    1203 - def proc_fun(self): -
    1204 return self._default_proc_fun -
    1205 -
    1206 - def coalesce_events(self, coalesce=True): -
    1207 """ -1208 Coalescing events. Events are usually processed by batchs, their size -1209 depend on various factors. Thus, before processing them, events received -1210 from inotify are aggregated in a fifo queue. If this coalescing -1211 option is enabled events are filtered based on their unicity, only -1212 unique events are enqueued, doublons are discarded. An event is unique -1213 when the combination of its fields (wd, mask, cookie, name) is unique -1214 among events of a same batch. After a batch of events is processed any -1215 events is accepted again. By default this option is disabled, you have -1216 to explictly call this function to turn it on. -1217 -1218 @param coalesce: Optional new coalescing value. True by default. -1219 @type coalesce: Bool -1220 """ -1221 self._coalesce = coalesce -1222 if not coalesce: -1223 self._eventset.clear() -
    1224 -
    1225 - def check_events(self, timeout=None): -
    1226 """ -1227 Check for new events available to read, blocks up to timeout -1228 milliseconds. -1229 -1230 @param timeout: If specified it overrides the corresponding instance -1231 attribute _timeout. -1232 @type timeout: int -1233 -1234 @return: New events to read. -1235 @rtype: bool -1236 """ -1237 while True: -1238 try: -1239 # blocks up to 'timeout' milliseconds -1240 if timeout is None: -1241 timeout = self._timeout -1242 ret = self._pollobj.poll(timeout) -1243 except select.error, err: -1244 if err[0] == errno.EINTR: -1245 continue # interrupted, retry -1246 else: -1247 raise -1248 else: -1249 break -1250 -1251 if not ret or (self._pipe[0] == ret[0][0]): -1252 return False -1253 # only one fd is polled -1254 return ret[0][1] & select.POLLIN -
    1255 -
    1256 - def read_events(self): -
    1257 """ -1258 Read events from device, build _RawEvents, and enqueue them. -1259 """ -1260 buf_ = array.array('i', [0]) -1261 # get event queue size -1262 if fcntl.ioctl(self._fd, termios.FIONREAD, buf_, 1) == -1: -1263 return -1264 queue_size = buf_[0] -1265 if queue_size < self._threshold: -1266 log.debug('(fd: %d) %d bytes available to read but threshold is ' -1267 'fixed to %d bytes', self._fd, queue_size, -1268 self._threshold) -1269 return -1270 -1271 try: -1272 # Read content from file -1273 r = os.read(self._fd, queue_size) -1274 except Exception, msg: -1275 raise NotifierError(msg) -1276 log.debug('Event queue size: %d', queue_size) -1277 rsum = 0 # counter -1278 while rsum < queue_size: -1279 s_size = 16 -1280 # Retrieve wd, mask, cookie and fname_len -1281 wd, mask, cookie, fname_len = struct.unpack('iIII', -1282 r[rsum:rsum+s_size]) -1283 # Retrieve name -1284 fname, = struct.unpack('%ds' % fname_len, -1285 r[rsum + s_size:rsum + s_size + fname_len]) -1286 rawevent = _RawEvent(wd, mask, cookie, fname) -1287 if self._coalesce: -1288 # Only enqueue new (unique) events. -1289 raweventstr = str(rawevent) -1290 if raweventstr not in self._eventset: -1291 self._eventset.add(raweventstr) -1292 self._eventq.append(rawevent) -1293 else: -1294 self._eventq.append(rawevent) -1295 rsum += s_size + fname_len -
    1296 -
    1297 - def process_events(self): -
    1298 """ -1299 Routine for processing events from queue by calling their -1300 associated proccessing method (an instance of ProcessEvent). -1301 It also does internal processings, to keep the system updated. +pyinotify._SysProcessEvent.__init__" class="py-name" href="#" onclick="return doclink('link-292', '__init__', 'link-1');">__init__(self, err) +
    1096 +
    1097 +1098 -class Notifier: +
    1099 """ +1100 Read notifications, process events. +1101 +1102 """ +
    1103 - def __init__(self, watch_manager, default_proc_fun=None, read_freq=0, +1104 threshold=0, timeout=None): +
    1105 """ +1106 Initialization. read_freq, threshold and timeout parameters are used +1107 when looping. +1108 +1109 @param watch_manager: Watch Manager. +1110 @type watch_manager: WatchManager instance +1111 @param default_proc_fun: Default processing method. If None, a new +1112 instance of PrintAllEvents will be assigned. +1113 @type default_proc_fun: instance of ProcessEvent +1114 @param read_freq: if read_freq == 0, events are read asap, +1115 if read_freq is > 0, this thread sleeps +1116 max(0, read_freq - (timeout / 1000)) seconds. But +1117 if timeout is None it may be different because +1118 poll is blocking waiting for something to read. +1119 @type read_freq: int +1120 @param threshold: File descriptor will be read only if the accumulated +1121 size to read becomes >= threshold. If != 0, you likely +1122 want to use it in combination with an appropriate +1123 value for read_freq because without that you would +1124 keep looping without really reading anything and that +1125 until the amount of events to read is >= threshold. +1126 At least with read_freq set you might sleep. +1127 @type threshold: int +1128 @param timeout: see read_freq above. If provided, it must be set in +1129 milliseconds. See +1130 https://docs.python.org/2/library/select.html#polling-objects +1131 @type timeout: int +1132 """ +1133 # Watch Manager instance +1134 self._watch_manager = watch_manager +1135 # File descriptor +1136 self._fd = self._watch_manager.get_fd() +1137 # Poll object and registration +1138 self._pollobj = select.poll() +1139 self._pollobj.register(self._fd, select.POLLIN) +1140 # This pipe is correctely initialized and used by ThreadedNotifier +1141 self._pipe = (-1, -1) +1142 # Event queue +1143 self._eventq = deque() +1144 # System processing functor, common to all events +1145 self._sys_proc_fun = _SysProcessEvent(self._watch_manager, self) +1146 # Default processing method +1147 self._default_proc_fun = default_proc_fun +1148 if default_proc_fun is None: +1149 self._default_proc_fun = PrintAllEvents() +1150 # Loop parameters +1151 self._read_freq = read_freq +1152 self._threshold = threshold +1153 self._timeout = timeout +1154 # Coalesce events option +1155 self._coalesce = False +1156 # set of str(raw_event), only used when coalesce option is True +1157 self._eventset = set() +
    1158 +
    1159 - def append_event(self, event): +
    1160 """ +1161 Append a raw event to the event queue. +1162 +1163 @param event: An event. +1164 @type event: _RawEvent instance. +1165 """ +1166 self._eventq.append(event) +
    1167 +
    1168 - def proc_fun(self): +
    1169 return self._default_proc_fun +
    1170 +
    1171 - def coalesce_events(self, coalesce=True): +
    1172 """ +1173 Coalescing events. Events are usually processed by batchs, their size +1174 depend on various factors. Thus, before processing them, events received +1175 from inotify are aggregated in a fifo queue. If this coalescing +1176 option is enabled events are filtered based on their unicity, only +1177 unique events are enqueued, doublons are discarded. An event is unique +1178 when the combination of its fields (wd, mask, cookie, name) is unique +1179 among events of a same batch. After a batch of events is processed any +1180 events is accepted again. By default this option is disabled, you have +1181 to explictly call this function to turn it on. +1182 +1183 @param coalesce: Optional new coalescing value. True by default. +1184 @type coalesce: Bool +1185 """ +1186 self._coalesce = coalesce +1187 if not coalesce: +1188 self._eventset.clear() +
    1189 +
    1190 - def check_events(self, timeout=None): +
    1191 """ +1192 Check for new events available to read, blocks up to timeout +1193 milliseconds. +1194 +1195 @param timeout: If specified it overrides the corresponding instance +1196 attribute _timeout. timeout must be sepcified in +1197 milliseconds. +1198 @type timeout: int +1199 +1200 @return: New events to read. +1201 @rtype: bool +1202 """ +1203 while True: +1204 try: +1205 # blocks up to 'timeout' milliseconds +1206 if timeout is None: +1207 timeout = self._timeout +1208 ret = self._pollobj.poll(timeout) +1209 except select.error, err: +1210 if err[0] == errno.EINTR: +1211 continue # interrupted, retry +1212 else: +1213 raise +1214 else: +1215 break +1216 +1217 if not ret or (self._pipe[0] == ret[0][0]): +1218 return False +1219 # only one fd is polled +1220 return ret[0][1] & select.POLLIN +
    1221 +
    1222 - def read_events(self): +
    1223 """ +1224 Read events from device, build _RawEvents, and enqueue them. +1225 """ +1226 buf_ = array.array('i', [0]) +1227 # get event queue size +1228 if fcntl.ioctl(self._fd, termios.FIONREAD, buf_, 1) == -1: +1229 return +1230 queue_size = buf_[0] +1231 if queue_size < self._threshold: +1232 log.debug('(fd: %d) %d bytes available to read but threshold is ' +1233 'fixed to %d bytes', self._fd, queue_size, +1234 self._threshold) +1235 return +1236 +1237 try: +1238 # Read content from file +1239 r = os.read(self._fd, queue_size) +1240 except Exception, msg: +1241 raise NotifierError(msg) +1242 log.debug('Event queue size: %d', queue_size) +1243 rsum = 0 # counter +1244 while rsum < queue_size: +1245 s_size = 16 +1246 # Retrieve wd, mask, cookie and fname_len +1247 wd, mask, cookie, fname_len = struct.unpack('iIII', +1248 r[rsum:rsum+s_size]) +1249 # Retrieve name +1250 fname, = struct.unpack('%ds' % fname_len, +1251 r[rsum + s_size:rsum + s_size + fname_len]) +1252 rawevent = _RawEvent(wd, mask, cookie, fname) +1253 if self._coalesce: +1254 # Only enqueue new (unique) events. +1255 raweventstr = str(rawevent) +1256 if raweventstr not in self._eventset: +1257 self._eventset.add(raweventstr) +1258 self._eventq.append(rawevent) +1259 else: +1260 self._eventq.append(rawevent) +1261 rsum += s_size + fname_len +
    1262 +
    1263 - def process_events(self): +
    1264 """ +1265 Routine for processing events from queue by calling their +1266 associated proccessing method (an instance of ProcessEvent). +1267 It also does internal processings, to keep the system updated. +1268 """ +1269 while self._eventq: +1270 raw_event = self._eventq.popleft() # pop next event +1271 if self._watch_manager.ignore_events: +1272 log.debug("Event ignored: %s" % repr(raw_event)) +1273 continue +1274 watch_ = self._watch_manager.get_watch(raw_event.wd) +1275 if (watch_ is None) and not (raw_event.mask & IN_Q_OVERFLOW): +1276 if not (raw_event.mask & IN_IGNORED): +1277 # Not really sure how we ended up here, nor how we should +1278 # handle these types of events and if it is appropriate to +1279 # completly skip them (like we are doing here). +1280 log.warning("Unable to retrieve Watch object associated to %s", +1281 repr(raw_event)) +1282 continue +1283 revent = self._sys_proc_fun(raw_event) # system processings +1284 if watch_ and watch_.proc_fun: +1285 watch_.proc_fun(revent) # user processings +1286 else: +1287 self._default_proc_fun(revent) +1288 self._sys_proc_fun.cleanup() # remove olds MOVED_* events records +1289 if self._coalesce: +1290 self._eventset.clear() +
    1291 +
    1292 - def __daemonize(self, pid_file=None, stdin=os.devnull, stdout=os.devnull, +1293 stderr=os.devnull): +
    1294 """ +1295 @param pid_file: file where the pid will be written. If pid_file=None +1296 the pid is written to +1297 /var/run/<sys.argv[0]|pyinotify>.pid, if pid_file=False +1298 no pid_file is written. +1299 @param stdin: +1300 @param stdout: +1301 @param stderr: files associated to common streams. 1302 """ -1303 while self._eventq: -1304 raw_event = self._eventq.popleft() # pop next event -1305 if self._watch_manager.ignore_events: -1306 log.debug("Event ignored: %s" % repr(raw_event)) -1307 continue -1308 watch_ = self._watch_manager.get_watch(raw_event.wd) -1309 if (watch_ is None) and not (raw_event.mask & IN_Q_OVERFLOW): -1310 if not (raw_event.mask & IN_IGNORED): -1311 # Not really sure how we ended up here, nor how we should -1312 # handle these types of events and if it is appropriate to -1313 # completly skip them (like we are doing here). -1314 log.warning("Unable to retrieve Watch object associated to %s", -1315 repr(raw_event)) -1316 continue -1317 revent = self._sys_proc_fun(raw_event) # system processings -1318 if watch_ and watch_.proc_fun: -1319 watch_.proc_fun(revent) # user processings -1320 else: -1321 self._default_proc_fun(revent) -1322 self._sys_proc_fun.cleanup() # remove olds MOVED_* events records -1323 if self._coalesce: -1324 self._eventset.clear() -
    1325 -
    1326 - def __daemonize(self, pid_file=None, stdin=os.devnull, stdout=os.devnull, -1327 stderr=os.devnull): -
    1328 """ -1329 @param pid_file: file where the pid will be written. If pid_file=None -1330 the pid is written to -1331 /var/run/<sys.argv[0]|pyinotify>.pid, if pid_file=False -1332 no pid_file is written. -1333 @param stdin: -1334 @param stdout: -1335 @param stderr: files associated to common streams. -1336 """ -1337 if pid_file is None: -1338 dirname = '/var/run/' -1339 basename = os.path.basename(sys.argv[0]) or 'pyinotify' -1340 pid_file = os.path.join(dirname, basename + '.pid') -1341 -1342 if pid_file != False and os.path.lexists(pid_file): -1343 err = 'Cannot daemonize: pid file %s already exists.' % pid_file -1344 raise NotifierError(err) -1345 -1346 def fork_daemon(): -1347 # Adapted from Chad J. Schroeder's recipe -1348 # @see http://code.activestate.com/recipes/278731/ -1349 pid = os.fork() -1350 if (pid == 0): -1351 # parent 2 -1352 os.setsid() -1353 pid = os.fork() -1354 if (pid == 0): -1355 # child -1356 os.chdir('/') -1357 os.umask(022) -1358 else: -1359 # parent 2 -1360 os._exit(0) -1361 else: -1362 # parent 1 -1363 os._exit(0) -1364 -1365 fd_inp = os.open(stdin, os.O_RDONLY) -1366 os.dup2(fd_inp, 0) -1367 fd_out = os.open(stdout, os.O_WRONLY|os.O_CREAT, 0600) -1368 os.dup2(fd_out, 1) -1369 fd_err = os.open(stderr, os.O_WRONLY|os.O_CREAT, 0600) -1370 os.dup2(fd_err, 2) -
    1371 -1372 # Detach task -1373 fork_daemon() -1374 -1375 # Write pid -1376 if pid_file != False: -1377 flags = os.O_WRONLY|os.O_CREAT|os.O_NOFOLLOW|os.O_EXCL -1378 fd_pid = os.open(pid_file, flags, 0600) -1379 os.write(fd_pid, str(os.getpid()) + '\n') -1380 os.close(fd_pid) -1381 # Register unlink function -1382 atexit.register(lambda : os.unlink(pid_file)) -
    1383 -
    1384 - def _sleep(self, ref_time): -
    1385 # Only consider sleeping if read_freq is > 0 -1386 if self._read_freq > 0: -1387 cur_time = time.time() -1388 sleep_amount = self._read_freq - (cur_time - ref_time) -1389 if sleep_amount > 0: -1390 log.debug('Now sleeping %d seconds', sleep_amount) -1391 time.sleep(sleep_amount) -
    1392 -
    1393 - def loop(self, callback=None, daemonize=False, **args): -
    1394 """ -1395 Events are read only one time every min(read_freq, timeout) -1396 seconds at best and only if the size to read is >= threshold. -1397 After this method returns it must not be called again for the same -1398 instance. -1399 -1400 @param callback: Functor called after each event processing iteration. -1401 Expects to receive the notifier object (self) as first -1402 parameter. If this function returns True the loop is -1403 immediately terminated otherwise the loop method keeps -1404 looping. -1405 @type callback: callable object or function -1406 @param daemonize: This thread is daemonized if set to True. -1407 @type daemonize: boolean -1408 @param args: Optional and relevant only if daemonize is True. Remaining -1409 keyworded arguments are directly passed to daemonize see -1410 __daemonize() method. If pid_file=None or is set to a -1411 pathname the caller must ensure the file does not exist -1412 before this method is called otherwise an exception -1413 pyinotify.NotifierError will be raised. If pid_file=False -1414 it is still daemonized but the pid is not written in any -1415 file. -1416 @type args: various -1417 """ -1418 if daemonize: -1419 self.__daemonize(**args) -1420 -1421 # Read and process events forever -1422 while 1: -1423 try: -1424 self.process_events() -1425 if (callback is not None) and (callback(self) is True): -1426 break -1427 ref_time = time.time() -1428 # check_events is blocking -1429 if self.check_events(): -1430 self._sleep(ref_time) -1431 self.read_events() -1432 except KeyboardInterrupt: -1433 # Stop monitoring if sigint is caught (Control-C). -1434 log.debug('Pyinotify stops monitoring.') -1435 break -1436 # Close internals -1437 self.1303 if pid_file is None: +1304 dirname = '/var/run/' +1305 basename = os.path.basename(sys.argv[0]) or 'pyinotify' +1306 pid_file = os.path.join(dirname, basename + '.pid') +1307 +1308 if pid_file != False and os.path.lexists(pid_file): +1309 err = 'Cannot daemonize: pid file %s already exists.' % pid_file +1310 raise NotifierError(err) +1311 +1312 def fork_daemon(): +1313 # Adapted from Chad J. Schroeder's recipe +1314 # @see http://code.activestate.com/recipes/278731/ +1315 pid = os.fork() +1316 if (pid == 0): +1317 # parent 2 +1318 os.setsid() +1319 pid = os.fork() +1320 if (pid == 0): +1321 # child +1322 os.chdir('/') +1323 os.umask(022) +1324 else: +1325 # parent 2 +1326 os._exit(0) +1327 else: +1328 # parent 1 +1329 os._exit(0) +1330 +1331 fd_inp = os.open(stdin, os.O_RDONLY) +1332 os.dup2(fd_inp, 0) +1333 fd_out = os.open(stdout, os.O_WRONLY|os.O_CREAT, 0600) +1334 os.dup2(fd_out, 1) +1335 fd_err = os.open(stderr, os.O_WRONLY|os.O_CREAT, 0600) +1336 os.dup2(fd_err, 2) +
    1337 +1338 # Detach task +1339 fork_daemon() +1340 +1341 # Write pid +1342 if pid_file != False: +1343 flags = os.O_WRONLY|os.O_CREAT|os.O_NOFOLLOW|os.O_EXCL +1344 fd_pid = os.open(pid_file, flags, 0600) +1345 os.write(fd_pid, str(os.getpid()) + '\n') +1346 os.close(fd_pid) +1347 # Register unlink function +1348 atexit.register(lambda : os.unlink(pid_file)) +
    1349 +
    1350 - def _sleep(self, ref_time): +
    1351 # Only consider sleeping if read_freq is > 0 +1352 if self._read_freq > 0: +1353 cur_time = time.time() +1354 sleep_amount = self._read_freq - (cur_time - ref_time) +1355 if sleep_amount > 0: +1356 log.debug('Now sleeping %d seconds', sleep_amount) +1357 time.sleep(sleep_amount) +
    1358 +
    1359 - def loop(self, callback=None, daemonize=False, **args): +
    1360 """ +1361 Events are read only one time every min(read_freq, timeout) +1362 seconds at best and only if the size to read is >= threshold. +1363 After this method returns it must not be called again for the same +1364 instance. +1365 +1366 @param callback: Functor called after each event processing iteration. +1367 Expects to receive the notifier object (self) as first +1368 parameter. If this function returns True the loop is +1369 immediately terminated otherwise the loop method keeps +1370 looping. +1371 @type callback: callable object or function +1372 @param daemonize: This thread is daemonized if set to True. +1373 @type daemonize: boolean +1374 @param args: Optional and relevant only if daemonize is True. Remaining +1375 keyworded arguments are directly passed to daemonize see +1376 __daemonize() method. If pid_file=None or is set to a +1377 pathname the caller must ensure the file does not exist +1378 before this method is called otherwise an exception +1379 pyinotify.NotifierError will be raised. If pid_file=False +1380 it is still daemonized but the pid is not written in any +1381 file. +1382 @type args: various +1383 """ +1384 if daemonize: +1385 self.__daemonize(**args) +1386 +1387 # Read and process events forever +1388 while 1: +1389 try: +1390 self.process_events() +1391 if (callback is not None) and (callback(self) is True): +1392 break +1393 ref_time = time.time() +1394 # check_events is blocking +1395 if self.check_events(): +1396 self._sleep(ref_time) +1397 self.read_events() +1398 except KeyboardInterrupt: +1399 # Stop monitoring if sigint is caught (Control-C). +1400 log.debug('Pyinotify stops monitoring.') +1401 break +1402 # Close internals +1403 self.stop() -
    1438 -
    1439 - def stop(self): -
    1440 """ -1441 Close inotify's instance (close its file descriptor). -1442 It destroys all existing watches, pending events,... -1443 This method is automatically called at the end of loop(). -1444 """ -1445 self._pollobj.unregister(self._fd) -1446 os.close(self._fd) -1447 self._sys_proc_fun = None -
    1448 -
    1449 -1450 -class ThreadedNotifier(threading.Thread, Notifier): -
    1451 """ -1452 This notifier inherits from threading.Thread for instanciating a separate -1453 thread, and also inherits from Notifier, because it is a threaded notifier. -1454 -1455 Note that every functionality provided by this class is also provided -1456 through Notifier class. Moreover Notifier should be considered first because -1457 it is not threaded and could be easily daemonized. -1458 """ -
    1459 - def __init__(self, watch_manager, default_proc_fun=None, read_freq=0, -1460 threshold=0, timeout=None): -
    1461 """ -1462 Initialization, initialize base classes. read_freq, threshold and -1463 timeout parameters are used when looping. -1464 -1465 @param watch_manager: Watch Manager. -1466 @type watch_manager: WatchManager instance -1467 @param default_proc_fun: Default processing method. See base class. -1468 @type default_proc_fun: instance of ProcessEvent -1469 @param read_freq: if read_freq == 0, events are read asap, -1470 if read_freq is > 0, this thread sleeps -1471 max(0, read_freq - timeout) seconds. -1472 @type read_freq: int -1473 @param threshold: File descriptor will be read only if the accumulated -1474 size to read becomes >= threshold. If != 0, you likely -1475 want to use it in combination with an appropriate -1476 value set for read_freq because without that you would -1477 keep looping without really reading anything and that -1478 until the amount of events to read is >= threshold. At -1479 least with read_freq you might sleep. -1480 @type threshold: int -1481 @param timeout: -1482 https://docs.python.org/3/library/select.html#polling-objects -1483 @type timeout: int -1484 """ -1485 # Init threading base class -1486 threading.Thread.stop() +
    1404 +
    1405 - def stop(self): +
    1406 """ +1407 Close inotify's instance (close its file descriptor). +1408 It destroys all existing watches, pending events,... +1409 This method is automatically called at the end of loop(). +1410 Afterward it is invalid to access this instance. +1411 """ +1412 if self._fd is not None: +1413 self._pollobj.unregister(self._fd) +1414 os.close(self._fd) +1415 self._fd = None +1416 self._sys_proc_fun = None +
    1417 +
    1418 +1419 -class ThreadedNotifier(threading.Thread, Notifier): +
    1420 """ +1421 This notifier inherits from threading.Thread for instanciating a separate +1422 thread, and also inherits from Notifier, because it is a threaded notifier. +1423 +1424 Note that every functionality provided by this class is also provided +1425 through Notifier class. Moreover Notifier should be considered first because +1426 it is not threaded and could be easily daemonized. +1427 """ +
    1428 - def __init__(self, watch_manager, default_proc_fun=None, read_freq=0, +1429 threshold=0, timeout=None): +
    1430 """ +1431 Initialization, initialize base classes. read_freq, threshold and +1432 timeout parameters are used when looping. +1433 +1434 @param watch_manager: Watch Manager. +1435 @type watch_manager: WatchManager instance +1436 @param default_proc_fun: Default processing method. See base class. +1437 @type default_proc_fun: instance of ProcessEvent +1438 @param read_freq: if read_freq == 0, events are read asap, +1439 if read_freq is > 0, this thread sleeps +1440 max(0, read_freq - (timeout / 1000)) seconds. +1441 @type read_freq: int +1442 @param threshold: File descriptor will be read only if the accumulated +1443 size to read becomes >= threshold. If != 0, you likely +1444 want to use it in combination with an appropriate +1445 value set for read_freq because without that you would +1446 keep looping without really reading anything and that +1447 until the amount of events to read is >= threshold. At +1448 least with read_freq you might sleep. +1449 @type threshold: int +1450 @param timeout: see read_freq above. If provided, it must be set in +1451 milliseconds. See +1452 https://docs.python.org/2/library/select.html#select.poll.poll +1453 @type timeout: int +1454 """ +1455 # Init threading base class +1456 threading.Thread.__init__(self) -1487 # Stop condition -1488 self._stop_event = threading.Event() -1489 # Init Notifier base class -1490 Notifier.__init__(self) +1457 # Stop condition +1458 self._stop_event = threading.Event() +1459 # Init Notifier base class +1460 Notifier.__init__(self, watch_manager, default_proc_fun, read_freq, -1491 threshold, timeout) -1492 # Create a new pipe used for thread termination -1493 self._pipe = os.pipe() -1494 self._pollobj.register(self._pipe[0], select.POLLIN) -
    1495 -
    1496 - def stop(self): -
    1497 """ -1498 Stop notifier's loop. Stop notification. Join the thread. -1499 """ -1500 self._stop_event.set() -1501 os.write(self._pipe[1], 'stop') -1502 threading.Thread.join(self) -1503 Notifier.__init__(self, watch_manager, default_proc_fun, read_freq, +1461 threshold, timeout) +1462 # Create a new pipe used for thread termination +1463 self._pipe = os.pipe() +1464 self._pollobj.register(self._pipe[0], select.POLLIN) +
    1465 +
    1466 - def stop(self): +
    1467 """ +1468 Stop notifier's loop. Stop notification. Join the thread. +1469 """ +1470 self._stop_event.set() +1471 os.write(self._pipe[1], 'stop') +1472 threading.Thread.join(self) +1473 Notifier.stop(self) -1504 self._pollobj.unregister(self._pipe[0]) -1505 os.close(self._pipe[0]) -1506 os.close(self._pipe[1]) -
    1507 -
    1508 - def loop(self): -
    1509 """ -1510 Thread's main loop. Don't meant to be called by user directly. -1511 Call inherited start() method instead. +pyinotify.TornadoAsyncNotifier.stop" class="py-name" href="#" onclick="return doclink('link-335', 'stop', 'link-328');">stop(self) +1474 self._pollobj.unregister(self._pipe[0]) +1475 os.close(self._pipe[0]) +1476 os.close(self._pipe[1]) +
    1477 +
    1478 - def loop(self): +
    1479 """ +1480 Thread's main loop. Don't meant to be called by user directly. +1481 Call inherited start() method instead. +1482 +1483 Events are read only once time every min(read_freq, timeout) +1484 seconds at best and only if the size of events to read is >= threshold. +1485 """ +1486 # When the loop must be terminated .stop() is called, 'stop' +1487 # is written to pipe fd so poll() returns and .check_events() +1488 # returns False which make evaluate the While's stop condition +1489 # ._stop_event.isSet() wich put an end to the thread's execution. +1490 while not self._stop_event.isSet(): +1491 self.process_events() +1492 ref_time = time.time() +1493 if self.check_events(): +1494 self._sleep(ref_time) +1495 self.read_events() +
    1496 +
    1497 - def run(self): +
    1498 """ +1499 Start thread's loop: read and process events until the method +1500 stop() is called. +1501 Never call this method directly, instead call the start() method +1502 inherited from threading.Thread, which then will call run() in +1503 its turn. +1504 """ +1505 self.loop() +
    1506 +
    1507 +1508 -class AsyncNotifier(asyncore.file_dispatcher, Notifier): +
    1509 """ +1510 This notifier inherits from asyncore.file_dispatcher in order to be able to +1511 use pyinotify along with the asyncore framework. 1512 -1513 Events are read only once time every min(read_freq, timeout) -1514 seconds at best and only if the size of events to read is >= threshold. -1515 """ -1516 # When the loop must be terminated .stop() is called, 'stop' -1517 # is written to pipe fd so poll() returns and .check_events() -1518 # returns False which make evaluate the While's stop condition -1519 # ._stop_event.isSet() wich put an end to the thread's execution. -1520 while not self._stop_event.isSet(): -1521 self.process_events() -1522 ref_time = time.time() -1523 if self.check_events(): -1524 self._sleep(ref_time) -1525 self.read_events() -
    1526 -
    1527 - def run(self): -
    1528 """ -1529 Start thread's loop: read and process events until the method -1530 stop() is called. -1531 Never call this method directly, instead call the start() method -1532 inherited from threading.Thread, which then will call run() in -1533 its turn. -1534 """ -1535 self.loop() -
    1536 -
    1537 -1538 -class AsyncNotifier(asyncore.file_dispatcher, Notifier): -
    1539 """ -1540 This notifier inherits from asyncore.file_dispatcher in order to be able to -1541 use pyinotify along with the asyncore framework. -1542 -1543 """ -
    1544 - def __init__(self, watch_manager, default_proc_fun=None, read_freq=0, -1545 threshold=0, timeout=None, channel_map=None): -
    1546 """ -1547 Initializes the async notifier. The only additional parameter is -1548 'channel_map' which is the optional asyncore private map. See -1549 Notifier class for the meaning of the others parameters. -1550 -1551 """ -1552 Notifier.1513 """ +
    1514 - def __init__(self, watch_manager, default_proc_fun=None, read_freq=0, +1515 threshold=0, timeout=None, channel_map=None): +
    1516 """ +1517 Initializes the async notifier. The only additional parameter is +1518 'channel_map' which is the optional asyncore private map. See +1519 Notifier class for the meaning of the others parameters. +1520 +1521 """ +1522 Notifier.__init__(self, watch_manager, default_proc_fun, read_freq, -1553 threshold, timeout) -1554 asyncore.file_dispatcher.__init__(self, watch_manager, default_proc_fun, read_freq, +1523 threshold, timeout) +1524 asyncore.file_dispatcher.__init__(self, self._fd, channel_map) -
    1555 -
    1556 - def handle_read(self): -
    1557 """ -1558 When asyncore tells us we can read from the fd, we proceed processing -1559 events. This method can be overridden for handling a notification -1560 differently. -1561 -1562 """ -1563 self.read_events() -1564 self.process_events() -
    1565 -
    1566 -1567 -class TornadoAsyncNotifier(Notifier): -
    1568 """ -1569 Tornado ioloop adapter. -1570 -1571 """ -
    1572 - def __init__(self, watch_manager, ioloop, callback=None, -1573 default_proc_fun=None, read_freq=0, threshold=0, timeout=None, -1574 channel_map=None): -
    1575 """ -1576 Note that if later you must call ioloop.close() be sure to let the -1577 default parameter to all_fds=False. -1578 -1579 See example tornado_notifier.py for an example using this notifier. -1580 -1581 @param ioloop: Tornado's IO loop. -1582 @type ioloop: tornado.ioloop.IOLoop instance. -1583 @param callback: Functor called at the end of each call to handle_read -1584 (IOLoop's read handler). Expects to receive the -1585 notifier object (self) as single parameter. -1586 @type callback: callable object or function -1587 """ -1588 self.io_loop = ioloop -1589 self.handle_read_callback = callback -1590 Notifier.__init__(self, self._fd, channel_map) +
    1525 +
    1526 - def handle_read(self): +
    1527 """ +1528 When asyncore tells us we can read from the fd, we proceed processing +1529 events. This method can be overridden for handling a notification +1530 differently. +1531 +1532 """ +1533 self.read_events() +1534 self.process_events() +
    1535 +
    1536 +1537 -class TornadoAsyncNotifier(Notifier): +
    1538 """ +1539 Tornado ioloop adapter. +1540 +1541 """ +
    1542 - def __init__(self, watch_manager, ioloop, callback=None, +1543 default_proc_fun=None, read_freq=0, threshold=0, timeout=None, +1544 channel_map=None): +
    1545 """ +1546 Note that if later you must call ioloop.close() be sure to let the +1547 default parameter to all_fds=False. +1548 +1549 See example tornado_notifier.py for an example using this notifier. +1550 +1551 @param ioloop: Tornado's IO loop. +1552 @type ioloop: tornado.ioloop.IOLoop instance. +1553 @param callback: Functor called at the end of each call to handle_read +1554 (IOLoop's read handler). Expects to receive the +1555 notifier object (self) as single parameter. +1556 @type callback: callable object or function +1557 """ +1558 self.io_loop = ioloop +1559 self.handle_read_callback = callback +1560 Notifier.__init__(self, watch_manager, default_proc_fun, read_freq, -1591 threshold, timeout) -1592 ioloop.add_handler(self._fd, self.__init__(self, watch_manager, default_proc_fun, read_freq, +1561 threshold, timeout) +1562 ioloop.add_handler(self._fd, self.handle_read, ioloop.READ) -
    1593 -
    1594 - def stop(self): -
    1595 self.io_loop.remove_handler(self._fd) -1596 Notifier.handle_read, ioloop.READ) +
    1563 +
    1564 - def stop(self): +
    1565 self.io_loop.remove_handler(self._fd) +1566 Notifier.stop(self) -
    1597 -
    1598 - def handle_read(self, *args, **kwargs): -
    1599 """ -1600 See comment in AsyncNotifier. -1601 -1602 """ -1603 self.read_events() -1604 self.process_events() -1605 if self.handle_read_callback is not None: -1606 self.handle_read_callback(self) -
    1607 -
    1608 -1609 -class AsyncioNotifier(Notifier): -
    1610 """ -1611 -1612 asyncio/trollius event loop adapter. -1613 -1614 """ -
    1615 - def __init__(self, watch_manager, loop, callback=None, -1616 default_proc_fun=None, read_freq=0, threshold=0, timeout=None): -
    1617 """ -1618 -1619 See examples/asyncio_notifier.py for an example usage. -1620 -1621 @param loop: asyncio or trollius event loop instance. -1622 @type loop: asyncio.BaseEventLoop or trollius.BaseEventLoop instance. -1623 @param callback: Functor called at the end of each call to handle_read. -1624 Expects to receive the notifier object (self) as -1625 single parameter. -1626 @type callback: callable object or function -1627 -1628 """ -1629 self.loop = loop -1630 self.handle_read_callback = callback -1631 Notifier.stop(self) +
    1567 +
    1568 - def handle_read(self, *args, **kwargs): +
    1569 """ +1570 See comment in AsyncNotifier. +1571 +1572 """ +1573 self.read_events() +1574 self.process_events() +1575 if self.handle_read_callback is not None: +1576 self.handle_read_callback(self) +
    1577 +
    1578 +1579 -class AsyncioNotifier(Notifier): +
    1580 """ +1581 +1582 asyncio/trollius event loop adapter. +1583 +1584 """ +
    1585 - def __init__(self, watch_manager, loop, callback=None, +1586 default_proc_fun=None, read_freq=0, threshold=0, timeout=None): +
    1587 """ +1588 +1589 See examples/asyncio_notifier.py for an example usage. +1590 +1591 @param loop: asyncio or trollius event loop instance. +1592 @type loop: asyncio.BaseEventLoop or trollius.BaseEventLoop instance. +1593 @param callback: Functor called at the end of each call to handle_read. +1594 Expects to receive the notifier object (self) as +1595 single parameter. +1596 @type callback: callable object or function +1597 +1598 """ +1599 self.loop = loop +1600 self.handle_read_callback = callback +1601 Notifier.__init__(self, watch_manager, default_proc_fun, read_freq, -1632 threshold, timeout) -1633 loop.add_reader(self._fd, self.__init__(self, watch_manager, default_proc_fun, read_freq, +1602 threshold, timeout) +1603 loop.add_reader(self._fd, self.handle_read) -
    1634 -
    1635 - def stop(self): -
    1636 self.loop.remove_reader(self._fd) -1637 Notifier.handle_read) +
    1604 +
    1605 - def stop(self): +
    1606 self.loop.remove_reader(self._fd) +1607 Notifier.stop(self) -
    1638 -
    1639 - def handle_read(self, *args, **kwargs): -
    1640 self.read_events() -1641 self.process_events() -1642 if self.handle_read_callback is not None: -1643 self.handle_read_callback(self) -
    1644 -
    1645 -1646 -class Watch: -
    1647 """ -1648 Represent a watch, i.e. a file or directory being watched. -1649 -1650 """ -1651 __slots__ = ('wd', 'path', 'mask', 'proc_fun', 'auto_add', -1652 'exclude_filter', 'dir') -1653 -
    1654 - def __init__(self, wd, path, mask, proc_fun, auto_add, exclude_filter): -
    1655 """ -1656 Initializations. -1657 -1658 @param wd: Watch descriptor. -1659 @type wd: int -1660 @param path: Path of the file or directory being watched. -1661 @type path: str -1662 @param mask: Mask. -1663 @type mask: int -1664 @param proc_fun: Processing callable object. -1665 @type proc_fun: -1666 @param auto_add: Automatically add watches on new directories. -1667 @type auto_add: bool -1668 @param exclude_filter: Boolean function, used to exclude new -1669 directories from being automatically watched. -1670 See WatchManager.__init__ -1671 @type exclude_filter: callable object -1672 """ -1673 self.wd = wd -1674 self.path = path -1675 self.mask = mask -1676 self.proc_fun = proc_fun -1677 self.auto_add = auto_add -1678 self.exclude_filter = exclude_filter -1679 self.dir = os.path.isdir(self.path) -
    1680 -
    1681 - def __repr__(self): -
    1682 """ -1683 @return: String representation. -1684 @rtype: str -1685 """ -1686 s = ' '.join(['%s%s%s' % (output_format.field_name(attr), -1687 output_format.punctuation('='), -1688 output_format.field_value(getattr(self, -1689 attr))) \ -1690 for attr in self.__slots__ if not attr.startswith('_')]) -1691 -1692 s = '%s%s %s %s' % (output_format.punctuation('<'), -1693 output_format.class_name(self.__class__.__name__), -1694 s, -1695 output_format.punctuation('>')) -1696 return s -
    1697 -
    1698 -1699 -class ExcludeFilter: -
    1700 """ -1701 ExcludeFilter is an exclusion filter. -1702 -1703 """ -
    1704 - def __init__(self, arg_lst): -
    1705 """ -1706 Examples: -1707 ef1 = ExcludeFilter(["/etc/rc.*", "/etc/hostname"]) -1708 ef2 = ExcludeFilter("/my/path/exclude.lst") -1709 Where exclude.lst contains: -1710 /etc/rc.* -1711 /etc/hostname -1712 -1713 Note: it is not possible to exclude a file if its encapsulating -1714 directory is itself watched. See this issue for more details -1715 https://github.com/seb-m/pyinotify/issues/31 -1716 -1717 @param arg_lst: is either a list of patterns or a filename from which -1718 patterns will be loaded. -1719 @type arg_lst: list of str or str -1720 """ -1721 if isinstance(arg_lst, str): -1722 lst = self._load_patterns_from_file(arg_lst) -1723 elif isinstance(arg_lst, list): -1724 lst = arg_lst -1725 else: -1726 raise TypeError -1727 -1728 self._lregex = [] -1729 for regex in lst: -1730 self._lregex.append(re.compile(regex, re.UNICODE)) -
    1731 -
    1732 - def _load_patterns_from_file(self, filename): -
    1733 lst = [] -1734 file_obj = file(filename, 'r') -1735 try: -1736 for line in file_obj.readlines(): -1737 # Trim leading an trailing whitespaces -1738 pattern = line.strip() -1739 if not pattern or pattern.startswith('#'): -1740 continue -1741 lst.append(pattern) -1742 finally: -1743 file_obj.close() -1744 return lst -
    1745 -
    1746 - def _match(self, regex, path): -
    1747 return regex.match(path) is not None -
    1748 -
    1749 - def __call__(self, path): -
    1750 """ -1751 @param path: Path to match against provided regexps. -1752 @type path: str -1753 @return: Return True if path has been matched and should -1754 be excluded, False otherwise. -1755 @rtype: bool -1756 """ -1757 for regex in self._lregex: -1758 if self._match(regex, path): -1759 return True -1760 return False -
    1761 -
    1762 -1763 -class WatchManagerError(Exception): -
    1764 """ -1765 WatchManager Exception. Raised on error encountered on watches -1766 operations. -1767 -1768 """ -
    1769 - def __init__(self, msg, wmd): -
    1770 """ -1771 @param msg: Exception string's description. -1772 @type msg: string -1773 @param wmd: This dictionary contains the wd assigned to paths of the -1774 same call for which watches were successfully added. -1775 @type wmd: dict -1776 """ -1777 self.wmd = wmd -1778 Exception.stop(self) +
    1608 +
    1609 - def handle_read(self, *args, **kwargs): +
    1610 self.read_events() +1611 self.process_events() +1612 if self.handle_read_callback is not None: +1613 self.handle_read_callback(self) +
    1614 +
    1615 +1616 -class Watch: +
    1617 """ +1618 Represent a watch, i.e. a file or directory being watched. +1619 +1620 """ +1621 __slots__ = ('wd', 'path', 'mask', 'proc_fun', 'auto_add', +1622 'exclude_filter', 'dir') +1623 +
    1624 - def __init__(self, wd, path, mask, proc_fun, auto_add, exclude_filter): +
    1625 """ +1626 Initializations. +1627 +1628 @param wd: Watch descriptor. +1629 @type wd: int +1630 @param path: Path of the file or directory being watched. +1631 @type path: str +1632 @param mask: Mask. +1633 @type mask: int +1634 @param proc_fun: Processing callable object. +1635 @type proc_fun: +1636 @param auto_add: Automatically add watches on new directories. +1637 @type auto_add: bool +1638 @param exclude_filter: Boolean function, used to exclude new +1639 directories from being automatically watched. +1640 See WatchManager.__init__ +1641 @type exclude_filter: callable object +1642 """ +1643 self.wd = wd +1644 self.path = path +1645 self.mask = mask +1646 self.proc_fun = proc_fun +1647 self.auto_add = auto_add +1648 self.exclude_filter = exclude_filter +1649 self.dir = os.path.isdir(self.path) +
    1650 +
    1651 - def __repr__(self): +
    1652 """ +1653 @return: String representation. +1654 @rtype: str +1655 """ +1656 s = ' '.join(['%s%s%s' % (output_format.field_name(attr), +1657 output_format.punctuation('='), +1658 output_format.field_value(getattr(self, +1659 attr))) \ +1660 for attr in self.__slots__ if not attr.startswith('_')]) +1661 +1662 s = '%s%s %s %s' % (output_format.punctuation('<'), +1663 output_format.class_name(self.__class__.__name__), +1664 s, +1665 output_format.punctuation('>')) +1666 return s +
    1667 +
    1668 +1669 -class ExcludeFilter: +
    1670 """ +1671 ExcludeFilter is an exclusion filter. +1672 +1673 """ +
    1674 - def __init__(self, arg_lst): +
    1675 """ +1676 Examples: +1677 ef1 = ExcludeFilter(["/etc/rc.*", "/etc/hostname"]) +1678 ef2 = ExcludeFilter("/my/path/exclude.lst") +1679 Where exclude.lst contains: +1680 /etc/rc.* +1681 /etc/hostname +1682 +1683 Note: it is not possible to exclude a file if its encapsulating +1684 directory is itself watched. See this issue for more details +1685 https://github.com/seb-m/pyinotify/issues/31 +1686 +1687 @param arg_lst: is either a list of patterns or a filename from which +1688 patterns will be loaded. +1689 @type arg_lst: list of str or str +1690 """ +1691 if isinstance(arg_lst, str): +1692 lst = self._load_patterns_from_file(arg_lst) +1693 elif isinstance(arg_lst, list): +1694 lst = arg_lst +1695 else: +1696 raise TypeError +1697 +1698 self._lregex = [] +1699 for regex in lst: +1700 self._lregex.append(re.compile(regex, re.UNICODE)) +
    1701 +
    1702 - def _load_patterns_from_file(self, filename): +
    1703 lst = [] +1704 file_obj = file(filename, 'r') +1705 try: +1706 for line in file_obj.readlines(): +1707 # Trim leading an trailing whitespaces +1708 pattern = line.strip() +1709 if not pattern or pattern.startswith('#'): +1710 continue +1711 lst.append(pattern) +1712 finally: +1713 file_obj.close() +1714 return lst +
    1715 +
    1716 - def _match(self, regex, path): +
    1717 return regex.match(path) is not None +
    1718 +
    1719 - def __call__(self, path): +
    1720 """ +1721 @param path: Path to match against provided regexps. +1722 @type path: str +1723 @return: Return True if path has been matched and should +1724 be excluded, False otherwise. +1725 @rtype: bool +1726 """ +1727 for regex in self._lregex: +1728 if self._match(regex, path): +1729 return True +1730 return False +
    1731 +
    1732 +1733 -class WatchManagerError(Exception): +
    1734 """ +1735 WatchManager Exception. Raised on error encountered on watches +1736 operations. +1737 +1738 """ +
    1739 - def __init__(self, msg, wmd): +
    1740 """ +1741 @param msg: Exception string's description. +1742 @type msg: string +1743 @param wmd: This dictionary contains the wd assigned to paths of the +1744 same call for which watches were successfully added. +1745 @type wmd: dict +1746 """ +1747 self.wmd = wmd +1748 Exception.__init__(self, msg) -
    1779 -
    1780 -1781 -class WatchManager: -
    1782 """ -1783 Provide operations for watching files and directories. Its internal -1784 dictionary is used to reference watched items. When used inside -1785 threaded code, one must instanciate as many WatchManager instances as -1786 there are ThreadedNotifier instances. -1787 -1788 """ -
    1789 - def __init__(self, exclude_filter=lambda path: False): -
    1790 """ -1791 Initialization: init inotify, init watch manager dictionary. -1792 Raise OSError if initialization fails, raise InotifyBindingNotFoundError -1793 if no inotify binding was found (through ctypes or from direct access to -1794 syscalls). -1795 -1796 @param exclude_filter: boolean function, returns True if current -1797 path must be excluded from being watched. -1798 Convenient for providing a common exclusion -1799 filter for every call to add_watch. -1800 @type exclude_filter: callable object -1801 """ -1802 self._ignore_events = False -1803 self._exclude_filter = exclude_filter -1804 self._wmd = {} # watch dict key: watch descriptor, value: watch -1805 -1806 self._inotify_wrapper = INotifyWrapper.create() -1807 if self._inotify_wrapper is None: -1808 raise InotifyBindingNotFoundError() -1809 -1810 self._fd = self._inotify_wrapper.inotify_init() # file descriptor -1811 if self._fd < 0: -1812 err = 'Cannot initialize new instance of inotify, %s' -1813 raise OSError(err % self._inotify_wrapper.str_errno()) +pyinotify._SysProcessEvent.__init__" class="py-name" href="#" onclick="return doclink('link-398', '__init__', 'link-1');">__init__(self, msg) +
    1749 +
    1750 +1751 -class WatchManager: +
    1752 """ +1753 Provide operations for watching files and directories. Its internal +1754 dictionary is used to reference watched items. When used inside +1755 threaded code, one must instanciate as many WatchManager instances as +1756 there are ThreadedNotifier instances. +1757 +1758 """ +
    1759 - def __init__(self, exclude_filter=lambda path: False): +
    1760 """ +1761 Initialization: init inotify, init watch manager dictionary. +1762 Raise OSError if initialization fails, raise InotifyBindingNotFoundError +1763 if no inotify binding was found (through ctypes or from direct access to +1764 syscalls). +1765 +1766 @param exclude_filter: boolean function, returns True if current +1767 path must be excluded from being watched. +1768 Convenient for providing a common exclusion +1769 filter for every call to add_watch. +1770 @type exclude_filter: callable object +1771 """ +1772 self._ignore_events = False +1773 self._exclude_filter = exclude_filter +1774 self._wmd = {} # watch dict key: watch descriptor, value: watch +1775 +1776 self._inotify_wrapper = INotifyWrapper.create() +1777 if self._inotify_wrapper is None: +1778 raise InotifyBindingNotFoundError() +1779 +1780 self._fd = self._inotify_wrapper.inotify_init() # file descriptor +1781 if self._fd < 0: +1782 err = 'Cannot initialize new instance of inotify, %s' +1783 raise OSError(err % self._inotify_wrapper.str_errno()) +
    1784 +
    1785 - def close(self): +
    1786 """ +1787 Close inotify's file descriptor, this action will also automatically +1788 remove (i.e. stop watching) all its associated watch descriptors. +1789 After a call to this method the WatchManager's instance become useless +1790 and cannot be reused, a new instance must then be instanciated. It +1791 makes sense to call this method in few situations for instance if +1792 several independant WatchManager must be instanciated or if all watches +1793 must be removed and no other watches need to be added. +1794 """ +1795 os.close(self._fd) +
    1796 +
    1797 - def get_fd(self): +
    1798 """ +1799 Return assigned inotify's file descriptor. +1800 +1801 @return: File descriptor. +1802 @rtype: int +1803 """ +1804 return self._fd +
    1805 +
    1806 - def get_watch(self, wd): +
    1807 """ +1808 Get watch from provided watch descriptor wd. +1809 +1810 @param wd: Watch descriptor. +1811 @type wd: int +1812 """ +1813 return self._wmd.get(wd)
    1814 -
    1815 - def close(self): -
    1816 """ -1817 Close inotify's file descriptor, this action will also automatically -1818 remove (i.e. stop watching) all its associated watch descriptors. -1819 After a call to this method the WatchManager's instance become useless -1820 and cannot be reused, a new instance must then be instanciated. It -1821 makes sense to call this method in few situations for instance if -1822 several independant WatchManager must be instanciated or if all watches -1823 must be removed and no other watches need to be added. -1824 """ -1825 os.close(self._fd) +
    1815 - def del_watch(self, wd): +
    1816 """ +1817 Remove watch entry associated to watch descriptor wd. +1818 +1819 @param wd: Watch descriptor. +1820 @type wd: int +1821 """ +1822 try: +1823 del self._wmd[wd] +1824 except KeyError, err: +1825 log.error('Cannot delete unknown watch descriptor %s' % str(err))
    1826 -
    1827 - def get_fd(self): -
    1828 """ -1829 Return assigned inotify's file descriptor. -1830 -1831 @return: File descriptor. -1832 @rtype: int -1833 """ -1834 return self._fd -
    1835 -
    1836 - def get_watch(self, wd): -
    1837 """ -1838 Get watch from provided watch descriptor wd. -1839 -1840 @param wd: Watch descriptor. -1841 @type wd: int -1842 """ -1843 return self._wmd.get(wd) -
    1844 -
    1845 - def del_watch(self, wd): -
    1846 """ -1847 Remove watch entry associated to watch descriptor wd. -1848 -1849 @param wd: Watch descriptor. -1850 @type wd: int -1851 """ -1852 try: -1853 del self._wmd[wd] -1854 except KeyError, err: -1855 log.error('Cannot delete unknown watch descriptor %s' % str(err)) -
    1856 -1857 @property -
    1858 - def watches(self): -
    1859 """ -1860 Get a reference on the internal watch manager dictionary. -1861 -1862 @return: Internal watch manager dictionary. -1863 @rtype: dict -1864 """ -1865 return self._wmd +1827 @property +
    1828 - def watches(self): +
    1829 """ +1830 Get a reference on the internal watch manager dictionary. +1831 +1832 @return: Internal watch manager dictionary. +1833 @rtype: dict +1834 """ +1835 return self._wmd +
    1836 +
    1837 - def __format_path(self, path): +
    1838 """ +1839 Format path to its internal (stored in watch manager) representation. +1840 """ +1841 # Unicode strings are converted back to strings, because it seems +1842 # that inotify_add_watch from ctypes does not work well when +1843 # it receives an ctypes.create_unicode_buffer instance as argument. +1844 # Therefore even wd are indexed with bytes string and not with +1845 # unicode paths. +1846 if isinstance(path, unicode): +1847 path = path.encode(sys.getfilesystemencoding()) +1848 return os.path.normpath(path) +
    1849 +
    1850 - def __add_watch(self, path, mask, proc_fun, auto_add, exclude_filter): +
    1851 """ +1852 Add a watch on path, build a Watch object and insert it in the +1853 watch manager dictionary. Return the wd value. +1854 """ +1855 path = self.__format_path(path) +1856 if auto_add and not mask & IN_CREATE: +1857 mask |= IN_CREATE +1858 wd = self._inotify_wrapper.inotify_add_watch(self._fd, path, mask) +1859 if wd < 0: +1860 return wd +1861 watch = Watch(wd=wd, path=path, mask=mask, proc_fun=proc_fun, +1862 auto_add=auto_add, exclude_filter=exclude_filter) +1863 self._wmd[wd] = watch +1864 log.debug('New %s', watch) +1865 return wd
    1866 -
    1867 - def __format_path(self, path): -
    1868 """ -1869 Format path to its internal (stored in watch manager) representation. -1870 """ -1871 # Unicode strings are converted back to strings, because it seems -1872 # that inotify_add_watch from ctypes does not work well when -1873 # it receives an ctypes.create_unicode_buffer instance as argument. -1874 # Therefore even wd are indexed with bytes string and not with -1875 # unicode paths. -1876 if isinstance(path, unicode): -1877 path = path.encode(sys.getfilesystemencoding()) -1878 return os.path.normpath(path) -
    1879 -
    1880 - def __add_watch(self, path, mask, proc_fun, auto_add, exclude_filter): -
    1881 """ -1882 Add a watch on path, build a Watch object and insert it in the -1883 watch manager dictionary. Return the wd value. -1884 """ -1885 path = self.__format_path(path) -1886 if auto_add and not mask & IN_CREATE: -1887 mask |= IN_CREATE -1888 wd = self._inotify_wrapper.inotify_add_watch(self._fd, path, mask) -1889 if wd < 0: -1890 return wd -1891 watch = Watch(wd=wd, path=path, mask=mask, proc_fun=proc_fun, -1892 auto_add=auto_add, exclude_filter=exclude_filter) -1893 self._wmd[wd] = watch -1894 log.debug('New %s', watch) -1895 return wd -
    1896 -
    1897 - def __glob(self, path, do_glob): -
    1898 if do_glob: -1899 return glob(path) -1900 else: -1901 return [path] -
    1902 -
    1903 - def add_watch(self, path, mask, proc_fun=None, rec=False, -1904 auto_add=False, do_glob=False, quiet=True, -1905 exclude_filter=None): -
    1906 """ -1907 Add watch(s) on the provided |path|(s) with associated |mask| flag -1908 value and optionally with a processing |proc_fun| function and -1909 recursive flag |rec| set to True. -1910 Ideally |path| components should not be unicode objects. Note that -1911 although unicode paths are accepted there are converted to byte -1912 strings before a watch is put on that path. The encoding used for -1913 converting the unicode object is given by sys.getfilesystemencoding(). -1914 If |path| si already watched it is ignored, but if it is called with -1915 option rec=True a watch is put on each one of its not-watched -1916 subdirectory. -1917 -1918 @param path: Path to watch, the path can either be a file or a -1919 directory. Also accepts a sequence (list) of paths. -1920 @type path: string or list of strings -1921 @param mask: Bitmask of events. -1922 @type mask: int -1923 @param proc_fun: Processing object. -1924 @type proc_fun: function or ProcessEvent instance or instance of -1925 one of its subclasses or callable object. -1926 @param rec: Recursively add watches from path on all its -1927 subdirectories, set to False by default (doesn't -1928 follows symlinks in any case). -1929 @type rec: bool -1930 @param auto_add: Automatically add watches on newly created -1931 directories in watched parent |path| directory. -1932 If |auto_add| is True, IN_CREATE is ored with |mask| -1933 when the watch is added. -1934 @type auto_add: bool -1935 @param do_glob: Do globbing on pathname (see standard globbing -1936 module for more informations). -1937 @type do_glob: bool -1938 @param quiet: if False raises a WatchManagerError exception on -1939 error. See example not_quiet.py. -1940 @type quiet: bool -1941 @param exclude_filter: predicate (boolean function), which returns -1942 True if the current path must be excluded -1943 from being watched. This argument has -1944 precedence over exclude_filter passed to -1945 the class' constructor. -1946 @type exclude_filter: callable object -1947 @return: dict of paths associated to watch descriptors. A wd value -1948 is positive if the watch was added sucessfully, -1949 otherwise the value is negative. If the path was invalid -1950 or was already watched it is not included into this returned -1951 dictionary. -1952 @rtype: dict of {str: int} -1953 """ -1954 ret_ = {} # return {path: wd, ...} -1955 -1956 if exclude_filter is None: -1957 exclude_filter = self._exclude_filter -1958 -1959 # normalize args as list elements -1960 for npath in self.__format_param(path): -1961 # unix pathname pattern expansion -1962 for apath in self.__glob(npath, do_glob): -1963 # recursively list subdirs according to rec param -1964 for rpath in self.__walk_rec(apath, rec): -1965 if not exclude_filter(rpath): -1966 wd = ret_[rpath] = self.__add_watch(rpath, mask, -1967 proc_fun, -1968 auto_add, -1969 exclude_filter) -1970 if wd < 0: -1971 err = ('add_watch: cannot watch %s WD=%d, %s' % \ -1972 (rpath, wd, -1973 self._inotify_wrapper.str_errno())) -1974 if quiet: -1975 log.error(err) -1976 else: -1977 raise WatchManagerError(err, ret_) -1978 else: -1979 # Let's say -2 means 'explicitely excluded -1980 # from watching'. -1981 ret_[rpath] = -2 -1982 return ret_ -
    1983 -
    1984 - def __get_sub_rec(self, lpath): -
    1985 """ -1986 Get every wd from self._wmd if its path is under the path of -1987 one (at least) of those in lpath. Doesn't follow symlinks. -1988 -1989 @param lpath: list of watch descriptor -1990 @type lpath: list of int -1991 @return: list of watch descriptor -1992 @rtype: list of int -1993 """ -1994 for d in lpath: -1995 root = self.get_path(d) -1996 if root is not None: -1997 # always keep root -1998 yield d -1999 else: -2000 # if invalid -2001 continue -2002 -2003 # nothing else to expect -2004 if not os.path.isdir(root): -2005 continue -2006 -2007 # normalization -2008 root = os.path.normpath(root) -2009 # recursion -2010 lend = len(root) -2011 for iwd in self._wmd.items(): -2012 cur = iwd[1].path -2013 pref = os.path.commonprefix([root, cur]) -2014 if root == os.sep or (len(pref) == lend and \ -2015 len(cur) > lend and \ -2016 cur[lend] == os.sep): -2017 yield iwd[1].wd -
    2018 -
    2019 - def update_watch(self, wd, mask=None, proc_fun=None, rec=False, -2020 auto_add=False, quiet=True): -
    2021 """ -2022 Update existing watch descriptors |wd|. The |mask| value, the -2023 processing object |proc_fun|, the recursive param |rec| and the -2024 |auto_add| and |quiet| flags can all be updated. -2025 -2026 @param wd: Watch Descriptor to update. Also accepts a list of -2027 watch descriptors. -2028 @type wd: int or list of int -2029 @param mask: Optional new bitmask of events. -2030 @type mask: int -2031 @param proc_fun: Optional new processing function. -2032 @type proc_fun: function or ProcessEvent instance or instance of -2033 one of its subclasses or callable object. -2034 @param rec: Optionally adds watches recursively on all -2035 subdirectories contained into |wd| directory. -2036 @type rec: bool -2037 @param auto_add: Automatically adds watches on newly created -2038 directories in the watch's path corresponding to |wd|. -2039 If |auto_add| is True, IN_CREATE is ored with |mask| -2040 when the watch is updated. -2041 @type auto_add: bool -2042 @param quiet: If False raises a WatchManagerError exception on -2043 error. See example not_quiet.py -2044 @type quiet: bool -2045 @return: dict of watch descriptors associated to booleans values. -2046 True if the corresponding wd has been successfully -2047 updated, False otherwise. -2048 @rtype: dict of {int: bool} -2049 """ -2050 lwd = self.__format_param(wd) -2051 if rec: -2052 lwd = self.__get_sub_rec(lwd) +
    1867 - def __glob(self, path, do_glob): +
    1868 if do_glob: +1869 return glob(path) +1870 else: +1871 return [path] +
    1872 +
    1873 - def add_watch(self, path, mask, proc_fun=None, rec=False, +1874 auto_add=False, do_glob=False, quiet=True, +1875 exclude_filter=None): +
    1876 """ +1877 Add watch(s) on the provided |path|(s) with associated |mask| flag +1878 value and optionally with a processing |proc_fun| function and +1879 recursive flag |rec| set to True. +1880 Ideally |path| components should not be unicode objects. Note that +1881 although unicode paths are accepted there are converted to byte +1882 strings before a watch is put on that path. The encoding used for +1883 converting the unicode object is given by sys.getfilesystemencoding(). +1884 If |path| is already watched it is ignored, but if it is called with +1885 option rec=True a watch is put on each one of its not-watched +1886 subdirectory. +1887 +1888 @param path: Path to watch, the path can either be a file or a +1889 directory. Also accepts a sequence (list) of paths. +1890 @type path: string or list of strings +1891 @param mask: Bitmask of events. +1892 @type mask: int +1893 @param proc_fun: Processing object. +1894 @type proc_fun: function or ProcessEvent instance or instance of +1895 one of its subclasses or callable object. +1896 @param rec: Recursively add watches from path on all its +1897 subdirectories, set to False by default (doesn't +1898 follows symlinks in any case). +1899 @type rec: bool +1900 @param auto_add: Automatically add watches on newly created +1901 directories in watched parent |path| directory. +1902 If |auto_add| is True, IN_CREATE is ored with |mask| +1903 when the watch is added. +1904 @type auto_add: bool +1905 @param do_glob: Do globbing on pathname (see standard globbing +1906 module for more informations). +1907 @type do_glob: bool +1908 @param quiet: if False raises a WatchManagerError exception on +1909 error. See example not_quiet.py. +1910 @type quiet: bool +1911 @param exclude_filter: predicate (boolean function), which returns +1912 True if the current path must be excluded +1913 from being watched. This argument has +1914 precedence over exclude_filter passed to +1915 the class' constructor. +1916 @type exclude_filter: callable object +1917 @return: dict of paths associated to watch descriptors. A wd value +1918 is positive if the watch was added sucessfully, +1919 otherwise the value is negative. If the path was invalid +1920 or was already watched it is not included into this returned +1921 dictionary. +1922 @rtype: dict of {str: int} +1923 """ +1924 ret_ = {} # return {path: wd, ...} +1925 +1926 if exclude_filter is None: +1927 exclude_filter = self._exclude_filter +1928 +1929 # normalize args as list elements +1930 for npath in self.__format_param(path): +1931 # unix pathname pattern expansion +1932 for apath in self.__glob(npath, do_glob): +1933 # recursively list subdirs according to rec param +1934 for rpath in self.__walk_rec(apath, rec): +1935 if not exclude_filter(rpath): +1936 wd = ret_[rpath] = self.__add_watch(rpath, mask, +1937 proc_fun, +1938 auto_add, +1939 exclude_filter) +1940 if wd < 0: +1941 err = ('add_watch: cannot watch %s WD=%d, %s' % \ +1942 (rpath, wd, +1943 self._inotify_wrapper.str_errno())) +1944 if quiet: +1945 log.error(err) +1946 else: +1947 raise WatchManagerError(err, ret_) +1948 else: +1949 # Let's say -2 means 'explicitely excluded +1950 # from watching'. +1951 ret_[rpath] = -2 +1952 return ret_ +
    1953 +
    1954 - def __get_sub_rec(self, lpath): +
    1955 """ +1956 Get every wd from self._wmd if its path is under the path of +1957 one (at least) of those in lpath. Doesn't follow symlinks. +1958 +1959 @param lpath: list of watch descriptor +1960 @type lpath: list of int +1961 @return: list of watch descriptor +1962 @rtype: list of int +1963 """ +1964 for d in lpath: +1965 root = self.get_path(d) +1966 if root is not None: +1967 # always keep root +1968 yield d +1969 else: +1970 # if invalid +1971 continue +1972 +1973 # nothing else to expect +1974 if not os.path.isdir(root): +1975 continue +1976 +1977 # normalization +1978 root = os.path.normpath(root) +1979 # recursion +1980 lend = len(root) +1981 for iwd in self._wmd.items(): +1982 cur = iwd[1].path +1983 pref = os.path.commonprefix([root, cur]) +1984 if root == os.sep or (len(pref) == lend and \ +1985 len(cur) > lend and \ +1986 cur[lend] == os.sep): +1987 yield iwd[1].wd +
    1988 +
    1989 - def update_watch(self, wd, mask=None, proc_fun=None, rec=False, +1990 auto_add=False, quiet=True): +
    1991 """ +1992 Update existing watch descriptors |wd|. The |mask| value, the +1993 processing object |proc_fun|, the recursive param |rec| and the +1994 |auto_add| and |quiet| flags can all be updated. +1995 +1996 @param wd: Watch Descriptor to update. Also accepts a list of +1997 watch descriptors. +1998 @type wd: int or list of int +1999 @param mask: Optional new bitmask of events. +2000 @type mask: int +2001 @param proc_fun: Optional new processing function. +2002 @type proc_fun: function or ProcessEvent instance or instance of +2003 one of its subclasses or callable object. +2004 @param rec: Optionally adds watches recursively on all +2005 subdirectories contained into |wd| directory. +2006 @type rec: bool +2007 @param auto_add: Automatically adds watches on newly created +2008 directories in the watch's path corresponding to |wd|. +2009 If |auto_add| is True, IN_CREATE is ored with |mask| +2010 when the watch is updated. +2011 @type auto_add: bool +2012 @param quiet: If False raises a WatchManagerError exception on +2013 error. See example not_quiet.py +2014 @type quiet: bool +2015 @return: dict of watch descriptors associated to booleans values. +2016 True if the corresponding wd has been successfully +2017 updated, False otherwise. +2018 @rtype: dict of {int: bool} +2019 """ +2020 lwd = self.__format_param(wd) +2021 if rec: +2022 lwd = self.__get_sub_rec(lwd) +2023 +2024 ret_ = {} # return {wd: bool, ...} +2025 for awd in lwd: +2026 apath = self.get_path(awd) +2027 if not apath or awd < 0: +2028 err = 'update_watch: invalid WD=%d' % awd +2029 if quiet: +2030 log.error(err) +2031 continue +2032 raise WatchManagerError(err, ret_) +2033 +2034 if mask: +2035 wd_ = self._inotify_wrapper.inotify_add_watch(self._fd, apath, +2036 mask) +2037 if wd_ < 0: +2038 ret_[awd] = False +2039 err = ('update_watch: cannot update %s WD=%d, %s' % \ +2040 (apath, wd_, self._inotify_wrapper.str_errno())) +2041 if quiet: +2042 log.error(err) +2043 continue +2044 raise WatchManagerError(err, ret_) +2045 +2046 assert(awd == wd_) +2047 +2048 if proc_fun or auto_add: +2049 watch_ = self._wmd[awd] +2050 +2051 if proc_fun: +2052 watch_.proc_fun = proc_fun 2053 -2054 ret_ = {} # return {wd: bool, ...} -2055 for awd in lwd: -2056 apath = self.get_path(awd) -2057 if not apath or awd < 0: -2058 err = 'update_watch: invalid WD=%d' % awd -2059 if quiet: -2060 log.error(err) -2061 continue -2062 raise WatchManagerError(err, ret_) -2063 -2064 if mask: -2065 wd_ = self._inotify_wrapper.inotify_add_watch(self._fd, apath, -2066 mask) -2067 if wd_ < 0: -2068 ret_[awd] = False -2069 err = ('update_watch: cannot update %s WD=%d, %s' % \ -2070 (apath, wd_, self._inotify_wrapper.str_errno())) -2071 if quiet: -2072 log.error(err) -2073 continue -2074 raise WatchManagerError(err, ret_) -2075 -2076 assert(awd == wd_) -2077 -2078 if proc_fun or auto_add: -2079 watch_ = self._wmd[awd] -2080 -2081 if proc_fun: -2082 watch_.proc_fun = proc_fun -2083 -2084 if auto_add: -2085 watch_.auto_add = auto_add -2086 -2087 ret_[awd] = True -2088 log.debug('Updated watch - %s', self._wmd[awd]) -2089 return ret_ -
    2090 -
    2091 - def __format_param(self, param): -
    2092 """ -2093 @param param: Parameter. -2094 @type param: string or int -2095 @return: wrap param. -2096 @rtype: list of type(param) -2097 """ -2098 if isinstance(param, list): -2099 for p_ in param: -2100 yield p_ -2101 else: -2102 yield param -
    2103 -
    2104 - def get_wd(self, path): -
    2105 """ -2106 Returns the watch descriptor associated to path. This method -2107 presents a prohibitive cost, always prefer to keep the WD -2108 returned by add_watch(). If the path is unknown it returns None. -2109 -2110 @param path: Path. -2111 @type path: str -2112 @return: WD or None. -2113 @rtype: int or None +2054 if auto_add: +2055 watch_.auto_add = auto_add +2056 +2057 ret_[awd] = True +2058 log.debug('Updated watch - %s', self._wmd[awd]) +2059 return ret_ +
    2060 +
    2061 - def __format_param(self, param): +
    2062 """ +2063 @param param: Parameter. +2064 @type param: string or int +2065 @return: wrap param. +2066 @rtype: list of type(param) +2067 """ +2068 if isinstance(param, list): +2069 for p_ in param: +2070 yield p_ +2071 else: +2072 yield param +
    2073 +
    2074 - def get_wd(self, path): +
    2075 """ +2076 Returns the watch descriptor associated to path. This method +2077 presents a prohibitive cost, always prefer to keep the WD +2078 returned by add_watch(). If the path is unknown it returns None. +2079 +2080 @param path: Path. +2081 @type path: str +2082 @return: WD or None. +2083 @rtype: int or None +2084 """ +2085 path = self.__format_path(path) +2086 for iwd in self._wmd.items(): +2087 if iwd[1].path == path: +2088 return iwd[0] +
    2089 +
    2090 - def get_path(self, wd): +
    2091 """ +2092 Returns the path associated to WD, if WD is unknown it returns None. +2093 +2094 @param wd: Watch descriptor. +2095 @type wd: int +2096 @return: Path or None. +2097 @rtype: string or None +2098 """ +2099 watch_ = self._wmd.get(wd) +2100 if watch_ is not None: +2101 return watch_.path +
    2102 +
    2103 - def __walk_rec(self, top, rec): +
    2104 """ +2105 Yields each subdirectories of top, doesn't follow symlinks. +2106 If rec is false, only yield top. +2107 +2108 @param top: root directory. +2109 @type top: string +2110 @param rec: recursive flag. +2111 @type rec: bool +2112 @return: path of one subdirectory. +2113 @rtype: string 2114 """ -2115 path = self.__format_path(path) -2116 for iwd in self._wmd.items(): -2117 if iwd[1].path == path: -2118 return iwd[0] -
    2119 -
    2120 - def get_path(self, wd): -
    2121 """ -2122 Returns the path associated to WD, if WD is unknown it returns None. -2123 -2124 @param wd: Watch descriptor. -2125 @type wd: int -2126 @return: Path or None. -2127 @rtype: string or None -2128 """ -2129 watch_ = self._wmd.get(wd) -2130 if watch_ is not None: -2131 return watch_.path -
    2132 -
    2133 - def __walk_rec(self, top, rec): -
    2134 """ -2135 Yields each subdirectories of top, doesn't follow symlinks. -2136 If rec is false, only yield top. -2137 -2138 @param top: root directory. -2139 @type top: string -2140 @param rec: recursive flag. -2141 @type rec: bool -2142 @return: path of one subdirectory. -2143 @rtype: string -2144 """ -2145 if not rec or os.path.islink(top) or not os.path.isdir(top): -2146 yield top -2147 else: -2148 for root, dirs, files in os.walk(top): -2149 yield root -
    2150 -
    2151 - def rm_watch(self, wd, rec=False, quiet=True): -
    2152 """ -2153 Removes watch(s). -2154 -2155 @param wd: Watch Descriptor of the file or directory to unwatch. -2156 Also accepts a list of WDs. -2157 @type wd: int or list of int. -2158 @param rec: Recursively removes watches on every already watched -2159 subdirectories and subfiles. -2160 @type rec: bool -2161 @param quiet: If False raises a WatchManagerError exception on -2162 error. See example not_quiet.py -2163 @type quiet: bool -2164 @return: dict of watch descriptors associated to booleans values. -2165 True if the corresponding wd has been successfully -2166 removed, False otherwise. -2167 @rtype: dict of {int: bool} -2168 """ -2169 lwd = self.__format_param(wd) -2170 if rec: -2171 lwd = self.__get_sub_rec(lwd) -2172 -2173 ret_ = {} # return {wd: bool, ...} -2174 for awd in lwd: -2175 # remove watch -2176 wd_ = self._inotify_wrapper.inotify_rm_watch(self._fd, awd) -2177 if wd_ < 0: -2178 ret_[awd] = False -2179 err = ('rm_watch: cannot remove WD=%d, %s' % \ -2180 (awd, self._inotify_wrapper.str_errno())) -2181 if quiet: -2182 log.error(err) -2183 continue -2184 raise WatchManagerError(err, ret_) -2185 -2186 # Remove watch from our dictionary -2187 if awd in self._wmd: -2188 del self._wmd[awd] -2189 ret_[awd] = True -2190 log.debug('Watch WD=%d (%s) removed', awd, self.get_path(awd)) -2191 return ret_ -
    2192 -2193 -
    2194 - def watch_transient_file(self, filename, mask, proc_class): -
    2195 """ -2196 Watch a transient file, which will be created and deleted frequently -2197 over time (e.g. pid file). -2198 -2199 @attention: Currently under the call to this function it is not -2200 possible to correctly watch the events triggered into the same -2201 base directory than the directory where is located this watched -2202 transient file. For instance it would be wrong to make these -2203 two successive calls: wm.watch_transient_file('/var/run/foo.pid', ...) -2204 and wm.add_watch('/var/run/', ...) -2205 -2206 @param filename: Filename. -2207 @type filename: string -2208 @param mask: Bitmask of events, should contain IN_CREATE and IN_DELETE. -2209 @type mask: int -2210 @param proc_class: ProcessEvent (or of one of its subclass), beware of -2211 accepting a ProcessEvent's instance as argument into -2212 __init__, see transient_file.py example for more -2213 details. -2214 @type proc_class: ProcessEvent's instance or of one of its subclasses. -2215 @return: Same as add_watch(). -2216 @rtype: Same as add_watch(). -2217 """ -2218 dirname = os.path.dirname(filename) -2219 if dirname == '': -2220 return {} # Maintains coherence with add_watch() -2221 basename = os.path.basename(filename) -2222 # Assuming we are watching at least for IN_CREATE and IN_DELETE -2223 mask |= IN_CREATE | IN_DELETE -2224 -2225 def cmp_name(event): -2226 if getattr(event, 'name') is None: -2227 return False -2228 return basename == event.name -
    2229 return self.add_watch(dirname, mask, -2230 proc_fun=proc_class(ChainIfTrue(func=cmp_name)), -2231 rec=False, -2232 auto_add=False, do_glob=False, -2233 exclude_filter=lambda path: False) -
    2234 -
    2235 - def get_ignore_events(self): -
    2236 return self._ignore_events -
    2237 -
    2238 - def set_ignore_events(self, nval): -
    2239 self._ignore_events = nval +2115 if not rec or os.path.islink(top) or not os.path.isdir(top): +2116 yield top +2117 else: +2118 for root, dirs, files in os.walk(top): +2119 yield root +
    2120 +
    2121 - def rm_watch(self, wd, rec=False, quiet=True): +
    2122 """ +2123 Removes watch(s). +2124 +2125 @param wd: Watch Descriptor of the file or directory to unwatch. +2126 Also accepts a list of WDs. +2127 @type wd: int or list of int. +2128 @param rec: Recursively removes watches on every already watched +2129 subdirectories and subfiles. +2130 @type rec: bool +2131 @param quiet: If False raises a WatchManagerError exception on +2132 error. See example not_quiet.py +2133 @type quiet: bool +2134 @return: dict of watch descriptors associated to booleans values. +2135 True if the corresponding wd has been successfully +2136 removed, False otherwise. +2137 @rtype: dict of {int: bool} +2138 """ +2139 lwd = self.__format_param(wd) +2140 if rec: +2141 lwd = self.__get_sub_rec(lwd) +2142 +2143 ret_ = {} # return {wd: bool, ...} +2144 for awd in lwd: +2145 # remove watch +2146 wd_ = self._inotify_wrapper.inotify_rm_watch(self._fd, awd) +2147 if wd_ < 0: +2148 ret_[awd] = False +2149 err = ('rm_watch: cannot remove WD=%d, %s' % \ +2150 (awd, self._inotify_wrapper.str_errno())) +2151 if quiet: +2152 log.error(err) +2153 continue +2154 raise WatchManagerError(err, ret_) +2155 +2156 # Remove watch from our dictionary +2157 if awd in self._wmd: +2158 del self._wmd[awd] +2159 ret_[awd] = True +2160 log.debug('Watch WD=%d (%s) removed', awd, self.get_path(awd)) +2161 return ret_ +
    2162 +2163 +
    2164 - def watch_transient_file(self, filename, mask, proc_class): +
    2165 """ +2166 Watch a transient file, which will be created and deleted frequently +2167 over time (e.g. pid file). +2168 +2169 @attention: Currently under the call to this function it is not +2170 possible to correctly watch the events triggered into the same +2171 base directory than the directory where is located this watched +2172 transient file. For instance it would be wrong to make these +2173 two successive calls: wm.watch_transient_file('/var/run/foo.pid', ...) +2174 and wm.add_watch('/var/run/', ...) +2175 +2176 @param filename: Filename. +2177 @type filename: string +2178 @param mask: Bitmask of events, should contain IN_CREATE and IN_DELETE. +2179 @type mask: int +2180 @param proc_class: ProcessEvent (or of one of its subclass), beware of +2181 accepting a ProcessEvent's instance as argument into +2182 __init__, see transient_file.py example for more +2183 details. +2184 @type proc_class: ProcessEvent's instance or of one of its subclasses. +2185 @return: Same as add_watch(). +2186 @rtype: Same as add_watch(). +2187 """ +2188 dirname = os.path.dirname(filename) +2189 if dirname == '': +2190 return {} # Maintains coherence with add_watch() +2191 basename = os.path.basename(filename) +2192 # Assuming we are watching at least for IN_CREATE and IN_DELETE +2193 mask |= IN_CREATE | IN_DELETE +2194 +2195 def cmp_name(event): +2196 if getattr(event, 'name') is None: +2197 return False +2198 return basename == event.name +
    2199 return self.add_watch(dirname, mask, +2200 proc_fun=proc_class(ChainIfTrue(func=cmp_name)), +2201 rec=False, +2202 auto_add=False, do_glob=False, +2203 exclude_filter=lambda path: False) +
    2204 +
    2205 - def get_ignore_events(self): +
    2206 return self._ignore_events +
    2207 +
    2208 - def set_ignore_events(self, nval): +
    2209 self._ignore_events = nval +
    2210 +2211 ignore_events = property(get_ignore_events, set_ignore_events, +2212 "Make watch manager ignoring new events.") +
    2213 +
    2214 +2215 +2216 -class RawOutputFormat: +
    2217 """ +2218 Format string representations. +2219 """ +
    2220 - def __init__(self, format=None): +
    2221 self.format = format or {} +
    2222 +
    2223 - def simple(self, s, attribute): +
    2224 if not isinstance(s, str): +2225 s = str(s) +2226 return (self.format.get(attribute, '') + s + +2227 self.format.get('normal', '')) +
    2228 +
    2229 - def punctuation(self, s): +
    2230 """Punctuation color.""" +2231 return self.simple(s, 'normal') +
    2232 +
    2233 - def field_value(self, s): +
    2234 """Field value color.""" +2235 return self.simple(s, 'purple') +
    2236 +
    2237 - def field_name(self, s): +
    2238 """Field name color.""" +2239 return self.simple(s, 'blue')
    2240 -2241 ignore_events = property(get_ignore_events, set_ignore_events, -2242 "Make watch manager ignoring new events.") -
    2243 -
    2244 -2245 -2246 -class RawOutputFormat: -
    2247 """ -2248 Format string representations. -2249 """ -
    2250 - def __init__(self, format=None): -
    2251 self.format = format or {} -
    2252 -
    2253 - def simple(self, s, attribute): -
    2254 if not isinstance(s, str): -2255 s = str(s) -2256 return (self.format.get(attribute, '') + s + -2257 self.format.get('normal', '')) -
    2258 -
    2259 - def punctuation(self, s): -
    2260 """Punctuation color.""" -2261 return self.simple(s, 'normal') -
    2262 -
    2263 - def field_value(self, s): -
    2264 """Field value color.""" -2265 return self.simple(s, 'purple') -
    2266 -
    2267 - def field_name(self, s): -
    2268 """Field name color.""" -2269 return self.simple(s, 'blue') -
    2270 -
    2271 - def class_name(self, s): -
    2272 """Class name color.""" -2273 return self.format.get('red', '') + self.simple(s, 'bold') -
    2274 -2275 output_format = RawOutputFormat() -
    2276 -2277 -class ColoredOutputFormat(RawOutputFormat): -
    2278 """ -2279 Format colored string representations. -2280 """ -
    2281 - def __init__(self): -
    2282 f = {'normal': '\033[0m', -2283 'black': '\033[30m', -2284 'red': '\033[31m', -2285 'green': '\033[32m', -2286 'yellow': '\033[33m', -2287 'blue': '\033[34m', -2288 'purple': '\033[35m', -2289 'cyan': '\033[36m', -2290 'bold': '\033[1m', -2291 'uline': '\033[4m', -2292 'blink': '\033[5m', -2293 'invert': '\033[7m'} -2294 RawOutputFormat.
    2241 - def class_name(self, s): +
    2242 """Class name color.""" +2243 return self.format.get('red', '') + self.simple(s, 'bold') +
    2244 +2245 output_format = RawOutputFormat() +
    2246 +2247 -class ColoredOutputFormat(RawOutputFormat): +
    2248 """ +2249 Format colored string representations. +2250 """ +
    2251 - def __init__(self): +
    2252 f = {'normal': '\033[0m', +2253 'black': '\033[30m', +2254 'red': '\033[31m', +2255 'green': '\033[32m', +2256 'yellow': '\033[33m', +2257 'blue': '\033[34m', +2258 'purple': '\033[35m', +2259 'cyan': '\033[36m', +2260 'bold': '\033[1m', +2261 'uline': '\033[4m', +2262 'blink': '\033[5m', +2263 'invert': '\033[7m'} +2264 RawOutputFormat.__init__(self, f) -
    2295 -
    2296 -2297 -def compatibility_mode(): -
    2298 """ -2299 Use this function to turn on the compatibility mode. The compatibility -2300 mode is used to improve compatibility with Pyinotify 0.7.1 (or older) -2301 programs. The compatibility mode provides additional variables 'is_dir', -2302 'event_name', 'EventsCodes.IN_*' and 'EventsCodes.ALL_EVENTS' as -2303 Pyinotify 0.7.1 provided. Do not call this function from new programs!! -2304 Especially if there are developped for Pyinotify >= 0.8.x. -2305 """ -2306 setattr(EventsCodes, 'ALL_EVENTS', ALL_EVENTS) -2307 for evname in globals(): -2308 if evname.startswith('IN_'): -2309 setattr(EventsCodes, evname, globals()[evname]) -2310 global COMPATIBILITY_MODE -2311 COMPATIBILITY_MODE = True -
    2312 -
    2313 -2314 -def command_line(): -
    2315 """ -2316 By default the watched path is '/tmp' and all types of events are -2317 monitored. Events monitoring serves forever, type c^c to stop it. -2318 """ -2319 from optparse import OptionParser -2320 -2321 usage = "usage: %prog [options] [path1] [path2] [pathn]" -2322 -2323 parser = OptionParser(usage=usage) -2324 parser.add_option("-v", "--verbose", action="store_true", -2325 dest="verbose", help="Verbose mode") -2326 parser.add_option("-r", "--recursive", action="store_true", -2327 dest="recursive", -2328 help="Add watches recursively on paths") -2329 parser.add_option("-a", "--auto_add", action="store_true", -2330 dest="auto_add", -2331 help="Automatically add watches on new directories") -2332 parser.add_option("-g", "--glob", action="store_true", -2333 dest="glob", -2334 help="Treat paths as globs") -2335 parser.add_option("-e", "--events-list", metavar="EVENT[,...]", -2336 dest="events_list", -2337 help=("A comma-separated list of events to watch for - " -2338 "see the documentation for valid options (defaults" -2339 " to everything)")) -2340 parser.add_option("-s", "--stats", action="store_true", -2341 dest="stats", -2342 help="Display dummy statistics") -2343 parser.add_option("-V", "--version", action="store_true", -2344 dest="version", help="Pyinotify version") -2345 parser.add_option("-f", "--raw-format", action="store_true", -2346 dest="raw_format", -2347 help="Disable enhanced output format.") -2348 parser.add_option("-c", "--command", action="store", -2349 dest="command", -2350 help="Shell command to run upon event") -2351 -2352 (options, args) = parser.parse_args() -2353 -2354 if options.verbose: -2355 log.setLevel(10) -2356 -2357 if options.version: -2358 print(__version__) -2359 -2360 if not options.raw_format: -2361 global output_format -2362 output_format = ColoredOutputFormat() -2363 -2364 if len(args) < 1: -2365 path = '/tmp' # default watched path -2366 else: -2367 path = args -2368 -2369 # watch manager instance -2370 wm = WatchManager() -2371 # notifier instance and init -2372 if options.stats: -2373 notifier = Notifier(wm, default_proc_fun=Stats(), read_freq=5) -2374 else: -2375 notifier = Notifier(wm, default_proc_fun=PrintAllEvents()) -2376 -2377 # What mask to apply -2378 mask = 0 -2379 if options.events_list: -2380 events_list = options.events_list.split(',') -2381 for ev in events_list: -2382 evcode = EventsCodes.ALL_FLAGS.get(ev, 0) -2383 if evcode: -2384 mask |= evcode -2385 else: -2386 parser.error("The event '%s' specified with option -e" -2387 " is not valid" % ev) -2388 else: -2389 mask = ALL_EVENTS -2390 -2391 # stats -2392 cb_fun = None -2393 if options.stats: -2394 def cb(s): -2395 sys.stdout.write(repr(s.proc_fun())) -2396 sys.stdout.write('\n') -2397 sys.stdout.write(str(s.proc_fun())) -2398 sys.stdout.write('\n') -2399 sys.stdout.flush() -
    2400 cb_fun = cb -2401 -2402 # External command -2403 if options.command: -2404 def cb(s): -2405 subprocess.Popen(options.command, shell=True) -
    2406 cb_fun = cb -2407 -2408 log.debug('Start monitoring %s, (press c^c to halt pyinotify)' % path) -2409 -2410 wm.add_watch(path, mask, rec=options.recursive, auto_add=options.auto_add, do_glob=options.glob) -2411 # Loop forever (until sigint signal get caught) -2412 notifier.loop(callback=cb_fun) -
    2413 -2414 -2415 if __name__ == '__main__': -2416 command_line() -2417 + + + + + + + + + + + + + + + + + + + + +
       Home      Trees      Indices      Help   
    + + + + + +
    + + Module pyinotify :: + Class ProcINotify + + + + + + +
    [hide private]
    [frames] | no frames]
    +
    + +

    Class ProcINotify

    source code

    +
    +
    + + + + + + + + +
    +
    +
    +

    Access (read, write) inotify's variables through /proc/sys/. Note that + usually it requires administrator rights to update them.

    +

    Examples:

    +
      +
    • + Read max_queued_events attribute: myvar = max_queued_events.value +
      • +
    • + Update max_queued_events attribute: max_queued_events.value = 42 +
      • +
    + + + + + + + + + + + + + + + + + + + + + + +
    + + + + + +
    Instance Methods[hide private]
    +
    +   + + + + + + +
    __init__(self, + attr)
    + x.__init__(...) initializes x; see help(type(x)) for signature    		 + source code + +
    + +
    + int + + + + + + +
    get_val(self)
    + Gets attribute's value.    		 + source code + +
    + +
    +   + + + + + + +
    set_val(self, + nval)
    + Sets new attribute's value.    		 + source code + +
    + +
    +   + + + + + + +
    __repr__(self)
    + repr(x)    		 + source code + +
    + +
    +

    Inherited from object: + __delattr__, + __format__, + __getattribute__, + __hash__, + __new__, + __reduce__, + __reduce_ex__, + __setattr__, + __sizeof__, + __str__, + __subclasshook__ +

    +
    + + + + + + + + + + + + +
    + + + + + +
    Properties[hide private]
    +
    + int + + value
    + Gets attribute's value. +
    +

    Inherited from object: + __class__ +

    +
    + + + + + + +
    + + + + + +
    Method Details[hide private]
    +
    + +
    + +
    + + +
    +

    __init__(self, + attr) +
    (Constructor) +

    +     		source code  +
    + +

    x.__init__(...) initializes x; see help(type(x)) for signature

    +
    +
    Overrides: + object.__init__ +
    (inherited documentation)
    + +
    +
    +
    + +
    + +
    + + +
    +

    get_val(self) +

    +     		source code  +
    + +

    Gets attribute's value.

    +
    +
    Returns: int
    +
    stored value.
    +
    Raises:
    +
      +
    • IOError - if corresponding file in /proc/sys cannot be read.
      • +
    +
    +
    +
    + +
    + +
    + + +
    +

    set_val(self, + nval) +

    +     		source code  +
    + +

    Sets new attribute's value.

    +
    +
    Parameters:
    +
      +
    • nval (int) - replaces current value by nval.
      • +
    +
    Raises:
    +
      +
    • IOError - if corresponding file in /proc/sys cannot be written.
      • +
    +
    +
    +
    + +
    + +
    + + +
    +

    __repr__(self) +
    (Representation operator) +

    +     		source code  +
    + +

    repr(x)

    +
    +
    Overrides: + object.__repr__ +
    (inherited documentation)
    + +
    +
    +
    +
    + + + + + + +
    + + + + + +
    Property Details[hide private]
    +
    + +
    + +
    +

    value

    +

    Gets attribute's value.

    +
    +
    Get Method:
    +
    get_val(self) + - Gets attribute's value. +
    +
    Set Method:
    +
    set_val(self, + nval) + - Sets new attribute's value. +
    +
    Type:
    +
    int
    +
    +
    +
    +
    + + + + + + + + + + + + + + + + + +
       Home      Trees      Indices      Help   
    + + + + + +
    + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015 + + http://epydoc.sourceforge.net +
    + + + + diff --git a/pyinotify.ProcessEvent-class.html b/pyinotify.ProcessEvent-class.html index 9cfd0b4..2a1f828 100644 --- a/pyinotify.ProcessEvent-class.html +++ b/pyinotify.ProcessEvent-class.html @@ -57,22 +57,22 @@

    Class ProcessEvent

    source code

    -
    - - - - - - - - - - - - - +
    + + + + + + + + + + + + + - +
    @@ -516,7 +516,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015

    Class ProcessEventError

    source code

    -
    +
    @@ -77,7 +77,7 @@ - +
    @@ -247,7 +247,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015

    Class PyinotifyError

    source code

    -
    - - - - - - - - - - - - - - - - +
    + - - - - + + + + + + + + + + + + + + + + + + + - +
    @@ -186,7 +186,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:20 2015

    Class RawOutputFormat

    source code

    -
    +
    @@ -67,7 +67,7 @@ - +
    @@ -312,7 +312,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015

    Class Stats

    source code

    -
    +
    @@ -72,7 +72,7 @@ - +
    @@ -445,7 +445,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015 - - - - pyinotify.SysCtlINotify - - - - - - - - - - - - - - - - - - - - - - -
       Home      Trees      Indices      Help   
    - - - - - -
    - - Module pyinotify :: - Class SysCtlINotify - - - - - - -
    [hide private]
    [frames] | no frames]
    -
    - -

    Class SysCtlINotify

    source code

    -
    -
    - - - - - - - - - - -
    -
    -
    -

    Access (read, write) inotify's variables through sysctl. Usually it - requires administrator rights to update them.

    -

    Examples:

    -
      -
    • - Read max_queued_events attribute: myvar = max_queued_events.value -
      • -
    • - Update max_queued_events attribute: max_queued_events.value = 42 -
      • -
    - - - - - - - - - - - - - - - - - - - - - - -
    - - - - - -
    Instance Methods[hide private]
    -
    -   - - - - - - -
    __init__(self, - attrname, - inotify_wrapper)
    - x.__init__(...) initializes x; see help(type(x)) for signature    		 - source code - -
    - -
    - int - - - - - - -
    get_val(self)
    - Gets attribute's value.    		 - source code - -
    - -
    -   - - - - - - -
    set_val(self, - nval)
    - Sets new attribute's value.    		 - source code - -
    - -
    -   - - - - - - -
    __repr__(self)
    - repr(x)    		 - source code - -
    - -
    -

    Inherited from object: - __delattr__, - __format__, - __getattribute__, - __hash__, - __new__, - __reduce__, - __reduce_ex__, - __setattr__, - __sizeof__, - __str__, - __subclasshook__ -

    -
    - - - - - - - - - -
    - - - - - -
    Static Methods[hide private]
    -
    -   - - - - - - -
    create(attrname)
    - Factory method instanciating and returning the right wrapper.    		 - source code - -
    - -
    - - - - - - - - - -
    - - - - - -
    Class Variables[hide private]
    -
    -   - - inotify_attrs = {'max_queued_events': 3, 'max_user_instances':... -
    - - - - - - - - - - - - -
    - - - - - -
    Properties[hide private]
    -
    - int - - value
    - Gets attribute's value. -
    -

    Inherited from object: - __class__ -

    -
    - - - - - - -
    - - - - - -
    Method Details[hide private]
    -
    - -
    - -
    - - -
    -

    __init__(self, - attrname, - inotify_wrapper) -
    (Constructor) -

    -     		source code  -
    - -

    x.__init__(...) initializes x; see help(type(x)) for signature

    -
    -
    Overrides: - object.__init__ -
    (inherited documentation)
    - -
    -
    -
    - -
    - -
    - - -
    -

    get_val(self) -

    -     		source code  -
    - -

    Gets attribute's value. Raises OSError if the operation failed.

    -
    -
    Returns: int
    -
    stored value.
    -
    -
    -
    - -
    - -
    - - -
    -

    set_val(self, - nval) -

    -     		source code  -
    - -

    Sets new attribute's value. Raises OSError if the operation - failed.

    -
    -
    Parameters:
    -
      -
    • nval (int) - replaces current value by nval.
      • -
    -
    -
    -
    - -
    - -
    - - -
    -

    __repr__(self) -
    (Representation operator) -

    -     		source code  -
    - -

    repr(x)

    -
    -
    Overrides: - object.__repr__ -
    (inherited documentation)
    - -
    -
    -
    -
    - - - - - - -
    - - - - - -
    Class Variable Details[hide private]
    -
    - -
    - -
    -

    inotify_attrs

    - -
    -
    -
    -
    Value:
    - 
    -{'max_queued_events': 3,
- 'max_user_instances': 1,
- 'max_user_watches': 2}
-
    -
    -
    -
    -
    -
    - - - - - - -
    - - - - - -
    Property Details[hide private]
    -
    - -
    - -
    -

    value

    -

    Gets attribute's value. Raises OSError if the operation failed.

    -
    -
    Get Method:
    -
    get_val(self) - - Gets attribute's value. -
    -
    Set Method:
    -
    set_val(self, - nval) - - Sets new attribute's value. -
    -
    Type:
    -
    int
    -
    -
    -
    -
    - - - - - - - - - - - - - - - - - -
       Home      Trees      Indices      Help   
    - - - - - -
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 - - http://epydoc.sourceforge.net -
    - - - - diff --git a/pyinotify.ThreadedNotifier-class.html b/pyinotify.ThreadedNotifier-class.html index a1bcc51..394a4f1 100644 --- a/pyinotify.ThreadedNotifier-class.html +++ b/pyinotify.ThreadedNotifier-class.html @@ -76,14 +76,14 @@ - - - - - - - - + + + + + + + + @@ -314,14 +314,16 @@
  • watch_manager (WatchManager instance) - Watch Manager.
  • default_proc_fun (instance of ProcessEvent) - Default processing method. See base class.
  • read_freq (int) - if read_freq == 0, events are read asap, if read_freq is > 0, - this thread sleeps max(0, read_freq - timeout) seconds.
    • + this thread sleeps max(0, read_freq - (timeout / 1000)) seconds.
  • threshold (int) - File descriptor will be read only if the accumulated size to read becomes >= threshold. If != 0, you likely want to use it in combination with an appropriate value set for read_freq because without that you would keep looping without really reading anything and that until the amount of events to read is >= threshold. At least with read_freq you might sleep.
    • -
  • timeout (int) - https://docs.python.org/3/library/select.html#polling-objects
    • +
  • timeout (int) - see read_freq above. If provided, it must be set in milliseconds. + See + https://docs.python.org/2/library/select.html#select.poll.poll
    • Overrides: object.__init__ @@ -443,7 +445,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015 Close inotify's instance (close its file descriptor). It destroys all existing watches, pending events,... This method is automatically called - at the end of loop().

    + at the end of loop(). Afterward it is invalid to access this + instance.

    Overrides: Notifier.stop @@ -323,7 +324,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:53 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    __init__(self, - exclude_filter=<function <lambda> at 0x7fd536728ed8>)
    + exclude_filter=<function <lambda> at 0x7f64fff3ede8>)
    Initialization: init inotify, init watch manager dictionary.    		 source code @@ -551,7 +551,7 @@

    __init__(self, - exclude_filter=<function <lambda> at 0x7fd536728ed8>) + exclude_filter=<function <lambda> at 0x7f64fff3ede8>)
    (Constructor)

    @@ -1101,7 +1101,7 @@ - - -
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:54 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:54 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    -   - - - - - - -
    _sysctl(self, - *args) - source code - -
    - -

    Inherited from INotifyWrapper: @@ -354,7 +337,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:54 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:54 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:54 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015 Class _ProcessEvent

    source code

    - - - - - - - - + + + + + + + +
    @@ -302,7 +302,7 @@
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:54 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:54 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015
    - Generated by Epydoc 3.0.1 on Fri Jan 9 18:03:54 2015 + Generated by Epydoc 3.0.1 on Thu Jun 4 11:54:21 2015