def background_thread(): global observer event_handler = CsvWatcher() observer = Observer() observer.schedule(event_handler, './', recursive=True) observer.start()
def __init__(self, watchDirectory: str): self.watchDirectory = watchDirectory self.observer = Observer()
def monitor(configuration): """Monitors the filesystem for crontab changes""" pid = multiprocessing.current_process().pid print('Starting global crontab monitor process') logger.info('Starting global crontab monitor process') # Set base_dir and base_dir_len shared_state['base_dir'] = os.path.join(configuration.user_settings) shared_state['base_dir_len'] = len(shared_state['base_dir']) # Allow e.g. logrotate to force log re-open after rotates register_hangup_handler(configuration) # Monitor crontab configurations crontab_monitor_home = shared_state['base_dir'] recursive_crontab_monitor = True crontab_monitor = Observer() crontab_pattern = os.path.join(crontab_monitor_home, '*', crontab_name) atjobs_pattern = os.path.join(crontab_monitor_home, '*', atjobs_name) shared_state['crontab_handler'] = MiGCrontabEventHandler( patterns=[crontab_pattern, atjobs_pattern], ignore_directories=False, case_sensitive=True) crontab_monitor.schedule(shared_state['crontab_handler'], configuration.user_settings, recursive=recursive_crontab_monitor) crontab_monitor.start() if len(crontab_monitor._emitters) != 1: logger.error('(%s) Number of crontab_monitor._emitters != 1' % pid) return 1 crontab_monitor_emitter = min(crontab_monitor._emitters) if not hasattr(crontab_monitor_emitter, '_inotify'): logger.error('(%s) crontab_monitor_emitter require inotify' % pid) return 1 shared_state['crontab_inotify'] = crontab_monitor_emitter._inotify._inotify logger.info('(%s) trigger crontab and atjobs refresh' % (pid, )) # Fake touch event on all crontab files to load initial crontabs # logger.info('(%s) trigger load on all files (greedy) matching %s or %s' \ # % (pid, crontab_pattern, atjobs_pattern)) # We manually walk and test to get the greedy "*" directory match behaviour # of the PatternMatchingEventHandler all_crontab_files, all_atjobs_files = [], [] for (root, _, files) in walk(crontab_monitor_home): if crontab_name in files: crontab_path = os.path.join(root, crontab_name) all_crontab_files.append(crontab_path) if atjobs_name in files: atjobs_path = os.path.join(root, atjobs_name) all_atjobs_files.append(atjobs_path) for target_path in all_crontab_files + all_atjobs_files: logger.debug('(%s) trigger load on cron/at file in %s' % (pid, target_path)) shared_state['crontab_handler'].dispatch( FileModifiedEvent(target_path)) # logger.debug('(%s) loaded initial crontabs:\n%s' % (pid, # all_crontab_files)) while not stop_running.is_set(): try: loop_start = datetime.datetime.now() loop_minute = loop_start.replace(second=0, microsecond=0) logger.debug('main loop started with %d crontabs and %d atjobs' % (len(all_crontabs), len(all_atjobs))) for crontab_path, user_crontab in all_crontabs.items(): client_dir = os.path.basename(os.path.dirname(crontab_path)) client_id = client_dir_id(client_dir) for entry in user_crontab: logger.debug('inspect cron entry for %s: %s' % (client_id, entry)) if cron_match(configuration, loop_minute, entry): logger.info('run matching cron entry: %s' % entry) run_handler(configuration, client_id, loop_minute, entry) for atjobs_path, user_atjobs in all_atjobs.items(): client_dir = os.path.basename(os.path.dirname(atjobs_path)) client_id = client_dir_id(client_dir) remaining = [] for entry in user_atjobs: logger.debug('inspect atjobs entry for %s: %s' % (client_id, entry)) remain_mins = at_remain(configuration, loop_minute, entry) if remain_mins == 0: logger.info('run matching at entry: %s' % entry) run_handler(configuration, client_id, loop_minute, entry) elif remain_mins > 0: remaining.append(entry) else: logger.info('removing expired at job: %s' % entry) # Update remaining jobs to clean up expired if remaining: all_atjobs[atjobs_path] = remaining else: del all_atjobs[atjobs_path] except KeyboardInterrupt: print('(%s) caught interrupt' % pid) stop_running.set() except Exception as exc: logger.error('unexpected exception in monitor: %s' % exc) import traceback print(traceback.format_exc()) # Throttle down until next minute loop_time = (datetime.datetime.now() - loop_start).seconds if loop_time > 60: logger.warning('(%s) loop did not finish before next tick: %s' % (os.getpid(), loop_time)) loop_time = 59 # Target sleep until start of next minute sleep_time = max(60 - (loop_time + loop_start.second), 1) # TODO: this debug log never shows up - conflict with user info log? # at least it does if changed to info. logger.debug('main loop sleeping %ds' % sleep_time) # print('main loop sleeping %ds' % sleep_time) time.sleep(sleep_time) print('(%s) Exiting crontab monitor' % pid) logger.info('(%s) Exiting crontab monitor' % pid) return 0
print("Specify path to workspace!") exit(1) mesh_keys_path = os.path.expanduser(sys.argv[1]) network_file = 'mesh_network_data.txt' app_file = 'mesh_app_data.txt' key = winreg.OpenKey( winreg.HKEY_LOCAL_MACHINE, r'SOFTWARE\WOW6432Node\Frontline Test Equipment\User Data') my_decoders_path = winreg.QueryValueEx(key, "My Decoders")[0] mesh_options_filename = 'MeshOptions.ini' file_modified() mesh_keys_file_event_handler = MeshKeysFileEventHandler(patterns=[ os.path.join(mesh_keys_path, network_file), os.path.join(mesh_keys_path, app_file) ]) observer = Observer() observer.schedule(mesh_keys_file_event_handler, path=mesh_keys_path, recursive=False) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()
def start(): global observer observer = Observer() observer.schedule(Handler(), path=r"C:", recursive=True) observer.start()
def __init__(self): self.observer = Observer() for path in odoo.modules.module.ad_paths: _logger.info('Watching addons folder %s', path) self.observer.schedule(self, path, recursive=True)
def run_watcher(self): """ Watcher thread's function. :return: None. """ # Create observer observer = Observer() # Start observer observer.start() # Dict that maps file path to `watch object` watche_obj_map = {} # Run change check in a loop while not self._watcher_to_stop: # Get current watch paths old_watch_path_s = set(watche_obj_map) # Get new watch paths new_watch_path_s = self._find_watch_paths() # For each new watch path for new_watch_path in new_watch_path_s: # Remove from the old watch paths if exists old_watch_path_s.discard(new_watch_path) # If the new watch path was not watched if new_watch_path not in watche_obj_map: try: # Schedule a watch watch_obj = observer.schedule( # 2KGRW # `FileSystemEventHandler` instance self, # File path to watch new_watch_path, # Whether recursive recursive=True, ) # Store the watch obj watche_obj_map[new_watch_path] = watch_obj # If have error except OSError: # Set the watch object be None watche_obj_map[new_watch_path] = None # For each old watch path that is not in the new watch paths for old_watch_path in old_watch_path_s: # Get watch object watch_obj = watche_obj_map.pop(old_watch_path, None) # If have watch object if watch_obj is not None: # Unschedule the watch observer.unschedule(watch_obj) # Store new watch paths self._watch_paths = new_watch_path_s # Sleep before next check time.sleep(self._interval)
def __init__(self): _import_watchdog() from watchdog.observers import Observer self._observer = Observer() self._started = False
def serve(args): """Start a server which will watch .md and .rst files for changes. If a md file changes, the Home Documentation is rebuilt. If a .rst file changes, the updated sphinx project is rebuilt Args: args (ArgumentParser): flags from the CLI """ # Sever's parameters port = args.serve_port or PORT host = "0.0.0.0" # Current working directory dir_path = Path().absolute() yaml = YAML() mkdocs_yml = yaml.load(open(dir_path / 'mkdocs.yml')) site_dir = mkdocs_yml['site_dir'] if 'site_dir' in mkdocs_yml else 'site' web_dir = dir_path / site_dir # Update routes utils.set_routes() # Offline mode if args.offline: os.environ["METADOCS_OFFLINE"] = "true" _ = subprocess.check_output("mkdocs build > /dev/null", shell=True) utils.make_offline() class MetadocsHTTPHandler(SimpleHTTPRequestHandler): """Class routing urls (paths) to projects (resources) """ def translate_path(self, path): # default root -> cwd location = str(web_dir) route = location if len(path) != 0 and path != "/": for key, loc in utils.get_routes(): if path.startswith(key): location = loc path = path[len(key) :] break if location[-1] == "/" or not path or path[0] == "/": route = location + path else: route = location + "/" + path return route.split("?")[0] # Serve as deamon thread success = False count = 0 print("Waiting for server port...") try: while not success: try: httpd = socketserver.TCPServer((host, port), MetadocsHTTPHandler) success = True except OSError: count += 1 finally: if not success and count > 20: s = "port {} seems occupied. Try with {} ? (y/n)" if "y" in input(s.format(port, port + 1)): port += 1 count = 0 else: print("You can specify a custom port with metadocs serve -s") return time.sleep(0.5) except KeyboardInterrupt: print("Aborting.") return httpd.allow_reuse_address = True print("\nServing at http://{}:{}\n".format(host, port)) thread = threading.Thread(target=httpd.serve_forever) thread.daemon = True thread.start() # Watch for changes event_handler = utils.MetadocsFileHandler( patterns=["*.rst", "*.md", "*.yml", "*.yaml"] ) observer = Observer() observer.schedule(event_handler, path=str(dir_path), recursive=True) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() httpd.server_close() observer.join()
def watch_command(context, backend, config, poll): """ Watch for change on your Sass project sources then compile them to CSS. Watched events are: \b * Create: when a new source file is created; * Change: when a source is changed; * Delete: when a source is deleted; * Move: When a source file is moved in watched dirs. Also occurs with editor transition file; Almost all errors occurring during compile won"t break watcher, so you can resolve them and watcher will try again to compile once a new event occurs. You can stop watcher using key combo "CTRL+C" (or CMD+C on MacOSX). """ logger = logging.getLogger("boussole") logger.info("Watching project") # Discover settings file try: discovering = Discover( backends=[SettingsBackendJson, SettingsBackendYaml]) config_filepath, config_engine = discovering.search( filepath=config, basedir=os.getcwd(), kind=backend) project = ProjectBase(backend_name=config_engine._kind_name) settings = project.backend_engine.load(filepath=config_filepath) except BoussoleBaseException as e: logger.critical(six.text_type(e)) raise click.Abort() logger.debug(u"Settings file: {} ({})".format(config_filepath, config_engine._kind_name)) logger.debug(u"Project sources directory: {}".format( settings.SOURCES_PATH)) logger.debug(u"Project destination directory: {}".format( settings.TARGET_PATH)) logger.debug(u"Exclude patterns: {}".format(settings.EXCLUDES)) # Watcher settings watcher_templates_patterns = { "patterns": ["*.scss", "*.sass"], "ignore_patterns": ["*.part"], "ignore_directories": False, "case_sensitive": True, } # Init inspector instance shared through all handlers inspector = ScssInspector() if not poll: logger.debug(u"Using Watchdog native platform observer") observer = Observer() else: logger.debug(u"Using Watchdog polling observer") observer = PollingObserver() # Init event handlers project_handler = WatchdogProjectEventHandler(settings, inspector, **watcher_templates_patterns) lib_handler = WatchdogLibraryEventHandler(settings, inspector, **watcher_templates_patterns) # Observe source directory observer.schedule(project_handler, settings.SOURCES_PATH, recursive=True) # Also observe libraries directories for libpath in settings.LIBRARY_PATHS: observer.schedule(lib_handler, libpath, recursive=True) # Start watching logger.warning(u"Launching the watcher, use CTRL+C to stop it") observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: logger.warning(u"CTRL+C used, stopping..") observer.stop() observer.join()
class Server(): def __init__(self, configfile=None, basedir=None, host="0.0.0.0", port=5000, debug=False, allowRoot=False, logConf=None): self._configfile = configfile self._basedir = basedir self._host = host self._port = port self._debug = debug self._allowRoot = allowRoot self._logConf = logConf self._ioLoop = None def stop(self): if self._ioLoop: self._ioLoop.stop() self._ioLoop = None def run(self): if not self._allowRoot: self._checkForRoot() global userManager global eventManager global loginManager global debug global softwareManager global discoveryManager global VERSION from tornado.wsgi import WSGIContainer from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from tornado.web import Application, FallbackHandler from astroprint.printfiles.watchdogs import UploadCleanupWatchdogHandler debug = self._debug # first initialize the settings singleton and make sure it uses given configfile and basedir if available self._initSettings(self._configfile, self._basedir) s = settings() # then initialize logging self._initLogging(self._debug, self._logConf) logger = logging.getLogger(__name__) if s.getBoolean(["accessControl", "enabled"]): userManagerName = settings().get(["accessControl", "userManager"]) try: clazz = util.getClass(userManagerName) userManager = clazz() except AttributeError, e: logger.exception("Could not instantiate user manager %s, will run with accessControl disabled!" % userManagerName) softwareManager = swManager() VERSION = softwareManager.versionString logger.info("Starting AstroBox (%s) - Commit (%s)" % (VERSION, softwareManager.commit)) from astroprint.migration import migrateSettings migrateSettings() eventManager = events.eventManager() printer = printerManager(printerProfileManager().data['driver']) #Start some of the managers here to make sure there are no thread collisions from astroprint.network.manager import networkManager from astroprint.boxrouter import boxrouterManager networkManager() boxrouterManager() # configure timelapse #octoprint.timelapse.configureTimelapse() app.wsgi_app = ReverseProxied(app.wsgi_app) app.secret_key = boxrouterManager().boxId loginManager = LoginManager() loginManager.session_protection = "strong" loginManager.user_callback = load_user if userManager is None: loginManager.anonymous_user = users.DummyUser principals.identity_loaders.appendleft(users.dummy_identity_loader) loginManager.init_app(app) # setup command triggers events.CommandTrigger(printer) if self._debug: events.DebugEventListener() if networkManager().isOnline(): softwareManager.checkForcedUpdate() if self._host is None: self._host = s.get(["server", "host"]) if self._port is None: self._port = s.getInt(["server", "port"]) app.debug = self._debug from octoprint.server.api import api app.register_blueprint(api, url_prefix="/api") boxrouterManager() # Makes sure the singleton is created here. It doesn't need to be stored self._router = SockJSRouter(self._createSocketConnection, "/sockjs") discoveryManager = DiscoveryManager() def access_validation_factory(validator): """ Creates an access validation wrapper using the supplied validator. :param validator: the access validator to use inside the validation wrapper :return: an access validation wrapper taking a request as parameter and performing the request validation """ def f(request): """ Creates a custom wsgi and Flask request context in order to be able to process user information stored in the current session. :param request: The Tornado request for which to create the environment and context """ wsgi_environ = tornado.wsgi.WSGIContainer.environ(request) with app.request_context(wsgi_environ): app.session_interface.open_session(app, flask.request) loginManager.reload_user() validator(flask.request) return f self._tornado_app = Application(self._router.urls + [ #(r"/downloads/timelapse/([^/]*\.mpg)", LargeResponseHandler, {"path": s.getBaseFolder("timelapse"), "as_attachment": True}), (r"/downloads/files/local/([^/]*\.(gco|gcode))", LargeResponseHandler, {"path": s.getBaseFolder("uploads"), "as_attachment": True}), (r"/downloads/logs/([^/]*)", LargeResponseHandler, {"path": s.getBaseFolder("logs"), "as_attachment": True, "access_validation": access_validation_factory(admin_validator)}), #(r"/downloads/camera/current", UrlForwardHandler, {"url": s.get(["webcam", "snapshot"]), "as_attachment": True, "access_validation": access_validation_factory(user_validator)}), (r".*", FallbackHandler, {"fallback": WSGIContainer(app.wsgi_app)}) ]) self._server = HTTPServer(self._tornado_app, max_buffer_size=167772160) #Allows for uploads up to 160MB self._server.listen(self._port, address=self._host) logger.info("Listening on http://%s:%d" % (self._host, self._port)) eventManager.fire(events.Events.STARTUP) if s.getBoolean(["serial", "autoconnect"]): (port, baudrate) = s.get(["serial", "port"]), s.getInt(["serial", "baudrate"]) connectionOptions = printer.getConnectionOptions() if port in connectionOptions["ports"]: printer.connect(port, baudrate) # start up watchdogs observer = Observer() observer.schedule(UploadCleanupWatchdogHandler(), s.getBaseFolder("uploads")) observer.start() try: self._ioLoop = IOLoop.instance() self._ioLoop.start() except SystemExit: pass except: logger.fatal("Please report this including the stacktrace below in AstroPrint's bugtracker. Thanks!") logger.exception("Stacktrace follows:") finally: observer.stop() self.cleanup() observer.join() logger.info('Good Bye!')
def __init__(self, src_path): # initialisieren von Variablen die global (auch außerhalb der Class!) verwendet werden soll self.__src_path = src_path self.__event_handler = plcEventHandler() self.__event_observer = Observer()
def start(services, auto_upgrade, anchore_module, skip_config_validate, skip_db_compat_check, all): """ Startup and monitor service processes. Specify a list of service names or empty for all. """ global config ecode = 0 auto_upgrade = True if not anchore_module: module_name = "anchore_engine" else: module_name = str(anchore_module) if os.environ.get('ANCHORE_ENGINE_SKIP_DB_COMPAT_CHECK', str(skip_db_compat_check)).lower() in ['true', 't', 'y', 'yes']: skip_db_compat_check = True else: skip_db_compat_check = False if services: input_services = list(services) else: input_services = os.getenv('ANCHORE_ENGINE_SERVICES', '').strip().split() if not input_services and not all: raise click.exceptions.BadArgumentUsage('No services defined to start. Must either provide service arguments, ANCHORE_ENGINE_SERVICES env var, or --all option') try: validate_params = { 'services': True, 'webhooks': True, 'credentials': True } if skip_config_validate: try: items = skip_config_validate.split(',') for item in items: validate_params[item] = False except Exception as err: raise Exception(err) # find/set up configuration configdir = config['configdir'] configfile = os.path.join(configdir, "config.yaml") localconfig = None if os.path.exists(configfile): try: localconfig = anchore_engine.configuration.localconfig.load_config(configdir=configdir, configfile=configfile, validate_params=validate_params) except Exception as err: raise Exception("cannot load local configuration: " + str(err)) else: raise Exception("cannot locate configuration file ({})".format(configfile)) # load the appropriate DB module try: logger.info("Loading DB routines from module ({})".format(module_name)) module = importlib.import_module(module_name + ".db.entities.upgrade") # except TableNotFoundError as ex: # logger.info("Initialized DB not found.") except Exception as err: raise Exception("Input anchore-module (" + str(module_name) + ") cannot be found/imported - exception: " + str(err)) # get the list of local services to start startFailed = False if not input_services: config_services = localconfig.get('services', {}) if not config_services: logger.warn('could not find any services to execute in the config file') sys.exit(1) input_services = [ name for name, srv_conf in list(config_services.items()) if srv_conf.get('enabled')] services = [] for service_conf_name in input_services: if service_conf_name in list(service_map.values()): svc = service_conf_name else: svc = service_map.get(service_conf_name) if svc: services.append(svc) else: logger.warn('specified service {} not found in list of available services {} - removing from list of services to start'.format(service_conf_name, list(service_map.keys()))) if 'anchore-catalog' in services: services.remove('anchore-catalog') services.insert(0, 'anchore-catalog') if not services: logger.error("No services found in ANCHORE_ENGINE_SERVICES or as enabled in config.yaml to start - exiting") sys.exit(1) # preflight - db checks try: db_params = anchore_engine.db.entities.common.get_params(localconfig) #override db_timeout since upgrade might require longer db session timeout setting try: if 'timeout' in db_params.get('db_connect_args', {}): db_params['db_connect_args']['timeout'] = 86400 elif 'connect_timeout' in db_params.get('db_connect_args', {}): db_params['db_connect_args']['connect_timeout'] = 86400 except Exception as err: pass anchore_manager.cli.utils.connect_database(config, db_params, db_retries=300) code_versions, db_versions = anchore_manager.cli.utils.init_database(upgrade_module=module, localconfig=localconfig, do_db_compatibility_check=(not skip_db_compat_check)) in_sync = False timed_out = False max_timeout = 3600 timer = time.time() while not in_sync and not timed_out: code_versions, db_versions = module.get_versions() if code_versions and db_versions: if code_versions['db_version'] != db_versions['db_version']: if auto_upgrade and 'anchore-catalog' in services: logger.info("Auto-upgrade is set - performing upgrade.") try: # perform the upgrade logic here rc = module.run_upgrade() if rc: logger.info("Upgrade completed") else: logger.info("No upgrade necessary. Completed.") except Exception as err: raise err in_sync = True else: logger.warn("this version of anchore-engine requires the anchore DB version ({}) but we discovered anchore DB version ({}) in the running DB - it is safe to run the upgrade while seeing this message - will retry for {} more seconds.".format(str(code_versions['db_version']), str(db_versions['db_version']), str(max_timeout - int(time.time() - timer)))) time.sleep(5) else: logger.info("DB version and code version in sync.") in_sync = True else: logger.warn('no existing anchore DB data can be discovered, assuming bootstrap') in_sync = True if (max_timeout - int(time.time() - timer)) < 0: timed_out = True if not in_sync: raise Exception("this version of anchore-engine requires the anchore DB version ("+str(code_versions['db_version'])+") but we discovered anchore DB version ("+str(db_versions['db_version'])+") in the running DB - please perform the DB upgrade process and retry") except Exception as err: raise err finally: rc = anchore_engine.db.entities.common.do_disconnect() # start up services logger.info('Starting services: {}'.format(services)) for supportdir in ["/var/log/anchore", "/var/run/anchore"]: try: if not os.path.exists(supportdir): os.makedirs(supportdir, 0o755) except Exception as err: logger.error("cannot create log directory {} - exception: {}".format(supportdir, str(err))) raise err pids = [] keepalive_threads = [] for service in services: pidfile = "/var/run/anchore/" + service + ".pid" try: terminate_service(service, flush_pidfile=True) service_thread = ServiceThread(startup_service, (service, configdir)) keepalive_threads.append(service_thread) max_tries = 30 tries = 0 alive = True while not os.path.exists(pidfile) and tries < max_tries: logger.info("waiting for service pidfile {} to exist {}/{}".format(pidfile, tries, max_tries)) try: alive = service_thread.thread.is_alive() except: pass if not alive: logger.info("service thread has stopped {}".format(service)) break time.sleep(1) tries = tries + 1 logger.info("auto_restart_services setting: {}".format(localconfig.get('auto_restart_services', False))) if not localconfig.get('auto_restart_services', False): logger.info("checking for startup failure pidfile={}, is_alive={}".format(os.path.exists(pidfile), alive)) if not os.path.exists(pidfile) or not alive: raise Exception("service thread for ({}) failed to start".format(service)) time.sleep(1) except Exception as err: startFailed = True logger.warn("service start failed - exception: {}".format(str(err))) break if startFailed: logger.fatal("one or more services failed to start. cleanly terminating the others") for service in services: terminate_service(service, flush_pidfile=True) sys.exit(1) else: # start up the log watchers try: observer = Observer() observer.schedule(AnchoreLogWatcher(), path="/var/log/anchore/") observer.start() try: while True: time.sleep(1) if localconfig.get('auto_restart_services', False): #'auto_restart_services' in localconfig and localconfig['auto_restart_services']: for service_thread in keepalive_threads: if not service_thread.thread.is_alive(): logger.info("restarting service: {}".format(service_thread.thread.name)) service_thread.start() except KeyboardInterrupt: observer.stop() observer.join() except Exception as err: logger.error("failed to startup log watchers - exception: {}".format(str(err))) raise err except Exception as err: logger.error(anchore_manager.cli.utils.format_error_output(config, 'servicestart', {}, err)) if not ecode: ecode = 2 anchore_manager.cli.utils.doexit(ecode)
def start_observer(self): self.observer = Observer() self.observer.schedule(self.watcher, os.path.dirname(self.file_observing), recursive=False) self.observer.start()
def start(self): """ Start threads and directory observer. """ #start threads for threadid in range(1, self.options.threads): print "start proc [", threadid, "]" worker = Process(target=funcworker, args=(self, threadid)) worker.daemon = True self.pool.append(worker) worker.start() #self.processimage(picture,options) self.starttime = time.time() if self.options.watch: eventhandler = addtoqueue(self.picturequeue) self.observer = Observer() self.observer.schedule(eventhandler, self.args[0], recursive=True) self.observer.start() #We let the master process do some work because its useful for matplotlib. if not self.options.nowalk: self.fillqueuewithexistingfiles() if self.options.servermode: from Leash import addauthentication try: while (self.options.servermode or (not self.picturequeue.empty()) or (self.dirwalker and self.dirwalker.is_alive()) or self.options.watch): try: picture = self.picturequeue.get(timeout=1) except Empty: continue #in Case something goes wrong try: lastfile, data = self.procimage(picture, 0) except: continue if self.options.servermode: request = { "command": "putplotdata", "argument": { "data": { "result": "plot", "data": { "filename": lastfile, "graphs": data, "stat": {} } } } } self.plotdataqueue.put(request) if np.mod(self.allp.value, 500) == 0: self.timreport() except KeyboardInterrupt: pass self.stop() self.timreport() return self.allp.value, time.time() - self.starttime
def __init__(self, dir_queue=None): logger.info('Starting to watch directory...') self.observer = Observer() self.dir_queue = dir_queue
def __init__(self, parent=None) -> None: super().__init__(parent=parent) self._observer = Observer() self._handler = Handler() self._observer.schedule(self._handler, path=unsafe_path, recursive=True)
class Server(): def __init__(self, configfile=None, basedir=None, host="127.0.0.1", port=5000, debug=False, allowRoot=False, logConf=None): self._configfile = configfile self._basedir = basedir self._host = host self._port = port self._debug = debug self._allowRoot = allowRoot self._logConf = logConf self._ioLoop = None def stop(self): if self._ioLoop: self._ioLoop.stop() self._ioLoop = None def run(self): if not self._allowRoot: self._checkForRoot() global userManager global eventManager global loginManager global debug global softwareManager global discoveryManager global VERSION global UI_API_KEY from tornado.wsgi import WSGIContainer from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from tornado.web import Application, FallbackHandler from astroprint.printfiles.watchdogs import UploadCleanupWatchdogHandler from astroprint.printfiles.watchdogs import EtherBoxHandler debug = self._debug # first initialize the settings singleton and make sure it # uses given configfile and basedir if available self._initSettings(self._configfile, self._basedir) s = settings() if not s.getBoolean(['api', 'regenerate']) and s.getString( ['api', 'key']): UI_API_KEY = s.getString(['api', 'key']) else: UI_API_KEY = ''.join('%02X' % ord(z) for z in uuid.uuid4().bytes) # then initialize logging self._initLogging(self._debug, self._logConf) logger = logging.getLogger(__name__) if s.getBoolean(["accessControl", "enabled"]): userManagerName = s.get(["accessControl", "userManager"]) try: clazz = util.getClass(userManagerName) userManager = clazz() except AttributeError, e: logger.exception( "Could not instantiate user manager %s, will run " "with accessControl disabled!" % userManagerName) softwareManager = swManager() VERSION = softwareManager.versionString logger.info("Starting AstroBox (%s) - Commit (%s)" % (VERSION, softwareManager.commit)) from astroprint.migration import migrateSettings migrateSettings() eventManager = events.eventManager() printer = printerManager(printerProfileManager().data['driver']) # Start some of the managers here to make sure there are # no thread collisions from astroprint.network.manager import networkManager from astroprint.boxrouter import boxrouterManager networkManager() machine_id = s.get(["setup", "machineId"]) access_key = s.get(["setup", "accessCode"]) _set_boxid = False if machine_id and access_key: api = s.get(["cloudSlicer", "apiHost"]) _data = { 'boxid': machine_id, 'access_key': access_key, } try: logger.info("Trying to set printer id") logger.info(_data) headers = {'Content-type': 'application/json'} res = requests.post( "%s/api/printerauth/" % api, json=_data, headers=headers, timeout=10, allow_redirects=False, ) if res.status_code == 200: logger.info("Printer's id is: %s", machine_id) boxrouterManager() boxrouterManager().boxId = machine_id _set_boxid = True logger.info("Done setting printer id") else: logger.info("Could not authenticate the printer") logger.info("Response status code: %s", res.status_code) except Exception as e: logger.error( "Error setting up boxrouter, boxid could not be set") logger.error(e) app.wsgi_app = ReverseProxied(app.wsgi_app) app.secret_key = os.urandom(4096) loginManager = LoginManager() loginManager.session_protection = "strong" loginManager.user_callback = load_user if userManager is None: loginManager.anonymous_user = users.DummyUser principals.identity_loaders.appendleft(users.dummy_identity_loader) loginManager.init_app(app) # setup command triggers events.CommandTrigger(printer) if self._debug: events.DebugEventListener() if networkManager().isOnline() and _set_boxid: softwareManager.checkForcedUpdate() if self._host is None: self._host = s.get(["server", "host"]) if self._port is None: self._port = s.getInt(["server", "port"]) app.debug = self._debug from octoprint.server.api import api app.register_blueprint(api, url_prefix="/api") # Makes sure the singleton is created here. It doesn't need to be stored boxrouterManager(connect=False) self._router = SockJSRouter(self._createSocketConnection, "/sockjs") discoveryManager = DiscoveryManager() def access_validation_factory(validator): """ Creates an access validation wrapper using the supplied validator. :param validator: the access validator to use inside the validation wrapper :return: an access validation wrapper taking a request as parameter and performing the request validation """ def f(request): """ Creates a custom wsgi and Flask request context in order to be able to process user information stored in the current session. :param request: The Tornado request for which to create the environment and context """ wsgi_environ = tornado.wsgi.WSGIContainer.environ(request) with app.request_context(wsgi_environ): app.session_interface.open_session(app, request) loginManager.reload_user() validator(request) return f self._tornado_app = Application(self._router.urls + [ #(r"/downloads/timelapse/([^/]*\.mpg)", # LargeResponseHandler, # {"path": s.getBaseFolder("timelapse"), # "as_attachment": True}), (r"/downloads/files/local/([^/]*\.(gco|gcode))", LargeResponseHandler, { "path": s.getBaseFolder("uploads"), "as_attachment": True }), (r"/downloads/logs/([^/]*)", LargeResponseHandler, { "path": s.getBaseFolder("logs"), "as_attachment": True, "access_validation": access_validation_factory(admin_validator) }), #(r"/downloads/camera/current", # UrlForwardHandler, # {"url": s.get(["webcam", "snapshot"]), # "as_attachment": True, # "access_validation": access_validation_factory(user_validator)}), (r".*", FallbackHandler, { "fallback": WSGIContainer(app.wsgi_app) }) ]) self._server = HTTPServer(self._tornado_app, max_buffer_size=1048576 * s.getInt(['server', 'maxUploadSize'])) self._server.listen(self._port, address=self._host) logger.info("Listening on http://%s:%d" % (self._host, self._port)) eventManager.fire(events.Events.STARTUP) if s.getBoolean(["serial", "autoconnect"]): (port, baudrate) = s.get(["serial", "port" ]), s.getInt(["serial", "baudrate"]) connectionOptions = printer.getConnectionOptions() if port in connectionOptions["ports"]: printer.connect(port, baudrate) usbdetector = EtherBoxHandler() # start up watchdogs observer = Observer() observer.schedule(UploadCleanupWatchdogHandler(), s.getBaseFolder("uploads")) #observer.schedule( # usbdetector, s.get(['usb', 'folder']), recursive=True) observer.start() try: self._ioLoop = IOLoop.instance() self._ioLoop.start() except SystemExit: pass except: logger.fatal("Please report this including the stacktrace below " "in AstroPrint's bugtracker. Thanks!") logger.exception("Stacktrace follows:") finally: observer.stop() self.cleanup() observer.join() logger.info('Good Bye!')
def _start_observe_file_changes(self): observer = Observer() event_handler = RoutePriorities.ObserverEventHandler( self, self._config_file) observer.schedule(event_handler, path=self._config_file) observer.start()
from watcher.Handler import Handler from watchdog.observers import Observer from indexer.indexer import Indexer from watchdog.events import FileSystemEventHandler import os if __name__ == '__main__': web_dir_observer = Observer() event_handler = Handler() web_dir_observer.schedule(event_handler, path='docs_web/') web_dir_observer.start() nombresDocumentos = os.listdir("docs_web/") indexer = Indexer(list(map(lambda x: "docs_web/" + x, nombresDocumentos))) try: while True: word = input("----ingresa termino a buscar: ") indexer.searchIndex(word) is_change = event_handler.get_val( ) #check if new files were created & get names collected by handler if len(is_change) is not 0: indexer.update_indexer(is_change) except KeyboardInterrupt: web_dir_observer.stop() # sleep until keyboard interrupt, then stop + rejoin the observer web_dir_observer.join()
def watchdog(self, path): # 自定义处理类 class MyHandler(FileSystemEventHandler): global label_title # 声明全局变量 global label_qty global qty global status def on_created(self, event): global label_title # 声明全局变量 global label_qty global qty try: # 加入try异常处理机制,防止程式中断 config_list = [] # 定义列表list,存储config信息 with open('./config.csv', 'r') as f: # 打开config文件 reader = csv.reader(f) # 读取文件 for i in reader: # 通过for循环写入到列表 config_list.append(i[1]) site = config_list[0] # 站点 line = config_list[1] # 线体 station = config_list[2] # 工位 type = config_list[3] # 类型 except: site = "???" # 站点 line = "???" # 线体 station = "???" # 工位 type = "???" # 类型 pass my_name = socket.gethostname() # 获取本机名称 my_ip = socket.gethostbyname(my_name) # 获取本机IP now_time_for_rename = str(datetime.datetime.now().strftime( '%Y%m%d%H%M%S')) # 获取当前时间并对时间进行格式化 path_name = os.path.basename(event.src_path) # 获取被修改的文件名及其路径 created_file_path = event.src_path # 被创建的文件 created_file_type = os.path.splitext(created_file_path)[-1][ 1:] # 获取被清洗文件文件的后缀名 if created_file_type == type.upper( ) or created_file_type == type.lower(): print( "\n###############################################################" ) print("数据文件[%s]被创建 in %s" % (event.src_path, datetime.datetime.now())) # 在此函数内定义需触发的事件 result = upload_file( site + "_" + line + "_" + station + "_" + my_name + '_' + my_ip + '_' + now_time_for_rename + '_' + path_name, event.src_path) if result == 1: print("该文件上抛成功\n") label_title.setText('<b>OK<b>') # 设定界面文本信息 label_title.setStyleSheet( 'color: rgb(0, 255, 0)') # 设定界面文本信息颜色 qty = qty + 1 label_qty.setText(str(qty)) # 设定界面数量显示 label_qty.setStyleSheet( 'color: rgb(0, 255, 0)') # 设定界面文本信息颜色 if result == 0: print("该文件上抛失败\n") label_title.setText('<b>NG<b>') label_title.setStyleSheet('color: rgb(255, 0, 0)') qty = qty label_qty.setText(str(qty)) label_qty.setStyleSheet('color: rgb(255, 0, 0)') event_handler = MyHandler() # 实例化MyHandler类 observer = Observer() # 开启相关服务 observer.schedule(event_handler, path, recursive=True) # 设定监控路径 observer.start() # 开启监控
def __init__(self, directory): self.dir_to_watch = directory print "monitoring " + self.dir_to_watch self.observer = Observer()
def __init__(self, directory_to_watch, videoAnalysis, authChatIds, bot): self.observer = Observer() self.directory_to_watch = directory_to_watch self.videoAnalysis = videoAnalysis self.authChatIds = authChatIds self.bot = bot
def __init__(self): self.observer = Observer()
def __init__(self, src_path): self.__src_path = src_path self.__event_handler = ImagesEventHandler() self.__event_observer = Observer()
if __name__ == "__main__": if config.LIGHT_DEBUG: from light_controls import debug debug() from schedule_handler import Schedule_Runner schedule_runner = Schedule_Runner() loop = schedule_runner.controller.loop file_change_handler = FileChangeHandler(config.SCHEDULE_FILE, schedule_runner.run_schedule, loop=loop) obs = Observer() obs.schedule(file_change_handler, path.Path(config.SCHEDULE_FILE).abspath().dirname() ) #Define what file to watch and how obs.start() #start watching file file_change_handler.process() #start schedule running try: while True: #This does nothing except step through the loops (why is this necessary?) file_change_handler.loop.run_until_complete( asyncio.ensure_future(asyncio.sleep( 0.1, loop=file_change_handler.loop), loop=file_change_handler.loop) ) #arbitrary sleep time here I think. Could it be forever? except KeyboardInterrupt: obs.stop()
class FileWatcher(object): """ A class with only static methods that wraps object watchdogs, to trigger callbacks when a file changes. """ #: A :class:`~watchdog.observers.Observer` to watch when the file changes observer = Observer() #: A :class:`~watchdog.events.FileSystemEventHandler` to get notified when the file changes monitor = FileSystemEventHandler() # `int` that is a GLib timeout id to delay the callback timeout = 0 @classmethod def watch_file(cls, path, callback, *args, **kwargs): """ Watches a new file with a new callback. Removes any precedent watched files. Args: path (`str`): full path to the file to watch callback (`function`): callback to call with all the further arguments when the file changes """ cls.start_daemon() cls.stop_watching() directory = os.path.dirname(path) cls.monitor.on_modified = lambda evt: cls.enqueue(callback, *args, **kwargs) if evt.src_path == path else None try: cls.observer.schedule(cls.monitor, directory) except OSError: logger.error('Impossible to open dir at {}'.format(directory), exc_info = True) @classmethod def enqueue(cls, callback, *args, **kwargs): """ Do not call callback directly, instead delay as to avoid repeated calls in short periods of time. Args: callback (`function`): callback to call with all the further arguments """ if cls.timeout: GLib.Source.remove(cls.timeout) cls.timeout = GLib.timeout_add(200, cls.call, callback, *args, **kwargs) @classmethod def call(cls, callback, *args, **kwargs): """ Call the callback Args: callback (`function`): callback to call with all the further arguments """ if cls.timeout: cls.timeout = 0 callback(*args, **kwargs) @classmethod def stop_watching(cls): """ Remove all files that are being watched """ cls.observer.unschedule_all() @classmethod def start_daemon(cls): """ Start the watchdog observer thread """ if not cls.observer.is_alive(): cls.observer.start() @classmethod def stop_daemon(cls, wait = False): """ Stop the watchdog observer thread. Args: wait (`bool`): whether to wait for the thread to have joined before returning """ cls.observer.unschedule_all() if cls.observer.is_alive(): cls.observer.stop() while wait and cls.observer.is_alive(): cls.observer.join()