Python Observer.unschedule_all方法代码示例

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class PropMTimeWatcher:
    def __init__(self, app_data_folder):
        self._app_data_folder = app_data_folder
        self._observer = Observer()
        self.schedule()

    def schedule(self):
        pref = PropMTimePreferences(self._app_data_folder)
        self._observer.unschedule_all()
        for path, watcher in pref.get_all_paths().items():
            if watcher:
                if os.path.exists(path):
                    event_handler = ModHandler(path, self._app_data_folder)
                    log.info('scheduling watcher : %s' % path)
                    self._observer.schedule(event_handler, path=path, recursive=True)
                else:
                    log.error('Error: "%s" does not exist.\n\nPlease edit the path.\n\nTo do this, click on the %s icon and select "Paths".' %
                              (path, __application_name__))
        self._observer.start()

    def request_exit(self):
        self._observer.unschedule_all()
        self._observer.stop()
        self._observer.join(TIMEOUT)
        if self._observer.isAlive():
            log.error('observer still alive')

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class ObservePaths(object):
    def __new__(cls):
        if Observer is None:
            return None
        return object.__new__(cls)

    def __init__(self):
        self.observer = Observer()
        self.event_handler = ReportEvent()
        self.paths = {}
        self.observer.start()
        package_events.listen(u'FileBrowser', self.dired_event_handler)

    def dired_event_handler(self, package, event, payload):
        '''receiving args from common.emit_event'''
        def view_closed(view): self.paths.pop(view, None)

        def start_refresh(view, path):
            self.paths.update({view: [path.rstrip(os.sep)] if path else []})

        def finish_refresh(view, paths):
            if not paths:
                return

            old_paths = sorted(self.paths.get(view, []))
            paths = sorted(paths)
            if paths == old_paths:
                return

            self.paths.update({view: sorted(p for p in
                              set(old_paths + [p.rstrip(os.sep) for p in paths])
                              if os.path.exists(p))})
            self.observer.unschedule_all()
            for p in reduce(lambda i, j: i + j, self.paths.values()):
                self.observer.schedule(self.event_handler, p)

        def fold(view, path):
            p = set(self.paths.get(view, [])) - set([path.rstrip(os.sep)])
            finish_refresh(view, list(p))

        def toggle_watch_all(watch):
            '''watch is boolean or None, global setting dired_autorefresh'''
            views = self.paths.keys()
            if not watch:
                self.paths = {}
            sublime.set_timeout(lambda: refresh(views, erase_settings=(not watch)), 1)

        case = {
            'start_refresh': lambda: start_refresh(*payload),
            'finish_refresh': lambda: finish_refresh(*payload),
            'view_closed': lambda: view_closed(payload),
            'fold': lambda: fold(*payload),
            'stop_watch': lambda: view_closed(payload),
            'toggle_watch_all': lambda: toggle_watch_all(payload)
        }
        case[event]()
        emit_event(u'', self.paths, plugin=u'FileBrowserWFS')

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
def main():
    args = docopt(__doc__)
    path = args.get('<dir>') or '.'

    observer = Observer()
    event_handler = EventHandler()

    observer.schedule(event_handler, path, recursive=True)
    observer.start()
    observer.join()
    observer.unschedule_all()
    observer.stop()

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
    class ModuleChangedEventHandler(FileSystemEventHandler):
        def __init__(self, paths, on_change):
            self.dirs = defaultdict(set)
            self.on_change = on_change
            self.modules_to_add_later = []
            self.observer = Observer()
            self.old_dirs = defaultdict(set)
            self.started = False
            for path in paths:
                self.add_module(path)

        def reset(self):
            self.dirs = defaultdict(set)
            del self.modules_to_add_later[:]
            self.old_dirs = defaultdict(set)
            self.observer.unschedule_all()

        def add_module(self, path):
            """Add a python module to track changes to"""
            path = os.path.abspath(path)
            for suff in importcompletion.SUFFIXES:
                if path.endswith(suff):
                    path = path[:-len(suff)]
                    break
            dirname = os.path.dirname(path)
            if dirname not in self.dirs:
                self.observer.schedule(self, dirname, recursive=False)
                self.dirs[os.path.dirname(path)].add(path)

        def add_module_later(self, path):
            self.modules_to_add_later.append(path)

        def activate(self):
            if not self.started:
                self.started = True
                self.observer.start()
            self.dirs = self.old_dirs
            for dirname in self.dirs:
                self.observer.schedule(self, dirname, recursive=False)
            for module in self.modules_to_add_later:
                self.add_module(module)
            del self.modules_to_add_later[:]

        def deactivate(self):
            self.observer.unschedule_all()
            self.old_dirs = self.dirs
            self.dirs = defaultdict(set)

        def on_any_event(self, event):
            dirpath = os.path.dirname(event.src_path)
            paths = [path + '.py' for path in self.dirs[dirpath]]
            if event.src_path in paths:
                self.on_change(event.src_path)

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class ProjectWatcher(object):
    '''ProjectWatcher is responsible for watching any changes in
       project directory. It will call self._callback whenever there
       are any changes. It can currently handle only one directory at
       a time.
    '''
    def __init__(self, callback):
        super(ProjectWatcher, self).__init__()
        self.proj_event = None
        self._observer = None
        self._event_handler = None
        self._callback = callback
        self.allow_event_dispatch = True

    def start_watching(self, project_dir):
        '''To start watching project_dir.
        '''
        self._project_dir = project_dir
        self._observer = Observer()
        self._event_handler = ProjectEventHandler(self._observer, self)
        self._watch = self._observer.schedule(self._event_handler,
                                              self._project_dir,
                                              recursive=True)
        self._observer.start()

    def on_project_modified(self, *args):
        pass

    def dispatch_proj_event(self, event):
        '''To dispatch event to self._callback.
        '''
        self.proj_event = event
        # Do not dispatch event if '.designer' is modified
        if '.designer' not in event.src_path and self.allow_event_dispatch:
            self._callback(event)

    def stop(self):
        '''To stop watching currently watched directory. This will also call
           join() on the thread created by Observer.
        '''

        if self._observer:
            self._observer.unschedule_all()
            self._observer.stop()
            self.join()

        self._observer = None

    def join(self):
        '''join observer after unschedulling it
        '''
        self._observer.join()

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class FSEventHandler(FileSystemEventHandler):
    def __init__(self, folder, filename):
        self.folder = folder
        self.filename = filename
        self.observer = Observer()

    def on_created(self, event):
        if not event.is_directory and event.src_path.endswith(self.filename):
            self.observer.unschedule_all()
            self.observer.stop()

    def watch(self):
        self.observer.schedule(self, self.folder, recursive=False)
        self.observer.start()
        self.observer.join()

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
def watch_apis():
    observer_api = Observer()
    observer_api.stop()
    observer_api.unschedule_all()
    api_event_handler = API_Handler()
    #get api from list
    apis = open( "../list/list.txt", "r")
    #Loop through list
    for api in apis:
        #trim
        if not str(api).startswith('#'):
            observer_api.schedule(api_event_handler, "../apis/"+api.rstrip(), recursive=False)
            watchdog_log("Starting watchdog on  apis: '" + api.rstrip()+"'.")
    apis.close()
    observer_api.start()    

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class ObserverWrapper():

	def __init__(self, key, monitoring_directory, storage_directory, share_ID, user_name, machine_ID, command_port, json_response_dict, min_update_interval, command_dict):
		self.key = key
		self.monitoring_directory = monitoring_directory
		self.storage_directory = storage_directory
		self.share_ID = share_ID
		self.user_name = user_name
		self.machine_ID = machine_ID
		self.command_port = command_port
		self.json_response_dict = json_response_dict
		self.min_update_interval = min_update_interval
		self.command_dict = command_dict
		
		
		
	def run(self):
		self.a_s = AutoSync(self.key, self.monitoring_directory, self.storage_directory, self.share_ID, self.user_name, self.machine_ID, self.command_port, self.json_response_dict, self.min_update_interval)	
		self.observer = Observer()  #The observer objects can't cross process boundaries because they are unpicklable
		self.observer.schedule(self.a_s, self.monitoring_directory, recursive=True)
		self.observer.start()
		while True:
			if self.monitoring_directory not in self.command_dict:
				time.sleep(0.1)
				continue
			command = self.command_dict[self.monitoring_directory]
			if command == 'stop' and self.observer.isAlive():
				logging.debug('stopping observer')
				self.observer.stop()
			elif command == 'start' and not self.observer.isAlive():
				logging.debug('starting observer')
				self.observer.start()
			elif command == 'terminate':
				logging.debug('terminating observer')
				if self.observer.isAlive():
					self.observer.stop()
				self.observer.unschedule_all()
				return

	
	def start(self):
		proc = Process(target=self.run)
		proc.start()
		logging.info('observer started')

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class Rainmaker():
   
    def __init__(self):
        self.event_handlers = {}
        self.observer = Observer()
        self.observer.start()

    def add_watch(self,watch_path,rec_flag=True):
        event_handler = RainmakerEventHandler( watch_path )
        self.event_handlers[watch_path] = event_handler
        self.observer.schedule( event_handler, watch_path, recursive = rec_flag) 
    
    def remove_watch(self, k): 
        eh = self.event_handlers.pop(k)
        self.observer.unschedule(eh)

    def shutdown(self):
        self.log.info( "Shutting down FSwatcher")
        self.observer.stop()
        self.observer.unschedule_all()
        self.observer.join()

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class FolderWatcherThread(BaseThread):
    observer = None

    class Handler(FileSystemEventHandler):
        def on_any_event(self, event):
            event_processor_thread.queue.put([event])

    def setup(self):
        super().setup()
        self.observer = Observer()
        self.observer.start()
        self.set_folders()

    def _run(self):
        while True:
            self.queue.get()
            self.set_folders()

    def set_folders(self):
        self.observer.unschedule_all()
        for folder in Config.folders:
            self.observer.schedule(self.Handler(), folder, recursive=True)

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
def start(actual_directories):
    
    observer = Observer()

        
    p = PTmp()
    
    for actual_directory in actual_directories:
        print "DIRECTORY", actual_directory
        observer.schedule(p, path=actual_directory, recursive=True)
    observer.start()
    try:
        print "Waiting for stuff to happen..."
        while True:
            sleep(1)
    except KeyboardInterrupt:
        pass
    finally:
        observer.unschedule_all()
        observer.stop()
        observer.join()
    
    return 0

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
    class ModuleChangedEventHandler(FileSystemEventHandler):
        def __init__(self, paths, on_change):
            self.dirs = defaultdict(set)
            self.on_change = on_change
            self.modules_to_add_later = []
            self.observer = Observer()
            self.old_dirs = defaultdict(set)
            self.started = False
            self.activated = False
            for path in paths:
                self._add_module(path)

        def reset(self):
            self.dirs = defaultdict(set)
            del self.modules_to_add_later[:]
            self.old_dirs = defaultdict(set)
            self.observer.unschedule_all()

        def _add_module(self, path):
            """Add a python module to track changes"""
            path = os.path.abspath(path)
            for suff in importcompletion.SUFFIXES:
                if path.endswith(suff):
                    path = path[:-len(suff)]
                    break
            dirname = os.path.dirname(path)
            if dirname not in self.dirs:
                self.observer.schedule(self, dirname, recursive=False)
            self.dirs[dirname].add(path)

        def _add_module_later(self, path):
            self.modules_to_add_later.append(path)

        def track_module(self, path):
            """
            Begins tracking this if activated, or remembers to track later.
            """
            if self.activated:
                self._add_module(path)
            else:
                self._add_module_later(path)

        def activate(self):
            if self.activated:
                raise ValueError("%r is already activated." % (self,))
            if not self.started:
                self.started = True
                self.observer.start()
            for dirname in self.dirs:
                self.observer.schedule(self, dirname, recursive=False)
            for module in self.modules_to_add_later:
                self._add_module(module)
            del self.modules_to_add_later[:]
            self.activated = True

        def deactivate(self):
            if not self.activated:
                raise ValueError("%r is not activated." % (self,))
            self.observer.unschedule_all()
            self.activated = False

        def on_any_event(self, event):
            dirpath = os.path.dirname(event.src_path)
            paths = [path + '.py' for path in self.dirs[dirpath]]
            if event.src_path in paths:
                self.on_change(files_modified=[event.src_path])

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class ChangesWatcher(FileSystemEventHandler):
    def __init__(self, application):
        self.application = application
        self.observer = Observer()
        self.changes = []
        self.mute_list = []
        self.path = None
        self.changes_timer = None
        self.observer.start()

    def observe(self, path, mute_list=None):
        self.path = path
        self.mute_list = (mute_list or []) + DEFAULT_MUTE_LIST
        self.observer.unschedule_all()
        self.observer.schedule(self, self.path, recursive=True)

    def get_changes_since(self, timestamp):
        ret = []
        for change in self.changes:
            if change.timestamp > timestamp:
                ret.append(change)
        return ret

    def add_pure_change(self, change):
        """ 监测change的类型，并添加非垃圾change和不在黑名单中的change
        """

        # 如果是黑名单及黑名单子目录的change，则跳过
        for black_path in self.mute_list:
            if path_is_parent(black_path, change.path):
                print '...', change.type, change.path
                return

        # 寻找当前change对应的垃圾change，找到后删除；未找到则添加当前change
        trash_changes = self.find_related_trash_changes(change)
        if trash_changes:
            for change in trash_changes:
                self.changes.remove(change)
                print '-  ', change.type, change.path
        else:
            self.changes.append(change)
            print '+  ', change.type, change.path
            self.compile_if_necessary(change)

        ioloop.IOLoop.instance().add_callback(lambda: self.remove_outdated_changes(30))

    def compile_if_necessary(self, change):
        if change.type == EVENT_TYPE_DELETED:
            return

        abs_path = normalize_path(os.path.join(self.path, change.path))
        base_path, ext = os.path.splitext(abs_path)
        ext = ext.lower()

        if ext not in['.less', '.coffee']:
            return

        if not self.application.active_project:
            return

        active_project = self.application.active_project
        begin_time = time.time()
        os.chdir(APP_FOLDER)
        if ext == '.less':
            if active_project.compileLess:
                output_path = base_path + '.css'
                cmd = 'bundled/node.exe bundled/less/bin/lessc %s %s' % (abs_path, output_path)
                os.system(cmd.replace('/', '\\'))
                print 'compile:', change.path, time.time() - begin_time, 'seconds'
            else:
                print 'skip compile', change.path, '(setting is off)'
        elif ext == '.coffee':
            if active_project.compileCoffee:
                output_path = base_path + '.js'
                cmd = 'bundled/node.exe bundled/coffee/bin/coffee --compile %s' % (abs_path, )
                os.system(cmd.replace('/', '\\'))
                print 'compile:', change.path, time.time() - begin_time, 'seconds'
            else:
                print 'skip compile', change.path, '(setting is off)'

    def if_folder_changed(self, folder_path):
        print folder_path
        import sys
        from watchdog.events import FileModifiedEvent
        if sys.platform.startswith('win'):
            return
        now = time.time() - 2.5 # 2.5秒内的都算修改
        if not os.path.isdir(folder_path):
            return # ignore
        for filename in os.listdir(folder_path):
            file_path = os.path.join(folder_path, filename)
            if not os.path.isfile(file_path):
                continue
            modified_time = os.path.getmtime(file_path)
            if modified_time > now:
                self.on_any_event(FileModifiedEvent(file_path))

    def on_any_event(self, event):
        if event.is_directory:
            self.if_folder_changed(event.src_path)
#.........这里部分代码省略.........

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]

#.........这里部分代码省略.........
    def configuration_changed(self):
        # check if collection dirs have
        # been changed since we last started
        # if yes, we will do a full rescan
        # otherwise, an incremental scan.

        config = GlobalConfig()
        paths_saved_at = 0
        last_scan = 0
        self.last_shutdown_time = 0
        try:
            paths_saved_at = int(config['collection']['paths_saved_at'])
        except KeyError:
#TODO(nikhil) test this behaviour
            pass

        try:
            last_scan = int(config['collection']['last_scan'])
        except KeyError:
            last_scan = paths_saved_at - 1

        try:
            self.last_shutdown_time = int(config['last_shutdown_time'])
        except KeyError:
            pass

        collection_directories = set()
        try:
            collection_directories = set(config['collection']['paths'])
        except KeyError:
            pass

        full_scan = False
        if last_scan < paths_saved_at:
            full_scan = True

        if full_scan:
            try:
                # for a full scan, first wipe all tables
                Artist.deleteMany(None)
                Album.deleteMany(None)
                Genre.deleteMany(None)
                Composer.deleteMany(None)
                Track.deleteMany(None)
                TrackStatistics.deleteMany(None)
                AlbumStatistics.deleteMany(None)
                ArtistStatistics.deleteMany(None)
                GenreStatistics.deleteMany(None)
            except OperationalError:
                pass

        # first remove watches on
        # any directories that have been
        # removed from the collection directories
        existing_directories = set(self.watches.keys())
        for dir in existing_directories.difference(collection_directories):
            self.remove_directory(dir)

        for dir in collection_directories:
            if dir in self.watches:
                # directory is already being watched
                # do nothing
                pass
            else:
                self.add_directory(dir, full_scan)


    def start(self):
        self.configuration_changed()
        # Note: a 'first' scan is an
        # incremental scan behaving like a full
        # scan, so we don't have to explicitly
        # handle that case.
        # finally put a watch on the config file itself
        self.observer.schedule(ConfigWatcher(self), path=USERDIR)
        self.observer.start()

    def quit(self, signum, frame):
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        signal.signal(signal.SIGTERM, signal.SIG_DFL)
        # stop watching file before we make any changes
        self.observer.unschedule_all()
        self.observer.stop()
        # close all update threads
        # save current time
        config = GlobalConfig()
        try:
            config['collection']
        except KeyError:
            config['collection'] = {}
        now = int(time.time())
        config['collection']['last_scan'] = now
        config.save()

        self.scanner_pool.close()
        self.scanner_pool.terminate()

        self.observer.join()
        self.scanner_pool.join()
        sys.exit(0)

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import unschedule_all [as 别名]
class Dashboard(FileSystemEventHandler):

    _POLL = 1		# Fallback polling interval

    def __init__(self):
        FileSystemEventHandler.__init__(self)	# futureproofing - not need for current version of watchdog
        self.root = None
        self.currentdir = None		# The actual logdir that we're monitoring
        self.observer = None
        self.observed = None		# a watchdog ObservedWatch, or None if polling
        self.status = {}		# Current status for communicating status back to main thread

    def start(self, root, started):
        self.root = root
        self.session_start = started

        logdir = config.get('journaldir') or config.default_journal_dir
        if not logdir or not isdir(logdir):
            self.stop()
            return False

        if self.currentdir and self.currentdir != logdir:
            self.stop()
        self.currentdir = logdir

        # Set up a watchdog observer.
        # File system events are unreliable/non-existent over network drives on Linux.
        # We can't easily tell whether a path points to a network drive, so assume
        # any non-standard logdir might be on a network drive and poll instead.
        polling = platform != 'win32'
        if not polling and not self.observer:
            self.observer = Observer()
            self.observer.daemon = True
            self.observer.start()
        elif polling and self.observer:
            self.observer.stop()
            self.observer = None

        if not self.observed and not polling:
            self.observed = self.observer.schedule(self, self.currentdir)

        if __debug__:
            print '%s Dashboard "%s"' % (polling and 'Polling' or 'Monitoring', self.currentdir)

        # Even if we're not intending to poll, poll at least once to process pre-existing
        # data and to check whether the watchdog thread has crashed due to events not
        # being supported on this filesystem.
        self.root.after(self._POLL * 1000/2, self.poll, True)

        return True

    def stop(self):
        if __debug__:
            print 'Stopping monitoring Dashboard'
        self.currentdir = None
        if self.observed:
            self.observed = None
            self.observer.unschedule_all()
        self.status = {}

    def close(self):
        self.stop()
        if self.observer:
            self.observer.stop()
        if self.observer:
            self.observer.join()
            self.observer = None

    def poll(self, first_time=False):
        if not self.currentdir:
            # Stopped
            self.status = {}
        else:
            self.process()

            if first_time:
                # Watchdog thread
                emitter = self.observed and self.observer._emitter_for_watch[self.observed]	# Note: Uses undocumented attribute
                if emitter and emitter.is_alive():
                    return	# Watchdog thread still running - stop polling

            self.root.after(self._POLL * 1000, self.poll)	# keep polling

    def on_modified(self, event):
        # watchdog callback - DirModifiedEvent on macOS, FileModifiedEvent on Windows
        if event.is_directory or (isfile(event.src_path) and getsize(event.src_path)):	# Can get on_modified events when the file is emptied
            self.process(event.src_path if not event.is_directory else None)

    # Can be called either in watchdog thread or, if polling, in main thread.
    def process(self, logfile=None):
        try:
            with open(join(self.currentdir, 'Status.json'), 'rb') as h:
                data = h.read().strip()
                if data:	# Can be empty if polling while the file is being re-written
                    entry = json.loads(data)

                    # Status file is shared between beta and live. So filter out status not in this game session.
                    if (timegm(time.strptime(entry['timestamp'], '%Y-%m-%dT%H:%M:%SZ')) >= self.session_start and
                        self.status != entry):
                        self.status = entry
#.........这里部分代码省略.........