def main(): print(VITRAGE_TITLE) conf = service.prepare_service() db_connection = storage.get_connection_from_config(conf) sm = cotyledon.ServiceManager() sm.add(PersistorService, args=(conf, db_connection)) sm.run()
def _init_instance(self): conf = self._conf LOG.info("Vitrage Api Handler Service - Starting...") notifier = messaging.VitrageNotifier(conf, "vitrage.api", [EVALUATOR_TOPIC]) db = storage.get_connection_from_config(conf) transport = messaging.get_rpc_transport(conf) rabbit_hosts = conf.oslo_messaging_rabbit.rabbit_hosts target = oslo_messaging.Target(topic=conf.rpc_topic, server=rabbit_hosts) endpoints = [ TopologyApis(self._entity_graph, conf), AlarmApis(self._entity_graph, conf, db), RcaApis(self._entity_graph, conf, db), TemplateApis(notifier, db), EventApis(conf), ResourceApis(self._entity_graph, conf), WebhookApis(conf) ] server = vitrage_rpc.get_server(target, endpoints, transport) server.start() LOG.info("Vitrage Api Handler Service - Started!")
def main(): print(VITRAGE_TITLE) conf = service.prepare_service() db_connection = storage.get_connection_from_config(conf) launcher = os_service.ServiceLauncher(conf) launcher.launch_service(PersistorService(conf, db_connection)) launcher.wait()
def _read_db_graph(self): db = storage.get_connection_from_config(self._conf) graph_snapshot = db.graph_snapshots.query() NXGraph.read_gpickle(graph_snapshot.graph_snapshot, self._entity_graph) GraphPersistency.do_replay_events(db, self._entity_graph, graph_snapshot.event_id) self._entity_graph.ready = True
def submit_template_event(self, event): """Template worker to load the new/deleted template Load the template to scenario-evaluator and run it on the entire graph """ template_action = event.get(TEMPLATE_ACTION) if not self._db: self._db = storage.get_connection_from_config(self._conf) if template_action == ADD: templates = self._db.templates.query(status=TStatus.LOADING) new_status = TStatus.ACTIVE action_mode = ActionMode.DO elif template_action == DELETE: templates = self._db.templates.query(status=TStatus.DELETING) new_status = TStatus.DELETED action_mode = ActionMode.UNDO else: raise VitrageError('Invalid template_action %s' % template_action) # Template event will be handled by a single evaluator worker self._submit_and_wait( [self._evaluator_queues[0]], ( TEMPLATE_ACTION, [t.name for t in templates if t.template_type == TType.STANDARD], action_mode, )) for t in templates: self._db.templates.update(t.uuid, 'status', new_status)
def __init__(self, conf, e_graph): super(VitrageApiHandlerService, self).__init__() self.conf = conf self.entity_graph = e_graph self.notifier = VitrageNotifier(self.conf, "vitrage.api", [EVALUATOR_TOPIC]) self.db = storage.get_connection_from_config(conf)
def main(): print(VITRAGE_TITLE) config.parse_config(sys.argv) db_connection = storage.get_connection_from_config() sm = cotyledon.ServiceManager() sm.add(PersistorService, args=(db_connection, )) sm.run()
def main(): """Main method of vitrage-graph""" print(VITRAGE_TITLE) conf = service.prepare_service() e_graph = get_graph_driver(conf)('Entity Graph') db_connection = storage.get_connection_from_config(conf) VitrageGraphInit(conf, e_graph, db_connection).run()
def clear_db(conf): """Delete all data from vitrage tables The following deletes the entire vitrage database It should be removed once graph is persistent """ db_connection = storage.get_connection_from_config(conf) db_connection.clear()
def add_db(self): db_name = "sqlite:///test-%s-%s.db" % (type(self).__name__, sys.version_info[0]) self.config(group='database', connection=db_name) self._db = storage.get_connection_from_config() engine = self._db._engine_facade.get_engine() models.Base.metadata.drop_all(engine) models.Base.metadata.create_all(engine) return self._db
def purge_data(): print(VITRAGE_TITLE) conf = service.prepare_service() db = storage.get_connection_from_config(conf) db.active_actions.delete() db.events.delete() db.graph_snapshots.delete() db.changes.delete() db.edges.delete() db.alarms.delete()
def add_db(cls, conf): conf.register_opts(database_opts, group='database') db_name = "sqlite:///test-%s-%s.db" % (cls.__name__, sys.version_info[0]) conf.set_override('connection', db_name, group='database') cls._db = storage.get_connection_from_config(conf) engine = cls._db._engine_facade.get_engine() models.Base.metadata.drop_all(engine) models.Base.metadata.create_all(engine) return cls._db
def purge_data(): print(VITRAGE_TITLE) config.parse_config(sys.argv) db = storage.get_connection_from_config() db.active_actions.delete() db.events.delete() db.graph_snapshots.delete() db.changes.delete() db.edges.delete() db.alarms.delete()
def main(): """Main method of vitrage-graph""" print(VITRAGE_TITLE) conf = service.prepare_service() e_graph = get_graph_driver(conf)('Entity Graph') db_connection = storage.get_connection_from_config(conf) clear_active_actions_table(db_connection) VitrageApiHandlerService(conf, e_graph).start() VitrageGraphInit(conf, e_graph, db_connection).run()
def __init__(self, e_graph, scenario_repo, actions_callback, enabled=False): self._entity_graph = e_graph self._db = storage.get_connection_from_config() self._scenario_repo = scenario_repo self._action_executor = ActionExecutor(actions_callback) self._entity_graph.subscribe(self.process_event) self.enabled = enabled self.connected_component_cache = defaultdict(dict)
def __init__(self, conf, workers): self.conf = conf self.graph = get_graph_driver(conf)('Entity Graph') self.db = db_connection = storage.get_connection_from_config(conf) self.workers = workers self.events_coordination = EventsCoordination(conf, self.process_event) self.persist = GraphPersistency(conf, db_connection, self.graph) self.driver_exec = driver_exec.DriverExec( self.conf, self.events_coordination.handle_multiple_low_priority, self.persist) self.scheduler = Scheduler(conf, self.graph, self.driver_exec, self.persist) self.processor = Processor(conf, self.graph)
def setUpClass(cls): super(TestGraphPersistor, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') cls.conf.register_opts(database_opts, group='database') cls.conf.set_override('connection', 'sqlite:///test-%s.db' % sys.version_info[0], group='database') cls._db = storage.get_connection_from_config(cls.conf) engine = cls._db._engine_facade.get_engine() models.Base.metadata.create_all(engine) cls.load_datasources(cls.conf) cls.graph_persistor = GraphPersistor(cls.conf)
def __init__(self, conf, e_graph, scenario_repo, actions_callback, enabled=False): super(ScenarioEvaluator, self).__init__(conf, e_graph) self._db_connection = storage.get_connection_from_config(self._conf) self._scenario_repo = scenario_repo self._action_executor = ActionExecutor(self._conf, actions_callback) self._entity_graph.subscribe(self.process_event) self._active_actions_tracker = ActiveActionsTracker( self._conf, self._db_connection) self.enabled = enabled self.connected_component_cache = defaultdict(dict)
def setUpClass(cls): super(TestActionExecutor, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') cls.conf.register_opts(database_opts, group='database') cls.conf.set_override('connection', 'sqlite:///:memory:', group='database') cls._db = storage.get_connection_from_config(cls.conf) engine = cls._db._engine_facade.get_engine() models.Base.metadata.create_all(engine) for datasource_name in cls.conf.datasources.types: register_opts(cls.conf, datasource_name, cls.conf.datasources.path)
def __init__(self, worker_index=None, workers_num=None): """Create an instance of ScenarioRepository :param conf: :param worker_index: Index of the current evaluator worker :param workers_num: Total number of evaluator workers """ self._templates = {} self._def_templates = {} self._all_scenarios = [] self._db = storage.get_connection_from_config() self.entity_equivalences = EquivalenceRepository().load(self._db) self.relationship_scenarios = defaultdict(list) self.entity_scenarios = defaultdict(list) self._load_def_templates_from_db() self._load_templates_from_db() self._enable_worker_scenarios(worker_index, workers_num) self.actions = self._create_actions_collection()
def _init_instance(self): notifier = messaging.VitrageNotifier("vitrage.api", [EVALUATOR_TOPIC]) db = storage.get_connection_from_config() transport = messaging.get_rpc_transport() target = oslo_messaging.Target(topic=CONF.rpc_topic, server=uuidutils.generate_uuid()) self.api_lock = threading.RLock() endpoints = [ TopologyApis(self._entity_graph, self.api_lock), AlarmApis(self._entity_graph, self.api_lock, db), RcaApis(self._entity_graph, self.api_lock, db), ResourceApis(self._entity_graph, self.api_lock), TemplateApis(notifier, db), EventApis(), WebhookApis(db), OperationalApis(self._entity_graph), ] server = vitrage_rpc.get_server(target, endpoints, transport) server.start()
def __init__(self, conf): self.storage = storage.get_connection_from_config(conf)
def dbsync(): print(VITRAGE_TITLE) conf = service.prepare_service() storage.get_connection_from_config(conf).upgrade()
def __init__(self, conf): self.conf = conf self.db_conn = storage.get_connection_from_config(conf)
def __init__(self, conf): super(Webhook, self).__init__(conf) self._db = storage.get_connection_from_config(self.conf) self.max_retries = self.conf.webhook.max_retries self.default_headers = {'content-type': 'application/json'}
def dbsync(): print(VITRAGE_TITLE) config.parse_config(sys.argv) storage.get_connection_from_config().upgrade()
def __init__(self, conf): super(GraphPersistor, self).__init__() self.db_connection = storage.get_connection_from_config(conf) self.last_event_timestamp = datetime.datetime.utcnow()
def setUpClass(cls): super(TestEvents, cls).setUpClass() cls.db_connection = storage.get_connection_from_config(cls.conf)