openstack/vitrage
Code Issues Proposed changes

Merge "Refactor vitrage to use global CONF instead of local one"

Browse Source
This commit is contained in:
Zuul 2019-07-23 16:31:10 +00:00 committed by Gerrit Code Review
commit 9babfab50e
185 changed files with 1065 additions and 1327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
tools/datasource-scaffold/sample/driver.py
View File

@ -22,9 +22,8 @@ LOG = log.getLogger(__name__)
class SampleDriver(DriverBase):
def __init__(self, conf):
def __init__(self):
super(SampleDriver, self).__init__()
self.cfg = conf
@staticmethod
def get_event_types():

4
tools/datasource-scaffold/sample/transformer.py
View File

@ -28,8 +28,8 @@ LOG = logging.getLogger(__name__)
class SampleTransformer(ResourceTransformerBase):
def __init__(self, transformers, conf):
super(SampleTransformer, self).__init__(transformers, conf)
def __init__(self, transformers):
super(SampleTransformer, self).__init__(transformers)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event)

3
tools/datasource-scaffold/{{cookiecutter.name}}/driver.py
View File

@ -22,9 +22,8 @@ LOG = log.getLogger(__name__)
class {{cookiecutter.name|capitalize}}Driver(DriverBase):
def __init__(self, conf):
def __init__(self):
super({{cookiecutter.name|capitalize}}Driver, self).__init__()
self.cfg = conf
@staticmethod
def get_event_types():

4
tools/datasource-scaffold/{{cookiecutter.name}}/transformer.py
View File

@ -28,8 +28,8 @@ LOG = logging.getLogger(__name__)
class {{cookiecutter.name|capitalize}}Transformer(ResourceTransformerBase):
def __init__(self, transformers, conf):
super({{cookiecutter.name|capitalize}}Transformer, self).__init__(transformers, conf)
def __init__(self, transformers:
super({{cookiecutter.name|capitalize}}Transformer, self).__init__(transformers)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event)

15
tools/load_generator/load_generator.py
View File

@ -17,14 +17,17 @@ import sys
import cotyledon
from futurist import periodics
from futurist import ThreadPoolExecutor
from oslo_config import cfg
from oslo_log import log
import oslo_messaging
from tools.load_generator.notification_info import * # noqa
from vitrage.common import config
from vitrage.messaging import get_transport
from vitrage import service
CONF = cfg.CONF
LOG = log.getLogger(__name__)
EXISTING_COMPUTES_NUM = 64
@ -62,12 +65,12 @@ to avoid Vitrage consistency deleting the created resources.
class StressNotificationsService(cotyledon.Service):
def __init__(self, worker_id, conf):
def __init__(self, worker_id):
super(StressNotificationsService, self).__init__(worker_id)
self.oslo_notifier = None
topics = conf.datasources.notification_topics
topics = CONF.datasources.notification_topics
self.oslo_notifier = oslo_messaging.Notifier(
get_transport(conf),
get_transport(),
driver='messagingv2',
publisher_id='vitrage.stress',
topics=topics)
@ -141,9 +144,9 @@ def create_vm(instance_num, compute_num):
def main():
conf = service.prepare_service()
config.parse_config(sys.argv)
sm = cotyledon.ServiceManager()
sm.add(StressNotificationsService, args=(conf,))
sm.add(StressNotificationsService)
sm.run()

47
vitrage/api/app.py
View File

@ -27,6 +27,8 @@ from werkzeug import serving
from vitrage.api import hooks
CONF = cfg.CONF
LOG = log.getLogger(__name__)
# NOTE(sileht): pastedeploy uses ConfigParser to handle
@ -40,13 +42,13 @@ APPCONFIGS = {}
def setup_app(root, conf=None):
app_hooks = [hooks.ConfigHook(conf),
app_hooks = [hooks.ConfigHook(),
hooks.TranslationHook(),
hooks.GCHook(),
hooks.RPCHook(conf),
hooks.RPCHook(),
hooks.ContextHook(),
hooks.DBHook(conf),
hooks.CoordinatorHook(conf)]
hooks.DBHook(),
hooks.CoordinatorHook()]
app = pecan.make_app(
root,
@ -57,53 +59,52 @@ def setup_app(root, conf=None):
return app
def load_app(conf):
def load_app():
global APPCONFIGS
# Build the WSGI app
cfg_path = conf.api.paste_config
cfg_path = CONF.api.paste_config
if not os.path.isabs(cfg_path):
cfg_path = conf.find_file(cfg_path)
cfg_path = CONF.find_file(cfg_path)
if cfg_path is None or not os.path.exists(cfg_path):
raise cfg.ConfigFilesNotFoundError([conf.api.paste_config])
raise cfg.ConfigFilesNotFoundError([CONF.api.paste_config])
config = dict(conf=conf)
config = dict(conf=CONF)
configkey = uuidutils.generate_uuid()
APPCONFIGS[configkey] = config
LOG.info('Full WSGI config used: %s', cfg_path)
appname = "vitrage+" + conf.api.auth_mode
appname = "vitrage+" + CONF.api.auth_mode
return deploy.loadapp("config:" + cfg_path, name=appname,
global_conf={'configkey': configkey})
def build_server(conf):
def build_server():
uwsgi = spawn.find_executable("uwsgi")
if not uwsgi:
LOG.warning('uwsgi not installed, starting a TEST server')
build_simple_server(conf)
build_simple_server()
else:
build_uwsgi_server(conf, uwsgi)
build_uwsgi_server(uwsgi)
def wsgi_file():
return path.join(path.dirname(__file__), 'app.wsgi')
def build_uwsgi_server(conf, uwsgi):
def build_uwsgi_server(uwsgi):
args = [
"--if-not-plugin", "python", "--plugin", "python", "--endif",
"--http-socket", "%s:%d" % (conf.api.host, conf.api.port),
"--http-socket", "%s:%d" % (CONF.api.host, CONF.api.port),
"--master",
"--enable-threads",
"--thunder-lock",
"--hook-master-start", "unix_signal:15 gracefully_kill_them_all",
"--die-on-term",
"--processes", str(math.floor(conf.api.workers * 1.5)),
"--threads", str(conf.api.workers),
"--processes", str(math.floor(CONF.api.workers * 1.5)),
"--threads", str(CONF.api.workers),
"--lazy-apps",
"--chdir", "/",
"--buffer-size", "65535",
@ -119,14 +120,14 @@ def build_uwsgi_server(conf, uwsgi):
return os.execl(uwsgi, uwsgi, *args)
def build_simple_server(conf):
app = load_app(conf)
def build_simple_server():
app = load_app()
# Create the WSGI server and start it
host, port = conf.api.host, conf.api.port
host, port = CONF.api.host, CONF.api.port
LOG.info('Starting server in PID %s', os.getpid())
LOG.info('Configuration:')
conf.log_opt_values(LOG, log.INFO)
CONF.log_opt_values(LOG, log.INFO)
if host == '0.0.0.0':
LOG.info(
@ -139,7 +140,7 @@ def build_simple_server(conf):
LOG.info('"DANGER! For testing only, do not use in production"')
serving.run_simple(host, port,
app, processes=conf.api.workers)
app, processes=CONF.api.workers)
def app_factory(global_config, **local_conf):

6
vitrage/api/app.wsgi
View File

@ -14,8 +14,8 @@
See http://pecan.readthedocs.org/en/latest/deployment.html for details.
"""
from vitrage.api import app
from vitrage import service
from vitrage.common import config
# Initialize the oslo configuration library and logging
conf = service.prepare_service()
application = app.load_app(conf)
config.parse_config([])
application = app.load_app()

26
vitrage/api/hooks.py
View File

@ -12,6 +12,7 @@
import gc
import oslo_messaging
from oslo_config import cfg
from oslo_context import context
from oslo_policy import policy
from pecan import hooks
@ -22,31 +23,32 @@ from vitrage import messaging
from vitrage import rpc as vitrage_rpc
from vitrage import storage
CONF = cfg.CONF
class ConfigHook(hooks.PecanHook):
"""Attach the configuration and policy enforcer object to the request. """
def __init__(self, conf):
self.conf = conf
self.enforcer = policy.Enforcer(conf)
def __init__(self):
self.enforcer = policy.Enforcer(CONF)
self._register_rules()
def _register_rules(self):
self.enforcer.register_defaults(policies.list_rules())
def before(self, state):
state.request.cfg = self.conf
state.request.cfg = CONF
state.request.enforcer = self.enforcer
class RPCHook(hooks.PecanHook):
"""Create and attach an rpc to the request. """
def __init__(self, conf):
transport = messaging.get_rpc_transport(conf)
target = oslo_messaging.Target(topic=conf.rpc_topic)
def __init__(self):
transport = messaging.get_rpc_transport()
target = oslo_messaging.Target(topic=CONF.rpc_topic)
self.client = vitrage_rpc.get_client(transport, target)
self.check_backend = conf.api.check_backend
self.check_backend = CONF.api.check_backend
def on_route(self, state):
state.request.client = self.client
@ -87,8 +89,8 @@ class ContextHook(hooks.PecanHook):
class DBHook(hooks.PecanHook):
def __init__(self, conf):
self.storage = storage.get_connection_from_config(conf)
def __init__(self):
self.storage = storage.get_connection_from_config()
def before(self, state):
state.request.storage = self.storage
@ -102,8 +104,8 @@ class GCHook(hooks.PecanHook):
class CoordinatorHook(hooks.PecanHook):
def __init__(self, conf):
self.coordinator = coordination.Coordinator(conf)
def __init__(self):
self.coordinator = coordination.Coordinator()
self.coordinator.start()
self.coordinator.join_group()

3
vitrage/api_handler/apis/base.py
View File

@ -76,9 +76,8 @@ RESOURCES_ALL_QUERY = {
class EntityGraphApisBase(object):
def __init__(self, entity_graph, conf, api_lock, db=None):
def __init__(self, entity_graph, api_lock, db=None):
self.entity_graph = entity_graph
self.conf = conf
self.db = db
self.api_lock = api_lock

5
vitrage/api_handler/apis/event.py
View File

@ -32,8 +32,7 @@ LOG = log.getLogger(__name__)
info={}, hide_args=False, trace_private=False)
class EventApis(object):
def __init__(self, conf):
self.conf = conf
def __init__(self):
self._init_oslo_notifier()
def post(self, ctx, event_time, event_type, details):
@ -65,7 +64,7 @@ class EventApis(object):
self.publisher = 'api_%s' % socket.gethostname()
self.oslo_notifier = oslo_messaging.Notifier(
get_transport(self.conf),
get_transport(),
driver='messagingv2',
publisher_id=self.publisher,
topics=['vitrage_notifications'])

3
vitrage/api_handler/apis/operational.py
View File

@ -19,8 +19,7 @@ LOG = log.getLogger(__name__)
class OperationalApis(object):
def __init__(self, conf, graph):
self.conf = conf
def __init__(self, graph):
self.graph = graph
def is_alive(self, ctx):

3
vitrage/api_handler/apis/resource.py
View File

@ -31,9 +31,6 @@ LOG = log.getLogger(__name__)
info={}, hide_args=False, trace_private=False)
class ResourceApis(base.EntityGraphApisBase):
def __init__(self, entity_graph, conf, api_lock):
super(ResourceApis, self).__init__(entity_graph, conf, api_lock)
@timed_method(log_results=True)
@base.lock_graph
def get_resources(self, ctx, resource_type=None, all_tenants=False,

3
vitrage/api_handler/apis/topology.py
View File

@ -34,9 +34,6 @@ LOG = log.getLogger(__name__)
info={}, hide_args=False, trace_private=False)
class TopologyApis(base.EntityGraphApisBase):
def __init__(self, entity_graph, conf, api_lock):
super(TopologyApis, self).__init__(entity_graph, conf, api_lock)
@timed_method(log_results=True)
@base.lock_graph
def get_topology(self, ctx, graph_type, depth, query, root, all_tenants):

3
vitrage/api_handler/apis/webhook.py
View File

@ -34,8 +34,7 @@ Result = namedtuple("Result", ["is_valid", "message"])
class WebhookApis(object):
DELETED_ROWS_SUCCESS = 1
def __init__(self, conf, db):
self.conf = conf
def __init__(self, db):
self.db_conn = db
def delete_webhook(self, ctx, id):

6
vitrage/cli/api.py
View File

@ -16,13 +16,13 @@ import sys
from vitrage.api import app
from vitrage.cli import VITRAGE_TITLE
from vitrage import service
from vitrage.common import config
def main():
print(VITRAGE_TITLE)
conf = service.prepare_service()
app.build_server(conf)
config.parse_config(sys.argv)
app.build_server()
if __name__ == "__main__":

14
vitrage/cli/graph.py
View File

@ -16,10 +16,10 @@ from oslo_log import log
import sys
from vitrage.cli import VITRAGE_TITLE
from vitrage.common import config
from vitrage.common.utils import spawn
from vitrage.entity_graph.graph_init import VitrageGraphInit
from vitrage.entity_graph.workers import GraphWorkersManager
from vitrage import service
LOG = log.getLogger(__name__)
@ -27,19 +27,19 @@ LOG = log.getLogger(__name__)
def main():
"""Main method of vitrage-graph"""
conf = service.prepare_service()
LOG.info(VITRAGE_TITLE)
workers = GraphWorkersManager(conf)
spawn(init, conf, workers)
config.parse_config(sys.argv)
workers = GraphWorkersManager()
spawn(init, workers)
workers.run()
def init(conf, workers):
def init(workers):
# Because fork duplicates the process memory.
# We should only create master process resources after workers are forked.
workers.wait_for_worker_start()
VitrageGraphInit(conf, workers).run()
VitrageGraphInit(workers).run()
if __name__ == "__main__":
sys.exit(main())

6
vitrage/cli/machine_learning.py
View File

@ -16,15 +16,15 @@ import cotyledon
import sys
from vitrage.cli import VITRAGE_TITLE
from vitrage.common import config
from vitrage.machine_learning.service import MachineLearningService
from vitrage import service
def main():
print(VITRAGE_TITLE)
conf = service.prepare_service()
config.parse_config(sys.argv)
sm = cotyledon.ServiceManager()
sm.add(MachineLearningService, args=(conf,))
sm.add(MachineLearningService)
sm.run()

6
vitrage/cli/notifier.py
View File

@ -15,15 +15,15 @@ import cotyledon
import sys
from vitrage.cli import VITRAGE_TITLE
from vitrage.common import config
from vitrage.notifier.service import VitrageNotifierService
from vitrage import service
def main():
print(VITRAGE_TITLE)
conf = service.prepare_service()
config.parse_config(sys.argv)
sm = cotyledon.ServiceManager()
sm.add(VitrageNotifierService, args=(conf,))
sm.add(VitrageNotifierService)
sm.run()

9
vitrage/cli/persistor.py
View File

@ -16,9 +16,10 @@ import sys
import cotyledon
from oslo_log import log
from vitrage.cli import VITRAGE_TITLE
from vitrage.common import config
from vitrage.persistency.service import PersistorService
from vitrage import service
from vitrage import storage
LOG = log.getLogger(__name__)
@ -26,10 +27,10 @@ LOG = log.getLogger(__name__)
def main():
print(VITRAGE_TITLE)
conf = service.prepare_service()
db_connection = storage.get_connection_from_config(conf)
config.parse_config(sys.argv)
db_connection = storage.get_connection_from_config()
sm = cotyledon.ServiceManager()
sm.add(PersistorService, args=(conf, db_connection))
sm.add(PersistorService, args=(db_connection,))
sm.run()

7
vitrage/cli/snmp_parsing.py
View File

@ -15,16 +15,17 @@
import sys
import cotyledon
from vitrage.cli import VITRAGE_TITLE
from vitrage import service
from vitrage.common import config
from vitrage.snmp_parsing.service import SnmpParsingService
def main():
print(VITRAGE_TITLE)
conf = service.prepare_service()
config.parse_config(sys.argv)
sm = cotyledon.ServiceManager()
sm.add(SnmpParsingService, args=(conf,))
sm.add(SnmpParsingService)
sm.run()

12
vitrage/cli/storage.py
View File

@ -12,21 +12,23 @@
# License for the specific language governing permissions and limitations
# under the License.
import sys
from vitrage.cli import VITRAGE_TITLE
from vitrage import service
from vitrage.common import config
from vitrage import storage
def dbsync():
print(VITRAGE_TITLE)
conf = service.prepare_service()
storage.get_connection_from_config(conf).upgrade()
config.parse_config(sys.argv)
storage.get_connection_from_config().upgrade()
def purge_data():
print(VITRAGE_TITLE)
conf = service.prepare_service()
db = storage.get_connection_from_config(conf)
config.parse_config(sys.argv)
db = storage.get_connection_from_config()
db.active_actions.delete()
db.events.delete()
db.graph_snapshots.delete()

47
vitrage/service.py → vitrage/common/config.py
View File

@ -1,4 +1,4 @@
# Copyright 2015 - Alcatel-Lucent
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
@ -10,7 +10,6 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_db import options as db_options
from oslo_log import log
@ -20,47 +19,43 @@ from osprofiler import opts as osprofiler_opts
from vitrage import keystone_client
from vitrage import messaging
from vitrage import opts
from vitrage.opts import register_opts
CONF = cfg.CONF
LOG = log.getLogger(__name__)
def prepare_service(args=None, conf=None, config_files=None):
def parse_config(args, default_config_files=None):
set_defaults()
if conf is None:
conf = cfg.ConfigOpts()
log.register_options(conf)
policy_opts.set_defaults(conf)
osprofiler_opts.set_defaults(conf)
db_options.set_defaults(conf)
log.register_options(CONF)
policy_opts.set_defaults(CONF)
osprofiler_opts.set_defaults(CONF)
db_options.set_defaults(CONF)
for group, options in opts.list_opts():
conf.register_opts(list(options),
CONF.register_opts(list(options),
group=None if group == 'DEFAULT' else group)
conf(args, project='vitrage', validate_default_values=True,
default_config_files=config_files)
CONF(args[1:], project='vitrage', validate_default_values=True,
default_config_files=default_config_files)
if conf.profiler.enabled:
if CONF.profiler.enabled:
osprofiler_initializer.init_from_conf(
conf=conf,
conf=CONF,
context=None,
project="vitrage",
service="api",
host=conf.api.host)
project='vitrage',
service='api',
host=CONF.api.host
)
for datasource in conf.datasources.types:
register_opts(conf, datasource, conf.datasources.path)
for datasource in CONF.datasources.types:
opts.register_opts(datasource, CONF.datasources.path)
keystone_client.register_keystoneauth_opts(conf)
log.setup(conf, 'vitrage')
conf.log_opt_values(LOG, log.DEBUG)
keystone_client.register_keystoneauth_opts()
log.setup(CONF, 'vitrage')
CONF.log_opt_values(LOG, log.DEBUG)
messaging.setup()
return conf
def set_defaults():
from oslo_middleware import cors

7
vitrage/coordination/coordination.py
View File

@ -20,16 +20,17 @@ import six
import tenacity
import tooz.coordination
from oslo_config import cfg
from oslo_log import log
from oslo_utils import timeutils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class Coordinator(object):
def __init__(self, conf, my_id=None):
self.conf = conf
self.backend_url = self.conf.coordination.backend_url
def __init__(self, my_id=None):
self.backend_url = CONF.coordination.backend_url
self.my_id = my_id or ' '.join(psutil.Process(os.getpid()).cmdline())
self.coordinator = None
if self.backend_url:

6
vitrage/coordination/service.py
View File

@ -19,10 +19,10 @@ from vitrage.coordination.coordination import Coordinator
class Service(cotyledon.Service):
def __init__(self, worker_id, conf):
def __init__(self, worker_id):
super(Service, self).__init__(worker_id)
self.coordinator = Coordinator(conf, '%s worker(%s)' % (self.name,
worker_id))
self.coordinator = Coordinator('%s worker(%s)' % (self.name,
worker_id))
def run(self):
self.coordinator.start()

3
vitrage/datasources/alarm_transformer_base.py
View File

@ -22,9 +22,6 @@ from vitrage.datasources import transformer_base as tbase
class AlarmTransformerBase(tbase.TransformerBase):
def __init__(self, transformers, conf):
super(AlarmTransformerBase, self).__init__(transformers, conf)
def _ok_status(self, entity_event):
pass

5
vitrage/datasources/aodh/driver.py
View File

@ -32,10 +32,9 @@ LOG = log.getLogger(__name__)
class AodhDriver(AlarmDriverBase):
def __init__(self, conf):
def __init__(self):
super(AodhDriver, self).__init__()
self._client = None
self.conf = conf
self._init_aodh_event_actions()
self._init_convert_aodh_alarm_rule_actions()
self._init_alarm_type_to_rule()
@ -86,7 +85,7 @@ class AodhDriver(AlarmDriverBase):
@property
def client(self):
if not self._client:
self._client = os_clients.aodh_client(self.conf)
self._client = os_clients.aodh_client()
return self._client
def _vitrage_type(self):

3
vitrage/datasources/aodh/transformer.py
View File

@ -38,9 +38,6 @@ class AodhTransformer(AlarmTransformerBase):
AodhEventType.DELETION: GraphAction.DELETE_ENTITY,
}
def __init__(self, transformers, conf):
super(AodhTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
if _is_vitrage_alarm(entity_event):
return self._create_merge_alarm_vertex(entity_event)

5
vitrage/datasources/ceilometer/driver.py
View File

@ -32,17 +32,16 @@ LOG = log.getLogger(__name__)
class CeilometerDriver(AlarmDriverBase):
def __init__(self, conf):
def __init__(self):
super(CeilometerDriver, self).__init__()
self._client = None
self.conf = conf
self._init_aodh_event_actions()
self._cache_all_alarms()
@property
def client(self):
if not self._client:
self._client = os_clients.ceilometer_client(self.conf)
self._client = os_clients.ceilometer_client()
return self._client
def _vitrage_type(self):

3
vitrage/datasources/ceilometer/transformer.py
View File

@ -41,9 +41,6 @@ class CeilometerTransformer(AlarmTransformerBase):
CeilEventType.DELETION: GraphAction.DELETE_ENTITY,
}
def __init__(self, transformers, conf):
super(CeilometerTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
if _is_vitrage_alarm(entity_event):
return self._create_merge_alarm_vertex(entity_event)

5
vitrage/datasources/cinder/volume/driver.py
View File

@ -21,15 +21,14 @@ from vitrage import os_clients
class CinderVolumeDriver(DriverBase):
def __init__(self, conf):
def __init__(self):
super(CinderVolumeDriver, self).__init__()
self._client = None
self.conf = conf
@property
def client(self):
if not self._client:
self._client = os_clients.cinder_client(self.conf)
self._client = os_clients.cinder_client()
return self._client
@staticmethod

3
vitrage/datasources/cinder/volume/transformer.py
View File

@ -39,9 +39,6 @@ class CinderVolumeTransformer(ResourceTransformerBase):
'volume.attach.end': GraphAction.UPDATE_RELATIONSHIP
}
def __init__(self, transformers, conf):
super(CinderVolumeTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
volume_name = extract_field_value(entity_event,

11
vitrage/datasources/collectd/driver.py
View File

@ -12,6 +12,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import DatasourceAction
@ -24,17 +25,17 @@ from vitrage.datasources.collectd.properties\
import CollectdProperties as CProps
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class CollectdDriver(AlarmDriverBase):
conf_map = None
def __init__(self, conf):
def __init__(self):
super(CollectdDriver, self).__init__()
self.conf = conf
if not CollectdDriver.conf_map:
mapper = CollectdDriver._configuration_mapping(conf)
mapper = CollectdDriver._configuration_mapping()
if mapper:
CollectdDriver.conf_map = CollectdMapper(mapper)
@ -59,9 +60,9 @@ class CollectdDriver(AlarmDriverBase):
and alarm[CProps.RESOURCE_NAME] is not None
@staticmethod
def _configuration_mapping(conf):
def _configuration_mapping():
try:
collectd_config_file = conf.collectd[DSOpts.CONFIG_FILE]
collectd_config_file = CONF.collectd[DSOpts.CONFIG_FILE]
collectd_config = file_utils.load_yaml_file(collectd_config_file)
collectd_config_elements = collectd_config[COLLECTD_DATASOURCE]

3
vitrage/datasources/collectd/transformer.py
View File

@ -28,9 +28,6 @@ from vitrage.utils.datetime import format_unix_timestamp
class CollectdTransformer(AlarmTransformerBase):
def __init__(self, transformers, conf):
super(CollectdTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
# The Collectd datasource does not support snapshot mode
return None

4
vitrage/datasources/consistency/transformer.py
View File

@ -29,8 +29,8 @@ class ConsistencyTransformer(ResourceTransformerBase):
GraphAction.REMOVE_DELETED_ENTITY: GraphAction.REMOVE_DELETED_ENTITY
}
def __init__(self, transformers, conf):
super(ConsistencyTransformer, self).__init__(transformers, conf)
def __init__(self, transformers):
super(ConsistencyTransformer, self).__init__(transformers)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event)

3
vitrage/datasources/doctor/driver.py
View File

@ -32,9 +32,8 @@ LOG = log.getLogger(__name__)
class DoctorDriver(AlarmDriverBase):
AlarmKey = namedtuple('AlarmKey', ['alarm_name', 'hostname'])
def __init__(self, conf):
def __init__(self):
super(DoctorDriver, self).__init__()
self.conf = conf
self._client = None
def _vitrage_type(self):

3
vitrage/datasources/doctor/transformer.py
View File

@ -35,9 +35,6 @@ LOG = logging.getLogger(__name__)
class DoctorTransformer(AlarmTransformerBase):
def __init__(self, transformers, conf):
super(DoctorTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
# The Doctor monitor does not support snapshot mode
return None

3
vitrage/datasources/driver_base.py
View File

@ -29,9 +29,6 @@ class DriverBase(object):
_datasource_name = None
def __init__(self):
pass
@abc.abstractmethod
def get_all(self, datasource_action):
pass

15
vitrage/datasources/heat/stack/driver.py
View File

@ -12,6 +12,8 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from vitrage.common.constants import DatasourceAction
from vitrage.common.constants import DatasourceProperties as DSProps
from vitrage.common.constants import GraphAction
@ -27,6 +29,8 @@ from vitrage.datasources.nova.instance.driver import InstanceDriver
from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE
from vitrage import os_clients
CONF = cfg.CONF
class HeatStackDriver(DriverBase):
@ -44,21 +48,20 @@ class HeatStackDriver(DriverBase):
'OS::Neutron::Port': PortDriver
}
def __init__(self, conf):
def __init__(self):
super(HeatStackDriver, self).__init__()
self._client = None
self._conf = conf
self._filter_resource_types()
@property
def client(self):
if not self._client:
self._client = os_clients.heat_client(self._conf)
self._client = os_clients.heat_client()
return self._client
@staticmethod
def get_topic(conf):
return conf[HEAT_STACK_DATASOURCE].notification_topic
def get_topic():
return CONF[HEAT_STACK_DATASOURCE].notification_topic
@staticmethod
def get_event_types():
@ -93,7 +96,7 @@ class HeatStackDriver(DriverBase):
return self.client.stacks.get(_id).to_dict()['parent']
def _filter_resource_types(self):
types = self._conf.datasources.types
types = CONF.datasources.types
self.RESOURCE_TYPE = {key: value for key, value in
self.RESOURCE_TYPE.items() if value in types}

3
vitrage/datasources/heat/stack/transformer.py
View File

@ -46,9 +46,6 @@ class HeatStackTransformer(ResourceTransformerBase):
'orchestration.stack.delete.end': GraphAction.DELETE_ENTITY,
}
def __init__(self, transformers, conf):
super(HeatStackTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
stack_name = extract_field_value(entity_event, StackProps.STACK_NAME)

6
vitrage/datasources/kapacitor/config.py
View File

@ -14,11 +14,13 @@
import re
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import DatasourceOpts as DSOpts
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
KAPACITOR_HOST = 'kapacitor_host'
KAPACITOR = 'kapacitor'
@ -30,9 +32,9 @@ VITRAGE_RESOURCE = 'vitrage_resource'
class KapacitorConfig(object):
def __init__(self, conf):
def __init__(self):
try:
kapacitor_config_file = conf.kapacitor[DSOpts.CONFIG_FILE]
kapacitor_config_file = CONF.kapacitor[DSOpts.CONFIG_FILE]
kapacitor_config = file_utils.load_yaml_file(kapacitor_config_file)
kapacitor = kapacitor_config[KAPACITOR]

5
vitrage/datasources/kapacitor/driver.py
View File

@ -32,12 +32,11 @@ class KapacitorDriver(AlarmDriverBase):
ServiceKey = namedtuple('ServiceKey', ['hostname', 'alarmid'])
conf_map = None
def __init__(self, conf):
def __init__(self):
super(KapacitorDriver, self).__init__()
self.cfg = conf
if not KapacitorDriver.conf_map:
self.conf_map = KapacitorConfig(conf)
self.conf_map = KapacitorConfig()
self._client = None
@staticmethod

3
vitrage/datasources/kapacitor/transformer.py
View File

@ -34,9 +34,6 @@ LOG = logging.getLogger(__name__)
class KapacitorTransformer(AlarmTransformerBase):
def __init__(self, transformers, conf):
super(KapacitorTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event)

13
vitrage/datasources/kubernetes/driver.py
View File

@ -14,36 +14,37 @@
from kubernetes import client
from kubernetes import config
from oslo_log import cfg
from oslo_log import log
from vitrage.datasources.driver_base import DriverBase
from vitrage.datasources.kubernetes.properties import KUBERNETES_DATASOURCE
from vitrage.datasources.kubernetes.properties import KubernetesProperties\
as kubProp
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class KubernetesDriver(DriverBase):
def __init__(self, conf):
def __init__(self):
super(KubernetesDriver, self).__init__()
self._client = None
self.conf = conf
@property
def client(self):
if not self._client:
self._client = self._k8s_client(self.conf)
self._client = self._k8s_client()
return self._client
@staticmethod
def _k8s_client(conf):
def _k8s_client():
try:
if not conf.kubernetes.config_file:
if not CONF.kubernetes.config_file:
LOG.warning('kubernetes config file is not defined')
return
kubeconf = conf.kubernetes.config_file
kubeconf = CONF.kubernetes.config_file
config.load_kube_config(config_file=kubeconf)
k8s_client = client.CoreV1Api()
if k8s_client is None:

7
vitrage/datasources/kubernetes/transformer.py
View File

@ -11,6 +11,7 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log as logging
from vitrage.common.constants import DatasourceProperties as DSProps
@ -32,13 +33,11 @@ from vitrage.datasources.kubernetes.properties import \
KubernetesProperties as kubProp
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
class KubernetesTransformer(ResourceTransformerBase):
def __init__(self, transformers, conf):
super(KubernetesTransformer, self).__init__(transformers, conf)
self.conf = conf
def _create_vertex(self, entity_event):
metadata = {
@ -84,7 +83,7 @@ class KubernetesTransformer(ResourceTransformerBase):
return KUBERNETES_DATASOURCE
def _get_cluster_name(self):
kubeconf = file_utils.load_yaml_file(self.conf.kubernetes.config_file)
kubeconf = file_utils.load_yaml_file(CONF.kubernetes.config_file)
if not kubeconf:
return None
contexts = kubeconf['contexts']

5
vitrage/datasources/monasca/driver.py
View File

@ -28,15 +28,14 @@ LOG = log.getLogger(__name__)
class MonascaDriver(AlarmDriverBase):
def __init__(self, conf):
def __init__(self):
super(MonascaDriver, self).__init__()
self.conf = conf
self.__client = None
@property
def client(self):
if not self.__client:
self.__client = os_clients.monasca_client(self.conf)
self.__client = os_clients.monasca_client()
return self.__client
def _vitrage_type(self):

6
vitrage/datasources/nagios/config.py
View File

@ -14,11 +14,13 @@
import re
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import DatasourceOpts as DSOpts
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
NAGIOS_HOST = 'nagios_host'
NAGIOS = 'nagios'
@ -28,9 +30,9 @@ NAME = 'name'
class NagiosConfig(object):
def __init__(self, conf):
def __init__(self):
try:
nagios_config_file = conf.nagios[DSOpts.CONFIG_FILE]
nagios_config_file = CONF.nagios[DSOpts.CONFIG_FILE]
nagios_config = file_utils.load_yaml_file(nagios_config_file)
nagios = nagios_config[NAGIOS] # nagios root in the yaml file

13
vitrage/datasources/nagios/driver.py
View File

@ -14,6 +14,7 @@
from collections import namedtuple
from oslo_config import cfg
from oslo_log import log
import requests
@ -26,16 +27,16 @@ from vitrage.datasources.nagios.properties import NagiosProperties\
as NagiosProps
from vitrage.datasources.nagios.properties import NagiosTestStatus
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class NagiosDriver(AlarmDriverBase):
ServiceKey = namedtuple('ServiceKey', ['hostname', 'service'])
def __init__(self, conf):
def __init__(self):
super(NagiosDriver, self).__init__()
self.conf = conf
self.config = NagiosConfig(conf)
self.config = NagiosConfig()
def _vitrage_type(self):
return NAGIOS_DATASOURCE
@ -45,9 +46,9 @@ class NagiosDriver(AlarmDriverBase):
service=alarm[NagiosProps.SERVICE])
def _get_alarms(self):
nagios_user = self.conf.nagios.user
nagios_password = self.conf.nagios.password
nagios_url = self.conf.nagios.url
nagios_user = CONF.nagios.user
nagios_password = CONF.nagios.password
nagios_url = CONF.nagios.url
if not nagios_user:
return []

3
vitrage/datasources/nagios/transformer.py
View File

@ -27,9 +27,6 @@ from vitrage.utils import datetime as datetime_utils
class NagiosTransformer(AlarmTransformerBase):
def __init__(self, transformers, conf):
super(NagiosTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event)

5
vitrage/datasources/neutron/base.py
View File

@ -18,13 +18,12 @@ from vitrage import os_clients
class NeutronBase(DriverBase):
def __init__(self, conf):
def __init__(self):
super(NeutronBase, self).__init__()
self._client = None
self.conf = conf
@property
def client(self):
if not self._client:
self._client = os_clients.neutron_client(self.conf)
self._client = os_clients.neutron_client()
return self._client

3
vitrage/datasources/neutron/network/transformer.py
View File

@ -40,9 +40,6 @@ class NetworkTransformer(ResourceTransformerBase):
'network.delete.end': GraphAction.DELETE_ENTITY,
}
def __init__(self, transformers, conf):
super(NetworkTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
name = entity_event[NetworkProps.NAME]

3
vitrage/datasources/neutron/port/transformer.py
View File

@ -51,9 +51,6 @@ class PortTransformer(ResourceTransformerBase):
'port.delete.end': GraphAction.DELETE_ENTITY,
}
def __init__(self, transformers, conf):
super(PortTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
name = entity_event[PortProps.NAME]\

3
vitrage/datasources/nova/host/transformer.py
View File

@ -33,9 +33,6 @@ LOG = logging.getLogger(__name__)
class HostTransformer(ResourceTransformerBase):
def __init__(self, transformers, conf):
super(HostTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event,
entity_event.get(HostProps.HOST))

5
vitrage/datasources/nova/instance/driver.py
View File

@ -12,6 +12,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from vitrage.common.constants import DatasourceAction
from vitrage.common.constants import DatasourceProperties as DSProps
from vitrage.common.constants import GraphAction
@ -19,6 +20,8 @@ from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE
from vitrage.datasources.nova.nova_driver_base import NovaDriverBase
CONF = cfg.CONF
# versioned notifications
VERSIONED_NOTIFICATIONS = {
'instance.create.end',
@ -114,7 +117,7 @@ class InstanceDriver(NovaDriverBase):
*self.properties_to_filter_out())
def enrich_event(self, event, event_type):
use_versioned = self.conf.use_nova_versioned_notifications
use_versioned = CONF.use_nova_versioned_notifications
# Send to the processor only events of the matching types. Nova may
# send both versioned and legacy notifications, and we don't want to

8
vitrage/datasources/nova/instance/transformer.py
View File

@ -11,6 +11,8 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log as logging
from vitrage.common.constants import DatasourceProperties as DSProps
@ -32,6 +34,7 @@ from vitrage.datasources import transformer_base as tbase
from vitrage.datasources.transformer_base import extract_field_value
import vitrage.graph.utils as graph_utils
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
@ -47,9 +50,6 @@ class InstanceTransformer(ResourceTransformerBase):
'instance.delete.end': GraphAction.DELETE_ENTITY,
}
def __init__(self, transformers, conf):
super(InstanceTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
LOG.debug('got snapshot')
return self._create_vertex(entity_event)
@ -134,7 +134,7 @@ class InstanceTransformer(ResourceTransformerBase):
"""Return an object that extracts the field values from the event"""
if tbase.is_update_event(event):
return self.versioned_notifications_extractor if \
self.conf.use_nova_versioned_notifications is True else \
CONF.use_nova_versioned_notifications is True else \
self.legacy_notifications_extractor
else:
return self.snapshot_extractor

5
vitrage/datasources/nova/nova_driver_base.py
View File

@ -18,13 +18,12 @@ from vitrage import os_clients
class NovaDriverBase(DriverBase):
def __init__(self, conf):
def __init__(self):
super(NovaDriverBase, self).__init__()
self._client = None
self.conf = conf
@property
def client(self):
if not self._client:
self._client = os_clients.nova_client(self.conf)
self._client = os_clients.nova_client()
return self._client

3
vitrage/datasources/nova/zone/transformer.py
View File

@ -38,9 +38,6 @@ class ZoneTransformer(ResourceTransformerBase):
STATE_AVAILABLE = 'available'
STATE_UNAVAILABLE = 'unavailable'
def __init__(self, transformers, conf):
super(ZoneTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
zone_name = extract_field_value(entity_event, ZoneProps.ZONE_NAME)

17
vitrage/datasources/prometheus/driver.py
View File

@ -16,6 +16,7 @@ import socket
from collections import namedtuple
from ipaddress import ip_address
from oslo_config import cfg
from oslo_log import log
import requests
import six
@ -46,6 +47,7 @@ from vitrage.datasources.prometheus.properties \
from vitrage import os_clients
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
PROMETHEUS_EVENT_TYPE = 'prometheus.alarm'
@ -132,17 +134,16 @@ class PrometheusDriver(AlarmDriverBase):
PCFProps.RESOURCE])
conf_map = {}
def __init__(self, conf):
def __init__(self):
super(PrometheusDriver, self).__init__()
self.conf = conf
self._client = None
self._nova_client = None
self.conf_map = self._configuration_mapping(conf)
self.conf_map = self._configuration_mapping()
@property
def nova_client(self):
if not self._nova_client:
self._nova_client = os_clients.nova_client(self.conf)
self._nova_client = os_clients.nova_client()
return self._nova_client
def _vitrage_type(self):
@ -167,8 +168,8 @@ class PrometheusDriver(AlarmDriverBase):
old_alarm.get(PAlertProps.STATUS)
def _get_all_alarms(self):
alertmanager_url = self.conf.prometheus.alertmanager_url
receiver = self.conf.prometheus.receiver
alertmanager_url = CONF.prometheus.alertmanager_url
receiver = CONF.prometheus.receiver
if not alertmanager_url:
LOG.warning('Alertmanager url is not defined')
return []
@ -209,8 +210,8 @@ class PrometheusDriver(AlarmDriverBase):
return []
@staticmethod
def _configuration_mapping(conf):
prometheus_config_file = conf.prometheus[DSOpts.CONFIG_FILE]
def _configuration_mapping():
prometheus_config_file = CONF.prometheus[DSOpts.CONFIG_FILE]
try:
prometheus_config = \
file_utils.load_yaml_file(prometheus_config_file)

3
vitrage/datasources/prometheus/transformer.py
View File

@ -38,9 +38,6 @@ LOG = logging.getLogger(__name__)
class PrometheusTransformer(AlarmTransformerBase):
def __init__(self, transformers, conf):
super(PrometheusTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event)

4
vitrage/datasources/resource_transformer_base.py
View File

@ -16,6 +16,4 @@ from vitrage.datasources import transformer_base as tbase
class ResourceTransformerBase(tbase.TransformerBase):
def __init__(self, transformers, conf):
super(ResourceTransformerBase, self).__init__(transformers, conf)
pass

7
vitrage/datasources/static/driver.py
View File

@ -16,6 +16,7 @@ from itertools import chain
from jsonschema import validate
from six.moves import reduce
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import DatasourceProperties as DSProps
@ -26,6 +27,7 @@ from vitrage.datasources.static import STATIC_SCHEMA
from vitrage.datasources.static import StaticFields
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
@ -35,9 +37,8 @@ class StaticDriver(DriverBase):
StaticFields.TYPE,
StaticFields.ID}
def __init__(self, conf):
def __init__(self):
super(StaticDriver, self).__init__()
self.cfg = conf
self.entities_cache = []
@staticmethod
@ -77,7 +78,7 @@ class StaticDriver(DriverBase):
return self.entities_cache
def _get_all_entities(self):
files = file_utils.list_files(self.cfg.static.directory, '.yaml', True)
files = file_utils.list_files(CONF.static.directory, '.yaml', True)
return list(reduce(chain, [self._get_entities_from_file(path)
for path in files], []))

3
vitrage/datasources/static/transformer.py
View File

@ -29,9 +29,6 @@ LOG = logging.getLogger(__name__)
class StaticTransformer(ResourceTransformerBase):
def __init__(self, transformers, conf):
super(StaticTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event)

11
vitrage/datasources/transformer_base.py
View File

@ -17,6 +17,7 @@ import abc
from collections import namedtuple
import six
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import uuidutils
@ -35,6 +36,7 @@ import vitrage.graph.utils as graph_utils
from vitrage.utils import datetime as datetime_utils
from vitrage.utils import opt_exists
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
EntityWrapper = \
@ -109,8 +111,7 @@ class TransformerBase(object):
key_to_uuid_cache = {}
def __init__(self, transformers, conf):
self.conf = conf
def __init__(self, transformers):
self.transformers = transformers
def transform(self, entity_event):
@ -138,11 +139,11 @@ class TransformerBase(object):
def _create_entity_vertex(self, entity_event):
if is_update_event(entity_event) and \
opt_exists(self.conf, self.get_vitrage_type()) and \
opt_exists(self.conf[self.get_vitrage_type()],
opt_exists(CONF, self.get_vitrage_type()) and \
opt_exists(CONF[self.get_vitrage_type()],
DSOpts.UPDATE_METHOD):
update_method = \
self.conf[self.get_vitrage_type()].update_method.lower()
CONF[self.get_vitrage_type()].update_method.lower()
if update_method == UpdateMethod.PUSH:
vertex = self._create_update_entity_vertex(entity_event)
return self.update_uuid_in_vertex(vertex)

4
vitrage/datasources/trove/cluster/driver.py
View File

@ -27,8 +27,8 @@ LOG = log.getLogger(__name__)
class TroveClusterDriver(TroveDriverBase):
def __init__(self, conf):
super(TroveClusterDriver, self).__init__(conf)
def __init__(self):
super(TroveClusterDriver, self).__init__()
self._cached_entities = []
def _get_vitrage_type(self):

4
vitrage/datasources/trove/instance/driver.py
View File

@ -26,8 +26,8 @@ LOG = log.getLogger(__name__)
class TroveInstanceDriver(TroveDriverBase):
def __init__(self, conf):
super(TroveInstanceDriver, self).__init__(conf)
def __init__(self):
super(TroveInstanceDriver, self).__init__()
self._cached_entities = []
def _get_vitrage_type(self):

5
vitrage/datasources/trove/trove_driver_base.py
View File

@ -23,16 +23,15 @@ from vitrage import os_clients
class TroveDriverBase(DriverBase):
def __init__(self, conf):
def __init__(self):
super(TroveDriverBase, self).__init__()
self.conf = conf
self.__client = None
self.__cached_entities = []
@property
def client(self):
if not self.__client:
self.__client = os_clients.trove_client(self.conf)
self.__client = os_clients.trove_client()
return self.__client
def get_all(self, datasource_action):

26
vitrage/datasources/utils.py
View File

@ -11,34 +11,38 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_utils import importutils as utils
from vitrage.common.constants import DatasourceOpts as DSOpts
from vitrage.common.constants import UpdateMethod
from vitrage.utils import opt_exists
CONF = cfg.CONF
drivers = {}
# noinspection PyProtectedMember
def get_drivers_by_name(conf, driver_names):
def get_drivers_by_name(driver_names):
for d_name in driver_names:
if not drivers.get(d_name):
drivers[d_name] = utils.import_object(conf[d_name].driver, conf)
drivers[d_name] = utils.import_object(CONF[d_name].driver)
drivers[d_name].__class__._datasource_name = d_name
return [drivers[d_name] for d_name in driver_names]
def get_pull_drivers_names(conf):
return [name for name in conf.datasources.types
if conf[name].update_method.lower() == UpdateMethod.PULL
and opt_exists(conf[name], DSOpts.CHANGES_INTERVAL)]
def get_pull_drivers_names():
return [name for name in CONF.datasources.types
if CONF[name].update_method.lower() == UpdateMethod.PULL
and opt_exists(CONF[name], DSOpts.CHANGES_INTERVAL)]
def get_push_drivers_names(conf):
return [name for name in conf.datasources.types
if conf[name].update_method.lower() == UpdateMethod.PUSH]
def get_push_drivers_names():
return [name for name in CONF.datasources.types
if CONF[name].update_method.lower() == UpdateMethod.PUSH]
def get_driver_class(conf, driver_name):
return utils.import_class(conf[driver_name].driver)
def get_driver_class(driver_name):
return utils.import_class(CONF[driver_name].driver)

23
vitrage/datasources/zabbix/driver.py
View File

@ -14,6 +14,7 @@
from collections import namedtuple
from oslo_config import cfg
from oslo_log import log
from oslo_utils import importutils as utils
@ -29,6 +30,7 @@ from vitrage.datasources.zabbix.properties import ZabbixTriggerValue \
from vitrage.datasources.zabbix import ZABBIX_DATASOURCE
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
@ -36,30 +38,29 @@ class ZabbixDriver(AlarmDriverBase):
ServiceKey = namedtuple('ServiceKey', ['hostname', 'triggerid'])
conf_map = None
def __init__(self, conf):
def __init__(self):
super(ZabbixDriver, self).__init__()
self.conf = conf
if not ZabbixDriver.conf_map:
ZabbixDriver.conf_map =\
ZabbixDriver._configuration_mapping(conf)
ZabbixDriver._configuration_mapping()
self._client = None
def zabbix_client_login(self):
if not self.conf.zabbix.user:
if not CONF.zabbix.user:
LOG.warning('Zabbix user is not defined')
if not self.conf.zabbix.password:
if not CONF.zabbix.password:
LOG.warning('Zabbix password is not defined')
if not self.conf.zabbix.url:
if not CONF.zabbix.url:
LOG.warning('Zabbix url is not defined')
try:
if not self._client:
self._client = utils.import_object(
'pyzabbix.ZabbixAPI',
self.conf.zabbix.url)
CONF.zabbix.url)
self._client.login(
self.conf.zabbix.user,
self.conf.zabbix.password)
CONF.zabbix.user,
CONF.zabbix.password)
except Exception:
LOG.exception('pyzabbix.ZabbixAPI error occurred.')
self._client = None
@ -154,9 +155,9 @@ class ZabbixDriver(AlarmDriverBase):
return alarm[ZProps.VALUE]
@staticmethod
def _configuration_mapping(conf):
def _configuration_mapping():
try:
zabbix_config_file = conf.zabbix[DSOpts.CONFIG_FILE]
zabbix_config_file = CONF.zabbix[DSOpts.CONFIG_FILE]
zabbix_config = file_utils.load_yaml_file(zabbix_config_file)
zabbix_config_elements = zabbix_config[ZABBIX_DATASOURCE]

3
vitrage/datasources/zabbix/transformer.py
View File

@ -32,9 +32,6 @@ from vitrage.utils.datetime import format_unix_timestamp
class ZabbixTransformer(AlarmTransformerBase):
def __init__(self, transformers, conf):
super(ZabbixTransformer, self).__init__(transformers, conf)
def _create_snapshot_entity_vertex(self, entity_event):
return self._create_vertex(entity_event)

6
vitrage/entity_graph/__init__.py
View File

@ -17,6 +17,8 @@ from oslo_config import cfg
from stevedore import driver
CONF = cfg.CONF
OPTS = [
cfg.StrOpt('datasources_values_dir',
default='/etc/vitrage/datasources_values',
@ -35,10 +37,10 @@ OPTS = [
EVALUATOR_TOPIC = 'vitrage.evaluator'
def get_graph_driver(conf):
def get_graph_driver():
try:
mgr = driver.DriverManager('vitrage.entity_graph',
conf.entity_graph.graph_driver,
CONF.entity_graph.graph_driver,
invoke_on_load=True)
return mgr.driver
except ImportError:

14
vitrage/entity_graph/consistency/consistency_enforcer.py
View File

@ -14,6 +14,7 @@
from datetime import timedelta
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import DatasourceAction
@ -30,18 +31,17 @@ from vitrage.evaluator.actions.evaluator_event_transformer \
from vitrage.messaging import VitrageNotifier
from vitrage.utils.datetime import utcnow
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class ConsistencyEnforcer(object):
def __init__(self,
conf,
entity_graph,
actions_callback=None):
self.conf = conf
self.actions_callback = actions_callback or VitrageNotifier(
conf, 'vitrage_consistency', [EVALUATOR_TOPIC]).notify
'vitrage_consistency', [EVALUATOR_TOPIC]).notify
self.graph = entity_graph
self._init_datasources_to_mark_deleted()
@ -73,7 +73,7 @@ class ConsistencyEnforcer(object):
def _find_outdated_entities_to_mark_as_deleted(self):
vitrage_sample_tstmp = str(utcnow() - timedelta(
seconds=2 * self.conf.datasources.snapshots_interval))
seconds=2 * CONF.datasources.snapshots_interval))
query = {
'and': [
{'!=': {VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE}},
@ -87,7 +87,7 @@ class ConsistencyEnforcer(object):
def _find_old_deleted_entities(self):
vitrage_sample_tstmp = str(utcnow() - timedelta(
seconds=self.conf.consistency.min_time_to_delete))
seconds=CONF.consistency.min_time_to_delete))
query = {
'and': [
{'==': {VProps.VITRAGE_IS_DELETED: True}},
@ -140,8 +140,8 @@ class ConsistencyEnforcer(object):
def _init_datasources_to_mark_deleted(self):
self.datasources_to_mark_deleted = []
for driver_name in self.conf.datasources.types:
driver_class = utils.get_driver_class(self.conf, driver_name)
for driver_name in CONF.datasources.types:
driver_class = utils.get_driver_class(driver_name)
if driver_class.should_delete_outdated_entities():
self.datasources_to_mark_deleted.append(driver_name)

24
vitrage/entity_graph/driver_exec.py
View File

@ -15,6 +15,7 @@ from collections import defaultdict
import threading
import time
from oslo_config import cfg
from oslo_log import log
import oslo_messaging
@ -22,18 +23,18 @@ from vitrage.common.constants import DatasourceAction
from vitrage.datasources import utils
from vitrage import messaging
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class DriverExec(object):
def __init__(self, conf, process_output_func, persist):
self.conf = conf
def __init__(self, process_output_func, persist):
self.process_output_func = process_output_func
self.persist = persist
def snapshot_get_all(self, action=DatasourceAction.INIT_SNAPSHOT):
driver_names = self.conf.datasources.types
driver_names = CONF.datasources.types
LOG.info('get_all starting for %s', driver_names)
t1 = time.time()
events_count = 0
@ -46,7 +47,7 @@ class DriverExec(object):
def get_all(self, driver_name, action):
try:
LOCK_BY_DRIVER.acquire(driver_name)
driver = utils.get_drivers_by_name(self.conf, [driver_name])[0]
driver = utils.get_drivers_by_name([driver_name])[0]
LOG.info("run driver get_all: %s", driver_name)
events = driver.get_all(action)
count = self.process_output_func(events)
@ -65,7 +66,7 @@ class DriverExec(object):
driver_name)
return 0
try:
driver = utils.get_drivers_by_name(self.conf, [driver_name])[0]
driver = utils.get_drivers_by_name([driver_name])[0]
LOG.info("run driver get_changes: %s", driver_name)
events = driver.get_changes(DatasourceAction.UPDATE)
count = self.process_output_func(events)
@ -81,23 +82,22 @@ class DriverExec(object):
class DriversNotificationEndpoint(object):
def __init__(self, conf, processor_func):
self._conf = conf
def __init__(self, processor_func):
self._processor_func = processor_func
self._enrich_event_methods = defaultdict(list)
def init(self):
driver_names = utils.get_push_drivers_names(self._conf)
push_drivers = utils.get_drivers_by_name(self._conf, driver_names)
driver_names = utils.get_push_drivers_names()
push_drivers = utils.get_drivers_by_name(driver_names)
for driver in push_drivers:
for event in driver.get_event_types():
self._enrich_event_methods[event].append(driver.enrich_event)
return self
def get_listener(self):
topics = self._conf.datasources.notification_topics
exchange = self._conf.datasources.notification_exchange
transport = messaging.get_transport(self._conf)
topics = CONF.datasources.notification_topics
exchange = CONF.datasources.notification_exchange
transport = messaging.get_transport()
targets = [oslo_messaging.Target(exchange=exchange, topic=topic)
for topic in topics]

28
vitrage/entity_graph/graph_init.py
View File

@ -14,6 +14,7 @@
import threading
import time
from oslo_config import cfg
from oslo_log import log
import oslo_messaging
@ -33,24 +34,23 @@ from vitrage.graph.driver.networkx_graph import NXGraph
from vitrage import messaging
from vitrage import storage
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class VitrageGraphInit(object):
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)
def __init__(self, workers):
self.graph = get_graph_driver()('Entity Graph')
self.db = db_connection = storage.get_connection_from_config()
self.workers = workers
self.events_coordination = EventsCoordination(conf, self.process_event)
self.persist = GraphPersistency(conf, db_connection, self.graph)
self.events_coordination = EventsCoordination(self.process_event)
self.persist = GraphPersistency(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.scheduler = Scheduler(self.graph, self.driver_exec,
self.persist)
self.processor = Processor(conf, self.graph)
self.processor = Processor(self.graph)
def run(self):
LOG.info('Init Started')
@ -114,7 +114,7 @@ class VitrageGraphInit(object):
def _add_graph_subscriptions(self):
self.graph.subscribe(self.workers.submit_graph_update)
vitrage_notifier = GraphNotifier(self.conf)
vitrage_notifier = GraphNotifier()
if vitrage_notifier.enabled:
self.graph.subscribe(vitrage_notifier.notify_when_applicable)
LOG.info('Subscribed vitrage notifier to graph changes')
@ -122,14 +122,13 @@ class VitrageGraphInit(object):
finalization=True)
def subscribe_presist_notifier(self):
self.graph.subscribe(PersistNotifier(self.conf).notify_when_applicable)
self.graph.subscribe(PersistNotifier().notify_when_applicable)
PRIORITY_DELAY = 0.05
class EventsCoordination(object):
def __init__(self, conf, do_work_func):
self._conf = conf
def __init__(self, do_work_func):
self._lock = threading.Lock()
self._high_event_finish_time = 0
@ -146,7 +145,6 @@ class EventsCoordination(object):
def start(self):
self._low_pri_listener = driver_exec.DriversNotificationEndpoint(
self._conf,
self.handle_multiple_low_priority).init().get_listener()
self._high_pri_listener = self._init_listener(
EVALUATOR_TOPIC,
@ -191,7 +189,7 @@ class EventsCoordination(object):
if not topic:
return
return messaging.get_notification_listener(
transport=messaging.get_transport(self._conf),
transport=messaging.get_transport(),
targets=[oslo_messaging.Target(topic=topic)],
endpoints=[PushNotificationsEndpoint(callback)])

3
vitrage/entity_graph/graph_persistency.py
View File

@ -24,8 +24,7 @@ LOG = log.getLogger(__name__)
class GraphPersistency(object):
def __init__(self, conf, db, graph):
self.conf = conf
def __init__(self, db, graph):
self.db = db
self.graph = graph
self.events_buffer = []

13
vitrage/entity_graph/mappings/datasource_info_mapper.py
View File

@ -14,6 +14,7 @@
import os
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import EntityCategory
@ -23,6 +24,7 @@ from vitrage.entity_graph.mappings.resource_handler import \
ResourceHandler
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
@ -34,8 +36,7 @@ class DatasourceInfoMapper(object):
PRIORITY_VALUES = 'priority_values'
UNDEFINED_DATASOURCE = 'undefined datasource'
def __init__(self, conf):
self.conf = conf
def __init__(self):
self.category_normalizer = self._init_category_normalizer()
self.datasources_value_confs = self._load_value_configurations()
@ -62,7 +63,7 @@ class DatasourceInfoMapper(object):
graph_vertex[VProps.VITRAGE_CATEGORY]
if vitrage_type in self.datasources_value_confs or \
vitrage_type not in self.conf.datasources.types:
vitrage_type not in CONF.datasources.types:
value_properties = \
self.category_normalizer[vitrage_category].value_properties()
vitrage_operational_value, vitrage_aggregated_value, value_priority = \
@ -115,11 +116,11 @@ class DatasourceInfoMapper(object):
erroneous_datasources_conf = []
files = file_utils.list_files(
self.conf.entity_graph.datasources_values_dir, '.yaml')
CONF.entity_graph.datasources_values_dir, '.yaml')
for file_name in files:
try:
full_path = self.conf.entity_graph.datasources_values_dir \
full_path = CONF.entity_graph.datasources_values_dir \
+ '/' + file_name
operational_values, priority_values = \
self._retrieve_values_and_priorities_from_file(full_path)
@ -227,7 +228,7 @@ class DatasourceInfoMapper(object):
ok_datasources,
error_datasources):
datasource_types = self.conf.datasources.types
datasource_types = CONF.datasources.types
datasources_with_state_conf = ok_datasources + error_datasources
for datasource_type in datasource_types:

25
vitrage/entity_graph/processor/notifier.py
View File

@ -11,6 +11,7 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log
import oslo_messaging
@ -24,19 +25,21 @@ from vitrage.graph.driver.networkx_graph import edge_copy
from vitrage.graph.driver.networkx_graph import vertex_copy
from vitrage.messaging import get_transport
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class GraphNotifier(object):
"""Allows writing to message bus"""
def __init__(self, conf):
def __init__(self):
self.oslo_notifier = None
topics = self._get_topics(conf)
topics = self._get_topics()
if not topics:
LOG.info('Graph Notifier is disabled')
return
self.oslo_notifier = oslo_messaging.Notifier(
get_transport(conf),
get_transport(),
driver='messagingv2',
publisher_id='vitrage.graph',
topics=topics)
@ -45,12 +48,12 @@ class GraphNotifier(object):
def enabled(self):
return self.oslo_notifier is not None
def _get_topics(self, conf):
def _get_topics(self):
topics = []
try:
notifier_topic = conf.entity_graph.notifier_topic
notifier_plugins = conf.notifiers
notifier_topic = CONF.entity_graph.notifier_topic
notifier_plugins = CONF.notifiers
if notifier_topic and notifier_plugins:
topics.append(notifier_topic)
except Exception:
@ -58,8 +61,8 @@ class GraphNotifier(object):
try:
machine_learning_topic = \
conf.machine_learning.machine_learning_topic
machine_learning_plugins = conf.machine_learning.plugins
CONF.machine_learning.machine_learning_topic
machine_learning_plugins = CONF.machine_learning.plugins
if machine_learning_topic and machine_learning_plugins:
topics.append(machine_learning_topic)
except Exception:
@ -117,11 +120,11 @@ class GraphNotifier(object):
class PersistNotifier(object):
"""Allows writing to message bus"""
def __init__(self, conf):
def __init__(self):
self.oslo_notifier = None
topics = [conf.persistency.persistor_topic]
topics = [CONF.persistency.persistor_topic]
self.oslo_notifier = oslo_messaging.Notifier(
get_transport(conf),
get_transport(),
driver='messagingv2',
publisher_id='vitrage.graph',
topics=topics)

7
vitrage/entity_graph/processor/processor.py
View File

@ -31,11 +31,10 @@ LOG = log.getLogger(__name__)
class Processor(processor.ProcessorBase):
def __init__(self, conf, e_graph=None):
def __init__(self, e_graph=None):
super(Processor, self).__init__()
self.conf = conf
self.transformer_manager = TransformerManager(self.conf)
self.info_mapper = DatasourceInfoMapper(self.conf)
self.transformer_manager = TransformerManager()
self.info_mapper = DatasourceInfoMapper()
self._initialize_events_actions()
self.entity_graph = e_graph

26
vitrage/entity_graph/processor/transformer_manager.py
View File

@ -13,6 +13,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import importutils
@ -26,29 +27,30 @@ from vitrage.evaluator.actions.evaluator_event_transformer \
import VITRAGE_DATASOURCE
from vitrage.utils import opt_exists
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
ENTITIES = 'entities'
class TransformerManager(object):
def __init__(self, conf):
self.transformers = self.register_transformer_classes(conf)
def __init__(self):
self.transformers = self.register_transformer_classes()
@staticmethod
def register_transformer_classes(conf):
def register_transformer_classes():
transformers = {}
for datasource_type in conf.datasources.types:
for datasource_type in CONF.datasources.types:
try:
transformers[datasource_type] = importutils.import_object(
conf[datasource_type].transformer,
transformers, conf)
if opt_exists(conf[datasource_type], ENTITIES):
for entity in conf[datasource_type].entities:
CONF[datasource_type].transformer,
transformers)
if opt_exists(CONF[datasource_type], ENTITIES):
for entity in CONF[datasource_type].entities:
transformers[entity] = importutils.import_object(
conf[datasource_type].transformer,
transformers, conf)
CONF[datasource_type].transformer,
transformers)
except Exception:
LOG.exception('Failed to register transformer %s.',
@ -56,11 +58,11 @@ class TransformerManager(object):
transformers[VITRAGE_DATASOURCE] = importutils.import_object(
"%s.%s" % (EvaluatorEventTransformer.__module__,
EvaluatorEventTransformer.__name__), transformers, conf)
EvaluatorEventTransformer.__name__), transformers)
transformers[CONSISTENCY_DATASOURCE] = importutils.import_object(
"%s.%s" % (ConsistencyTransformer.__module__,
ConsistencyTransformer.__name__), transformers, conf)
ConsistencyTransformer.__name__), transformers)
return transformers

17
vitrage/entity_graph/scheduler.py
View File

@ -14,6 +14,7 @@
from concurrent.futures import ThreadPoolExecutor
from futurist import periodics
from oslo_config import cfg
from oslo_log import log
from vitrage.datasources import utils
@ -23,22 +24,22 @@ from vitrage.common.utils import spawn
from vitrage.entity_graph.consistency.consistency_enforcer import\
ConsistencyEnforcer
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class Scheduler(object):
def __init__(self, conf, graph, driver_exec, persist):
def __init__(self, graph, driver_exec, persist):
super(Scheduler, self).__init__()
self.conf = conf
self.graph = graph
self.driver_exec = driver_exec
self.persist = persist
self.consistency = ConsistencyEnforcer(conf, graph)
self.consistency = ConsistencyEnforcer(graph)
self.periodic = None
def start_periodic_tasks(self, immediate_get_all):
thread_num = len(utils.get_pull_drivers_names(self.conf))
thread_num = len(utils.get_pull_drivers_names())
thread_num += 2 # for consistency and get_all
self.periodic = periodics.PeriodicWorker.create(
[], executor_factory=lambda: ThreadPoolExecutor(
@ -49,7 +50,7 @@ class Scheduler(object):
spawn(self.periodic.start)
def _add_consistency_timer(self):
spacing = self.conf.datasources.snapshots_interval
spacing = CONF.datasources.snapshots_interval
@periodics.periodic(spacing=spacing)
def consistency_periodic():
@ -62,7 +63,7 @@ class Scheduler(object):
LOG.info("added consistency_periodic (spacing=%s)", spacing)
def _add_datasource_timers(self, run_immediately):
spacing = self.conf.datasources.snapshots_interval
spacing = CONF.datasources.snapshots_interval
@periodics.periodic(spacing=spacing, run_immediately=run_immediately)
def get_all_periodic():
@ -71,9 +72,9 @@ class Scheduler(object):
self.periodic.add(get_all_periodic)
LOG.info("added get_all_periodic (spacing=%s)", spacing)
driver_names = utils.get_pull_drivers_names(self.conf)
driver_names = utils.get_pull_drivers_names()
for d_name in driver_names:
spacing = self.conf[d_name].changes_interval
spacing = CONF[d_name].changes_interval
@periodics.periodic(spacing=spacing)
def get_changes_periodic(driver_name=d_name):

55
vitrage/entity_graph/workers.py
View File

@ -18,6 +18,7 @@ import cotyledon
import multiprocessing
import multiprocessing.queues
import os
from oslo_config import cfg
from oslo_log import log
import oslo_messaging
from oslo_utils import uuidutils
@ -45,6 +46,7 @@ from vitrage import messaging
from vitrage import rpc as vitrage_rpc
from vitrage import storage
CONF = cfg.CONF
LOG = None
# Supported message types
@ -67,9 +69,8 @@ class GraphWorkersManager(cotyledon.ServiceManager):
- the queues used to communicate with these workers
- methods interface to submit tasks to workers
"""
def __init__(self, conf):
def __init__(self):
super(GraphWorkersManager, self).__init__()
self._conf = conf
self._db = None
self._evaluator_queues = []
self._template_queues = []
@ -93,10 +94,10 @@ class GraphWorkersManager(cotyledon.ServiceManager):
"""
if self._evaluator_queues:
raise VitrageError('add_evaluator_workers called more than once')
workers = self._conf.evaluator.workers
workers = CONF.evaluator.workers
queues = [multiprocessing.JoinableQueue() for i in range(workers)]
self.add(EvaluatorWorker,
args=(self._conf, queues, workers),
args=(queues, workers),
workers=workers)
self._evaluator_queues = queues
self._all_queues.extend(queues)
@ -111,9 +112,9 @@ class GraphWorkersManager(cotyledon.ServiceManager):
"""
if self._api_queues:
raise VitrageError('add_api_workers called more than once')
workers = self._conf.api.workers
workers = CONF.api.workers
queues = [multiprocessing.Queue() for i in range(workers)]
self.add(ApiWorker, args=(self._conf, queues), workers=workers)
self.add(ApiWorker, args=(queues,), workers=workers)
self._api_queues = queues
self._all_queues.extend(queues)
@ -177,7 +178,7 @@ class GraphWorkersManager(cotyledon.ServiceManager):
template_action = event.get(TEMPLATE_ACTION)
if not self._db:
self._db = storage.get_connection_from_config(self._conf)
self._db = storage.get_connection_from_config()
if template_action == ADD:
templates = self._db.templates.query(status=TStatus.LOADING)
@ -219,10 +220,8 @@ class GraphWorkersManager(cotyledon.ServiceManager):
class GraphCloneWorkerBase(coord.Service):
def __init__(self,
worker_id,
conf,
task_queues):
super(GraphCloneWorkerBase, self).__init__(worker_id, conf)
self._conf = conf
super(GraphCloneWorkerBase, self).__init__(worker_id)
self._task_queue = task_queues[worker_id]
self._entity_graph = NXGraph()
@ -285,7 +284,7 @@ class GraphCloneWorkerBase(coord.Service):
self._entity_graph.remove_edge(before)
def _read_db_graph(self):
db = storage.get_connection_from_config(self._conf)
db = storage.get_connection_from_config()
graph_snapshot = db.graph_snapshots.query()
NXGraph.read_gpickle(graph_snapshot.graph_snapshot, self._entity_graph)
GraphPersistency.do_replay_events(db, self._entity_graph,
@ -296,25 +295,22 @@ class GraphCloneWorkerBase(coord.Service):
class EvaluatorWorker(GraphCloneWorkerBase):
def __init__(self,
worker_id,
conf,
task_queues,
workers_num):
super(EvaluatorWorker, self).__init__(
worker_id, conf, task_queues)
worker_id, task_queues)
self._workers_num = workers_num
self._evaluator = None
name = 'EvaluatorWorker'
def _init_instance(self):
scenario_repo = ScenarioRepository(self._conf, self.worker_id,
scenario_repo = ScenarioRepository(self.worker_id,
self._workers_num)
actions_callback = messaging.VitrageNotifier(
conf=self._conf,
publisher_id='vitrage_evaluator',
topics=[EVALUATOR_TOPIC]).notify
self._evaluator = ScenarioEvaluator(
self._conf,
self._entity_graph,
scenario_repo,
actions_callback,
@ -338,7 +334,7 @@ class EvaluatorWorker(GraphCloneWorkerBase):
def _reload_templates(self):
LOG.info("reloading evaluator scenarios")
scenario_repo = ScenarioRepository(self._conf, self.worker_id,
scenario_repo = ScenarioRepository(self.worker_id,
self._workers_num)
self._evaluator.scenario_repo = scenario_repo
self._evaluator.scenario_repo.log_enabled_scenarios()
@ -347,7 +343,7 @@ class EvaluatorWorker(GraphCloneWorkerBase):
# Here, we create a temporary ScenarioRepo to execute the needed
# templates. Once _reload_templates is called, it will create a
# non temporary ScenarioRepo, to replace this one
scenario_repo = ScenarioRepository(self._conf)
scenario_repo = ScenarioRepository()
for s in scenario_repo._all_scenarios:
s.enabled = False
for template_name in template_names:
@ -363,24 +359,23 @@ class ApiWorker(GraphCloneWorkerBase):
name = 'ApiWorker'
def _init_instance(self):
conf = self._conf
notifier = messaging.VitrageNotifier(conf, "vitrage.api",
notifier = messaging.VitrageNotifier("vitrage.api",
[EVALUATOR_TOPIC])
db = storage.get_connection_from_config(conf)
transport = messaging.get_rpc_transport(conf)
target = oslo_messaging.Target(topic=conf.rpc_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, conf, self.api_lock),
AlarmApis(self._entity_graph, conf, self.api_lock, db),
RcaApis(self._entity_graph, conf, self.api_lock, db),
ResourceApis(self._entity_graph, conf, self.api_lock),
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(conf),
WebhookApis(conf, db),
OperationalApis(conf, self._entity_graph),
EventApis(),
WebhookApis(db),
OperationalApis(self._entity_graph),
]
server = vitrage_rpc.get_server(target, endpoints, transport)

4
vitrage/evaluator/actions/action_executor.py
View File

@ -51,10 +51,10 @@ SOURCE = 'source'
class ActionExecutor(object):
def __init__(self, conf, actions_callback):
def __init__(self, actions_callback):
self.actions_callback = actions_callback
self.notifier = EvaluatorNotifier(conf)
self.notifier = EvaluatorNotifier()
self.action_recipes = ActionExecutor._register_action_recipes()
self.action_step_defs = {

4
vitrage/evaluator/actions/evaluator_event_transformer.py
View File

@ -42,8 +42,8 @@ VITRAGE_DATASOURCE = 'vitrage'
class EvaluatorEventTransformer(transformer_base.TransformerBase):
def __init__(self, transformers, conf):
super(EvaluatorEventTransformer, self).__init__(transformers, conf)
def __init__(self, transformers):
super(EvaluatorEventTransformer, self).__init__(transformers)
self.actions = self._init_actions()
def _create_snapshot_entity_vertex(self, entity_event):

11
vitrage/evaluator/actions/notifier.py
View File

@ -11,6 +11,8 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log
import oslo_messaging
@ -18,15 +20,16 @@ from vitrage.common.constants import NotifierEventTypes
from vitrage.messaging import get_transport
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class EvaluatorNotifier(object):
"""Allows writing to message bus"""
def __init__(self, conf):
def __init__(self, ):
self.oslo_notifiers = {}
try:
notifier_plugins = conf.notifiers
notifier_plugins = CONF.notifiers
LOG.debug('notifier_plugins: %s', notifier_plugins)
@ -35,13 +38,13 @@ class EvaluatorNotifier(object):
return
topic_prefix = \
conf.evaluator_actions.evaluator_notification_topic_prefix
CONF.evaluator_actions.evaluator_notification_topic_prefix
for notifier in notifier_plugins:
LOG.debug('Adding evaluator notifier %s', notifier)
self.oslo_notifiers[notifier] = oslo_messaging.Notifier(
get_transport(conf),
get_transport(),
driver='messagingv2',
publisher_id='vitrage.evaluator',
topics=[topic_prefix + '.' + notifier])

18
vitrage/evaluator/scenario_evaluator.py
View File

@ -18,6 +18,7 @@ import copy
import re
import time
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import EdgeProperties as EProps
@ -42,6 +43,7 @@ from vitrage import storage
from vitrage.storage.sqlalchemy import models
from vitrage.utils.datetime import utcnow
CONF = cfg.CONF
LOG = log.getLogger(__name__)
# Entry containing action info.
@ -60,16 +62,14 @@ SOURCE = 'source'
class ScenarioEvaluator(object):
def __init__(self,
conf,
e_graph,
scenario_repo,
actions_callback,
enabled=False):
self._conf = conf
self._entity_graph = e_graph
self._db = storage.get_connection_from_config(self._conf)
self._db = storage.get_connection_from_config()
self._scenario_repo = scenario_repo
self._action_executor = ActionExecutor(self._conf, actions_callback)
self._action_executor = ActionExecutor(actions_callback)
self._entity_graph.subscribe(self.process_event)
self.enabled = enabled
self.connected_component_cache = defaultdict(dict)
@ -314,7 +314,7 @@ class ScenarioEvaluator(object):
if not actions:
return []
active_actions = ActiveActionsTracker(self._conf, self._db, actions)
active_actions = ActiveActionsTracker(self._db, actions)
for action_info in actions:
if action_info.mode == ActionMode.DO:
active_actions.calc_do_action(action_info)
@ -483,13 +483,13 @@ class ActiveActionsTracker(object):
"""
action_tools = None
def __init__(self, conf, db, actions):
def __init__(self, db, actions):
self.db = db
self.data = defaultdict(set)
self.actions_to_create = {}
self.actions_to_remove = set()
self.actions_to_perform = [] # use a list to keep the insertion order
self._init_action_tools(conf)
self._init_action_tools()
# Query DB for all actions with same properties
actions_keys = set([self._get_key(action) for action in actions])
@ -499,10 +499,10 @@ class ActiveActionsTracker(object):
db_row.extra_info, db_row.action_type)].add(db_row)
@classmethod
def _init_action_tools(cls, conf):
def _init_action_tools(cls):
if cls.action_tools:
return
info_mapper = DatasourceInfoMapper(conf)
info_mapper = DatasourceInfoMapper()
alarms_score = info_mapper.get_datasource_priorities('vitrage')
all_scores = info_mapper.get_datasource_priorities()
cls.action_tools = {

4
vitrage/evaluator/scenario_repository.py
View File

@ -35,7 +35,7 @@ DEF_TEMPLATES_DIR_OPT = 'def_templates_dir'
class ScenarioRepository(object):
def __init__(self, conf, worker_index=None, workers_num=None):
def __init__(self, worker_index=None, workers_num=None):
"""Create an instance of ScenarioRepository
:param conf:
@ -45,7 +45,7 @@ class ScenarioRepository(object):
self._templates = {}
self._def_templates = {}
self._all_scenarios = []
self._db = storage.get_connection_from_config(conf)
self._db = storage.get_connection_from_config()
self.entity_equivalences = EquivalenceRepository().load(self._db)
self.relationship_scenarios = defaultdict(list)
self.entity_scenarios = defaultdict(list)

21
vitrage/keystone_client.py
View File

@ -24,22 +24,23 @@ from keystoneclient.v3 import client as ks_client_v3
from oslo_config import cfg
from oslo_log import log
CONF = cfg.CONF
LOG = log.getLogger(__name__)
CFG_GROUP = "service_credentials"
def get_session(conf):
def get_session():
"""Get a vitrage service credentials auth session."""
auth_plugin = ka_loading.load_auth_from_conf_options(conf, CFG_GROUP)
auth_plugin = ka_loading.load_auth_from_conf_options(CONF, CFG_GROUP)
return ka_loading.load_session_from_conf_options(
conf, CFG_GROUP, auth=auth_plugin
CONF, CFG_GROUP, auth=auth_plugin
)
def get_client(conf):
def get_client():
"""Return a client for keystone v3 endpoint."""
sess = get_session(conf)
sess = get_session()
return ks_client_v3.Client(session=sess)
@ -57,10 +58,10 @@ def get_client_on_behalf_user(auth_plugin):
return ks_client_v3.Client(session=sess)
def create_trust_id(conf, trustor_user_id, trustor_project_id, roles,
def create_trust_id(trustor_user_id, trustor_project_id, roles,
auth_plugin):
"""Create a new trust using the vitrage service user."""
admin_client = get_client(conf)
admin_client = get_client()
trustee_user_id = admin_client.session.get_user_id()
client = get_client_on_behalf_user(auth_plugin)
@ -98,10 +99,10 @@ OPTS = [
]
def register_keystoneauth_opts(conf):
ka_loading.register_auth_conf_options(conf, CFG_GROUP)
def register_keystoneauth_opts():
ka_loading.register_auth_conf_options(CONF, CFG_GROUP)
ka_loading.register_session_conf_options(
conf, CFG_GROUP,
CONF, CFG_GROUP,
deprecated_opts={'cacert': [
cfg.DeprecatedOpt('os-cacert', group=CFG_GROUP),
cfg.DeprecatedOpt('os-cacert', group="DEFAULT")]

3
vitrage/machine_learning/plugins/base.py
View File

@ -19,9 +19,6 @@ import six
@six.add_metaclass(abc.ABCMeta)
class MachineLearningBase(object):
def __init__(self, conf):
self.conf = conf
@abc.abstractmethod
def process_event(self, data, event_type):
pass

12
vitrage/machine_learning/plugins/jaccard_correlation/alarm_processor.py
View File

@ -14,6 +14,8 @@
from collections import namedtuple
from datetime import datetime
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import NotifierEventTypes
@ -28,6 +30,8 @@ from vitrage.machine_learning.plugins.jaccard_correlation.\
from vitrage.machine_learning.plugins.jaccard_correlation.correlation_manager\
import CorrelationManager as CM
CONF = cfg.CONF
LOG = log.getLogger(__name__)
AlarmID = namedtuple('AlarmID', [VProps.VITRAGE_RESOURCE_ID,
@ -41,12 +45,12 @@ class AlarmDataProcessor(MachineLearningBase):
def get_plugin_name():
return 'jaccard_correlation'
def __init__(self, conf):
super(AlarmDataProcessor, self).__init__(conf)
def __init__(self):
super(AlarmDataProcessor, self).__init__()
self.data_manager = ADAcummulator(APersistor.load_data())
self.correlation_manager = CM(conf)
self.correlation_manager = CM()
self.num_of_events_to_flush = \
conf.jaccard_correlation.num_of_events_to_flush
CONF.jaccard_correlation.num_of_events_to_flush
self.event_counter = 0
def process_event(self, data, event_type):

12
vitrage/machine_learning/plugins/jaccard_correlation/correlation_manager.py
View File

@ -15,6 +15,7 @@
import os
import time
from oslo_config import cfg
from oslo_log import log
from vitrage.machine_learning.plugins.jaccard_correlation.\
@ -23,17 +24,18 @@ from vitrage.machine_learning.plugins.jaccard_correlation.\
correlation_collection import CorrelationPriorities as CPriorities
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class CorrelationManager(object):
def __init__(self, conf):
self.high_corr_score = conf.jaccard_correlation.high_corr_score
self.med_corr_score = conf.jaccard_correlation.med_corr_score
def __init__(self):
self.high_corr_score = CONF.jaccard_correlation.high_corr_score
self.med_corr_score = CONF.jaccard_correlation.med_corr_score
self.correlation_threshold = \
conf.jaccard_correlation.correlation_threshold
self.output_folder = conf.jaccard_correlation.output_folder
CONF.jaccard_correlation.correlation_threshold
self.output_folder = CONF.jaccard_correlation.output_folder
self.last_written_file = ""
self.correlation_table = CCollection(self.high_corr_score,
self.med_corr_score)

26
vitrage/machine_learning/service.py
View File

@ -12,7 +12,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log
import oslo_messaging as oslo_m
from oslo_utils import importutils
@ -21,18 +21,18 @@ from vitrage.coordination import service as coord
from vitrage import messaging
from vitrage.opts import register_opts
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class MachineLearningService(coord.Service):
def __init__(self, worker_id, conf):
super(MachineLearningService, self).__init__(worker_id, conf)
self.conf = conf
self.machine_learning_plugins = self.get_machine_learning_plugins(conf)
transport = messaging.get_transport(conf)
def __init__(self, worker_id):
super(MachineLearningService, self).__init__(worker_id)
self.machine_learning_plugins = self.get_machine_learning_plugins()
transport = messaging.get_transport()
target = \
oslo_m.Target(topic=conf.machine_learning.machine_learning_topic)
oslo_m.Target(topic=CONF.machine_learning.machine_learning_topic)
self.listener = messaging.get_notification_listener(
transport, [target],
[VitrageEventEndpoint(self.machine_learning_plugins)])
@ -55,21 +55,21 @@ class MachineLearningService(coord.Service):
LOG.info("Vitrage Machine Learning Service - Stopped!")
@staticmethod
def get_machine_learning_plugins(conf):
def get_machine_learning_plugins():
machine_learning_plugins = []
machine_learning_plugins_names = \
conf.machine_learning.plugins
CONF.machine_learning.plugins
if not machine_learning_plugins_names:
LOG.info('There are no Machine Learning plugins in configuration')
return []
for machine_learning_plugin_name in machine_learning_plugins_names:
register_opts(conf, machine_learning_plugin_name,
conf.machine_learning.plugins_path)
register_opts(machine_learning_plugin_name,
CONF.machine_learning.plugins_path)
LOG.info('Machine Learning plugin %s started',
machine_learning_plugin_name)
machine_learning_plugins.append(importutils.import_object(
conf[machine_learning_plugin_name].plugin_path,
conf))
CONF[machine_learning_plugin_name].plugin_path,
CONF))
return machine_learning_plugins

17
vitrage/messaging.py
View File

@ -11,11 +11,12 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log
import oslo_messaging as oslo_msg
# from oslo_messaging import serializer as oslo_serializer
CONF = cfg.CONF
LOG = log.getLogger(__name__)
DEFAULT_URL = "__default__"
@ -28,11 +29,11 @@ def setup():
oslo_msg.set_transport_defaults('vitrage')
def get_rpc_transport(conf, url=None, optional=False, cache=True):
return get_transport(conf, url, optional, cache, rpc=True)
def get_rpc_transport(url=None, optional=False, cache=True):
return get_transport(url, optional, cache, rpc=True)
def get_transport(conf, url=None, optional=False, cache=True, rpc=False):
def get_transport(url=None, optional=False, cache=True, rpc=False):
"""Initialise the oslo_messaging layer."""
global TRANSPORTS, DEFAULT_URL
cache_key = url or DEFAULT_URL + '_rpc' if rpc else ''
@ -40,9 +41,9 @@ def get_transport(conf, url=None, optional=False, cache=True, rpc=False):
if not transport or not cache:
try:
if rpc:
transport = oslo_msg.get_rpc_transport(conf, url)
transport = oslo_msg.get_rpc_transport(CONF, url)
else:
transport = oslo_msg.get_notification_transport(conf, url)
transport = oslo_msg.get_notification_transport(CONF, url)
except oslo_msg.InvalidTransportURL as e:
if not optional or e.url:
# NOTE(sileht): oslo_messaging is configured but unloadable
@ -65,8 +66,8 @@ def get_notification_listener(transport, targets, endpoints,
class VitrageNotifier(object):
"""Allows writing to message bus"""
def __init__(self, conf, publisher_id, topics):
transport = get_transport(conf)
def __init__(self, publisher_id, topics):
transport = get_transport()
self.notifier = oslo_msg.Notifier(
transport,
driver='messagingv2',

6
vitrage/notifier/plugins/aodh/aodh_notifier.py
View File

@ -39,9 +39,9 @@ class AodhNotifier(NotifierBase):
def get_notifier_name():
return AODH_DATASOURCE
def __init__(self, conf):
super(AodhNotifier, self).__init__(conf)
self.client = os_clients.aodh_client(conf)
def __init__(self):
super(AodhNotifier, self).__init__()
self.client = os_clients.aodh_client()
def process_event(self, data, event_type):
response = None

3
vitrage/notifier/plugins/base.py
View File

@ -19,9 +19,6 @@ import six
@six.add_metaclass(abc.ABCMeta)
class NotifierBase(object):
def __init__(self, conf):
self.conf = conf
@abc.abstractmethod
def process_event(self, data, event_type):
pass

7
vitrage/notifier/plugins/mistral/mistral_notifier.py
View File

@ -25,9 +25,8 @@ LOG = logging.getLogger(__name__)
class MistralNotifier(NotifierBase):
def __init__(self, conf):
super(MistralNotifier, self).__init__(conf)
self.conf = conf
def __init__(self):
super(MistralNotifier, self).__init__()
self._client = None
@staticmethod
@ -41,7 +40,7 @@ class MistralNotifier(NotifierBase):
@property
def client(self):
if not self._client:
self._client = os_clients.mistral_client(self.conf)
self._client = os_clients.mistral_client()
return self._client
def info(self, ctxt, publisher_id, event_type, payload, metadata):

6
vitrage/notifier/plugins/nova/nova_notifier.py
View File

@ -30,9 +30,9 @@ class NovaNotifier(NotifierBase):
def get_notifier_name():
return 'nova'
def __init__(self, conf):
super(NovaNotifier, self).__init__(conf)
self.client = os_clients.nova_client(conf)
def __init__(self):
super(NovaNotifier, self).__init__()
self.client = os_clients.nova_client()
self.actions = {
NOVA_HOST_DATASOURCE: self._mark_host_down,
NOVA_INSTANCE_DATASOURCE: self._reset_instance_state

3
vitrage/notifier/plugins/snmp/base.py
View File

@ -20,9 +20,6 @@ import six
class SnmpSenderBase(object):
"""Abstract Vitrage snmp trap sender"""
def __init__(self, conf):
self.conf = conf
@abc.abstractmethod
def send_snmp(self, alarm_data):
pass

8
vitrage/notifier/plugins/snmp/snmp_notifier.py
View File

@ -12,6 +12,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import importutils
@ -19,6 +20,7 @@ from vitrage.common.constants import NotifierEventTypes
from vitrage.common.constants import VertexProperties as VProps
from vitrage.notifier.plugins.base import NotifierBase
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
@ -27,10 +29,10 @@ class SnmpNotifier(NotifierBase):
def get_notifier_name():
return 'snmp'
def __init__(self, conf):
super(SnmpNotifier, self).__init__(conf)
def __init__(self):
super(SnmpNotifier, self).__init__()
self.snmp_sender = \
importutils.import_object(conf.snmp.snmp_sender_class, conf)
importutils.import_object(CONF.snmp.snmp_sender_class)
def process_event(self, data, event_type):

11
vitrage/notifier/plugins/snmp/snmp_sender.py
View File

@ -12,6 +12,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log as logging
from pysnmp.entity.engine import SnmpEngine
from pysnmp.hlapi.asyncore.sync.compat.ntforg import sendNotification
@ -27,6 +28,7 @@ from vitrage.common.constants import VertexProperties as VProps
from vitrage.notifier.plugins.snmp.base import SnmpSenderBase
from vitrage.utils.file import load_yaml_file
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
# TODO(annarez): change NA to N/A
@ -43,12 +45,11 @@ PORT_PAT = re.compile('\d+')
class SnmpSender(SnmpSenderBase):
def __init__(self, conf):
super(SnmpSender, self).__init__(conf)
self.hosts = load_yaml_file(self.conf.snmp.consumers, True)
self.oid_tree = load_yaml_file(self.conf.snmp.oid_tree, True)
def __init__(self):
self.hosts = load_yaml_file(CONF.snmp.consumers, True)
self.oid_tree = load_yaml_file(CONF.snmp.oid_tree, True)
self.alarm_mapping = \
load_yaml_file(self.conf.snmp.alarm_oid_mapping, True)
load_yaml_file(CONF.snmp.alarm_oid_mapping, True)
self.oids, self.var_fields = self._build_oids()
def send_snmp(self, alarm_data):

10
vitrage/notifier/plugins/webhook/webhook.py
View File

@ -14,6 +14,7 @@
import ast
import re
from oslo_config import cfg
from oslo_log import log as logging
from oslo_serialization import jsonutils
from oslo_utils import uuidutils
@ -26,6 +27,7 @@ from vitrage.notifier.plugins.base import NotifierBase
from vitrage.notifier.plugins.webhook import utils as webhook_utils
from vitrage import storage
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
URL = 'url'
IS_ADMIN_WEBHOOK = 'is_admin_webhook'
@ -65,10 +67,10 @@ class Webhook(NotifierBase):
def get_notifier_name():
return 'webhook'
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
def __init__(self):
super(Webhook, self).__init__()
self._db = storage.get_connection_from_config()
self.max_retries = CONF.webhook.max_retries
self.default_headers = {'content-type': 'application/json'}
def process_event(self, data, event_type):

12
vitrage/notifier/plugins/zaqar/zaqar_notifier.py
View File

@ -11,22 +11,24 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import NotifierEventTypes
from vitrage.notifier.plugins.base import NotifierBase
from vitrage import os_clients
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class ZaqarNotifier(NotifierBase):
def __init__(self, conf):
super(ZaqarNotifier, self).__init__(conf)
client = os_clients.zaqar_client(self.conf)
self._queue = client.queue(self.conf.zaqar.queue)
def __init__(self):
super(ZaqarNotifier, self).__init__()
client = os_clients.zaqar_client()
self._queue = client.queue(CONF.zaqar.queue)
@staticmethod
def get_notifier_name():

29
vitrage/notifier/service.py
View File

@ -11,6 +11,8 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log
import oslo_messaging
from oslo_utils import importutils
@ -19,16 +21,16 @@ from vitrage.coordination import service as coord
from vitrage import messaging
from vitrage.opts import register_opts
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class VitrageNotifierService(coord.Service):
def __init__(self, worker_id, conf):
super(VitrageNotifierService, self).__init__(worker_id, conf)
self.conf = conf
self.notifiers = self.get_notifier_plugins(conf)
self._init_listeners(self.conf)
def __init__(self, worker_id):
super(VitrageNotifierService, self).__init__(worker_id)
self.notifiers = self.get_notifier_plugins()
self._init_listeners()
def run(self):
super(VitrageNotifierService, self).run()
@ -51,31 +53,30 @@ class VitrageNotifierService(coord.Service):
LOG.info("Vitrage Notifier Service - Stopped!")
@staticmethod
def get_notifier_plugins(conf):
def get_notifier_plugins():
notifiers = []
conf_notifier_names = conf.notifiers
conf_notifier_names = CONF.notifiers
if not conf_notifier_names:
LOG.info('There are no notifier plugins in configuration')
return []
for notifier_name in conf_notifier_names:
register_opts(conf, notifier_name, conf.notifiers_path)
register_opts(notifier_name, CONF.notifiers_path)
LOG.info('Notifier plugin %s started', notifier_name)
notifiers.append(importutils.import_object(
conf[notifier_name].notifier,
conf))
CONF[notifier_name].notifier))
return notifiers
def _init_listeners(self, conf):
def _init_listeners(self):
self.listeners = []
transport = messaging.get_transport(conf)
transport = messaging.get_transport()
self._init_notifier(transport=transport,
topic=conf.entity_graph.notifier_topic,
topic=CONF.entity_graph.notifier_topic,
endpoint=VitrageDefaultEventEndpoint(
self.notifiers))
topic_prefix = \
conf.evaluator_actions.evaluator_notification_topic_prefix
CONF.evaluator_actions.evaluator_notification_topic_prefix
for notifier in self.notifiers:
if notifier.use_private_topic():

Some files were not shown because too many files have changed in this diff Show More