def _send_sandesh(self, sandesh): if self._send_queue.is_queue_empty(): more = False else: more = True if not self._connected: self._logger.log(SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log()) return if sandesh.is_logging_allowed(self._sandesh_instance): self._logger.log(SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log()) self._writer.send_msg(sandesh, more)
def _send_sandesh(self, sandesh): if self._send_queue.is_queue_empty(): more = False else: more = True if not self._connected: self._logger.log( SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log()) return if sandesh.is_logging_allowed(self._sandesh_instance): self._logger.log( SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log()) self._writer.send_msg(sandesh, more)
def send_sandesh(self, sandesh): if (self._connection.session() is not None) and \ (self._sandesh_instance._module is not None) and \ (self._sandesh_instance._module != ""): self._connection.session().enqueue_sandesh(sandesh) else: if (self._connection.session() is None): self._logger.log( SandeshLogger.get_py_logger_level(sandesh.level()), "No Connection: %s" % sandesh.log()) else: self._logger.log( SandeshLogger.get_py_logger_level(sandesh.level()), "No ModuleId: %s" % sandesh.log()) return 0
def send_sandesh(self, tx_sandesh): if self._client: ret = self._client.send_sandesh(tx_sandesh) else: if self._connect_to_collector: self._logger.error('SANDESH: No Client: %s', tx_sandesh.log()) else: self._logger.log( SandeshLogger.get_py_logger_level(tx_sandesh.level()), tx_sandesh.log())
def _send_sandesh(self, sandesh): if self._send_queue.is_queue_empty(): more = False else: more = True if not self._connected: if self._sandesh_instance.is_logging_dropped_allowed(sandesh): self._logger.error("SANDESH: %s: %s" % ("Not connected", sandesh.log())) self._sandesh_instance.msg_stats().update_tx_stats( sandesh.__class__.__name__, 0, SandeshTxDropReason.SessionNotConnected ) return if sandesh.is_logging_allowed(self._sandesh_instance): self._logger.log(SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log()) self._writer.send_msg(sandesh, more)
def _send_sandesh(self, queue_element): sandesh = queue_element.sandesh if self._send_queue.is_queue_empty(): more = False else: more = True if not self._connected: if self._sandesh_instance.is_logging_dropped_allowed(sandesh): self._logger.error( "SANDESH: %s: %s" % ("Not connected", sandesh.log())) self._sandesh_instance.drop_tx_sandesh(sandesh, SandeshTxDropReason.SessionNotConnected) return if sandesh.is_logging_allowed(self._sandesh_instance): self._logger.log( SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log()) self._writer.send_msg(sandesh, more)
def _send_sandesh(self, sandesh): if self._send_queue.is_queue_empty(): more = False else: more = True if not self._connected: if self._sandesh_instance.is_logging_dropped_allowed(sandesh): self._logger.error("SANDESH: %s: %s" % ("Not connected", sandesh.log())) self._sandesh_instance.msg_stats().update_tx_stats( sandesh.__class__.__name__, 0, SandeshTxDropReason.SessionNotConnected) return if sandesh.is_logging_allowed(self._sandesh_instance): self._logger.log( SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log()) self._writer.send_msg(sandesh, more)
# # Copyright (c) 2013 Juniper Networks, Inc. All rights reserved. # # # Sandesh UVE # import importlib from sandesh_logger import SandeshLogger logger = SandeshLogger('SandeshUVE').logger() class SandeshUVETypeMaps(object): def __init__(self): self._uve_global_map = {} #end __init__ def get_uve_global_map(self): return self._uve_global_map #end get_uve_global_map def register_uve_type_map(self, uve_type_key, uve_type_map): try: uve_map = self._uve_global_map[uve_type_key] except KeyError: self._uve_global_map[uve_type_key] = uve_type_map else: logger.error('UVE type "%s" already added' % (uve_type_key)) assert 0
def _init_logger(self, generator): if not generator: generator = 'sandesh' self._sandesh_logger = SandeshLogger(generator) self._logger = self._sandesh_logger.logger()
class Sandesh(object): _DEFAULT_LOG_FILE = SandeshLogger._DEFAULT_LOG_FILE _DEFAULT_SYSLOG_FACILITY = SandeshLogger._DEFAULT_SYSLOG_FACILITY class SandeshRole: INVALID = 0 GENERATOR = 1 COLLECTOR = 2 # end class SandeshRole def __init__(self): self._context = '' self._scope = '' self._module = '' self._source = '' self._node_type = '' self._instance_id = '' self._timestamp = 0 self._versionsig = 0 self._type = 0 self._hints = 0 self._client_context = '' self._client = None self._role = self.SandeshRole.INVALID self._logger = None self._level = SandeshLevel.INVALID self._category = '' self._send_queue_enabled = True self._http_server = None # end __init__ # Public functions def init_generator(self, module, source, node_type, instance_id, collectors, client_context, http_port, sandesh_req_uve_pkg_list=None, discovery_client=None): self._role = self.SandeshRole.GENERATOR self._module = module self._source = source self._node_type = node_type self._instance_id = instance_id self._client_context = client_context self._collectors = collectors self._rcv_queue = WorkQueue(self._process_rx_sandesh) self._init_logger(source + ':' + module + ':' + node_type + ':' \ + instance_id) self._stats = SandeshStats() self._trace = trace.Trace() self._sandesh_request_dict = {} self._uve_type_maps = SandeshUVETypeMaps() if sandesh_req_uve_pkg_list is None: sandesh_req_uve_pkg_list = [] # Initialize the request handling # Import here to break the cyclic import dependency import sandesh_req_impl sandesh_req_impl = sandesh_req_impl.SandeshReqImpl(self) sandesh_req_uve_pkg_list.append('pysandesh.gen_py') for pkg_name in sandesh_req_uve_pkg_list: self._create_sandesh_request_and_uve_lists(pkg_name) if http_port != -1: self._http_server = SandeshHttp( self, module, http_port, sandesh_req_uve_pkg_list) gevent.spawn(self._http_server.start_http_server) primary_collector = None secondary_collector = None if self._collectors is not None: if len(self._collectors) > 0: primary_collector = self._collectors[0] if len(self._collectors) > 1: secondary_collector = self._collectors[1] self._client = SandeshClient( self, primary_collector, secondary_collector, discovery_client) self._client.initiate() # end init_generator def logger(self): return self._logger # end logger def sandesh_logger(self): return self._sandesh_logger # end sandesh_logger def set_logging_params(self, enable_local_log=False, category='', level=SandeshLevel.SYS_INFO, file=SandeshLogger._DEFAULT_LOG_FILE, enable_syslog=False, syslog_facility=_DEFAULT_SYSLOG_FACILITY): self._sandesh_logger.set_logging_params( enable_local_log, category, level, file, enable_syslog, syslog_facility) # end set_logging_params def set_local_logging(self, enable_local_log): self._sandesh_logger.set_local_logging(enable_local_log) # end set_local_logging def set_logging_level(self, level): self._sandesh_logger.set_logging_level(level) # end set_logging_level def set_logging_category(self, category): self._sandesh_logger.set_logging_category(category) # end set_logging_category def set_logging_file(self, file): self._sandesh_logger.set_logging_file(file) # end set_logging_file def is_send_queue_enabled(self): return self._send_queue_enabled # end is_send_queue_enabled def set_send_queue(self, enable): if self._send_queue_enabled != enable: self._logger.info("SANDESH: CLIENT: SEND QUEUE: %s -> %s", self._send_queue_enabled, enable) self._send_queue_enabled = enable if enable: connection = self._client.connection() if connection and connection.session(): connection.session().send_queue().may_be_start_runner() # end set_send_queue def init_collector(self): pass # end init_collector def stats(self): return self._stats # end stats @classmethod def next_seqnum(cls): if not hasattr(cls, '_lseqnum'): cls._lseqnum = 1 else: cls._lseqnum += 1 return cls._lseqnum # end next_seqnum @classmethod def lseqnum(cls): if not hasattr(cls, '_lseqnum'): cls._lseqnum = 0 return cls._lseqnum # end lseqnum def module(self): return self._module # end module def source_id(self): return self._source # end source_id def node_type(self): return self._node_type #end node_type def instance_id(self): return self._instance_id #end instance_id def scope(self): return self._scope # end scope def context(self): return self._context # end context def seqnum(self): return self._seqnum # end seqnum def timestamp(self): return self._timestamp # end timestamp def versionsig(self): return self._versionsig # end versionsig def type(self): return self._type # end type def hints(self): return self._hints # end hints def client(self): return self._client # end client def level(self): return self._level # end level def category(self): return self._category # end category def validate(self): return # end validate def is_local_logging_enabled(self): return self._sandesh_logger.is_local_logging_enabled() # end is_local_logging_enabled def logging_level(self): return self._sandesh_logger.logging_level() # end logging_level def logging_category(self): return self._sandesh_logger.logging_category() # end logging_category def is_syslog_logging_enabled(self): return self._sandesh_logger.is_syslog_logging_enabled() #end is_syslog_logging_enabled def logging_syslog_facility(self): return self._sandesh_logger.logging_syslog_facility() #end logging_syslog_facility def is_unit_test(self): return self._role == self.SandeshRole.INVALID # end is_unit_test def handle_test(self, sandesh_init): if sandesh_init.is_unit_test() or self._is_level_ut(): if self._is_logging_allowed(sandesh_init): sandesh_init._logger.debug(self.log()) return True return False def is_logging_allowed(self, sandesh_init): if not sandesh_init.is_local_logging_enabled(): return False logging_level = sandesh_init.logging_level() level_allowed = logging_level >= self._level logging_category = sandesh_init.logging_category() if logging_category is None or len(logging_category) == 0: category_allowed = True else: category_allowed = logging_category == self._category return level_allowed and category_allowed # end is_logging_allowed def enqueue_sandesh_request(self, sandesh): self._rcv_queue.enqueue(sandesh) # end enqueue_sandesh_request def send_sandesh(self, tx_sandesh): if self._client: ret = self._client.send_sandesh(tx_sandesh) else: self._logger.debug(tx_sandesh.log()) # end send_sandesh def send_generator_info(self): from gen_py.sandesh_uve.ttypes import SandeshClientInfo, \ ModuleClientState, SandeshModuleClientTrace client_info = SandeshClientInfo() try: client_start_time = self._start_time except: self._start_time = UTCTimestampUsec() finally: client_info.start_time = self._start_time client_info.pid = os.getpid() if self._http_server is not None: client_info.http_port = self._http_server.get_port() client_info.collector_name = self._client.connection().collector() client_info.status = self._client.connection().state() client_info.successful_connections = \ self._client.connection().statemachine().connect_count() client_info.primary = self._client.connection().primary_collector() if client_info.primary is None: client_info.primary = '' client_info.secondary = \ self._client.connection().secondary_collector() if client_info.secondary is None: client_info.secondary = '' module_state = ModuleClientState(name=self._source + ':' + self._node_type + ':' + self._module + ':' + self._instance_id, client_info=client_info) generator_info = SandeshModuleClientTrace( data=module_state, sandesh=self) generator_info.send(sandesh=self) # end send_generator_info def get_sandesh_request_object(self, request): try: req_module = self._sandesh_request_dict[request] except KeyError: self._logger.error('Invalid Sandesh Request "%s"' % (request)) return None else: if req_module: try: imp_module = importlib.import_module(req_module) except ImportError: self._logger.error( 'Failed to import Module "%s"' % (req_module)) else: try: sandesh_request = getattr(imp_module, request)() return sandesh_request except AttributeError: self._logger.error( 'Failed to create Sandesh Request "%s"' % (request)) return None else: self._logger.error( 'Sandesh Request "%s" not implemented' % (request)) return None # end get_sandesh_request_object def trace_enable(self): self._trace.TraceOn() # end trace_enable def trace_disable(self): self._trace.TraceOff() # end trace_disable def is_trace_enabled(self): return self._trace.IsTraceOn() # end is_trace_enabled def trace_buffer_create(self, name, size, enable=True): self._trace.TraceBufAdd(name, size, enable) # end trace_buffer_create def trace_buffer_delete(self, name): self._trace.TraceBufDelete(name) # end trace_buffer_delete def trace_buffer_enable(self, name): self._trace.TraceBufOn(name) # end trace_buffer_enable def trace_buffer_disable(self, name): self._trace.TraceBufOff(name) # end trace_buffer_disable def is_trace_buffer_enabled(self, name): return self._trace.IsTraceBufOn(name) # end is_trace_buffer_enabled def trace_buffer_list_get(self): return self._trace.TraceBufListGet() # end trace_buffer_list_get def trace_buffer_size_get(self, name): return self._trace.TraceBufSizeGet(name) # end trace_buffer_size_get def trace_buffer_read(self, name, read_context, count, read_cb): self._trace.TraceRead(name, read_context, count, read_cb) # end trace_buffer_read def trace_buffer_read_done(self, name, context): self._trace.TraceReadDone(name, context) # end trace_buffer_read_done # API to send the trace buffer to the Collector. # If trace count is not specified/or zero, then the entire trace buffer # is sent to the Collector. # [Note] No duplicate trace message sent to the Collector. i.e., If there # is no trace message added between two consequent calls to this API, then # no trace message is sent to the Collector. def send_sandesh_trace_buffer(self, trace_buf, count=0): trace_req_runner = SandeshTraceRequestRunner(sandesh=self, request_buffer_name= trace_buf, request_context='', read_context='Collector', request_count=count) trace_req_runner.Run() # end send_sandesh_trace_buffer # Private functions def _is_level_ut(self): return self._level >= SandeshLevel.UT_START and \ self._level <= SandeshLevel.UT_END # end _is_level_ut def _create_task(self): return gevent.spawn(self._runner.run_for_ever) # end _create_task def _process_rx_sandesh(self, rx_sandesh): handle_request_fn = getattr(rx_sandesh, "handle_request", None) if callable(handle_request_fn): handle_request_fn(rx_sandesh) else: self._logger.error('Sandesh Request "%s" not implemented' % (rx_sandesh.__class__.__name__)) # end _process_rx_sandesh def _create_sandesh_request_and_uve_lists(self, package): try: imp_pkg = __import__(package) except ImportError: self._logger.error('Failed to import package "%s"' % (package)) else: try: pkg_path = imp_pkg.__path__ except AttributeError: self._logger.error( 'Failed to get package [%s] path' % (package)) return for importer, mod, ispkg in \ pkgutil.walk_packages(path=pkg_path, prefix=imp_pkg.__name__ + '.'): if not ispkg: module = mod.rsplit('.', 1)[-1] if 'ttypes' == module: self._logger.debug( 'Add Sandesh requests in module "%s"' % (mod)) self._add_sandesh_request(mod) self._logger.debug( 'Add Sandesh UVEs in module "%s"' % (mod)) self._add_sandesh_uve(mod) # end _create_sandesh_request_and_uve_lists def _add_sandesh_request(self, mod): try: imp_module = importlib.import_module(mod) except ImportError: self._logger.error('Failed to import Module "%s"' % (mod)) else: try: sandesh_req_list = getattr(imp_module, '_SANDESH_REQUEST_LIST') except AttributeError: self._logger.error( '"%s" module does not have sandesh request list' % (mod)) else: # Add sandesh requests to the dictionary. for req in sandesh_req_list: self._sandesh_request_dict[req] = mod # end _add_sandesh_request def _add_sandesh_uve(self, mod): try: imp_module = importlib.import_module(mod) except ImportError: self._logger.error('Failed to import Module "%s"' % (mod)) else: try: sandesh_uve_list = getattr(imp_module, '_SANDESH_UVE_LIST') except AttributeError: self._logger.error( '"%s" module does not have sandesh UVE list' % (mod)) else: # Register sandesh UVEs for uve_type_name in sandesh_uve_list: SandeshUVEPerTypeMap(self, uve_type_name, mod) # end _add_sandesh_uve def _init_logger(self, generator): if not generator: generator = 'sandesh' self._sandesh_logger = SandeshLogger(generator) self._logger = self._sandesh_logger.logger()
def _init_logger(self, module): if not module: module = 'sandesh' self._sandesh_logger = SandeshLogger(module) self._logger = self._sandesh_logger.logger()
class Sandesh(object): _DEFAULT_LOG_FILE = SandeshLogger._DEFAULT_LOG_FILE _DEFAULT_SYSLOG_FACILITY = SandeshLogger._DEFAULT_SYSLOG_FACILITY class SandeshRole: INVALID = 0 GENERATOR = 1 COLLECTOR = 2 # end class SandeshRole def __init__(self): self._context = '' self._scope = '' self._module = '' self._source = '' self._node_type = '' self._instance_id = '' self._timestamp = 0 self._versionsig = 0 self._type = 0 self._hints = 0 self._client_context = '' self._client = None self._role = self.SandeshRole.INVALID self._logger = None self._level = SandeshLevel.INVALID self._category = '' self._send_queue_enabled = True self._http_server = None self._connect_to_collector = True # end __init__ # Public functions def init_generator(self, module, source, node_type, instance_id, collectors, client_context, http_port, sandesh_req_uve_pkg_list=None, discovery_client=None, connect_to_collector=True): self._role = self.SandeshRole.GENERATOR self._module = module self._source = source self._node_type = node_type self._instance_id = instance_id self._client_context = client_context self._collectors = collectors self._connect_to_collector = connect_to_collector self._rcv_queue = WorkQueue(self._process_rx_sandesh) self._init_logger(source + ':' + module + ':' + node_type + ':' \ + instance_id) self._logger.info('SANDESH: CONNECT TO COLLECTOR: %s', connect_to_collector) self._stats = SandeshStats() self._trace = trace.Trace() self._sandesh_request_dict = {} self._uve_type_maps = SandeshUVETypeMaps(self._logger) if sandesh_req_uve_pkg_list is None: sandesh_req_uve_pkg_list = [] # Initialize the request handling # Import here to break the cyclic import dependency import sandesh_req_impl sandesh_req_impl = sandesh_req_impl.SandeshReqImpl(self) sandesh_req_uve_pkg_list.append('pysandesh.gen_py') for pkg_name in sandesh_req_uve_pkg_list: self._create_sandesh_request_and_uve_lists(pkg_name) self._gev_httpd = None if http_port != -1: self._http_server = SandeshHttp( self, module, http_port, sandesh_req_uve_pkg_list) self._gev_httpd = gevent.spawn( self._http_server.start_http_server) primary_collector = None secondary_collector = None if self._collectors is not None: if len(self._collectors) > 0: primary_collector = self._collectors[0] if len(self._collectors) > 1: secondary_collector = self._collectors[1] if self._connect_to_collector: self._client = SandeshClient( self, primary_collector, secondary_collector, discovery_client) self._client.initiate() # end init_generator def uninit(self): self.kill_httpd() def kill_httpd(self): if self._gev_httpd: try: self._gev_httpd.kill() except Exception as e: self._logger.debug(str(e)) def record_port(self, name, port): pipe_name = '/tmp/%s.%d.%s_port' % (self._module, os.getppid(), name) try: pipeout = os.open(pipe_name, os.O_WRONLY) except: self._logger.error('Cannot write %s_port %d to %s' % (name, port, pipe_name)) else: self._logger.error('Writing %s_port %d to %s' % (name, port, pipe_name)) os.write(pipeout, '%d\n' % port) os.close(pipeout) def logger(self): return self._logger # end logger def sandesh_logger(self): return self._sandesh_logger # end sandesh_logger def set_logging_params(self, enable_local_log=False, category='', level=SandeshLevel.SYS_INFO, file=SandeshLogger._DEFAULT_LOG_FILE, enable_syslog=False, syslog_facility=_DEFAULT_SYSLOG_FACILITY): self._sandesh_logger.set_logging_params( enable_local_log, category, level, file, enable_syslog, syslog_facility) # end set_logging_params def set_local_logging(self, enable_local_log): self._sandesh_logger.set_local_logging(enable_local_log) # end set_local_logging def set_logging_level(self, level): self._sandesh_logger.set_logging_level(level) # end set_logging_level def set_logging_category(self, category): self._sandesh_logger.set_logging_category(category) # end set_logging_category def set_logging_file(self, file): self._sandesh_logger.set_logging_file(file) # end set_logging_file def is_send_queue_enabled(self): return self._send_queue_enabled # end is_send_queue_enabled def is_connect_to_collector_enabled(self): return self._connect_to_collector # end is_connect_to_collector_enabled def set_send_queue(self, enable): if self._send_queue_enabled != enable: self._logger.info("SANDESH: CLIENT: SEND QUEUE: %s -> %s", self._send_queue_enabled, enable) self._send_queue_enabled = enable if enable: connection = self._client.connection() if connection and connection.session(): connection.session().send_queue().may_be_start_runner() # end set_send_queue def init_collector(self): pass # end init_collector def stats(self): return self._stats # end stats @classmethod def next_seqnum(cls): if not hasattr(cls, '_lseqnum'): cls._lseqnum = 1 else: cls._lseqnum += 1 return cls._lseqnum # end next_seqnum @classmethod def lseqnum(cls): if not hasattr(cls, '_lseqnum'): cls._lseqnum = 0 return cls._lseqnum # end lseqnum def module(self): return self._module # end module def source_id(self): return self._source # end source_id def node_type(self): return self._node_type #end node_type def instance_id(self): return self._instance_id #end instance_id def scope(self): return self._scope # end scope def context(self): return self._context # end context def seqnum(self): return self._seqnum # end seqnum def timestamp(self): return self._timestamp # end timestamp def versionsig(self): return self._versionsig # end versionsig def type(self): return self._type # end type def hints(self): return self._hints # end hints def client(self): return self._client # end client def level(self): return self._level # end level def category(self): return self._category # end category def validate(self): return # end validate def is_local_logging_enabled(self): return self._sandesh_logger.is_local_logging_enabled() # end is_local_logging_enabled def logging_level(self): return self._sandesh_logger.logging_level() # end logging_level def logging_category(self): return self._sandesh_logger.logging_category() # end logging_category def is_syslog_logging_enabled(self): return self._sandesh_logger.is_syslog_logging_enabled() #end is_syslog_logging_enabled def logging_syslog_facility(self): return self._sandesh_logger.logging_syslog_facility() #end logging_syslog_facility def is_unit_test(self): return self._role == self.SandeshRole.INVALID # end is_unit_test def handle_test(self, sandesh_init): if sandesh_init.is_unit_test() or self._is_level_ut(): if self._is_logging_allowed(sandesh_init): sandesh_init._logger.debug(self.log()) return True return False def is_logging_allowed(self, sandesh_init): if not sandesh_init.is_local_logging_enabled(): return False logging_level = sandesh_init.logging_level() level_allowed = logging_level >= self._level logging_category = sandesh_init.logging_category() if logging_category is None or len(logging_category) == 0: category_allowed = True else: category_allowed = logging_category == self._category return level_allowed and category_allowed # end is_logging_allowed def enqueue_sandesh_request(self, sandesh): self._rcv_queue.enqueue(sandesh) # end enqueue_sandesh_request def send_sandesh(self, tx_sandesh): if self._client: ret = self._client.send_sandesh(tx_sandesh) else: if self._connect_to_collector: self._logger.error('SANDESH: No Client: %s', tx_sandesh.log()) else: self._logger.log( SandeshLogger.get_py_logger_level(tx_sandesh.level()), tx_sandesh.log()) # end send_sandesh def send_generator_info(self): from gen_py.sandesh_uve.ttypes import SandeshClientInfo, \ ModuleClientState, SandeshModuleClientTrace client_info = SandeshClientInfo() try: client_start_time = self._start_time except: self._start_time = UTCTimestampUsec() finally: client_info.start_time = self._start_time client_info.pid = os.getpid() if self._http_server is not None: client_info.http_port = self._http_server.get_port() client_info.collector_name = self._client.connection().collector() client_info.status = self._client.connection().state() client_info.successful_connections = \ self._client.connection().statemachine().connect_count() client_info.primary = self._client.connection().primary_collector() if client_info.primary is None: client_info.primary = '' client_info.secondary = \ self._client.connection().secondary_collector() if client_info.secondary is None: client_info.secondary = '' module_state = ModuleClientState(name=self._source + ':' + self._node_type + ':' + self._module + ':' + self._instance_id, client_info=client_info) generator_info = SandeshModuleClientTrace( data=module_state, sandesh=self) generator_info.send(sandesh=self) # end send_generator_info def get_sandesh_request_object(self, request): try: req_module = self._sandesh_request_dict[request] except KeyError: self._logger.error('Invalid Sandesh Request "%s"' % (request)) return None else: if req_module: try: imp_module = importlib.import_module(req_module) except ImportError: self._logger.error( 'Failed to import Module "%s"' % (req_module)) else: try: sandesh_request = getattr(imp_module, request)() return sandesh_request except AttributeError: self._logger.error( 'Failed to create Sandesh Request "%s"' % (request)) return None else: self._logger.error( 'Sandesh Request "%s" not implemented' % (request)) return None # end get_sandesh_request_object def trace_enable(self): self._trace.TraceOn() # end trace_enable def trace_disable(self): self._trace.TraceOff() # end trace_disable def is_trace_enabled(self): return self._trace.IsTraceOn() # end is_trace_enabled def trace_buffer_create(self, name, size, enable=True): self._trace.TraceBufAdd(name, size, enable) # end trace_buffer_create def trace_buffer_delete(self, name): self._trace.TraceBufDelete(name) # end trace_buffer_delete def trace_buffer_enable(self, name): self._trace.TraceBufOn(name) # end trace_buffer_enable def trace_buffer_disable(self, name): self._trace.TraceBufOff(name) # end trace_buffer_disable def is_trace_buffer_enabled(self, name): return self._trace.IsTraceBufOn(name) # end is_trace_buffer_enabled def trace_buffer_list_get(self): return self._trace.TraceBufListGet() # end trace_buffer_list_get def trace_buffer_size_get(self, name): return self._trace.TraceBufSizeGet(name) # end trace_buffer_size_get def trace_buffer_read(self, name, read_context, count, read_cb): self._trace.TraceRead(name, read_context, count, read_cb) # end trace_buffer_read def trace_buffer_read_done(self, name, context): self._trace.TraceReadDone(name, context) # end trace_buffer_read_done # API to send the trace buffer to the Collector. # If trace count is not specified/or zero, then the entire trace buffer # is sent to the Collector. # [Note] No duplicate trace message sent to the Collector. i.e., If there # is no trace message added between two consequent calls to this API, then # no trace message is sent to the Collector. def send_sandesh_trace_buffer(self, trace_buf, count=0): trace_req_runner = SandeshTraceRequestRunner(sandesh=self, request_buffer_name= trace_buf, request_context='', read_context='Collector', request_count=count) trace_req_runner.Run() # end send_sandesh_trace_buffer # Private functions def _is_level_ut(self): return self._level >= SandeshLevel.UT_START and \ self._level <= SandeshLevel.UT_END # end _is_level_ut def _create_task(self): return gevent.spawn(self._runner.run_for_ever) # end _create_task def _process_rx_sandesh(self, rx_sandesh): handle_request_fn = getattr(rx_sandesh, "handle_request", None) if callable(handle_request_fn): handle_request_fn(rx_sandesh) else: self._logger.error('Sandesh Request "%s" not implemented' % (rx_sandesh.__class__.__name__)) # end _process_rx_sandesh def _create_sandesh_request_and_uve_lists(self, package): try: imp_pkg = __import__(package) except ImportError: self._logger.error('Failed to import package "%s"' % (package)) else: try: pkg_path = imp_pkg.__path__ except AttributeError: self._logger.error( 'Failed to get package [%s] path' % (package)) return for importer, mod, ispkg in \ pkgutil.walk_packages(path=pkg_path, prefix=imp_pkg.__name__ + '.'): if not ispkg: module = mod.rsplit('.', 1)[-1] if 'ttypes' == module: self._logger.debug( 'Add Sandesh requests in module "%s"' % (mod)) self._add_sandesh_request(mod) self._logger.debug( 'Add Sandesh UVEs in module "%s"' % (mod)) self._add_sandesh_uve(mod) self._logger.debug( 'Add Sandesh Alarms in module "%s"' %(mod)) self._add_sandesh_alarm(mod) # end _create_sandesh_request_and_uve_lists def _add_sandesh_request(self, mod): try: imp_module = importlib.import_module(mod) except ImportError: self._logger.error('Failed to import Module "%s"' % (mod)) else: try: sandesh_req_list = getattr(imp_module, '_SANDESH_REQUEST_LIST') except AttributeError: self._logger.error( '"%s" module does not have sandesh request list' % (mod)) else: # Add sandesh requests to the dictionary. for req in sandesh_req_list: self._sandesh_request_dict[req] = mod # end _add_sandesh_request def _get_sandesh_uve_list(self, imp_module): try: sandesh_uve_list = getattr(imp_module, '_SANDESH_UVE_LIST') except AttributeError: self._logger.error( '"%s" module does not have sandesh UVE list' % (imp_module.__name__)) return None else: return sandesh_uve_list # end _get_sandesh_uve_list def _get_sandesh_uve_data_list(self, imp_module): try: sandesh_uve_data_list = getattr(imp_module, '_SANDESH_UVE_DATA_LIST') except AttributeError: self._logger.error( '"%s" module does not have sandesh UVE data list' % (imp_module.__name__)) return None else: return sandesh_uve_data_list # end _get_sandesh_uve_data_list def _add_sandesh_uve(self, mod): try: imp_module = importlib.import_module(mod) except ImportError: self._logger.error('Failed to import Module "%s"' % (mod)) else: sandesh_uve_list = self._get_sandesh_uve_list(imp_module) sandesh_uve_data_list = self._get_sandesh_uve_data_list(imp_module) if sandesh_uve_list is None or sandesh_uve_data_list is None: return if len(sandesh_uve_list) != len(sandesh_uve_data_list): self._logger.error( '"%s" module sandesh UVE and UVE data list do not match' % (mod)) return sandesh_uve_info_list = zip(sandesh_uve_list, sandesh_uve_data_list) # Register sandesh UVEs for uve_type_name, uve_data_type_name in sandesh_uve_info_list: SandeshUVEPerTypeMap(self, SandeshType.UVE, uve_type_name, uve_data_type_name, mod) # end _add_sandesh_uve def _get_sandesh_alarm_list(self, imp_module): try: sandesh_alarm_list = getattr(imp_module, '_SANDESH_ALARM_LIST') except AttributeError: self._logger.error( '"%s" module does not have sandesh Alarm list' % (imp_module.__name__)) return None else: return sandesh_alarm_list # end _get_sandesh_alarm_list def _get_sandesh_alarm_data_list(self, imp_module): try: sandesh_alarm_data_list = getattr(imp_module, '_SANDESH_ALARM_DATA_LIST') except AttributeError: self._logger.error( '"%s" module does not have sandesh Alarm data list' % (imp_module.__name__)) return None else: return sandesh_alarm_data_list # end _get_sandesh_alarm_data_list def _add_sandesh_alarm(self, mod): try: imp_module = importlib.import_module(mod) except ImportError: self._logger.error('Failed to import Module "%s"' % (mod)) else: sandesh_alarm_list = self._get_sandesh_alarm_list(imp_module) sandesh_alarm_data_list = self._get_sandesh_alarm_data_list(imp_module) if sandesh_alarm_list is None or sandesh_alarm_data_list is None: return if len(sandesh_alarm_list) != len(sandesh_alarm_data_list): self._logger.error( '"%s" module sandesh Alarm and Alarm data list do not match' % (mod)) return sandesh_alarm_info_list = zip(sandesh_alarm_list, sandesh_alarm_data_list) # Register sandesh Alarms for alarm_type_name, alarm_data_type_name in sandesh_alarm_info_list: SandeshUVEPerTypeMap(self, SandeshType.ALARM, alarm_type_name, alarm_data_type_name, mod) # end _add_sandesh_alarm def _init_logger(self, generator): if not generator: generator = 'sandesh' self._sandesh_logger = SandeshLogger(generator) self._logger = self._sandesh_logger.logger()