def modcommand(self, arg): # get args args = arg.split(RequestHandler.DELIM_MODCOMMAND) # check arg-count if len(args) != 2: return Result(arg, Exception('invalid arg-count for modcommand')) # get vars from args moduleName = args[0] moduleCommand = args[1] # get ModuleManager-instance moduleManager = Activator().getInstance('ModuleManager') # call command data = moduleManager.moduleCommand(moduleName, moduleCommand) # if data is none, return none if data is None: return None # return result return Result(data, None)
def reloadModules(self, args): # get ModuleManager-instance moduleManager = Activator().getInstance('ModuleManager') # get Dispatcher-instance dispatcher = Activator().getInstance('Dispatcher') # stop ModuleManager if running try: if moduleManager.isModuleRunning(): # stop moduleManager.stopModule() # check if we got a running module tries = 0 triesMax = 75 nap = 0.2 isRunning = True while isRunning and tries < triesMax: time.sleep(nap) tries += 1 isRunning = moduleManager.isModuleRunning() if isRunning: raise Exception, "Modules running after %d seconds" % (triesMax * nap) except Exception, e: self.logger.error("Error when stopping ModuleManager (%s)" % (e)) # return result return Result('Error when stopping ModuleManager', e)
def invoke(self): # invocation-count self.runCount += 1 try: # get Fluxcli instance fluxcli = Activator().getInstance('Fluxcli') # process jobs jobCopy = self.jobs[:] for job in jobCopy: # build arg-array args = [] args.append('rss') args.append(job['savedir']) args.append('%s%s.dat' % (self.dataDir, job['filtername'])) args.append('%s%s.hist' % (self.dataDir, job['filtername'])) args.append(job['url']) # execute job try: # log run self.logger.debug('running rssad-job: %s' % job.__str__()) # invoke fluxcli result = fluxcli.invoke(args, True).strip() # log result self.logger.debug('rssad-run-result:\n%s' % result) except Exception, e: self.logger.error("Error when calling rssad (%s)" % (e)) # return return True
def transferStart(name): # imports from fluxd.activator.Activator import Activator # get Fluxcli-instance fluxcli = Activator().getInstance('Fluxcli') # invoke fluxcli try: # invoke and return return fluxcli.invoke(['start', name], True).strip() except Exception, e: raise Exception, "Exception when invoking fluxcli to start transfer %s (%s)" % (name, e)
class BasicModule(IModule): # lock InstanceLock = Lock() """ -------------------------------------------------------------------- """ """ __init__ """ """ -------------------------------------------------------------------- """ def __init__(self, name, *p, **k): # set name self.name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger(self.name) # request-handler self.requestHandler = None # onStop-delegates self.onStopDelegates = [] # running-flag self.running = False # listener-thread self.thread = Thread(target = self.run) self.thread.setName(self.name) self.thread.setDaemon(True) """ -------------------------------------------------------------------- """ """ run """ """ -------------------------------------------------------------------- """ def run(self): # log self.logger.info("up and running") # running-flag self.running = True # module-main try: self.main() except Exception, e: if self.running: self.logger.error("Exception in Module-Thread (%s)" % (e)) # shutdown self.shutdown()
def modstate(self, args): # mod-name module = args[0].strip() # get ModuleManager-instance moduleManager = Activator().getInstance('ModuleManager') mstate = '0' if moduleManager.isModuleRunning(module): mstate = '1' # return result return Result(mstate, None)
def __init__(self, name): # set name self.__name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('Dispatcher') # onStop-delegates self.__onStopDelegates = [] # request-queue self.__queueRequest = Queue() # request-handler self.__requestHandler = RequestHandler(self.logger) # running-flag self.__running = False # request-count self.requestCount = 0 # thread self.__thread = Thread(target = self.run) self.__thread.setName(self.__name) self.__thread.setDaemon(True)
def __init__(self, name): # set name self.__name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('ModuleManager')
def __init__(self, name, address, socket, requestHandler, onCloseDelegate = None): # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('RequestDispatcher') # set name self.__name = name # set address self.__address = address # set socket self.__socket = socket # request-handler self.__requestHandler = requestHandler # onClose-delegates self.__onCloseDelegates = [] if not onCloseDelegate is None: self.__onCloseDelegates.append(onCloseDelegate) # result-queue self.__queueResult = Queue() # done-flag self.__done = False # running-flag self.__running = False # thread self.__thread = Thread(target = self.run) self.__thread.setName(self.__name) self.__thread.setDaemon(True)
class DatabaseManager(IActivator): # instance Instance = None # lock InstanceLock = Lock() """ -------------------------------------------------------------------- """ """ __new__ """ """ -------------------------------------------------------------------- """ def __new__(cls, *p, **k): if DatabaseManager.Instance is None: DatabaseManager.Instance = object.__new__(cls, *p, **k) return DatabaseManager.Instance """ -------------------------------------------------------------------- """ """ __init__ """ """ -------------------------------------------------------------------- """ def __init__(self, name): # set name self.__name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('DatabaseManager') # settings self.settings = {} """ -------------------------------------------------------------------- """ """ getName """ """ -------------------------------------------------------------------- """ def getName(self): return self.__name """ -------------------------------------------------------------------- """ """ getSetting """ """ -------------------------------------------------------------------- """ def getSetting(self, key): try: return self.settings[key] except Exception, e: self.logger.error("Exception in getSetting: %s" % (e)) raise Exception, "Failed to get Setting: %s" % (key)
def modstop(self, args): # mod-name module = args[0].strip() # get ModuleManager-instance moduleManager = Activator().getInstance('ModuleManager') # check if running if not moduleManager.isModuleRunning(module): return Result('Module not running: %s' % module, None) # stop it try: moduleManager.stopModule(module) except Exception, e: # return result return Result('Error when stopping Module: %s' % module, e)
def invoke(self): # invocation-count self.runCount += 1 try: # get Fluxcli instance fluxcli = Activator().getInstance("Fluxcli") # process jobs jobCopy = self.jobs[:] for job in jobCopy: # build arg-array args = [] args.append("watch") args.append(job["D"]) # watchdir args.append(job["U"]) # user if job.has_key("A"): # action action = job["A"] else: action = "ds" extraargs = [] if job.has_key("P"): # profile action += "p" extraargs.append(job["P"]) args.append(action) args += extraargs # execute job try: # log run self.logger.debug("running watch-job: %s" % job.__str__()) # invoke fluxcli result = fluxcli.invoke(args, True).strip() # log result self.logger.debug("watch-run-result:\n%s" % result) except Exception, e: self.logger.error("Error when calling watch (%s)" % (e)) # return return True
def __init__(self, name): # set name self.__name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('Fluxcli') # invocation-Count self.invocationCount = 0
def __init__(self, name): # set name self.__name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('DatabaseManager') # settings self.settings = {}
def __init__(self): # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('DataAdapterADOdb') # db-config self.dbConfig = None # connection self.connection = None
def invoke(self): # invocation-count self.runCount += 1 try: # get Fluxcli instance fluxcli = Activator().getInstance('Fluxcli') # invoke result = fluxcli.invoke(['maintenance', self.restart], True).strip() # log self.logger.debug('maintenance-run-result:\n%s' % result) # return return True except Exception, e: self.logger.error("Error when calling maintenance (%s)" % (e))
def modstart(self, args): # mod-name module = args[0].strip() # get ModuleManager-instance moduleManager = Activator().getInstance('ModuleManager') # check if running if moduleManager.isModuleRunning(module): return Result('Module already running: %s' % module, None) # get Dispatcher-instance dispatcher = Activator().getInstance('Dispatcher') # start it try: moduleManager.startModule(dispatcher.requestHandler, module) except Exception, e: # return result return Result('Error when starting Module: %s' % module, e)
def modlist(self, args): # get ModuleManager-instance moduleManager = Activator().getInstance('ModuleManager') # get module-list modules = Config().get('modules', 'Modules').strip().split(',') # build list data = '' for module in modules: module = module.strip() mstate = '0' if moduleManager.isModuleRunning(module): mstate = '1' data += '%s%s%s%s' % (RequestHandler.DELIM_MOD, module, RequestHandler.DELIM_MODSTATE, mstate) if len(data) > 1: data = data[1:] # return result return Result(data, None)
def __init__(self, name, *p, **k): # set name self.name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger(self.name) # request-handler self.requestHandler = None # onStop-delegates self.onStopDelegates = [] # running-flag self.running = False # listener-thread self.thread = Thread(target = self.run) self.thread.setName(self.name) self.thread.setDaemon(True)
def reloadDBCache(self, args): # get DatabaseManager-instance databaseManager = Activator().getInstance('DatabaseManager') # database-load databaseManager.load() # get ModuleManager-instance moduleManager = Activator().getInstance('ModuleManager') # Signal the loaded modules to come and check if they need to update # themselves modmsg = '' for module in moduleManager.runningModules(): data = moduleManager.moduleCommand(module, 'reloadConfig') modmsg += '%s: %s\n' % (module, data) # return result return Result('Database-Config reloaded (%s)\n%s' % (str(databaseManager.getSettingsCount()), modmsg), None)
# invoke fluxcli try: # invoke fluxcli.invoke(['pm', 'Trigger', new.transferowner.strip(), name + ' has met criteria: ' + event], False) except Exception, e: raise Exception, 'Exception when attempting to pm the user: %s' % e return self.removeJob(name, event, action) elif action.startswith('tset'): """ adjust transfer settings.""" # check the parameters (setting, value) = action.split(Trigger.CmdDelim)[1:] # get fluxcli instance fluxcli = Activator().getInstance('Fluxcli'); # invoke fluxcli try: fluxcli.invoke(['tset', name, setting, value], True).strip() except Exception, e: raise Exception, "Exception when attempting to adjust torrent settings" return self.removeJob(name, event, action) elif action.startswith('unzip'): # don't find the files, get them directly from the user! files = action.split(Trigger.CmdDelim)[1:] for file in files: try: # Get the file's extension
def status(self, args): # get Fluxcli-instance fluxcli = Activator().getInstance('Fluxcli') # get DatabaseManager-instance databaseManager = Activator().getInstance('DatabaseManager') # get ServerManager-instance serverManager = Activator().getInstance('ServerManager') # get ModuleManager-instance moduleManager = Activator().getInstance('ModuleManager') # get Dispatcher-instance dispatcher = Activator().getInstance('Dispatcher') # get server-list servers = serverManager.runningServers() # get module-list modules = moduleManager.runningModules() # data data = '' # status data += '----------------------------------------------------------------\n' data += ' Status\n' data += '----------------------------------------------------------------\n' # thread-count data += '%d Threads active\n' % activeCount() # server-count data += '%d Servers running\n' % len(servers) # module-count data += '%d Modules running\n' % len(modules) # dispatcher request-count data += '%d Dispatcher-Requests\n' % dispatcher.requestCount # fluxcli invocations data += '%d Fluxcli invocations\n' % fluxcli.invocationCount # database-settings data += '%d Database-Settings loaded\n' % databaseManager.getSettingsCount() # threads data += '\n----------------------------------------------------------------\n' data += ' Threads\n' data += '----------------------------------------------------------------\n' for thr in enumerate(): data += '%s (isDaemon: %s)\n' % (thr.getName(), str(thr.isDaemon())) # servers data += '\n----------------------------------------------------------------\n' data += ' Servers\n' data += '----------------------------------------------------------------\n' for server in servers: data += '\n[%s]\n' % server serverStatus = serverManager.serverStatus(server) if serverStatus is not None: for key, val in serverStatus.iteritems(): data += '%s: %s\n' % (key, val) # modules data += '\n----------------------------------------------------------------\n' data += ' Modules\n' data += '----------------------------------------------------------------\n' for module in modules: data += '\n[%s]\n' % module moduleStatus = moduleManager.moduleStatus(module) if moduleStatus is not None: for key, val in moduleStatus.iteritems(): data += '%s: %s\n' % (key, val) # config data += '\n----------------------------------------------------------------\n' data += ' Config\n' data += '----------------------------------------------------------------\n' data += Config().currentConfigAsIniString() # return result return Result(data, None)
class DataAdapterADOdb(IDataAdapter): """ -------------------------------------------------------------------- """ """ __init__ """ """ -------------------------------------------------------------------- """ def __init__(self): # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('DataAdapterADOdb') # db-config self.dbConfig = None # connection self.connection = None """ -------------------------------------------------------------------- """ """ loadSettings """ """ -------------------------------------------------------------------- """ def loadSettings(self): # info self.logger.info('loading settings...') # try/finally (separate this for python < 2.5) try: # try try: # open connection self.openConnection() # execute select and get cursor cursor = self.connection.Execute('SELECT tf_key, tf_value FROM tf_settings') # retval retVal = {} # process rows while not cursor.EOF: # get row-dict rowDict = cursor.GetRowAssoc(0) # add setting retVal[rowDict['tf_key']] = rowDict['tf_value'] # next cursor.MoveNext() # close cursor cursor.Close() # check if len(retVal) < 1: raise Exception, 'settings-validation failed' # return return retVal # catch, log and rethrow except Exception, e: self.logger.error('failed to load Settings (%s)' % (e)) raise e # finally close the con finally: self.closeConnection() """ -------------------------------------------------------------------- """ """ saveSettings """ """ -------------------------------------------------------------------- """ def saveSettings(self, settings = {}): # info self.logger.info('saving settings...') # try/finally (separate this for python < 2.5) try: # try try: # open connection self.openConnection() # update settings try: # begin transaction self.connection.BeginTrans() # update for key, val in settings.iteritems(): # sql sql = 'UPDATE tf_settings SET tf_value = %s WHERE tf_key = %s' % \ (self.connection.qstr(val), self.connection.qstr(key)) # DEBUG #self.logger.debug(sql) # execute update and get cursor cursor = self.connection.Execute(sql) # close cursor cursor.Close() # commit transaction self.connection.CommitTrans() # catch, rollback and rethrow except Exception, e: self.connection.RollbackTrans() raise e # catch, log and rethrow except Exception, e: self.logger.error('failed to save Settings (%s)' % (e)) raise e # finally close the con finally: self.closeConnection() """ -------------------------------------------------------------------- """ """ openConnection """ """ -------------------------------------------------------------------- """ def openConnection(self): # debug self.logger.debug('open connection...') # get config try: self.dbConfig = getDatabaseConfig() # catch, log and rethrow except Exception, e: self.logger.error('failed to get database-config (%s)' % (e)) raise e # mysql if self.dbConfig['db_type'].lower().startswith('mysql'): # get ado-connection try: self.connection = adodb.NewADOConnection('mysql') if self.connection is None: raise Exception, 'connection is None' # catch, log and rethrow except Exception, e: self.logger.error('failed to get ADOConnection (%s)' % (e)) raise e # connect try: self.connection.Connect(self.dbConfig['db_host'], self.dbConfig['db_user'], self.dbConfig['db_pass'], self.dbConfig['db_name']) # catch, log and rethrow except Exception, e: self.logger.error('failed to connect to database (%s)' % (e)) raise e
class Fluxcli(IActivator): # instance Instance = None # lock InstanceLock = Lock() # path (relative to docroot) Path = 'bin/fluxcli.php' """ -------------------------------------------------------------------- """ """ __new__ """ """ -------------------------------------------------------------------- """ def __new__(cls, *p, **k): if Fluxcli.Instance is None: Fluxcli.Instance = object.__new__(cls, *p, **k) return Fluxcli.Instance """ -------------------------------------------------------------------- """ """ __init__ """ """ -------------------------------------------------------------------- """ def __init__(self, name): # set name self.__name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('Fluxcli') # invocation-Count self.invocationCount = 0 """ -------------------------------------------------------------------- """ """ getName """ """ -------------------------------------------------------------------- """ def getName(self): return self.__name """ -------------------------------------------------------------------- """ """ getPath """ """ -------------------------------------------------------------------- """ def getPath(self): return '%s%s' % (Config().get('dir', 'docroot').strip(), Fluxcli.Path) """ -------------------------------------------------------------------- """ """ invoke """ """ -------------------------------------------------------------------- """ @synchronized(InstanceLock) def invoke(self, args = [], readResult = True): # increment counter self.invocationCount += 1 # log self.logger.info('invoking fluxcli...') try: # unshift fluxcli-arg args.insert(0, self.getPath()) # unshift php-arg (command is invoked thru an args # list, not by building a string command-line given # to a shell -- this avoids any quoting troubles) php = Config().get('file', 'php').strip() args.insert(0, php) # log pseudo-cmdline (see above, php is not actually invoked that way) self.logger.debug(' '.join([("'%s'" % arg) for arg in args])) # open if readResult: # invoke (use popen2.Popen3 directly to be able to reap # child correctly -- using os.popen2 leaves zombies) p = popen2.Popen3(args) p.tochild.close() result = p.fromchild.read() p.fromchild.close() p.wait() # return result return result # spawn else: # invoke and return bool return (os.spawnv(os.P_WAIT, php, args) == 0) except Exception, e: self.logger.error("Exception in invoke: %s" % (e)) raise e
class ModuleManager(IActivator): # instance Instance = None # lock InstanceLock = Lock() # modules Modules = {} """ -------------------------------------------------------------------- """ """ __new__ """ """ -------------------------------------------------------------------- """ def __new__(cls, *p, **k): if ModuleManager.Instance is None: ModuleManager.Instance = object.__new__(cls, *p, **k) return ModuleManager.Instance """ -------------------------------------------------------------------- """ """ __init__ """ """ -------------------------------------------------------------------- """ def __init__(self, name): # set name self.__name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('ModuleManager') """ -------------------------------------------------------------------- """ """ getName """ """ -------------------------------------------------------------------- """ def getName(self): return self.__name """ -------------------------------------------------------------------- """ """ startModule """ """ -------------------------------------------------------------------- """ @synchronized(InstanceLock) def startModule(self, requestHandler, name = None): try: # start all modules if name is None: self.logger.info('Starting all Modules...') names = Config().get('modules', 'Modules').strip().split(',') for name in names: name = name.strip() if isTrue(Config().getExt(name, 'enabled').strip()): try: # check if exists if ModuleManager.Modules.has_key(name): raise Exception, "Module does already exist: %s" % (name) # start ModuleManager.Modules[name] = getClassByName(Config().get(name, 'module').strip(), Config().get(name, 'class').strip())(name) ModuleManager.Modules[name].start(requestHandler, self.onModuleStop) except Exception, e: self.logger.error("failed to start Module %s (%s)" % (name, e)) # start single module else:
class Dispatcher(IActivator): # instance Instance = None # lock InstanceLock = Lock() """ -------------------------------------------------------------------- """ """ __new__ """ """ -------------------------------------------------------------------- """ def __new__(cls, *p, **k): if Dispatcher.Instance is None: Dispatcher.Instance = object.__new__(cls, *p, **k) return Dispatcher.Instance """ -------------------------------------------------------------------- """ """ __init__ """ """ -------------------------------------------------------------------- """ def __init__(self, name): # set name self.__name = name # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('Dispatcher') # onStop-delegates self.__onStopDelegates = [] # request-queue self.__queueRequest = Queue() # request-handler self.__requestHandler = RequestHandler(self.logger) # running-flag self.__running = False # request-count self.requestCount = 0 # thread self.__thread = Thread(target = self.run) self.__thread.setName(self.__name) self.__thread.setDaemon(True) """ -------------------------------------------------------------------- """ """ getName """ """ -------------------------------------------------------------------- """ def getName(self): return self.__name """ -------------------------------------------------------------------- """ """ start """ """ -------------------------------------------------------------------- """ def start(self): # log self.logger.info('Starting...') # start thread self.__thread.start() """ -------------------------------------------------------------------- """ """ stop """ """ -------------------------------------------------------------------- """ def stop(self): # running-flag self.__running = False # join self.__thread.join(2.0) # shutdown if still alive if self.__thread.isAlive(): self.shutdown() """ -------------------------------------------------------------------- """ """ run """ """ -------------------------------------------------------------------- """ def run(self): # running-flag self.__running = True # debug self.logger.info("up and running") # main-loop while self.__running: # process queue try: # get and process request request = self.__queueRequest.get() # handle request self.__running = self.__requestHandler.handleRequest(request) except Empty, emp: self.logger.error("request-queue is empty (%s)" % emp) except Exception, e: self.logger.error("failed to process request (%s)" % e)
def _fireEventCore(self, event, name, action, new): """actually call the event.""" if action.startswith('execute'): script = action.split(Trigger.CmdDelim)[1] # pass stuff to the environment params = {} params[Trigger.Param_CURDATE] = time.strftime(Config().get('logging', 'Dateformat')) params[Trigger.Param_DOCROOT] = Config().get('dir', 'docroot').strip() params[Trigger.Param_EVENT] = event params[Trigger.Param_FLUXCLI] = Activator().getInstance('Fluxcli').getPath() params[Trigger.Param_FLUXD] = Config().get('dir', 'pathFluxd').strip() params[Trigger.Param_OWNER] = new.transferowner.strip() params[Trigger.Param_PATH] = Config().get('dir', 'pathTf').strip() params[Trigger.Param_PHP] = Config().get('file', 'php').strip() params[Trigger.Param_TRANSFER] = name #params[Trigger.Param_TYPE] = type params[Trigger.Param_RUNNING] = new.running params[Trigger.Param_PERCENT] = new.percent_done params[Trigger.Param_TIME] = new.time_left params[Trigger.Param_DOWN] = new.down_speed params[Trigger.Param_UP] = new.up_speed params[Trigger.Param_SEEDS] = new.seeds params[Trigger.Param_PEERS] = new.peers params[Trigger.Param_SHARING] = new.sharing params[Trigger.Param_SEEDLIM] = new.seedlimit params[Trigger.Param_UPTOTAL] = new.uptotal params[Trigger.Param_DOWNTOTAL]= new.downtotal params[Trigger.Param_SIZE] = new.size # Prepare environment (clean up and add params). env = dict([(k, v) for k, v in os.environ.iteritems() if not k.startswith(Trigger.ParamPrefix)]) env.update(params) bgShellCmd(self.logger, self.name + ':' + event, script, Config().get('dir', 'pathTf').strip(), env) return self.removeJob(name, event, action) elif action.startswith('email'): """ Attempt to email the user, and fall back to PM if necessary.""" try: # Can't get the email out of the DB at this time # it must be inserted into the job initially. recipient = action.split(Trigger.CmdDelim)[1] sender = '*****@*****.**' msg = MIMEText('%s has met criteria: %s' % (name, event)) msg['Subject'] = 'Update from Torrentflux-B4rt' msg['From'] = sender msg['To'] = recipient # actually send the message. could require setting the host # and port on some systems. s = smtplib.SMTP() s.connect() s.sendmail(sender, [recipient], msg.as_string()) s.close() except Exception, e: """ email failed, fallback to PM""" # log self.logger.error('cannot email, falling back to PM: %s' % e) # get fluxcli instance fluxcli = Activator().getInstance('Fluxcli'); # invoke fluxcli try: # invoke fluxcli.invoke(['pm', 'Trigger', new.transferowner.strip(), name + ' has met criteria: ' + event], False) except Exception, e: raise Exception, 'Exception when attempting to pm the user: %s' % e
class SocketRequestDispatcher(object): # lock InstanceLock = Lock() # delim DELIM = '\n' """ -------------------------------------------------------------------- """ """ __init__ """ """ -------------------------------------------------------------------- """ def __init__(self, name, address, socket, requestHandler, onCloseDelegate = None): # logger self.logger = Activator().getInstance('LoggerFactory').getLogger('RequestDispatcher') # set name self.__name = name # set address self.__address = address # set socket self.__socket = socket # request-handler self.__requestHandler = requestHandler # onClose-delegates self.__onCloseDelegates = [] if not onCloseDelegate is None: self.__onCloseDelegates.append(onCloseDelegate) # result-queue self.__queueResult = Queue() # done-flag self.__done = False # running-flag self.__running = False # thread self.__thread = Thread(target = self.run) self.__thread.setName(self.__name) self.__thread.setDaemon(True) """ -------------------------------------------------------------------- """ """ run """ """ -------------------------------------------------------------------- """ def run(self): # running-flag self.__running = True # handle request self.handleRequest() # get and process result while self.__running and not self.__done: try: # get result from queue result = self.__queueResult.get() # handle result self.handleResult(result) except Empty, emp: self.logger.debug("result-queue is empty (%s) (%s)" % (self.__name, emp)) except Exception, e: self.logger.error("failed to process queue (%s) (%s)" % (self.__name, e)) # running-flag self.__running = False