def on_inotify_event(self, ev) -> None:
try:
logger.debug(
"inotify-event: name: '%s' mask: %s", ev.name,
", ".join([str(x) for x in inotify_flags.from_mask(ev.mask)]))
location = Location.join(self.location, ev.name)
if ev.mask & inotify_flags.CREATE:
self.sig_file_added.emit(self.vfs.get_fileinfo(location))
elif ev.mask & inotify_flags.DELETE:
self.sig_file_removed.emit(location)
elif ev.mask & inotify_flags.DELETE_SELF:
pass # directory itself has disappeared
elif ev.mask & inotify_flags.MOVE_SELF:
pass # directory itself has moved
elif ev.mask & inotify_flags.MODIFY or ev.mask & inotify_flags.ATTRIB:
self.sig_file_modified.emit(self.vfs.get_fileinfo(location))
elif ev.mask & inotify_flags.MOVED_FROM:
self.sig_file_removed.emit(location)
elif ev.mask & inotify_flags.MOVED_TO:
self.sig_file_added.emit(self.vfs.get_fileinfo(location))
elif ev.mask & inotify_flags.CLOSE_WRITE:
self.sig_file_closed.emit(self.vfs.get_fileinfo(location))
else:
# unhandled event
print("ERROR: Unhandled flags:")
for flag in inotify_flags.from_mask(ev.mask):
print(' ' + str(flag))
except Exception as err:
print(traceback.format_exc())
print("DirectoryWatcher:", err)
def _main():
watch_dir = "/tmp/watch_tree"
create_thread = threading.Thread(target=create_test_files,
args=(watch_dir,))
try:
os.mkdir(watch_dir)
except OSError:
pass
inotify = INotify()
watch_flags = (flags.CREATE | flags.DELETE | flags.MODIFY
| flags.DELETE_SELF | flags.ISDIR)
wd_to_path = {}
wd = inotify.add_watch(watch_dir, watch_flags)
wd_to_path[wd] = watch_dir
print("wd_to_path: ", wd_to_path)
create_thread.start()
while True:
for event in inotify.read():
path = wd_to_path[event.wd]
event_type = flags.from_mask(event.mask)
# remember dir name
if flags.ISDIR in event_type and flags.CREATE in event_type:
new_dir = os.path.join(path, event.name)
wd = inotify.add_watch(new_dir, watch_flags)
wd_to_path[wd] = new_dir
print("PATH=[{}] FILENAME=[{}] EVENT_TYPES={}"
.format(path, event.name, event_type))
def run(self, inotify: INotify, store: OrderedDict, timeout: int):
for file_path in list(store):
try:
# for now only monitor modification of files
logger.info("adding %s to watch list" % file_path)
wd = inotify.add_watch(file_path, flags.MODIFY)
watches[wd] = file_path
except FileNotFoundError:
pass
# print("watch list %s " % watches)
while self._running:
for event in inotify.read(timeout=timeout):
# print(str(event))
for flag in flags.from_mask(event.mask):
# we only watch files for modification events
if flag == flags.MODIFY:
# only if the event is for a file that we are watching for
if event.wd in watches:
file_path = watches[event.wd]
logger.debug("modify event received for %s " %
file_path)
store[
file_path] = FStatCache.get_file_stats_using_stat(
file_path)
def on_watch_event(self, event):
MASK_NEW_DIR = flags.CREATE | flags.ISDIR
if logging.getLogger().isEnabledFor(logging.DEBUG):
logger.debug('New event: %r', event)
for flag in flags.from_mask(event.mask):
logger.debug('-> flag: %s', flag)
if MASK_NEW_DIR == MASK_NEW_DIR & event.mask:
new_dir_path = join(self.wds[event.wd], event.name)
self.on_new_dir(new_dir_path)
elif flags.CLOSE_WRITE & event.mask and event.name:
# we are watching a directory and a file inside of it has been touched
logger.debug('Watching dir, file touched')
self.on_file_write(join(self.wds[event.wd], event.name))
elif flags.CLOSE_WRITE & event.mask and not event.name:
# we are watching a file
logger.debug('Watching file, file touched')
self.on_file_write(self.wds[event.wd])
elif flags.IGNORED & event.mask:
# inotify_rm_watch was called automatically
# (file/directory removed/unmounted)
path = self.wds[event.wd]
self.wds.pop(event.wd)
self.on_file_gone(path)
def process(self, event):
flags_ = flags.from_mask(event.mask)
if flags.ISDIR in flags_:
if flags.DELETE in flags_:
path = os.path.join(self.TRACKING_DIRS, event.directory.path)
if os.path.exists(path):
os.system('rm -r {}'.format(path))
else:
# TODO: add proper exception
logger_srv.error('Do not support "{}" type of operations '
.format(flags_))
raise NotImplementedError
else:
path = os.path.join(self.TRACKING_DIRS, event.directory.path,
event.name)
if flags.MODIFY in flags_:
fc.patch(path, event.diff)
elif flags.DELETE in flags_:
if os.path.exists(path):
os.system('rm {}'.format(path))
else:
# TODO: add proper exception
logger_srv.error('Do not support "{}" type of operations '
.format(flags_))
raise NotImplementedError
def run(self):
self.alive = True
try:
while self.alive == True:
for event in self.inotify.read():
if self.alive == False:
break
if event.name.endswith('.py'):
print(
'Cheguei em event.name. Name: {}, knownmodules:{}'.
format(event.name, self.known_modules))
module_name = self.path + '.' + os.path.splitext(
event.name)[0]
for flag in flags.from_mask(event.mask):
if flag.name == 'CLOSE_WRITE':
if event.name not in self.known_modules:
print('Primeira vez em known modules ({})'.
format(self.known_modules))
self.known_modules.add((event.name))
self.register.add_module(module_name)
if flag.name == 'DELETE':
# TODO: handle unload from roles / modules
pass
finally:
self.inotify.rm_watch(self.wd)
def run(self):
"""Run the event detection.
"""
if self.create_job is not None:
self.create_job.start()
timeout = self.timeout * 1000 # is in ms
n_events = 0
t_start = 0
run_loop = True
while run_loop:
events = self.inotify.read(timeout=timeout)
if t_start and not events:
run_loop = False
for event in events:
if not t_start:
t_start = time.time()
if event.wd < 0:
continue
event_type = flags.from_mask(event.mask)
if flags.OPEN in event_type:
n_events += 1
t_needed = time.time() - t_start
print("n_events {} in {} s, ({} Hz)"
.format(n_events, t_needed, n_events / t_needed))
if self.create_job is not None:
self.create_job.join()
def _main():
watch_dir = "/tmp/watch_tree"
try:
for path in watch_dir:
os.mkdir(path)
except OSError:
pass
inotify = INotify()
watch_flags = flags.CREATE | flags.DELETE | flags.MODIFY | flags.DELETE_SELF
wd_to_path = {}
wd = inotify.add_watch(watch_dir, watch_flags)
wd_to_path[wd] = watch_dir
print("wd_to_path: ", wd_to_path)
with open(os.path.join(watch_dir, "test_file"), "w"):
pass
while True:
for event in inotify.read():
path = wd_to_path[event.wd]
event_type = flags.from_mask(event.mask)
print("PATH=[{}] FILENAME=[{}] EVENT_TYPES={}".format(
path, event.name, event_type))
def on_watch_event(self, event):
MASK_NEW_DIR = flags.CREATE | flags.ISDIR
if logging.getLogger().isEnabledFor(logging.DEBUG):
logger.debug('New event: %r', event)
for flag in flags.from_mask(event.mask):
logger.debug('-> flag: %s', flag)
if MASK_NEW_DIR == MASK_NEW_DIR & event.mask:
new_dir_path = join(self.wds[event.wd], event.name)
self.on_new_dir(new_dir_path)
elif flags.CLOSE_WRITE & event.mask and event.name:
# we are watching a directory and a file inside of it has been touched
logger.debug('Watching dir, file touched')
self.on_file_write(join(self.wds[event.wd], event.name))
elif flags.CLOSE_WRITE & event.mask and not event.name:
# we are watching a file
logger.debug('Watching file, file touched')
self.on_file_write(self.wds[event.wd])
elif flags.IGNORED & event.mask:
# inotify_rm_watch was called automatically
# (file/directory removed/unmounted)
path = self.wds[event.wd]
self.wds.pop(event.wd)
self.on_file_gone(path)
def run(self, pool_name):
event = self.inotify.read()[0]
file_path = ""
print(" >>>>> event = ", event)
for flag in flags.from_mask(event.mask):
if str(flag) == "flags.CREATE" or str(flag) == "flags.MODIFY":
try:
Printer().cprint(
" **** TaskRegistrator detected a new task to be registered ... name = %s"
% event.name)
cmd, key = self.__extract_json(event.name)
file_path = self.main_path + pool_name + "/" + event.name
print(" ** DIBACA = ", file_path)
with open(file_path) as json_file:
self.data = {
"cmd": cmd,
"key": key,
"pool_name": pool_name,
"path": file_path,
"value": json.load(json_file)
}
print("Data .. DISIMPAN")
return True
except:
print(" damn .. masuk else ...")
pass
if os.path.exists(file_path):
print(" sampah! deleting ..")
os.remove(file_path)
print(" File is deleted ..")
return True
def run(self):
event = self.inotify.read()[0]
for flag in flags.from_mask(event.mask):
if str(flag) == "flags.MODIFY":
with open(self.tick_file_path) as json_file:
self.tick_data = json.load(json_file)
return True
def run(self):
logger.info(f'Watching input for {self.input_file}')
watch_flags = flags.CREATE | flags.MODIFY
self.watched = self.inotify.add_watch(self.input_file, watch_flags)
while self.running:
for event in self.inotify.read():
if flags.from_mask(event.mask) is flags.CREATE | flags.MODIFY:
self.fire_event()
def main():
inotify = INotify()
watch_flags = flags.CREATE | flags.DELETE | flags.MODIFY | flags.DELETE_SELF
wd = inotify.add_watch('/tmp', watch_flags)
for event in inotify.read():
print(event)
for flag in flags.from_mask(event.mask):
print(' ' + str(flag))
def __init__(self, event, path):
self.event = event
self.wd = event[0]
self.mask = event[1]
self.cookie = event[2]
self.name = event[3]
self.flags = flags.from_mask(self.mask)
self.parent_path = path
self.full_path = path + "/" + self.name
def __inotifyRead(self):
while self.__active:
for event in self.__inotify.read():
for flag in flags.from_mask(event.mask):
for path in self.paths:
self.emit(flag, {
'type': flag,
'path': path,
'entry': event.name
})
def run_monitor(monitored_path, slack_lambda_name, state_machine_arn):
wd_dir_map = {}
root_wd = inotify_service.add_watch(monitored_path, WATCH_FLAGS)
wd_dir_map[root_wd] = monitored_path
while 1:
for event in inotify_service.read(read_delay=500):
reported_flags = flags.from_mask(event.mask)
# we're only interested in creation events
if flags.CREATE in reported_flags or flags.MOVED_TO in reported_flags:
parent_path = wd_dir_map[
event.
wd] # map the current watch descriptor to the watched folder
current_path = os.path.join(
parent_path, event.name) # the full path of the event
# and only directory creations in the root folder (direct sub-directories)
if flags.ISDIR in reported_flags and event.wd is root_wd:
logger.info(f"New runfolder detected: {current_path}")
try:
# try add a watch for the newly created directory (runfolder)
# these watches are automatically removed when the directory is deleted
wd = inotify_service.add_watch(current_path,
WATCH_FLAGS)
wd_dir_map[wd] = current_path
except OSError as err:
notify_slack(
topic=SLACK_TOPIC,
title=event.name,
message="ERROR creating watch for new runfolder!",
lambda_name=slack_lambda_name)
notify_slack(topic=SLACK_TOPIC,
title=event.name,
message="New runfolder detected.",
lambda_name=slack_lambda_name)
# or the creation of the ready flag file
elif event.name == FLAG_FILE_NAME:
logger.info(f"New flag file detected: {current_path}")
# found a flag file, so the directory linked to the watch descriptor is the runfolder
runfolder = os.path.basename(parent_path)
notify_slack(topic=SLACK_TOPIC,
title=runfolder,
message="Runfolder ready flag detected.",
lambda_name=slack_lambda_name)
start_pipeline(state_machine_arn=state_machine_arn,
runfolder=runfolder)
# Could remove watch for this run, instead of watching it until the directory is removed
else: # Ignore other events
logger.debug(
f"Ignored CREATE/MOVE_TO event for {event.name}")
else: # Ignore event types we haven't signed up for (e.g. DELETE_SELF)
logger.debug(
f"Ignored event with flags {reported_flags} for {event.name}"
)
def main(argv: List[str]) -> None:
inotify = INotify()
watch_flags = masks.ALL_EVENTS
print("watching /tmp")
inotify.add_watch('/tmp', watch_flags)
while True:
for event in inotify.read():
print(event)
evs = [str(fl) for fl in flags.from_mask(event.mask)]
print(" " + ", ".join(evs))
def main(argv: List[str]) -> None:
inotify = INotify()
watch_flags = masks.ALL_EVENTS
print("watching /tmp")
inotify.add_watch('/tmp', watch_flags)
while True:
for event in inotify.read():
print(event)
evs = [str(fl) for fl in flags.from_mask(event.mask)]
print(" " + ", ".join(evs))
def update_watch_list(self, flags, event):
flags_concat = ''
#used to add or remove a watch on a folder
for flag in flags.from_mask(event.mask):
flags_concat = flags_concat + str(flag)
if flags_concat == "flags.CREATEflags.ISDIR":
self.create_watch_list(flags, event)
#this sectio is used to remove the entry from the watch dictionary
elif (flags_concat
== "flags.DELETEflags.ISDIR") or (flags_concat
== "flags.DELETE_SELF"):
self.delete_watch_list(flags, event)
def changed(self):
modified = saved = False
events = self.__inotify.read()
events = (e for e in events if e.name == self.__name)
flags = (f for e in events for f in Flags.from_mask(e.mask))
for flag in flags:
if flag == Flags.MODIFY:
modified = True
elif flag == Flags.CLOSE_WRITE:
saved = True
elif flag == Flags.MOVED_TO:
modified = saved = True
return modified and saved
def inotify_watch(self):
for event in self.inotify.read():
print(event.name)
flags_concat = ''
for flag in flags.from_mask(event.mask):
self.update_watch_list(flags, event)
print(' ' + str(flag))
#get the nature of the event
flags_concat = flags_concat + str(flag)
#if not re.search(".*flags.ISDIR", flags_concat):
json_data = self.json_formatter_to_kafka(event, flags_concat)
print(str(json_data))
#Kafka_producer(self.kafka_url, self.kafka_topic_name).run(json_data)
self.inotify_watch()
def config_file_listener(config_file):
# Initialize inotify object
inotify = INotify()
watch_flags = flags.MODIFY
wd = inotify.add_watch(config_file, watch_flags)
while True:
# Watch config file changes
readable, _, _ = select.select([inotify], [], [])
if inotify in readable:
for event in inotify.read():
for flag in flags.from_mask(event.mask):
logging.info("Config file changed")
# Do stuff
def read(self):
for watch, mask, _, name in self.inotify.read():
masks = flags.from_mask(mask)
pathname = self.watch_dir[watch] / name
status = None
if flags.ISDIR in masks:
if flags.CREATE in masks or flags.MOVED_TO in masks:
status = "mkdir"
else:
status = "rmdir"
elif flags.CLOSE_WRITE in masks or flags.MOVED_TO in masks:
status = "file"
yield status, pathname
def log_file_event(self, file_event):
actionable_flags = flags.from_mask((self.watchFlags ^ flags.ISDIR
^ flags.Q_OVERFLOW)
& file_event.mask)
if len(actionable_flags) > 0:
log_string = ""
for flag in actionable_flags:
log_string += str(flag)[6:] + ", "
log_string = log_string[:-2]
log_string += " " + file_event.full_path
if flags.Q_OVERFLOW & file_event.mask:
self.logger.error(log_string)
self.logger.error(
"INOTIFY QUEUE OVERFLOW DETECTED - some events may not have been logged!"
)
else:
self.logger.info(log_string)
def run(self, rollover=False):
if rollover:
self.logger.info("Tailing log file after rollover at %s" %
self.config.log_path)
else:
self.logger.info('Begin tailing log file at %s' %
self.config.log_path)
try:
with open(self.config.log_path, 'rt') as fh:
try:
inotify = INotify()
except IsADirectoryError as e:
#inotify_simple known issue
#https://github.com/chrisjbillington/inotify_simple/issues/17
self.logger.critical(
'inotify_simple version error on this kernel')
self.queue.put(PyaltEnum.INOTIFY_ERR)
return
mask = flags.MODIFY | flags.MOVE_SELF
wd = inotify.add_watch(self.config.log_path, mask)
while True:
do_break = False
for event in inotify.read():
for flag in flags.from_mask(event.mask):
if flag is flags.MOVE_SELF:
# rollover is happening
self.logfile_modified(fh)
do_break = True
elif flag is flags.MODIFY:
self.logfile_modified(fh)
if do_break:
break
except FileNotFoundError as e:
self.logger.warning(
'Log rollover did not happen quickly enough. Quick sleep then try again.'
)
time.sleep(.05)
self.run(rollover=True)
inotify.close()
self.run(rollover=True)
def log_file_event(self, file_event):
actionable_flags = flags.from_mask((self.watch_flags ^ flags.ISDIR
^ flags.Q_OVERFLOW)
& file_event.mask)
if len(actionable_flags) > 0:
log_string = ""
for flag in actionable_flags:
log_string += str(flag)[6:] + ", "
log_string = log_string[:-2]
log_string += " " + file_event.full_path
if flags.Q_OVERFLOW & file_event.mask:
self.logger.error(log_string)
self.logger.error(
"INOTIFY QUEUE OVERFLOW DETECTED - some events may not have been logged!"
)
else:
# Only log this event if we haven't logged an identical event very recently
if self.expiring_file_event_dict.get(log_string) == None:
self.expiring_file_event_dict[log_string] = True
self.logger.info(log_string)
def watch_directory(directory):
inotify = INotify()
watch_flags = flags.CREATE | flags.DELETE
logging.info(f"Starting inotify on directory: {directory}")
try:
inotify.add_watch(directory, watch_flags)
except Exception as e:
logging.error(f"{e}")
return
while True:
for event in inotify.read():
for flag in flags.from_mask(event.mask):
logging.info(f"Event on {directory}: {event.name} - {flag}")
item = {
"path": f"{directory}/{event.name}",
"action": str(flag)
}
q.put(item)
def process(self, event):
flags_ = flags.from_mask(event.mask)
# Generate path to local copy for new object to have chance
# get changes on object modify event later.
ds_path_to_new_object = \
os.path.join(self.ds_path,
event.directory.path[len(self.directory)+1:])
if flags.ISDIR in flags_:
if flags.CREATE in flags_:
copy_tree(event.directory.path, ds_path_to_new_object)
self.sender.send_directory(event.directory.path)
elif flags.DELETE in flags_:
os.system('rm -r {}'.format(ds_path_to_new_object))
self.sender.send_event(event)
else:
logger_cl.error('Can not handle "{}" event'.format(flags_))
# TODO: add proper exception
raise NotImplementedError
else:
file_path = os.path.join(event.directory.path, event.name)
ds_file_path = os.path.join(ds_path_to_new_object, event.name)
if flags.CREATE in flags_:
if not os.path.exists(ds_path_to_new_object):
os.mkdir(ds_path_to_new_object)
os.system('cp {} {}'.format(file_path, ds_file_path))
self.sender.send_file(event.directory.path, event.name)
elif flags.MODIFY in flags_:
diff = fc.diff(ds_file_path, file_path)
fc.patch(ds_file_path, diff)
event.diff = diff
self.sender.send_event(event)
elif flags.DELETE in flags_:
if os.path.exists(ds_file_path):
os.system('rm -r {}'.format(ds_file_path))
self.sender.send_event(event)
else:
# TODO: add proper exception
logger_cl.error('Can not handle "{}" event'.format(flags_))
raise NotImplementedError
def setupandloop(self):
self.inotify = INotify()
# FIXME: make flags configuratble
watch_flags = flags.CREATE | flags.DELETE | flags.CLOSE_WRITE | flags.DELETE_SELF
#watch_flags = flags.CREATE | flags.DELETE | flags.MODIFY | flags.CLOSE_WRITE | flags.DELETE_SELF
for i in self.config['watch']:
logging.debug('Watching: %s', i)
wd = self.inotify.add_watch(i, watch_flags)
# loop while run is True
while self.run:
# wait for events for 1 second
for event in self.inotify.read(timeout=1000):
print(event)
# FIXME
# id, event = '', type = 'message', ageent = '', user = ''
self.eventcallback(
lib.event.event(
self.config['instanceid'], event, 'message', '', '', {
'flags': str(flags.from_mask(event.mask)),
'event': event
}))
def beda(log, check):
inotify.add_watch(log, watch_flags)
try:
for event in inotify.read(timeout=1):
if event is not None:
for flag in flags.from_mask(event.mask):
if str(flag) == 'flags.MODIFY':
with open(log,
"r") as logFile, open(check) as checkFile:
loglines = logFile.readlines()
checklines = checkFile.readlines()
d = difflib.Differ()
diff = d.compare(loglines, checklines)
perbedaan = "".join(x[2:] for x in diff
if x.startswith('- '))
if perbedaan != "":
try:
kirim = 'ERROR TERDETEKSI:\n' + perbedaan
bot.send_message(chatId, kirim)
with open(check, "a+") as appendFile:
appendFile.write(perbedaan)
except:
print("Gagal mengirim error")
else:
pass
elif str(flag) == 'flags.MOVE_SELF':
with open(check, 'w'):
pass
elif str(flag) == 'flags.IGNORED':
print("warning")
bot.send_message(
chatId,
"Peringatan! file error.log diubah secara manual")
else:
print(str(flag))
bot.send_message(chatId, str(flag))
except:
print("error event")
inotify.rm_watch(log)
def _recognize_event_patterns(events):
move_pairs = dict()
move_pairs_tmp = dict()
all_events = []
for ev in events:
# Store the event and flags for chrono order processing.
flags = _inotify_flags.from_mask(ev.mask)
all_events.append((ev, flags))
# Form pairs for move events.
if _inotify_flags.MOVED_FROM in flags:
if ev.cookie in move_pairs_tmp:
move_pairs[ev.cookie] = ((ev, flags), move_pairs_tmp[ev.cookie])
del move_pairs_tmp[ev.cookie]
else:
move_pairs_tmp[ev.cookie] = (ev, flags)
elif _inotify_flags.MOVED_TO in flags:
if ev.cookie in move_pairs_tmp:
move_pairs[ev.cookie] = (move_pairs_tmp[ev.cookie], (ev, flags))
del move_pairs_tmp[ev.cookie]
else:
move_pairs_tmp[ev.cookie] = (ev, flags)
return move_pairs, all_events
def watch(args):
logger = setup_logger()
config = load_config(args.config)
keeplog = Keeplog(logger, config)
inotify = INotify()
watch_flags = flags.MODIFY | flags.DELETE_SELF
inotify.add_watch(config.file, watch_flags)
while True:
try:
logger.info("Watching local log file for changes")
modified = False
for event in inotify.read(timeout=config.watch_interval * 1000):
for flag in flags.from_mask(event.mask):
if flag == flags.MODIFY:
logger.info("File modified, triggering sync")
modified = True
elif flag == flags.DELETE_SELF:
logger.info("File deleted/replaced, triggering sync")
modified = True
inotify.add_watch(config.file, watch_flags)
if not modified:
logger.info("Local file unmodified, triggering scheduled sync")
time.sleep(config.watch_sync_delay)
keeplog.sync()
except KeyboardInterrupt:
logger.info("Interrupt received. Exiting.")
break
except:
logger.warning("Unexpected error:", sys.exc_info()[0])
if config.on_watch_error == "exit":
logger.warning("Exiting as per watch error strategy 'exit'.")
exit(1)
else:
logger.warning(
f"Sleeping {config.watch_interval} seconds before trying again. Events may be missed."
)
time.sleep(config.watch_interval)
def _recognize_event_patterns(events):
move_pairs = dict()
move_pairs_tmp = dict()
all_events = []
for ev in events:
# Store the event and flags for chrono order processing.
flags = _inotify_flags.from_mask(ev.mask)
all_events.append((ev, flags))
# Form pairs for move events.
if _inotify_flags.MOVED_FROM in flags:
if ev.cookie in move_pairs_tmp:
move_pairs[ev.cookie] = ((ev, flags), move_pairs_tmp[ev.cookie])
del move_pairs_tmp[ev.cookie]
else:
move_pairs_tmp[ev.cookie] = (ev, flags)
elif _inotify_flags.MOVED_TO in flags:
if ev.cookie in move_pairs_tmp:
move_pairs[ev.cookie] = (move_pairs_tmp[ev.cookie], (ev, flags))
del move_pairs_tmp[ev.cookie]
else:
move_pairs_tmp[ev.cookie] = (ev, flags)
return move_pairs, all_events
from inotify_simple import INotify, flags
os.mkdir('/tmp/inotify_test')
inotify = INotify()
watch_flags = flags.CREATE | flags.DELETE | flags.MODIFY | flags.DELETE_SELF
wd = inotify.add_watch('/tmp/inotify_test', watch_flags)
# Now create, delete and modify some files in the directory being monitored:
os.chdir('/tmp/inotify_test')
# CREATE event for a directory:
os.system('mkdir foo')
# CREATE event for a file:
os.system('echo hello > test.txt')
# MODIFY event for the file:
os.system('echo world >> test.txt')
# DELETE event for the file
os.system('rm test.txt')
# DELETE event for the directory
os.system('rmdir foo')
os.chdir('/tmp')
# DELETE_SELF on the original directory. # Also generates an IGNORED event
# indicating the watch was removed.
os.system('rmdir inotify_test')
# And see the corresponding events:
for event in inotify.read():
print(event)
for flag in flags.from_mask(event.mask):
print(' ' + str(flag))
def on_event(ev):
print(ev)
evs = [str(fl) for fl in inotify_flags.from_mask(ev.mask)]
print(" " + ", ".join(evs))
