Refactor vitrage to use global CONF instead of local one

Remove usage of local config object in Vitrage
services and tests. Instead, it's been replaced
with the global CONF object. The structure of the
code becomes more like in other OpenStack projects.
Also, this change provides an opportunity to
introduce migrations and tests for them.

Story: 2004059
Task: 27065
Change-Id: I37544a350adf8ca38a6fc4ff5d0fd96e38a3f922

tools/datasource-scaffold/sample/driver.py

@@ -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():

tools/datasource-scaffold/sample/transformer.py

@@ -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)

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

@@ -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():

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

@@ -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)

tools/load_generator/load_generator.py

@@ -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()
 
 

vitrage/api/app.py

@@ -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):

vitrage/api/app.wsgi

@@ -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()

vitrage/api/hooks.py

@@ -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()
 

vitrage/api_handler/apis/base.py

@@ -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
 

vitrage/api_handler/apis/event.py

@@ -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'])

vitrage/api_handler/apis/operational.py

@@ -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):

vitrage/api_handler/apis/resource.py

@@ -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,

vitrage/api_handler/apis/topology.py

@@ -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):

vitrage/api_handler/apis/webhook.py

@@ -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):

vitrage/cli/api.py

@@ -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__":

vitrage/cli/graph.py

@@ -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())

vitrage/cli/machine_learning.py

@@ -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()
 
 

vitrage/cli/notifier.py

@@ -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()
 
 

vitrage/cli/persistor.py

@@ -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()
 
 

vitrage/cli/snmp_parsing.py

@@ -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()
 
 

vitrage/cli/storage.py

@@ -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()

vitrage/common/config.py

@@ -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

vitrage/coordination/coordination.py

@@ -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:

vitrage/coordination/service.py

@@ -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()

vitrage/datasources/alarm_transformer_base.py

@@ -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
 

vitrage/datasources/aodh/driver.py

@@ -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):

vitrage/datasources/aodh/transformer.py

@@ -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)

vitrage/datasources/ceilometer/driver.py

@@ -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):

vitrage/datasources/ceilometer/transformer.py

@@ -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)

vitrage/datasources/cinder/volume/driver.py

@@ -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

vitrage/datasources/cinder/volume/transformer.py

@@ -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,

vitrage/datasources/collectd/driver.py

@@ -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]
 

vitrage/datasources/collectd/transformer.py

@@ -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

vitrage/datasources/consistency/transformer.py

@@ -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)

vitrage/datasources/doctor/driver.py

@@ -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):

vitrage/datasources/doctor/transformer.py

@@ -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

vitrage/datasources/driver_base.py

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

vitrage/datasources/heat/stack/driver.py

@@ -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}

vitrage/datasources/heat/stack/transformer.py

@@ -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)

vitrage/datasources/kapacitor/config.py

@@ -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]
 

vitrage/datasources/kapacitor/driver.py

@@ -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

vitrage/datasources/kapacitor/transformer.py

@@ -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)
 

vitrage/datasources/kubernetes/driver.py

@@ -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:

vitrage/datasources/kubernetes/transformer.py

@@ -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']

vitrage/datasources/monasca/driver.py

@@ -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):

vitrage/datasources/nagios/config.py

@@ -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
 

vitrage/datasources/nagios/driver.py

@@ -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 []

vitrage/datasources/nagios/transformer.py

@@ -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)