~hdlorean-watcher/hdlorean/watcher

#

#HDLorean is free software: you can redistribute it and/or modify

#it under the terms of the GNU General Public License as published by

 

#HDLorean is distributed in the hope that it will be useful,

#but WITHOUT ANY WARRANTY; without even the implied warranty of

import os

import GlobalExceptions

from hdlogger import HDLogger

 

## @brief a handler for inotiy events

#

        __log = None

        ## contains the number of watches

        __nWatches = 0

 

 

        ## @brief takes a list of paths and adds each one to watched.

        # The handler is initialized with those sets

        # a notifier is created with the watched set and the handler

        # @see Watcher

        # @author: Jorge

                self.__logger = HDLogger.HDLogger()

                self.__log = self.__logger.setupHDLogger('hdlorean.Watcher.PyinotifyHandler')

                try:

                self.__reBlacklist = reBlacklist

                self.__parentlist = parentsList

                self.__watchedlist = watched

                self.__handler = handler

        #deprecated

        ## @brief Callback method to be notified by Watcher of the changes made in the lists

        #

                for add in added:

                        try:

                                self.addToWatched(add)

                        except GlobalExceptions.InvalidPath:

                                self.__log.error('Invald path' + add)

                for rm in removed:

                        self.removeFromWatched(rm)

                for add in parentAdded:

                        self.addParentToWatched(add)

                for rm in parentRemoved:

                        #remove from watched can be used to remove parents

                        self.removeFromWatched(rm)

 

        ## @brief adds a single path to __watched.

        #

        # then adds path to watched resources with the appropriate flags

        # @param path type=string  add the file or directoriy path to watched

        # @author Jorge

        # first of all we must know if the path exist, then if it's file or dir

        # TODO: it seems that WatchManager.add checks if the path is valid...check it

                if os.path.exists(path):

                                        EventsCodes.IN_MOVED_FROM

                                _dic = self.__watched.add_watch(path, mask, None, True, True)

                                self.__updateDictionaries(_dic,True)

                                self.__nWatches = len(self.__pathDic)

                                self.__log.debug('Addition. Number of watches = '+ repr(self.__nWatches))

                                if(self.__nWatches >= 0.8 * inotify.max_user_watches.value):

                                #TODO: refactor this if-else

                                        pass

                else:

                        raise GlobalExceptions.InvalidPath

                

 

        def startNotifier(self):

                if not(self.__notifier.isAlive()):

                        self.__notifier.start()

                else:

                        raise GlobalExceptions.NotifierRunning

        

        def stopNotifier(self):

                if self.__notifier.isAlive():

                        self.__notifier.stop()

                else:

                        raise GlobalExceptions.NotifierStopped

                        

        def removeFromWatched(self,path):

        #pyinotify don't return a dictionary of wd and paths, instead of this we obtain

        #a dictionary of wd and boolean

                if path != '':

                                        except KeyError:

                                                #borramos la entrada que da error en _wdDic

                                                deleteMe.append(key)

                        #here we proceed with the deletion of the pairs that we don't have on __wdDic nor __pathDic

                        for rm in deleteMe:

                        self.__updateDictionaries(_dic,False)

                        self.__nWatches = len(self.__pathDic)

                        self.__log.debug('Remove. Number of watches =' + repr(self.__nWatches))

        def __updateDictionaries(self,dictionary,add):

                if add:

                        self.__pathDic.update(dictionary)

                        #the next is more simple than it appears

                        # the wdDic keys are the values of dictionary

                        for key in dictionary:

                        self.addToWatched(path)

                for path in self.__parentlist:

                        self.addToWatched(path)

                        

        def update(self,mask):

                if mask == False:

                for item in self.__watchedlist: 

                        wd = self.__pathDic[item]

                        self.__watched.update_watch(wd, mask,None, True)

##

##              FOR DEBUGING PROPOSAL

##REMEMBER: This CODE has been moved into Watcher