def _register_watcher(self): logger.debug("Register File Watcher for {0}".format(self.plugin_name)) self.event_handler = PluginEventHandler(self.plugin_name, self._reload_plugin) self.observer = Observer() self.observer.schedule(self.event_handler, self.plugin_dir) self.observer.start()
def start_watch(): event_handler = when_file_chanage(kill_progress) observer = Observer(timeout=1) observer.schedule(event_handler, path=os.getcwd(), recursive=True) observer.start() global p, job_name cmd = ["uwsgi", "--json", job_name] p = subprocess.Popen(cmd, stderr=subprocess.PIPE) return_code = p.poll() while return_code is None: if not observer.is_alive(): kill_progress() break return_code = p.poll() line = p.stderr.readline().strip().decode("utf-8") if len(line) != 0: print(line) sys.stderr.flush() time.sleep(0.01) while len(line) != 0: line = p.stderr.readline().strip().decode("utf-8") print(line) sys.stderr.flush() observer.stop() return return_code
def main(): if int(os.getuid()) != 0: raise SystemExit("ERROR: this script should be run as root") parser = ArgumentParser( description='Watch a directory and install the code') args = parser.parse_args() current_path = Path(__file__).resolve().parent setup_path = Path(current_path, '..').resolve() git_path = Path(current_path, '..', '..').resolve() observer = Observer() observer.schedule(FileHandler(setup_path, 'site'), str(Path(git_path, 'site')), True) observer.schedule(FileHandler(setup_path, 'bin'), str(Path(git_path, 'bin')), True) observer.schedule(FileHandler(setup_path, 'bin'), str(Path(git_path, 'sbin')), True) observer.start() try: print("Watching the following folders for change:") print(" - site") print(" - bin") print(" - sbin") print() input("~~Hit enter to exit~~\n") finally: observer.stop() observer.join()
def start(self): path = self.config.get('watchdog', 'path') patterns = self.config.get('watchdog', 'patterns').split(';') ignore_directories = self.config.getboolean('watchdog', 'ignore_directories') ignore_patterns = self.config.get('watchdog', 'ignore_patterns').split(';') case_sensitive = self.config.getboolean('watchdog', 'case_sensitive') recursive = self.config.getboolean('watchdog', 'recursive') event_handler = PatternMatchingEventHandler( patterns=patterns, ignore_patterns=ignore_patterns, ignore_directories=ignore_directories, case_sensitive=case_sensitive) event_handler.on_created = self.on_created # event_handler.on_modified = self.on_modified observer = Observer() observer.schedule(path=path, event_handler=event_handler, recursive=recursive) observer.start() self.logger.info('WatchDog Observer for HCS/AFS/AAS is startting.....') self.logger.info('patterns=%s' % patterns) self.logger.info('path=%s' % path) try: while observer.is_alive(): time.sleep(1) except (KeyboardInterrupt): observer.stop() self.logger.debug('WatchDog Observer is stoped.') observer.join()
def __init__(self, args, callback=None): self._watchdog_observer = None self._path = args.config self._callback = callback self._config = {} # Load from file try: self.load_config_file() except FileNotFoundError: logger.info("No configuration file, creating a new one") self._config = CONF_SCHEMA({}) # Overwrite with command line arguments args_keys = vars(args) for key in args_keys: if self._config.get(key) != args_keys[key]: self._config[key] = args_keys[key] self.save_config_file() self._watchdog_observer = Observer() watchdog_event_handler = FileSystemEventHandler() watchdog_event_handler.on_modified = lambda event: self.load_config_file( ) self._watchdog_observer.schedule(watchdog_event_handler, self._path) self._watchdog_observer.start()
def shell_command(args): """ Subcommand to execute shell commands in response to file system events. :param args: Command line argument options. """ from watchdog.tricks import ShellCommandTrick if not args.command: args.command = None if args.debug_force_polling: from watchdog.observers.polling import PollingObserver as Observer else: from watchdog.observers import Observer patterns, ignore_patterns = parse_patterns(args.patterns, args.ignore_patterns) handler = ShellCommandTrick(shell_command=args.command, patterns=patterns, ignore_patterns=ignore_patterns, ignore_directories=args.ignore_directories, wait_for_process=args.wait_for_process, drop_during_process=args.drop_during_process) observer = Observer(timeout=args.timeout) observe_with(observer, handler, args.directories, args.recursive)
def watch_record(indexer, use_polling=False): """ Start watching `cfstore.record_path`. :type indexer: rash.indexer.Indexer """ if use_polling: from watchdog.observers.polling import PollingObserver as Observer Observer # fool pyflakes else: from watchdog.observers import Observer event_handler = RecordHandler(indexer) observer = Observer() observer.schedule(event_handler, path=indexer.record_path, recursive=True) indexer.logger.debug('Start observer.') observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: indexer.logger.debug('Got KeyboardInterrupt. Stopping observer.') observer.stop() indexer.logger.debug('Joining observer.') observer.join() indexer.logger.debug('Finish watching record.')
def log(args): """ Command to log file system events to the console. """ from watchdog.utils import echo from watchdog.tricks import LoggerTrick if args.trace: echo.echo_class(LoggerTrick) patterns, ignore_patterns =\ parse_patterns(args.patterns, args.ignore_patterns) handler = LoggerTrick(patterns=patterns, ignore_patterns=ignore_patterns, ignore_directories=args.ignore_directories) if args.debug_force_polling: from watchdog.observers.polling import PollingObserver as Observer elif args.debug_force_kqueue: from watchdog.observers.kqueue import KqueueObserver as Observer elif args.debug_force_winapi: from watchdog.observers.read_directory_changes import\ WindowsApiObserver as Observer elif args.debug_force_inotify: from watchdog.observers.inotify import InotifyObserver as Observer elif args.debug_force_fsevents: from watchdog.observers.fsevents import FSEventsObserver as Observer else: # Automatically picks the most appropriate observer for the platform # on which it is running. from watchdog.observers import Observer observer = Observer(timeout=args.timeout) observe_with(observer, handler, args.directories, args.recursive)
def auto_restart(args): """ Subcommand to start a long-running subprocess and restart it on matched events. :param args: Command line argument options. """ if args.debug_force_polling: from watchdog.observers.polling import PollingObserver as Observer else: from watchdog.observers import Observer from watchdog.tricks import AutoRestartTrick import signal if not args.directories: args.directories = ['.'] # Allow either signal name or number. if args.signal.startswith("SIG"): stop_signal = getattr(signal, args.signal) else: stop_signal = int(args.signal) # Handle termination signals by raising a semantic exception which will # allow us to gracefully unwind and stop the observer termination_signals = {signal.SIGTERM, signal.SIGINT} def handler_termination_signal(_signum, _frame): # Neuter all signals so that we don't attempt a double shutdown for signum in termination_signals: signal.signal(signum, signal.SIG_IGN) raise WatchdogShutdown for signum in termination_signals: signal.signal(signum, handler_termination_signal) patterns, ignore_patterns = parse_patterns(args.patterns, args.ignore_patterns) command = [args.command] command.extend(args.command_args) handler = AutoRestartTrick(command=command, patterns=patterns, ignore_patterns=ignore_patterns, ignore_directories=args.ignore_directories, stop_signal=stop_signal, kill_after=args.kill_after) handler.start() observer = Observer(timeout=args.timeout) try: observe_with(observer, handler, args.directories, args.recursive) except WatchdogShutdown: pass finally: handler.stop()
def _start_watch_mode(self, args: ConvertModeArguments) -> None: """Starts and runs the watch mode until canceled Arguments: args {ConvertModeArguments} -- The arguments for convert mode """ # Use custom event handler event_handler = self._create_watch_handler( args['in_path'], args['out_path'], ) # Init the observer observer = Observer() observer.schedule(event_handler, args['in_path'], recursive=True) self._logger.debug(f"Starting watch mode for: {args['in_path']}") if self._visual: print( colored('Starting watcher for:', 'blue', attrs=['bold']), colored(f"{os.path.abspath(args['in_path'])}", 'blue'), ) else: self._logger.info(f"Starting watch mode for: {args['in_path']}") # Start observer.start() # Keep the process running while # the watcher watches (until KeyboardInterrupt) try: while True: # Pretty spinner =) spinner_text = colored( 'Watching files', 'blue', ) + colored(' (use Ctrl+c to exit)', 'red') with yaspin( Spinners.bouncingBar, text=spinner_text, color='blue', ): time.sleep(1) except KeyboardInterrupt: self._logger.debug('Got a KeyboardInterrupt, stopping watcher.') observer.stop() observer.join() self._logger.debug(f"Stoped watching {args['in_path']}") if self._visual: print( colored('Stoped watcher for:', 'blue', attrs=['bold']), colored(f"{os.path.abspath(args['in_path'])}", 'blue'), ) else: self._logger.info(f"Stoped watching {args['in_path']}")
def watch(script, callback): if script in _observers: raise RuntimeError("Script already observed") script_dir = os.path.dirname(os.path.abspath(script.filename)) script_name = os.path.basename(script.filename) event_handler = _ScriptModificationHandler(callback, filename=script_name) observer = Observer() observer.schedule(event_handler, script_dir) observer.start() _observers[script] = observer
def __init__(self, instance=os, root='.'): FileSystem.__init__(self, instance) self.root = os.path.normpath(root) self.eventQueue = EventQueue() self.eventHandler = EventHandler(self.eventQueue) self.observer = Observer() self.observer.schedule(self.eventHandler, path=self.root, recursive=True) self.observer.start()
def watch_folder(folder, queue): observer = Observer() observer.schedule(MyHandler(queue), path=folder, recursive=True) observer.start() try: while True: observer.join() time.sleep(1) except: pass
def tricks_from(args): """ Command to execute tricks from a tricks configuration file. """ if args.debug_force_polling: from watchdog.observers.polling import PollingObserver as Observer elif args.debug_force_kqueue: from watchdog.observers.kqueue import KqueueObserver as Observer elif args.debug_force_winapi: from watchdog.observers.read_directory_changes import\ WindowsApiObserver as Observer elif args.debug_force_inotify: from watchdog.observers.inotify import InotifyObserver as Observer elif args.debug_force_fsevents: from watchdog.observers.fsevents import FSEventsObserver as Observer else: # Automatically picks the most appropriate observer for the platform # on which it is running. from watchdog.observers import Observer add_to_sys_path(path_split(args.python_path)) observers = [] for tricks_file in args.files: observer = Observer(timeout=args.timeout) if not os.path.exists(tricks_file): raise OSError(errno.ENOENT, os.strerror(errno.ENOENT), tricks_file) config = load_config(tricks_file) try: tricks = config[CONFIG_KEY_TRICKS] except KeyError: raise KeyError("No %r key specified in %s." % ( CONFIG_KEY_TRICKS, tricks_file)) if CONFIG_KEY_PYTHON_PATH in config: add_to_sys_path(config[CONFIG_KEY_PYTHON_PATH]) dir_path = os.path.dirname(tricks_file) if not dir_path: dir_path = os.path.relpath(os.getcwd()) schedule_tricks(observer, tricks, dir_path, args.recursive) observer.start() observers.append(observer) try: while True: time.sleep(1) except WatchdogShutdown: for o in observers: o.unschedule_all() o.stop() for o in observers: o.join()
def start(self): _g_logger.debug("Starting alert message sender %s" % self.dir_to_watch) if self._thread is not None: raise Exception("The alert object has already been started.") self._stopping = threading.Event() self._thread = threading.Thread(target=self._run) self._thread.start() try: self.observer = Observer() self.observer.schedule(self, path=self.dir_to_watch) self.observer.start() except: self.observer = None raise
def start_watch_loop(self, *args, **options): self.set_options(**options) callback = partial(self.watch_handle, *args, **options) handler = ChangeDebounceHandler(callback) observer = Observer() for path in self.collect_watch_paths(): observer.schedule(handler, path, recursive=True) observer.start() try: while True: handler.process() time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()
def __init__(self, config, change_manager, poll=1): self.watch_dir = config["watch_dir"] self.poll = poll self.event_handler = change_manager(self.watch_dir, config) self.observer = Observer(os.stat, os.listdir) try: os.stat("./logs") except: os.mkdir("./logs") logging.basicConfig(filename="./logs/dir_watch.log", level=logging.INFO, format='%(asctime)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
def __init__(self, path=".", recursive=True, event_handler=None, observer=None): if observer is None: self._observer = Observer() else: self._observer = observer evh = event_handler or AIOEventHandler() if isinstance(path, list): for _path in path: self._observer.schedule(evh, _path, recursive) else: self._observer.schedule(evh, path, recursive)
def start_toml_observer(path, transfer=None, dry_run=False, import_db=None): toml_handler = TomlCreatedEventHandler(transfer=transfer, dry_run=dry_run, import_db=import_db) # We use the polling observer as inotify # does not see remote file creation events observer = Observer() observer.schedule(toml_handler, path, recursive=True) print("Starting observer") observer.start() print("Observer started") try: while True: time.sleep(1) finally: observer.stop() observer.join()
def watchJsonFile(): class MyEventHandler(PatternMatchingEventHandler): def on_modified(self, event): super(MyEventHandler, self).on_modified(event) # FIXME python recognizes change, needs to take change and push to led lights updateColors() printData() event_handler = MyEventHandler(patterns='dat*.json') my_observer = Observer() my_observer.schedule(event_handler, ".", recursive=True) my_observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: my_observer.stop() my_observer.join()
def start(self): patterns = self.config.get('watchdog', 'patterns').split(';') ignore_directories = self.config.getboolean('watchdog', 'ignore_directories') ignore_patterns = self.config.get('watchdog', 'ignore_patterns').split(';') case_sensitive = self.config.getboolean('watchdog', 'case_sensitive') recursive = self.config.getboolean('watchdog', 'recursive') event_handler = PatternMatchingEventHandler(patterns=patterns, ignore_patterns=ignore_patterns, ignore_directories=ignore_directories, case_sensitive=case_sensitive) # event_handler.on_any_event = self.on_any_event event_handler.on_created = self.on_created # event_handler.on_modified = self.on_modified event_handler.on_moved = self.on_moved sy_path = self.config.get('sy', 'path') hcs_path = self.config.get('hcs', 'path') afs_path = self.config.get('afs', 'path') aas_path = self.config.get('aas', 'path') paths = [sy_path, hcs_path, afs_path, aas_path] self.observer = Observer(stat=os.stat, listdir=os.listdir) # self.observer = Observer() for path in paths: self.observer.schedule(path=path, event_handler=event_handler, recursive=recursive) self.observer.start() self.logger.info('Data Grabbing Robot for CCLAS is startting.....') self.logger.info('patterns=%s' % patterns) self.logger.info('paths=%s' % paths) self.logger.info('delay=%s' % str(self.config.getfloat('watchdog', 'delay'))) try: while self.observer.is_alive(): time.sleep(self.config.getfloat('watchdog', 'delay')) except KeyboardInterrupt: self.observer.stop() self.logger.info('Data Grabbing Robot is stoped.') except PermissionError: self.observer.start() except TypeError: self.observer.start() self.observer.join()
def start_observer(self): loggerwatchdog.info( "******************** Pre-initialization ********************") loggerwatchdog.info("Watchdog will be active to this directory: " + DIRECTORY_TO_WATCH) loggerwatchdog.info( "Watchdog will move the files to this directory: " + DIRECTORY_TO_MOVE) loggerwatchdog.info( "Watchdog will move unmatched files to this directory: " + DIRECTORY_UNMATCHED) loggerwatchdog.info("Preferred ID is set to: " + str(pref_ID)) loggerwatchdog.info("Dry Run is set to: " + str(pref_DryRun)) if (pref_StripSymbol != ""): loggerwatchdog.info("Your strip symbol is: " + (pref_StripSymbol)) else: loggerwatchdog.info("You haven't set a Strip Symbol.") loggerwatchdog.info( "******************** Pre-initialization ********************") self.DIR_W_TextField.config(state="disabled") self.DIR_W_Button.config(state="disabled") self.DIR_M_TextField.config(state="disabled") self.DIR_M_Button.config(state="disabled") self.DIR_U_TextField.config(state="disabled") self.DIR_U_Button.config(state="disabled") self.UI_Checkbutton_ID.config(state="disabled") self.UI_pref_StripSymbol_TextField.config(state="disabled") self.UI_Checkbutton_DryRun.config(state="disabled") self.SET_BUTTON.config(state="disabled") self.but.config(state="disabled", text="Watchdog Initiated") self.but2.config(state="normal", text="Stop Watchdog") self.observer = Observer() self.observer.schedule(event_handler, DIRECTORY_TO_WATCH, recursive=True) self.observer.start() loggerwatchdog.info( "******************** Watchdog initiated ********************")
def handle(self, *args, **options): if options['watch']: self.set_options(**options) callback = partial(self.watch_handle, *args, **options) handler = ChangeDebounceHandler(callback) observer = Observer() for path in self.collect_watch_paths(): observer.schedule(handler, path, recursive=True) observer.start() try: while True: handler.process() time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join() else: # fall back to parent functionality super(Command, self).handle(*args, **options)
def __init__(self, collections_path: str, granule_updated_callback: Callable[[str, Collection], Awaitable], s3_bucket: Optional[str] = None, collections_refresh_interval: float = 30): if not os.path.isabs(collections_path): raise RelativePathError( "Collections config path must be an absolute path.") self._collections_path = collections_path self._granule_updated_callback = granule_updated_callback self._collections_refresh_interval = collections_refresh_interval self._collections_by_dir: Dict[str, Set[Collection]] = defaultdict(set) self._observer = S3Observer( s3_bucket, initial_scan=True) if s3_bucket else Observer() self._granule_watches = set()
def __init__(self, root, userkey, salt): """ Create a new server that handles the public key authentication. @param root: root path of the server. @type root: str @param userkey: path to the user's public key. @type userkey: str """ super(Server, self).__init__() self.root = root self.userkey = userkey self.salt = salt self.eventQueue = EventQueue() self.eventHandler = EventHandler(self.eventQueue) self.observer = Observer() self.observer.schedule(self.eventHandler, path=self.root, recursive=True) self.observer.start()
def run_watch(self): if self.poll: from watchdog.observers.polling import PollingObserver as Observer else: from watchdog.observers import Observer event_handler = RoninEventHandler(self) observer = Observer() observer.schedule(event_handler, self.source, recursive=True) observer.start() try: logger.info( "Watching directory: '{0}' for changes (poll={1})".format( self.source, self.poll)) while True: time.sleep(1) except KeyboardInterrupt: logger.info("Stopping watcher...") observer.stop() observer.join()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-c', nargs='?', default=os.getcwd(), help=('Location of the tox.ini file. Defaults to ' 'current working directory.')) parser.add_argument('-n', nargs='?', default=min(8, multiprocessing.cpu_count()), help=('Number of concurrent jobs allowed. Default ' 'is number of CPUs or 8, whichever is smaller.')) parser.add_argument('-e', nargs='*', help=('Environments to allow from the tox.ini file. ' 'Default is all environments.')) parser.add_argument('-o', nargs='*', help=('Environments to omit from the tox.ini file. ' 'Default is omitting no environments.')) args = vars(parser.parse_args(sys.argv[1:])) observer = Observer() handler = ToxdogEventHandler(args['c'], args['e'] or [], args['o'] or [], int(args['n'])) handler.start() observer.schedule(handler, args['c'], True) observer.start() try: while True: time.sleep(1.0) except KeyboardInterrupt: observer.stop() handler.stop() sys.stdout.write("\r\033[K") sys.stdout.flush() observer.join()
def __init__(self, contentdir=''): """ @param contentDirs are the dirs where we will load wiki files from & parse """ self.file_observers = [] self.spacehandler = SpaceHandler(self) self.contentdir = contentdir if contentdir.endswith( '/') else '%s/' % contentdir if not j.sal.fs.exists(contentdir): print("Contentdir %s was not found .. creating it." % contentdir) j.sal.fs.createDir(contentdir) if contentdir.strip(): # Watch the contentdir for changes observer = Observer() self.file_observers.append(observer) j.portal.tools.server.active.watchedspaces.append(contentdir) print(('Monitoring', contentdir)) observer.schedule(self.spacehandler, contentdir, recursive=True) observer.start()
def __init__(self): self.FourDFlowScanNameC1 = "" self.FourDFlowScanNameC2 = "" self.DicomNamesC1 = [] self.DicomNamesC2 = [] self.Candidate_Num1 = 0 self.Candidate_Num2 = 0 self.finalPath1 = "" self.finalPath2 = "" self.Patients = [] self.ProcessedPatients = [] self.path = r'/mnt/data_imaging/jetsonTest' #self.path = r'C:\Users\jjb1487\Desktop\WatchdogTest' self.documents = dict( ) # key = document label value = Document reference self.patterns = "*" self.ignore_patterns = "" self.ignore_directories = False self.case_sensitive = True self.my_event_handler = watchdog.events.PatternMatchingEventHandler( self.patterns, self.ignore_patterns, self.ignore_directories, self.case_sensitive) #self.my_event_handler.on_any_event = self.on_any_event #self.my_event_handler.on_deleted = self.on_deleted self.my_event_handler.on_created = self.on_created self.observer = Observer() self.observer.schedule(self.my_event_handler, self.path, recursive=True) self.observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: self.observer.stop() self.observer.join()
def __init__(self): for file in searching_all_files(input_path): work_with_file(file) self.observer = Observer()