Esempio n. 1
0
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)
Esempio n. 2
0
def main():

    upload_queue = Queue.Queue()
    thread.start_new_thread(upload_thread, (upload_queue,))

    #
    # Setup a watcher on the images folder.
    #
    wm = WatchManager()
    notifier = Notifier(wm, PTmp(upload_queue))
    wm.add_watch(BASE_FOLDER, EventsCodes.OP_FLAGS['IN_CREATE'], rec=True)

    #
    # loop forever
    #
    while True:
        try:
            #
            # process the queue of events
            #
            notifier.process_events()
            if notifier.check_events():
                #
                # read notified events and enqeue them
                #
                notifier.read_events()

        except KeyboardInterrupt:
            #
            # destroy the inotify's instance on this
            # interrupt (stop monitoring)
            #
            notifier.stop()

            #
            # Stop the upload queue.
            #
            upload_queue.put((None, None))
            break
Esempio n. 3
0
def FSMonitor(path='.'):
    wm = WatchManager()
    mask = IN_CREATE | IN_MODIFY | IN_MOVED_TO
    notifier = Notifier(wm, EventHandler())
    path = join(_env.PREFIX, 'coffee')
    for i in os.listdir(path):
        p = join(path, i)
        if not isdir(p):
            continue
        p = link_path(p)
        wm.add_watch(p, mask, rec=True)
    wm.add_watch(path, mask, rec=True)

    print '开始实时编译 COFFEE SCRIPT %s' % (path)
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 4
0
def Monitor(path):
    class PCreate(ProcessEvent):
        def process_IN_CREATE(self, event):
            f = event.name and os.path.join(event.path,
                                            event.name) or event.path
            # remove path element from entity
            item = f[len(path):]

            # start a socat instance
            socat_cmd = "socat "
            socat_cmd += path
            socat_cmd += item
            socat_cmd += " pty:,link="
            socat_cmd += ptypath
            socat_cmd += item
            socat_cmd += " &"
            os.system(socat_cmd)
            # load in a screen session
            screen_cmd = "screen -S vmware -X eval 'screen -t "
            screen_cmd += item
            screen_cmd += " -L "
            screen_cmd += ptypath
            screen_cmd += item
            screen_cmd += " 9600'"
            os.system(screen_cmd)

    wm = WatchManager()
    notifier = Notifier(wm, PCreate())
    wm.add_watch(path, pyinotify.IN_CREATE)

    try:
        while 1:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
    except KeyboardInterrupt:
        notifier.stop()
        return
Esempio n. 5
0
def start(conf):

    global_conf = conf

    wm = WatchManager()
    mask = EventsCodes.ALL_FLAGS['IN_CREATE'] | EventsCodes.ALL_FLAGS[
        'IN_MOVED_TO']

    notifier = Notifier(wm, PTmp())

    for watch_dir in conf['watch_directories']:
        watch_dir = os.path.expanduser(watch_dir)
        print("Now watching %s" % watch_dir)
        wm.add_watch(watch_dir, mask, rec=True)

    while True:
        try:
            notifier.process_events()
            if (notifier.check_events()):
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 6
0
def wait_for_vm_boot(path, timeout=300):
    wait_for_vm_boot.ks_read = False

    def proc(_):
        wait_for_vm_boot.ks_read = True

    wm = WatchManager()
    notifier = Notifier(wm, timeout=1000)
    wm.add_watch(path, mask=IN_CLOSE_NOWRITE, rec=False, proc_fun=proc)
    start_time = int(time.time())

    notifier.process_events()
    while not wait_for_vm_boot.ks_read:
        if int(time.time()) - start_time > timeout:
            break
        if notifier.check_events(
        ):  #loop in case more events appear while we are processing
            notifier.read_events()
            notifier.process_events()
    else:
        return True
    print 'Timeout {} sec occured while waiting for Master Node reboot'.format(
        timeout)
Esempio n. 7
0
def FSMonitor(path='.', deploy=None):
    """
    Monitor the path-folder,when there is a new file generated,the IN_Create event will be triggered
    :param path:the path to be monitored
    :param deploy:the object if gru-model
    :return:
    """
    wm = WatchManager()
    mask = IN_CREATE
    if deploy is None:
        logging.error('Model Uninitial!')
        return
    notifier = Notifier(wm, EventHandler(predict=deploy))
    wm.add_watch(path, mask, auto_add=True, rec=True)
    print('now starting monitor %s' % (path))
    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 8
0
    def __inotify(self):

        wm = WatchManager()
        mask = pyinotify.IN_CLOSE_WRITE

        class Process_handler(ProcessEvent):
            def __init__(self, main):

                self.main = main

            def process_IN_CLOSE_WRITE(self, event):

                for user in pwd.getpwall():
                    if user.pw_name == event.name:
                        f = open(event.path + "/" + event.name)
                        ticket = f.readlines()[0]
                        f.close()
                        self.main.tickets[user.pw_name] = {}
                        self.main.tickets[user.pw_name]["password"] = ticket
                        self.main.tickets[user.pw_name]["date"] = time.time()
                        break

        notifier = Notifier(wm, Process_handler(self))
        wdd = wm.add_watch(TicketsManager.WATCH_DIR, mask, rec=True)

        while True:
            try:

                notifier.process_events()
                if notifier.check_events():
                    notifier.read_events()

            except Exception as e:
                print(e)
                notifier.stop()

        return False
Esempio n. 9
0
    def __init__(s, nodename):
        Thread.__init__(s)

        # Init logger
        s.log = logging.getLogger('Connector-{0}'.format(s.name))

        # Init new database session
        s._sess = s.Session()

        # Init firewall tables
        s.f = Firewall(s.log, s._sess)

        # Init DNS daemon
        s.dns = DNSDaemon(s.log, s._sess)

        # Init database connection status table
        s.connections = ConnectionStatus(s.log, s._sess, nodename)

        # Make inotify watcher
        wm = WatchManager()

        ## OpenVPN status update handler
        class PUpdateStatus(ProcessEvent):

            ## Close file event method
            def process_IN_MODIFY(self, event):

                # Update status and firewall rules
                s.updateStatus()

        # Make notificator
        s.notifier = Notifier(wm, PUpdateStatus())

        # Add OpenVPN status file watcher
        wm.watch_transient_file(OPENVPN_STATUS_FILE, IN_MODIFY, PUpdateStatus)

        s._sess.close()
Esempio n. 10
0
    def enabled(self):
        if not self.running:
            wm = WatchManager()
            self.event_handler = LibraryEvent(library=app.library)

            FLAGS = [
                'IN_DELETE',
                'IN_CLOSE_WRITE',  # 'IN_MODIFY',
                'IN_MOVED_FROM',
                'IN_MOVED_TO',
                'IN_CREATE'
            ]

            masks = [
                EventsCodes.FLAG_COLLECTIONS['OP_FLAGS'][s] for s in FLAGS
            ]
            mask = reduce(operator.or_, masks, 0)

            if self.USE_THREADS:
                print_d("Using threaded notifier")
                self.notifier = ThreadedNotifier(wm, self.event_handler)
                # Daemonize to ensure thread dies on exit
                self.notifier.daemon = True
                self.notifier.start()
            else:
                self.notifier = Notifier(wm, self.event_handler, timeout=100)
                GLib.timeout_add(1000, self.unthreaded_callback)

            for path in get_scan_dirs():
                real_path = os.path.realpath(path)
                print_d('Watching directory %s for %s (mask: %x)' %
                        (real_path, FLAGS, mask))
                # See https://github.com/seb-m/pyinotify/wiki/
                # Frequently-Asked-Questions
                wm.add_watch(real_path, mask, rec=True, auto_add=True)

            self.running = True
Esempio n. 11
0
def _reloader_inotify(fnames, interval=None):
    #: Mutated by inotify loop when changes occur.
    changed = [False]

    # Setup inotify watches
    import pyinotify
    from pyinotify import WatchManager, EventsCodes, Notifier
    wm = WatchManager()
    mask = "IN_DELETE_SELF IN_MOVE_SELF IN_MODIFY IN_ATTRIB".split()
    try:
        # pyinotify 0.7
        mask = reduce(lambda m, a: m | getattr(EventsCodes, a), mask, 0)
    except AttributeError:
        # pyinotify 0.8 and up
        mask = reduce(lambda m, a: m | getattr(pyinotify, a), mask, 0)

    def signal_changed(event):
        if changed[0]:
            return
        _log('info', ' * Detected change in %r, reloading' % event.path)
        changed[:] = [True]

    for fname in fnames:
        wm.add_watch(fname, mask, signal_changed)

    # ... And now we wait...
    notif = Notifier(wm)
    try:
        while not changed[0]:
            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)
Esempio n. 12
0
            print "Recompiling %s" % outName
            call([
                "dot", "-Tpng",
                os.path.join(event.path, event.name), '-o',
                os.path.join(event.path, outName)
            ])

    def process_IN_MOVED_TO(self, event):
        #print "modify {0}, {1}".format(event.path, event.name)
        if (event.name.endswith('.dot')):
            outName = event.name.replace('.dot', '.png')
            print "Recompiling %s" % outName
            call([
                "dot", "-Tpng",
                os.path.join(event.path, event.name), '-o',
                os.path.join(event.path, outName)
            ])


notifier = Notifier(wm, PDir())
wdd = wm.add_watch('.', mask, rec=True)

while True:
    try:
        notifier.process_events()
        if notifier.check_events():
            notifier.read_events()
    except KeyboardInterrupt:
        notifier.stop()
        break
Esempio n. 13
0
File: ftp.py Progetto: SECOORA/GDAM
def main():
    logger.setLevel(logging.INFO)
    logger.addHandler(logging.StreamHandler())

    parser = argparse.ArgumentParser(
        description="Monitor a directory for new netCDF glider data and "
                    "upload the netCDF files to an FTP site."

    )
    parser.add_argument(
        "--ftp_url",
        help="Path to the glider data netCDF output directory",
        default=os.environ.get('NC2FTPURL')
    )
    parser.add_argument(
        "--ftp_user",
        help="FTP username, defaults to 'anonymous'",
        default=os.environ.get('NC2FTPUSER', 'anonymous')
    )
    parser.add_argument(
        "--ftp_pass",
        help="FTP password, defaults to an empty string",
        default=os.environ.get('NC2FTPPASS', '')
    )
    parser.add_argument(
        "-i",
        "--input",
        help="Path to the glider data netCDF output directory",
        default=os.environ.get('GDAM2NC_OUTPUT')
    )
    parser.add_argument(
        "--daemonize",
        help="To daemonize or not to daemonize",
        type=bool,
        default=False
    )

    args = parser.parse_args()

    if not args.input:
        logger.error("Please provide an --input agrument or set the "
                     "GDAM2NC_OUTPUT environmental variable")
        sys.exit(parser.print_usage())

    if not args.ftp_url:
        logger.error("Please provide an --ftp_url agrument or set the "
                     "NC2FTPURL environmental variable")
        sys.exit(parser.print_usage())

    wm = WatchManager()
    mask = IN_MOVED_TO | IN_CLOSE_WRITE
    wm.add_watch(
        args.input,
        mask,
        rec=True,
        auto_add=True
    )

    processor = GliderNc2FtpProcessor(
        ftp_url=args.ftp_url,
        ftp_user=args.ftp_user,
        ftp_pass=args.ftp_pass,
    )
    notifier = Notifier(wm, processor)

    try:
        logger.info("Watching {}\nUploading to {}".format(
            args.input,
            args.ftp_url)
        )
        notifier.loop(daemonize=args.daemonize)
    except NotifierError:
        logger.exception('Unable to start notifier loop')
        return 1

    logger.info("NC2FTP Exited Successfully")
    return 0
Esempio n. 14
0
def recon_view(pnet,
               rnet,
               onet,
               model,
               image_path,
               ip,
               margin=44,
               image_size=160):
    print('begin recon_view!!')
    with tf.Graph().as_default():
        config = tf.ConfigProto()
        with tf.Session(config=config) as sess:
            # Load the model
            facenet.load_model(model)
            # Get input and output tensors
            images_placeholder = tf.get_default_graph().get_tensor_by_name(
                "input:0")
            # embeddings:输入端的特征向量
            embeddings = tf.get_default_graph().get_tensor_by_name(
                "embeddings:0")
            phase_train_placeholder = tf.get_default_graph(
            ).get_tensor_by_name("phase_train:0")

            # 加载库中的人脸并映射成embdings
            print('加载人脸库。。。。。。')
            embding, images_label_list = face_lib.get_face_lib()
            print('读取完毕.....')

            path_exp = os.path.expanduser(image_path)
            classes = os.listdir(path_exp)
            if not len(classes) == 0:
                classes.sort()
                nrof_classes = len(classes)
                for i in range(nrof_classes):
                    images_path = os.path.join(path_exp, classes[i])
                    # get_face(sess, images_path, margin, image_size, images_placeholder, embeddings,
                    #          phase_train_placeholder, embding, images_label_list, pnet, rnet, onet)
                    if os.path.isfile(images_path):
                        get_video(sess, images_path, margin, image_size,
                                  images_placeholder, embeddings,
                                  phase_train_placeholder, embding,
                                  images_label_list, pnet, rnet, onet, ip)
                        os.remove(images_path)

            wm = WatchManager()
            mask = IN_DELETE | IN_CREATE | IN_MODIFY | IN_CLOSE_WRITE
            notifier = Notifier(
                wm,
                EventHandler(sess, image_path, margin, image_size,
                             images_placeholder, embeddings,
                             phase_train_placeholder, embding,
                             images_label_list, pnet, rnet, onet, ip))
            wm.add_watch(image_path, mask, auto_add=True, rec=True)
            print('Please input video')
            while True:
                try:
                    notifier.process_events()
                    if notifier.check_events():
                        notifier.read_events()
                except KeyboardInterrupt:
                    notifier.stop()
                    break
Esempio n. 15
0
    def __init__(self, freq=1, timeout=1, channel=channel):
        super(INotifyDriver, self).__init__(channel=channel)

        self._freq = freq
        self._wm = WatchManager()
        self._notifier = Notifier(self._wm, self._process, timeout=timeout)
Esempio n. 16
0
        if myfile in join(event.path, event.name):
            target.close()
            target = open(myfile, 'r')
            log.debug("Log file created... Catching up!")
            for line in target.readlines():
                luser = is_bad(line.rstrip())
                if (luser):
                    blocker(luser["ip"])
                    now = pendulum.now().to_atom_string()
                    log.info("Blocked {0} at {1}".format(luser["ip"], now))
                    add_block(luser["ip"], now)
            target.seek(0, 2)
        return


notifier = Notifier(WM, EventHandler())
index = myfile.rfind("/")
WM.add_watch(myfile[:index], dirmask)
last = pendulum.parse(last_run)

while True:
    try:
        now = pendulum.now()
        if now.diff(last).in_hours() > 1:
            last = now
            checkup()
        notifier.process_events()
        if notifier.check_events():
            notifier.read_events()
    except KeyboardInterrupt:
        break
Esempio n. 17
0
 def __init__(self, path):
     self.wm = WatchManager()
     mask = IN_DELETE | IN_CLOSE_WRITE
     self.notifier = Notifier(self.wm, MyProcessEvent())
     self.wm.add_watch(path, mask, rec=True)
Esempio n. 18
0
        if not os.path.exists(model_dir):
            os.makedirs(model_dir)
        package_path = f"{package_dir}/{package_file_name}"
        untar(package_path,model_dir)
        submit(package_name,model_dir)



class EventHandler(ProcessEvent):
    def process_IN_CREATE( self, event):
        print(f"Create file:{event.path} - {event.name}")
        update_package(event.path,event.name)
    
    def process_IN_DELETE( self, event):
        print(f"Delete file:{event.path} - {event.name}")

    def process_IN_MODIFY( self, event):
        print(f"Modify file:{event.path} - {event.name}")
        update_package(event.path,event.name)

    def process_IN_MOVED_TO( self, event):
        print(f"Move to file:{event.path} - {event.name}")
        update_package(event.path,event.name)

    def process_IN_MOVED_FROM( self, event):
        print(f"Move from file:{event.path} - {event.name}")


print("start loop...")
notifier = Notifier(wm, EventHandler())
notifier.loop()
Esempio n. 19
0
import os
from pyinotify import WatchManager, Notifier, ProcessEvent, IN_DELETE, IN_CREATE, IN_MODIFY

wm = WatchManager()
mask = IN_DELETE | IN_CREATE | IN_MODIFY  # watched events


class PFilePath(ProcessEvent):
    def process_IN_CREATE(self, event):
        print "Create file: %s " % os.path.join(event.path, event.name)

    def process_IN_DELETE(self, event):
        print "Delete file: %s " % os.path.join(event.path, event.name)

    def process_IN_MODIFY(self, event):
        print "Modify file: %s " % os.path.join(event.path, event.name)


if __name__ == "__main__":
    notifier = Notifier(wm, PFilePath())
    wdd = wm.add_watch('.', mask, rec=True)

    while True:
        try:
            notifier.process_events()
            if notifier.check_events():
                notifier.read_events()
        except KeyboardInterrupt:
            notifier.stop()
            break
Esempio n. 20
0
                        default=[],
                        help="Identifier for monitored files")

    #parser.add_argument("-c", "--configuration_file", dest="configuration_file",
    #                  default='noaa15_products.xml', type=str,
    #                  help="Name of the xml configuration file")

    if len(sys.argv) <= 1:
        parser.print_help()
        sys.exit()
    else:
        args = parser.parse_args()

    #Event handler observes the operations in defined folder
    wm = WatchManager()
    mask = pyinotify.IN_CREATE  # monitored events

    #message_dict = {'publish_port':args.publish_port, 'filetypes':args.filetypes, 'subject':'/Joonas/'}

    event_handler = EventHandler(args.filetypes,
                                 publish_port=args.publish_port)
    notifier = Notifier(wm, event_handler)
    for monitored_dir in args.monitored_dirs:
        wdd = wm.add_watch(monitored_dir, mask, rec=True)

#    notifier.loop(daemonize=True,\
#                    pid_file='/tmp/pyinotify.pid',\
#                    stdout='/tmp/stdout.txt')

    notifier.loop()
Esempio n. 21
0
            os.unlink(arg)
        except Exception, e:
            print e
        print "Done: %s" % arg


task_queue = Queue()
done_queue = Queue()

for i in range(PROCS):
    Process(target=worker, args=(task_queue, done_queue)).start()


class CloseEvent(ProcessEvent):
    def process_IN_CLOSE_WRITE(self, event):
        task_queue.put("%s" %  os.path.join(event.path, event.name))
        print "Received: %s" % os.path.join(event.path, event.name)

wm = WatchManager()

notifier = Notifier(wm, CloseEvent())
wdd = wm.add_watch('/data2', pyinotify.IN_CLOSE_WRITE, rec=True)
while True:  # loop forever
    try:
        notifier.process_events()
        if notifier.check_events():
            notifier.read_events()
    except KeyboardInterrupt:
        notifier.stop()
        break
Esempio n. 22
0
	content = file.read()
	os.system("rm " + tmp) #Remove temporary file.
	
	#Get the image link.
	start = content.find("<image_link>")
	end = content.find("</image_link>")
	link = content[start + 12 : end]			      
	os.system('zenity --info --text "' + link + '"')


class WatcherEvent(ProcessEvent):
	def process_IN_CREATE(self, event):
		uploadImage(os.path.join(event.path, event.name))


wm = WatchManager()

notifier = Notifier(wm, WatcherEvent())

wdd = wm.add_watch(imageDir, pyinotify.IN_CREATE, auto_add=True)

while True:
	try:
		notifier.process_events()
		if notifier.check_events():
			notifier.read_events()
	except KeyboardInterrupt:
		notifier.stop()
		break

Esempio n. 23
0
if not options.background:
    if options.verbose: print "[d] run once"
    set_status(account, grovstatus_file, options)
    sys.exit(0)

if options.verbose: print "[d] run monitoring file %s" % (grovstatus_file,)


class PClose(ProcessEvent):
    def process_IN_CLOSE(self, event):
        # wait for write to file
        time.sleep(5)
        set_status(account, grovstatus_file, options)


wm = WatchManager()
notifier = Notifier(wm, PClose())
wm.add_watch(grovstatus_file, EventsCodes.ALL_FLAGS.get('IN_CLOSE_WRITE'))
#wm.add_watch(grovstatus_file, EventsCodes.ALL_FLAGS.get('IN_CLOSE_WRITE')|EventsCodes.ALL_FLAGS.get('IN_CLOSE_NOWRITE')) 
set_status(account, grovstatus_file, options)

try:
    while 1:
        notifier.process_events()
        if notifier.check_events():
            notifier.read_events()
except KeyboardInterrupt:
    notifier.stop()


Esempio n. 24
0
def watch(directory):
    wm = WatchManager()
    notifier = Notifier(wm, EventHandler())
    wm.add_watch(directory, IN_CREATE)
    notifier.loop()
Esempio n. 25
0
    def __init__(self, channel=channel):
        super(Notify, self).__init__(channel=channel)

        self._poller = None
        self._wm = WatchManager()
        self._notifier = Notifier(self._wm, self._on_process_events)
Esempio n. 26
0
	def __init__(self, path):
		threading.Thread.__init__(self)  
		self.path = path
		self.thread_stop = False 
		self.wm = WatchManager()
		self.notifier = Notifier(self.wm, EventHandler())
Esempio n. 27
0
 def __init__(self, local_rootpath):  
     self.wm = WatchManager()  
     mask = IN_CREATE
            
     self.notifier = Notifier(self.wm, proc_evt())  
     self.wm.add_watch(local_rootpath, mask, rec = True)  
Esempio n. 28
0
def main():
    logger.setLevel(logging.INFO)
    logger.addHandler(logging.StreamHandler())
    logging.getLogger('py.warnings').setLevel(logging.ERROR)

    parser = argparse.ArgumentParser(
        description="Monitor a directory for new glider data. "
                    "Announce changes via ZMQ."
    )
    parser.add_argument(
        "-d",
        "--data_path",
        help="Path to Glider data directory",
        default=os.environ.get('GDB_DATA_DIR')
    )
    parser.add_argument(
        "--zmq_url",
        help='Port to publish ZMQ messages on. '
             'Default is "tcp://127.0.0.1:44444".',
        default=os.environ.get('ZMQ_URL', 'tcp://127.0.0.1:44444')
    )
    parser.add_argument(
        "--daemonize",
        help="To daemonize or not to daemonize",
        type=bool,
        default=False
    )

    args = parser.parse_args()

    if not args.data_path:
        logger.error("Please provide a --data_path attribute or set the GDB_DATA_DIR "
                     "environmental variable")
        sys.exit(parser.print_usage())

    monitor_path = args.data_path
    if monitor_path[-1] == '/':
        monitor_path = monitor_path[:-1]

    wm = WatchManager()
    mask = IN_MOVED_TO | IN_CLOSE_WRITE
    wm.add_watch(
        args.data_path,
        mask,
        rec=True,
        auto_add=True
    )

    processor = GliderFileProcessor(zmq_url=args.zmq_url)
    notifier = Notifier(wm, processor)

    try:
        logger.info("Watching {}\nPublishing to {}".format(
            args.data_path,
            args.zmq_url)
        )
        notifier.loop(daemonize=args.daemonize)
    except NotifierError:
        logger.exception('Unable to start notifier loop')
        return 1

    logger.info("GSPS Exited Successfully")
    return 0
Esempio n. 29
0
        raise Reload()

    def process_IN_CLOSE_WRITE(self, event):
        target = os.path.join(event.path, event.name)
        if self.regex.match(target):
            args = self.script.replace('$f', target).split()
            os.system("clear")
            sys.stdout.write("executing script: " + " ".join(args) + "\n")
            subprocess.call(args)
            sys.stdout.write("------------------------\n")


while True:
    wm = WatchManager()
    process = Process(options)
    notifier = Notifier(wm, process)
    mask = IN_DELETE | IN_CREATE | IN_CLOSE_WRITE
    wdd = wm.add_watch(options.directory, mask, rec=True)
    try:
        while True:
            print '.'
            notifier.process_events()
            print '+'
            if notifier.check_events():
                notifier.read_events()
            print '-'
    except Reload:
        pass
    except KeyboardInterrupt:
        notifier.stop()
        break
Esempio n. 30
0
    def monitor_models(self):
        try:
            now = datetime.datetime.utcnow() - datetime.timedelta(hours=16)
            logger.info("refresh monitor info from database :{}".format(now.strftime("%Y-%m-%d %H:%M:%S")))
            self.__cleanMonitorData()
            models = Model.objects.all()
        except Exception as e:
            info = "get models failed : {}".format(str(e))
            logger.error(info)
            sys.exit(1)

        try:
            for model in models:
                text = model.text
                obj = json.loads(text)
                if not "monitor" in obj:
                    continue

                user_id = model.user.uuid
                user_root = os.path.join(setting.UPLOADS_ROOT,str(user_id))
                monitor = obj["monitor"]
                status = monitor["status"]
                if status == "on":
                    data = monitor["data"]
                    for d in data:
                        d_path = d["path"]
                        d["relative_path"] = d_path
                        path = os.path.join(user_root,d_path[1:])
                        d["path"] = path
                        self.__add_monitor_folder_path(path,str(model.uuid))
                    self.__monitorData.append({
                        "id": str(model.uuid),
                        "data": data
                    })
        except Exception as e:
            logger.error("get monitor info failed:{}".format(str(e)))
            return

        try:
            mask = IN_CLOSE_WRITE
            paths = []
            if not self.__wm:
                wm = WatchManager()
                self.__wm = wm
                self.__notifier = Notifier(self.__wm, EventHandler())
                for monitorPath in self.__monitorPaths:
                    path = monitorPath["path"]
                    logger.info('now starting monitor %s' % (path))
                    paths.append(path)
                self.__watchPaths = self.__wm.add_watch(paths, mask, rec=False)
                connection.close()
                self.__timer = threading.Timer(self.__interval, self.monitor_models)
                self.__timer.start()

                while True:
                    try:
                        self.__notifier.process_events()
                        if self.__notifier.check_events():
                            self.__notifier.read_events()
                    except KeyboardInterrupt:
                        self.__notifier.stop()
                        break
            else:
                # 第二次访问,清理监听文件夹,新加入监听文件夹
                rm_paths = []
                for value in self.__watchPaths.values():
                    rm_paths.append(value)
                self.__wm.rm_watch(rm_paths)
                for monitorPath in self.__monitorPaths:
                    path = monitorPath["path"]
                    logger.info('now starting monitor %s' % (path))
                    paths.append(path)
                self.__watchPaths = self.__wm.add_watch(paths, mask, rec=False)
                connection.close()
                self.__timer = threading.Timer(self.__interval, self.monitor_models)
                self.__timer.start()
        except Exception as e:
            logger.error("run monitor failed:{}".format(str(e)))