def _assert_action_after_watcher(self, process_asap, assertions_cb):
events = []
def callback(event):
events.append(event)
import os
import time
from fsevents import Stream
from fsevents import Observer
observer = Observer(process_asap=process_asap)
observer.start()
stream = Stream(callback, self.tempdir, file_events=True)
observer.schedule(stream)
# add single file
del events[:]
f = open(os.path.join(self.tempdir, "test"), "w")
f.write("abc")
f.flush()
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
os.unlink(f.name)
assertions_cb(events, f)
def test_single_file_added_with_observer_unscheduled(self):
events = []
def callback(*args):
events.append(args)
f, path = self._make_temporary()
from fsevents import Stream
stream = Stream(callback, path)
from fsevents import Observer
observer = Observer()
observer.start()
import time
while not observer.isAlive():
time.sleep(0.1)
observer.schedule(stream)
observer.unschedule(stream)
# add single file
del events[:]
f.close()
time.sleep(0.1)
# stop and join observer
observer.stop()
observer.join()
self.assertEqual(events, [])
def test_existing_directories_are_not_reported(self):
import os
from fsevents import Stream, Observer
events = []
def callback(event):
events.append(event)
stream = Stream(callback, self.tempdir, file_events=True)
new1 = os.path.join(self.tempdir, "newdir1")
new2 = os.path.join(self.tempdir, "newdir2")
os.mkdir(new1)
observer = Observer()
observer.schedule(stream)
observer.start()
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(1)
os.mkdir(new2)
try:
time.sleep(1.1)
observer.stop()
observer.unschedule(stream)
observer.join()
from fsevents import IN_CREATE
self.assertEqual(len(events), 1)
self.assertEqual(events[0].mask, IN_CREATE)
self.assertEqual(events[0].name, os.path.realpath(new2))
finally:
os.rmdir(new1)
os.rmdir(new2)
def test_start_then_watch(self):
events = []
def callback(*args):
events.append(args)
f, path = self._make_temporary()
from fsevents import Stream
stream = Stream(callback, path)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
self.assertEqual(events, [(path, self.create_and_remove_mask)])
def test_start_no_watch(self):
events = []
def callback(*args):
events.append(args)
from fsevents import Observer
observer = Observer()
f, path = self._make_temporary()
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.join()
self.assertEqual(events, [])
def test_single_file_added_multiple_streams(self):
events = []
def callback(*args):
events.append(args)
f, path = self._make_temporary()
from fsevents import Stream
stream1 = Stream(callback, path)
stream2 = Stream(callback, path)
from fsevents import Observer
observer = Observer()
observer.schedule(stream1)
observer.schedule(stream2)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
time.sleep(0.1)
del events[:]
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream1)
observer.unschedule(stream2)
observer.join()
self.assertEquals(events[0][0], path)
self.assertEquals(events[1][0], path)
def test_start_then_watch(self):
events = []
def callback(*args):
events.append(args)
f, path = self._make_temporary()
from fsevents import Stream
stream = Stream(callback, path)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
self.assertEqual(events, [(path, self.create_and_remove_mask)])
def test_single_file_added_with_observer_unscheduled(self):
events = []
def callback(*args):
events.append(args)
f, path = self._make_temporary()
from fsevents import Stream
stream = Stream(callback, path)
from fsevents import Observer
observer = Observer()
observer.start()
import time
while not observer.isAlive():
time.sleep(0.1)
observer.schedule(stream)
observer.unschedule(stream)
# add single file
del events[:]
f.close()
time.sleep(0.1)
# stop and join observer
observer.stop()
observer.join()
self.assertEqual(events, [])
def test_existing_directories_are_not_reported(self):
import os
from fsevents import Stream, Observer
events = []
def callback(event):
events.append(event)
stream = Stream(callback, self.tempdir, file_events=True)
new1 = os.path.join(self.tempdir, "newdir1")
new2 = os.path.join(self.tempdir, "newdir2")
os.mkdir(new1)
observer = Observer()
observer.schedule(stream)
observer.start()
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(1)
os.mkdir(new2)
try:
time.sleep(1.1)
observer.stop()
observer.unschedule(stream)
observer.join()
from fsevents import IN_CREATE
self.assertEqual(len(events), 1)
self.assertEqual(events[0].mask, IN_CREATE)
self.assertEqual(events[0].name, os.path.realpath(new2))
finally:
os.rmdir(new1)
os.rmdir(new2)
def test_single_file_added_multiple_streams(self):
events = []
def callback(*args):
events.append(args)
f, path = self._make_temporary()
from fsevents import Stream
stream1 = Stream(callback, path)
stream2 = Stream(callback, path)
from fsevents import Observer
observer = Observer()
observer.schedule(stream1)
observer.schedule(stream2)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
time.sleep(0.1)
del events[:]
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream1)
observer.unschedule(stream2)
observer.join()
self.assertEquals(events, [(path, 0), (path, 0)])
def main():
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('path')
arg_parser.add_argument('-c', '--cmd', required=True, nargs='+', help='Console command for execute')
arg_parser.add_argument('-d', '--delay', type=int, default=5, nargs='?', help='Synchronization delay in seconds')
arg_parser.add_argument('-v', '--verbose', action='store_true', help='verbose flag')
try:
args = arg_parser.parse_args()
path = args.path
if not os.path.isdir(path):
raise IOError('Path `%s` is not a directory' % path)
event_handler = EventHandler()
timer = TimerInterval(callback_func, args.delay, event_handler=event_handler, cmd=args.cmd, verbose=args.verbose)
stream = Stream(event_handler.callback_handler, path, file_events=True)
observer = Observer()
observer.schedule(stream)
observer.start()
timer.start()
except IOError as e:
print e
except KeyboardInterrupt:
observer.unschedule(stream)
observer.stop()
timer.stop()
def test_single_file_added(self):
events = []
def callback(*args):
events.append(args)
f, path = self._make_temporary()
from fsevents import Observer
observer = Observer(callback, file_events=True)
observer.start()
observer.schedule(path)
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f.close()
time.sleep(1.1)
# stop and join observer
observer.stop()
observer.join()
self.assertEquals(events[0][0], path)
def run():
observer = Observer()
observer.start()
# start foreman
forerunner = Forerunner()
forerunner.start()
# call callback when files under the cwd change
stream = Stream(forerunner.callback, './', file_events=True)
observer.schedule(stream)
while True:
try:
sleep(1)
except KeyboardInterrupt:
observer.unschedule(stream)
observer.stop()
observer.join()
foreman = forerunner.foreman
for i in range(1, 10):
if foreman.poll() is not None:
break
print "sleeping... %i" % i
sleep(1)
if foreman.poll() is None:
foreman.kill()
sleep(1)
break
class Dmon:
def __init__(self, dir, handlers):
self._handlers = handlers
self._dir = dir
def _call_handler(self, method, fname):
for handler in self._handlers:
getattr(handler, method)(fname)
def _run_pyinotify(self):
from lib import pyinotify
class PyInotifyEventProcessor(pyinotify.ProcessEvent):
def __init__(self, c_handler):
self._call = c_handler
def process_IN_CREATE(self, event):
self._call('on_create', event.pathname)
def process_IN_DELETE(self, event):
self._call('on_delete', event.pathname)
def process_IN_MODIFY(self, event):
self._call('on_update', event.pathname)
wm = pyinotify.WatchManager()
self._observer = pyinotify.Notifier(wm, PyInotifyEventProcessor(self._call_handler))
mask = pyinotify.ALL_EVENTS
wm.add_watch(self._dir, mask, rec=True)
while True:
self._observer.process_events()
if self._observer.check_events():
self._observer.read_events()
time.sleep(1)
def _run_macfse(self):
from lib import fsevents
from fsevents import Stream
from fsevents import Observer
def macfse_callback(event):
if event.mask in [256, 128]:
self._call_handler('on_create', event.name)
elif event.mask in [512, 64]:
self._call_handler('on_delete', event.name)
elif event.mask == 2:
self._call_handler('on_update', event.name)
self._observer = Observer()
self._stream = Stream(macfse_callback, self._dir, file_events=True)
self._observer.schedule(self._stream)
self._observer.start()
def start(self):
if 'darwin' in sys.platform.lower():
self._run_macfse()
elif 'linux' in sys.platform.lower():
self._run_pyinotify()
def stop(self):
if 'darwin' in sys.platform.lower():
self._observer.unschedule(self._stream)
self._observer.stop()
elif 'linux' in sys.platform.lower():
self._observer.stop()
def test_since_stream(self):
events = []
def callback(*args):
events.append(args)
# two files in same directory
import os
path1 = os.path.realpath(self._make_tempdir()) + '/'
f = self._make_temporary(path1)[0]
g = self._make_temporary(path1)[0]
from fsevents import Stream, FS_FLAGHISTORYDONE
stream = Stream(callback, path1, ids = True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
#create one file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
self.assertEqual(len(events),1)
self.assertEqual(events[0][:-1], (path1, self.create_and_remove_mask))
#create a second file
g.close()
stream = Stream(callback, path1, since = events[0][2])
del events[:]
# new observer
observer = Observer()
observer.schedule(stream)
observer.start()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
self.assertEqual(len(events),2)
#FIXME: why do events arrive here in reversed order?
self.assertEqual(events[1], (path1, self.create_and_remove_mask))
self.assertEqual(events[0], (path1[:-1], FS_FLAGHISTORYDONE))
def watch_local_files():
print "Watching for changes to: {}".format(", ".join(TEMPLATES.keys()))
observer = Observer()
stream = Stream(event_callback, os.getcwd(), file_events=True)
observer.schedule(stream)
try:
observer.start()
while True:
time.sleep(86400)
except KeyboardInterrupt:
observer.stop()
def watch_local_files():
print "Watching for changes to: {}".format(", ".join(TEMPLATES.keys()))
observer = Observer()
stream = Stream(event_callback, os.getcwd(), file_events=True)
observer.schedule(stream)
try:
observer.start()
while True:
time.sleep(86400)
except KeyboardInterrupt:
observer.stop()
def main():
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('path')
arg_parser.add_argument('-c',
'--cmd',
required=True,
nargs='+',
help='Console command for execute')
arg_parser.add_argument('-d',
'--delay',
type=int,
default=5,
nargs='?',
help='Synchronization delay in seconds')
arg_parser.add_argument('-f',
'--files',
action='store_true',
help="show changed files snapshot")
arg_parser.add_argument('-v',
'--verbose',
action='store_true',
help='increase verbosity')
try:
args = arg_parser.parse_args()
path = args.path
if not os.path.isdir(path):
raise IOError('Path `%s` is not a directory' % path)
event_handler = EventHandler()
callback_params = {
'event_handler': event_handler,
'cmd': args.cmd,
'verbose': args.verbose,
'show_files': args.files
}
timer = TimerInterval(callback_func, args.delay, **callback_params)
stream = Stream(event_handler.callback_handler, path, file_events=True)
observer = Observer()
observer.schedule(stream)
observer.start()
timer.start()
except IOError as e:
print e
except KeyboardInterrupt:
observer.unschedule(stream)
observer.stop()
timer.stop()
def loop(self):
observer = Observer()
observer.schedule(self.stream)
observer.daemon = True
observer.start()
try:
while True:
# Cannot use observer.join() as it is not interrupted by
# Ctrl-C
time.sleep(10000)
finally:
observer.unschedule(self.stream)
observer.stop()
def loop(self):
observer = Observer()
observer.schedule(self.stream)
observer.daemon = True
observer.start()
try:
while True:
# Cannot use observer.join() as it is not interrupted by
# Ctrl-C
time.sleep(10000)
finally:
observer.unschedule(self.stream)
observer.stop()
def test_multiple_files_added(self):
events = []
def callback(*args):
events.append(args)
from fsevents import Observer
observer = Observer()
from fsevents import Stream
observer.start()
# wait until activation
import time
while not observer.isAlive():
time.sleep(0.1)
time.sleep(0.1)
# two files in same directory
import os
path1 = os.path.realpath(self._make_tempdir()) + '/'
f = self._make_temporary(path1)[0]
g = self._make_temporary(path1)[0]
# one file in a separate directory
path2 = os.path.realpath(self._make_tempdir()) + '/'
h = self._make_temporary(path2)[0]
stream = Stream(callback, path1, path2)
observer.schedule(stream)
try:
del events[:]
f.close()
g.close()
h.close()
time.sleep(0.2)
self.assertEqual(
sorted(events),
sorted([(path1, self.create_and_remove_mask),
(path2, self.create_and_remove_mask)]))
finally:
f.close()
g.close()
h.close()
os.rmdir(path1)
os.rmdir(path2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
def test_file_moved_to_not_watched_path(self):
import os
events = []
def callback(event):
events.append(event)
from fsevents import Stream
not_watched_path = os.path.realpath(self._make_tempdir()) + '/'
stream = Stream(callback, self.tempdir, file_events=True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(2.1)
src_name = os.path.join(self.tempdir, "test")
dst_name = os.path.join(not_watched_path, "test")
f = open(src_name, "w")
f.write("abc")
f.close()
time.sleep(1.0)
os.rename(src_name, dst_name)
time.sleep(0.1)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
os.unlink(dst_name)
os.rmdir(not_watched_path)
from fsevents import IN_CREATE, IN_MODIFY, IN_DELETE
self.assertEquals(len(events), 3)
# assert the creation events
self.assertEquals(events[0].mask, IN_CREATE)
self.assertEquals(events[0].name, os.path.realpath(src_name))
self.assertEquals(events[1].mask, IN_MODIFY)
self.assertEquals(events[1].name, os.path.realpath(src_name))
self.assertEquals(events[2].mask, IN_DELETE)
self.assertEquals(events[2].name, os.path.realpath(src_name))
def start_scanner(path):
"""
watch for file events in the supplied path
"""
try:
observer = Observer()
observer.start()
stream = Stream(file_modified, path, file_events=True)
observer.schedule(stream)
print "Watching for changes. Press Ctrl-C to stop."
while 1:
pass
except (KeyboardInterrupt, OSError, IOError):
observer.unschedule(stream)
observer.stop()
def main():
logging.basicConfig(level=logging.INFO)
load_config()
observer = Observer()
observer.setDaemon(True)
observer.start()
observer.schedule(Stream(callback, ".", file_events=True))
try:
while True:
time.sleep(10)
except KeyboardInterrupt:
pass
finally:
observer.stop()
print("")
def start_scanner(path):
"""
watch for file events in the supplied path
"""
try:
observer = Observer()
observer.start()
stream = Stream(file_modified, path, file_events=True)
observer.schedule(stream)
print "Watching for changes. Press Ctrl-C to stop."
while 1:
pass
except (KeyboardInterrupt, OSError, IOError):
observer.unschedule(stream)
observer.stop()
def main():
logging.basicConfig(level=logging.INFO)
load_config()
observer = Observer()
observer.setDaemon(True)
observer.start()
observer.schedule(Stream(callback, ".", file_events=True))
try:
while True:
time.sleep(10)
except KeyboardInterrupt:
pass
finally:
observer.stop()
print("")
def test_single_file_created_and_modified(self):
events = []
def callback(event):
events.append(event)
from fsevents import Stream
stream = Stream(callback, self.tempdir, file_events=True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(2.1)
import os
f = open(os.path.join(self.tempdir, "test"), "w")
f.write("abc")
f.flush()
time.sleep(1.0)
f.write("def")
f.flush()
f.close()
time.sleep(0.1)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
os.unlink(f.name)
from fsevents import IN_CREATE, IN_MODIFY
self.assertEquals(len(events), 3)
# assert events related to the creations
self.assertEquals(events[0].mask, IN_CREATE)
self.assertEquals(events[0].name, os.path.realpath(f.name))
self.assertEquals(events[1].mask, IN_MODIFY)
self.assertEquals(events[1].name, os.path.realpath(f.name))
# assert events related to the modify
self.assertEquals(events[2].mask, IN_MODIFY)
self.assertEquals(events[2].name, os.path.realpath(f.name))
def test_multiple_files_added(self):
events = []
def callback(*args):
events.append(args)
from fsevents import Observer
observer = Observer(callback, file_events=True)
observer.start()
# wait until activation
import time
while not observer.isAlive():
time.sleep(0.1)
time.sleep(0.1)
# two files in same directory
import os
path1 = os.path.realpath(self._make_tempdir()) + '/'
f = self._make_temporary(path1)[0]
g = self._make_temporary(path1)[0]
# one file in a separate directory
path2 = os.path.realpath(self._make_tempdir()) + '/'
h = self._make_temporary(path2)[0]
observer.schedule(path1)
observer.schedule(path2)
try:
del events[:]
f.close()
g.close()
h.close()
time.sleep(0.2)
events = [e[0] for e in events]
self.assertEqual(sorted(events), sorted([path1, path2]))
finally:
f.close()
g.close()
h.close()
os.rmdir(path1)
os.rmdir(path2)
# stop and join observer
observer.stop()
observer.unschedule(path1)
observer.unschedule(path2)
observer.join()
def loop(self):
observer = Observer()
observer.schedule(self.stream)
observer.daemon = True
observer.start()
try:
while True:
try:
# Cannot use blocking get() as it is not interrupted by
# Ctrl-C
if self.wait_queue.get(10000) is True:
self.force_restart()
except Empty:
pass
finally:
observer.unschedule(self.stream)
observer.stop()
def main():
signal.signal(signal.SIGINT, signal_handler)
parser = argparse.ArgumentParser(description='Sync files to a remote server of scp.')
parser.add_argument('path', type=str, metavar=('local', 'remote'), nargs=2,
help='path for the monitor')
args = parser.parse_args()
print args.path
observer = Observer()
stream = Stream(lambda x, y: callback(x,y, args.path[1]), args.path[0])
observer.schedule(stream)
try:
observer.start()
while True: # instead of this infinite loop, you can do
pass # whatever processing you wanted
except KeyboardInterrupt:
observer.stop()
def main():
parser = argparse.ArgumentParser(description="Refresh browser tabs when local files change.")
parser.add_argument("path", help="The directory to watch for changes.")
parser.add_argument("keyword", help="Tabs with this keyword in their URL will be refreshed.")
parser.add_argument("-b", "--browser", help="Which browser to refresh.", choices=sorted(browser_reloaders.keys()), default="chrome")
args = parser.parse_args()
print("Watching {} for changes...".format(os.path.abspath(args.path)))
event_callback_partial = partial(event_callback, browsers=(args.browser,), keyword=args.keyword)
observer = Observer()
stream = Stream(event_callback_partial, sys.argv[1], file_events=True)
observer.schedule(stream)
try:
observer.start()
while True:
time.sleep(86400)
except KeyboardInterrupt:
observer.stop()
def loop(self):
observer = Observer()
observer.schedule(self.stream)
observer.daemon = True
observer.start()
try:
while True:
try:
# Cannot use blocking get() as it is not interrupted by
# Ctrl-C
if self.wait_queue.get(10000) is True:
self.force_restart()
except Empty:
pass
finally:
observer.unschedule(self.stream)
observer.stop()
def test_single_file_created_and_modified(self):
events = []
def callback(event):
events.append(event)
from fsevents import Stream
stream = Stream(callback, self.tempdir, file_events=True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(2.1)
import os
f = open(os.path.join(self.tempdir, "test"), "w")
f.write("abc")
f.flush()
time.sleep(1.0)
f.write("def")
f.flush()
f.close()
time.sleep(0.1)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
os.unlink(f.name)
from fsevents import IN_CREATE, IN_MODIFY
self.assertEqual(len(events), 2)
self.assertEqual(events[0].mask, IN_CREATE)
self.assertEqual(events[0].name, os.path.realpath(f.name))
self.assertEqual(events[1].mask, IN_MODIFY)
self.assertEqual(events[1].name, os.path.realpath(f.name))
class MtimeFileWatcher(object):
SUPPORTS_MULTIPLE_DIRECTORIES = True
def __init__(self, directories, **kwargs):
self._changes = _changes = []
# Path to current module
module_dir = directories[0]
# Paths to watch
paths = [module_dir]
# Explicitly adding paths outside of module dir.
for path in NON_MODULE_DIRS:
paths.append(path)
self.observer = Observer()
def callback(event, mask=None):
# Get extension
try:
ext = os.path.splitext(event.name)[1]
except IndexError:
ext = None
# Add to changes if we're watching a file with this extension.
if ext in WATCHED_EXTENSIONS:
_changes.append(event.name)
self.stream = Stream(callback, file_events=True, *paths)
def start(self):
self.observer.schedule(self.stream)
self.observer.start()
def changes(self, timeout=None):
time.sleep(0.1)
changed = set(self._changes)
del self._changes[:]
return changed
def quit(self):
self.observer.unschedule(self.stream)
self.observer.stop()
self.observer.join()
class Monitor:
def __init__(self):
self.obs = Observer()
self.stream = Stream(self.callback, SOURCE_PATH, file_events=True)
def callback(self, event): #file event callback function
if event.name.endswith(VALID_SUFFIX) and os.path.isfile(event.name):
sc.upload_track(event.name)
def start(self):
print "Starting monitor..."
self.obs.start()
self.obs.schedule(self.stream)
def stop(self):
print "Stopping monitor..."
self.obs.unschedule(self.stream)
self.obs.stop()
def test_single_file_moved(self):
events = []
def callback(event):
events.append(event)
import os
f = open(os.path.join(self.tempdir, "test"), "w")
f.write("abc")
f.flush()
f.close()
from fsevents import Stream
stream = Stream(callback, self.tempdir, file_events=True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(2.1)
new = "%s.new" % f.name
os.rename(f.name, new)
time.sleep(0.1)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
os.unlink(new)
from fsevents import IN_MOVED_FROM
from fsevents import IN_MOVED_TO
self.assertEqual(len(events), 2)
self.assertEqual(events[0].mask, IN_MOVED_FROM)
self.assertEqual(events[0].name, os.path.realpath(f.name))
self.assertEqual(events[1].mask, IN_MOVED_TO)
self.assertEqual(events[1].name, os.path.realpath(new))
self.assertEqual(events[0].cookie, events[1].cookie)
def test_single_file_added_to_subdirectory(self):
events = []
def callback(*args):
events.append(args)
import os
directory = self._make_tempdir()
subdirectory = os.path.realpath(os.path.join(directory,
'subdir')) + '/'
os.mkdir(subdirectory)
import time
time.sleep(0.1)
try:
from fsevents import Stream
stream = Stream(callback, directory)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f = open(os.path.join(subdirectory, "test"), "w")
f.write("abc")
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
self.assertEqual(len(events), 1)
self.assertEqual(events, [(subdirectory, self.modified_mask)])
finally:
os.unlink(f.name)
os.rmdir(subdirectory)
os.rmdir(directory)
class Monitor: def __init__( self ): self.obs = Observer() self.stream = Stream ( self.callback, SOURCE_PATH, file_events=True ) def callback( self, event ): #file event callback function if event.name.endswith( VALID_SUFFIX ) and os.path.isfile( event.name ): sc.upload_track ( event.name ) def start( self ): print "Starting monitor..." self.obs.start() self.obs.schedule( self.stream ) def stop( self ): print "Stopping monitor..." self.obs.unschedule( self.stream ) self.obs.stop()
def test_single_file_moved(self):
events = []
def callback(event):
events.append(event)
import os
f = open(os.path.join(self.tempdir, "test"), "w")
f.write("abc")
f.flush()
f.close()
from fsevents import Stream
stream = Stream(callback, self.tempdir, file_events=True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(2.1)
new = "%s.new" % f.name
os.rename(f.name, new)
time.sleep(0.1)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
os.unlink(new)
from fsevents import IN_MOVED_FROM
from fsevents import IN_MOVED_TO
self.assertEqual(len(events), 2)
self.assertEqual(events[0].mask, IN_MOVED_FROM)
self.assertEqual(events[0].name, os.path.realpath(f.name))
self.assertEqual(events[1].mask, IN_MOVED_TO)
self.assertEqual(events[1].name, os.path.realpath(new))
self.assertEqual(events[0].cookie, events[1].cookie)
def test_single_directory_deleted(self):
events = []
def callback(event):
events.append(event)
import os
new1 = os.path.join(self.tempdir, "newdir1")
new2 = os.path.join(self.tempdir, "newdir2")
try:
os.mkdir(new1)
os.mkdir(new2)
import time
time.sleep(0.2)
from fsevents import Stream
stream = Stream(callback, self.tempdir, file_events=True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(0.1)
os.rmdir(new2)
time.sleep(1.0)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
from fsevents import IN_DELETE
self.assertEqual(len(events), 1)
self.assertEqual(events[0].mask, IN_DELETE)
self.assertEqual(events[0].name, os.path.realpath(new2))
finally:
os.rmdir(new1)
class FileSystemNotifier(object):
def __init__(self, target_dirs, callback):
self.target_dirs = target_dirs
self.callback = callback
def start(self):
self.stream = Stream(self.directory_changed, *self.target_dirs)
self.observer = Observer()
self.observer.schedule(self.stream)
self.observer.daemon = True # Kill observer when main thread killed.
self.observer.start() # start observer in the other thread.
def directory_changed(self, subpath, mask):
logging.debug('Directory changed: %s, %s' % (subpath, mask))
self.callback(subpath, mask)
def shutdown(self):
self.observer.unschedule(self.stream)
self.observer.stop()
def test_single_file_added_to_subdirectory(self):
events = []
def callback(*args):
events.append(args)
import os
directory = self._make_tempdir()
subdirectory = os.path.realpath(os.path.join(directory, 'subdir')) + '/'
os.mkdir(subdirectory)
import time
time.sleep(0.1)
try:
from fsevents import Stream
stream = Stream(callback, directory)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f = open(os.path.join(subdirectory, "test"), "w")
f.write("abc")
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
self.assertEqual(len(events), 1)
self.assertEqual(events, [(subdirectory, self.modified_mask)])
finally:
os.unlink(f.name)
os.rmdir(subdirectory)
os.rmdir(directory)
def test_single_directory_deleted(self):
events = []
def callback(event):
events.append(event)
import os
new1 = os.path.join(self.tempdir, "newdir1")
new2 = os.path.join(self.tempdir, "newdir2")
try:
os.mkdir(new1)
os.mkdir(new2)
import time
time.sleep(0.2)
from fsevents import Stream
stream = Stream(callback, self.tempdir, file_events=True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(0.1)
os.rmdir(new2)
time.sleep(1.0)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
from fsevents import IN_DELETE
self.assertEqual(len(events), 1)
self.assertEqual(events[0].mask, IN_DELETE)
self.assertEqual(events[0].name, os.path.realpath(new2))
finally:
os.rmdir(new1)
class FileSystemNotifier(object):
def __init__(self, target_dirs, callback):
self.target_dirs = target_dirs
self.callback = callback
def start(self):
self.stream = Stream(self.directory_changed, *self.target_dirs)
self.observer = Observer()
self.observer.schedule(self.stream)
self.observer.daemon = True # Kill observer when main thread killed.
self.observer.start() # start observer in the other thread.
def directory_changed(self, subpath, mask):
logging.debug('Directory changed: %s, %s' % (subpath, mask))
self.callback(subpath, mask)
def shutdown(self):
self.observer.unschedule(self.stream)
self.observer.stop()
def main():
signal.signal(signal.SIGINT, signal_handler)
parser = argparse.ArgumentParser(
description='Sync files to a remote server of scp.')
parser.add_argument('path',
type=str,
metavar=('local', 'remote'),
nargs=2,
help='path for the monitor')
args = parser.parse_args()
print args.path
observer = Observer()
stream = Stream(lambda x, y: callback(x, y, args.path[1]), args.path[0])
observer.schedule(stream)
try:
observer.start()
while True: # instead of this infinite loop, you can do
pass # whatever processing you wanted
except KeyboardInterrupt:
observer.stop()
def test_fileevent_stream(self):
events = []
def callback(*args):
events.append(args)
# two files in same directory
import os
path1 = os.path.realpath(self._make_tempdir()) + '/'
f = self._make_temporary(path1)[0]
g = self._make_temporary(path1)[0]
from fsevents import Stream, FS_CFLAGFILEEVENTS, FS_ITEMISDIR
stream = Stream(callback, path1, flags=FS_CFLAGFILEEVENTS)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
#create two files (here in the same directory)
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f.close()
g.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
import os
self.assertEqual(len(events),3)
self.assertEqual(events, [(path1[:-1], self.create_and_remove_mask|FS_ITEMISDIR),
(f.name, self.create_and_remove_mask),
(g.name, self.create_and_remove_mask)])
def test_existing_directories_are_not_reported(self):
import os
from fsevents import Observer
import time
events = []
def callback(*args):
events.append(args)
new1 = os.path.join(self.tempdir, "newdir1")
new2 = os.path.join(self.tempdir, "newdir2")
os.mkdir(new1)
time.sleep(1.0)
observer = Observer(callback, file_events=True)
observer.start()
observer.schedule(self.tempdir)
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(1)
os.mkdir(new2)
try:
time.sleep(1.1)
observer.stop()
observer.unschedule(self.tempdir)
observer.join()
from fsevents import FSE_CREATED_FLAG
from fsevents import FSE_ITEM_IS_DIR_FLAG
flags = FSE_CREATED_FLAG | FSE_ITEM_IS_DIR_FLAG
self.assertEquals(len(events), 1)
self.assertEquals(events[0][0], os.path.realpath(new2))
self.assertEquals(events[0][1], flags)
finally:
os.rmdir(new1)
os.rmdir(new2)
def main():
if len(sys.argv) != 3:
print "Usage: %s FilePath SetID" % sys.argv[0]
sys.exit(1)
path = sys.argv[1]
if not os.path.exists(path):
print "Path does not exist"
sys.exit(1)
global driver
driver = setupDriver(sys.argv[2])
observer = Observer()
stream = Stream(callback, os.path.abspath(path), file_events=True)
observer.schedule(stream)
observer.start()
print "Starting observation..."
print "Ctrl-C to exit."
try:
# yields to allow Ctrl-C to be captured
while True:
# sleep saves CPU cycles
time.sleep(1)
except KeyboardInterrupt:
print "\nQuitting program gracefully"
observer.unschedule(stream)
observer.stop()
try:
driver.quit()
except URLError:
# Some URLError
pass
sys.exit(1)
def test_single_file_deleted(self):
events = []
def callback(event):
events.append(event)
import os
f = open(os.path.join(self.tempdir, "test"), "w")
f.write("abc")
f.flush()
f.close()
from fsevents import Stream
stream = Stream(callback, self.tempdir, file_events=True)
from fsevents import Observer
observer = Observer()
observer.schedule(stream)
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
time.sleep(2.1)
os.unlink(f.name)
time.sleep(0.1)
# stop and join observer
observer.stop()
observer.unschedule(stream)
observer.join()
from fsevents import IN_DELETE
self.assertEqual(len(events), 1)
self.assertEqual(events[0].mask, IN_DELETE)
self.assertEqual(events[0].name, os.path.realpath(f.name))
def test_start_no_watch(self):
events = []
def callback(*args):
events.append(args)
from fsevents import Observer
observer = Observer()
f, path = self._make_temporary()
observer.start()
# add single file
import time
while not observer.isAlive():
time.sleep(0.1)
del events[:]
f.close()
time.sleep(0.2)
# stop and join observer
observer.stop()
observer.join()
self.assertEqual(events, [])
syncer.lock()
syncer.sync(config["path_source"], args.from_server)
syncer.release()
else:
logging.critical("--init needs --from-server or --from-local")
syncer.cleanup(True)
sys.exit(5)
# CTRL+Z will force a full sync :
signal.signal(signal.SIGTSTP, syncer.sig_handler)
observer.start()
logging.info("------- FS WATCHING %s -------" % config["path_source"])
logging.info("(CTRL+z to force a full sync)")
logging.debug("Interval %ssec", args.interval)
os.chdir(config["path_source"])
stream = Stream(syncer.callback, config["path_source"])
try:
observer.schedule(stream)
observer.join()
logging.info("Schedule finished")
except KeyboardInterrupt:
logging.warning("CTRL+c")
finally:
logging.info("Stopping observer...")
observer.stop()
logging.debug("Cleanup threads ...")
syncer.cleanup(True)
logging.info("Finished.")
class FSEventsListener(object):
def __init__(self, path, f, ignore=None):
logging.info("Using FSEvents")
self.path = path
self.f = f
self.ignore = ignore
self.observer = Observer()
self.observer.daemon = True
self._streams = []
self._streams.append(createStream(self.path, path, self._update))
self._streamed_folders = [self.path]
def add_stream(p):
if p in self._streamed_folders:
return
self._streams.append(createStream(p, file_path, self._update))
self._streamed_folders.append(p)
# Start an extra listener for all symlinks
for file_path in fileList(self.path, folders=True):
if os.path.islink(file_path):
if os.path.isdir(file_path):
add_stream(os.path.realpath(file_path))
else:
add_stream(os.path.dirname(os.path.realpath(file_path)))
def run(self):
self.resume()
self.observer.start()
def pause(self):
logging.debug("MacListener.PAUSE")
for stream in self._streams:
self.observer.unschedule(stream)
def resume(self):
logging.debug("MacListener.RESUME")
for stream in self._streams:
self.observer.schedule(stream)
def stop():
self.observer.stop()
def _update(self, event):
path = event.name
if self.ignore and self.ignore(path):
return
logging.debug("MacListener.update %s", event)
result = {
'added': [],
'deleted': [],
'changed': [],
}
if os.path.exists(path):
seconds_since_created = int(time.time()) - get_creation_time(
os.path.realpath(path))
if seconds_since_created < 1.0:
result["added"].append(path)
else:
result["changed"].append(path)
else:
result["deleted"].append(path)
self.f(result)
class MacOSFileBaseSystem(FilesystemBasic):
"""MacOS specific Filesystem."""
is_mac = True
"""Used for testing to ensure that the Filesystem does subclass this class."""
observer = None
"""The observer which is instantiated in start_events."""
@property
def real_root(self):
"""Return the realpath of the root.
fs_events paths are realpaths. i.e.: without symlinks.
"""
return os.path.realpath(self.root)
def fsevent_handler(self, path, mask, _id):
"""Handle events from fsevents, get the current directory content and update the model.
Args:
:param path: absolute path which caused this event.
:param mask: bit mask of attributes set for this event.
:param _id: internal id of the event.
:type path: string
:type mask: int
:type _id: int
..Note: The flags on these events are badly/not documented. Log the events to make
sure which flags are actualy set. Do not trust your intuition.
After preliminary checks, the path is handed to self._update, to trigger the necessary
events.
"""
event = FSEvent(path=path, mask=mask, event_id=_id)
if file_ignored(event.path):
logger.debug('Event ignored for %s', path)
return
cc_path = event.cc_path(self.real_root)
if cc_path == ['.']:
cc_path = []
logger.info('update for %s', cc_path)
try:
self._update(cc_path)
except BaseException:
logger.debug('got exception while processing FSEvents %s',
exc_info=True)
def _update(self, cc_path):
"""Inspect the directory to detect what has changed since the last call to `_update`.
Args:
:param cc_path: path of directory to update.
:type cc_path: list of strings.
"""
logger.info('_update for %s for tree %s', cc_path, self.model)
# ignore event if parent directory no longer exists on the fs
parent_folder = cc_path_to_fs(cc_path[:-1], self.real_root)
if not os.path.exists(parent_folder):
logger.debug('Event ignored: parent folder no longer exist')
return
with TreeToSyncEngineEngineAdapter(node=self.model,
storage_id=self.storage_id,
sync_engine=self._event_sink):
# Ensure that the path exists in the model.
parent = self.model
for idx, name in enumerate(cc_path):
if parent.has_child(name):
parent = parent.get_node([name])
else:
partial_cc_path = cc_path[:idx + 1]
parent = parent.add_child(
name, props=self.get_props(partial_cc_path))
directory = cc_path_to_fs(cc_path, self.real_root)
new_inodes = {
props['_inode']: (name, props)
for name, props in self.get_tree_children(cc_path)
}
old_inodes = {
node.props['_inode']: node
for node in parent.children
}
new_inodes_set = new_inodes.keys()
old_inodes_set = old_inodes.keys()
inode_intersection = new_inodes_set & old_inodes_set
removed_inodes = old_inodes_set - new_inodes_set
added_inodes = new_inodes_set - old_inodes_set
for inode in inode_intersection:
old_node = old_inodes[inode]
new_node_name, new_node_props = new_inodes[inode]
old_node.props.update(new_node_props)
old_node.name = new_node_name
for inode in removed_inodes:
# TODO: might be moved to a different dir, might be deleted
old_inodes[inode].delete()
for inode in added_inodes:
new_node_name, new_node_props = new_inodes[inode]
new_node = parent.add_child(new_node_name, new_node_props)
if new_node_props[jars.IS_DIR]:
self._update(new_node.path)
def start_events(self):
"""Setup the observer."""
self.get_tree(cached=False)
if self.observer is None:
self.observer = Observer()
stream = Stream(self.fsevent_handler, self.real_root, ids=True)
self.observer.schedule(stream)
if not self.observer.is_alive():
self.observer.start()
def stop_events(self, *args, **kwargs):
"""Call stop() on the observer."""
self.update()
if self.observer is not None:
self.observer.stop()
def clear_model(self):
"""Reset the model to only contain one root node."""
self.model = Node(None)
def get_tree(self, cached=False):
"""Return a deep copy of the internal model."""
if cached:
return copy.deepcopy(self.model)
else:
return super().get_tree(cached=False)
def update(self):
"""Update the internal model, by walking the directory structure of the root."""
self.model = self.get_tree()
def get_internal_model(self):
"""Return the current internal model, used in testing."""
return self.model
class sftpwatch:
def __init__(self,
ignore=[regexp(r'.*\.git.*'),
regexp(r'.*\.DS_Store$')],
mapping=[],
host=None,
user=None,
password=None,
rootdir=None):
self.ignore = ignore
self.PATH_MAPPING = mapping
self.host = host
self.user = user
self.password = password
self.root = rootdir
self.observer = None
self.stream = None
self.sf = None
self.connected = False
self.exit = False
try:
self.connect()
except Exception as e:
logging.critical("SSH Could not connect!")
logging.critical(str(e))
exit(1)
def connect(self):
self.sf = self.getsftp(args.host, args.user, args.password)
def watch(self):
self.observer = Observer()
self.observer.start()
self.stream = Stream(self.file_event_callback,
self.root,
file_events=True)
self.observer.schedule(self.stream)
def ssh_connect(self, hostname, username, password):
"""Connect to SSH server and return (authenticated) transport socket"""
host_keys = paramiko.util.load_host_keys(
expanduser('~/.ssh/known_hosts'))
if hostname in host_keys:
hostkeytype = host_keys[hostname].keys()[0]
hostkey = host_keys[hostname][hostkeytype]
logging.debug('Using host key of type %s' % hostkeytype)
else:
logging.critical("Host key not found")
exit(0)
t = paramiko.Transport((hostname, 22))
t.set_keepalive(30)
t.connect(hostkey, username, password)
return t
def getsftp(self, hostname, username, password):
"""Return a ready-to-roll paramiko sftp object"""
t = self.ssh_connect(hostname, username, password)
return paramiko.SFTPClient.from_transport(t)
def transfer_file(self, localpath, remotepath):
"""Transfer file over sftp"""
with self.sf.open(remotepath, 'wb') as destination:
with open(localpath, 'rb') as source:
total = 0
while True:
data = source.read(8192)
if not data:
return total
destination.write(data)
total += len(data)
def file_event_callback(self, event):
"""Respond to file events"""
# Make sure we have sftp connectivity
while not self.exit:
try:
assert not self.sf == None
self.sf.stat("/")
break
except (OSError, AssertionError) as e:
logging.warning("Attempting to connect...")
try:
self.connect()
break
except Exception as ee:
logging.warning("Could not Connect.")
logging.error("Error was: %s" % str(ee))
logging.warning("Trying again in 5 seconds...")
sleep(5)
if self.exit:
return
# check ignored
for expr in self.ignore:
if not expr.match(event.name) == None:
return
# Determine file path relative to our root
filePath = event.name.replace(self.root, "")
logging.debug("Path from basedir: %s" % filePath)
# Apply directory mapping
for mapping in self.PATH_MAPPING:
localMapPath, remoteMapPath = mapping
if filePath[0:len(localMapPath)] == localMapPath:
logging.debug("Using mapping: %s" % (str(mapping)))
filePath = remoteMapPath + "/" + filePath[len(localMapPath):]
break
filePath = normpath(filePath)
# Ensure path starts with /
if filePath[0] != "/":
filePath = "/" + filePath
if event.mask & (fsevents.IN_MODIFY | fsevents.IN_CREATE
| fsevents.IN_MOVED_TO):
logging.debug("\nFile was modified: %s" % event.name)
logging.debug("Remote path: %s" % filePath)
# Ensure directory exists
path_dirs = dirname(filePath).split("/")
for i in range(1, len(path_dirs)):
pathSegment = "/".join(path_dirs[0:i + 1])
logging.debug("stat %s" % pathSegment)
try:
self.sf.stat(pathSegment)
except IOError as e:
logging.info("Creating %s" % pathSegment)
self.sf.mkdir(pathSegment)
# If file, upload it
if isfile(event.name) or islink(event.name):
tries = 0
while True:
try:
bytesSent = self.transfer_file(event.name, filePath)
break
except IOError as ioe:
logging.error("Unable to upload file: %s" % str(ioe))
# reconnect to SSH on error
#sf.close()
#sf = getsftp(args.host, args.user, args.password)
tries += 1
sleep(0.5)
if tries > 5:
return False
logging.info(
"%s: sent %s KB to %s" %
(event.name, max(1, int(bytesSent / 1024)), filePath))
else:
logging.info("Not a file: %s" % event.name)
if event.mask & (fsevents.IN_MOVED_FROM | fsevents.IN_DELETE):
logging.info("removing %s" % filePath)
# Just delete it
try:
self.sf.remove(filePath)
except:
# Silently fail so we don't delete unexpected stuff
pass
"""
We can respond to:
done IN_MOVED_FROM - path is old file path
done IN_MOVED_TO - path is new file path
done IN_MODIFY - file was edited
done IN_CREATE - file was created
done IN_DELETE - file was deleted
IN_ATTRIB - attributes modified - ignore for now
"""
#self.sf.close()
def signal_handler(self, signal, frame):
logging.info('Cleaning up....')
self.exit = True
self.observer.unschedule(self.stream)
self.observer.stop()