def _get_panoptes_logger(self): """ Returns the logger to be used by the context The method attempts to guess the name of the calling module based on introspection of the stack Returns: logger(logger): A Python logger subsystem logger Raises: PanoptesContextError: This exception is raised is any errors happen trying to instantiate the logger """ self.__logger.info(u'Attempting to get logger') try: module = get_calling_module_name() logger = self.__rootLogger.getChild(module) self.__logger.info(u'Got logger for module %s' % module) return logger except Exception as e: raise PanoptesContextError(u'Could not get logger: %s' % str(e))
def __init__(self, context, path, timeout, retries=1, identifier=None): """ Creates and maintains state for a lock Args: path (str): A '/' separated path for the lock timeout (int): in seconds. Must be a positive integer retries (int): how many times to try before giving up. Zero implies try forever identifier (str): Name to use for this lock contender. This can be useful for querying \ to see who the current lock contenders are Returns: PanoptesLock: lock """ assert PanoptesContextValidators.valid_panoptes_context( context), u'context must be a valid PanoptesContext' assert PanoptesValidators.valid_nonempty_string(path) and re.search(r"^/\S+", path), \ u'path must be a non-empty string that begins with /' assert PanoptesValidators.valid_nonzero_integer( timeout), u'timeout must be a positive integer' assert PanoptesValidators.valid_positive_integer( retries), u'retries must be a non-negative integer' assert PanoptesValidators.valid_nonempty_string( identifier), u'identifier must be a non-empty string' self._context = context self._logger = self._context.logger self._path = path self._timeout = timeout self._retries = retries self._identifier = identifier self._lock = None self._locked = False self._calling_module = get_calling_module_name(3) self._get_lock()
This method creates a Panoptes Context and the Celery Instance for the Enrichment Plugin Agent Returns: None """ global panoptes_context, celery try: panoptes_context = PanoptesEnrichmentAgentContext() except Exception as e: sys.exit(u'Could not create a Panoptes Context: %s' % (str(e))) logger = panoptes_context.logger logger.info(u'Attempting to start Celery application') celery_config = PanoptesCeleryConfig( const.ENRICHMENT_PLUGIN_AGENT_CELERY_APP_NAME) try: celery = PanoptesCeleryInstance(panoptes_context, celery_config).celery except Exception as exp: sys.exit(u'Could not instantiate Celery application: %s' % str(exp)) else: logger.info(u'Started Celery application: %s' % celery) if get_calling_module_name() == const.CELERY_LOADER_MODULE or \ inspect_calling_module_for_name('celery'): # pragma: no cover faulthandler.enable() start_enrichment_plugin_agent()
def get_lock(self, path, timeout, retries=1, identifier=None, listener=None): """ A wrapper around the kazoo library lock Args: path (str): A '/' separated path for the lock timeout (int): in seconds. Must be a positive integer retries (int): how many times to try before giving up. Zero implies try forever identifier (str): Name to use for this lock contender. This can be useful for querying \ to see who the current lock contenders are listener (callable): The callable to use to handle Zookeeper state changes Returns: kazoo.recipe.lock.Lock: lock """ assert PanoptesValidators.valid_nonempty_string(path) and re.search("^/\S+", path), \ u'path must be a non-empty string that begins with /' assert PanoptesValidators.valid_nonzero_integer( timeout), u'timeout must be a positive integer' assert PanoptesValidators.valid_positive_integer( retries), u'retries must be a non-negative integer' assert PanoptesValidators.valid_nonempty_string( identifier), u'identifier must be a non-empty string' assert ( not listener) or callable(listener), u'listener must be a callable' logger = self.logger calling_module = get_calling_module_name(2) logger.info(u"Creating lock for module: " + calling_module + u" with lock parameters: " u"path=" + path + u",timeout=" + str(timeout) + u",retries=" + str(retries) + u"," u"identifier=" + identifier) try: lock = self.zookeeper_client.Lock(path, identifier) except Exception as e: logger.error(u'Failed to create lock object: %s' % str(e)) return None if retries == 0: while True: logger.info( u'Trying to acquire lock with client id "%s" under path %s. Other contenders: %s. ' % (identifier, path, lock.contenders())) try: lock.acquire(timeout=timeout) except LockTimeout: logger.info( u'Timed out after %d seconds trying to acquire lock. Retrying.' % timeout) except Exception as e: logger.info(u'Error in acquiring lock: %s. Retrying.' % str(e)) if lock.is_acquired: break else: tries = 0 while tries < retries: logger.info( u'Trying to acquire lock with client id "%s" under path %s. Other contenders: %s. ' % (identifier, path, lock.contenders())) try: lock.acquire(timeout=timeout) except LockTimeout: logger.info( u'Timed out after %d seconds trying to acquire lock. Retrying %d more times' % (timeout, retries - tries)) except Exception as e: logger.info( u'Error in acquiring lock: %s. Retrying %d more times' % (str(e), (retries - tries))) if lock.is_acquired: break tries += 1 if not lock.is_acquired: logger.warn(u'Unable to acquire lock after %d tries' % retries) if lock.is_acquired: logger.info(u'Lock acquired. Other contenders: %s' % lock.contenders()) if listener: self.zookeeper_client.add_listener(listener) return lock