def __init__(self, listen_host, listen_port, server_key, server_cert, ca_cert, image_path, image_types, exec_handlers, static_paths):
websockets = WebSockets()
wm = pyinotify.WatchManager()
inotify_handler = INotifyHandler(websockets)
self._notifier = pyinotify.Notifier(wm, inotify_handler)
for image_type in image_types:
type_path = os.path.join(image_path, image_type)
wm.add_watch(type_path, pyinotify.IN_MOVED_TO)
exec_handlers = dict(x.split('=', 1) for x in (exec_handlers or []))
static_paths = dict(x.split('=', 1) for x in (static_paths or []))
http_handler = HTTPRequestHandler(image_path, image_types, exec_handlers, static_paths, websockets)
self._httpd = geventserver.WSGIServer(
(listen_host, listen_port),
http_handler,
keyfile=server_key,
certfile=server_cert,
ca_certs=ca_cert,
cert_reqs=ssl.CERT_REQUIRED,
ssl_version=ssl.PROTOCOL_TLSv1_2)
python类Notifier()的实例源码
def watch_config_changes(config_path, queues, nuimo_apps, processes, ha_api_url, ble_adapter_name):
class ModificationHandler(pyinotify.ProcessEvent):
def process_IN_CLOSE_WRITE(self, event):
if hasattr(event, 'pathname') and event.pathname == config_path:
logger.info("Config file was changed, reloading it...")
update_from_config_file(config_path, queues, nuimo_apps, processes, ha_api_url, ble_adapter_name)
handler = ModificationHandler()
watch_manager = pyinotify.WatchManager()
notifier = pyinotify.Notifier(watch_manager, handler)
# IN_CLOSE_WRITE is fired when the file was closed after modification
# in opposite to IN_MODIFY which is called for each partial write
watch_manager.add_watch(config_path, pyinotify.IN_CLOSE_WRITE)
logger.info("Listening to changes of: %s", config_path)
notifier.loop()
logger.info("Stopped listening to changes of: %s", config_path)
def run(self):
self.running = True
wm = pyinotify.WatchManager()
notifier = pyinotify.Notifier(wm)
def inotify_callback(event):
if event.mask == pyinotify.IN_CLOSE_WRITE:
self.populate_app(event.pathname)
elif event.mask == pyinotify.IN_DELETE:
with self.lock:
for cmd, data in self.apps.items():
if data[2] == event.pathname:
del self.apps[cmd]
break
for p in DESKTOP_PATHS:
if os.path.exists(p):
wm.add_watch(p,
pyinotify.IN_CLOSE_WRITE | pyinotify.IN_DELETE,
inotify_callback)
notifier.loop()
def watch(self):
# watch changes to the config file -- needs to be run in a separate thread
configStatusManager = pyinotify.WatchManager()
configStatusNotifier = pyinotify.Notifier(configStatusManager)
configStatusManager.add_watch(self.path, pyinotify.IN_CLOSE_WRITE, proc_fun=PipelinesConfigUpdateHandler(config=self))
configStatusNotifier.loop()
def watch(self):
# watch changes to the config file -- needs to be run in a separate thread
configStatusManager = pyinotify.WatchManager()
configStatusNotifier = pyinotify.Notifier(configStatusManager)
configStatusManager.add_watch(self.path, pyinotify.IN_CLOSE_WRITE, proc_fun=PipelineConfigUpdateHandler(config=self))
configStatusNotifier.loop()
def check_support():
global w_pyinotify, w_fam, w_gamin
try:
import pyinotify as w_pyinotify
except ImportError:
w_pyinotify = None
else:
try:
wm = w_pyinotify.WatchManager()
wm = w_pyinotify.Notifier(wm)
wm = None
except:
raise
w_pyinotify = None
try:
import gamin as w_gamin
except ImportError:
w_gamin = None
else:
try:
test = w_gamin.WatchMonitor()
test.disconnect()
test = None
except:
w_gamin = None
try:
import _fam as w_fam
except ImportError:
w_fam = None
else:
try:
test = w_fam.open()
test.close()
test = None
except:
w_fam = None
def wait_pyinotify(self, bld):
class PE(w_pyinotify.ProcessEvent):
def stop(self, event):
self.notif.ev = True
self.notif.stop()
raise ValueError("stop for delete")
process_IN_DELETE = stop
process_IN_CLOSE = stop
process_default = stop
proc = PE()
wm = w_pyinotify.WatchManager()
notif = w_pyinotify.Notifier(wm, proc)
proc.notif = notif
# well, we should add all the folders to watch here
for x in self.enumerate(bld.srcnode):
wm.add_watch(x, w_pyinotify.IN_DELETE | w_pyinotify.IN_CLOSE_WRITE)
try:
# pyinotify uses an infinite loop ... not too nice, so we have to use an exception
notif.loop()
except ValueError:
pass
if not hasattr(notif, 'ev'):
raise KeyboardInterrupt
def check_support():
global w_pyinotify, w_fam, w_gamin
try:
import pyinotify as w_pyinotify
except ImportError:
w_pyinotify = None
else:
try:
wm = w_pyinotify.WatchManager()
wm = w_pyinotify.Notifier(wm)
wm = None
except:
raise
w_pyinotify = None
try:
import gamin as w_gamin
except ImportError:
w_gamin = None
else:
try:
test = w_gamin.WatchMonitor()
test.disconnect()
test = None
except:
w_gamin = None
try:
import _fam as w_fam
except ImportError:
w_fam = None
else:
try:
test = w_fam.open()
test.close()
test = None
except:
w_fam = None
def wait_pyinotify(self, bld):
class PE(w_pyinotify.ProcessEvent):
def stop(self, event):
self.notif.ev = True
self.notif.stop()
raise ValueError("stop for delete")
process_IN_DELETE = stop
process_IN_CLOSE = stop
process_default = stop
proc = PE()
wm = w_pyinotify.WatchManager()
notif = w_pyinotify.Notifier(wm, proc)
proc.notif = notif
# well, we should add all the folders to watch here
for x in self.enumerate(bld.srcnode):
wm.add_watch(x, w_pyinotify.IN_DELETE | w_pyinotify.IN_CLOSE_WRITE)
try:
# pyinotify uses an infinite loop ... not too nice, so we have to use an exception
notif.loop()
except ValueError:
pass
if not hasattr(notif, 'ev'):
raise KeyboardInterrupt
def check_support():
global w_pyinotify, w_fam, w_gamin
try:
import pyinotify as w_pyinotify
except ImportError:
w_pyinotify = None
else:
try:
wm = w_pyinotify.WatchManager()
wm = w_pyinotify.Notifier(wm)
wm = None
except:
raise
w_pyinotify = None
try:
import gamin as w_gamin
except ImportError:
w_gamin = None
else:
try:
test = w_gamin.WatchMonitor()
test.disconnect()
test = None
except:
w_gamin = None
try:
import _fam as w_fam
except ImportError:
w_fam = None
else:
try:
test = w_fam.open()
test.close()
test = None
except:
w_fam = None
def _get_notifier():
'''
Check the context for the notifier and construct it if not present
'''
if 'pulsar.notifier' not in __context__:
__context__['pulsar.queue'] = collections.deque()
wm = pyinotify.WatchManager()
__context__['pulsar.notifier'] = pyinotify.Notifier(wm, _enqueue)
return __context__['pulsar.notifier']
def enable_inotify(self):
self._wm = pyinotify.WatchManager()
self._notifier = pyinotify.Notifier(self._wm, lambda *a, **b: False)
self._wm.add_watch('/dev/input', pyinotify.IN_CREATE, False)
self.daemon.get_poller().register(self._notifier._fd,
self.daemon.get_poller().POLLIN, self._inotify_cb)
def start_config_watch(self):
wm = pyinotify.WatchManager()
wm.add_watch('./config/mitmf.conf', pyinotify.IN_MODIFY)
notifier = pyinotify.Notifier(wm, self)
t = threading.Thread(name='ConfigWatcher', target=notifier.loop)
t.setDaemon(True)
t.start()
def _get_notifier():
'''
Check the context for the notifier and construct it if not present
'''
if 'pulsar.notifier' not in __context__:
__context__['pulsar.queue'] = collections.deque()
wm = pyinotify.WatchManager()
__context__['pulsar.notifier'] = pyinotify.Notifier(wm, _enqueue)
return __context__['pulsar.notifier']
def __init__(self, monitor_path, bcloud_app):
super(WatchFileChange, self).__init__()
self.setDaemon(True)
self.monitor_path = monitor_path
self.bcloud_app = bcloud_app
self.submitter = TaskSubmitter(self.bcloud_app)
self.submitter.start()
self.handler = EventHandler(self.monitor_path, self.bcloud_app,
self.submitter)
self.wm = pyinotify.WatchManager()
self.wdds = self.wm.add_watch(self.monitor_path, MASK, rec=True,
auto_add=True)
self.notifyer = pyinotify.Notifier(self.wm, self.handler)
def start_config_watch(self):
wm = pyinotify.WatchManager()
wm.add_watch('./config/mitmf.conf', pyinotify.IN_MODIFY)
notifier = pyinotify.Notifier(wm, self)
t = threading.Thread(name='ConfigWatcher', target=notifier.loop)
t.setDaemon(True)
t.start()
def run(self):
if running_on_linux()==True:
print("thread: start")
wm = pyinotify.WatchManager()
print("wathcing path",self.watch_path)
ret=wm.add_watch(self.watch_path, pyinotify.IN_CLOSE_WRITE, self.onChange,False,False)
print(ret)
print("thread: start notifyer",self.notifier)
self.notifier = pyinotify.Notifier(wm)
try:
while 1:
self.notifier.process_events()
if self.notifier.check_events():
self.notifier.read_events()
#self.notifier.loop()
except:
print("error in notify",sys.exc_info()[0])
else:
hDir = win32file.CreateFile (self.watch_path,FILE_LIST_DIRECTORY,win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE,None,win32con.OPEN_EXISTING,win32con.FILE_FLAG_BACKUP_SEMANTICS,None)
while 1:
results = win32file.ReadDirectoryChangesW (hDir,1024,True,
win32con.FILE_NOTIFY_CHANGE_FILE_NAME |
win32con.FILE_NOTIFY_CHANGE_DIR_NAME |
win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES |
win32con.FILE_NOTIFY_CHANGE_SIZE |
win32con.FILE_NOTIFY_CHANGE_LAST_WRITE |
win32con.FILE_NOTIFY_CHANGE_SECURITY,
None,
None)
for action, file in results:
full_filename = os.path.join (self.watch_path, file)
self.onChange(full_filename)
def _get_notifier():
'''
Check the context for the notifier and construct it if not present
'''
if 'pulsar.notifier' not in __context__:
__context__['pulsar.queue'] = collections.deque()
wm = pyinotify.WatchManager()
__context__['pulsar.notifier'] = pyinotify.Notifier(wm, _enqueue)
return __context__['pulsar.notifier']
def start_config_watch(self):
wm = pyinotify.WatchManager()
wm.add_watch('./config/mitmf.conf', pyinotify.IN_MODIFY)
notifier = pyinotify.Notifier(wm, self)
t = threading.Thread(name='ConfigWatcher', target=notifier.loop)
t.setDaemon(True)
t.start()
def FSMonitor(self):
wm = WatchManager()
mask = IN_DELETE_SELF | IN_ACCESS
notifier = Notifier(wm,EventHandle())
while True:
try:
notifier.process_events()
wm.add_watch(usericonPath,mask,rec=True)
if notifier.check_events():
notifier.read_events()
except KeyboardInterrupt:
notifier.stop()
break
def decrypt_to_fifo(_input, _output, _mode, _force, text=None):
def write_to_fifo(notifier):
st = os.stat(_output)
if not stat.S_ISFIFO(st.st_mode):
raise click.ClickException('%s is not a FIFO!' % _output)
if (st.st_mode & 0o777 != _mode):
raise click.ClickException('mode has changed on %s!' % _output)
if _input != '-':
f_in = open(_input, 'rb')
text = f_in.read()
f_in.close()
try:
f = open(_output, 'w')
text = decrypt_string(text)
f.write(text)
f.close()
except IOError:
pass
finally:
text = str(0x00) * len(text)
wm = pyinotify.WatchManager()
notifier = pyinotify.Notifier(wm, pyinotify.ProcessEvent)
wm.add_watch(_output, pyinotify.IN_CLOSE_NOWRITE)
notifier.loop(callback=write_to_fifo)
def start_config_watch(self):
wm = pyinotify.WatchManager()
wm.add_watch('./config/mitmf.conf', pyinotify.IN_MODIFY)
notifier = pyinotify.Notifier(wm, self)
t = threading.Thread(name='ConfigWatcher', target=notifier.loop)
t.setDaemon(True)
t.start()
def main():
watchman = pyinotify.WatchManager()
notifier = pyinotify.Notifier(watchman, INotifyHandler())
watchman.add_watch(state_fname, pyinotify.ALL_EVENTS)
notifier.loop()
def start(self):
watchPath = self.config["inputs"]
self.notifier = pyinotify.Notifier(self.wm, self.handler, timeout=10)
self.wdd = self.wm.add_watch(watchPath, self.mask, rec=False)
def watch_shakemaps_push(
working_dir, timeout=None, handler=None, daemon=False):
wm = pyinotify.WatchManager()
if daemon:
notifier = pyinotify.ThreadedNotifier(wm, handler, timeout=timeout)
else:
notifier = pyinotify.Notifier(wm, handler, timeout=timeout)
flags = pyinotify.IN_CREATE | pyinotify.IN_MODIFY | pyinotify.IN_MOVED_TO
wm.add_watch(working_dir, flags, rec=True, auto_add=True)
return notifier
def main():
(options, args) = parser.parse_args()
if None in [options.watch_dir, options.backup_dir]:
parser.print_help()
return
# ????? /
options.watch_dir = options.watch_dir.rstrip('/')
options.backup_dir = options.backup_dir.rstrip('/')
global watch_dir_name
global back_dir_name
watch_dir_name = options.watch_dir
back_dir_name = options.backup_dir
logger.info('watch dir %s' % options.watch_dir)
logger.info('back dir %s' % options.backup_dir)
if not options.disable_backup:
backup_monitor_dir(options.watch_dir, options.backup_dir)
# watch manager
wm = pyinotify.WatchManager()
wm.add_watch(options.watch_dir, pyinotify.ALL_EVENTS, rec=True)
wm.add_watch(options.backup_dir, pyinotify.ALL_EVENTS, rec=True)
# event handler
eh = FileEventHandler()
# notifier
notifier = pyinotify.Notifier(wm, eh)
notifier.loop()
def start_config_watch(self):
wm = pyinotify.WatchManager()
wm.add_watch('./config/mitmf.conf', pyinotify.IN_MODIFY)
notifier = pyinotify.Notifier(wm, self)
t = threading.Thread(name='ConfigWatcher', target=notifier.loop)
t.setDaemon(True)
t.start()
def start_config_watch(self):
wm = pyinotify.WatchManager()
wm.add_watch('./config/mitmf.conf', pyinotify.IN_MODIFY)
notifier = pyinotify.Notifier(wm, self)
t = threading.Thread(name='ConfigWatcher', target=notifier.loop)
t.setDaemon(True)
t.start()
def inotify_code_changed():
"""
Checks for changed code using inotify. After being called
it blocks until a change event has been fired.
"""
class EventHandler(pyinotify.ProcessEvent):
modified_code = None
def process_default(self, event):
if event.path.endswith('.mo'):
EventHandler.modified_code = I18N_MODIFIED
else:
EventHandler.modified_code = FILE_MODIFIED
wm = pyinotify.WatchManager()
notifier = pyinotify.Notifier(wm, EventHandler())
def update_watch(sender=None, **kwargs):
if sender and getattr(sender, 'handles_files', False):
# No need to update watches when request serves files.
# (sender is supposed to be a django.core.handlers.BaseHandler subclass)
return
mask = (
pyinotify.IN_MODIFY |
pyinotify.IN_DELETE |
pyinotify.IN_ATTRIB |
pyinotify.IN_MOVED_FROM |
pyinotify.IN_MOVED_TO |
pyinotify.IN_CREATE |
pyinotify.IN_DELETE_SELF |
pyinotify.IN_MOVE_SELF
)
for path in gen_filenames(only_new=True):
wm.add_watch(path, mask)
# New modules may get imported when a request is processed.
request_finished.connect(update_watch)
# Block until an event happens.
update_watch()
notifier.check_events(timeout=None)
notifier.read_events()
notifier.process_events()
notifier.stop()
# If we are here the code must have changed.
return EventHandler.modified_code
def _reloader_inotify(extra_files=None, interval=None):
# Mutated by inotify loop when changes occur.
changed = [False]
# Setup inotify watches
from pyinotify import WatchManager, Notifier
# this API changed at one point, support both
try:
from pyinotify import EventsCodes as ec
ec.IN_ATTRIB
except (ImportError, AttributeError):
import pyinotify as ec
wm = WatchManager()
mask = ec.IN_DELETE_SELF | ec.IN_MOVE_SELF | ec.IN_MODIFY | ec.IN_ATTRIB
def signal_changed(event):
if changed[0]:
return
_log('info', ' * Detected change in %r, reloading' % event.path)
changed[:] = [True]
for fname in extra_files or ():
wm.add_watch(fname, mask, signal_changed)
# ... And now we wait...
notif = Notifier(wm)
try:
while not changed[0]:
# always reiterate through sys.modules, adding them
for fname in _iter_module_files():
wm.add_watch(fname, mask, signal_changed)
notif.process_events()
if notif.check_events(timeout=interval):
notif.read_events()
# TODO Set timeout to something small and check parent liveliness
finally:
notif.stop()
sys.exit(3)
# currently we always use the stat loop reloader for the simple reason
# that the inotify one does not respond to added files properly. Also
# it's quite buggy and the API is a mess.
