def open(self, path=''):
self.callback = tornado.ioloop.PeriodicCallback(
lambda: self.ping(''), 6000)
path = path.strip('/') + '.ipynb'
if path not in event_handlers:
handlers = []
watchdog_observer = watchdog.observers.Observer()
# sometimes useful to add this when triggering does not work
from watchdog.events import LoggingEventHandler
logging_handler = LoggingEventHandler()
watchdog_observer.schedule(logging_handler, '.', recursive=True)
notebook_handler = WatchDogEventHandler(regexes=['\\./' + path])
watchdog_observer.schedule(notebook_handler, '.', recursive=True)
handlers.append(notebook_handler)
misc_handler = WatchDogEventHandler(regexes=[
str(ROOT) + r'/templates/.*',
str(ROOT / 'static/main.js'),
str(ROOT / 'static/dist/libwidgets.js')
])
watchdog_observer.schedule(misc_handler, str(ROOT), recursive=True)
handlers.append(misc_handler)
watchdog_observer.start()
event_handlers[path] = handlers
tornado.autoreload.add_reload_hook(self._on_reload)
self.handlers = event_handlers[path]
for handler in self.handlers:
handler.listeners.append(self)
def start_watchdog():
event_handler = RankingHandler()
observer = Observer()
log_handler = LoggingEventHandler()
log_observer = Observer()
try:
observer.schedule(event_handler, path='./watch')
observer.start()
log_observer.schedule(log_handler, path='./watch')
log_observer.start()
logging.info("Watching Directory")
while True:
time.sleep(1)
except KeyboardInterrupt:
logging.info("Kill message sent. Aborting")
observer.stop()
log_observer.stop()
except:
logging.info("Unexpected error: %s" % sys.exc_info()[0])
observer.stop()
log_observer.stop()
error_message(sys.exc_info()[0])
observer.join()
log_observer.join()
def main():
""" main """
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
path = sys.argv[1] if len(sys.argv) > 1 else '.'
#event_handler = EventHandler()
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def watch(flag):
if flag == 1:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
elif flag == 2:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y/%m/%d %H:%M:%S')
# path = sys.argv[1] if len(sys.argv) > 1 else '.'
# logging.basicConfig(level=logging.INFO,
# format='%(asctime)s - %(message)s',
# datefmt='%Y-%m-%d %H:%M:%S')
print flag
path = 'd:\\home'
event_handler = LoggingEventHandler()
print '24'
observer = Observer()
print '26'
observer.schedule(event_handler, path, recursive=True)
print '28'
observer.start()
print '30'
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
print '36'
observer.stop()
observer.join()
def work_apidoc(paths_to_watch_d):
observer = Observer()
for path in paths_to_watch_d:
event_handler = EventHandler(
patterns=path.get('patterns', ['*.py']),
ignore_directories=path.get('ignore_directories', True),
)
observer.schedule(
event_handler,
path['path'],
recursive=path.get('recursive', True),
)
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
event_handler2 = LoggingEventHandler()
observer.add_handler_for_watch(event_handler2, observer)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def run():
auditList = [
"#-------------- Directory Auditor --------------#",
"1. Save output to file (watchdog.log)", "2. Pipe output to terminal"
]
path = input("Directory Full Path: ")
inp = makeAchoice(auditList, 2)
if (inp == 1):
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filename="./watchdog.txt")
else:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
try:
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
except:
print("ERROR!! Invalid Directory")
exit(2)
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def monitor(self):
"""Monitor current installation and log any changes"""
print("Details at: " + LOGS_DIR + self.type + "-" + self.name +
"-monitor.log")
logging.basicConfig(filename=LOGS_DIR + self.type + "-" + self.name +
"-monitor.log",
level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%d-%m-%Y %H:%M:%S')
# Monitor for changes and write details to a log
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, self.path, recursive=True)
observer.start()
# Monitor for changes and trigger a event
filesystem_event = FileSystemEventHandler()
filesystem_event.on_modified = self.on_modified
observer.schedule(filesystem_event, self.path, recursive=True)
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def main2():
auditList = ["\n\n#--------------Directory Auditor V1.0--------------#", "1. Save output to file (/root/Desktop/lazytool.log)",
"2. Pipe output to terminal"]
inp = printer(auditList, 2)
if(inp == 1):
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S',
filename="/root/Desktop/CS40AuditLogs.log")
else:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
try:
path = input("Directory Full Path: ")
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
except:
print("ERROR!! Invalid Directory")
exit(2)
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def main():
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
(options, args) = parse_options()
port = options.port
assets_path = options.path
file_prefix = options.prefix
host_address = options.host_address
csv.register_dialect('custom_delimiter', delimiter=options.delimiter)
card_renderer = CardRenderer(assets_path, file_prefix)
observer = Observer()
observer.schedule(LoggingEventHandler(), assets_path, recursive=True)
observer.schedule(RenderingEventHandler(card_renderer),
assets_path,
recursive=True)
card_renderer.render_cards()
observer.start()
server = Server()
server.watch(card_renderer.all_cards_rendered_path)
server.serve(root=assets_path, port=port, host=host_address)
observer.stop()
observer.join()
def dir_mon(sv):
try:
if sv == 1:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
elif sv == 2:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filename="/root/Desktop/dir_mon.txt")
except:
print("Couldnt create file program will")
exit()
try:
path = input("Enter full path of monitered directory:")
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
except:
print("couldnt monitor given input program will exit")
def main():
redirect_uri = "http://localhost:8080/"
client_secret = "tzUNLG6DdGydHriTGawVVg4"
client = onedrivesdk.get_default_client(
client_id='5d866328-ad7e-4414-9bc9-df1e47004d41',
scopes=['wl.signin', 'wl.offline_access', 'onedrive.readwrite'])
auth_url = client.auth_provider.get_auth_url(redirect_uri)
code = GetAuthCodeServer.get_auth_code(auth_url, redirect_uri)
client.auth_provider.authenticate(code, redirect_uri, client_secret)
# watchdog
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
path = sys.argv[1] if len(sys.argv) > 1 else '.'
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def run():
logging.basicConfig(filename='logger.txt',
filemode='a',
level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
#CHANGE PATH to directory you want to observe
path = "test_dir_test"
# sys.argv[1] if len(sys.argv) > 1 else '.'
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
files = os.listdir(os.curdir)
mtime_last = {}
for file in files:
mtime_last[file] = 0
try:
while True:
time.sleep(1)
mtime_cur = {}
for file in files:
mtime_cur[file] = os.path.getmtime(file)
if mtime_cur[file] != mtime_last:
print("File Opened")
mtime_last = mtime_cur[file]
except KeyboardInterrupt:
observer.stop()
observer.join()
def run():
"""
Run the CLI tool
"""
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
args = _get_config(_get_args())
observer = Observer()
if args.verbose is True:
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
logging_handler = LoggingEventHandler()
observer.schedule(logging_handler, args.directory, recursive=False)
logging.info('Using keybase.io user %s', args.user)
logging.info('Watching %s for screenshot events', args.directory)
observer.schedule(ScreenshotWatcher(args), args.directory, recursive=False)
observer.start()
try:
while True:
sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def showChangeInfo(path):
msg = """
______ _ _ _ _
| ____(_| | (_| |
| |__ _| | ___ _ __ ___ ___ _ __ _| |_ ___ _ __
| __| | | |/ _ \ | '_ ` _ \ / _ \| '_ \| | __/ _ \| '__|
| | | | | __/ | | | | | | (_) | | | | | || (_) | |
|_| |_|_|\___| |_| |_| |_|\___/|_| |_|_|\__\___/|_|
"""
printc.printf(msg, 'yellow')
class LoggingEventHandler(FileSystemEventHandler):
"""Logs all the events captured."""
#文件被移动时显示白色
def on_moved(self, event):
super(LoggingEventHandler, self).on_moved(event)
t = time.strftime("%Y-%m-%d %X", time.localtime())
what = 'directory' if event.is_directory else 'file'
msg = t + " - Moved %s: from %s to %s" % (what, event.src_path,
event.dest_path)
print(msg)
#文件创建时显示绿色(green)
def on_created(self, event):
super(LoggingEventHandler, self).on_created(event)
t = time.strftime("%Y-%m-%d %X", time.localtime())
what = 'directory' if event.is_directory else 'file'
msg = t + " - Created %s: %s" % (what, event.src_path)
printc.printf(msg, 'green')
#文件删除时显示红色(red)
def on_deleted(self, event):
super(LoggingEventHandler, self).on_deleted(event)
t = time.strftime("%Y-%m-%d %X", time.localtime())
what = 'directory' if event.is_directory else 'file'
msg = t + " - Deleted %s: %s" % (what, event.src_path)
printc.printf(msg, 'red')
#文件修改时显示蓝色(blue)
def on_modified(self, event):
super(LoggingEventHandler, self).on_modified(event)
t = time.strftime("%Y-%m-%d %X", time.localtime())
what = 'directory' if event.is_directory else 'file'
msg = t + " - Modified %s: %s" % (what, event.src_path)
printc.printf(msg, 'blue')
# path = sys.argv[1] if len(sys.argv) > 1 else '.'
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def run_server(args: "DocumentationBuildArguments", port: "int"):
import time
from watchdog.events import FileSystemEventHandler, LoggingEventHandler
from watchdog.observers import Observer as WatchdogObserver
# when in server mode, serve files up from the file system as-is, no archiving
replaced_args = replace(args, archive_format=None)
build_docs(replaced_args)
class docs_update_handler(FileSystemEventHandler):
def on_any_event(self, event):
print("handling an event...")
if not event.is_directory:
build_docs(replaced_args)
observer = WatchdogObserver()
observer.schedule(LoggingEventHandler(), str("dazl"), recursive=True)
observer.schedule(LoggingEventHandler(), str("docs"), recursive=True)
observer.schedule(docs_update_handler(), str("dazl"), recursive=True)
observer.schedule(docs_update_handler(), str("docs"), recursive=True)
observer.start()
d = {}
def run_http_server():
with socketserver.TCPServer(("", port),
SimpleHTTPRequestHandler) as httpd:
d["httpd"] = httpd
httpd.serve_forever()
t = Thread(target=run_http_server)
t.start()
print(
f"Watching for changes in {replaced_args.output_directory} and Serving at port {port}"
)
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
d["httpd"].shutdown()
def __init__(self):
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
# watch a set of directories
for directory in WATCH_DIRECTORIES:
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, directory, recursive=False)
observer.start()
def __init__(self):
event_handler = LoggingEventHandler()
self.observer = Observer()
self.observer.schedule(event_handler, ts3lib.getConfigPath(), recursive=True)
self.observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
self.observer.stop()
self.observer.join()
if PluginHost.cfg.getboolean("general", "verbose"): ts3lib.printMessageToCurrentTab("{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded.".format(timestamp(), self.name, self.author))
def listendog():
path = "c:\Import\help\"
event_handler = LoggingEventHandler()
observer = Observer
observer.schedule(event_handler, path, recursize=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def task2():
print("press 1 to show the logs or 2 to save in file ")
x = int(input("enter 1 or 2 : "))
if x == 1:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
elif x == 2:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filename='/root/python/Dirlog.txt')
try:
path = input("enter the full path: ")
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
exit
except:
print("Invalid input ya man ...")
exit(1)
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def run(self):
self.observer = Observer()
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
event_handler = LoggingEventHandler()
self.observer.schedule(event_handler, self.load_handler.dropboxdir+"/neighbour/loads", recursive=False)
self.observer.schedule(self.load_handler, self.load_handler.dropboxdir+"/neighbour/loads", recursive=False)
self.observer.start()
self.observer.join()
def handle(self, *args, **options):
path = settings.ZDS_APP['content']['extra_content_watchdog_dir']
event_handler = TutorialIsPublished()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.schedule(LoggingEventHandler(), path)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def startSpy(path):
logging.basicConfig(handlers=[
RotatingFileHandler(logFile, maxBytes=100000, backupCount=10)
],
level=logging.DEBUG,
format="%(asctime)s %(message)s",
datefmt='%H:%M %d.%m.%Y')
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
observersMap[path] = observer
def main():
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
args = parse_args()
port = args.port
assets_path = args.path
file_prefix = args.prefix
host_address = args.host_address
rendered_cards_file = args.rendered_cards_file
csv_file = args.csv_file
css_file = args.css_file
pattern = args.pattern
csv.register_dialect('custom_delimiter', delimiter=args.delimiter)
if pattern is None:
card_renderers = [
CardRenderer(assets_path, file_prefix, rendered_cards_file,
csv_file, css_file)
]
else:
matches = re_glob(assets_path, pattern + re.escape(".html.jinja2"))
card_renderers = [
CardRenderer(assets_path, file_prefix.format(match),
rendered_cards_file.format(match),
csv_file.format(match), css_file.format(match))
for match in matches.keys()
]
observer = Observer()
observer.schedule(LoggingEventHandler(), assets_path, recursive=True)
observer.schedule(RenderingEventHandler(card_renderers),
assets_path,
recursive=True)
for card_renderer in card_renderers:
card_renderer.render_cards()
observer.start()
server = Server()
for card_renderer in card_renderers:
server.watch(card_renderer.all_cards_rendered_path)
server.serve(root=assets_path, port=port, host=host_address)
observer.stop()
observer.join()
def main():
path = input("What is the path of the directory you wish to monitor: ")
# Comment 3: Starting event handler and observer on target dir
event_handler = LoggingEventHandler()
event_handler.on_created = on_created
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def watch_for_changes(path): # This method needs to be daemonized
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def observe_over_sessions(path=os.path.curdir):
logging.basicConfig(level=logging.DEBUG)
event_handler = LoggingEventHandler()
observer = PersistantObserver(save_to='C:\\temp\\test.pickle', protocol=-1)
observer.schedule(event_handler, path=path, recursive=True)
observer.start()
# observer.join()
observer.stop()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def startLogger():
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, ".", recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def watch_folder():
if __name__ == "__main__":
event_handler = LoggingEventHandler()
event_handler.on_created = on_dir_created
observer = Observer()
check_if_folder(config.server_folder)
observer.schedule(event_handler, config.server_folder, recursive=False)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def main(dirpath):
# Hook these two signals from the OS ..
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
# Now my signal_handler will get called if OS sends either
# of these to my process.
event_handler = LoggingEventHandler()
observer = Observer()
# recursive=True will monitor sub-dirs and not just the specified dir
observer.schedule(event_handler, dirpath, recursive=True)
observer.schedule(MyHandler(), dirpath)
observer.start()
print 'Program is starting up'
try:
# Will keep track of what lines in what file the word 'magic' is in
magic_dict = {}
while not exit_flag:
# Do my long-running stuff
print 'searching'
# I can set up a dictionary with the file and
# what lines magic appears on
for filename in os.listdir(dirpath):
# Making sure we do not replace the dictionary each loop check
if filename not in magic_dict.keys():
magic_dict[filename] = list()
file_object = open(dirpath + '/' + filename, "r")
file_contents = file_object.readlines()
for i, line in enumerate(file_contents):
print magic_dict
print i, line
magic_in_line = bool(re.search('magic', line))
if magic_in_line and (i not in magic_dict[filename]):
magic_dict[filename].append(i)
logger.warn('Magic keyword in file ' + filename +
' line: ' + str(i))
# put a sleep inside my while loop so I don't peg
# the cpu usage at 100%
time.sleep(5)
except KeyboardInterrupt:
observer.stop()
observer.join()
print 'Program is done'
def main(watch_path):
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
os.makedirs(watch_path) if not os.path.exists(watch_path) else None
dog = Observer()
image_handler = ImageChangeEventHandler()
log_handler = LoggingEventHandler()
watch_instance = dog.schedule(image_handler, watch_path)
dog.add_handler_for_watch(log_handler, watch_instance)
dog.start()
print(u'watching', watch_path, u',interrupt watching with Ctrl + C')
wait_interrupt()
dog.stop()
dog.join()
