Esempio n. 1
0
    def sandesh_init(self, http_server_port=None):
        """ Init sandesh """
        self._sandesh = Sandesh()
        # Reset the sandesh send rate limit value
        if self._args.sandesh_send_rate_limit is not None:
            SandeshSystem.set_sandesh_send_rate_limit(
                self._args.sandesh_send_rate_limit)
        self.redefine_sandesh_handles()
        if not http_server_port:
            http_server_port = self._args.http_server_port
        self._sandesh.init_generator(
            self._module_name, self._hostname, self._node_type_name,
            self._instance_id, self._args.random_collectors,
            '%s_context' % self.context, int(http_server_port),
            ['cfgm_common', '%s.sandesh' % self.module_pkg],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # connection state init
        ConnectionState.init(
                self._sandesh, self._hostname, self._module_name,
                self._instance_id,
                staticmethod(ConnectionState.get_process_state_cb),
                NodeStatusUVE, NodeStatus, self.table)
Esempio n. 2
0
    def sandesh_init(self, http_server_port=None):
        """ Init sandesh """
        self._sandesh = Sandesh()
        self.redefine_sandesh_handles()
        if not http_server_port:
            http_server_port = self._args.http_server_port

        self._instance_id = self.sandesh_instance_id

        self._sandesh.init_generator(
            self._module_name,
            self._hostname,
            self._node_type_name,
            self.sandesh_instance_id,
            self._args.random_collectors,
            '%s_context' % self.context,
            int(http_server_port), ['cfgm_common'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        VncGreenlet.register_sandesh_handler()

        self._sandesh.trace_buffer_create(name="MessageBusNotifyTraceBuf",
                                          size=1000)
Esempio n. 3
0
    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self.module['name'],
            self.module['hostname'],
            self.module['node_type_name'],
            self.module['instance_id'],
            self._args.collectors,
            'mesos_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'mesos_manager.sandesh'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(self._sandesh, self.module['hostname'],
                             self.module['name'], self.module['instance_id'],
                             staticmethod(ConnectionState.get_conn_state_cb),
                             NodeStatusUVE, NodeStatus, self.module['table'])
Esempio n. 4
0
 def setUp(self):
     self.maxDiff = None
     self._sandesh = Sandesh()
     http_port = test_utils.get_free_port()
     self._sandesh.init_generator('conn_info_test', socket.gethostname(),
                                  'Test', 'Test', None,
                                  'conn_info_test_ctxt', http_port)
Esempio n. 5
0
    def __init__(self, vnc_lib, args=None):
        self._args = args

        # api server and cassandra init
        self._vnc_lib = vnc_lib
        self._cassandra_init()

        # dictionary for nova
        self._nova = {}

        #initialize discovery client
        self._disc = None
        if self._args.disc_server_ip and self._args.disc_server_port:
            self._disc = client.DiscoveryClient(self._args.disc_server_ip,
                                                self._args.disc_server_port,
                                                client_type='Service Monitor')

        #sandesh init
        self._sandesh = Sandesh()
        sandesh.ServiceInstanceList.handle_request =\
            self.sandesh_si_handle_request
        module = Module.SVC_MONITOR
        module_name = ModuleNames[module]
        node_type = Module2NodeType[module]
        node_type_name = NodeTypeNames[node_type]
        instance_id = INSTANCE_ID_DEFAULT
        self._sandesh.init_generator(module_name, socket.gethostname(),
                                     node_type_name, instance_id,
                                     self._args.collectors,
                                     'svc_monitor_context',
                                     int(self._args.http_server_port),
                                     ['cfgm_common', 'sandesh'], self._disc)
        self._sandesh.set_logging_params(enable_local_log=self._args.log_local,
                                         category=self._args.log_category,
                                         level=self._args.log_level,
                                         file=self._args.log_file)

        #create default analyzer template
        self._create_default_template('analyzer-template', 'analyzer',
                                      'analyzer')
        self._create_default_template('nat-template', 'nat-service',
                                      'firewall', 'in-network-nat')

        #create cpu_info object to send periodic updates
        sysinfo_req = False
        cpu_info = vnc_cpu_info.CpuInfo(module_name, instance_id, sysinfo_req,
                                        self._sandesh, 60)
        self._cpu_info = cpu_info

        # logging
        self._err_file = '/var/log/contrail/svc-monitor.err'
        self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
        self._svc_err_logger = logging.getLogger('SvcErrLogger')
        self._svc_err_logger.setLevel(logging.ERROR)
        handler = logging.handlers.RotatingFileHandler(self._err_file,
                                                       maxBytes=64 * 1024,
                                                       backupCount=2)
        self._svc_err_logger.addHandler(handler)
Esempio n. 6
0
 def setUp(self):
     self._sandesh = Sandesh()
     http_port = get_free_port()
     self._sandesh.init_generator('sandesh_trace_test',
                                  socket.gethostname(), 'Test', 'Test',
                                  None, 'trace_test_ctxt', http_port)
     self._sandesh.set_logging_params(level=SandeshLevel.SYS_DEBUG,
                                      enable_local_log=True,
                                      enable_trace_print=True)
     self._trace_read_list = []
Esempio n. 7
0
 def setUp(self):
     self.sandesh_instance = Sandesh()
     self.sandesh_instance.init_generator('SandeshSessionTest',
                                          'localhost',
                                          'UT',
                                          0,
                                          None,
                                          'context',
                                          -1,
                                          connect_to_collector=False)
 def setUp(self):
     self.maxDiff = None
     self.sandesh = Sandesh()
     self.sandesh.init_generator('sandesh_uve_alarm_test',
                                 socket.gethostname(),
                                 'Test',
                                 '0',
                                 None,
                                 '',
                                 get_free_port(),
                                 connect_to_collector=False)
     # mock the sandesh client object
     self.sandesh._client = mock.MagicMock(spec=SandeshClient)
Esempio n. 9
0
    def sandesh_init(self, http_server_port=None):
        """ Init sandesh """
        if self._sandesh is not None:
            return

        self._sandesh = Sandesh()
        self.redefine_sandesh_handles()
        if not http_server_port:
            http_server_port = self._args.http_server_port

        self._instance_id = self.sandesh_instance_id

        self._sandesh.init_generator(
            self._module_name, self._hostname, self._node_type_name,
            self.sandesh_instance_id, self._args.random_collectors,
            '%s_context' % self.context, int(http_server_port),
            ['cfgm_common'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        VncGreenlet.register_sandesh_handler()

        self._sandesh.trace_buffer_create(name="MessageBusNotifyTraceBuf",
                                          size=1000)
Esempio n. 10
0
    def sandesh_init(self):
        """ Init sandesh """
        self._sandesh = Sandesh()
        # Reset the sandesh send rate limit value
        if self._args.sandesh_send_rate_limit is not None:
            SandeshSystem.set_sandesh_send_rate_limit(
                self._args.sandesh_send_rate_limit)
        self.redefine_sandesh_handles()
        self._sandesh.init_generator(
            self._module_name, self._hostname, self._node_type_name,
            self._instance_id, self._args.random_collectors,
            '%s_context' % self.context, int(self._args.http_server_port),
            ['cfgm_common', '%s.sandesh' % self.module_pkg], self.discovery,
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # connection state init
        ConnectionState.init(
                self._sandesh, self._hostname, self._module_name,
                self._instance_id,
                staticmethod(ConnectionState.get_process_state_cb),
                NodeStatusUVE, NodeStatus, self.table)
Esempio n. 11
0
    def sandesh_init(self, http_server_port=None):
        """ Init sandesh """
        self._sandesh = Sandesh()
        self.redefine_sandesh_handles()
        if not http_server_port:
            http_server_port = self._args.http_server_port
        self._sandesh.init_generator(
            self._module_name, self._hostname, self._node_type_name,
            self._instance_id, self._args.random_collectors,
            '%s_context' % self.context, int(http_server_port),
            ['cfgm_common', '%s.sandesh' % self.module_pkg],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # connection state init
        ConnectionState.init(
                self._sandesh, self._hostname, self._module_name,
                self._instance_id,
                staticmethod(ConnectionState.get_conn_state_cb),
                NodeStatusUVE, NodeStatus, self.table)
        VncGreenlet.register_sandesh_handler()
Esempio n. 12
0
    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self.module['name'], self.module['hostname'],
            self.module['node_type_name'], self.module['instance_id'],
            self._args.collectors, 'mesos_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'mesos_manager.sandesh'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level, file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(self._sandesh, self.module['hostname'],
            self.module['name'], self.module['instance_id'],
            staticmethod(ConnectionState.get_process_state_cb),
            NodeStatusUVE, NodeStatus, self.module['table'])
Esempio n. 13
0
    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Register custom sandesh request handlers.
        self._redefine_sandesh_handles()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self._module["name"], self._module["hostname"],
            self._module["node_type_name"], self._module["instance_id"],
            self._args.random_collectors, 'kube_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'kube_manager'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category, level=self._args.log_level,
            file=self._args.log_file, enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(
            self._sandesh, self._module["hostname"], self._module["name"],
            self._module["instance_id"],
            staticmethod(ConnectionState.get_process_state_cb),
            NodeStatusUVE, NodeStatus, self._module["table"])
Esempio n. 14
0
 def setUp(self):
     self.maxDiff = None
     self._sandesh = Sandesh()
     http_port = test_utils.get_free_port()
     self._sandesh.init_generator(
         "conn_info_test", socket.gethostname(), "Test", "Test", None, "conn_info_test_ctxt", http_port
     )
Esempio n. 15
0
    def __init__(self, vnc_lib, args=None):
        self._args = args

        # api server and cassandra init
        self._vnc_lib = vnc_lib
        self._cassandra_init()

        # dictionary for nova
        self._nova = {}

        # initialize discovery client
        self._disc = None
        if self._args.disc_server_ip and self._args.disc_server_port:
            self._disc = client.DiscoveryClient(
                self._args.disc_server_ip, self._args.disc_server_port, client_type="Service Monitor"
            )

        # sandesh init
        self._sandesh = Sandesh()
        sandesh.ServiceInstanceList.handle_request = self.sandesh_si_handle_request
        module = Module.SVC_MONITOR
        module_name = ModuleNames[module]
        node_type = Module2NodeType[module]
        node_type_name = NodeTypeNames[node_type]
        instance_id = INSTANCE_ID_DEFAULT
        self._sandesh.init_generator(
            module_name,
            socket.gethostname(),
            node_type_name,
            instance_id,
            self._args.collectors,
            "svc_monitor_context",
            int(self._args.http_server_port),
            ["cfgm_common", "sandesh"],
            self._disc,
        )
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
        )

        # create default analyzer template
        self._create_default_template("analyzer-template", "analyzer", "analyzer")
        self._create_default_template("nat-template", "nat-service", "firewall", "in-network-nat")

        # create cpu_info object to send periodic updates
        sysinfo_req = False
        cpu_info = vnc_cpu_info.CpuInfo(module_name, instance_id, sysinfo_req, self._sandesh, 60)
        self._cpu_info = cpu_info

        # logging
        self._err_file = "/var/log/contrail/svc-monitor.err"
        self._tmp_file = "/var/log/contrail/svc-monitor.tmp"
        self._svc_err_logger = logging.getLogger("SvcErrLogger")
        self._svc_err_logger.setLevel(logging.ERROR)
        handler = logging.handlers.RotatingFileHandler(self._err_file, maxBytes=64 * 1024, backupCount=2)
        self._svc_err_logger.addHandler(handler)
Esempio n. 16
0
class SandeshSessionTest(unittest.TestCase):
    def setUp(self):
        self.sandesh_instance = Sandesh()
        self.sandesh_instance.init_generator('SandeshSessionTest',
                                             'localhost',
                                             'UT',
                                             0,
                                             None,
                                             'context',
                                             -1,
                                             connect_to_collector=False)

    # end setUp

    def tearDown(self):
        pass

    # end tearDown

    def verify_watermarks(self, session, expected_wms, actual_wms):
        expected_wms.sort()
        actual_wms.sort()
        print('== verify watermarks ==')
        print(expected_wms)
        self.assertEqual(len(expected_wms), len(actual_wms))
        for i in range(len(expected_wms)):
            self.assertEqual(expected_wms[i][0], actual_wms[i].size)
            # Invoke the watermark callback and verify that the
            # send_level is set correctly
            actual_wms[i].callback(expected_wms[i][0])
            self.assertEqual(expected_wms[i][1], session.send_level())

    # end verify_watermarks

    def test_send_queue_watermarks(self):
        session = SandeshSession(self.sandesh_instance, None, None, None)
        wms = SandeshSendQueue._SENDQ_WATERMARKS
        # verify high watermarks are set properly in sandesh send queue
        high_wms = [wm for wm in wms if wm[2] is True]
        sendq_hwms = session.send_queue().high_watermarks()
        self.verify_watermarks(session, high_wms, sendq_hwms)

        # verify low watermarks are set properly in sandesh send queue
        low_wms = [wm for wm in wms if wm[2] is False]
        sendq_lwms = session.send_queue().low_watermarks()
        self.verify_watermarks(session, low_wms, sendq_lwms)
Esempio n. 17
0
 def _sandesh_init(self, discovery):
     sandesh_instance = Sandesh()
     sandesh.ServiceInstanceList.handle_request =\
         self.sandesh_si_handle_request
     sandesh_instance.init_generator(
         self._module_name, self._hostname, self._node_type_name, 
         self._instance_id, self._args.collectors, 'svc_monitor_context',
         int(self._args.http_server_port), ['cfgm_common', 'svc_monitor.sandesh'],
         discovery)
     sandesh_instance.set_logging_params(
         enable_local_log=self._args.log_local,
         category=self._args.log_category,
         level=self._args.log_level,
         file=self._args.log_file,
         enable_syslog=self._args.use_syslog,
         syslog_facility=self._args.syslog_facility)
     return sandesh_instance
Esempio n. 18
0
    def __init__(self, vnc_lib, args=None):
        self._args = args

        # api server and cassandra init
        self._vnc_lib = vnc_lib
        self._cassandra_init()

        # dictionary for nova
        self._nova = {}

        #initialize discovery client
        self._disc = None
        if self._args.disc_server_ip and self._args.disc_server_port:
            self._disc = client.DiscoveryClient(self._args.disc_server_ip,
                                                self._args.disc_server_port,
                                                client_type='Service Monitor')

        #sandesh init
        collectors = None
        if self._args.collector and self._args.collector_port:
            collectors = [(self._args.collector,
                           int(self._args.collector_port))]
        self._sandesh = Sandesh()
        sandesh.ServiceInstanceList.handle_request =\
            self.sandesh_si_handle_request
        self._sandesh.init_generator(
            ModuleNames[Module.SVC_MONITOR], socket.gethostname(),
            collectors, 'svc_monitor_context',
            int(self._args.http_server_port), ['cfgm_common', 'sandesh'],
            self._disc)
        self._sandesh.set_logging_params(enable_local_log=self._args.log_local,
                                         category=self._args.log_category,
                                         level=self._args.log_level,
                                         file=self._args.log_file)

        #create default analyzer template
        self._create_default_template('analyzer-template', 'analyzer',
                                      'analyzer')
        self._create_default_template('nat-template', 'nat-service',
                                      'firewall', 'in-network-nat')

        #create cpu_info object to send periodic updates
        sysinfo_req = False
        cpu_info = vnc_cpu_info.CpuInfo(
            Module.SVC_MONITOR, sysinfo_req, self._sandesh, 60)
        self._cpu_info = cpu_info

        # logging
        self._err_file = '/var/log/contrail/svc-monitor.err'
        self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
        self._svc_err_logger = logging.getLogger('SvcErrLogger')
        self._svc_err_logger.setLevel(logging.ERROR)
        handler = logging.handlers.RotatingFileHandler(
            self._err_file, maxBytes=64*1024, backupCount=2)
        self._svc_err_logger.addHandler(handler)
Esempio n. 19
0
    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Reset sandesh send rate limit value.
        if self._args.sandesh_send_rate_limit is not None:
            SandeshSystem.set_sandesh_send_rate_limit(
                self._args.sandesh_send_rate_limit)

        # Register custom sandesh request handlers.
        self._redefine_sandesh_handles()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self._module["name"],
            self._module["hostname"],
            self._module["node_type_name"],
            self._module["instance_id"],
            self._args.collectors,
            'kube_manager_context',
            int(self._args.http_server_port), ['cfgm_common', 'kube_manager'],
            self._module["discovery"],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(
            self._sandesh, self._module["hostname"], self._module["name"],
            self._module["instance_id"],
            staticmethod(ConnectionState.get_process_state_cb), NodeStatusUVE,
            NodeStatus, self._module["table"])
Esempio n. 20
0
    def _sandesh_init(self, discovery):
        sandesh_instance = Sandesh()
        sandesh.ServiceInstanceList.handle_request =\
            self.sandesh_si_handle_request
        sandesh_instance.init_generator(
            self._module_name,
            self._hostname,
            self._node_type_name,
            self._instance_id,
            self._args.collectors,
            'svc_monitor_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'svc_monitor.sandesh'],
            discovery,
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf)

        sandesh_instance.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)
        return sandesh_instance
Esempio n. 21
0
    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Reset sandesh send rate limit value.
        if self._args.sandesh_send_rate_limit is not None:
            SandeshSystem.set_sandesh_send_rate_limit(
                self._args.sandesh_send_rate_limit)

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self.module.name,
            self.module.hostname,
            self.module.node_type_name,
            self.module.instance_id,
            self._args.collectors,
            'mesos_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'mesos_manager.sandesh'],
            self.module.discovery,
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(
            self._sandesh, self.module.hostname, self.module.name,
            self.module.instance_id,
            staticmethod(ConnectionState.get_process_state_cb), NodeStatusUVE,
            NodeStatus, self.module.table)
Esempio n. 22
0
class JobLogger(ConfigServiceLogger):
    def __init__(self,
                 args=None,
                 http_server_port=None,
                 sandesh_instance_id=None,
                 sandesh_instance=None):
        """
        Initialize Job Logger.

        :param args: Config params passed to job manager
        :param http_server_port: Required for Sandesh logger initialization
        :param sandesh_instance_id: Uniquely identifies the logger instance
        :param sandesh_instance: Optional sandesh instance
        """
        self.sandesh_instance_id = sandesh_instance_id
        self._sandesh = sandesh_instance
        module = Module.FABRIC_ANSIBLE
        module_pkg = "job_manager"
        self.context = "job_manager"
        super(JobLogger, self).__init__(module, module_pkg, args,
                                        http_server_port)

    def sandesh_init(self, http_server_port=None):
        if self._sandesh is not None:
            return

        self._sandesh = Sandesh()
        self.redefine_sandesh_handles()
        if not http_server_port:
            http_server_port = self._args.http_server_port

        self._instance_id = self.sandesh_instance_id

        self._sandesh.init_generator(
            self._module_name,
            self._hostname,
            self._node_type_name,
            self.sandesh_instance_id,
            self._args.random_collectors,
            '%s_context' % self.context,
            int(http_server_port), ['cfgm_common'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        VncGreenlet.register_sandesh_handler()

        self._sandesh.trace_buffer_create(name="MessageBusNotifyTraceBuf",
                                          size=1000)
Esempio n. 23
0
def run_introspect(cfg, database, lock):
    sandesh_config = cfg['sandesh']
    sandesh_config['collectors'] = sandesh_config['collectors'].split()
    random.shuffle(sandesh_config['collectors'])
    sandesh_config.update({
        'id': Module.VCENTER_MANAGER,
        'hostname': socket.gethostname(),
        'table': 'ObjectContrailvCenterManagerNode',
        'instance_id': INSTANCE_ID_DEFAULT,
        'introspect_port': ServiceHttpPortMap['contrail-vcenter-manager'],
    })
    sandesh_config['name'] = ModuleNames[sandesh_config['id']]
    sandesh_config['node_type'] = Module2NodeType[sandesh_config['id']]
    sandesh_config['node_type_name'] = NodeTypeNames[sandesh_config['node_type']]

    sandesh = Sandesh()
    sandesh_handler = SandeshHandler(database, lock)
    sandesh_handler.bind_handlers()
    config = SandeshConfig(http_server_ip=sandesh_config['http_server_ip'])
    sandesh.init_generator(
        module='cvm',
        source=sandesh_config['hostname'],
        node_type=sandesh_config['node_type_name'],
        instance_id=sandesh_config['instance_id'],
        collectors=sandesh_config['collectors'],
        client_context='cvm_context',
        http_port=sandesh_config['introspect_port'],
        sandesh_req_uve_pkg_list=['cfgm_common', 'cvm'],
        config=config
    )
    sandesh.sandesh_logger().set_logger_params(
        logger=sandesh.logger(),
        enable_local_log=True,
        level=translate_logging_level(sandesh_config['logging_level']),
        file=sandesh_config['log_file'],
        enable_syslog=False,
        syslog_facility=None
    )
    ConnectionState.init(
        sandesh=sandesh,
        hostname=sandesh_config['hostname'],
        module_id=sandesh_config['name'],
        instance_id=sandesh_config['instance_id'],
        conn_status_cb=staticmethod(ConnectionState.get_conn_state_cb),
        uve_type_cls=NodeStatusUVE,
        uve_data_type_cls=NodeStatus,
        table=sandesh_config['table']
    )
Esempio n. 24
0
class JobLogger(ConfigServiceLogger):
    def __init__(self,
                 args=None,
                 http_server_port=None,
                 sandesh_instance_id=None):
        self.sandesh_instance_id = sandesh_instance_id
        module = Module.FABRIC_ANSIBLE
        module_pkg = "job_manager"
        self.context = "job_manager"
        super(JobLogger, self).__init__(module, module_pkg, args,
                                        http_server_port)

    def sandesh_init(self, http_server_port=None):
        """ Init sandesh """
        self._sandesh = Sandesh()
        self.redefine_sandesh_handles()
        if not http_server_port:
            http_server_port = self._args.http_server_port

        self._instance_id = self.sandesh_instance_id

        self._sandesh.init_generator(
            self._module_name,
            self._hostname,
            self._node_type_name,
            self.sandesh_instance_id,
            self._args.random_collectors,
            '%s_context' % self.context,
            int(http_server_port),
            ['cfgm_common', '%s.sandesh' % self.module_pkg],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        VncGreenlet.register_sandesh_handler()

        self._sandesh.trace_buffer_create(name="MessageBusNotifyTraceBuf",
                                          size=1000)
class ConnInfoTest(unittest.TestCase):

    def setUp(self):
        self.maxDiff = None
        self._sandesh = Sandesh()
        http_port = test_utils.get_free_port()
        self._sandesh.init_generator('conn_info_test', socket.gethostname(),
            'Test', 'Test', None, 'conn_info_test_ctxt', http_port)
    #end setUp

    def _check_process_status_cb(self, vcinfos):
        self._expected_vcinfos.sort()
        vcinfos.sort()
        self.assertEqual(self._expected_vcinfos, vcinfos)
        return (ProcessState.FUNCTIONAL, '')
    #end _check_process_status_cb

    def _update_conn_info(self, name, status, description, vcinfos):
        cinfo = ConnectionInfo()
        cinfo.name = name
        cinfo.status = ConnectionStatusNames[status]
        cinfo.description = description
        cinfo.type = ConnectionTypeNames[ConnectionType.TEST]
        cinfo.server_addrs = ['127.0.0.1:0']
        vcinfos.append(cinfo)
    #end _update_conn_info

    def _update_conn_state(self, name, status, description, vcinfos):
        self._expected_vcinfos = vcinfos
        ConnectionState.update(ConnectionType.TEST, name, status,
            ['127.0.0.1:0'], description)
    #end _update_conn_state

    def _delete_conn_info(self, name, vcinfos):
        return [cinfo for cinfo in vcinfos if cinfo.name != name]
    #end _delete_conn_info

    def _delete_conn_state(self, name, vcinfos):
        self._expected_vcinfos = vcinfos
        ConnectionState.delete(ConnectionType.TEST, name)
    #end _delete_conn_state

    def test_basic(self):
        ConnectionState.init(sandesh = self._sandesh, hostname = "TestHost",
            module_id = "TestModule", instance_id = "0",
            status_cb = self._check_process_status_cb,
            uve_type_cls = NodeStatusTestUVE,
            uve_data_type_cls = NodeStatusTest)
        vcinfos = []
        self._update_conn_info("Test1", ConnectionStatus.UP, "Test1 UP",
            vcinfos)
        self._update_conn_state("Test1", ConnectionStatus.UP, "Test1 UP",
            vcinfos)
        self._update_conn_info("Test2", ConnectionStatus.UP, "Test2 UP",
            vcinfos)
        self._update_conn_state("Test2", ConnectionStatus.UP, "Test2 UP",
            vcinfos)
        vcinfos = self._delete_conn_info("Test2", vcinfos)
        self._delete_conn_state("Test2", vcinfos)
    #end test_basic

    def test_callback(self):
        vcinfos = []
        self._update_conn_info("Test1", ConnectionStatus.UP, "Test1 UP",
            vcinfos);
        (pstate, message) = ConnectionState.get_process_state_cb(vcinfos)
        self.assertEqual(ProcessState.FUNCTIONAL, pstate)
        self.assertEqual('', message)
        self._update_conn_info("Test2", ConnectionStatus.DOWN, "Test2 DOWN",
            vcinfos);
        (pstate, message) = ConnectionState.get_process_state_cb(vcinfos)
        self.assertEqual(ProcessState.NON_FUNCTIONAL, pstate)
        self.assertEqual("Test:Test2[Test2 DOWN] connection down", message);
        self._update_conn_info("Test3", ConnectionStatus.DOWN, "Test3 DOWN",
            vcinfos);
        (pstate, message) = ConnectionState.get_process_state_cb(vcinfos);
        self.assertEqual(ProcessState.NON_FUNCTIONAL, pstate);
        self.assertEqual("Test:Test2[Test2 DOWN], Test:Test3[Test3 DOWN] connection down", message);
Esempio n. 26
0
class ConfigServiceLogger(object):

    _LOGGER_LEVEL_TO_SANDESH_LEVEL = {
        logging.CRITICAL: SandeshLevel.SYS_EMERG,
        logging.CRITICAL: SandeshLevel.SYS_ALERT,
        logging.CRITICAL: SandeshLevel.SYS_CRIT,
        logging.ERROR: SandeshLevel.SYS_ERR,
        logging.WARNING: SandeshLevel.SYS_WARN,
        logging.WARNING: SandeshLevel.SYS_NOTICE,
        logging.INFO: SandeshLevel.SYS_INFO,
        logging.DEBUG: SandeshLevel.SYS_DEBUG
    }

    def __init__(self, module, module_pkg, args=None, http_server_port=None):
        self.module_pkg = module_pkg
        if not hasattr(self, 'context'):
            self.context = module_pkg
        self._args = args

        if 'host_ip' in args:
            host_ip = args.host_ip
        else:
            host_ip = socket.gethostbyname(socket.getfqdn())
        node_type = Module2NodeType[module]
        self._module_name = ModuleNames[module]
        self._node_type_name = NodeTypeNames[node_type]
        self.table = "ObjectConfigNode"
        self._instance_id = INSTANCE_ID_DEFAULT
        self._hostname = socket.getfqdn(host_ip)

        # sandesh init
        self.sandesh_init(http_server_port)

    def _get_sandesh_logger_level(self, sandesh_level):
        return self._LOGGER_LEVEL_TO_SANDESH_LEVEL[sandesh_level]

    def log(self, log_msg, level=SandeshLevel.SYS_DEBUG, fun=None):
        if fun:
            log = fun(level=level, og_msg=log_msg, sandesh=self._sandesh)
            log.send(sandesh=self._sandesh)
        else:
            self._sandesh.logger().log(
                    SandeshLogger.get_py_logger_level(level), log_msg)

    def emergency(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_EMERG, fun=log_fun)

    def alert(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_ALERT, fun=log_fun)

    def critical(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_CRIT, fun=log_fun)

    def error(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_ERR, fun=log_fun)

    def cgitb_error(self):
        string_buf = cStringIO.StringIO()
        cgitb_hook(file=string_buf, format="text")
        self.error(string_buf.getvalue())

    def warning(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_WARN, fun=log_fun)

    def notice(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_NOTICE, fun=log_fun)

    def info(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_INFO, fun=log_fun)

    def debug(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_DEBUG, fun=log_fun)

    def _utc_timestamp_usec(self):
        epoch = datetime.datetime.utcfromtimestamp(0)
        now = datetime.datetime.utcnow()
        delta = now - epoch
        return (delta.microseconds +
                (delta.seconds + delta.days * 24 * 3600) * 10 ** 6)

    def redefine_sandesh_handles(self):
        """ Redefine sandesh handle requests for various object types. """
        pass

    def sandesh_init(self, http_server_port=None):
        """ Init sandesh """
        self._sandesh = Sandesh()
        self.redefine_sandesh_handles()
        if not http_server_port:
            http_server_port = self._args.http_server_port
        self._sandesh.init_generator(
            self._module_name, self._hostname, self._node_type_name,
            self._instance_id, self._args.random_collectors,
            '%s_context' % self.context, int(http_server_port),
            ['cfgm_common', '%s.sandesh' % self.module_pkg],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # connection state init
        ConnectionState.init(
                self._sandesh, self._hostname, self._module_name,
                self._instance_id,
                staticmethod(ConnectionState.get_conn_state_cb),
                NodeStatusUVE, NodeStatus, self.table)
        VncGreenlet.register_sandesh_handler()

    def introspect_init(self):
        self._sandesh.run_introspect_server(int(self._args.http_server_port))

    def sandesh_reconfig_collectors(self, args):
        self._sandesh.reconfig_collectors(args.random_collectors)
Esempio n. 27
0
class MesosManagerLogger(object):

    def __init__(self, args=None):
        self._args = args

        # Initialize module parameters.
        self.module = {}
        self.module["id"] = Module.MESOS_MANAGER
        self.module["name"] = ModuleNames[self.module["id"]]
        self.module["node_type"] = Module2NodeType[self.module["id"]]
        self.module["node_type_name"] = NodeTypeNames[self.module["node_type"]]
        self.module["hostname"] = socket.gethostname()
        self.module["table"] = "ObjectConfigNode"
        if self._args.worker_id:
            self.module["instance_id"] = self._args.worker_id
        else:
            self.module["instance_id"] = INSTANCE_ID_DEFAULT

        # Init Sandesh.
        self.sandesh_init()

    def syslog(self, log_msg, level):
        # Log to syslog.
        self._sandesh.logger().log(
            SandeshLogger.get_py_logger_level(level), log_msg)

    def log(self, log_msg, level=SandeshLevel.SYS_DEBUG, fun=None):
        # If a sandesh function is provided, use the function.
        # If not, revert to syslog.
        if fun:
            log = fun(level=level, log_msg=log_msg, sandesh=self._sandesh)
            log.send(sandesh=self._sandesh)
        else:
            self.syslog(log_msg, level)

    # EMERGENCY.
    def emergency(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_EMERG
        logging_fun = log_fun if log_fun else sandesh.MesosManagerEmergencyLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # ALERT.
    def alert(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ALERT
        logging_fun = log_fun if log_fun else sandesh.MesosManagerAlertLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def critical(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_CRIT
        logging_fun = log_fun if log_fun else sandesh.MesosManagerCriticalLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def error(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ERR
        logging_fun = log_fun if log_fun else sandesh.MesosManagerErrorLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # WARNING.
    def warning(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_WARN
        logging_fun = log_fun if log_fun else sandesh.MesosManagerWarningLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # NOTICE.
    def notice(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_NOTICE
        logging_fun = log_fun if log_fun else sandesh.MesosManagerNoticeLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # INFO.
    def info(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_INFO
        logging_fun = log_fun if log_fun else sandesh.MesosManagerInfoLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # DEBUG.
    def debug(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_DEBUG
        logging_fun = log_fun if log_fun else sandesh.MesosManagerDebugLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self.module['name'], self.module['hostname'],
            self.module['node_type_name'], self.module['instance_id'],
            self._args.collectors, 'mesos_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'mesos_manager.sandesh'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level, file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(self._sandesh, self.module['hostname'],
            self.module['name'], self.module['instance_id'],
            staticmethod(ConnectionState.get_process_state_cb),
            NodeStatusUVE, NodeStatus, self.module['table'])
Esempio n. 28
0
class SandeshTraceTest(unittest.TestCase):
    def setUp(self):
        self._sandesh = Sandesh()
        http_port = get_free_port()
        self._sandesh.init_generator('sandesh_trace_test',
                                     socket.gethostname(), 'Test', 'Test',
                                     None, 'trace_test_ctxt', http_port)
        self._sandesh.set_logging_params(level=SandeshLevel.SYS_DEBUG,
                                         enable_local_log=True,
                                         enable_trace_print=True)
        self._trace_read_list = []

    # end setUp

    def sandesh_trace_read_handler(self, trace_msg, more):
        self._trace_read_list.append(trace_msg)

    # end sandesh_trace_read_handler

    def test_create_delete_trace_buffer(self):
        trace_buf_name = 'test_create_delete_trace_buffer'
        trace_buf_size = 5
        self._sandesh.trace_buffer_create(trace_buf_name, trace_buf_size)
        self.assertTrue(
            trace_buf_name in self._sandesh.trace_buffer_list_get())
        self.assertEqual(trace_buf_size,
                         self._sandesh.trace_buffer_size_get(trace_buf_name))

        # Read from empty trace buffer
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='test',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = []
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._sandesh.trace_buffer_delete(trace_buf_name)
        self.assertFalse(
            trace_buf_name in self._sandesh.trace_buffer_list_get())

        # Read deleted trace buffer
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='test',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = []
        self.assertEqual(exp_trace_list, self._trace_read_list)

    # end test_create_delete_trace_buffer

    def test_enable_disable_trace_buffer(self):
        trace_buf_name = 'test_enable_disable_trace_buffer'
        trace_buf_size = 5
        # Create trace buffer in disabled state
        self._sandesh.trace_buffer_create(trace_buf_name, trace_buf_size,
                                          False)
        tmsg1 = TraceTest(magicNo=1234, sandesh=self._sandesh)
        tmsg1.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        # Trace buffer should be empty
        exp_trace_list = []
        self.assertEqual(exp_trace_list, self._trace_read_list)

        # Enable trace buffer
        self._sandesh.trace_buffer_enable(trace_buf_name)
        tmsg1.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        tmsg2 = TraceTest(magicNo=3456, sandesh=self._sandesh)
        tmsg2.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read2',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg1, tmsg2]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []

        # Disable trace buffer
        self._sandesh.trace_buffer_disable(trace_buf_name)
        tmsg3 = TraceTest(magicNo=7890, sandesh=self._sandesh)
        tmsg3.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read3',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg1, tmsg2]
        self.assertEqual(exp_trace_list, self._trace_read_list)

    # end test_enable_disable_trace_buffer

    def test_enable_disable_trace(self):
        trace_buf_name = 'test_enable_disable_trace'
        trace_buf_size = 3
        # Disable trace
        self._sandesh.trace_disable()
        self._sandesh.trace_buffer_create(trace_buf_name, trace_buf_size)
        tmsg1 = TraceTest(magicNo=1234, sandesh=self._sandesh)
        tmsg1.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        # Trace buffer should be empty
        exp_trace_list = []
        self.assertEqual(exp_trace_list, self._trace_read_list)

        # Enable trace
        self._sandesh.trace_enable()
        tmsg1.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read2',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg1]
        self.assertEqual(exp_trace_list, self._trace_read_list)

    # end test_enable_disable_trace

    def test_read_count_trace_buffer(self):
        trace_buf_name = 'test_read_count_trace_buffer'
        trace_buf_size = 10
        self._sandesh.trace_buffer_create(trace_buf_name, trace_buf_size)
        tmsg1 = TraceTest(magicNo=1, sandesh=self._sandesh)
        tmsg1.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        tmsg2 = TraceTest(magicNo=2, sandesh=self._sandesh)
        tmsg2.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        tmsg3 = TraceTest(magicNo=3, sandesh=self._sandesh)
        tmsg3.trace_msg(name=trace_buf_name, sandesh=self._sandesh)

        # Total messages in trace buffer = 3, count = 1
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=1,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg1]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []

        # count = 0, should read the last two messages
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg2, tmsg3]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []

        # Total messages in trace buffer = 3, count = 5 (< trace_buf_size)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read2',
            count=5,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg1, tmsg2, tmsg3]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []

        # Total messages in trace buffer = 3, count = 20 (> trace_buf_size)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read3',
            count=20,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg1, tmsg2, tmsg3]
        self.assertEqual(exp_trace_list, self._trace_read_list)

    # end test_read_count_trace_buffer

    def test_overwrite_trace_buffer(self):
        trace_buf_name = 'test_overwrite_trace_buffer'
        trace_buf_size = 3
        self._sandesh.trace_buffer_create(trace_buf_name, trace_buf_size)
        tmsg1 = TraceTest(magicNo=123, sandesh=self._sandesh)
        tmsg1.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        tmsg2 = TraceTest(magicNo=345, sandesh=self._sandesh)
        tmsg2.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        tmsg3 = TraceTest(magicNo=567, sandesh=self._sandesh)
        tmsg3.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg1, tmsg2, tmsg3]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []
        # Overwrite trace buffer
        tmsg4 = TraceTest(magicNo=789, sandesh=self._sandesh)
        tmsg4.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read2',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg2, tmsg3, tmsg4]
        self.assertEqual(exp_trace_list, self._trace_read_list)

    # end test_overwrite_trace_buffer

    def test_trace_buffer_read_context(self):
        trace_buf_name = 'test_trace_buffer_read_context'
        trace_buf_size = 3
        self._sandesh.trace_buffer_create(trace_buf_name, trace_buf_size)
        tmsg1 = TraceTest(magicNo=123, sandesh=self._sandesh)
        tmsg1.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        tmsg2 = TraceTest(magicNo=345, sandesh=self._sandesh)
        tmsg2.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg1, tmsg2]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []

        # After reading the entire content of trace buffer,
        # dont delete the read context. Subsequent call to trace_buffer_read()
        # should not read any trace message
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = []
        self.assertEqual(exp_trace_list, self._trace_read_list)

        # We have not deleted the read context. Add more trace messages
        # and make sure we don't read the already read trace messages.
        tmsg3 = TraceTest(magicNo=56, sandesh=self._sandesh)
        tmsg3.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        tmsg4 = TraceTest(magicNo=67, sandesh=self._sandesh)
        tmsg4.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=1,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg3]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []
        # Now read the last message
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg4]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []

        # Read the trace buffer with different read_context
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read2',
            count=2,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg2, tmsg3]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []

        # Delete read context
        self._sandesh.trace_buffer_read_done(name=trace_buf_name,
                                             context='read2')
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read2',
            count=1,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg2]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []

        # Interleave reading and writing of trace buffer - invalidate read
        # context
        tmsg5 = TraceTest(magicNo=78, sandesh=self._sandesh)
        tmsg5.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        tmsg6 = TraceTest(magicNo=89, sandesh=self._sandesh)
        tmsg6.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read2',
            count=2,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg4, tmsg5]
        self.assertEqual(exp_trace_list, self._trace_read_list)
        self._trace_read_list = []
        tmsg7 = TraceTest(magicNo=98, sandesh=self._sandesh)
        tmsg7.trace_msg(name=trace_buf_name, sandesh=self._sandesh)
        self._sandesh.trace_buffer_read(
            name=trace_buf_name,
            read_context='read1',
            count=0,
            read_cb=self.sandesh_trace_read_handler)
        exp_trace_list = [tmsg5, tmsg6, tmsg7]
        self.assertEqual(exp_trace_list, self._trace_read_list)
Esempio n. 29
0
class SvcMonitor(object):
    """
    data + methods used/referred to by ssrc and arc greenlets
    """

    _KEYSPACE = 'svc_monitor_keyspace'
    _SVC_VM_CF = 'svc_vm_table'
    _SVC_SI_CF = 'svc_si_table'
    _SVC_CLEANUP_CF = 'svc_cleanup_table'

    def __init__(self, vnc_lib, args=None):
        self._args = args

        # api server and cassandra init
        self._vnc_lib = vnc_lib
        self._cassandra_init()

        # dictionary for nova
        self._nova = {}

        #initialize discovery client
        self._disc = None
        if self._args.disc_server_ip and self._args.disc_server_port:
            self._disc = client.DiscoveryClient(self._args.disc_server_ip,
                                                self._args.disc_server_port,
                                                client_type='Service Monitor')

        #sandesh init
        self._sandesh = Sandesh()
        sandesh.ServiceInstanceList.handle_request =\
            self.sandesh_si_handle_request
        module = Module.SVC_MONITOR
        module_name = ModuleNames[module]
        node_type = Module2NodeType[module]
        node_type_name = NodeTypeNames[node_type]
        instance_id = INSTANCE_ID_DEFAULT
        self._sandesh.init_generator(module_name, socket.gethostname(),
                                     node_type_name, instance_id,
                                     self._args.collectors,
                                     'svc_monitor_context',
                                     int(self._args.http_server_port),
                                     ['cfgm_common', 'sandesh'], self._disc)
        self._sandesh.set_logging_params(enable_local_log=self._args.log_local,
                                         category=self._args.log_category,
                                         level=self._args.log_level,
                                         file=self._args.log_file)

        #create default analyzer template
        self._create_default_template('analyzer-template', 'analyzer',
                                      'analyzer')
        self._create_default_template('nat-template', 'nat-service',
                                      'firewall', 'in-network-nat')

        #create cpu_info object to send periodic updates
        sysinfo_req = False
        cpu_info = vnc_cpu_info.CpuInfo(module_name, instance_id, sysinfo_req,
                                        self._sandesh, 60)
        self._cpu_info = cpu_info

        # logging
        self._err_file = '/var/log/contrail/svc-monitor.err'
        self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
        self._svc_err_logger = logging.getLogger('SvcErrLogger')
        self._svc_err_logger.setLevel(logging.ERROR)
        handler = logging.handlers.RotatingFileHandler(self._err_file,
                                                       maxBytes=64 * 1024,
                                                       backupCount=2)
        self._svc_err_logger.addHandler(handler)

    # end __init__

    # create service template
    def _create_default_template(self,
                                 st_name,
                                 image_name,
                                 svc_type,
                                 svc_mode=None):
        domain_name = 'default-domain'
        domain_fq_name = [domain_name]
        st_fq_name = [domain_name, st_name]
        self._svc_syslog("Creating %s %s image %s" %
                         (domain_name, st_name, image_name))

        try:
            st_obj = self._vnc_lib.service_template_read(fq_name=st_fq_name)
            st_uuid = st_obj.uuid
            self._svc_syslog("%s exists uuid %s" % (st_name, str(st_uuid)))
            return
        except NoIdError:
            domain = self._vnc_lib.domain_read(fq_name=domain_fq_name)
            st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
            st_uuid = self._vnc_lib.service_template_create(st_obj)

        svc_properties = ServiceTemplateType()
        svc_properties.set_image_name(image_name)
        svc_properties.set_service_type(svc_type)
        svc_properties.set_flavor("m1.medium")
        svc_properties.set_ordered_interfaces(True)

        # set interface list
        if svc_type == 'analyzer':
            if_list = [['left', False]]
        else:
            if_list = [['management', False], ['left', False],
                       ['right', False]]
            svc_properties.set_service_mode(svc_mode)

        for itf in if_list:
            if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
            if_type.set_service_interface_type(itf[0])
            svc_properties.add_interface_type(if_type)

        try:
            st_obj.set_service_template_properties(svc_properties)
            self._vnc_lib.service_template_update(st_obj)
        except Exception as e:
            print e

        self._svc_syslog("%s created with uuid %s" % (st_name, str(st_uuid)))

    #_create_default_analyzer_template

    def cleanup(self):
        # TODO cleanup sandesh context
        pass

    # end cleanup

    def _sandesh_populate_vn_info(self, si_info, sandesh_si):
        for if_str in [_LEFT_STR, _RIGHT_STR, _MGMT_STR]:
            if_set = set()
            if_str_vn = if_str + '-vn'
            if not if_str_vn in si_info.keys():
                continue

            vn_fq_str = str(si_info[if_str_vn])
            vn_uuid = str(si_info[vn_fq_str])
            vn_str = ("VN [%s : %s]" % (vn_fq_str, vn_uuid))
            if_set.add(vn_str)

            iip_uuid_str = if_str + '-iip-uuid'
            if iip_uuid_str in si_info.keys():
                vn_iip_uuid = str(si_info[iip_uuid_str])
                iip_addr_str = if_str + '-iip-addr'
                vn_iip_addr = str(si_info[iip_addr_str])
                iip_str = ("IIP [%s : %s]" % (vn_iip_addr, vn_iip_uuid))
                if_set.add(iip_str)

            if if_str == _LEFT_STR:
                sandesh_si.left_vn = list(if_set)
            if if_str == _RIGHT_STR:
                sandesh_si.right_vn = list(if_set)
            if if_str == _MGMT_STR:
                sandesh_si.management_vn = list(if_set)

            si_info['done'] = True

    # end _sandesh_populate_vn_info

    def sandesh_si_handle_request(self, req):
        si_resp = sandesh.ServiceInstanceListResp(si_names=[])
        if req.si_name is None:
            vm_list = list(self._svc_vm_cf.get_range())
            si_list = list(self._svc_si_cf.get_range())

            #walk all vms
            for vm_uuid, si in vm_list:
                if 'done' in si:
                    continue

                #collect all ecmp instances
                sandesh_si = sandesh.ServiceInstance(name=si['si_fq_str'])
                vm_set = set()
                for key, val in vm_list:
                    if val['si_fq_str'] != si['si_fq_str']:
                        continue
                    vm_str = ("%s: %s" % (val['instance_name'], key))
                    vm_set.add(vm_str)
                    val['done'] = True
                sandesh_si.vm_list = list(vm_set)

                #find the vn and iip iformation
                for si_fq_str, si_info in si_list:
                    if si_fq_str != si['si_fq_str']:
                        continue
                    self._sandesh_populate_vn_info(si_info, sandesh_si)
                    si_info['done'] = True
                si_resp.si_names.append(sandesh_si)

            #walk all instances where vms are pending launch
            for si_fq_str, si_info in si_list:
                if 'done' in si_info.keys():
                    continue
                sandesh_si = sandesh.ServiceInstance(name=si_fq_str)
                sandesh_si.vm_list = set()
                sandesh_si.instance_name = ''
                self._sandesh_populate_vn_info(si_info, sandesh_si)
                si_resp.si_names.append(sandesh_si)

        si_resp.response(req.context())

    # end sandesh_si_handle_request

    def _utc_timestamp_usec(self):
        epoch = datetime.datetime.utcfromtimestamp(0)
        now = datetime.datetime.utcnow()
        delta = now - epoch
        return (delta.microseconds +
                (delta.seconds + delta.days * 24 * 3600) * 10**6)

    # end utc_timestamp_usec

    def _uve_svc_instance(self,
                          si_fq_name_str,
                          status=None,
                          vm_uuid=None,
                          st_name=None):
        svc_uve = UveSvcInstanceConfig(name=si_fq_name_str,
                                       deleted=False,
                                       st_name=None,
                                       vm_list=[],
                                       create_ts=None)

        if st_name:
            svc_uve.st_name = st_name
        if vm_uuid:
            svc_uve.vm_list.append(vm_uuid)
        if status:
            svc_uve.status = status
            if status == 'CREATE':
                svc_uve.create_ts = self._utc_timestamp_usec()
            elif status == 'DELETE':
                svc_uve.deleted = True

        svc_log = UveSvcInstanceConfigTrace(data=svc_uve,
                                            sandesh=self._sandesh)
        svc_log.send(sandesh=self._sandesh)

    # end uve_vm

    def _svc_syslog(self, log_msg):
        self._sandesh._logger.debug("%s", log_msg)
        vn_log = sandesh.SvcMonitorLog(log_msg=log_msg, sandesh=self._sandesh)
        vn_log.send(sandesh=self._sandesh)

    # end _svc_syslog

    def _get_proj_name_from_si_fq_str(self, si_fq_str):
        return si_fq_str.split(':')[1]

    # enf _get_si_fq_str_to_proj_name

    def _get_vn_id(self,
                   proj_obj,
                   vn_fq_name_str,
                   shared_vn_name=None,
                   shared_vn_subnet=None):
        vn_id = None

        if vn_fq_name_str:
            vn_fq_name = vn_fq_name_str.split(':')
            # search for provided VN
            try:
                vn_id = self._vnc_lib.fq_name_to_id('virtual-network',
                                                    vn_fq_name)
            except NoIdError:
                self._svc_syslog("Error: vn_fq_name %s not found" %
                                 (vn_fq_name_str))
        else:
            # search or create shared VN
            domain_name, proj_name = proj_obj.get_fq_name()
            vn_fq_name = [domain_name, proj_name, shared_vn_name]
            try:
                vn_id = self._vnc_lib.fq_name_to_id('virtual-network',
                                                    vn_fq_name)
            except NoIdError:
                vn_id = self._create_svc_vn(shared_vn_name, shared_vn_subnet,
                                            proj_obj)

        return vn_id

    # end _get_vn_id

    def _set_svc_vm_if_properties(self, vmi_obj, vn_obj):
        # confirm service vm by checking reference to service instance
        vm_id = get_vm_id_from_interface(vmi_obj)
        if vm_id is None:
            return
        vm_obj = self._vnc_lib.virtual_machine_read(id=vm_id)
        si_list = vm_obj.get_service_instance_refs()
        if not si_list:
            return

        # if interface property already set
        if vmi_obj.get_virtual_machine_interface_properties() is not None:
            return

        # get service instance
        fq_name = si_list[0]['to']
        si_obj = self._vnc_lib.service_instance_read(fq_name=fq_name)
        si_props = si_obj.get_service_instance_properties()
        si_if_list = si_props.get_interface_list()
        si_if = None

        # get service template
        st_list = si_obj.get_service_template_refs()
        if st_list is not None:
            fq_name = st_list[0]['to']
            st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
        st_props = st_obj.get_service_template_properties()
        st_if_list = st_props.get_interface_type()

        # set interface type
        vn_fq_name_str = vn_obj.get_fq_name_str()
        for idx in range(0, len(st_if_list)):
            st_if = st_if_list[idx]
            itf_type = st_if.service_interface_type

            si_if = None
            if si_if_list and st_props.get_ordered_interfaces():
                si_if = si_if_list[idx]
                si_vn_str = si_if.get_virtual_network()
            else:
                funcname = "get_" + itf_type + "_virtual_network"
                func = getattr(si_props, funcname)
                si_vn_str = func()

            if (((itf_type == _MGMT_STR) and (vn_obj.name == _SVC_VN_MGMT)) or
                ((itf_type == _LEFT_STR) and (vn_obj.name == _SVC_VN_LEFT)) or
                ((itf_type == _RIGHT_STR) and (vn_obj.name == _SVC_VN_RIGHT))
                    or ((si_vn_str == vn_fq_name_str))):
                if_properties = VirtualMachineInterfacePropertiesType(itf_type)
                vmi_obj.set_virtual_machine_interface_properties(if_properties)
                break

        # set static routes
        if st_if.get_static_route_enable():
            static_routes = si_if.get_static_routes()
            if not static_routes:
                static_routes = {'route': []}

            try:
                domain_name, proj_name = si_obj.get_parent_fq_name()
                rt_name = si_obj.uuid + ' ' + str(idx)
                rt_fq_name = [domain_name, proj_name, rt_name]
                rt_obj = self._vnc_lib.interface_route_table_read(
                    fq_name=rt_fq_name)
                rt_obj.set_interface_route_table_routes(static_routes)
            except NoIdError:
                proj_obj = self._vnc_lib.project_read(
                    fq_name=si_obj.get_parent_fq_name())
                rt_obj = InterfaceRouteTable(
                    name=rt_name,
                    parent_obj=proj_obj,
                    interface_route_table_routes=static_routes)
                self._vnc_lib.interface_route_table_create(rt_obj)
            vmi_obj.set_interface_route_table(rt_obj)

        # remove security groups and update vmi
        if st_props.service_mode not in [
                'in-network', 'in-network-nat'
        ] or st_props.service_type == 'analyzer':
            vmi_obj.set_security_group_list([])
        self._vnc_lib.virtual_machine_interface_update(vmi_obj)

    # end _set_svc_vm_if_properties

    def _create_svc_instance_vm(self, st_obj, si_obj):
        #check if all config received before launch
        if not self._check_store_si_info(st_obj, si_obj):
            return

        row_entry = {}
        st_props = st_obj.get_service_template_properties()
        if st_props is None:
            return
        st_if_list = st_props.get_interface_type()

        flavor = st_props.get_flavor()
        image_name = st_props.get_image_name()
        if image_name is None:
            self._svc_syslog("Error: Image name not present in %s" %
                             (st_obj.name))
            return

        si_props = si_obj.get_service_instance_properties()
        max_instances = si_props.get_scale_out().get_max_instances()
        si_if_list = si_props.get_interface_list()
        if si_if_list and (len(si_if_list) != len(st_if_list)):
            self._svc_syslog("Error: IF mismatch template %s instance %s" %
                             (len(st_if_list), len(si_if_list)))
            return

        # check and create service virtual networks
        nics = []
        proj_fq_name = si_obj.get_parent_fq_name()
        proj_obj = self._vnc_lib.project_read(fq_name=proj_fq_name)
        for idx in range(0, len(st_if_list)):
            nic = {}
            st_if = st_if_list[idx]
            itf_type = st_if.service_interface_type

            # set vn id
            if si_if_list and st_props.get_ordered_interfaces():
                si_if = si_if_list[idx]
                vn_fq_name_str = si_if.get_virtual_network()
            else:
                funcname = "get_" + itf_type + "_virtual_network"
                func = getattr(si_props, funcname)
                vn_fq_name_str = func()

            if itf_type in _SVC_VNS:
                vn_id = self._get_vn_id(proj_obj, vn_fq_name_str,
                                        _SVC_VNS[itf_type][0],
                                        _SVC_VNS[itf_type][1])
            else:
                vn_id = self._get_vn_id(proj_obj, vn_fq_name_str)
            if vn_id is None:
                continue
            nic['net-id'] = vn_id
            nic['v4-fixed-ip'] = None

            # set shared ip
            if st_if.shared_ip:
                try:
                    iip_dict = self._svc_si_cf.get(si_obj.get_fq_name_str())
                    iip_uuid_str = itf_type + '-iip-uuid'
                    if iip_uuid_str in iip_dict.keys():
                        nic['v4-fixed-ip'] = iip_dict[itf_type + '-iip-addr']
                except pycassa.NotFoundException:
                    self._svc_syslog(
                        "Error: Shared IP not found in db for %s" % (itf_type))

            # add to nic list
            nics.append(nic)

        # create and launch vm
        vm_refs = si_obj.get_virtual_machine_back_refs()
        n_client = self._novaclient_get(proj_obj.name)
        for inst_count in range(0, max_instances):
            instance_name = si_obj.name + '_' + str(inst_count + 1)
            exists = False
            for vm_ref in vm_refs or []:
                vm = n_client.servers.find(id=vm_ref['uuid'])
                if vm.name == instance_name:
                    exists = True
                    break

            if exists:
                vm_uuid = vm_ref['uuid']
            else:
                vm = self._create_svc_vm(instance_name, image_name, nics,
                                         proj_obj.name, flavor)
                if vm is None:
                    continue
                vm_uuid = vm.id

            # store vm, instance in cassandra; use for linking when VM is up
            row_entry['si_fq_str'] = si_obj.get_fq_name_str()
            row_entry['instance_name'] = instance_name
            self._svc_vm_cf.insert(vm_uuid, row_entry)

            # uve trace
            self._uve_svc_instance(si_obj.get_fq_name_str(),
                                   status='CREATE',
                                   vm_uuid=vm.id,
                                   st_name=st_obj.get_fq_name_str())

    # end _create_svc_instance_vm

    def _delete_svc_instance_vm(self, vm_uuid, proj_name, si_fq_str=None):
        found = True
        try:
            self._svc_syslog("Deleting VM %s %s" % (proj_name, vm_uuid))
            n_client = self._novaclient_get(proj_name)
            vm = n_client.servers.find(id=vm_uuid)
            vm.delete()
            self._uve_svc_instance(si_fq_str, status='DELETE', vm_uuid=vm_uuid)
        except nc_exc.NotFound:
            # remove from cleanup list
            self._cleanup_cf.remove(vm_uuid)
            found = False

        # remove from launch table and queue into cleanup list
        if found:
            self._svc_vm_cf.remove(vm_uuid)
            self._cleanup_cf.insert(vm_uuid, {
                'proj_name': proj_name,
                'type': 'vm'
            })

    # end _delete_svc_instance_vm

    def _restart_svc_vm(self, vm_uuid, si_fq_str):
        proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
        self._delete_svc_instance_vm(vm_uuid, proj_name, si_fq_str=si_fq_str)

        si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
        st_list = si_obj.get_service_template_refs()
        if st_list is not None:
            fq_name = st_list[0]['to']
            st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
            self._create_svc_instance_vm(st_obj, si_obj)

    # end _restart_svc_vm

    def _check_store_si_info(self, st_obj, si_obj):
        config_complete = True
        st_props = st_obj.get_service_template_properties()
        st_if_list = st_props.get_interface_type()
        si_props = si_obj.get_service_instance_properties()
        si_if_list = si_props.get_interface_list()
        if si_if_list and (len(si_if_list) != len(st_if_list)):
            self._svc_syslog("Error: IF mismatch template %s instance %s" %
                             (len(st_if_list), len(si_if_list)))
            return

        #read existing si_entry
        try:
            si_entry = self._svc_si_cf.get(si_obj.get_fq_name_str())
        except Exception:
            si_entry = {}

        #walk the interface list
        for idx in range(0, len(st_if_list)):
            st_if = st_if_list[idx]
            itf_type = st_if.service_interface_type

            si_if = None
            if si_if_list and st_props.get_ordered_interfaces():
                si_if = si_if_list[idx]
                si_vn_str = si_if.get_virtual_network()
            else:
                funcname = "get_" + itf_type + "_virtual_network"
                func = getattr(si_props, funcname)
                si_vn_str = ':'.join(func())
            if not si_vn_str:
                continue

            si_entry[itf_type + '-vn'] = si_vn_str
            try:
                vn_obj = self._vnc_lib.virtual_network_read(
                    fq_name_str=si_vn_str)
                if vn_obj.uuid != si_entry.get(si_vn_str, None):
                    si_entry[si_vn_str] = vn_obj.uuid

                if not st_if.shared_ip:
                    continue

                iip_uuid_str = itf_type + '-iip-uuid'
                iip_uuid = si_entry.get(iip_uuid_str, None)
                iip = self._allocate_shared_iip(st_obj, si_obj, vn_obj,
                                                iip_uuid)
                si_entry[itf_type + '-iip-uuid'] = iip['uuid']
                si_entry[itf_type + '-iip-addr'] = iip['addr']
            except NoIdError:
                self._svc_syslog("Warn: VN %s add is pending" % si_vn_str)
                si_entry[si_vn_str] = 'pending'
                config_complete = False

        if config_complete:
            self._svc_syslog("SI %s info is complete" %
                             si_obj.get_fq_name_str())
        else:
            self._svc_syslog("Warn: SI %s info is not complete" %
                             si_obj.get_fq_name_str())

        #insert entry
        self._svc_si_cf.insert(si_obj.get_fq_name_str(), si_entry)
        return config_complete

    #end _check_store_si_info

    def _allocate_shared_iip(self, st_obj, si_obj, vn_obj, iip_uuid):
        iip_entry = {}
        iip_obj = None

        if iip_uuid:
            try:
                iip_obj = self._vnc_lib.instance_ip_read(id=iip_uuid)
            except NoIdError:
                pass

        # allocate ip
        if not iip_obj:
            addr = self._vnc_lib.virtual_network_ip_alloc(vn_obj)
            iip_name = '%s %s' % (vn_obj.uuid, addr[0])
            iip_obj = InstanceIp(name=iip_name, instance_ip_address=addr[0])
            iip_obj.add_virtual_network(vn_obj)
            self._vnc_lib.instance_ip_create(iip_obj)

        iip_entry = {
            'uuid': iip_obj.uuid,
            'addr': iip_obj.get_instance_ip_address()
        }

        return iip_entry

    #end _allocate_shared_iip

    def _delete_shared_vn(self, vn_uuid, proj_name):
        try:
            self._svc_syslog("Deleting VN %s %s" % (proj_name, vn_uuid))
            self._vnc_lib.virtual_network_delete(id=vn_uuid)
        except RefsExistError:
            self._svc_err_logger.error("Delete failed refs exist VN %s %s" %
                                       (proj_name, vn_uuid))
        except NoIdError:
            # remove from cleanup list
            self._cleanup_cf.remove(vn_uuid)

    # end _delete_shared_vn

    def _delete_shared_iip(self, iip_uuid, proj_name):
        try:
            iip_obj = self._vnc_lib.instance_ip_read(id=iip_uuid)
            vmi_refs = iip_obj.get_virtual_machine_interface_refs()
            if vmi_refs is None:
                self._svc_syslog("Deleting IIP %s %s" % (proj_name, iip_uuid))
                self._vnc_lib.instance_ip_delete(id=iip_uuid)
        except RefsExistError:
            self._svc_err_logger.error("Delete failed refs exist IIP %s %s" %
                                       (proj_name, iip_uuid))
        except NoIdError:
            # remove from cleanup list
            self._cleanup_cf.remove(iip_uuid)

    # end _delete_shared_iip

    def _delmsg_project_service_instance(self, idents):
        proj_fq_str = idents['project']
        proj_obj = self._vnc_lib.project_read(fq_name_str=proj_fq_str)
        if proj_obj.get_service_instances() is not None:
            return

        # no SIs left hence delete shared VNs
        for vn_name in [_SVC_VN_MGMT, _SVC_VN_LEFT, _SVC_VN_RIGHT]:
            domain_name, proj_name = proj_obj.get_fq_name()
            vn_fq_name = [domain_name, proj_name, vn_name]
            try:
                vn_uuid = self._vnc_lib.fq_name_to_id('virtual-network',
                                                      vn_fq_name)
                self._cleanup_cf.insert(vn_uuid, {
                    'proj_name': proj_obj.name,
                    'type': 'vn'
                })
            except Exception:
                pass

    # end _delmsg_project_service_instance

    def _delmsg_service_instance_service_template(self, idents):
        si_fq_str = idents['service-instance']

        vm_list = list(self._svc_vm_cf.get_range())
        for vm_uuid, si in vm_list:
            if si_fq_str != si['si_fq_str']:
                continue

            proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
            self._delete_svc_instance_vm(vm_uuid,
                                         proj_name,
                                         si_fq_str=si_fq_str)

            #insert shared instance IP uuids into cleanup list if present
            try:
                si_info = self._svc_si_cf.get(si_fq_str)
                for itf_str in [_MGMT_STR, _LEFT_STR, _RIGHT_STR]:
                    iip_uuid_str = itf_str + '-iip-uuid'
                    if not iip_uuid_str in si_info:
                        continue
                    self._cleanup_cf.insert(si_info[iip_uuid_str], {
                        'proj_name': proj_name,
                        'type': 'iip'
                    })
            except pycassa.NotFoundException:
                pass

        #delete si info
        try:
            self._svc_si_cf.remove(si_fq_str)
        except pycassa.NotFoundException:
            pass

    #end _delmsg_service_instance_service_template

    def _delmsg_virtual_machine_service_instance(self, idents):
        vm_uuid = idents['virtual-machine']
        si_fq_str = idents['service-instance']
        proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
        self._delete_svc_instance_vm(vm_uuid, proj_name, si_fq_str=si_fq_str)

    # end _delmsg_service_instance_virtual_machine

    def _delmsg_virtual_machine_interface_route_table(self, idents):
        rt_fq_str = idents['interface-route-table']

        rt_obj = self._vnc_lib.interface_route_table_read(
            fq_name_str=rt_fq_str)
        vmi_list = rt_obj.get_virtual_machine_interface_back_refs()
        if vmi_list is None:
            self._vnc_lib.interface_route_table_delete(id=rt_obj.uuid)

    # end _delmsg_virtual_machine_interface_route_table

    def _addmsg_virtual_machine_interface_virtual_network(self, idents):
        vmi_fq_str = idents['virtual-machine-interface']
        vn_fq_str = idents['virtual-network']

        try:
            vmi_obj = self._vnc_lib.virtual_machine_interface_read(
                fq_name_str=vmi_fq_str)
            vn_obj = self._vnc_lib.virtual_network_read(fq_name_str=vn_fq_str)
        except NoIdError:
            return

        # check if this is a service vm
        vm_id = get_vm_id_from_interface(vmi_obj)
        if vm_id is None:
            return
        vm_obj = self._vnc_lib.virtual_machine_read(id=vm_id)
        si_list = vm_obj.get_service_instance_refs()
        if si_list:
            fq_name = si_list[0]['to']
            si_obj = self._vnc_lib.service_instance_read(fq_name=fq_name)
        else:
            try:
                svc_vm_cf_row = self._svc_vm_cf.get(vm_obj.uuid)
                si_fq_str = svc_vm_cf_row['si_fq_str']
                vm_obj.name = svc_vm_cf_row['instance_name']
                si_obj = self._vnc_lib.service_instance_read(
                    fq_name_str=si_fq_str)
            except pycassa.NotFoundException:
                return
            except NoIdError:
                proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
                self._delete_svc_instance_vm(vm_obj.uuid,
                                             proj_name,
                                             si_fq_str=si_fq_str)
                return

        # create service instance to service vm link
        vm_obj.add_service_instance(si_obj)
        self._vnc_lib.virtual_machine_update(vm_obj)

        # set service instance property
        self._set_svc_vm_if_properties(vmi_obj, vn_obj)

    # end _addmsg_virtual_machine_interface_virtual_network

    def _addmsg_service_instance_service_template(self, idents):
        st_fq_str = idents['service-template']
        si_fq_str = idents['service-instance']

        try:
            st_obj = self._vnc_lib.service_template_read(fq_name_str=st_fq_str)
            si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
        except NoIdError:
            return

        #launch VMs
        self._create_svc_instance_vm(st_obj, si_obj)

    # end _addmsg_service_instance_service_template

    def _addmsg_service_instance_properties(self, idents):
        si_fq_str = idents['service-instance']

        try:
            si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
        except NoIdError:
            return

        #update static routes
        self._update_static_routes(si_obj)

    # end _addmsg_service_instance_service_template

    def _addmsg_project_virtual_network(self, idents):
        vn_fq_str = idents['virtual-network']

        try:
            si_list = list(self._svc_si_cf.get_range())
        except pycassa.NotFoundException:
            return

        for si_fq_str, si_info in si_list:
            if vn_fq_str not in si_info.keys():
                continue

            try:
                si_obj = self._vnc_lib.service_instance_read(
                    fq_name_str=si_fq_str)
                st_refs = si_obj.get_service_template_refs()
                fq_name = st_refs[0]['to']
                st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)

                #launch VMs
                self._create_svc_instance_vm(st_obj, si_obj)
            except Exception:
                continue

    #end _addmsg_project_virtual_network

    def process_poll_result(self, poll_result_str):
        result_list = parse_poll_result(poll_result_str)

        # process ifmap message
        for (result_type, idents, metas) in result_list:
            for meta in metas:
                meta_name = re.sub('{.*}', '', meta.tag)
                if result_type == 'deleteResult':
                    funcname = "_delmsg_" + meta_name.replace('-', '_')
                elif result_type in ['searchResult', 'updateResult']:
                    funcname = "_addmsg_" + meta_name.replace('-', '_')
                # end if result_type
                try:
                    func = getattr(self, funcname)
                except AttributeError:
                    pass
                else:
                    self._svc_syslog("%s with %s/%s" %
                                     (funcname, meta_name, idents))
                    func(idents)
            # end for meta
        # end for result_type

    # end process_poll_result

    def _novaclient_get(self, proj_name):
        client = self._nova.get(proj_name)
        if client is not None:
            return client

        self._nova[proj_name] = nc.Client('2',
                                          username=self._args.admin_user,
                                          project_id=proj_name,
                                          api_key=self._args.admin_password,
                                          region_name=self._args.region_name,
                                          service_type='compute',
                                          auth_url='http://' +
                                          self._args.auth_host + ':5000/v2.0')
        return self._nova[proj_name]

    # end _novaclient_get

    def _update_static_routes(self, si_obj):
        # get service instance interface list
        si_props = si_obj.get_service_instance_properties()
        si_if_list = si_props.get_interface_list()
        if not si_if_list:
            return

        for idx in range(0, len(si_if_list)):
            si_if = si_if_list[idx]
            static_routes = si_if.get_static_routes()
            if not static_routes:
                static_routes = {'route': []}

            # update static routes
            try:
                domain_name, proj_name = si_obj.get_parent_fq_name()
                rt_name = si_obj.uuid + ' ' + str(idx)
                rt_fq_name = [domain_name, proj_name, rt_name]
                rt_obj = self._vnc_lib.interface_route_table_read(
                    fq_name=rt_fq_name)
                rt_obj.set_interface_route_table_routes(static_routes)
                self._vnc_lib.interface_route_table_update(rt_obj)
            except NoIdError:
                pass

    # end _update_static_routes

    def _create_svc_vm(self, vm_name, image_name, nics, proj_name,
                       flavor_name):
        n_client = self._novaclient_get(proj_name)
        if flavor_name:
            flavor = n_client.flavors.find(name=flavor_name)
        else:
            flavor = n_client.flavors.find(ram=4096)

        image = ''
        try:
            image = n_client.images.find(name=image_name)
        except nc_exc.NotFound:
            self._svc_syslog("Error: Image %s not found in project %s" %
                             (image_name, proj_name))
            return
        except nc_exc.NoUniqueMatch:
            self._svc_syslog("Error: Multiple images %s found in project %s" %
                             (image_name, proj_name))
            return

        # launch vm
        self._svc_syslog('Launching VM : ' + vm_name)
        nova_vm = n_client.servers.create(name=vm_name,
                                          image=image,
                                          flavor=flavor,
                                          nics=nics)
        nova_vm.get()
        self._svc_syslog('Created VM : ' + str(nova_vm))
        return nova_vm

    # end create_svc_vm

    def _create_svc_vn(self, vn_name, vn_subnet, proj_obj):
        self._svc_syslog("Creating network %s subnet %s" %
                         (vn_name, vn_subnet))

        vn_obj = VirtualNetwork(name=vn_name, parent_obj=proj_obj)
        domain_name, project_name = proj_obj.get_fq_name()
        ipam_fq_name = [domain_name, 'default-project', 'default-network-ipam']
        ipam_obj = self._vnc_lib.network_ipam_read(fq_name=ipam_fq_name)
        cidr = vn_subnet.split('/')
        pfx = cidr[0]
        pfx_len = int(cidr[1])
        subnet_info = IpamSubnetType(subnet=SubnetType(pfx, pfx_len))
        subnet_data = VnSubnetsType([subnet_info])
        vn_obj.add_network_ipam(ipam_obj, subnet_data)
        self._vnc_lib.virtual_network_create(vn_obj)

        return vn_obj.uuid

    # end _create_svc_vn

    def _cassandra_init(self):
        server_idx = 0
        num_dbnodes = len(self._args.cassandra_server_list)
        connected = False
        while not connected:
            try:
                cass_server = self._args.cassandra_server_list[server_idx]
                sys_mgr = SystemManager(cass_server)
                connected = True
            except Exception as e:
                server_idx = (server_idx + 1) % num_dbnodes
                time.sleep(3)

        if self._args.reset_config:
            try:
                sys_mgr.drop_keyspace(SvcMonitor._KEYSPACE)
            except pycassa.cassandra.ttypes.InvalidRequestException as e:
                print "Warning! " + str(e)

        try:
            sys_mgr.create_keyspace(SvcMonitor._KEYSPACE, SIMPLE_STRATEGY,
                                    {'replication_factor': str(num_dbnodes)})
        except pycassa.cassandra.ttypes.InvalidRequestException as e:
            print "Warning! " + str(e)

        column_families = [
            self._SVC_VM_CF, self._SVC_CLEANUP_CF, self._SVC_SI_CF
        ]
        for cf in column_families:
            try:
                sys_mgr.create_column_family(SvcMonitor._KEYSPACE, cf)
            except pycassa.cassandra.ttypes.InvalidRequestException as e:
                print "Warning! " + str(e)

        conn_pool = pycassa.ConnectionPool(SvcMonitor._KEYSPACE,
                                           self._args.cassandra_server_list)

        rd_consistency = pycassa.cassandra.ttypes.ConsistencyLevel.QUORUM
        wr_consistency = pycassa.cassandra.ttypes.ConsistencyLevel.QUORUM
        self._svc_vm_cf = pycassa.ColumnFamily(
            conn_pool,
            self._SVC_VM_CF,
            read_consistency_level=rd_consistency,
            write_consistency_level=wr_consistency)
        self._svc_si_cf = pycassa.ColumnFamily(
            conn_pool,
            self._SVC_SI_CF,
            read_consistency_level=rd_consistency,
            write_consistency_level=wr_consistency)
        self._cleanup_cf = pycassa.ColumnFamily(
            conn_pool,
            self._SVC_CLEANUP_CF,
            read_consistency_level=rd_consistency,
            write_consistency_level=wr_consistency)
Esempio n. 30
0
class SvcMonitor(object):

    """
    data + methods used/referred to by ssrc and arc greenlets
    """

    _KEYSPACE = 'svc_monitor_keyspace'
    _SVC_VM_CF = 'svc_vm_table'
    _SVC_SI_CF = 'svc_si_table'
    _SVC_CLEANUP_CF = 'svc_cleanup_table'

    def __init__(self, vnc_lib, args=None):
        self._args = args

        # api server and cassandra init
        self._vnc_lib = vnc_lib
        self._cassandra_init()

        # dictionary for nova
        self._nova = {}

        #initialize discovery client
        self._disc = None
        if self._args.disc_server_ip and self._args.disc_server_port:
            self._disc = client.DiscoveryClient(self._args.disc_server_ip,
                                                self._args.disc_server_port,
                                                client_type='Service Monitor')

        #sandesh init
        self._sandesh = Sandesh()
        sandesh.ServiceInstanceList.handle_request =\
            self.sandesh_si_handle_request
        self._sandesh.init_generator(
            ModuleNames[Module.SVC_MONITOR], socket.gethostname(),
            self._args.collectors, 'svc_monitor_context',
            int(self._args.http_server_port), ['cfgm_common', 'sandesh'],
            self._disc)
        self._sandesh.set_logging_params(enable_local_log=self._args.log_local,
                                         category=self._args.log_category,
                                         level=self._args.log_level,
                                         file=self._args.log_file)

        #create default analyzer template
        self._create_default_template('analyzer-template', 'analyzer',
                                      'analyzer')
        self._create_default_template('nat-template', 'nat-service',
                                      'firewall', 'in-network-nat')

        #create cpu_info object to send periodic updates
        sysinfo_req = False
        cpu_info = vnc_cpu_info.CpuInfo(
            Module.SVC_MONITOR, sysinfo_req, self._sandesh, 60)
        self._cpu_info = cpu_info

        # logging
        self._err_file = '/var/log/contrail/svc-monitor.err'
        self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
        self._svc_err_logger = logging.getLogger('SvcErrLogger')
        self._svc_err_logger.setLevel(logging.ERROR)
        handler = logging.handlers.RotatingFileHandler(
            self._err_file, maxBytes=64*1024, backupCount=2)
        self._svc_err_logger.addHandler(handler)
    # end __init__

    # create service template
    def _create_default_template(self, st_name, image_name,
                                 svc_type, svc_mode=None):
        domain_name = 'default-domain'
        domain_fq_name = [domain_name]
        st_fq_name = [domain_name, st_name]
        self._svc_syslog("Creating %s %s image %s" %
                         (domain_name, st_name, image_name))

        try:
            st_obj = self._vnc_lib.service_template_read(fq_name=st_fq_name)
            st_uuid = st_obj.uuid
        except NoIdError:
            domain = self._vnc_lib.domain_read(fq_name=domain_fq_name)
            st_obj = ServiceTemplate(name=st_name, domain_obj=domain)
            st_uuid = self._vnc_lib.service_template_create(st_obj)

        svc_properties = ServiceTemplateType()
        svc_properties.set_image_name(image_name)
        svc_properties.set_service_type(svc_type)

        # set interface list
        if svc_type == 'analyzer':
            if_list = [['left', False]]
        else:
            if_list = [
                ['left', False], ['right', False], ['management', False]]
            svc_properties.set_service_mode(svc_mode)

        for itf in if_list:
            if_type = ServiceTemplateInterfaceType(shared_ip=itf[1])
            if_type.set_service_interface_type(itf[0])
            svc_properties.add_interface_type(if_type)

        try:
            st_obj.set_service_template_properties(svc_properties)
            self._vnc_lib.service_template_update(st_obj)
        except Exception as e:
            print e

        self._svc_syslog("%s created with uuid %s" % (st_name, str(st_uuid)))
    #_create_default_analyzer_template

    def cleanup(self):
        # TODO cleanup sandesh context
        pass
    # end cleanup

    def _sandesh_populate_vn_info(self, si_info, sandesh_si):
        for if_str in [_LEFT_STR, _RIGHT_STR, _MGMT_STR]:
            if_set = set()
            if_str_vn = if_str + '-vn'
            if not if_str_vn in si_info.keys():
                continue

            vn_fq_str = str(si_info[if_str_vn])
            vn_uuid = str(si_info[vn_fq_str])
            vn_str = ("VN [%s : %s]" % (vn_fq_str, vn_uuid))
            if_set.add(vn_str)

            iip_uuid_str = if_str + '-iip-uuid'
            if iip_uuid_str in si_info.keys():
                vn_iip_uuid = str(si_info[iip_uuid_str])
                iip_addr_str = if_str + '-iip-addr'
                vn_iip_addr = str(si_info[iip_addr_str])
                iip_str = ("IIP [%s : %s]" % (vn_iip_addr, vn_iip_uuid))
                if_set.add(iip_str)

            if if_str == _LEFT_STR:
                sandesh_si.left_vn = list(if_set)
            if if_str == _RIGHT_STR:
                sandesh_si.right_vn = list(if_set)
            if if_str == _MGMT_STR:
                sandesh_si.management_vn = list(if_set)

            si_info['done'] = True
    # end _sandesh_populate_vn_info

    def sandesh_si_handle_request(self, req):
        si_resp = sandesh.ServiceInstanceListResp(si_names=[])
        if req.si_name is None:
            vm_list = list(self._svc_vm_cf.get_range())
            si_list = list(self._svc_si_cf.get_range())

            #walk all vms
            for vm_uuid, si in vm_list:
                if 'done' in si:
                    continue

                #collect all ecmp instances
                sandesh_si = sandesh.ServiceInstance(name=si['si_fq_str'])
                vm_set = set()
                for key, val in vm_list:
                    if val['si_fq_str'] != si['si_fq_str']:
                        continue
                    vm_str = ("%s: %s" % (val['instance_name'], key))
                    vm_set.add(vm_str)
                    val['done'] = True
                sandesh_si.vm_list = list(vm_set)

                #find the vn and iip iformation
                for si_fq_str, si_info in si_list:
                    if si_fq_str != si['si_fq_str']:
                        continue
                    self._sandesh_populate_vn_info(si_info, sandesh_si)
                    si_info['done'] = True
                si_resp.si_names.append(sandesh_si)

            #walk all instances where vms are pending launch
            for si_fq_str, si_info in si_list:
                if 'done' in si_info.keys():
                    continue
                sandesh_si = sandesh.ServiceInstance(name=si_fq_str)
                sandesh_si.vm_list = set()
                sandesh_si.instance_name = ''
                self._sandesh_populate_vn_info(si_info, sandesh_si)
                si_resp.si_names.append(sandesh_si)

        si_resp.response(req.context())
    # end sandesh_si_handle_request

    def _utc_timestamp_usec(self):
        epoch = datetime.datetime.utcfromtimestamp(0)
        now = datetime.datetime.utcnow()
        delta = now - epoch
        return (delta.microseconds +
                (delta.seconds + delta.days * 24 * 3600) * 10 ** 6)
    # end utc_timestamp_usec

    def _uve_svc_instance(self, si_fq_name_str, status=None,
                          vm_uuid=None, st_name=None):
        svc_uve = UveSvcInstanceConfig(name=si_fq_name_str,
                                       deleted=False, st_name=None,
                                       vm_list=[], create_ts=None)

        if st_name:
            svc_uve.st_name = st_name
        if vm_uuid:
            svc_uve.vm_list.append(vm_uuid)
        if status:
            svc_uve.status = status
            if status == 'CREATE':
                svc_uve.create_ts = self._utc_timestamp_usec()
            elif status == 'DELETE':
                svc_uve.deleted = True

        svc_log = UveSvcInstanceConfigTrace(
            data=svc_uve, sandesh=self._sandesh)
        svc_log.send(sandesh=self._sandesh)
    # end uve_vm

    def _svc_syslog(self, log_msg):
        self._sandesh._logger.debug("%s", log_msg)
        vn_log = sandesh.SvcMonitorLog(
            log_msg=log_msg, sandesh=self._sandesh)
        vn_log.send(sandesh=self._sandesh)
    # end _svc_syslog

    def _get_proj_name_from_si_fq_str(self, si_fq_str):
        return si_fq_str.split(':')[1]
    # enf _get_si_fq_str_to_proj_name

    def _get_vn_id(self, proj_obj, vn_fq_name,
                   shared_vn_name=None,
                   shared_vn_subnet=None):
        vn_id = None

        if vn_fq_name:
            # search for provided VN
            try:
                vn_id = self._vnc_lib.fq_name_to_id(
                    'virtual-network', vn_fq_name)
            except NoIdError:
                self._svc_syslog("Error: vn_name %s not found" % (vn_name))
        else:
            # search or create shared VN
            domain_name, proj_name = proj_obj.get_fq_name()
            vn_fq_name = [domain_name, proj_name, shared_vn_name]
            try:
                vn_id = self._vnc_lib.fq_name_to_id(
                    'virtual-network', vn_fq_name)
            except NoIdError:
                vn_id = self._create_svc_vn(shared_vn_name, shared_vn_subnet,
                                            proj_obj)

        return vn_id
    # end _get_vn_id

    def _set_svc_vm_if_properties(self, vmi_obj, vn_obj):
        # confirm service vm by checking reference to service instance
        vm_obj = self._vnc_lib.virtual_machine_read(
            fq_name_str=vmi_obj.parent_name)
        si_list = vm_obj.get_service_instance_refs()
        if not si_list:
            return

        # if interface property already set
        if vmi_obj.get_virtual_machine_interface_properties() is not None:
            return

        # get service instance
        fq_name = si_list[0]['to']
        si_obj = self._vnc_lib.service_instance_read(fq_name=fq_name)
        si_props = si_obj.get_service_instance_properties()
        si_if_list = si_props.get_interface_list()
        si_if = None

        # get service template
        st_list = si_obj.get_service_template_refs()
        if st_list is not None:
            fq_name = st_list[0]['to']
            st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
        st_props = st_obj.get_service_template_properties()
        st_if_list = st_props.get_interface_type()

        # set interface type
        vn_fq_name_str = vn_obj.get_fq_name_str()
        for idx in range(0, len(st_if_list)):
            st_if = st_if_list[idx]
            itf_type = st_if.service_interface_type

            si_if = None
            if si_if_list:
                si_if = si_if_list[idx]
                si_vn_str = si_if.get_virtual_network()
            else:
                funcname = "get_" + itf_type + "_virtual_network"
                func = getattr(si_props, funcname)
                si_vn_str = func()

            if (((itf_type == _MGMT_STR) and (vn_obj.name == _SVC_VN_MGMT))
                    or ((itf_type == _LEFT_STR) and
                        (vn_obj.name == _SVC_VN_LEFT))
                    or ((itf_type == _RIGHT_STR) and
                        (vn_obj.name == _SVC_VN_RIGHT))
                    or ((si_vn_str == vn_fq_name_str))):
                if_properties = VirtualMachineInterfacePropertiesType(itf_type)
                vmi_obj.set_virtual_machine_interface_properties(if_properties)
                break

        # set static routes
        if st_if.get_static_route_enable():
            static_routes = si_if.get_static_routes()
            try:
                domain_name, proj_name = si_obj.get_parent_fq_name()
                rt_name = si_obj.uuid + ' ' + str(idx)
                rt_fq_name = [domain_name, proj_name, rt_name]
                rt_obj = self._vnc_lib.interface_route_table_read(
                    fq_name=rt_fq_name)
                rt_obj.set_interface_route_table_routes(static_routes)
            except NoIdError:
                proj_obj = self._vnc_lib.project_read(
                    fq_name=si_obj.get_parent_fq_name())
                rt_obj = InterfaceRouteTable(
                    name=rt_name,
                    parent_obj=proj_obj,
                    interface_route_table_routes=static_routes)
                self._vnc_lib.interface_route_table_create(rt_obj)
            vmi_obj.set_interface_route_table(rt_obj)

        # remove security groups and update vmi
        vmi_obj.set_security_group_list([])
        self._vnc_lib.virtual_machine_interface_update(vmi_obj)
    # end _set_svc_vm_if_properties

    def _create_svc_instance_vm(self, st_obj, si_obj):
        #check if all config received before launch
        if not self._check_store_si_info(st_obj, si_obj):
            return

        row_entry = {}
        st_props = st_obj.get_service_template_properties()
        if st_props is None:
            return
        st_if_list = st_props.get_interface_type()

        flavor = st_props.get_flavor()
        image_name = st_props.get_image_name()
        if image_name is None:
            self._svc_syslog("Error: Image name not present in %s" %
                             (st_obj.name))
            return

        si_props = si_obj.get_service_instance_properties()
        max_instances = si_props.get_scale_out().get_max_instances()
        si_if_list = si_props.get_interface_list()
        if si_if_list and (len(si_if_list) != len(st_if_list)):
            self._svc_syslog("Error: IF mismatch template %s instance %s" %
                             (len(st_if_list), len(si_if_list)))
            return

        # check and create service virtual networks
        nics = []
        proj_fq_name = si_obj.get_parent_fq_name()
        proj_obj = self._vnc_lib.project_read(fq_name=proj_fq_name)
        for idx in range(0, len(st_if_list)):
            nic = {}
            st_if = st_if_list[idx]
            itf_type = st_if.service_interface_type

            # set vn id
            if si_if_list:
                si_if = si_if_list[idx]
                vn_fq_name_str = si_if.get_virtual_network()
            else:
                funcname = "get_" + itf_type + "_virtual_network"
                func = getattr(si_props, funcname)
                vn_fq_name_str = func()

            vn_fq_name = None
            if vn_fq_name_str:
                domain, proj, vn_name = vn_fq_name_str.split(':')
                vn_fq_name = [domain, proj, vn_name]

            vn_id = self._get_vn_id(proj_obj, vn_fq_name,
                                    _SVC_VNS[itf_type][0],
                                    _SVC_VNS[itf_type][1])
            if vn_id is None:
                continue
            nic['net-id'] = vn_id

            # set shared ip
            if st_if.shared_ip:
                try:
                    iip_dict = self._svc_si_cf.get(si_obj.get_fq_name_str())
                    iip_uuid_str = itf_type + '-iip-uuid'
                    if iip_uuid_str in iip_dict.keys():
                        nic['v4-fixed-ip'] = iip_dict[itf_type + '-iip-addr']
                except pycassa.NotFoundException:
                    self._svc_syslog(
                        "Error: Shared IP not found in db for %s" % (itf_type))

            # add to nic list
            nics.append(nic)

        # create and launch vm
        vm_refs = si_obj.get_virtual_machine_back_refs()
        n_client = self._novaclient_get(proj_obj.name)
        for inst_count in range(0, max_instances):
            instance_name = si_obj.name + '_' + str(inst_count + 1)
            exists = False
            for vm_ref in vm_refs or []:
                vm = n_client.servers.find(id=vm_ref['uuid'])
                if vm.name == instance_name:
                    exists = True
                    break

            if exists:
                vm_uuid = vm_ref['uuid']
            else:
                vm = self._create_svc_vm(instance_name, image_name,
                                         nics, proj_obj.name, flavor)
                if vm is None:
                    continue
                vm_uuid = vm.id

            # store vm, instance in cassandra; use for linking when VM is up
            row_entry['si_fq_str'] = si_obj.get_fq_name_str()
            row_entry['instance_name'] = instance_name
            self._svc_vm_cf.insert(vm_uuid, row_entry)

            # uve trace
            self._uve_svc_instance(si_obj.get_fq_name_str(),
                                   status='CREATE', vm_uuid=vm.id,
                                   st_name=st_obj.get_fq_name_str())
    # end _create_svc_instance_vm

    def _delete_svc_instance_vm(self, vm_uuid, proj_name, si_fq_str=None):
        found = True
        try:
            self._svc_syslog("Deleting VM %s %s" % (proj_name, vm_uuid))
            n_client = self._novaclient_get(proj_name)
            vm = n_client.servers.find(id=vm_uuid)
            vm.delete()
            self._uve_svc_instance(
                si_fq_str, status='DELETE', vm_uuid=vm_uuid)
        except nc_exc.NotFound:
            # remove from cleanup list
            self._cleanup_cf.remove(vm_uuid)
            found = False

        # remove from launch table and queue into cleanup list
        if found:
            self._svc_vm_cf.remove(vm_uuid)
            self._cleanup_cf.insert(
                vm_uuid, {'proj_name': proj_name, 'type': 'vm'})
    # end _delete_svc_instance_vm

    def _restart_svc_vm(self, vm_uuid, si_fq_str):
        proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
        self._delete_svc_instance_vm(vm_uuid, proj_name, si_fq_str=si_fq_str)

        si_obj = self._vnc_lib.service_instance_read(fq_name_str=si_fq_str)
        st_list = si_obj.get_service_template_refs()
        if st_list is not None:
            fq_name = st_list[0]['to']
            st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)
            self._create_svc_instance_vm(st_obj, si_obj)
    # end _restart_svc_vm

    def _check_store_si_info(self, st_obj, si_obj):
        config_complete = True
        st_props = st_obj.get_service_template_properties()
        si_props = si_obj.get_service_instance_properties()
        if_list = st_props.get_interface_type()

        #read existing si_entry
        try:
            si_entry = self._svc_si_cf.get(si_obj.get_fq_name_str())
        except Exception:
            si_entry = {}

        #walk the interface list
        for vm_if in if_list:
            itf_type = vm_if.service_interface_type
            funcname = "get_" + itf_type + "_virtual_network"
            func = getattr(si_props, funcname)
            vn_fq_name_str = func()
            if not vn_fq_name_str:
                continue

            si_entry[itf_type + '-vn'] = vn_fq_name_str
            try:
                vn_obj = self._vnc_lib.virtual_network_read(
                    fq_name_str=vn_fq_name_str)
                if vn_obj.uuid != si_entry.get(vn_fq_name_str, None):
                    si_entry[vn_fq_name_str] = vn_obj.uuid

                if not vm_if.shared_ip:
                    continue

                iip_uuid_str = itf_type + '-iip-uuid'
                iip_uuid = si_entry.get(iip_uuid_str, None)
                iip = self._allocate_shared_iip(st_obj, si_obj,
                                                vn_obj, iip_uuid)
                si_entry[itf_type + '-iip-uuid'] = iip['uuid']
                si_entry[itf_type + '-iip-addr'] = iip['addr']
            except NoIdError:
                self._svc_syslog("Warn: VN %s add is pending" % vn_fq_name_str)
                si_entry[vn_fq_name_str] = 'pending'
                config_complete = False

        if config_complete:
            self._svc_syslog("SI %s info is complete" %
                             si_obj.get_fq_name_str())
        else:
            self._svc_syslog("Warn: SI %s info is not complete" %
                             si_obj.get_fq_name_str())

        #insert entry
        self._svc_si_cf.insert(si_obj.get_fq_name_str(), si_entry)
        return config_complete
    #end _check_store_si_info

    def _allocate_shared_iip(self, st_obj, si_obj, vn_obj, iip_uuid):
        iip_entry = {}
        iip_obj = None

        if iip_uuid:
            try:
                iip_obj = self._vnc_lib.instance_ip_read(id=iip_uuid)
            except NoIdError:
                pass

        # allocate ip
        if not iip_obj:
            addr = self._vnc_lib.virtual_network_ip_alloc(vn_obj)
            iip_name = '%s %s' % (vn_obj.uuid, addr[0])
            iip_obj = InstanceIp(name=iip_name,
                                 instance_ip_address=addr[0])
            iip_obj.add_virtual_network(vn_obj)
            self._vnc_lib.instance_ip_create(iip_obj)

        iip_entry = {'uuid': iip_obj.uuid,
                     'addr': iip_obj.get_instance_ip_address()}

        return iip_entry
    #end _allocate_shared_iip

    def _delete_shared_vn(self, vn_uuid, proj_name):
        try:
            self._svc_syslog("Deleting VN %s %s" % (proj_name, vn_uuid))
            self._vnc_lib.virtual_network_delete(id=vn_uuid)
        except RefsExistError:
            self._svc_err_logger.error("Delete failed refs exist VN %s %s" %
                                       (proj_name, vn_uuid))
        except NoIdError:
            # remove from cleanup list
            self._cleanup_cf.remove(vn_uuid)
    # end _delete_shared_vn

    def _delete_shared_iip(self, iip_uuid, proj_name):
        try:
            iip_obj = self._vnc_lib.instance_ip_read(id=iip_uuid)
            vmi_refs = iip_obj.get_virtual_machine_interface_refs()
            if vmi_refs is None:
                self._svc_syslog("Deleting IIP %s %s" % (proj_name, iip_uuid))
                self._vnc_lib.instance_ip_delete(id=iip_uuid)
        except RefsExistError:
            self._svc_err_logger.error("Delete failed refs exist IIP %s %s" %
                                       (proj_name, iip_uuid))
        except NoIdError:
            # remove from cleanup list
            self._cleanup_cf.remove(iip_uuid)
    # end _delete_shared_iip

    def _delmsg_project_service_instance(self, idents):
        proj_fq_str = idents['project']
        proj_obj = self._vnc_lib.project_read(fq_name_str=proj_fq_str)
        if proj_obj.get_service_instances() is not None:
            return

        # no SIs left hence delete shared VNs
        for vn_name in [_SVC_VN_MGMT, _SVC_VN_LEFT, _SVC_VN_RIGHT]:
            domain_name, proj_name = proj_obj.get_fq_name()
            vn_fq_name = [domain_name, proj_name, vn_name]
            try:
                vn_uuid = self._vnc_lib.fq_name_to_id(
                    'virtual-network', vn_fq_name)
                self._cleanup_cf.insert(
                    vn_uuid, {'proj_name': proj_obj.name, 'type': 'vn'})
            except Exception:
                pass
    # end _delmsg_project_service_instance

    def _delmsg_service_instance_service_template(self, idents):
        si_fq_str = idents['service-instance']

        vm_list = list(self._svc_vm_cf.get_range())
        for vm_uuid, si in vm_list:
            if si_fq_str != si['si_fq_str']:
                continue

            proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
            self._delete_svc_instance_vm(
                vm_uuid, proj_name, si_fq_str=si_fq_str)

            #insert shared instance IP uuids into cleanup list if present
            try:
                si_info = self._svc_si_cf.get(si_fq_str)
                for itf_str in [_MGMT_STR, _LEFT_STR, _RIGHT_STR]:
                    iip_uuid_str = itf_str + '-iip-uuid'
                    if not iip_uuid_str in si_info:
                        continue
                    self._cleanup_cf.insert(
                        si_info[iip_uuid_str], {'proj_name': proj_name,
                                                'type': 'iip'})
            except pycassa.NotFoundException:
                pass

        #delete si info
        try:
            self._svc_si_cf.remove(si_fq_str)
        except pycassa.NotFoundException:
            pass
    #end _delmsg_service_instance_service_template

    def _delmsg_virtual_machine_service_instance(self, idents):
        vm_uuid = idents['virtual-machine']
        si_fq_str = idents['service-instance']
        proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
        self._delete_svc_instance_vm(vm_uuid, proj_name, si_fq_str=si_fq_str)
    # end _delmsg_service_instance_virtual_machine

    def _delmsg_virtual_machine_interface_route_table(self, idents):
        rt_fq_str = idents['interface-route-table']

        rt_obj = self._vnc_lib.interface_route_table_read(
            fq_name_str=rt_fq_str)
        vmi_list = rt_obj.get_virtual_machine_interface_back_refs()
        if vmi_list is None:
            self._vnc_lib.interface_route_table_delete(id=rt_obj.uuid)
    # end _delmsg_virtual_machine_interface_route_table

    def _addmsg_virtual_machine_interface_virtual_network(self, idents):
        vmi_fq_str = idents['virtual-machine-interface']
        vn_fq_str = idents['virtual-network']

        try:
            vmi_obj = self._vnc_lib.virtual_machine_interface_read(
                fq_name_str=vmi_fq_str)
            vn_obj = self._vnc_lib.virtual_network_read(
                fq_name_str=vn_fq_str)
        except NoIdError:
            return

        # check if this is a service vm
        vm_obj = self._vnc_lib.virtual_machine_read(
            fq_name_str=vmi_obj.parent_name)
        si_list = vm_obj.get_service_instance_refs()
        if si_list:
            fq_name = si_list[0]['to']
            si_obj = self._vnc_lib.service_instance_read(fq_name=fq_name)
        else:
            try:
                svc_vm_cf_row = self._svc_vm_cf.get(vm_obj.uuid)
                si_fq_str = svc_vm_cf_row['si_fq_str']
                vm_obj.name = svc_vm_cf_row['instance_name']
                si_obj = self._vnc_lib.service_instance_read(
                    fq_name_str=si_fq_str)
            except pycassa.NotFoundException:
                return
            except NoIdError:
                proj_name = self._get_proj_name_from_si_fq_str(si_fq_str)
                self._delete_svc_instance_vm(
                    vm_obj.uuid, proj_name, si_fq_str=si_fq_str)
                return

        # create service instance to service vm link
        vm_obj.add_service_instance(si_obj)
        self._vnc_lib.virtual_machine_update(vm_obj)

        # set service instance property
        self._set_svc_vm_if_properties(vmi_obj, vn_obj)

    # end _addmsg_virtual_machine_interface_virtual_network

    def _addmsg_service_instance_service_template(self, idents):
        st_fq_str = idents['service-template']
        si_fq_str = idents['service-instance']

        try:
            st_obj = self._vnc_lib.service_template_read(
                fq_name_str=st_fq_str)
            si_obj = self._vnc_lib.service_instance_read(
                fq_name_str=si_fq_str)
        except NoIdError:
            return

        #launch VMs
        self._create_svc_instance_vm(st_obj, si_obj)
    # end _addmsg_service_instance_service_template

    def _addmsg_project_virtual_network(self, idents):
        vn_fq_str = idents['virtual-network']

        try:
            si_list = list(self._svc_si_cf.get_range())
        except pycassa.NotFoundException:
            return

        for si_fq_str, si_info in si_list:
            if vn_fq_str not in si_info.keys():
                continue

            try:
                si_obj = self._vnc_lib.service_instance_read(
                    fq_name_str=si_fq_str)
                st_refs = si_obj.get_service_template_refs()
                fq_name = st_refs[0]['to']
                st_obj = self._vnc_lib.service_template_read(fq_name=fq_name)

                #launch VMs
                self._create_svc_instance_vm(st_obj, si_obj)
            except Exception:
                continue
    #end _addmsg_project_virtual_network

    def process_poll_result(self, poll_result_str):
        result_list = parse_poll_result(poll_result_str)

        # process ifmap message
        for (result_type, idents, metas) in result_list:
            for meta in metas:
                meta_name = re.sub('{.*}', '', meta.tag)
                if result_type == 'deleteResult':
                    funcname = "_delmsg_" + meta_name.replace('-', '_')
                elif result_type in ['searchResult', 'updateResult']:
                    funcname = "_addmsg_" + meta_name.replace('-', '_')
                    self._svc_syslog("%s with %s/%s" %
                                     (funcname, meta_name, idents))
                # end if result_type
                try:
                    func = getattr(self, funcname)
                except AttributeError:
                    pass
                else:
                    self._svc_syslog("%s with %s/%s"
                                     % (funcname, meta_name, idents))
                    func(idents)
            # end for meta
        # end for result_type
    # end process_poll_result

    def _novaclient_get(self, proj_name):
        client = self._nova.get(proj_name)
        if client is not None:
            return client

        self._nova[proj_name] = nc.Client(
            '2', username=self._args.admin_user, project_id=proj_name,
            api_key=self._args.admin_password,
            auth_url='http://' + self._args.auth_host + ':5000/v2.0')
        return self._nova[proj_name]
    # end _novaclient_get

    def _create_svc_vm(self, vm_name, image_name, nics,
                       proj_name, flavor_name):
        n_client = self._novaclient_get(proj_name)
        if flavor_name:
            flavor = n_client.flavors.find(name=flavor_name)
        else:
            flavor = n_client.flavors.find(ram=4096)

        image = ''
        try:
            image = n_client.images.find(name=image_name)
        except nc_exc.NotFound:
            self._svc_syslog(
                "Error: Image %s not found in project %s"
                % (image_name, proj_name))
            return
        except nc_exc.NoUniqueMatch:
            self._svc_syslog(
                "Error: Multiple images %s found in project %s"
                % (image_name, proj_name))
            return

        # launch vm
        self._svc_syslog('Launching VM : ' + vm_name)
        nova_vm = n_client.servers.create(name=vm_name, image=image,
                                          flavor=flavor, nics=nics)
        nova_vm.get()
        self._svc_syslog('Created VM : ' + str(nova_vm))
        return nova_vm
    # end create_svc_vm

    def _create_svc_vn(self, vn_name, vn_subnet, proj_obj):
        self._svc_syslog(
            "Creating network %s subnet %s" % (vn_name, vn_subnet))

        vn_obj = VirtualNetwork(name=vn_name, parent_obj=proj_obj)
        domain_name, project_name = proj_obj.get_fq_name()
        ipam_fq_name = [domain_name, 'default-project', 'default-network-ipam']
        ipam_obj = self._vnc_lib.network_ipam_read(fq_name=ipam_fq_name)
        cidr = vn_subnet.split('/')
        pfx = cidr[0]
        pfx_len = int(cidr[1])
        subnet_info = IpamSubnetType(subnet=SubnetType(pfx, pfx_len))
        subnet_data = VnSubnetsType([subnet_info])
        vn_obj.add_network_ipam(ipam_obj, subnet_data)
        self._vnc_lib.virtual_network_create(vn_obj)

        return vn_obj.uuid
    # end _create_svc_vn

    def _cassandra_init(self):
        sys_mgr = SystemManager(self._args.cassandra_server_list[0])

        if self._args.reset_config:
            try:
                sys_mgr.drop_keyspace(SvcMonitor._KEYSPACE)
            except pycassa.cassandra.ttypes.InvalidRequestException as e:
                print "Warning! " + str(e)

        try:
            sys_mgr.create_keyspace(SvcMonitor._KEYSPACE, SIMPLE_STRATEGY,
                                    {'replication_factor': '1'})
        except pycassa.cassandra.ttypes.InvalidRequestException as e:
            print "Warning! " + str(e)

        column_families = [self._SVC_VM_CF,
                           self._SVC_CLEANUP_CF,
                           self._SVC_SI_CF]
        for cf in column_families:
            try:
                sys_mgr.create_column_family(SvcMonitor._KEYSPACE, cf)
            except pycassa.cassandra.ttypes.InvalidRequestException as e:
                print "Warning! " + str(e)

        conn_pool = pycassa.ConnectionPool(SvcMonitor._KEYSPACE,
                                           self._args.cassandra_server_list)
        self._svc_vm_cf = pycassa.ColumnFamily(conn_pool, self._SVC_VM_CF)
        self._svc_si_cf = pycassa.ColumnFamily(conn_pool, self._SVC_SI_CF)
        self._cleanup_cf = pycassa.ColumnFamily(conn_pool,
                                                self._SVC_CLEANUP_CF)
Esempio n. 31
0
class MesosManagerLogger(object):

    def __init__(self, args=None):
        self._args = args

        # Initialize module parameters.
        self.module = {}
        self.module["id"] = Module.MESOS_MANAGER
        self.module["name"] = ModuleNames[self.module["id"]]
        self.module["node_type"] = Module2NodeType[self.module["id"]]
        self.module["node_type_name"] = NodeTypeNames[self.module["node_type"]]
        if 'host_ip' in self._args:
            host_ip = self._args.host_ip
        else:
            host_ip = socket.gethostbyname(socket.getfqdn())
        self.module["hostname"] = socket.getfqdn(host_ip)
        self.module["table"] = "ObjectConfigNode"
        if self._args.worker_id:
            self.module["instance_id"] = self._args.worker_id
        else:
            self.module["instance_id"] = INSTANCE_ID_DEFAULT

        # Init Sandesh.
        self.sandesh_init()

    def syslog(self, log_msg, level):
        # Log to syslog.
        self._sandesh.logger().log(
            SandeshLogger.get_py_logger_level(level), log_msg)

    def log(self, log_msg, level=SandeshLevel.SYS_DEBUG, fun=None):
        # If a sandesh function is provided, use the function.
        # If not, revert to syslog.
        if fun:
            log = fun(level=level, log_msg=log_msg, sandesh=self._sandesh)
            log.send(sandesh=self._sandesh)
        else:
            self.syslog(log_msg, level)

    # EMERGENCY.
    def emergency(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_EMERG
        logging_fun = log_fun if log_fun else sandesh.MesosManagerEmergencyLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # ALERT.
    def alert(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ALERT
        logging_fun = log_fun if log_fun else sandesh.MesosManagerAlertLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def critical(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_CRIT
        logging_fun = log_fun if log_fun else sandesh.MesosManagerCriticalLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def error(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ERR
        logging_fun = log_fun if log_fun else sandesh.MesosManagerErrorLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # WARNING.
    def warning(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_WARN
        logging_fun = log_fun if log_fun else sandesh.MesosManagerWarningLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # NOTICE.
    def notice(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_NOTICE
        logging_fun = log_fun if log_fun else sandesh.MesosManagerNoticeLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # INFO.
    def info(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_INFO
        logging_fun = log_fun if log_fun else sandesh.MesosManagerInfoLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # DEBUG.
    def debug(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_DEBUG
        logging_fun = log_fun if log_fun else sandesh.MesosManagerDebugLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    def redefine_sandesh_handles(self):
        """ Register custom introspect handlers. """

        # Register Virtual Machine DB introspect handler.
        introspect.VirtualMachineDatabaseList.handle_request = \
            VirtualMachineMM.sandesh_handle_db_list_request

        # Register Virtual Router DB introspect handler.
        introspect.VirtualRouterDatabaseList.handle_request = \
            VirtualRouterMM.sandesh_handle_db_list_request

        # Register Virtual Machine Interface DB introspect handler.
        introspect.VirtualMachineInterfaceDatabaseList.handle_request = \
            VirtualMachineInterfaceMM.sandesh_handle_db_list_request

        # Register Virtual Network DB introspect handler.
        introspect.VirtualNetworkDatabaseList.handle_request = \
            VirtualNetworkMM.sandesh_handle_db_list_request

        # Register Instance IP DB introspect handler.
        introspect.InstanceIpDatabaseList.handle_request = \
            InstanceIpMM.sandesh_handle_db_list_request

        # Register Project DB introspect handler.
        introspect.ProjectDatabaseList.handle_request = \
            ProjectMM.sandesh_handle_db_list_request

        # Register Domain DB introspect handler.
        introspect.DomainDatabaseList.handle_request = \
            DomainMM.sandesh_handle_db_list_request

        # Register NetworkIpam DB introspect handler.
        introspect.NetworkIpamDatabaseList.handle_request = \
            NetworkIpamMM.sandesh_handle_db_list_request

    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Register custom sandesh request handlers.
        self.redefine_sandesh_handles()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self.module['name'], self.module['hostname'],
            self.module['node_type_name'], self.module['instance_id'],
            self._args.collectors, 'mesos_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'mesos_manager.sandesh', 'mesos_introspect.sandesh'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level, file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(self._sandesh, self.module['hostname'],
            self.module['name'], self.module['instance_id'],
            staticmethod(ConnectionState.get_conn_state_cb),
            NodeStatusUVE, NodeStatus, self.module['table'])

    def introspect_init(self):
        self._sandesh.run_introspect_server(int(self._args.http_server_port))
class SandeshUVEAlarmTest(unittest.TestCase):
    def setUp(self):
        self.maxDiff = None
        self.sandesh = Sandesh()
        self.sandesh.init_generator('sandesh_uve_alarm_test',
                                    socket.gethostname(),
                                    'Test',
                                    '0',
                                    None,
                                    '',
                                    get_free_port(),
                                    connect_to_collector=False)
        # mock the sandesh client object
        self.sandesh._client = mock.MagicMock(spec=SandeshClient)

    # end setUp

    def tearDown(self):
        pass

    # end tearDown

    def verify_uve_alarm_sandesh(self, sandesh, seqnum, sandesh_type, data):
        self.assertEqual(socket.gethostname(), sandesh._source)
        self.assertEqual('Test', sandesh._node_type)
        self.assertEqual('sandesh_uve_alarm_test', sandesh._module)
        self.assertEqual('0', sandesh._instance_id)
        self.assertEqual(SANDESH_KEY_HINT, (SANDESH_KEY_HINT & sandesh._hints))
        self.assertEqual(sandesh_type, sandesh._type)
        self.assertEqual(seqnum, sandesh._seqnum)
        self.assertEqual(data, sandesh.data)

    # end verify_uve_alarm_sandesh

    def test_sandesh_uve(self):
        uve_data = [
            # add uve
            SandeshUVEData(name='uve1'),
            # update uve
            SandeshUVEData(name='uve1', xyz=345),
            # add another uve
            SandeshUVEData(name='uve2', xyz=12),
            # delete uve
            SandeshUVEData(name='uve2', deleted=True),
            # add deleted uve
            SandeshUVEData(name='uve2')
        ]

        # send UVEs
        for i in range(len(uve_data)):
            uve_test = SandeshUVETest(data=uve_data[i], sandesh=self.sandesh)
            uve_test.send(sandesh=self.sandesh)

        expected_data = [{
            'seqnum': i + 1,
            'data': uve_data[i]
        } for i in range(len(uve_data))]

        # send UVE with different key
        uve_test_data = SandeshUVEData(name='uve1')
        uve_test = SandeshUVETest(data=uve_test_data,
                                  table='CollectorInfo',
                                  sandesh=self.sandesh)
        uve_test.send(sandesh=self.sandesh)

        expected_data.extend([{'seqnum': 6, 'data': uve_test_data}])

        # send dynamic UVEs
        dynamic_uve_data = [
            # add uve
            {
                'type': (ConfigUVE, Config),
                'table': 'CollectorInfo',
                'name': 'node1',
                'elements': {
                    'log_level': 'SYS_INFO'
                },
                'expected_elements': {
                    'log_level': 'SYS_INFO'
                },
                'seqnum': 1
            },
            # update uve
            {
                'type': (ConfigUVE, Config),
                'table': 'CollectorInfo',
                'name': 'node1',
                'elements': {
                    'log_local': 'True'
                },
                'expected_elements': {
                    'log_local': 'True'
                },
                'seqnum': 2
            },
            # add another uve
            {
                'type': (ConfigUVE, Config),
                'table': 'ControlInfo',
                'name': 'node1',
                'elements': {
                    'log_category': 'Redis'
                },
                'expected_elements': {
                    'log_category': 'Redis'
                },
                'seqnum': 3
            },
            # delete uve
            {
                'type': (ConfigUVE, Config),
                'table': 'ControlInfo',
                'name': 'node1',
                'deleted': True,
                'seqnum': 4
            },
            # add deleted uve
            {
                'type': (ConfigUVE, Config),
                'table': 'ControlInfo',
                'name': 'node1',
                'elements': {
                    'log_level': 'SYS_DEBUG',
                    'log_file': '/var/log/control.log'
                },
                'expected_elements': {
                    'log_level': 'SYS_DEBUG',
                    'log_file': '/var/log/control.log'
                },
                'seqnum': 5
            },
            #  add another uve - different type
            {
                'type': (ConfigTestUVE, ConfigTest),
                'table': 'CollectorInfo',
                'name': 'node2',
                'elements': {
                    'param1': 'val1',
                    'param2': 'val2'
                },
                'expected_elements': {
                    'param1': 'val1',
                    'param2': 'val2'
                },
                'seqnum': 1
            },
            # delete uve, set elements to []
            {
                'type': (ConfigTestUVE, ConfigTest),
                'table': 'CollectorInfo',
                'name': 'node2',
                'deleted': True,
                'elements': {},
                'expected_elements': {},
                'seqnum': 2
            },
        ]

        for uve in dynamic_uve_data:
            uve_type, uve_data_type = uve['type']
            elts = uve.get('elements')
            uve_data = uve_data_type(name=uve['name'],
                                     elements=elts,
                                     deleted=uve.get('deleted'))
            dynamic_uve = uve_type(data=uve_data,
                                   table=uve['table'],
                                   sandesh=self.sandesh)
            dynamic_uve.send(sandesh=self.sandesh)
            elts_exp = uve.get('expected_elements')
            if elts_exp is not None:
                uve_data = uve_data_type(name=uve['name'],
                                         elements=elts_exp,
                                         deleted=uve.get('deleted'))
                uve_data._table = uve['table']
            print(uve_data.__dict__)
            expected_data.extend([{'seqnum': uve['seqnum'], 'data': uve_data}])

        # verify the result
        args_list = self.sandesh._client.send_uve_sandesh.call_args_list
        args_len = len(args_list)
        self.assertEqual(len(expected_data), len(args_list),
                         'args_list: %s' % str(args_list))
        for i in range(len(expected_data)):
            self.verify_uve_alarm_sandesh(args_list[i][0][0],
                                          seqnum=expected_data[i]['seqnum'],
                                          sandesh_type=SandeshType.UVE,
                                          data=expected_data[i]['data'])

        # sync UVEs
        expected_data = []
        self.sandesh._uve_type_maps.sync_all_uve_types({}, self.sandesh)

        sync_uve_data = [{
            'data': SandeshUVEData(name='uve1'),
            'table': 'CollectorInfo',
            'seqnum': 6
        }, {
            'data': SandeshUVEData(name='uve2'),
            'table': 'OpserverInfo',
            'seqnum': 5
        }, {
            'data': SandeshUVEData(name='uve1', xyz=345),
            'table': 'OpserverInfo',
            'seqnum': 2
        }]
        for uve_data in sync_uve_data:
            uve_data['data']._table = uve_data['table']
            expected_data.extend([{
                'seqnum': uve_data['seqnum'],
                'data': uve_data['data']
            }])
        sync_dynamic_uve_data = [{
            'type': (ConfigTestUVE, ConfigTest),
            'table': 'CollectorInfo',
            'name': 'node2',
            'deleted': True,
            'elements': {},
            'seqnum': 2
        }, {
            'type': (ConfigUVE, Config),
            'table': 'ControlInfo',
            'name': 'node1',
            'elements': {
                'log_level': 'SYS_DEBUG',
                'log_file': '/var/log/control.log'
            },
            'seqnum': 5
        }, {
            'type': (ConfigUVE, Config),
            'table': 'CollectorInfo',
            'name': 'node1',
            'elements': {
                'log_local': 'True'
            },
            'seqnum': 2
        }]
        for uve in sync_dynamic_uve_data:
            uve_type, uve_data_type = uve['type']
            elts = uve.get('elements')
            uve_data = uve_data_type(name=uve['name'],
                                     elements=elts,
                                     deleted=uve.get('deleted'))
            uve_data._table = uve['table']
            expected_data.extend([{'seqnum': uve['seqnum'], 'data': uve_data}])

        # verify the result
        args_list = self.sandesh._client.send_uve_sandesh.\
            call_args_list[args_len:]
        args_sandesh_list = [args[0][0] for args in args_list]
        args_dlist = [{
            'source': sandesh._source,
            'node_type': sandesh._node_type,
            'module': sandesh._module,
            'instance_id': sandesh._instance_id,
            'hints': (SANDESH_KEY_HINT & sandesh._hints),
            'seqnum': sandesh._seqnum,
            'type': sandesh._type,
            'data': sandesh.data
        } for sandesh in args_sandesh_list]
        expected_source = socket.gethostname()
        expected_node_type = 'Test'
        expected_module = 'sandesh_uve_alarm_test'
        expected_instance_id = '0'
        expected_hints = SANDESH_KEY_HINT
        expected_sandesh_type = SandeshType.UVE
        expected_dlist = [{
            'source': expected_source,
            'node_type': expected_node_type,
            'module': expected_module,
            'instance_id': expected_instance_id,
            'hints': expected_hints,
            'seqnum': einfo['seqnum'],
            'type': expected_sandesh_type,
            'data': einfo['data']
        } for einfo in expected_data]
        self.assertEqual(len(expected_data), len(args_list),
                         'args_list: %s' % str(args_list))
        self.assertEqual(len(expected_dlist), len(args_dlist),
                         'args_dlist: %s' % str(args_dlist))
        for expected_dict in expected_dlist:
            self.assertTrue(expected_dict in args_dlist)
        for args_dict in args_dlist:
            self.assertTrue(args_dict in expected_dlist)

    # end test_sandesh_uve

    def _create_uve_alarm_info(self):
        uve_alarm_info = UVEAlarmInfo()
        uve_alarm_info.type = 'ProcessStatus'
        condition = AlarmCondition(
            operation='==',
            operand1='NodeStatus.process_info.process_state',
            operand2=AlarmOperand2(json_value=json.dumps('null')))
        match1 = AlarmMatch(json_operand1_value=json.dumps('null'))
        condition_match = AlarmConditionMatch(condition, [match1])
        and_list = AlarmAndList(and_list=[condition_match])
        uve_alarm_info.alarm_rules = [AlarmRules(or_list=[and_list])]
        uve_alarm_info.ack = False
        uve_alarm_info.timestamp = UTCTimestampUsec()
        uve_alarm_info.severity = 1
        return uve_alarm_info

    # end _create_uve_alarm_info

    def _update_uve_alarm_info(self):
        uve_alarm_info = self._create_uve_alarm_info()
        uve_alarm_info.ack = True
        return uve_alarm_info

    # end _update_uve_alarm_info

    def test_sandesh_alarm(self):
        alarm_data = [
            # add alarm
            (UVEAlarms(name='alarm1', alarms=[self._create_uve_alarm_info()]),
             'ObjectCollectorInfo'),
            # update alarm
            (UVEAlarms(name='alarm1', alarms=[self._update_uve_alarm_info()]),
             'ObjectCollectorInfo'),
            # add another alarm
            (UVEAlarms(name='alarm2', alarms=[self._create_uve_alarm_info()]),
             'ObjectVRouterInfo'),
            # delete alarm
            (UVEAlarms(name='alarm2', deleted=True), 'ObjectVRouterInfo'),
            # add deleted alarm
            (UVEAlarms(name='alarm2', alarms=[self._create_uve_alarm_info()]),
             'ObjectVRouterInfo'),
            # add alarm with deleted flag set
            (UVEAlarms(name='alarm3',
                       alarms=[self._create_uve_alarm_info()],
                       deleted=True), 'ObjectCollectorInfo'),
            # add alarm with same key and different table
            (UVEAlarms(name='alarm3', alarms=[self._create_uve_alarm_info()]),
             'ObjectVRouterInfo')
        ]

        # send the alarms
        for i in range(len(alarm_data)):
            alarm_test = AlarmTrace(data=alarm_data[i][0],
                                    table=alarm_data[i][1],
                                    sandesh=self.sandesh)
            alarm_test.send(sandesh=self.sandesh)

        expected_data1 = [{
            'seqnum': i + 1,
            'data': alarm_data[i][0]
        } for i in range(len(alarm_data))]

        # Sync alarms
        self.sandesh._uve_type_maps.sync_all_uve_types({}, self.sandesh)

        expected_data2 = [
            {
                'seqnum': 2,
                'data': alarm_data[1][0]
            },
            {
                'seqnum': 5,
                'data': alarm_data[4][0]
            },
            {
                'seqnum': 6,
                'data': alarm_data[5][0]
            },
            {
                'seqnum': 7,
                'data': alarm_data[6][0]
            },
        ]

        expected_data = expected_data1 + expected_data2

        # get the result
        args_list = self.sandesh._client.send_uve_sandesh.call_args_list
        self.assertEqual(len(expected_data), len(args_list),
                         'args_list: %s' % str(args_list))

        # Verify alarm traces for raised/cleared alarms
        for i in range(len(expected_data1)):
            self.verify_uve_alarm_sandesh(args_list[i][0][0],
                                          seqnum=expected_data1[i]['seqnum'],
                                          sandesh_type=SandeshType.ALARM,
                                          data=expected_data1[i]['data'])

        # Verify alarm traces after alarms sync.
        # It is observed that they come in different order for py2 and py3
        for i in range(len(expected_data1), len(expected_data)):
            for j in range(len(expected_data1), len(expected_data)):
                if expected_data[i]['seqnum'] == args_list[j][0][0]._seqnum:
                    self.verify_uve_alarm_sandesh(
                        args_list[j][0][0],
                        seqnum=expected_data[i]['seqnum'],
                        sandesh_type=SandeshType.ALARM,
                        data=expected_data[i]['data'])
Esempio n. 33
0
class MesosManagerLogger(object):
    def __init__(self, args=None):
        self._args = args

        # Initialize module parameters.
        self.module = {}
        self.module["id"] = Module.MESOS_MANAGER
        self.module["name"] = ModuleNames[self.module["id"]]
        self.module["node_type"] = Module2NodeType[self.module["id"]]
        self.module["node_type_name"] = NodeTypeNames[self.module["node_type"]]
        self.module["hostname"] = socket.gethostname()
        self.module["table"] = "ObjectConfigNode"
        if self._args.worker_id:
            self.module["instance_id"] = self._args.worker_id
        else:
            self.module["instance_id"] = INSTANCE_ID_DEFAULT

        # Initialize discovery client
        if self._args.disc_server_ip and self._args.disc_server_port:
            self.module["discovery"] = client.DiscoveryClient(
                self._args.disc_server_ip, self._args.disc_server_port,
                self.module["name"])

        # Init Sandesh.
        self.sandesh_init()

    def syslog(self, log_msg, level):
        # Log to syslog.
        self._sandesh.logger().log(SandeshLogger.get_py_logger_level(level),
                                   log_msg)

    def log(self, log_msg, level=SandeshLevel.SYS_DEBUG, fun=None):
        # If a sandesh function is provided, use the function.
        # If not, revert to syslog.
        if fun:
            log = fun(level=level, log_msg=log_msg, sandesh=self._sandesh)
            log.send(sandesh=self._sandesh)
        else:
            self.syslog(log_msg, level)

    # EMERGENCY.
    def emergency(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_EMERG
        logging_fun = log_fun if log_fun else sandesh.MesosManagerEmergencyLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # ALERT.
    def alert(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ALERT
        logging_fun = log_fun if log_fun else sandesh.MesosManagerAlertLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def critical(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_CRIT
        logging_fun = log_fun if log_fun else sandesh.MesosManagerCriticalLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def error(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ERR
        logging_fun = log_fun if log_fun else sandesh.MesosManagerErrorLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # WARNING.
    def warning(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_WARN
        logging_fun = log_fun if log_fun else sandesh.MesosManagerWarningLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # NOTICE.
    def notice(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_NOTICE
        logging_fun = log_fun if log_fun else sandesh.MesosManagerNoticeLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # INFO.
    def info(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_INFO
        logging_fun = log_fun if log_fun else sandesh.MesosManagerInfoLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # DEBUG.
    def debug(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_DEBUG
        logging_fun = log_fun if log_fun else sandesh.MesosManagerDebugLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Reset sandesh send rate limit value.
        if self._args.sandesh_send_rate_limit is not None:
            SandeshSystem.set_sandesh_send_rate_limit(
                self._args.sandesh_send_rate_limit)

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self.module['name'],
            self.module['hostname'],
            self.module['node_type_name'],
            self.module['instance_id'],
            self._args.collectors,
            'mesos_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'mesos_manager.sandesh'],
            self.module['discovery'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(
            self._sandesh, self.module['hostname'], self.module['name'],
            self.module['instance_id'],
            staticmethod(ConnectionState.get_process_state_cb), NodeStatusUVE,
            NodeStatus, self.module['table'])
Esempio n. 34
0
class KubeManagerLogger(object):

    def __init__(self, args=None):
        self._args = args

        # Initialize module parameters.
        self._module = {}
        self._module["id"] = Module.KUBE_MANAGER
        self._module["name"] = ModuleNames[self._module["id"]]
        self._module["node_type"] = Module2NodeType[self._module["id"]]
        self._module["node_type_name"] =\
            NodeTypeNames[self._module["node_type"]]
        self._module["hostname"] = socket.gethostname()
        self._module["table"] = "ObjectKubernetesManagerNode"
        if self._args.worker_id:
            self._module["instance_id"] = self._args.worker_id
        else:
            self._module["instance_id"] = INSTANCE_ID_DEFAULT

        # Init Sandesh.
        self.sandesh_init()

    def syslog(self, log_msg, level):
        """ Log to syslog. """
        self._sandesh.logger().log(
            SandeshLogger.get_py_logger_level(level), log_msg)

    def log(self, log_msg, level=SandeshLevel.SYS_DEBUG, fun=None):
        """
        If a sandesh function is provided, use the function.
        If not, revert to syslog.
        """
        if fun:
            log = fun(level=level, log_msg=log_msg, sandesh=self._sandesh)
            log.send(sandesh=self._sandesh)
        else:
            self.syslog(log_msg, level)

    # EMERGENCY.
    def emergency(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_EMERG
        logging_fun = log_fun if log_fun else sandesh.KubeManagerEmergencyLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # ALERT.
    def alert(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ALERT
        logging_fun = log_fun if log_fun else sandesh.KubeManagerAlertLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def critical(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_CRIT
        logging_fun = log_fun if log_fun else sandesh.KubeManagerCriticalLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # ERROR.
    def error(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ERR
        logging_fun = log_fun if log_fun else sandesh.KubeManagerErrorLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # WARNING.
    def warning(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_WARN
        logging_fun = log_fun if log_fun else sandesh.KubeManagerWarningLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # NOTICE.
    def notice(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_NOTICE
        logging_fun = log_fun if log_fun else sandesh.KubeManagerNoticeLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # INFO.
    def info(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_INFO
        logging_fun = log_fun if log_fun else sandesh.KubeManagerInfoLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # DEBUG.
    def debug(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_DEBUG
        logging_fun = log_fun if log_fun else sandesh.KubeManagerDebugLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    def _redefine_sandesh_handles(self):
        """ Register custom introspect handlers. """
        # Register Pod DB introspect handler.
        introspect.PodDatabaseList.handle_request =\
            PodKM.sandesh_handle_db_list_request

        # Register Namespace DB introspect handler.
        introspect.NamespaceDatabaseList.handle_request =\
            NamespaceKM.sandesh_handle_db_list_request

        # Register Service DB introspect handler.
        introspect.ServiceDatabaseList.handle_request =\
            ServiceKM.sandesh_handle_db_list_request

        # Register NetworkPolicy DB introspect handler.
        introspect.NetworkPolicyDatabaseList.handle_request =\
            NetworkPolicyKM.sandesh_handle_db_list_request

        # Register Ingress DB introspect handler.
        introspect.IngressDatabaseList.handle_request =\
            IngressKM.sandesh_handle_db_list_request

    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Register custom sandesh request handlers.
        self._redefine_sandesh_handles()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self._module["name"], self._module["hostname"],
            self._module["node_type_name"], self._module["instance_id"],
            self._args.random_collectors, 'kube_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'kube_manager'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category, level=self._args.log_level,
            file=self._args.log_file, enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(
            self._sandesh, self._module["hostname"], self._module["name"],
            self._module["instance_id"],
            staticmethod(ConnectionState.get_process_state_cb),
            NodeStatusUVE, NodeStatus, self._module["table"])

    def sandesh_uninit(self):
        self._sandesh.uninit()
Esempio n. 35
0
class ConfigServiceLogger(object):

    _LOGGER_LEVEL_TO_SANDESH_LEVEL = {
        logging.CRITICAL: SandeshLevel.SYS_EMERG,
        logging.CRITICAL: SandeshLevel.SYS_ALERT,
        logging.CRITICAL: SandeshLevel.SYS_CRIT,
        logging.ERROR: SandeshLevel.SYS_ERR,
        logging.WARNING: SandeshLevel.SYS_WARN,
        logging.WARNING: SandeshLevel.SYS_NOTICE,
        logging.INFO: SandeshLevel.SYS_INFO,
        logging.DEBUG: SandeshLevel.SYS_DEBUG
    }

    def __init__(self, module, module_pkg, args=None, http_server_port=None):
        self.module_pkg = module_pkg
        if not hasattr(self, 'context'):
            self.context = module_pkg
        self._args = args

        node_type = Module2NodeType[module]
        self._module_name = ModuleNames[module]
        self._node_type_name = NodeTypeNames[node_type]
        self.table = "ObjectConfigNode"
        self._instance_id = INSTANCE_ID_DEFAULT
        self._hostname = socket.gethostname()

        # sandesh init
        self.sandesh_init(http_server_port)

    def _get_sandesh_logger_level(self, sandesh_level):
        return self._LOGGER_LEVEL_TO_SANDESH_LEVEL[sandesh_level]

    def log(self, log_msg, level=SandeshLevel.SYS_DEBUG, fun=None):
        if fun:
            log = fun(level=level, og_msg=log_msg, sandesh=self._sandesh)
            log.send(sandesh=self._sandesh)
        else:
            self._sandesh.logger().log(
                SandeshLogger.get_py_logger_level(level), log_msg)

    def emergency(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_EMERG, fun=log_fun)

    def alert(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_ALERT, fun=log_fun)

    def critical(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_CRIT, fun=log_fun)

    def error(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_ERR, fun=log_fun)

    def cgitb_error(self):
        string_buf = cStringIO.StringIO()
        cgitb_hook(file=string_buf, format="text")
        self.error(string_buf.getvalue())

    def warning(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_WARN, fun=log_fun)

    def notice(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_NOTICE, fun=log_fun)

    def info(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_INFO, fun=log_fun)

    def debug(self, log_msg, log_fun=None):
        self.log(log_msg, level=SandeshLevel.SYS_DEBUG, fun=log_fun)

    def _utc_timestamp_usec(self):
        epoch = datetime.datetime.utcfromtimestamp(0)
        now = datetime.datetime.utcnow()
        delta = now - epoch
        return (delta.microseconds +
                (delta.seconds + delta.days * 24 * 3600) * 10**6)

    def redefine_sandesh_handles(self):
        """ Redefine sandesh handle requests for various object types. """
        pass

    def sandesh_init(self, http_server_port=None):
        """ Init sandesh """
        self._sandesh = Sandesh()
        self.redefine_sandesh_handles()
        if not http_server_port:
            http_server_port = self._args.http_server_port
        self._sandesh.init_generator(
            self._module_name,
            self._hostname,
            self._node_type_name,
            self._instance_id,
            self._args.random_collectors,
            '%s_context' % self.context,
            int(http_server_port),
            ['cfgm_common', '%s.sandesh' % self.module_pkg],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level,
            file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # connection state init
        ConnectionState.init(
            self._sandesh, self._hostname, self._module_name,
            self._instance_id,
            staticmethod(ConnectionState.get_process_state_cb), NodeStatusUVE,
            NodeStatus, self.table)

    def introspect_init(self):
        self._sandesh.run_introspect_server(int(self._args.http_server_port))

    def sandesh_reconfig_collectors(self, args):
        self._sandesh.reconfig_collectors(args.random_collectors)
Esempio n. 36
0
class MesosManagerLogger(object):

    def __init__(self, args=None):
        self._args = args

        # Initialize module parameters.
        self.module = {}
        self.module["id"] = Module.MESOS_MANAGER
        self.module["name"] = ModuleNames[self.module["id"]]
        self.module["node_type"] = Module2NodeType[self.module["id"]]
        self.module["node_type_name"] = NodeTypeNames[self.module["node_type"]]
        if 'host_ip' in self._args:
            host_ip = self._args.host_ip
        else:
            host_ip = socket.gethostbyname(socket.getfqdn())
        self.module["hostname"] = socket.getfqdn(host_ip)
        self.module["table"] = "ObjectConfigNode"
        if self._args.worker_id:
            self.module["instance_id"] = self._args.worker_id
        else:
            self.module["instance_id"] = INSTANCE_ID_DEFAULT

        # Init Sandesh.
        self.sandesh_init()

    def syslog(self, log_msg, level):
        # Log to syslog.
        self._sandesh.logger().log(
            SandeshLogger.get_py_logger_level(level), log_msg)

    def log(self, log_msg, level=SandeshLevel.SYS_DEBUG, fun=None):
        # If a sandesh function is provided, use the function.
        # If not, revert to syslog.
        if fun:
            log = fun(level=level, log_msg=log_msg, sandesh=self._sandesh)
            log.send(sandesh=self._sandesh)
        else:
            self.syslog(log_msg, level)

    # EMERGENCY.
    def emergency(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_EMERG
        logging_fun = log_fun if log_fun else sandesh.MesosManagerEmergencyLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # ALERT.
    def alert(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ALERT
        logging_fun = log_fun if log_fun else sandesh.MesosManagerAlertLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def critical(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_CRIT
        logging_fun = log_fun if log_fun else sandesh.MesosManagerCriticalLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def error(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ERR
        logging_fun = log_fun if log_fun else sandesh.MesosManagerErrorLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # WARNING.
    def warning(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_WARN
        logging_fun = log_fun if log_fun else sandesh.MesosManagerWarningLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # NOTICE.
    def notice(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_NOTICE
        logging_fun = log_fun if log_fun else sandesh.MesosManagerNoticeLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # INFO.
    def info(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_INFO
        logging_fun = log_fun if log_fun else sandesh.MesosManagerInfoLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # DEBUG.
    def debug(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_DEBUG
        logging_fun = log_fun if log_fun else sandesh.MesosManagerDebugLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    def redefine_sandesh_handles(self):
        """ Register custom introspect handlers. """

        # Register Virtual Machine DB introspect handler.
        introspect.VirtualMachineDatabaseList.handle_request = \
            VirtualMachineMM.sandesh_handle_db_list_request

        # Register Virtual Router DB introspect handler.
        introspect.VirtualRouterDatabaseList.handle_request = \
            VirtualRouterMM.sandesh_handle_db_list_request

        # Register Virtual Machine Interface DB introspect handler.
        introspect.VirtualMachineInterfaceDatabaseList.handle_request = \
            VirtualMachineInterfaceMM.sandesh_handle_db_list_request

        # Register Virtual Network DB introspect handler.
        introspect.VirtualNetworkDatabaseList.handle_request = \
            VirtualNetworkMM.sandesh_handle_db_list_request

        # Register Instance IP DB introspect handler.
        introspect.InstanceIpDatabaseList.handle_request = \
            InstanceIpMM.sandesh_handle_db_list_request

        # Register Project DB introspect handler.
        introspect.ProjectDatabaseList.handle_request = \
            ProjectMM.sandesh_handle_db_list_request

        # Register Domain DB introspect handler.
        introspect.DomainDatabaseList.handle_request = \
            DomainMM.sandesh_handle_db_list_request

        # Register NetworkIpam DB introspect handler.
        introspect.NetworkIpamDatabaseList.handle_request = \
            NetworkIpamMM.sandesh_handle_db_list_request

    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Register custom sandesh request handlers.
        self.redefine_sandesh_handles()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self.module['name'], self.module['hostname'],
            self.module['node_type_name'], self.module['instance_id'],
            self._args.collectors, 'mesos_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'mesos_manager.sandesh', 'mesos_introspect.sandesh'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category,
            level=self._args.log_level, file=self._args.log_file,
            enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(self._sandesh, self.module['hostname'],
            self.module['name'], self.module['instance_id'],
            staticmethod(ConnectionState.get_conn_state_cb),
            NodeStatusUVE, NodeStatus, self.module['table'])

    def introspect_init(self):
        self._sandesh.run_introspect_server(int(self._args.http_server_port))
Esempio n. 37
0
class KubeManagerLogger(object):

    def __init__(self, args=None):
        self._args = args

        # Initialize module parameters.
        self._module = {}
        self._module["id"] = Module.KUBE_MANAGER
        self._module["name"] = ModuleNames[self._module["id"]]
        self._module["node_type"] = Module2NodeType[self._module["id"]]
        self._module["node_type_name"] =\
            NodeTypeNames[self._module["node_type"]]
        self._module["hostname"] = socket.gethostname()
        self._module["table"] = "ObjectKubernetesManagerNode"
        if self._args.worker_id:
            self._module["instance_id"] = self._args.worker_id
        else:
            self._module["instance_id"] = INSTANCE_ID_DEFAULT

        # Init Sandesh.
        self.sandesh_init()

    def syslog(self, log_msg, level):
        """ Log to syslog. """
        self._sandesh.logger().log(
            SandeshLogger.get_py_logger_level(level), log_msg)

    def log(self, log_msg, level=SandeshLevel.SYS_DEBUG, fun=None):
        """
        If a sandesh function is provided, use the function.
        If not, revert to syslog.
        """
        if fun:
            log = fun(level=level, log_msg=log_msg, sandesh=self._sandesh)
            log.send(sandesh=self._sandesh)
        else:
            self.syslog(log_msg, level)

    # EMERGENCY.
    def emergency(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_EMERG
        logging_fun = log_fun if log_fun else sandesh.KubeManagerEmergencyLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # ALERT.
    def alert(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ALERT
        logging_fun = log_fun if log_fun else sandesh.KubeManagerAlertLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # CRITICAL.
    def critical(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_CRIT
        logging_fun = log_fun if log_fun else sandesh.KubeManagerCriticalLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # ERROR.
    def error(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_ERR
        logging_fun = log_fun if log_fun else sandesh.KubeManagerErrorLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # WARNING.
    def warning(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_WARN
        logging_fun = log_fun if log_fun else sandesh.KubeManagerWarningLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # NOTICE.
    def notice(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_NOTICE
        logging_fun = log_fun if log_fun else sandesh.KubeManagerNoticeLog

        # Log to syslog.
        self.syslog(log_msg, log_level)

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # INFO.
    def info(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_INFO
        logging_fun = log_fun if log_fun else sandesh.KubeManagerInfoLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    # DEBUG.
    def debug(self, log_msg, log_fun=None):
        log_level = SandeshLevel.SYS_DEBUG
        logging_fun = log_fun if log_fun else sandesh.KubeManagerDebugLog

        # Log using the desired logging function.
        self.log(log_msg, level=log_level, fun=logging_fun)

    def _redefine_sandesh_handles(self):
        """ Register custom introspect handlers. """
        # Register Pod DB introspect handler.
        introspect.PodDatabaseList.handle_request =\
            PodKM.sandesh_handle_db_list_request

        # Register Namespace DB introspect handler.
        introspect.NamespaceDatabaseList.handle_request =\
            NamespaceKM.sandesh_handle_db_list_request

        # Register Service DB introspect handler.
        introspect.ServiceDatabaseList.handle_request =\
            ServiceKM.sandesh_handle_db_list_request

        # Register NetworkPolicy DB introspect handler.
        introspect.NetworkPolicyDatabaseList.handle_request =\
            NetworkPolicyKM.sandesh_handle_db_list_request

        # Register Ingress DB introspect handler.
        introspect.IngressDatabaseList.handle_request =\
            IngressKM.sandesh_handle_db_list_request

    def sandesh_init(self):
        """ Init Sandesh """
        self._sandesh = Sandesh()

        # Register custom sandesh request handlers.
        self._redefine_sandesh_handles()

        # Initialize Sandesh generator.
        self._sandesh.init_generator(
            self._module["name"], self._module["hostname"],
            self._module["node_type_name"], self._module["instance_id"],
            self._args.random_collectors, 'kube_manager_context',
            int(self._args.http_server_port),
            ['cfgm_common', 'kube_manager'],
            logger_class=self._args.logger_class,
            logger_config_file=self._args.logging_conf,
            config=self._args.sandesh_config)

        # Set Sandesh logging params.
        self._sandesh.set_logging_params(
            enable_local_log=self._args.log_local,
            category=self._args.log_category, level=self._args.log_level,
            file=self._args.log_file, enable_syslog=self._args.use_syslog,
            syslog_facility=self._args.syslog_facility)

        # Connect to collector.
        ConnectionState.init(
            self._sandesh, self._module["hostname"], self._module["name"],
            self._module["instance_id"],
            staticmethod(ConnectionState.get_process_state_cb),
            NodeStatusUVE, NodeStatus, self._module["table"])
Esempio n. 38
0
class ConnInfoTest(unittest.TestCase):

    def setUp(self):
        self.maxDiff = None
        self._sandesh = Sandesh()
        http_port = get_free_port()
        self._sandesh.init_generator(
            'conn_info_test',
            socket.gethostname(),
            'Test',
            'Test',
            None,
            'conn_info_test_ctxt',
            http_port)
    # end setUp

    def _check_conn_status_cb(self, vcinfos):
        self.assertEqual(
            sorted(self._expected_vcinfos, key=lambda item: item.name),
            sorted(vcinfos, key=lambda item: item.name))
        return (ProcessState.FUNCTIONAL, '')
    # end _check_conn_status_cb

    def _update_conn_info(self, name, status, description, vcinfos):
        cinfo = ConnectionInfo()
        cinfo.name = name
        cinfo.status = ConnectionStatusNames[status]
        cinfo.description = description
        cinfo.type = ConnectionTypeNames[ConnectionType.TEST]
        cinfo.server_addrs = ['127.0.0.1:0']
        vcinfos.append(cinfo)
    # end _update_conn_info

    def _update_conn_state(self, name, status, description, vcinfos):
        self._expected_vcinfos = vcinfos
        ConnectionState.update(ConnectionType.TEST, name, status,
                               ['127.0.0.1:0'], description)
    # end _update_conn_state

    def _delete_conn_info(self, name, vcinfos):
        return [cinfo for cinfo in vcinfos if cinfo.name != name]
    # end _delete_conn_info

    def _delete_conn_state(self, name, vcinfos):
        self._expected_vcinfos = vcinfos
        ConnectionState.delete(ConnectionType.TEST, name)
    # end _delete_conn_state

    def test_basic(self):
        ConnectionState.init(sandesh=self._sandesh, hostname="TestHost",
                             module_id="TestModule", instance_id="0",
                             conn_status_cb=self._check_conn_status_cb,
                             uve_type_cls=NodeStatusUVE,
                             uve_data_type_cls=NodeStatus)
        vcinfos = []
        self._update_conn_info("Test1", ConnectionStatus.UP, "Test1 UP",
                               vcinfos)
        self._update_conn_state("Test1", ConnectionStatus.UP, "Test1 UP",
                                vcinfos)
        self._update_conn_info("Test2", ConnectionStatus.UP, "Test2 UP",
                               vcinfos)
        self._update_conn_state("Test2", ConnectionStatus.UP, "Test2 UP",
                                vcinfos)
        vcinfos = self._delete_conn_info("Test2", vcinfos)
        self._delete_conn_state("Test2", vcinfos)
    # end test_basic

    def test_callback(self):
        vcinfos = []
        self._update_conn_info("Test1", ConnectionStatus.UP, "Test1 UP",
                               vcinfos)
        (pstate, message) = ConnectionState.get_conn_state_cb(vcinfos)
        self.assertEqual(ProcessState.FUNCTIONAL, pstate)
        self.assertEqual('', message)
        self._update_conn_info("Test2", ConnectionStatus.DOWN, "Test2 DOWN",
                               vcinfos)
        (pstate, message) = ConnectionState.get_conn_state_cb(vcinfos)
        self.assertEqual(ProcessState.NON_FUNCTIONAL, pstate)
        self.assertEqual("Test:Test2[Test2 DOWN] connection down", message)
        self._update_conn_info("Test3", ConnectionStatus.DOWN, "Test3 DOWN",
                               vcinfos)
        (pstate, message) = ConnectionState.get_conn_state_cb(vcinfos)
        self.assertEqual(ProcessState.NON_FUNCTIONAL, pstate)
        self.assertEqual(
            "Test:Test2[Test2 DOWN], Test:Test3[Test3 DOWN] connection down",
            message)