Exemple #1
0
 def check_database(self):
     db_conn_str = Config.get('db_conn_str', self.OPTYPE)
     if self.__db_api and db_conn_str == self.__db_conn_str:
         return
     
     if self.__db_api:
         try:
             self.__db_api.close()
         except Exception, err:
             logger.error('DBAPI closing failed with error "%s"'%err)
 def get_wait_time(cls):
     return int(Config.get('AUTH_KEY_CHANGE_PERIOD', 43200))
    def __init__(self, self_address, home_dir='/tmp/', key_storage=None, is_init_node=False, node_name='unknown', config={}):
        cur_cfg = {}
        cur_cfg.update(DEFAULT_MONITOR_CONFIG)
        cur_cfg.update(config)

        Operator.__init__(self, self_address, home_dir, key_storage, is_init_node, node_name, cur_cfg)

        self.__db_conn_str = None
        self.__db_api = None
        self.check_database()

        client = FriClient(key_storage)

        db_conn_str = Config.get('db_conn_str')
        self.__dbm = MgmtDatabaseManager(db_conn_str)
        ca_host = Config.get('mgmt_ca_host', None)
        ca_port = int(Config.get('mgmt_ca_port', 8080))
        self.mgmt_api = mgmt_api = ManagementEngineAPI(self.__dbm, self_address, init_scheduler=True, \
                ca_host=ca_host, ca_port=ca_port)
        BaseMgmtCLIHandler.mgmtManagementAPI = mgmt_api
        host = Config.get('mgmt_cli_host', '0.0.0.0')
        cli_port = int(Config.get('mgmt_cli_port', '23'))
        logger.info('Starting CLI at %s:%s'%(host, cli_port))
        cli_server = TelnetServer((host, cli_port), BaseMgmtCLIHandler)
        #if key_storage:
        #    cert, key = self.get_ssl_keycert('cli_api')
        #    cli_server.socket = ssl.wrap_socket(cli_server.socket, certfile=cert, keyfile=key, server_side=True)
        self.__cli_api_thrd = ExternalAPIThread(cli_server, host, cli_port)
        self.__cli_api_thrd.setName('%s-CLIAPIThread'%self.node_name)
        self.__cli_api_thrd.start()

        RESTHandler.setup_mgmt_api(mgmt_api)
        host = Config.get('mgmt_rest_host', '0.0.0.0')
        rest_port = int(Config.get('mgmt_rest_port', '8080'))
        logger.info('Starting REST at %s:%s'%(host, rest_port))
        rest_server = BaseHTTPServer.HTTPServer((host, rest_port), RESTHandler)
        if key_storage:
            cert, key = self.get_ssl_keycert('rest_api')
            rest_server.socket = ssl.wrap_socket(rest_server.socket, certfile=cert, keyfile=key, server_side=True)
        self.__rest_api_thrd = ExternalAPIThread(rest_server, host, rest_port)
        self.__rest_api_thrd.setName('%s-RESTAPIThread'%self.node_name)
        self.__rest_api_thrd.start()

        if not self.__cli_api_thrd.started():
            self.__rest_api_thrd.stop()
            raise Exception('CLI API does not started!')

        if not self.__rest_api_thrd.started():
            self.__cli_api_thrd.stop()
            raise Exception('CLI API does not started!')

        self.__collect_up_nodes_stat_thread = CollectNodeStatisticsThread(self, client, STATUS_UP)
        self.__collect_up_nodes_stat_thread.setName('%s-UP-CollectNodeStatisticsThread'%self.node_name)
        self.__collect_up_nodes_stat_thread.start()

        self.__collect_dn_nodes_stat_thread = CollectNodeStatisticsThread(self, client, STATUS_DOWN)
        self.__collect_dn_nodes_stat_thread.setName('%s-DN-CollectNodeStatisticsThread'%self.node_name)
        self.__collect_dn_nodes_stat_thread.start()

        self.__discovery_topology_thrd = DiscoverTopologyThread(self)
        self.__discovery_topology_thrd.setName('%s-DiscoverTopologyThread'%self.node_name)
        self.__discovery_topology_thrd.start()