feat(prometheus): store mon job into prometheus collection, part of the decoupling...

[osm/MON.git] / osm_mon / server / service.py

diff --git a/osm_mon/server/service.py b/osm_mon/server/service.py
index 43a0d8e..94bdf4e 100755 (executable)
--- a/osm_mon/server/service.py
+++ b/osm_mon/server/service.py
@@ -20,103 +20,56 @@
 # For those usages not covered by the Apache License, Version 2.0 please
 # contact: bdiaz@whitestack.com or glavado@whitestack.com
 ##
-import json
 import logging
-import uuid
 
-from osm_mon.core import database
 from osm_mon.core.common_db import CommonDbClient
 from osm_mon.core.config import Config
-from osm_mon.core.database import VimCredentialsRepository, VimCredentials, AlarmRepository, Alarm
+from osm_mon.core.models import Alarm
 
 log = logging.getLogger(__name__)
 
 
 class ServerService:
-
     def __init__(self, config: Config):
         self.common_db = CommonDbClient(config)
 
-    def upsert_vim_account(self,
-                           vim_uuid: str,
-                           name: str,
-                           vim_type: str,
-                           url: str,
-                           user: str,
-                           password: str,
-                           tenant_name: str,
-                           schema_version: str,
-                           config: dict) -> VimCredentials:
-        decrypted_vim_password = self.common_db.decrypt_vim_password(password,
-                                                                     schema_version,
-                                                                     vim_uuid)
-
-        vim_config_encrypted = ("admin_password", "nsx_password", "vcenter_password")
-        for key in config:
-            if key in vim_config_encrypted:
-                config[key] = self.common_db.decrypt_vim_password(config[key],
-                                                                  schema_version,
-                                                                  vim_uuid)
-        database.db.connect()
-        try:
-            with database.db.atomic():
-                return VimCredentialsRepository.upsert(
-                    uuid=vim_uuid,
-                    name=name,
-                    type=vim_type,
-                    url=url,
-                    user=user,
-                    password=decrypted_vim_password,
-                    tenant_name=tenant_name,
-                    config=json.dumps(config)
-                )
-        finally:
-            database.db.close()
-
-    def delete_vim_account(self, vim_uuid: str) -> None:
-        database.db.connect()
-        try:
-            with database.db.atomic():
-                vim_credentials = VimCredentialsRepository.get(VimCredentials.uuid == vim_uuid)
-                vim_credentials.delete_instance()
-        finally:
-            database.db.close()
-
-    def create_alarm(self,
-                     name: str,
-                     threshold: str,
-                     operation: str,
-                     severity: str,
-                     statistic: str,
-                     metric_name: str,
-                     vdur_name: str,
-                     vnf_member_index: str,
-                     nsr_id: str) -> Alarm:
-        database.db.connect()
-        try:
-            with database.db.atomic():
-                return AlarmRepository.create(
-                    uuid=str(uuid.uuid4()),
-                    name=name,
-                    threshold=threshold,
-                    operation=operation.lower(),
-                    severity=severity.lower(),
-                    statistic=statistic.lower(),
-                    monitoring_param=metric_name,
-                    vdur_name=vdur_name,
-                    vnf_member_index=vnf_member_index,
-                    nsr_id=nsr_id
-                )
-
-        finally:
-            database.db.close()
-
-    def delete_alarm(self,
-                     alarm_uuid: str) -> None:
-        database.db.connect()
-        try:
-            with database.db.atomic():
-                alarm = AlarmRepository.get(Alarm.uuid == alarm_uuid)
-                alarm.delete_instance()
-        finally:
-            database.db.close()
+    def create_alarm(
+        self,
+        name: str,
+        threshold: float,
+        operation: str,
+        severity: str,
+        statistic: str,
+        metric_name: str,
+        tags: dict,
+    ) -> Alarm:
+        log.debug("create_alarm")
+        alarm = Alarm(
+            name, severity, threshold, operation, statistic, metric_name, tags
+        )
+        self.common_db.create_alarm(alarm)
+        log.info("Alarm %s created", alarm.name)
+        return alarm
+
+    def delete_alarm(self, alarm_uuid: str) -> None:
+        log.debug("delete_alarm")
+        self.common_db.delete_alarm(alarm_uuid)
+        log.info("Alarm %s is deleted", alarm_uuid)
+
+    def populate_prometheus(self):
+        # This method can be executed infinite number of times
+        # without side-effects.
+        self.common_db.common_db.set_one(
+            "prometheus_jobs", {"job_name": "mon_exporter"}, {
+                "job_name": "mon_exporter",
+                "static_configs": [
+                    {
+                        "targets": [
+                            "mon:8000"
+                        ]
+                    }
+                ]
+            },
+            fail_on_empty=False,
+            upsert=True
+        )