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():
sudo('supervisorctl restart wirephone')
try:
event_handler = LoggingEventHandler()
other_handler = CodeEvents()
observer = Observer()
watch = observer.schedule(event_handler, './wirephone', recursive=True)
observer.add_handler_for_watch(other_handler, watch)
observer.start()
logging.info('Waiting for events.')
while True:
try:
action,event = other_handler.queue.get(block=True, timeout=0.5)
except Queue.Empty:
continue
if action == 'reload':
other_handler.reloading = False
local("osascript -e 'display notification \"File %s changed.\" with title \"Reloading....\"'" % event)
logging.info('Reloading the source.')
sudo('supervisorctl restart wirephone')
local("osascript -e 'display notification \"Wirephone reloaded.\" with title \"Matrix Reloaded\"'")
except KeyboardInterrupt:
observer.stop()
observer.join()
def run():
sudo('supervisorctl restart wiregui')
try:
event_handler = LoggingEventHandler()
other_handler = CodeEvents()
observer = Observer()
watch = observer.schedule(event_handler, './wiregui-server', recursive=True)
observer.add_handler_for_watch(other_handler, watch)
observer.start()
logging.info('Waiting for events.')
while True:
try:
action,event = other_handler.queue.get(block=True, timeout=0.5)
except Queue.Empty:
continue
if action == 'reload':
reload(event)
other_handler.reloading = False
except KeyboardInterrupt:
observer.stop()
observer.join()
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()
# -*- coding: utf-8 -*-
import time
import logging
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler, LoggingEventHandler
# from watchdog.observers.api import ObservedWatch
class MyHandler(FileSystemEventHandler):
def on_modified(self, event):
if event.src_path == "/tmp/watch.log":
print("log file %s changed" % event.src_path)
if __name__ == '__main__':
event_handler1 = MyHandler()
observer = Observer()
watch = observer.schedule(event_handler1, path="/", 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, watch)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
class HotterDeployer(object):
def __init__(self, workspace_directory, tomcat_directory, hotterdeploy_dir,
liferay_context, do_polling, statics_directory):
self.do_polling = do_polling
self.workspace_directory = workspace_directory
self.tomcat_directory = tomcat_directory
self.liferay_context = liferay_context
self.statics_directory = statics_directory
self.portlets = {}
self.themes = {}
self.deploys = {}
if hotterdeploy_dir == '':
self.hotterdeploy_dir = os.path.abspath(
os.path.join(tomcat_directory, '..', 'hotterdeploy'))
else:
self.hotterdeploy_dir = os.path.abspath(
os.path.join(hotterdeploy_dir, 'hotterdeploy'))
self.tomcat_temp_dir = os.path.join(tomcat_directory, 'temp')
self.tomcat_webapps_dir = os.path.join(tomcat_directory, 'webapps')
self.liferay_dir = os.path.join(self.tomcat_webapps_dir,
self.liferay_context)
if do_polling:
self.observer = PollingObserverVFS(default_stat, listdir)
else:
self.observer = Observer()
# Create our hotterdeploy directory and watch it for wars
if not os.path.exists(self.hotterdeploy_dir):
os.mkdir(self.hotterdeploy_dir)
self.observer.schedule(OnDeployHandler(hotterDeployer=self),
self.hotterdeploy_dir,
recursive=False)
# Scan tomcat temp directory for deployed portlets
self._scan_temp()
self.observer.schedule(OnTempDeployHandler(hotterDeployer=self),
self.tomcat_temp_dir,
recursive=False)
# Scan tomcat webapps directory for deployed portlets
self._scan_webapps()
self.observer.schedule(OnWebappsDeployHandler(hotterDeployer=self),
self.tomcat_webapps_dir,
recursive=False)
# Scan the working directory for portlets
LOG.debug('Scanning workspace for portlets...')
self._scan_wd(workspace_directory)
LOG.debug('Done.')
# path = os.path.join(self.workspace_directory, 'liferay-portal', 'credoc-newsletter-portlet')
path = self.workspace_directory
# IN_CREATE | IN_DELETE | IN_CLOSE_WRITE && src/main/webapp/WEB-INF
w = self.observer.schedule(WorkSpaceHandler(hotterDeployer=self),
path,
recursive=True)
# IN_CLOSE_WRITE && src/main/webapp
self.observer.add_handler_for_watch(
OnFileChangedHandler(hotterDeployer=self), w)
# self.observer.schedule(OnFileChangedHandler(hotterDeployer=self), self.workspace_directory, recursive=True)
# IN_CLOSE_WRITE && target/classes
self.observer.add_handler_for_watch(
OnClassChangedHandler(hotterDeployer=self), w)
# self.observer.schedule(OnClassChangedHandler(hotterDeployer=self), self.workspace_directory, recursive=True)
self.livereload_server = Server()
def start(self):
import time
start_time = time.time()
LOG.debug('Starting observer...')
self.observer.start()
LOG.debug('Starting observer took {0} seconds'.format(time.time() -
start_time))
from livereload import LiveReloadInfoHandler
LiveReloadInfoHandler.hotterDeployer = weakref.proxy(self)
LOG.info(
'Using {0}'.format('polling' if self.do_polling else 'FS events'))
LOG.info('Serving livereload on http://{host}:{port}/info'.format(
**vars(self.livereload_server)))
try:
self.livereload_server.serve()
except KeyboardInterrupt:
self.observer.stop()
self.livereload_server.stop()
self.observer.join()
def __del__(self):
if os.path.exists(self.hotterdeploy_dir):
os.rmdir(self.hotterdeploy_dir)
def _scan_wd(self, directory):
self.portlets.update(
scan_working_directory_for_portlet_contexts(directory))
def _update_deploys(self):
deploys = {}
if hasattr(self, '_temp_deploys'):
for name, path in self._temp_deploys.items():
deploys[name] = path
if hasattr(self, '_webapp_deploys'):
for name, path in self._webapp_deploys.items():
if name not in deploys:
deploys[name] = path
self.deploys = deploys
def _scan_temp(self):
path = os.path.join(self.tomcat_directory, 'temp')
self._temp_deploys = scan_tomcat_temporary_directory(path)
self._update_deploys()
def _scan_webapps(self):
path = os.path.join(self.tomcat_directory, 'webapps')
self._webapp_deploys = scan_tomcat_webapps_directory(path)
self._update_deploys()
def find_latest_temp_dir(self, portlet_name):
'''
Find the latest temp deploy directory for a given portlet:
e.g. 21-my-portlet-name
'''
latest_subdir = self.deploys.get(portlet_name, None)
return latest_subdir
def trigger_browser_reload(self, path=None):
LOG.debug('reloading browser')
self.livereload_server.reload(path)
class HotterDeployer(object):
def __init__(
self,
workspace_directory,
tomcat_directory,
hotterdeploy_dir,
liferay_context,
do_polling,
statics_directory
):
self.do_polling = do_polling
self.workspace_directory = workspace_directory
self.tomcat_directory = tomcat_directory
self.liferay_context = liferay_context
self.statics_directory = statics_directory
self.portlets = {}
self.themes = {}
self.deploys = {}
if hotterdeploy_dir == '':
self.hotterdeploy_dir = os.path.abspath(os.path.join(tomcat_directory, '..', 'hotterdeploy'))
else:
self.hotterdeploy_dir = os.path.abspath(os.path.join(hotterdeploy_dir, 'hotterdeploy'))
self.tomcat_temp_dir = os.path.join(tomcat_directory, 'temp')
self.tomcat_webapps_dir = os.path.join(tomcat_directory, 'webapps')
self.liferay_dir = os.path.join(self.tomcat_webapps_dir, self.liferay_context)
if do_polling:
self.observer = PollingObserverVFS(default_stat, listdir)
else:
self.observer = Observer()
# Create our hotterdeploy directory and watch it for wars
if not os.path.exists(self.hotterdeploy_dir):
os.mkdir(self.hotterdeploy_dir)
self.observer.schedule(OnDeployHandler(hotterDeployer=self), self.hotterdeploy_dir, recursive=False)
# Scan tomcat temp directory for deployed portlets
self._scan_temp()
self.observer.schedule(OnTempDeployHandler(hotterDeployer=self), self.tomcat_temp_dir, recursive=False)
# Scan tomcat webapps directory for deployed portlets
self._scan_webapps()
self.observer.schedule(OnWebappsDeployHandler(hotterDeployer=self), self.tomcat_webapps_dir, recursive=False)
# Scan the working directory for portlets
LOG.debug('Scanning workspace for portlets...')
self._scan_wd(workspace_directory)
LOG.debug('Done.')
# path = os.path.join(self.workspace_directory, 'liferay-portal', 'credoc-newsletter-portlet')
path = self.workspace_directory
# IN_CREATE | IN_DELETE | IN_CLOSE_WRITE && src/main/webapp/WEB-INF
w = self.observer.schedule(WorkSpaceHandler(hotterDeployer=self), path, recursive=True)
# IN_CLOSE_WRITE && src/main/webapp
self.observer.add_handler_for_watch(OnFileChangedHandler(hotterDeployer=self), w)
# self.observer.schedule(OnFileChangedHandler(hotterDeployer=self), self.workspace_directory, recursive=True)
# IN_CLOSE_WRITE && target/classes
self.observer.add_handler_for_watch(OnClassChangedHandler(hotterDeployer=self), w)
# self.observer.schedule(OnClassChangedHandler(hotterDeployer=self), self.workspace_directory, recursive=True)
self.livereload_server = Server()
def start(self):
import time
start_time = time.time()
LOG.debug('Starting observer...')
self.observer.start()
LOG.debug('Starting observer took {0} seconds'.format(time.time() - start_time))
from livereload import LiveReloadInfoHandler
LiveReloadInfoHandler.hotterDeployer = weakref.proxy(self)
LOG.info('Using {0}'.format('polling' if self.do_polling else 'FS events'))
LOG.info('Serving livereload on http://{host}:{port}/info'.format(**vars(self.livereload_server)))
try:
self.livereload_server.serve()
except KeyboardInterrupt:
self.observer.stop()
self.livereload_server.stop()
self.observer.join()
def __del__(self):
if os.path.exists(self.hotterdeploy_dir):
os.rmdir(self.hotterdeploy_dir)
def _scan_wd(self, directory):
self.portlets.update(scan_working_directory_for_portlet_contexts(directory))
def _update_deploys(self):
deploys = {}
if hasattr(self, '_temp_deploys'):
for name, path in self._temp_deploys.items():
deploys[name] = path
if hasattr(self, '_webapp_deploys'):
for name, path in self._webapp_deploys.items():
if name not in deploys:
deploys[name] = path
self.deploys = deploys
def _scan_temp(self):
path = os.path.join(self.tomcat_directory, 'temp')
self._temp_deploys = scan_tomcat_temporary_directory(path)
self._update_deploys()
def _scan_webapps(self):
path = os.path.join(self.tomcat_directory, 'webapps')
self._webapp_deploys = scan_tomcat_webapps_directory(path)
self._update_deploys()
def find_latest_temp_dir(self, portlet_name):
'''
Find the latest temp deploy directory for a given portlet:
e.g. 21-my-portlet-name
'''
latest_subdir = self.deploys.get(portlet_name, None)
return latest_subdir
def trigger_browser_reload(self, path=None):
LOG.debug('reloading browser')
self.livereload_server.reload(path)
class QiniuSync():
def __init__(self, paths, reg_ignore):
self.paths = paths
self.reg_ignore = reg_ignore
sys.stderr.write(self.summary())
self.generate_conf()
self.copy_ignorefile()
self.observer = Observer()
# 初次同步，生成对比库
for path in config.WATCH_PATH:
qiniu_syn(path)
self.start_watch()
# 生成配置文件
def generate_conf(self):
for path in self.paths:
# 根据路径获取文件夹名称
dir_str = get_foldername(path)
json_data = {}
json_data["src"] = str(path)
json_data["dest"] = 'qiniu:access_key=' + config.QINIU_ACCESS_KEY + \
'&secret_key=' + config.QINIU_SECRET_KEY + \
'&bucket=' + config.QINIU_BUCKET + \
'&key_prefix=' + dir_str + '/'
json_data["debug_level"] = 1
# 根据路径生成文件名
if PY2:
filename = str(hashlib.md5(path).hexdigest()) + '.json'
else:
filename = str(hashlib.md5(
path.encode("utf8")).hexdigest()) + '.json'
# 文件不存在则重新创建配置文件
if not os.path.isfile(filename):
with open(filename, 'w') as f:
f.write(json.dumps(json_data))
# 拷贝屏蔽文件到同步目录(.qrsignore.txt)
def copy_ignorefile(self):
src = open(current_dir + '\.qrsignore.txt', 'r+')
for path in self.paths:
des_path = path + '/.qrsignore.txt'
if not os.path.isfile(des_path):
des = open(des_path, 'w+')
des.writelines(src.read())
des.close()
else:
continue
src.close()
# 启动监控
def start_watch(self):
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filename='log.txt')
# 根据路径创建多个监视对象
paths = self.paths
for path in paths:
event_handler = QiniuSyncEventHandler(path, self.reg_ignore)
watch = self.observer.schedule(event_handler, path, recursive=True)
logging_handler = LoggingEventHandler()
# 为watch添加log处理程序
self.observer.add_handler_for_watch(logging_handler, watch)
self.observer.start()
self.sys_tray()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
self.observer.stop()
self.observer.join()
# 停止监控
def stop_watch(self):
self.observer.stop()
exit()
# 最小化
def sys_tray(self):
import itertools, glob
from sys_tray_icon import SysTrayIcon
# 获取图标
icons = itertools.cycle(glob.glob('*.ico'))
# 最小化显示文字
hover_text = "QiniuSync"
import ctypes
import win32con
wnd = ctypes.windll.kernel32.GetConsoleWindow()
if wnd != 0:
ctypes.windll.user32.ShowWindow(wnd, win32con.SW_HIDE)
ctypes.windll.kernel32.CloseHandle(wnd)
# 退出处理
def quit_sync():
self.stop_watch()
# 最小化到托盘
SysTrayIcon(next(icons),
hover_text,
menu_options=(),
on_quit=quit_sync,
default_menu_index=1,
wnd=wnd)
# 输出信息
def summary(self):
info = ''
info += '------------------------------------------------------\n'
info += 'QiniuSync Version : %s (python/%s)\n' % (__version__,
sys.version[:5])
info += 'Author : skywatcher\n'
info += '------------------------------------------------------\n'
return info
class Schedule:
def __init__(self, config):
self.observer = Observer()
self.handlers = {}
self.watchers = {}
self.counter = Counter()
self.notifier = Notifier(config)
self.offset_db = OffsetPersistence(config)
def __make_key(self, filename):
return path.abspath(urlsafe_b64decode(filename).decode())
def add_watcher(self, filename):
#如果监控的文件都在同一个目录下，下面这种方法只会启动一个inotify来进行监控这个目录下的所有文件，handler.start实际上调用了monitor的start
filename = self.__make_key(filename)
if handler.filename not in self.handlers.keys():
handler = Watcher(filename, counter=self.counter, notifier=self.notifier, offset_db=self.offset_db)
if path.dirname(handler.filename) not in self.watchers.keys():
self.watchers[path.dirname(handler.filename)] = self.observer.schedule(handler, path.dirname(handler.filename), recursive=False)
else:
watch = self.watchers[path.dirname(handler.filename)]
self.observer.add_handler_for_watch(handler, watch)
self.handlers[handler.filename] = handler
handler.start()
def remove_watcher(self, filename):
#判断key是否在watchers里面，有则从observer中剔除，然后从watchers字典内删除，并把handlers剔除并stop
key = self.__make_key(filename)
handler = self.handlers.pop(key)
if handler is not None:
watch = self.watchers[path.dirname(key)]
self.observer.remove_handler_for_watch(handler, watch)
handler.stop()
if not self.observer._handlers[watch]:
self.observer.unschedule(watch)
self.watchers.pop(path.dirname(handler.filename))
#添加和移除monitor，实质上就是调用Monitor类的add和remove方法来操作
def add_monitor(self, filename, name, src):
key = self.__make_key(filename)
handler = self.handlers.get(key)
if handler is None:
logging.warning('watcher {0} not found, auto add it'.format(filename))
handler.add_watcher(filename)
handler = self.handlers.get(key)
handler.monitor.add(filename, name, src)
def remove_monitor(self, filename, name):
key = self.__make_key(filename)
handler = self.handlers.get(key)
if handler is None:
logging.warning('watcher {0} not found'.format(filename))
return
handler.monitor.remove(name)
def start(self):
self.observer.start()
self.notifier.start()
def join(self):
self.observer.join()
def stop(self):
self.observer.stop()
for handler in self.handlers.values():
handler.stop()
self.notifier.stop()
self.offset_db.close()
class WatchdogTests(unittest.TestCase):
def setUp(self):
self.events = queue.Queue()
self.observer = Observer()
self.handler = EventHandler(self.events, channel_id=5)
self.watch = self.observer.schedule(event_handler=self.handler, path=TMP_DIR)
self.observer.start()
def testEventChannelID(self):
with open(TMP_FILE, "w") as local_file:
local_file.write(string_common)
event = self.events.get(block=True, timeout=1)
self.assertEqual(event.channel_id, 5)
# Modifying the file should add a new task to the queue
def testTaskInsertion(self):
new_string = "This is a whole new line in file "+filename
with open (TMP_FILE, "w") as local_file:
local_file.write(new_string)
while True:
try:
task = self.events.get(block=True, timeout=1)
except queue.Empty:
break
self.assertEqual(task.src_path,local_dir+filename)
self.assertEqual(task.dest_path, remote_dir+filename)
# It should be possible to add a new Handler to an already scheduled watch
def testHandlerAdding(self):
fake_handle="I am a fake handler, don't mind me!"
class FakeHandler(EventHandler):
def handle_modification(self, event):
self.tasks.put(fake_handle)
fake_queue = queue.Queue()
fake_handler = FakeHandler(fake_queue)
self.observer.add_handler_for_watch(fake_handler, self.watch)
new_string = "This is a whole new line in file " + filename
with open(local_dir + filename, "w") as local_file:
local_file.write(new_string)
while True:
try:
task = fake_queue.get(block=True, timeout=1)
except queue.Empty:
break
self.assertEqual(task, fake_handle)
# A Handler blocking on one event (ex: inserting into a busy queue)
# should not prevent handling of further events
def testHandlerHanging(self):
class HangingHandler(EventHandler):
def on_any_event(self, event):
print("Handler hanging...")
time.sleep(1)
print("Handler dispatching")
super().on_any_event(event)
self.observer.remove_handler_for_watch(self.handler, self.watch)
slow_handler = HangingHandler(self.events)
self.observer.add_handler_for_watch(slow_handler, self.watch)
for i in range(5):
with open(os.path.join(TMP_DIR, "f"+str(i)), "w") as local_file:
local_file.write("Write #"+str(i))
time.sleep(0.1)
time.sleep(6)
num = len(empty_tasks(self.events))
print("[Hanging] "+str(num)+" events")
self.assertTrue(num >= 5)
# Scheduling a new watch while another one is running
# In this test, each write should set off 2 events (open+close) as seen on the next test
# However watchdog is nice enough to avoid adding similar events to its internal queue
def testNewScheduling(self):
self.assertTrue(self.events.empty()) # Queue starts off
with open(remote_dir + filename, "w") as remote_file:
remote_file.write("Going once")
self.assertRaises(queue.Empty, self.events.get, timeout=1) # No Handler is watching the file yet
handler2 = EventHandler(self.events)
self.observer.schedule(event_handler=handler2, path=remote_dir, recursive=True)
with open(remote_dir + filename, "w") as remote_file:
remote_file.write("Going twice")
l1 = empty_tasks(self.events) # Now it should work
self.assertEqual(len(l1), 1) # Single event
for task in l1:
self.assertEqual(task.src_path, remote_dir + filename)
self.assertEqual(task.dest_path, local_dir + filename)
with open(local_dir + filename, "w") as local_file:
local_file.write("Going thrice") # Writing to the local file still works
l2 = empty_tasks(self.events)
self.assertEqual(len(l2), 1) # Single event
for task in l2:
self.assertEqual(task.src_path, local_dir + filename)
self.assertEqual(task.dest_path, remote_dir + filename)
# It should be possible to remove a scheduled watch
def testWatchRemoval(self):
handler2 = EventHandler(self.events)
watch2 = self.observer.schedule(event_handler=handler2, path=remote_dir, recursive=True)
for client in [ {"path":local_dir+filename, "watch":self.watch},
{"path":remote_dir+filename, "watch":watch2} ]:
with open(client["path"], "w") as file:
file.write("This will make an event")
time.sleep(0.5)
task = self.events.get(timeout=1)
self.assertEquals(task.src_path, client["path"])
self.observer.unschedule(client["watch"])
with open(local_dir+filename, "w") as local_file:
local_file.write("This won't")
self.assertRaises(queue.Empty, self.events.get, timeout=1)
# Each open() and each close() should produce an event
# They are sometimes squashed into a single event if done
# Quickly enough (i.e. "with open(file) as f: f.write()")
def testEventsPerWrite(self):
local_file = open(local_dir+filename, "w")
self.assertTrue(len(empty_tasks(self.events)) == 1) # Opening sets off an event
local_file.write("First")
self.assertTrue(len(empty_tasks(self.events)) == 0) # Writing doesn't set off an event
local_file.write("Second")
self.assertTrue(len(empty_tasks(self.events)) == 0) # Writing doesn't set off an event
local_file.close()
self.assertTrue(len(empty_tasks(self.events)) == 1) # Closing sets off an event
def testEventsForBigFileCopy(self):
self.observer.schedule(self.handler, TMP_DIR, recursive=True)
try:
os.mkdir(TMP_DIR)
except FileExistsError:
pass
try:
shutil.copy(BIG_FILE, BIG_IN)
except OSError:
self.fail()
num = empty_tasks(self.events)
print("Used "+str(len(num))+" events")
'''
指定されたパラメータでハンドラを生成します。
:param params: パラメータ
:return: ハンドラ
'''
if 'class' in params: # インスタンスの生成
module = __import__("handler",fromlist=[params['class']])
clazz = getattr(module,params['class'])
handler = clazz()
for key in params: # プロパティの設定
if 'class' != key:
setattr(handler, key, params[key])
return handler
if __name__ == "__main__":
parser = load_ini(INI_FILE)
target_dir = get_target_dir(parser)
handlers = load_handlers(parser)
observer = Observer()
for index, handler in enumerate(handlers):
if index == 0:
watch = observer.schedule(handler, target_dir, recursive=True)
else:
observer.add_handler_for_watch(handler, watch)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
uploadPicture.setDaemon(True)
uploadPicture.start()
logging.info("server is running to upload pictures to tencent.")
netDisk.setDaemon(True)
netDisk.start()
logging.info(
"server is running to providing service to baidu netdisk.")
pictureMonitor = PicturePathHandler(patterns=[
r'*.jpg', r'*.png', r'*.jpeg', r'*.gif', r'*.JPG', r'*.PNG',
r'*.JPEG', r'*.GIF'
],
ignore_patterns=[r'*.swap'],
ignore_directories=True,
case_sensitive=True)
# below code to take pyeventbus work
pictureMonitor.register(pictureMonitor)
watch = observer.schedule(pictureMonitor,
path='..//pictures',
recursive=True)
observer.add_handler_for_watch(LoggingEventHandler(), watch)
observer.start()
logging.info("start to monitor the path of picture.")
logging.info("server is ready to provide the service.")
app.run(Log)
except KeyboardInterrupt:
observer.stop()
except Exception, exc:
logging.warn('Exception happened:%s' % traceback.print_exc(),
exc_info=True)
class QiniuSync():
def __init__(self, paths, reg_ignore):
self.paths = paths
self.reg_ignore = reg_ignore
sys.stderr.write(self.summary())
self.generate_conf()
self.copy_ignorefile()
self.observer = Observer()
# 初次同步，生成对比库
for path in config.WATCH_PATH:
qiniu_syn(path)
self.start_watch()
# 生成配置文件
def generate_conf(self):
for path in self.paths:
# 根据路径获取文件夹名称
dir_str = get_foldername(path)
json_data = {}
json_data["src"] = str(path)
json_data["dest"] = 'qiniu:access_key=' + config.QINIU_ACCESS_KEY + \
'&secret_key=' + config.QINIU_SECRET_KEY + \
'&bucket=' + config.QINIU_BUCKET + \
'&key_prefix=' + dir_str + '/'
json_data["debug_level"] = 1
# 根据路径生成文件名
if PY2:
filename = str(hashlib.md5(path).hexdigest()) + '.json'
else:
filename = str(hashlib.md5(path.encode("utf8")).hexdigest()) + '.json'
# 文件不存在则重新创建配置文件
if not os.path.isfile(filename):
with open(filename, 'w') as f:
f.write(json.dumps(json_data))
# 拷贝屏蔽文件到同步目录(.qrsignore.txt)
def copy_ignorefile(self):
src = open(current_dir + '\.qrsignore.txt', 'r+')
for path in self.paths:
des_path = path + '/.qrsignore.txt'
if not os.path.isfile(des_path):
des = open(des_path, 'w+')
des.writelines(src.read())
des.close()
else:
continue
src.close()
# 启动监控
def start_watch(self):
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S', filename='log.txt')
# 根据路径创建多个监视对象
paths = self.paths
for path in paths:
event_handler = QiniuSyncEventHandler(path, self.reg_ignore)
watch = self.observer.schedule(event_handler, path, recursive=True)
logging_handler = LoggingEventHandler()
# 为watch添加log处理程序
self.observer.add_handler_for_watch(logging_handler, watch)
self.observer.start()
self.sys_tray()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
self.observer.stop()
self.observer.join()
# 停止监控
def stop_watch(self):
self.observer.stop()
exit()
# 最小化
def sys_tray(self):
import itertools, glob
from sys_tray_icon import SysTrayIcon
# 获取图标
icons = itertools.cycle(glob.glob('*.ico'))
# 最小化显示文字
hover_text = "QiniuSync"
import ctypes
import win32con
wnd = ctypes.windll.kernel32.GetConsoleWindow()
if wnd != 0:
ctypes.windll.user32.ShowWindow(wnd, win32con.SW_HIDE)
ctypes.windll.kernel32.CloseHandle(wnd)
# 退出处理
def quit_sync():
self.stop_watch()
# 最小化到托盘
if PY2:
SysTrayIcon(icons.next(), hover_text, menu_options=(), on_quit=quit_sync, default_menu_index=1, wnd=wnd)
else:
SysTrayIcon(next(icons), hover_text, menu_options=(), on_quit=quit_sync, default_menu_index=1, wnd=wnd)
# 输出信息
def summary(self):
info = ''
info += '------------------------------------------------------\n'
info += 'QiniuSync Version : %s (python/%s)\n' % (__version__, sys.version[:5])
info += 'Author : skywatcher\n'
info += '------------------------------------------------------\n'
return info
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler, LoggingEventHandler
from watchdog.observers.api import ObservedWatch
class MyHandler(FileSystemEventHandler):
def on_modified(self, event):
if event.src_path == r"C:\Users\Admin\Desktop\python monitor":
print("log file %s changed!" % event.src_path)
if __name__ == "__main__":
event_handler1 = MyHandler()
observer = Observer()
watch = observer.schedule(event_handler1, path='.', 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,
watch) # 为watch新添加一个event handler
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt: #KeyboardInterrupt 引發當用戶按下中斷程序執行
observer.stop()
observer.join()
