Python Observer.join方法代码示例

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
def run():
    observer = Observer()
    observer.start()

    # start foreman
    forerunner = Forerunner()
    forerunner.start()

    # call callback when files under the cwd change
    stream = Stream(forerunner.callback, './', file_events=True)
    observer.schedule(stream)

    while True:
        try:
            sleep(1)
        except KeyboardInterrupt:
            observer.unschedule(stream)
            observer.stop()
            observer.join()

            foreman = forerunner.foreman

            for i in range(1, 10):
                if foreman.poll() is not None:
                    break

                print "sleeping... %i" % i
                sleep(1)

            if foreman.poll() is None:
                foreman.kill()

            sleep(1)
            break

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def _assert_action_after_watcher(self, process_asap, assertions_cb):
        events = []
        def callback(event):
            events.append(event)

        import os
        import time
        from fsevents import Stream
        from fsevents import Observer

        observer = Observer(process_asap=process_asap)
        observer.start()

        stream = Stream(callback, self.tempdir, file_events=True)
        observer.schedule(stream)
        # add single file
        del events[:]
        f = open(os.path.join(self.tempdir, "test"), "w")
        f.write("abc")
        f.flush()
        f.close()
        time.sleep(0.2)

        # stop and join observer
        observer.stop()
        observer.unschedule(stream)
        observer.join()

        os.unlink(f.name)
        assertions_cb(events, f)

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_single_file_added_with_observer_unscheduled(self):
        events = []
        def callback(*args):
            events.append(args)

        f, path = self._make_temporary()
        from fsevents import Stream
        stream = Stream(callback, path)

        from fsevents import Observer
        observer = Observer()
        observer.start()
        import time
        while not observer.isAlive():
            time.sleep(0.1)

        observer.schedule(stream)
        observer.unschedule(stream)

        # add single file
        del events[:]
        f.close()
        time.sleep(0.1)

        # stop and join observer
        observer.stop()
        observer.join()

        self.assertEqual(events, [])

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_single_file_added(self):
        events = []
        def callback(*args):
            events.append(args)

        f, path = self._make_temporary()

        from fsevents import Observer
        observer = Observer(callback, file_events=True)
        observer.start()
        observer.schedule(path)
 
        # add single file
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        del events[:]
        f.close()
        time.sleep(1.1)

        # stop and join observer
        observer.stop()
        observer.join()

        self.assertEquals(events[0][0], path)

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_single_file_added_multiple_streams(self):
        events = []
        def callback(*args):
            events.append(args)

        f, path = self._make_temporary()
        from fsevents import Stream
        stream1 = Stream(callback, path)
        stream2 = Stream(callback, path)

        from fsevents import Observer
        observer = Observer()
        observer.schedule(stream1)
        observer.schedule(stream2)
        observer.start()

        # add single file
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        time.sleep(0.1)
        del events[:]
        f.close()
        time.sleep(0.2)

        # stop and join observer
        observer.stop()
        observer.unschedule(stream1)
        observer.unschedule(stream2)
        observer.join()
        self.assertEquals(events[0][0], path)
        self.assertEquals(events[1][0], path)

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_start_then_watch(self):
        events = []
        def callback(*args):
            events.append(args)

        f, path = self._make_temporary()
        from fsevents import Stream
        stream = Stream(callback, path)

        from fsevents import Observer
        observer = Observer()
        observer.schedule(stream)
        observer.start()

        # add single file
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        del events[:]
        f.close()
        time.sleep(0.2)

        # stop and join observer
        observer.stop()
        observer.unschedule(stream)
        observer.join()

        self.assertEqual(events, [(path, self.create_and_remove_mask)])

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_existing_directories_are_not_reported(self):
        import os
        from fsevents import Stream, Observer

        events = []
        def callback(event):
            events.append(event)
        
        stream = Stream(callback, self.tempdir, file_events=True)
        new1 = os.path.join(self.tempdir, "newdir1")
        new2 = os.path.join(self.tempdir, "newdir2")
        os.mkdir(new1)
        observer = Observer()
        observer.schedule(stream)
        observer.start()

        import time
        while not observer.isAlive():
            time.sleep(0.1)
        del events[:]
        time.sleep(1)
        os.mkdir(new2)
        try:
            time.sleep(1.1)
            observer.stop()
            observer.unschedule(stream)
            observer.join()

            from fsevents import IN_CREATE
            self.assertEqual(len(events), 1)
            self.assertEqual(events[0].mask, IN_CREATE)
            self.assertEqual(events[0].name, os.path.realpath(new2))
        finally:
            os.rmdir(new1)
            os.rmdir(new2)

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_since_stream(self):
        events = []
        def callback(*args):
            events.append(args)
        
        # two files in same directory
        import os
        path1 = os.path.realpath(self._make_tempdir()) + '/'
        f = self._make_temporary(path1)[0]
        g = self._make_temporary(path1)[0]

        from fsevents import Stream, FS_FLAGHISTORYDONE
        
        stream = Stream(callback, path1, ids = True)
        
        from fsevents import Observer
        observer = Observer()
        observer.schedule(stream)
        observer.start()
        
        #create one file
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        del events[:]
        f.close()
        time.sleep(0.2)
        
        # stop and join observer
        observer.stop()
        observer.unschedule(stream)
        observer.join()
        self.assertEqual(len(events),1)
        self.assertEqual(events[0][:-1], (path1, self.create_and_remove_mask))

        #create a second file
        g.close()
           
        stream = Stream(callback, path1, since = events[0][2])
        del events[:]
        # new observer
        observer = Observer()
        observer.schedule(stream)
        observer.start()
        time.sleep(0.2)

        # stop and join observer
        observer.stop()
        observer.unschedule(stream)
        observer.join()

        self.assertEqual(len(events),2)
        #FIXME: why do events arrive here in reversed order?            
        self.assertEqual(events[1], (path1, self.create_and_remove_mask))
        self.assertEqual(events[0], (path1[:-1], FS_FLAGHISTORYDONE))

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_file_moved_to_not_watched_path(self):
        import os
        events = []
        def callback(event):
            events.append(event)

        from fsevents import Stream
        not_watched_path = os.path.realpath(self._make_tempdir()) + '/'
        stream = Stream(callback, self.tempdir, file_events=True)

        from fsevents import Observer
        observer = Observer()
        observer.schedule(stream)
        observer.start()

        # add single file
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        del events[:]
        time.sleep(2.1)

        src_name = os.path.join(self.tempdir, "test")
        dst_name = os.path.join(not_watched_path, "test")
        f = open(src_name, "w")
        f.write("abc")
        f.close()

        time.sleep(1.0)

        os.rename(src_name, dst_name)

        time.sleep(0.1)

        # stop and join observer
        observer.stop()
        observer.unschedule(stream)
        observer.join()

        os.unlink(dst_name)
        os.rmdir(not_watched_path)
        from fsevents import IN_CREATE, IN_MODIFY, IN_DELETE

        self.assertEquals(len(events), 3)
        # assert the creation events
        self.assertEquals(events[0].mask, IN_CREATE)
        self.assertEquals(events[0].name, os.path.realpath(src_name))
        self.assertEquals(events[1].mask, IN_MODIFY)
        self.assertEquals(events[1].name, os.path.realpath(src_name))
        self.assertEquals(events[2].mask, IN_DELETE)
        self.assertEquals(events[2].name, os.path.realpath(src_name))

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_single_file_created_and_modified(self):
        events = []
        def callback(event):
            events.append(event)

        from fsevents import Stream
        stream = Stream(callback, self.tempdir, file_events=True)

        from fsevents import Observer
        observer = Observer()
        observer.schedule(stream)
        observer.start()

        # add single file
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        del events[:]
        time.sleep(2.1)

        import os
        f = open(os.path.join(self.tempdir, "test"), "w")
        f.write("abc")
        f.flush()

        time.sleep(1.0)

        f.write("def")
        f.flush()
        f.close()
        time.sleep(0.1)

        # stop and join observer
        observer.stop()
        observer.unschedule(stream)
        observer.join()

        os.unlink(f.name)
        from fsevents import IN_CREATE, IN_MODIFY
        self.assertEquals(len(events), 3)
        # assert events related to the creations
        self.assertEquals(events[0].mask, IN_CREATE)
        self.assertEquals(events[0].name, os.path.realpath(f.name))
        self.assertEquals(events[1].mask, IN_MODIFY)
        self.assertEquals(events[1].name, os.path.realpath(f.name))
        # assert events related to the modify
        self.assertEquals(events[2].mask, IN_MODIFY)
        self.assertEquals(events[2].name, os.path.realpath(f.name))

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_multiple_files_added(self):
        events = []
        def callback(*args):
            events.append(args)

        from fsevents import Observer
        observer = Observer(callback, file_events=True)
        observer.start()

        # wait until activation
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        time.sleep(0.1)

        # two files in same directory
        import os
        path1 = os.path.realpath(self._make_tempdir()) + '/'
        f = self._make_temporary(path1)[0]
        g = self._make_temporary(path1)[0]

        # one file in a separate directory
        path2 = os.path.realpath(self._make_tempdir()) + '/'
        h = self._make_temporary(path2)[0]

        observer.schedule(path1)
        observer.schedule(path2)

        try:
            del events[:]
            f.close()
            g.close()
            h.close()
            time.sleep(0.2)
            events = [e[0] for e in events]
            self.assertEqual(sorted(events), sorted([path1, path2]))
        finally:
            f.close()
            g.close()
            h.close()
            os.rmdir(path1)
            os.rmdir(path2)

            # stop and join observer
            observer.stop()
            observer.unschedule(path1)
            observer.unschedule(path2)
            observer.join()

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_single_file_moved(self):
        events = []
        def callback(event):
            events.append(event)

        import os
        f = open(os.path.join(self.tempdir, "test"), "w")
        f.write("abc")
        f.flush()
        f.close()
        from fsevents import Stream
        stream = Stream(callback, self.tempdir, file_events=True)

        from fsevents import Observer
        observer = Observer()
        observer.schedule(stream)
        observer.start()

        # add single file
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        del events[:]
        time.sleep(2.1)
        new = "%s.new" % f.name
        os.rename(f.name, new)
        time.sleep(0.1)

        # stop and join observer
        observer.stop()
        observer.unschedule(stream)
        observer.join()

        os.unlink(new)
        from fsevents import IN_MOVED_FROM
        from fsevents import IN_MOVED_TO
        self.assertEqual(len(events), 2)
        self.assertEqual(events[0].mask, IN_MOVED_FROM)
        self.assertEqual(events[0].name, os.path.realpath(f.name))
        self.assertEqual(events[1].mask, IN_MOVED_TO)
        self.assertEqual(events[1].name, os.path.realpath(new))
        self.assertEqual(events[0].cookie, events[1].cookie)

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_single_directory_deleted(self):
        events = []
        def callback(event):
            events.append(event)

        import os
        new1 = os.path.join(self.tempdir, "newdir1")
        new2 = os.path.join(self.tempdir, "newdir2")
        try:
            os.mkdir(new1)
            os.mkdir(new2)
            import time
            time.sleep(0.2)
            from fsevents import Stream
            stream = Stream(callback, self.tempdir, file_events=True)

            from fsevents import Observer
            observer = Observer()
            observer.schedule(stream)
            observer.start()

            # add single file
            import time
            while not observer.isAlive():
                time.sleep(0.1)
            del events[:]
            time.sleep(0.1)
            os.rmdir(new2)
            time.sleep(1.0)

            # stop and join observer
            observer.stop()
            observer.unschedule(stream)
            observer.join()

            from fsevents import IN_DELETE
            self.assertEqual(len(events), 1)
            self.assertEqual(events[0].mask, IN_DELETE)
            self.assertEqual(events[0].name, os.path.realpath(new2))
        finally:
            os.rmdir(new1)

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_single_file_added_to_subdirectory(self):
        events = []
        def callback(*args):
            events.append(args)

        import os
        directory = self._make_tempdir()
        subdirectory = os.path.realpath(os.path.join(directory, 'subdir')) + '/'
        os.mkdir(subdirectory)
        import time
        time.sleep(0.1)

        try:
            from fsevents import Stream
            stream = Stream(callback, directory)

            from fsevents import Observer
            observer = Observer()
            observer.schedule(stream)
            observer.start()

            # add single file
            while not observer.isAlive():
                time.sleep(0.1)
            del events[:]
            f = open(os.path.join(subdirectory, "test"), "w")
            f.write("abc")
            f.close()
            time.sleep(0.2)

            # stop and join observer
            observer.stop()
            observer.unschedule(stream)
            observer.join()

            self.assertEqual(len(events), 1)
            self.assertEqual(events, [(subdirectory, self.modified_mask)])
        finally:
            os.unlink(f.name)
            os.rmdir(subdirectory)
            os.rmdir(directory)

# 需要导入模块: from fsevents import Observer [as 别名]
# 或者: from fsevents.Observer import join [as 别名]
    def test_fileevent_stream(self):
        events = []
        def callback(*args):
            events.append(args)
        
        # two files in same directory
        import os
        path1 = os.path.realpath(self._make_tempdir()) + '/'
        f = self._make_temporary(path1)[0]
        g = self._make_temporary(path1)[0]

        from fsevents import Stream, FS_CFLAGFILEEVENTS, FS_ITEMISDIR
        
        stream = Stream(callback, path1, flags=FS_CFLAGFILEEVENTS)
        
        from fsevents import Observer
        observer = Observer()
        observer.schedule(stream)
        observer.start()
        
        #create two files (here in the same directory)
        import time
        while not observer.isAlive():
            time.sleep(0.1)
        del events[:]
        f.close()
        g.close()
        time.sleep(0.2)
        
        # stop and join observer
        observer.stop()
        observer.unschedule(stream)
        observer.join()

        import os
        self.assertEqual(len(events),3)
        self.assertEqual(events, [(path1[:-1], self.create_and_remove_mask|FS_ITEMISDIR),
                                  (f.name, self.create_and_remove_mask),
                                  (g.name, self.create_and_remove_mask)])