Esempio n. 1
0
def _reloader_inotify(fnames, interval=None):
    #: Mutated by inotify loop when changes occur.
    changed = [False]

    # Setup inotify watches
    from pyinotify import WatchManager, EventsCodes, Notifier
    wm = WatchManager()
    mask = "IN_DELETE_SELF IN_MOVE_SELF IN_MODIFY IN_ATTRIB".split()
    mask = reduce(lambda m, a: m | getattr(EventsCodes, a), mask, 0)

    def signal_changed(event):
        if changed[0]:
            return
        _log('info', ' * Detected change in %r, reloading' % event.path)
        changed[:] = [True]

    for fname in fnames:
        wm.add_watch(fname, mask, signal_changed)

    # ... And now we wait...
    notif = Notifier(wm)
    try:
        while not changed[0]:
            notif.process_events()
            if notif.check_events(timeout=interval):
                notif.read_events()
            # TODO Set timeout to something small and check parent liveliness
    finally:
        notif.stop()
    sys.exit(3)
def main():
    argparser = argparse.ArgumentParser(description='%(prog)s watches directory for auction/* files to attach esnipers.')
    argparser.add_argument('--version', action='version', version='%(prog)s 0.3')
    argparser.add_argument('-d', '--debug', action='store_true', help='print simple debug statements')
    argparser.add_argument('directory', help='Directory to watch for auctions.')
    args = argparser.parse_args()

    if args.debug:
        logging.basicConfig(level=logging.DEBUG)
    else:
        logging.basicConfig(level=logging.INFO)

    os.chdir(args.directory)
    snipers = Snipers()
    wm = WatchManager()
    mask = EventsCodes.ALL_FLAGS['IN_CLOSE_WRITE']|EventsCodes.ALL_FLAGS['IN_MOVED_TO']| \
        EventsCodes.ALL_FLAGS['IN_MOVED_FROM']|EventsCodes.ALL_FLAGS['IN_DELETE']
    notifier = Notifier(wm, ProcessFiles(snipers))
    wm.add_watch('auction/', mask)

    auctions = filter(filefilter, os.listdir('auction/'))
    for a in auctions:
        snipers.restart(a)

    while True:
        logging.debug('cycle')
        if notifier.check_events(None): # "None" necessary for endless select()
            notifier.read_events()
            notifier.process_events()
Esempio n. 3
0
class TrackState(State, ProcessEvent):
    mask = (EventsCodes.OP_FLAGS['IN_DELETE']
            | EventsCodes.OP_FLAGS['IN_CLOSE_WRITE'])

    def __init__(self, *args, **kwargs):
        State.__init__(self, *args, **kwargs)
        self.wm = WatchManager()
        self.notifier = Notifier(self.wm, self)

    def process_IN_CLOSE_WRITE(self, event):
        debug("IN_CLOSE_WRITE: %r" % (event,))
        path = os.path.join(event.path, event.name)
        if os.path.isfile(path) and self.acceptable(path):
            self.upload(self.filename_to_File(path))

    def process_IN_DELETE(self, event):
        debug("IN_DELETE: %r" % (event,))
        path = os.path.join(event.path, event.name)
        if self.acceptable(path):
            self.delete(self.filename_to_File(path))

    def run(self):
        for f in self.files:
            f = os.path.abspath(f)
            self.wm.add_watch(f, self.mask, rec=True, auto_add=True)
        try:
            while True:
                self.notifier.process_events()
                if self.notifier.check_events(100):
                    self.notifier.read_events()
                sleep(0)
        except KeyboardInterrupt:
            self.notifier.stop()
Esempio n. 4
0
class Watcher(object):
    def __init__(self, incoming_path, logger=None):
        self.incoming_path = incoming_path
        self.logger = logger or logging.getLogger('Watcher')

        self.wm = WatchManager()
        mask = IN_CLOSE_WRITE # watched events

        self.event_processor = WatcherProcesEvent(logger=self.logger)
        self.notifier = Notifier(self.wm, self.event_processor)
        wdd = self.wm.add_watch(self.incoming_path, mask, rec=True)

    def loop(self):
        """
        Check for inotify events and process then when found.

	Note, check_events() below is blocking and the loop will not complete
        until an event that is being listened for occurs.
        """
        if self.notifier.check_events():
            # read notified events and enqeue them
            self.notifier.read_events()

        # process the queue of events
        self.notifier.process_events()

    def stop(self):
         # destroy the inotify's instance on this interrupt (stop monitoring)
         self.notifier.stop()
Esempio n. 5
0
class LinuxFileSysMonitor(FileSysMonitor):
    """File system monitor thread"""
    def __init__(self, name=None):
        super(LinuxFileSysMonitor, self).__init__(name)
        self.defaultMask = IN_DELETE | IN_CREATE | IN_MODIFY | IN_MOVED_TO | IN_MOVED_FROM
        self.wm = WatchManager()
        self.__lock = threading.Lock()

    def addWatch(self, path, mask=None):
        """Add watch for path"""
        super(LinuxFileSysMonitor, self).addWatch(path, mask)
        if not mask:
            mask = self.defaultMask
        self.wm.add_watch(path, mask, auto_add=True, rec=True)

    def run(self):
        """Thread entry"""
        super(LinuxFileSysMonitor, self).run()
        self.notifier = Notifier(self.wm, EventHandler(None, fsMonitor = self))

        while not self.threadStop:
            self.processMsg(1)
            if self.notifier.check_events(1000):
                self.notifier.read_events()
                self.notifier.process_events()

    def stop(self):
        """Stop watch"""
        super(LinuxFileSysMonitor, self).stop()
        self.notifier.stop()
Esempio n. 6
0
class QNotifier(QThread):
    def __init__(self, wm, processor):
        self.event_queue = list()
        self._processor = processor
        self.notifier = Notifier(wm,
                                 NinjaProcessEvent(self.event_queue.append))
        self.notifier.coalesce_events(True)
        self.keep_running = True
        QThread.__init__(self)

    def run(self):
        while self.keep_running:
            try:
                self.notifier.process_events()
            except OSError:
                pass  # OSError: [Errno 2] No such file or directory happens
            e_dict = {}
            while len(self.event_queue):
                e_type, e_path = self.event_queue.pop(0)
                e_dict.setdefault(e_path, []).append(e_type)

            keys = list(e_dict.keys())
            while len(keys):
                key = keys.pop(0)
                event = e_dict.pop(key)
                if (ADDED in event) and (DELETED in event):
                    event = [e for e in event if e not in (ADDED, DELETED)]
                for each_event in event:
                    self._processor(each_event, key)
            if self.notifier.check_events():
                self.notifier.read_events()

        self.notifier.stop()
Esempio n. 7
0
 def run(self, location='.'):
     transport = get_transport(location)
     root = transport.local_abspath('.')
     new_dirs = set('.')
     relpaths = set('.')
     while relpaths:
         relpath = relpaths.pop()
         paths = transport.list_dir(relpath)
         for path in paths:
             st = transport.stat(relpath + '/' + path)
             if S_ISDIR(st.st_mode):
                 if path != '.bzr':
                     new_dirs.add(relpath + '/' + path)
                 relpaths.add(relpath + '/' + path)
     # gather all dirs
     wm = WatchManager()
     added_flag = False
     handler = ProcessClose()
     handler._bzr_wm = wm
     notifier = Notifier(wm, handler)
     # read and process events
     try:
         while True:
             if new_dirs:
                 for path in new_dirs:
                     wm.add_watch(root + '/' + path, dir_mask)
                 new_dirs = set()
             notifier.process_events()
             if notifier.check_events():
                 notifier.read_events()
     finally:
         notifier.stop()
Esempio n. 8
0
    def run(self):
        self.pclose = PClose(self.path)
        PC = self.pclose
        # only watch these events
        mask = IN_CLOSE_WRITE | IN_CLOSE_NOWRITE

        # watch manager instance
        wm = WatchManager()
        notifier = Notifier(wm, PC)

        print 'monitoring of %s started' % self.path

        added_flag = False
        # read and process events
        while True:
            try:
                if not added_flag:
                    # on first iteration, add a watch on path:
                    # watch path for events handled by mask.
                    wm.add_watch(self.path, mask)
                    added_flag = True
                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()
            except KeyboardInterrupt:
                # ...until c^c signal
                print 'stop monitoring...'
                # stop monitoring
                notifier.stop()
                break
            except Exception, err:
                # otherwise keep on watching
                print err
Esempio n. 9
0
 def run(self, location='.'):
     transport = get_transport(location)
     root = transport.local_abspath('.')
     new_dirs = set('.')
     relpaths = set('.')
     while relpaths:
         relpath = relpaths.pop()
         paths = transport.list_dir(relpath)
         for path in paths:
             st = transport.stat(relpath + '/' + path)
             if S_ISDIR(st.st_mode):
                 if path != '.bzr':
                     new_dirs.add(relpath + '/' + path)
                 relpaths.add(relpath + '/' + path)
     # gather all dirs
     wm = WatchManager()
     added_flag = False
     handler = ProcessClose()
     handler._bzr_wm = wm
     notifier = Notifier(wm, handler)
     # read and process events
     try:
         while True:
             if new_dirs:
                 for path in new_dirs:
                     wm.add_watch(root + '/' + path, dir_mask)
                 new_dirs = set()
             notifier.process_events()
             if notifier.check_events():
                 notifier.read_events()
     finally:
         notifier.stop()
Esempio n. 10
0
def main(argv):
    if len(argv) == 1:
        print "Usage: %s [file]" % argv[0]
        return 1

    path = argv[1]

    logging.basicConfig(
        level=logging.DEBUG,
        format="%(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s",
        datefmt="%H:%M:%S",
        filename=None
        # filename = "/tmp/filemon.log"
    )

    logging.debug("Init Watcher (%s)" % path)

    class PClose(ProcessEvent):
        def process_default(self, event):
            logging.info("%s: %s: %s" % (getusers(event.pathname), event.pathname, str(event.maskname)))

    wm = WatchManager()
    notifier = Notifier(wm, PClose())
    wm.add_watch(path, EventsCodes.ALL_FLAGS["ALL_EVENTS"], rec=True)

    logging.info("Waiting for updates")
    while True:
        notifier.process_events()
        if notifier.check_events():
            notifier.read_events()

    return 0
def FSMonitor(path):
    wm = WatchManager()

    mask = IN_DELETE | IN_CREATE | IN_MODIFY

    notifier = Notifier(wm, EventHandler())

    wm.add_watch(path, mask, auto_add=True, rec=True)

    print('now starting monitor % s' % (path))

    while True:

        try:
            notifier.process_events()

            if notifier.check_events():

                notifier.read_events()

        except KeyboardInterrupt:

            notifier.stop()

            break
Esempio n. 12
0
class AutoLibraryUpdate(EventPlugin):
    PLUGIN_ID = "Automatic library update"
    PLUGIN_NAME = _("Automatic Library Update")
    PLUGIN_DESC = _("Keeps your library up to date with inotify. "
                    "Requires %s.") % "pyinotify"

    # TODO: make a config option
    USE_THREADS = True

    event_handler = None
    running = False

    def enabled(self):
        if not self.running:
            wm = WatchManager()
            self.event_handler = LibraryEvent(app.library)

            # Choose event types to watch for
            # FIXME: watch for IN_CREATE or for some reason folder copies
            # are missed,  --nickb
            FLAGS = ['IN_DELETE', 'IN_CLOSE_WRITE',# 'IN_MODIFY',
                     'IN_MOVED_FROM', 'IN_MOVED_TO', 'IN_CREATE']
            mask = reduce(lambda x, s: x | EventsCodes.ALL_FLAGS[s], FLAGS, 0)

            if self.USE_THREADS:
                print_d("Using threaded notifier")
                self.notifier = ThreadedNotifier(wm, self.event_handler)
                # Daemonize to ensure thread dies on exit
                self.notifier.daemon = True
                self.notifier.start()
            else:
                self.notifier = Notifier(wm, self.event_handler, timeout=100)
                GLib.timeout_add(1000, self.unthreaded_callback)

            for path in get_scan_dirs():
                print_d('Watching directory %s for %s' % (path, FLAGS))
                # See https://github.com/seb-m/pyinotify/wiki/
                # Frequently-Asked-Questions
                wm.add_watch(path, mask, rec=True, auto_add=True)

            self.running = True

    def unthreaded_callback(self):
        """Processes as much of the inotify events as allowed"""
        assert self.notifier._timeout is not None, \
                'Notifier must be constructed with a [short] timeout'
        self.notifier.process_events()
        # loop in case more events appear while we are processing
        while self.notifier.check_events():
            self.notifier.read_events()
        self.notifier.process_events()
        return True

    # disable hook, stop the notifier:
    def disabled(self):
        if self.running:
            self.running = False
        if self.notifier:
            print_d("Stopping inotify watch...")
            self.notifier.stop()
Esempio n. 13
0
    def run(self):
        self.pclose = PClose(self.path)
        PC = self.pclose
        # only watch these events
        mask = IN_CLOSE_WRITE | IN_CLOSE_NOWRITE

        # watch manager instance
        wm = WatchManager()
        notifier = Notifier(wm, PC)

        print 'monitoring of %s started' % self.path

        added_flag = False
        # read and process events
        while True:
            try:
                if not added_flag:
                    # on first iteration, add a watch on path:
                    # watch path for events handled by mask.
                    wm.add_watch(self.path, mask)
                    added_flag = True
                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()
            except KeyboardInterrupt:
                # ...until c^c signal
                print 'stop monitoring...'
                # stop monitoring
                notifier.stop()
                break
            except Exception, err:
                # otherwise keep on watching
                print err
Esempio n. 14
0
def _reloader_inotify(fnames, interval=None):
    #: Mutated by inotify loop when changes occur.
    changed = [False]

    # Setup inotify watches
    from pyinotify import WatchManager, EventsCodes, Notifier
    wm = WatchManager()
    mask = "IN_DELETE_SELF IN_MOVE_SELF IN_MODIFY IN_ATTRIB".split()
    mask = reduce(lambda m, a: m | getattr(EventsCodes, a), mask, 0)

    def signal_changed(event):
        if changed[0]:
            return
        _log('info', ' * Detected change in %r, reloading' % event.path)
        changed[:] = [True]

    for fname in fnames:
        wm.add_watch(fname, mask, signal_changed)

    # ... And now we wait...
    notif = Notifier(wm)
    try:
        while not changed[0]:
            notif.process_events()
            if notif.check_events(timeout=interval):
                notif.read_events()
            # TODO Set timeout to something small and check parent liveliness
    finally:
        notif.stop()
    sys.exit(3)
Esempio n. 15
0
class QNotifier(QThread):
    def __init__(self, wm, processor):
        self.event_queue = list()
        self._processor = processor
        self.notifier = Notifier(wm,
                            NinjaProcessEvent(self.event_queue.append))
        self.notifier.coalesce_events(True)
        self.keep_running = True
        QThread.__init__(self)

    def run(self):
        while self.keep_running:
            try:
                self.notifier.process_events()
            except OSError:
                pass  # OSError: [Errno 2] No such file or directory happens
            e_dict = {}
            while len(self.event_queue):
                e_type, e_path = self.event_queue.pop(0)
                e_dict.setdefault(e_path, []).append(e_type)

            keys = e_dict.keys()
            while len(keys):
                key = keys.pop(0)
                event = e_dict.pop(key)
                if (ADDED in event) and (DELETED in event):
                    event = [e for e in event if e not in (ADDED, DELETED)]
                for each_event in event:
                    self._processor(each_event, key)
            if self.notifier.check_events():
                self.notifier.read_events()

        self.notifier.stop()
Esempio n. 16
0
 def run(self):
     """Create the inotify WatchManager and generate FileSysEvents"""
     # Only capture events that git cares about
     self._wmgr = WatchManager()
     if self._is_pyinotify_08x():
         notifier = Notifier(self._wmgr, FileSysEvent(self),
                             timeout=self._timeout)
     else:
         notifier = Notifier(self._wmgr, FileSysEvent(self))
     dirs_seen = set()
     added_flag = False
     # self._abort signals app termination.  The timeout is a tradeoff
     # between fast notification response and waiting too long to exit.
     while not self._abort:
         if not added_flag:
             self._watch_directory(self._path)
             # Register files/directories known to git
             for filename in self._git.ls_files().splitlines():
                 directory = os.path.dirname(filename)
                 self._watch_directory(directory)
             added_flag = True
         notifier.process_events()
         if self._is_pyinotify_08x():
             check = notifier.check_events()
         else:
             check = notifier.check_events(timeout=self._timeout)
         if check:
             notifier.read_events()
     notifier.stop()
Esempio n. 17
0
    def run(self):
        """Create the inotify WatchManager and generate FileSysEvents"""

        if utils.is_win32():
            self.run_win32()
            return

        # Only capture events that git cares about
        self._wmgr = WatchManager()
        if self._is_pyinotify_08x():
            notifier = Notifier(self._wmgr, FileSysEvent(), timeout=self._timeout)
        else:
            notifier = Notifier(self._wmgr, FileSysEvent())

        self._watch_directory(self._path)

        # Register files/directories known to git
        for filename in core.decode(self._git.ls_files()).splitlines():
            filename = os.path.realpath(filename)
            directory = os.path.dirname(filename)
            self._watch_directory(directory)

        # self._running signals app termination.  The timeout is a tradeoff
        # between fast notification response and waiting too long to exit.
        while self._running:
            if self._is_pyinotify_08x():
                check = notifier.check_events()
            else:
                check = notifier.check_events(timeout=self._timeout)
            if not self._running:
                break
            if check:
                notifier.read_events()
                notifier.process_events()
        notifier.stop()
Esempio n. 18
0
def startSentry(sentry_paths):
    """
    Sentry Runner
    """
    notifier = Notifier(wm, do_event())
    for path in sentry_paths:
        wdd = wm.add_watch(sentry_paths[path].path, mask, rec=True)
        print 'watching %s ' % sentry_paths[path].path

    #wdd = wm.add_watch('/home/cmdln/sandbox/permissionminder/test', mask, rec=True)
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
        except ConfigChange:
            notifier.stop()
            raise ConfigChange('Config Changed')
            break
        except:
            #from pdb import set_trace;set_trace()
            pass
Esempio n. 19
0
	def __init__( self, path, MountDetectedCallback, UnmountDetectedCallback ):
		wm = WatchManager()
		notifier = Notifier( wm, MountEvents( MountDetectedCallback, UnmountDetectedCallback ) )
		wm.add_watch(path, pyinotify.IN_CREATE | pyinotify.IN_DELETE | pyinotify.IN_ISDIR )
		while( True ):
			notifier.process_events()
			if notifier.check_events():
				notifier.read_events()
			time.sleep( 0.1 )
Esempio n. 20
0
def fs_monitor(path=need_remove_disk_file):
        wm = WatchManager()
        mask = FLAG['OP_FLAGS']['IN_CLOSE_WRITE'] | FLAG['OP_FLAGS']['IN_CLOSE_NOWRITE']
        notifier = Notifier(wm, EventHandler())
        wm.add_watch(path, mask, rec=True)
        # print('now starting monitor %s' % path)

        while True:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
Esempio n. 21
0
def Monitor(path):
    notifier = Notifier(wm, PTmp())
    wdd = wm.add_watch(path, mask, rec=True)
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 22
0
def Monitor(path):
    notifier = Notifier(wm, PTmp())
    wdd = wm.add_watch(path, mask, rec=True)
    newDevice.put('/dev/waggle_coresense')
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 23
0
def newDev(path):
	notifier = Notifier(wm, PTmpCreate())
	wdd = wm.add_watch(path, maskCreate, rec=True)
	while True:  # loop forever
		time.sleep(0.1)
		try:
			notifier.process_events()
			if notifier.check_events():
				notifier.read_events()
		except KeyboardInterrupt:
			notifier.stop()
			break
Esempio n. 24
0
def Monitor(path):
    notifier = Notifier(wm, PTmp())
    wdd = wm.add_watch(path, mask, rec=True)
    newDevice.put('/dev/waggle_coresense')
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 25
0
def main(args):
    """
    args : [-h] [-r REGEX | -p REGEX] directory script

    example :
        react.py /local/data -p '*.hdf' 'echo $f'
        
    positional arguments :
        - directory:             the directory which is recursively monitored
        - script:                the script that is executed upon reaction

    optional arguments :
        -h, --help            show this help message and exit
        -r REGEX, --regex REGEX
                        files only trigger the reaction if their name matches
                        this regular expression
        -p REGEX, --pattern REGEX
                        files only trigger the reaction if their name matches
                        this shell pattern
     
    """

    parser = argparse.ArgumentParser(description='Launch a script if specified files change.')
    parser.add_argument('directory', help='the directory which is recursively monitored')

    group = parser.add_mutually_exclusive_group()
    group.add_argument('-r', '--regex', required=False, default=".*", help='files only trigger the reaction if their name matches this regular expression')
    group.add_argument('-p', '--pattern', required=False, dest="regex", action=PatternAction, help='files only trigger the reaction if their name matches this shell pattern')

    parser.add_argument("script", help="the script that is executed upon reaction")
    options = Options()

    args = parser.parse_args(namespace=options)

    #print sys.argv
    while True:
        wm = WatchManager()
        process = Process(options)

        notifier = Notifier(wm, process)
        mask = IN_DELETE | IN_CREATE | IN_CLOSE_WRITE
        wdd = wm.add_watch(options.directory, mask, rec=True)
        try:
            while True:
                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()
        except Reload:
            pass
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 26
0
def inotify_watch():
    wm = WatchManager()
    mask = EventsCodes.ALL_FLAGS['IN_CLOSE_WRITE']
    wdd = wm.add_watch('src', mask, rec=True)
    notifier = Notifier(wm, PTmp())
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 27
0
def Monitor(path, which_dev):
    notifier = Notifier(wm, PTmp())
    wdd = wm.add_watch(path, mask, rec=True)
    #    newDevice.put('/dev/ttyACM'+which_dev)
    newDevice.put(which_dev)
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 28
0
def start_watcher(source, new_files, destination, bitrate):
    wm = WatchManager()
    process = Process(new_files, destination, bitrate)
    notifier = Notifier(wm, process)
    # TODO detect files moving from a dir to another
    wm.add_watch(source, IN_CLOSE_WRITE, rec=True)
    try:
        while True:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
    except KeyboardInterrupt:
        notifier.stop()
Esempio n. 29
0
def start_watcher(source, new_files, destination, bitrate):
    wm = WatchManager()
    process = Process(new_files, destination, bitrate)
    notifier = Notifier(wm, process)
    # TODO detect files moving from a dir to another
    wm.add_watch(source, IN_CLOSE_WRITE, rec=True)
    try:
        while True:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
    except KeyboardInterrupt:
        notifier.stop()
Esempio n. 30
0
 def run(self):
     wm = WatchManager()
     mask = IN_DELETE | IN_CREATE | IN_MODIFY | IN_ATTRIB
     notifier = Notifier(wm, MyEventHandler())
     wm.add_watch(self.path, mask, auto_add=True, rec=True)
     print("Now starting monitor {0}".format(self.path))
     while True:
         try:
             notifier.process_events()
             if notifier.check_events():
                 notifier.read_events()
         except KeyboardInterrupt:
             notifier.stop()
             break
Esempio n. 31
0
    def socket_loop(self):
        wm = WatchManager()
        mask = pyinotify.IN_CREATE | pyinotify.IN_DELETE
        notifier = Notifier(wm, EventHandler(self))
        wm.add_watch(VLC_CACHE_PATH, mask, rec=True)

        while True:
            try:
                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()
            except KeyboardInterrupt:
                notifier.stop()
                break
def Monitor(path):
    wm = WatchManager()
    mask = IN_DELETE | IN_CREATE | IN_MOVED_TO | IN_ATTRIB | IN_ACCESS | IN_CLOSE_WRITE
    notifier = Notifier(wm, EventHandler())
    wm.add_watch(path, mask, rec=True)
    print '[+] Now Starting Monitor:  %s' % (path)
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 33
0
def FSMonitor(path='/var/log'):
    wm = WatchManager()
    mask = IN_DELETE | IN_CREATE |IN_MODIFY
    notifier = Notifier(wm, EventHandler())
    wm.add_watch(path, mask,rec=True)
    print 'now starting monitor %s'%(path)
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 34
0
def FSMonitor(path="."):
    wm = WatchManager()
    mask = IN_DELETE | IN_CREATE | IN_MODIFY | IN_ACCESS | IN_ATTRIB
    notifier = Notifier(wm, EventHandler())
    wm.add_watch(path, mask, rec=True)
    print ("now starting monitor %s" % (path))
    while True:
        try:
            notifier.process_events()  # 绑定处理event方法
            if notifier.check_events():  # 检查是否有有可读取的新event
                notifier.read_events()  # 读取event,交给EventHandler处理
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 35
0
def FSMonitor(path='.'):
    wm = WatchManager() 
    mask = IN_DELETE | IN_CREATE | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE | IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE_SELF | IN_MOVE_SELF
    notifier = Notifier(wm, EventHandler())
    wm.add_watch(path, mask,auto_add=True,rec=True)
    print 'now starting monitor %s'%(path)
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 36
0
    def run(self):
        for i in self.path:
            self.init_watch(i)
            print '开始监控 %s' % (i)
        notifier = Notifier(self.wm, EventHandler())

        while True:
            try:
                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()
            except KeyboardInterrupt:
                notifier.stop()
                break
Esempio n. 37
0
    def run(self):
        for i in self.path:
            self.init_watch(i)
            print('开始监控 %s' % (i))
        notifier = Notifier(self.wm, EventHandler())

        while True:
            try:
                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()
            except KeyboardInterrupt:
                notifier.stop()
                break
Esempio n. 38
0
class InoTailer(BaseTailer):
    def __init__(self, file, should_read=True, callback=None, timeout=None):
        super(InoTailer, self).__init__(file, callback, timeout)
        if self.timeout:
            self.timeout *= 1000

        self._should_read_myself = should_read
        if not hasattr(self.file, 'fileno') and self._should_read_myself:
            if not os.path.exists(self.file):
                raise DoesNotExist("Can't find %s. It does not seem to exist" % self.file)
            self.file = open(self.file)

        class Watcher(ProcessEvent):
            pass
        if callable(self.callback):
            setattr(Watcher, 'process_IN_MODIFY', self.callback)
        mask = IN_MODIFY
        self.wm = WatchManager()
        self.notifier = Notifier(self.wm, Watcher())
        self.wm.add_watch(self.file.name, mask,)

        self._initial_lines = None
        if not self.at_end():
            if self._should_read_myself:
                self._initial_lines = self.file.read().rstrip('\n').split('\n')
            else:
                self._initial_lines = True

    def at_end(self):
        return self.file.tell() == os.path.getsize(self.file.name)

    def check_once(self):
        if self._initial_lines:
            self._initial_lines, result = None, self._initial_lines
            return result
        self.notifier.process_events()
        if self.notifier.check_events(self.timeout):
            self.notifier.read_events()
            if self._should_read_myself:
                result = self.file.read().rstrip('\n').split('\n')
                return result
            return True
        return None

    def wait(self, with_timeout=False):
        timeout = None
        if with_timeout:
            timeout = self.timeout
        self.notifier.check_events(timeout)
Esempio n. 39
0
class INotifyDriver(Component):

    channel = "inotify"

    def __init__(self, freq=1, timeout=1, channel=channel):
        super(INotifyDriver, self).__init__(channel=channel)

        self._freq = freq
        self._wm = WatchManager()
        self._notifier = Notifier(self._wm, self._process, timeout=timeout)

    def _sleep(self, rtime):
        # Only consider sleeping if _freq is > 0
        if self._freq > 0:
            ctime = time.time()
            s = self._freq - (ctime - rtime)
            if s > 0:
                time.sleep(s)

    def __tick__(self):
        self._notifier.process_events()
        rtime = time.time()
        if self._notifier.check_events():
            self._sleep(rtime)
            self._notifier.read_events()

    def _process(self, event):
        dir = event.dir
        mask = event.mask
        path = event.path
        name = event.name
        pathname = event.pathname
        
        #print dir, mask, path, name, pathname

        for k, v in EVENT_MAP.iteritems():
            if mask & k:
                e = v(name, path, pathname, dir)
                c = e.name.lower()
                self.push(e, c)

    def add(self, path, mask=None, recursive=True):
        mask = mask or MASK
        self._wm.add_watch(path, mask, rec=recursive)

    def remove(self, path, recursive=False):
        wd = self._wm.get_wd(path)
        if wd:
            self._wm.rm_watch(wd, rec=recursive)
Esempio n. 40
0
	def run(self):
		sys.stdout.write('Daemon started with pid %d\n' % os.getpid())
		wm = WatchManager()
		mask = IN_CREATE | IN_MODIFY
		notifier = Notifier(wm, EventHandler())
		wdd = wm.add_watch(FSpath, mask, rec=True)
		print 'now starting monitor %s' % (FSpath)
		while True:
			try:
				notifier.process_events()
				if notifier.check_events():
					notifier.read_events()
			except KeyboardInterrupt:
				notifier.stop()
				break
Esempio n. 41
0
def Monitor(path='.'):
    wm=WatchManager()
    mask=IN_CREATE|IN_DELETE
    handler=Handler()
    notifier=Notifier(wm,handler)
    wm.add_watch(path,mask,rec=True)
    print 'now start monitor ... %s ' %path
    while True:
	try:
	    notifier.process_events()
	    if notifier.process_events():
		notifier.read_events()
	except KeyboardInterrupt:
	    notifier.stop()
	    break
Esempio n. 42
0
	def run (self):
		global  watchQueue
		toWatch = watchQueue.get()
		if toWatch :
			notifier = Notifier(wm, PTmpCreate())
			wdd = wm.add_watch(toWatch, maskCreate, rec=True)
			while True:  # loop forever
				time.sleep(1)
				try:
					notifier.process_events()
					if notifier.check_events():
						notifier.read_events()
				except KeyboardInterrupt:
					notifier.stop()
					break
Esempio n. 43
0
def FsMonitor(path='.'):
    wm = WatchManager()
    mask = IN_DELETE | IN_CREATE | IN_MODIFY
    notifier = Notifier(wm, EventHandler())
    wm.add_watch(path, mask, auto_add=True, rec=True)
    print("Now Start Monitoring %s.\n" % path)

    while True:
        try:
            notifier.process_events()
            notifier.read_events()
        except KeyboardInterrupt:
            print("Keyboard Interrupt.")
            notifier.stop()
            break
Esempio n. 44
0
    def __monitor(self):

        wm = WatchManager()
        mask = pyinotify.IN_DELETE | pyinotify.IN_CREATE | pyinotify.IN_MODIFY | pyinotify.IN_ACCESS | pyinotify.IN_ATTRIB
        notifier = Notifier(wm,self.eventHandler)
        wm.add_watch(self.path,mask,rec=True)
        print('now starting monitor %s',self.path)
        while True:
            try:
                notifier.process_events()  # 绑定处理event方法
                if notifier.check_events():  # 检查是否有有可读取的新event
                    notifier.read_events()  # 读取event,交给EventHandler处理
            except KeyboardInterrupt:
                notifier.stop()
                break
Esempio n. 45
0
    def run(self):
        self.send_from_outbox()

        wm = WatchManager()
        wm.add_watch(self.outbox_path.__str__(), IN_CREATE)

        notifier = Notifier(wm, MailerEventHandler(self.send_from_outbox))
        while True:
            try:
                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()
            except KeyboardInterrupt:
                notifier.stop()
                break
Esempio n. 46
0
def fsMonitor(path="/opt/deviceMonitor/access.log"):
    wm = WatchManager()
    mask = IN_DELETE | IN_CREATE | IN_MODIFY
    notifier = Notifier(wm, eventHandler())
    wm.add_watch(path, mask, auto_add=True, rec=True)
    #print "now starting monitor %s." %path

    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 47
0
def FSMonitor(path='../public/print'):
    wm = WatchManager()
    mask = IN_CLOSE_WRITE | IN_CREATE  #IN_DELETE | IN_CREATE | IN_MODIFY
    notifier = Notifier(wm, EventHandler())
    wm.add_watch(path, mask, rec=True)
    print "now starting monitor %s" % (path)
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            print KeyboardInterrupt
            break
Esempio n. 48
0
 def run(self):
     sys.stdout.write('Daemon started with pid %d\n' % os.getpid())
     wm = WatchManager()
     mask = IN_CREATE | IN_MODIFY
     notifier = Notifier(wm, EventHandler())
     wdd = wm.add_watch(FSpath, mask, rec=True)
     print 'now starting monitor %s' % (FSpath)
     while True:
         try:
             notifier.process_events()
             if notifier.check_events():
                 notifier.read_events()
         except KeyboardInterrupt:
             notifier.stop()
             break
Esempio n. 49
0
	def run(self):
		mask = IN_DELETE | IN_CREATE | IN_MODIFY
		wm = WatchManager()
		notifier = Notifier(wm, MyEventHandler())
		wm.add_watch(scriptdir+"/Common", mask, auto_add= True, rec=True)
		wm.add_watch(scriptdir+"/Special", mask, auto_add= True, rec=True)
		wm.add_watch(scriptdir+"/Override", mask, auto_add= True, rec=True)

		while True:
			try:
				notifier.process_events()
				if notifier.check_events():
					notifier.read_events()
			except KeyboardInterrupt:
				notifier.stop()
    def run(self):
        logger.info( '['+self.name+'] watching: '+ self.spath )
        wm = WatchManager() 
        mask = EventsCodes.OP_FLAGS["IN_DELETE"] | EventsCodes.OP_FLAGS["IN_CREATE"] |EventsCodes.OP_FLAGS["IN_MODIFY"] | EventsCodes.OP_FLAGS["IN_MOVED_TO"] | EventsCodes.OP_FLAGS["IN_MOVED_FROM"]
        notifier = Notifier(wm, WorkEvent("WEVNT",self.workqueue))
        wm.add_watch(self.spath, mask,rec=True)

        while True:
            try:
                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()
            except KeyboardInterrupt:
                notifier.stop()
                break
Esempio n. 51
0
def fsMonitor(path="."):
    wm = WatchManager()  # 创建监控组
    mask = IN_CREATE | IN_DELETE | IN_MODIFY
    wm.add_watch(path, mask, auto_add=True, rec=True)  # 将具体路径的监控加入监视组
    notifier = Notifier(wm, EventHandler())  # 创建事件处理器,参数为监视组和对应的事件处理函数
    print("now starting monitor %s." % path)
    while True:
        try:
            notifier.process_events()  # 对事件队列中的事件逐个调用事件处理函数
            if notifier.check_events():  # 等待 检查是否有新事件到来
                print("check event true")
                notifier.read_events()  # 将新事件读入事件队列
        except KeyboardInterrupt:
            print("keyboard interrupt")
            notifier.stop()
            break
Esempio n. 52
0
def FSMonitor():
	back_sql()
	
	wm = WatchManager()
	mask = IN_CREATE | IN_MODIFY
	notifier = Notifier(wm, PFilePath())
	wdd = wm.add_watch(find_path, mask, rec=True)
	print("now starting monitor %s" % find_path)
	while True:
		try:
			notifier.process_events()
			if notifier.check_events():
				notifier.read_events()
		except KeyboardInterrupt:
			notifier.stop()
			break
Esempio n. 53
0
def Monitor(path_list):
    wm = WatchManager()
    notifier = Notifier(wm, MyProcessEvent())

    for path in path_list:
        print '增加监控路径: %s' % path
        wm.add_watch(os.path.abspath(path), MASK, rec=True, auto_add=True)

    try:
        while 1:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
    except KeyboardInterrupt:
        notifier.stop()
        return
Esempio n. 54
0
 def run(self):
     notifier = Notifier(self.watchmanager, self.event)
     descriptor = self.watchmanager.add_watch(
         self.folder, EventsCodes.ALL_FLAGS['ALL_EVENTS'],
         rec=self.recursive)
     logging.info('Watching %i folders', len(descriptor))
     if self.first_run:
         self.event.run_cmd(True)
     while True:
         try:
             notifier.process_events()
             if notifier.check_events():
                 notifier.read_events()
         except KeyboardInterrupt:
             notifier.stop()
             break
Esempio n. 55
0
class INotifyDriver(Component):

    channel = "inotify"

    def __init__(self, freq=1, timeout=1, channel=channel):
        super(INotifyDriver, self).__init__(channel=channel)

        self._freq = freq
        self._wm = WatchManager()
        self._notifier = Notifier(self._wm, self._process, timeout=timeout)

    def _sleep(self, rtime):
        # Only consider sleeping if _freq is > 0
        if self._freq > 0:
            ctime = time.time()
            s = self._freq - (ctime - rtime)
            if s > 0:
                time.sleep(s)

    def __tick__(self):
        self._notifier.process_events()
        rtime = time.time()
        if self._notifier.check_events():
            self._sleep(rtime)
            self._notifier.read_events()

    def _process(self, event):
        dir = event.dir
        mask = event.mask
        path = event.path
        name = event.name
        pathname = event.pathname

        for k, v in EVENT_MAP.iteritems():
            if mask & k:
                e = v(name, path, pathname, dir)
                c = e.name.lower()
                self.push(e, c)

    def add(self, path, mask=None, recursive=False):
        mask = mask or MASK
        self._wm.add_watch(path, mask, rec=recursive)

    def remove(self, path, recursive=False):
        wd = self._wm.get_wd(path)
        if wd:
            self._wm.rm_watch(wd, rec=recursive)
Esempio n. 56
0
class MyNotify(object):
    def __init__(self, path):
        self.wm = WatchManager()
        mask = IN_DELETE | IN_CLOSE_WRITE
        self.notifier = Notifier(self.wm, MyProcessEvent())
        self.wm.add_watch(path, mask, rec=True)

    def run(self):
        signal.signal(signal.SIGHUP, lambda: sys.exit(0))
        while True:
            try:
                self.notifier.process_events()
                if self.notifier.check_events():
                    self.notifier.read_events()
            except Exception:
                self.notifier.stop()
                break
Esempio n. 57
0
def FsMonitor(path='.'):
    wm = WatchManager()
    mask = IN_DELETE | IN_CREATE | IN_MODIFY
    notifier = Notifier(wm, EventHandler())
    wm.add_watch(path, mask, auto_add=True, rec=True)
    print "[*] now starting monitor %s." % path

    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                print "check event true."
                notifier.read_events()
        except KeyboardInterrupt:
            print "keyboard Interrupt."
            notifier.stop()
            break