示例#1
0
class Gamin(FileMonitor):
    """ file monitor with gamin support """
    __priority__ = 10

    def __init__(self, ignore=None, debug=False):
        FileMonitor.__init__(self, ignore=ignore, debug=debug)
        self.mon = None
        self.counter = 0
        self.add_q = []

    def start(self):
        FileMonitor.start(self)
        self.mon = WatchMonitor()
        for monitor in self.add_q:
            self.AddMonitor(*monitor)
        self.add_q = []

    def fileno(self):
        return self.mon.get_fd()

    def queue(self, path, action, request_id):
        """queue up the event for later handling"""
        self.events.append(GaminEvent(request_id, path, action))

    def AddMonitor(self, path, obj, handle=None):
        """Add a monitor to path, installing a callback to obj."""
        if handle is None:
            handle = self.counter
            self.counter += 1

        if not self.started:
            self.add_q.append((path, obj, handle))
            return handle

        mode = os.stat(path)[stat.ST_MODE]

        # Flush queued gamin events
        while self.mon.event_pending():
            self.mon.handle_one_event()

        if stat.S_ISDIR(mode):
            self.mon.watch_directory(path, self.queue, handle)
        else:
            self.mon.watch_file(path, self.queue, handle)
        self.handles[handle] = obj
        return handle

    def pending(self):
        return FileMonitor.pending(self) or self.mon.event_pending()

    def get_event(self):
        if self.mon.event_pending():
            self.mon.handle_one_event()
        return FileMonitor.get_event(self)
示例#2
0
文件: FileMonitor.py 项目: syb/bcfg2
    class Gamin(FileMonitor):
        """
        The fam object is a set of callbacks for
        file alteration events (Gamin support)
        """

        def __init__(self, debug=False):
            FileMonitor.__init__(self, debug)
            self.mon = WatchMonitor()
            self.counter = 0
            self.events = []

        def fileno(self):
            return self.mon.get_fd()

        def queue(self, path, action, request_id):
            """queue up the event for later handling"""
            self.events.append(GaminEvent(request_id, path, action))

        def AddMonitor(self, path, obj):
            """Add a monitor to path, installing a callback to obj.HandleEvent."""
            handle = self.counter
            self.counter += 1
            mode = os.stat(path)[stat.ST_MODE]

            # Flush queued gamin events
            while self.mon.event_pending():
                self.mon.handle_one_event()

            if stat.S_ISDIR(mode):
                self.mon.watch_directory(path, self.queue, handle)
            else:
                self.mon.watch_file(path, self.queue, handle)
            self.handles[handle] = obj
            return handle

        def pending(self):
            return len(self.events) > 0 or self.mon.event_pending()

        def get_event(self):
            if self.mon.event_pending():
                self.mon.handle_one_event()
            return self.events.pop(0)
示例#3
0
    class Gamin(FileMonitor):
        """
        The fam object is a set of callbacks for
        file alteration events (Gamin support)
        """
        def __init__(self, debug=False):
            FileMonitor.__init__(self, debug)
            self.mon = WatchMonitor()
            self.counter = 0
            self.events = []

        def fileno(self):
            return self.mon.get_fd()

        def queue(self, path, action, request_id):
            """queue up the event for later handling"""
            self.events.append(GaminEvent(request_id, path, action))

        def AddMonitor(self, path, obj):
            """Add a monitor to path, installing a callback to obj.HandleEvent."""
            handle = self.counter
            self.counter += 1
            mode = os.stat(path)[stat.ST_MODE]

            # Flush queued gamin events
            while self.mon.event_pending():
                self.mon.handle_one_event()

            if stat.S_ISDIR(mode):
                self.mon.watch_directory(path, self.queue, handle)
            else:
                self.mon.watch_file(path, self.queue, handle)
            self.handles[handle] = obj
            return handle

        def pending(self):
            return len(self.events) > 0 or self.mon.event_pending()

        def get_event(self):
            if self.mon.event_pending():
                self.mon.handle_one_event()
            return self.events.pop(0)
示例#4
0
文件: Gamin.py 项目: xschlef/bcfg2
class Gamin(FileMonitor):
    """ File monitor backend with `Gamin
    <http://people.gnome.org/~veillard/gamin/>`_ support. **Deprecated.** """

    #: The Gamin backend is deprecated, but better than pseudo, so it
    #: has a medium priority.
    __priority__ = 50

    def __init__(self):
        FileMonitor.__init__(self)

        #: The :class:`Gamin.WatchMonitor` object for this monitor.
        self.mon = None

        #: The counter used to produce monotonically increasing
        #: monitor handle IDs
        self.counter = 0

        #: The queue used to record monitors that are added before
        #: :func:`start` has been called and :attr:`mon` is created.
        self.add_q = []

        self.logger.warning("The Gamin file monitor backend is deprecated. "
                            "Please switch to a supported file monitor.")
    __init__.__doc__ = FileMonitor.__init__.__doc__

    def start(self):
        """ The Gamin watch monitor in :attr:`mon` must be created by
        the daemonized process, so is created in ``start()``. Before
        the :class:`Gamin.WatchMonitor` object is created, monitors
        are added to :attr:`add_q`, and are created once the watch
        monitor is created."""
        FileMonitor.start(self)
        self.mon = WatchMonitor()
        for monitor in self.add_q:
            self.AddMonitor(*monitor)
        self.add_q = []

    def fileno(self):
        if self.started:
            return self.mon.get_fd()
        else:
            return None
    fileno.__doc__ = FileMonitor.fileno.__doc__

    def queue(self, path, action, request_id):
        """ Create a new :class:`GaminEvent` and add it to the
        :attr:`events` queue for later handling. """
        self.events.append(GaminEvent(request_id, path, action))

    def AddMonitor(self, path, obj, handle=None):
        if handle is None:
            handle = self.counter
            self.counter += 1

        if not self.started:
            self.add_q.append((path, obj, handle))
            return handle

        mode = os.stat(path)[stat.ST_MODE]

        # Flush queued gamin events
        while self.mon.event_pending():
            self.mon.handle_one_event()

        if stat.S_ISDIR(mode):
            self.mon.watch_directory(path, self.queue, handle)
        else:
            self.mon.watch_file(path, self.queue, handle)
        self.handles[handle] = obj
        return handle
    AddMonitor.__doc__ = FileMonitor.AddMonitor.__doc__

    def pending(self):
        return FileMonitor.pending(self) or self.mon.event_pending()
    pending.__doc__ = FileMonitor.pending.__doc__

    def get_event(self):
        if self.mon.event_pending():
            self.mon.handle_one_event()
        return FileMonitor.get_event(self)
    get_event.__doc__ = FileMonitor.get_event.__doc__
示例#5
0
#INICIO DEL PROGRAMA
opts, args = proc_opts()

preparaInt(opts.directorio)
d = dbm.open(opts.hashfile, "r")


def monitor(fichero, event):
    if event == GAMChanged:
        if d.has_key(os.path.join(opts.directorio, fichero)):
            if d[os.path.join(opts.directorio, fichero)] != funcHash(
                    os.path.join(opts.directorio, fichero)):
                print "Ha cambiado el contenido de " + fichero + " el " + time.strftime(
                    "%d/%b/%Y - %H:%M:%S")
        else:
            None
    return True


if __name__ == "__main__":
    mon = WatchMonitor()
    mon.watch_directory(opts.directorio, monitor)
    time.sleep(1)
    fd = mon.get_fd()
    while True:
        select([fd], [], [])
        if mon.event_pending():
            mon.handle_events()
    mon.stop_watch(fichero)
    del mon