def SvcDoRun(self): self.ReportServiceStatus(win32service.SERVICE_START_PENDING) log('starting') self.ReportServiceStatus(win32service.SERVICE_RUNNING) self.modification_handle = get_config_modification_handle( self._base_path) self.configuration_mtime = os.stat( os.path.join(self._base_path, self._config_filename)).st_mtime keep_running = True do_start = True while keep_running: # do the actual start if do_start: self.start() log('Started. Waiting for stop') index = win32event.WaitForMultipleObjects( [self.stop_event, self.modification_handle], False, win32event.INFINITE) if index == 0: # The stop event has been signaled. Stop execution. keep_running = False else: # re-initialise handle win32file.FindNextChangeNotification(self.modification_handle) new_mtime = os.stat( os.path.join(self._base_path, self._config_filename)).st_mtime if new_mtime != self.configuration_mtime: self.configuration_mtime = new_mtime do_start = True log('Restarting child processes as the configuration has changed' ) self.stop() self.config = read_config(self._base_path, self._config_filename) else: do_start = False win32file.FindCloseChangeNotification(self.modification_handle)
def watch(): """ Windows only """ import win32file, win32event, win32con watchPath = os.path.abspath(".") change_handle = win32file.FindFirstChangeNotification( watchPath, 0, win32con.FILE_NOTIFY_CHANGE_LAST_WRITE) try: while 1: result = win32event.WaitForSingleObject(change_handle, 500) if (result == win32con.WAIT_OBJECT_0): update() win32file.FindNextChangeNotification(change_handle) finally: win32file.FindCloseChangeNotification(change_handle)
def watch_win32(self, dir_to_watch): '''os-specific watch command''' # Loop forever, listing any file changes. The WaitFor... will # time out every half a second allowing for keyboard interrupts # to terminate the loop. files_added = [] old_path_contents = [] new_path_contents = [] cnt = 0 try: while 1: cnt += 1 #print 'Watching %s' % cnt #old_path_contents = os.listdir(dirToWatch) for item in dir_to_watch: change_handle = win32file.FindFirstChangeNotification( item, 0, win32con.FILE_NOTIFY_CHANGE_FILE_NAME) old_path_contents.append(os.listdir(item)) result = win32event.WaitForSingleObject(change_handle, 500) # If the WaitFor... returned because of a notification (as # opposed to timing out or some error) then look for the # changes in the directory contents. if result == win32con.WAIT_OBJECT_0: #new_path_contents = os.listdir(dirToWatch) # build the new list with all the files from all dirs for item in dir_to_watch: new_path_contents.append(os.listdir(item)) files_added = [ f for f in new_path_contents if not f in old_path_contents ] #files_deleted = [f for f in old_path_contents if not f in new_path_contents] if files_added: print() print(time.asctime()) print("Added:", files_added or "Nothing") return files_added #print "Deleted:", files_deleted or "Nothing" win32file.FindNextChangeNotification(change_handle) except KeyboardInterrupt: return []
def event_loop(self): logger.debug("Starting event notification loop") change_handle = win32file.FindFirstChangeNotification( str(self.path), 0, win32con.FILE_NOTIFY_CHANGE_LAST_WRITE) try: while self.stop_thread == False: result = win32event.WaitForSingleObject(change_handle, 500) # # If the WaitFor... returned because of a notification (as # opposed to timing out or some error) then look for the # changes in the directory contents. # if result == win32con.WAIT_OBJECT_0: self.on_event() win32file.FindNextChangeNotification(change_handle) except KeyboardInterrupt: self.stop_thread = True finally: win32file.FindCloseChangeNotification(change_handle) logger.debug("stopping notification loop")
def wait_for_beat_and_get_changed_folders(wait_period, changing_folders): returning_changed_folders = dict() # Make sure that the interval does not include milliseconds, yet still promoting # that calculations using interval can include milliseconds in their results. interval = round(wait_period, 0) this_second = current_seconds_milliseconds() max_seconds = float(int(this_second + interval)) if max_seconds > 60.0: max_seconds = 1.0 wait_for = round(interval - this_second % interval, 3) interrupter = None while (wait_for >= 60.0) or (0.0 <= this_second < max_seconds): try: interrupter = win32event.WaitForMultipleObjects( changing_folders.win32_handles, 0, int( 1000.0 * wait_for)) - win32event.WAIT_OBJECT_0 except IOError as e: if e.errno != errno.EINTR: raise except KeyboardInterrupt: return None except pywintypes.error: pass # This happens when the config folder doesn't exist this_second = current_seconds_milliseconds() if max_seconds > 59.0: max_seconds = 0.0 wait_for = round(interval - this_second % interval, 3) if interrupter is not None and interrupter < len( changing_folders.win32_handles): returning_changed_folders[changing_folders.paths[interrupter]] =\ changing_folders.callbacks[changing_folders.paths[interrupter]] win32file.FindNextChangeNotification( changing_folders.win32_handles[interrupter]) return returning_changed_folders
def monitoring_win32(self): """Watch trace directory for new files (Windows only)""" while not self.monitoring_win32_cancelled: from os.path import exists from time import sleep if not exists(self.directory): sleep(1) else: # watchdog: "Failed to import read_directory_changes. Fall back to polling" # http://code.activestate.com/recipes/156178-watching-a-directory-under-win32/ import win32file, win32event, win32con change_handle = win32file.FindFirstChangeNotification( directory, 0, win32con.FILE_NOTIFY_CHANGE_FILE_NAME) try: while self.monitoring_win32_cancelled: result = win32event.WaitForSingleObject( change_handle, 500) if result == win32con.WAIT_OBJECT_0: self.handler(*self.args, **self.kwargs) win32file.FindNextChangeNotification(change_handle) finally: win32file.FindCloseChangeNotification(change_handle)
def __Tick(self): if len(self.__watchedDirs) == 0: return changes = set() while 1: #TODO: Split wds if longer that 256 (?) - check limit for WaitForMultipleObjects wds = self.__watchedDirs.values() handles = [x.ChangeHandle for x in wds] result = win32event.WaitForMultipleObjects(handles, 0, 0) if result == win32con.STATUS_TIMEOUT: break win32file.FindNextChangeNotification(handles[result]) changes.add(wds[result]) if len(changes) > 0: L.debug( "Loader FS Watchdog discovered '%d' change(s) on filesystem" % len(changes)) for wds in changes: wds.OnChangeInDir()
def watchFile(): #setup the notifciation watchNotification = win32file.FindFirstChangeNotification(messagePath,0,win32con.FILE_NOTIFY_CHANGE_SIZE) try: while 1: #print "Watching" result = win32event.WaitForSingleObject(watchNotification, 500) #If there was a change if result == win32con.WAIT_OBJECT_0: #Read the message file readMessages(messageFile) #Start watching again for next notification win32file.FindNextChangeNotification (watchNotification) finally: #close it all down print "Closing the notification watch" win32file.FindCloseChangeNotification (watchNotification)
f for f in new_path_contents if not f in old_path_contents ] #deleted = [f for f in old_path_contents if not f in new_path_contents] #if added: print "Added: ", ", ".join (added) #if deleted: print "Deleted: ", ", ".join (deleted) # My open for item in added: #print item match_hdr = re.search(r'\.hdr$', item, re.M) if match_hdr: #print "HDR FOUND" fullfilename = os.path.join(path, item) hdr_file = open(fullfilename, 'r') #print '__________________________________\n' print "Job received on server @:", datetime.datetime.now( ), '\n' for line in hdr_file: if 'ENTITY_MODE' in line: print line, if 'ENTITY_NAME' in line: print line, if 'JOB_NAME' in line: print line, if 'PRINTER_NAME' in line: print line, if 'JOB_TOTAL_PAGES' in line: print line, if 'JOB_NB_COPY' in line: print line, print '_______________________________________\n' hdr_file.close() old_path_contents = new_path_contents win32file.FindNextChangeNotification(change_handle) finally: win32file.FindCloseChangeNotification(change_handle)
while True: # result = return value form waitfor... [ for infinite time until there were updates in the handle-path ] # result gets 0 if the return was because of a change-event. (otherwise it is an exception or some other error) result = win32event.WaitForMultipleObjects( stop_handles, 0, win32event.INFINITE ) # -> (handles, wait for one(0) / wait for all(1), event for one - infinte time) if result == win32con.WAIT_OBJECT_0: # ( if result == 0 ) 0 is the first handle in the [] # after = os.listdir(path) after = walk(path) added = [f for f in after if not f in before] if len(added) != 0: print "Added: ", ", ".join(added) for i in added: if i[-4:] == '.png' or i[-4:] == '.jpg' or i[ -4:] == '.bmp' or i[-4:] == '.ico' or i[ -4:] == '.gif': # or whatever other format :) win32file.CopyFile( i, 'D:\\Elik\\HW_Golan\\PICS\\New folder\\' + i.rsplit('\\', 1)[1], False) print "copied: ", ", ".join(added) before = after win32file.FindNextChangeNotification( changeHandle ) # same as FindFirst... but with an already existing handle elif result == win32con.WAIT_OBJECT_0 + 1: #( if result == 1 ) 1 is the first handle in the [] break win32file.FindCloseChangeNotification(changeHandle) print '++++++++++++++++++++++++\r\nstopped'
def __wait_for_client_to_open_from_lockfile(self, check_interval=3, timeout=float('inf')): import os import win32file import win32event import win32con retried = 0 path_to_watch = os.path.join(self.install_directory) if "lockfile" in os.listdir(path_to_watch): return retried # FindFirstChangeNotification sets up a handle for watching # file changes. The first parameter is the path to be # watched; the second is a boolean indicating whether the # directories underneath the one specified are to be watched; # the third is a list of flags as to what kind of changes to # watch for. We're just looking at file additions / deletions. change_handle = win32file.FindFirstChangeNotification( path_to_watch, 0, win32con.FILE_NOTIFY_CHANGE_FILE_NAME) # Loop forever, listing any file changes. The WaitFor... will # time out every N/1000 seconds allowing for keyboard interrupts # to terminate the loop. try: old_path_contents = dict([(f, None) for f in os.listdir(path_to_watch)]) while True: result = win32event.WaitForSingleObject( change_handle, check_interval * 1000) # If the WaitFor... returned because of a notification (as # opposed to timing out or some error) then look for the # changes in the directory contents. if result == win32con.WAIT_OBJECT_0: new_path_contents = dict([ (f, None) for f in os.listdir(path_to_watch) ]) added = [ f for f in new_path_contents if not f in old_path_contents ] #deleted = [f for f in old_path_contents if not f in new_path_contents] if "lockfile" in added: time.sleep( 1 ) # Wait another second for the lockfile to be written to break old_path_contents = new_path_contents win32file.FindNextChangeNotification(change_handle) retried += check_interval self.__check_systray_alive() if retried > timeout: raise TimeoutError( f"Timed out waiting for LCU to open. Waited for {retried} seconds." ) finally: win32file.FindCloseChangeNotification(change_handle) return retried