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()