Python Observer.isAlive方法代码示例

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import isAlive [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 isAlive [as 别名]
class relay_main():
    '''
    The relay main thread class for the file event handling.
    NOTE :: THIS THREAD SHOULDNT HOLD ANY LOCK OR ENTER INTO CRITICAL SECTION
    BY BLOCKING OTHER THREADS. ITS POSSIBLE THIS THREAD GET KILLED BY MAIN
    THREAD ANYTIME. HOLDING A CRITICAL SECTION RESOURCE IN THIS MODULE LEADS
    A DEAD LOCK.
    '''
    def __init__(self):
        self.nv_log_handler = nv_logger(self.__class__.__name__).get_logger()
        self.os_context = nv_os_lib()
        self.watcher_obj = relay_watcher()
        self.observer_obj = Observer()

    def process_relay(self):
        try:
            if not self.os_context.is_path_exists(NV_MID_BOX_CAM_STREAM_DIR):
                self.nv_log_handler.error("%s Directory not found",
                                          NV_MID_BOX_CAM_STREAM_DIR)
                raise FileNotFoundError
            self.observer_obj.schedule(self.watcher_obj, NV_MID_BOX_CAM_STREAM_DIR,
                                       recursive=True)
            self.observer_obj.start()
        except FileNotFoundError:
            raise
        except Exception as e:
            raise e

    def relay_stop(self):
        self.watcher_obj.kill_relay_thread()
        self.observer_obj.stop()

    def relay_join(self):
        if self.observer_obj.isAlive():
            self.observer_obj.join()

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import isAlive [as 别名]
def main():

    #logging.debug( "initialing...")
    logging.basicConfig(level=logging.DEBUG,
                        format='%(asctime)s - %(message)s',
                        datefmt='%Y-%m-%d %H:%M:%S',
                        filename='./log/console.log')
    logging.debug( "start process")
    event_handler = CompleteEventHandler()
    logging.info( "Watching Folder : " + event_handler.WATCH_FOLDER)
    observer = Observer()
    observer.schedule(event_handler, path=os.path.abspath(event_handler.WATCH_FOLDER), recursive=True)
    observer.start()
    

    # 데몬 쓰레드
    t1 = threading.Thread(target=getCache,
                        args=(event_handler.HTTP + event_handler.GEOSERVER_URL + '/geoserver/gwc/rest/seed/' + event_handler.GEOSERVER_STORE_NAME + ':' + event_handler.GEOSERVER_LAYER_NAME + '.json',
                            event_handler.GEOSERVER_USER,
                            event_handler.GEOSERVER_PASSWORD,
						    event_handler.GEOWEBCACHE_BOX_LEVEL))
    t1.daemon = True 
    t1.start()

        #t1.stop()
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()

    if observer.isAlive() :
        observer.stop()
    observer.join()

# 需要导入模块: from watchdog.observers import Observer [as 别名]
# 或者: from watchdog.observers.Observer import isAlive [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 isAlive [as 别名]
def watch(ctx):
    """Watch the directory for changes. Automatically run tests.
    """
    vcs = ctx.obj['vcs']

    event_handler = TestsEventHandler(vcs)

    observer = Observer()
    observer.schedule(event_handler, vcs.path, recursive=True)
    observer.start()
    click.echo('Watching directory `{path}`. Use ctrl-c to stop.'.format(path=vcs.path))
    while observer.isAlive():
        observer.join(timeout=1)