def test___eq__(self): watch1 = ObservedWatch('/foobar', True) watch2 = ObservedWatch('/foobar', True) watch_ne1 = ObservedWatch('/foo', True) watch_ne2 = ObservedWatch('/foobar', False) assert_true(watch1.__eq__(watch2)) assert_false(watch1.__eq__(watch_ne1)) assert_false(watch1.__eq__(watch_ne2))
def test_observer__ne__(): watch1 = ObservedWatch('/foobar', True) watch2 = ObservedWatch('/foobar', True) watch_ne1 = ObservedWatch('/foo', True) watch_ne2 = ObservedWatch('/foobar', False) assert not watch1.__ne__(watch2) assert watch1.__ne__(watch_ne1) assert watch1.__ne__(watch_ne2)
def test___ne__(self): watch1 = ObservedWatch('/foobar', True) watch2 = ObservedWatch('/foobar', True) watch_ne1 = ObservedWatch('/foo', True) watch_ne2 = ObservedWatch('/foobar', False) self.assertFalse(watch1.__ne__(watch2)) self.assertTrue(watch1.__ne__(watch_ne1)) self.assertTrue(watch1.__ne__(watch_ne2))
def start_watching(path=None, use_full_emitter=False): path = p('') if path is None else path global emitter if platform.is_linux() and use_full_emitter: emitter = InotifyFullEmitter(event_queue, ObservedWatch(path, recursive=True)) else: emitter = Emitter(event_queue, ObservedWatch(path, recursive=True)) if platform.is_darwin(): # FSEvents will report old evens (like create for mkdtemp in test # setup. Waiting for a considerable time seems to 'flush' the events. time.sleep(10) emitter.start()
def start_watching(path=None, use_full_emitter=False, recursive=True): # todo: check if other platforms expect the trailing slash (e.g. `p('')`) path = p() if path is None else path global emitter if platform.is_linux() and use_full_emitter: emitter = InotifyFullEmitter(event_queue, ObservedWatch(path, recursive=recursive)) else: emitter = Emitter(event_queue, ObservedWatch(path, recursive=recursive)) if platform.is_darwin(): emitter.suppress_history = True emitter.start()
def start_watching(path=None, use_full_emitter=False): global emitter path = p("") if path is None else path emitter = FSEventsEmitter(event_queue, ObservedWatch(path, recursive=True), suppress_history=True) emitter.start()
def emitter(event_queue): watch = ObservedWatch(temp_dir, True) em = Emitter(event_queue, watch, timeout=0.2) em.start() yield em em.stop() em.join(5)
def test_schedule_with(self): # This provides more readable traceback message for ObservedWatch. def ow_repr(self): return str((self.path, self.is_recursive)) setattr(ObservedWatch, '__repr__', ow_repr) # mock open so that files other than '.gitignore' raise exception m = mock_open(read_data='*.py[cod]\n__pycache__/\n') patcher = patch('builtins.open', m) patcher.start() # reset gitignore path to '.gitignore' (a file that exists) self.parser.gitignore_path = '.gitignore' observer = Observer() result = self.parser.schedule_with(observer, self.HandlerClass) # expected handlers = [] for dog in self.dogs: handler = dog.create_handler(self.HandlerClass) handlers.append(handler) watches = [] for dog in self.dogs: watch = ObservedWatch(*dog.watch_info) watches.append(watch) handler_for_watch = { watches[0]: set([handlers[0], handlers[1]]), watches[2]: set([handlers[2]]), watches[3]: set([handlers[3]]), } self.maxDiff = None # self.fail((result, handler_for_watch)) self.assertEqual(result, handler_for_watch) patcher.stop()
def start(self): sleep(0.5) self.event_queue = queue.Queue() global temp_dir self.watch = ObservedWatch(temp_dir, True) self.emitter = Emitter(self.event_queue, self.watch, timeout=0.2) self.emitter.start() sleep(0.5)
def watching(path=None, use_full_emitter=False): path = p("") if path is None else path global emitter Emitter = InotifyFullEmitter if use_full_emitter else InotifyEmitter emitter = Emitter(event_queue, ObservedWatch(path, recursive=True)) emitter.start() yield emitter.stop() emitter.join(5)
def ObservedWatch(self, path=None, recursive=False): """ Return an ObservedWatch instance. """ if path is None: path = mk.fs.temp_path path = mk.fs.getEncodedPath(path) return ObservedWatch(path=path, recursive=recursive)
def start_watching(path=None, use_full_emitter=False, recursive=True): # todo: check if other platforms expect the trailing slash (e.g. `p('')`) path = p() if path is None else path global emitter if platform.is_linux() and use_full_emitter: emitter = InotifyFullEmitter(event_queue, ObservedWatch(path, recursive=recursive)) else: emitter = Emitter(event_queue, ObservedWatch(path, recursive=recursive)) emitter.start() if platform.is_darwin(): # FSEvents _may_ report the event for the creation of `tmpdir`, # however, we're racing with fseventd there - if other filesystem # events happened _after_ `tmpdir` was created, but _before_ we # created the emitter then we won't get this event. # As such, let's create a sentinel event that tells us that we are # good to go. sentinel_file = os.path.join( path, '.sentinel' if isinstance(path, str) else '.sentinel'.encode()) touch(sentinel_file) sentinel_events = [ FileCreatedEvent(sentinel_file), DirModifiedEvent(path), FileModifiedEvent(sentinel_file) ] next_sentinel_event = sentinel_events.pop(0) now = time.monotonic() while time.monotonic() <= now + 30.0: try: event = event_queue.get(timeout=0.5)[0] if event == next_sentinel_event: if not sentinel_events: break next_sentinel_event = sentinel_events.pop(0) except Empty: pass time.sleep(0.1) else: assert False, "Sentinel event never arrived!"
def schedule(self, event_handler, path, emitter_cls=None): with self._lock: watch = ObservedWatch(path, True) emitter = emitter_cls(self.event_queue, watch, self.timeout) if self.is_alive(): emitter.start() self._add_handler_for_watch(event_handler, watch) self._add_emitter(emitter) self._watches.add(watch) return watch
def test___ne__(self): watch1 = ObservedWatch("/foobar", True) watch2 = ObservedWatch("/foobar", True) watch_ne1 = ObservedWatch("/foo", True) watch_ne2 = ObservedWatch("/foobar", False) self.assertFalse(watch1.__ne__(watch2)) self.assertTrue(watch1.__ne__(watch_ne1)) self.assertTrue(watch1.__ne__(watch_ne2))
def test___eq__(self): watch1 = ObservedWatch('/foobar', True) watch2 = ObservedWatch('/foobar', True) watch_ne1 = ObservedWatch('/foo', True) watch_ne2 = ObservedWatch('/foobar', False) self.assertTrue(watch1.__eq__(watch2)) self.assertFalse(watch1.__eq__(watch_ne1)) self.assertFalse(watch1.__eq__(watch_ne2))
def test___ne__(self): watch1 = ObservedWatch('/foobar', True) watch2 = ObservedWatch('/foobar', True) watch_ne1 = ObservedWatch('/foo', True) watch_ne2 = ObservedWatch('/foobar', False) assert_false(watch1.__ne__(watch2)) assert_true(watch1.__ne__(watch_ne1)) assert_true(watch1.__ne__(watch_ne2))
def test_passing_bytes_should_give_bytes(p): from watchdog.utils.unicode_paths import bytes_cls path = bytes_cls(p(''), 'ascii') assert isinstance(p(''), bytes_cls) event_queue = Queue() emitter = Emitter(event_queue, ObservedWatch(path, recursive=True)) emitter.start() touch(p('a')) event = event_queue.get(timeout=5)[0] assert isinstance(event.src_path, bytes_cls)
def _setup_emitter(path): event_queue = Queue() if platform.is_darwin(): # FSEvents will report old evens (like create for mkdtemp in test # setup. Waiting for a considerable time seems to 'flush' the events. time.sleep(10) emitter = Emitter(event_queue, ObservedWatch(path, recursive=True)) emitter.start() return event_queue, emitter
def test_dispatch_event(self): event = FileModifiedEvent("/foobar") watch = ObservedWatch("/path", True) class TestableEventDispatcher(EventDispatcher): def dispatch_event(self, event, watch): assert True event_dispatcher = TestableEventDispatcher() event_dispatcher.event_queue.put((event, watch)) event_dispatcher.start() time.sleep(1) event_dispatcher.stop()
def _set_root(self, root): """Set up watching `root` or closest existing parent.""" if self.root_watch is not None and self.root_watch.path == root: # already watching the specified root, return early return # schedule new root watch while True: try: watch = self.root_observer.schedule( event_handler=self, path=root, recursive=False ) except OSError as sched_err: # root doesn't exist, move up one directory and try again try: # clean up from failed scheduling self.root_observer.unschedule(ObservedWatch(root, False)) except KeyError: pass newroot = os.path.dirname(root) if newroot == root: # we've gotten to system root and still failed raise sched_err else: root = newroot else: # watch was set, break out of while loop break # add regex for root and next subdirectory regexes = [] regexes.append("^" + re.escape(root) + "$") nextdir = self._get_next_dir_in_path(root) if nextdir != root: regexes.append("^" + re.escape(nextdir) + "$") # update handler (self) with regexes RegexMatchingEventHandler.__init__( self, regexes=regexes, ignore_directories=False ) # unschedule old root watch if self.root_watch is not None: try: self.root_observer.unschedule(self.root_watch) except KeyError: # emitter already stopped pass self.root_watch = watch
def test_close_clean(tmpdir): """ On InotifyBuffer.close() InotifyBuffer.read_event() is un-blocked so that Inotify thread waiting for it can be closed. This is also a test for Inotify.queue_events handling of STOP_EVENT and InotifyBuffer.close() is test as side effect of Inotify.stop() """ watch = ObservedWatch(path=tmpdir, recursive=False) emitter = InotifyEmitter([], watch) emitter.start() emitter.stop() emitter.join(1) assert not emitter.isAlive()
def schedule(self, event_handler, path, recursive=False, initial_state=None): """ Schedules watching a path and calls appropriate methods specified in the given event handler in response to file system events. :param initial_state: The previous state of the directory. Files changes happened after the initial_state will be considered, previous events will be ignored. :type initial_state: :class:`DirectorySnapshot` :param from_scratch: If True will consider all files in path as new :type from_scratch: ``bool`` :param event_handler: An event handler instance that has appropriate event handling methods which will be called by the observer in response to file system events. :type event_handler: :class:`watchdog.events.FileSystemEventHandler` or a subclass :param path: Directory path that will be monitored. :type path: ``str`` :param recursive: ``True`` if events will be emitted for sub-directories traversed recursively; ``False`` otherwise. :type recursive: ``bool`` :return: An :class:`ObservedWatch` object instance representing a watch. """ with self._lock: watch = ObservedWatch(path, recursive) self._add_handler_for_watch(event_handler, watch) # If we don't have an emitter for this watch already, create it. if self._emitter_for_watch.get(watch) is None: emitter = self._emitter_class(event_queue=self.event_queue, watch=watch, timeout=self.timeout, initial_state=initial_state) self._add_emitter(emitter) if self.is_alive(): emitter.start() self._watches.add(watch) return watch
def test_add_watch_twice(observer): """ Adding the same watch twice used to result in a null pointer return without an exception. See https://github.com/gorakhargosh/watchdog/issues/765 """ a = p("a") mkdir(a) h = FileSystemEventHandler() w = ObservedWatch(a, recursive=False) def callback(path, inodes, flags, ids): pass _fsevents.add_watch(h, w, callback, [w.path]) with pytest.raises(RuntimeError): _fsevents.add_watch(h, w, callback, [w.path]) _fsevents.remove_watch(w) rmdir(a)
def emitter(event_queue): watch = ObservedWatch(temp_dir, True) em = WindowsApiEmitter(event_queue, watch, timeout=0.2) yield em em.stop()
def test_event_emitter(): event_queue = EventQueue() watch = ObservedWatch('/foobar', True) event_emitter = EventEmitter(event_queue, watch, timeout=1) event_emitter.queue_event(FileModifiedEvent('/foobar/blah'))
def test_observer__repr__(): observed_watch = ObservedWatch('/foobar', True) repr_str = '<ObservedWatch: path=/foobar, is_recursive=True>' assert observed_watch.__repr__() == repr(observed_watch) assert repr(observed_watch) == repr_str
def test___repr__(self): observed_watch = ObservedWatch('/foobar', True) assert_equal('<ObservedWatch: path=/foobar, is_recursive=True>', observed_watch.__repr__())
def emitter(event_queue): watch = ObservedWatch(temp_dir, True) yield Emitter(event_queue, watch, timeout=0.2)
def test___init__(self): event_queue = EventQueue() watch = ObservedWatch("/foobar", True) event_emitter = EventEmitter(event_queue, watch, timeout=1) event_emitter.queue_event(FileModifiedEvent("/foobar/blah"))
def test___repr__(self): observed_watch = ObservedWatch("/foobar", True) self.assertEqual( "<ObservedWatch: path=" + "/foobar" + ", is_recursive=True>", observed_watch.__repr__(), )
def test___repr__(self): observed_watch = ObservedWatch('/foobar', True) self.assertEqual( '<ObservedWatch: path=' + '/foobar' + ', is_recursive=True>', observed_watch.__repr__())
def setUp(self): self.event_queue = queue.Queue() self.watch = ObservedWatch(temp_dir, True) self.emitter = Emitter(self.event_queue, self.watch, timeout=0.2)
def test___repr__(self): observed_watch = ObservedWatch('/foobar', True) self.assertEqual('<ObservedWatch: path=' + absolute_path('/foobar') + ', is_recursive=True>', observed_watch.__repr__())
def setUp(self): super(TestEventEmitter, self).setUp() self.queue = [] watch = ObservedWatch(path=tempfile.tempdir, recursive=False) self.sut = DummyEventEmitter(self.queue, watch, timeout=0)