osm_mon/core/common_db.py

   1 # -*- coding: utf-8 -*-
   2
   3 # Copyright 2018 Whitestack, LLC
   4 # *************************************************************
   5
   6 # This file is part of OSM Monitoring module
   7 # All Rights Reserved to Whitestack, LLC
   8
   9 # Licensed under the Apache License, Version 2.0 (the "License"); you may
  10 # not use this file except in compliance with the License. You may obtain
  11 # a copy of the License at
  12
  13 #         http://www.apache.org/licenses/LICENSE-2.0
  14
  15 # Unless required by applicable law or agreed to in writing, software
  16 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  17 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  18 # License for the specific language governing permissions and limitations
  19 # under the License.
  20 # For those usages not covered by the Apache License, Version 2.0 please
  21 # contact: bdiaz@whitestack.com or glavado@whitestack.com
  22 ##
  23 from typing import List
  24
  25 from osm_common import dbmongo, dbmemory
  26
  27 from osm_mon.core.config import Config
  28 from osm_mon.core.models import Alarm
  29
  30
  31 class CommonDbClient:
  32     def __init__(self, config: Config):
  33         if config.get("database", "driver") == "mongo":
  34             self.common_db = dbmongo.DbMongo()
  35         elif config.get("database", "driver") == "memory":
  36             self.common_db = dbmemory.DbMemory()
  37         else:
  38             raise Exception(
  39                 "Unknown database driver {}".format(config.get("section", "driver"))
  40             )
  41         self.common_db.db_connect(config.get("database"))
  42
  43     def get_vnfr(self, nsr_id: str, member_index: int):
  44         vnfr = self.common_db.get_one(
  45             "vnfrs", {"nsr-id-ref": nsr_id, "member-vnf-index-ref": str(member_index)}
  46         )
  47         return vnfr
  48
  49     def get_vnfrs(self, nsr_id: str = None, vim_account_id: str = None):
  50         if nsr_id and vim_account_id:
  51             raise NotImplementedError("Only one filter is currently supported")
  52         if nsr_id:
  53             vnfrs = [
  54                 self.get_vnfr(nsr_id, member["member-vnf-index"])
  55                 for member in self.get_nsr(nsr_id)["nsd"]["constituent-vnfd"]
  56             ]
  57         elif vim_account_id:
  58             vnfrs = self.common_db.get_list("vnfrs", {"vim-account-id": vim_account_id})
  59         else:
  60             vnfrs = self.common_db.get_list("vnfrs")
  61         return vnfrs
  62
  63     def get_vnfd(self, vnfd_id: str):
  64         vnfd = self.common_db.get_one("vnfds", {"_id": vnfd_id})
  65         return vnfd
  66
  67     def get_vnfd_by_id(self, vnfd_id: str, filter: dict = {}):
  68         filter["id"] = vnfd_id
  69         vnfd = self.common_db.get_one("vnfds", filter)
  70         return vnfd
  71
  72     def get_vnfd_by_name(self, vnfd_name: str):
  73         # TODO: optimize way of getting single VNFD in shared enviroments (RBAC)
  74         if self.common_db.get_list("vnfds", {"name": vnfd_name}):
  75             vnfd = self.common_db.get_list("vnfds", {"name": vnfd_name})[0]
  76             return vnfd
  77         else:
  78             return None
  79
  80     def get_nsrs(self):
  81         return self.common_db.get_list("nsrs")
  82
  83     def get_nsr(self, nsr_id: str):
  84         nsr = self.common_db.get_one("nsrs", {"id": nsr_id})
  85         return nsr
  86
  87     def get_nslcmop(self, nslcmop_id):
  88         nslcmop = self.common_db.get_one("nslcmops", {"_id": nslcmop_id})
  89         return nslcmop
  90
  91     def get_vdur(self, nsr_id, member_index, vdur_name):
  92         vnfr = self.get_vnfr(nsr_id, member_index)
  93         for vdur in vnfr["vdur"]:
  94             if vdur["name"] == vdur_name:
  95                 return vdur
  96         raise ValueError(
  97             "vdur not found for nsr-id {}, member_index {} and vdur_name {}".format(
  98                 nsr_id, member_index, vdur_name
  99             )
 100         )
 101
 102     def decrypt_vim_password(self, vim_password: str, schema_version: str, vim_id: str):
 103         return self.common_db.decrypt(vim_password, schema_version, vim_id)
 104
 105     def decrypt_sdnc_password(
 106         self, sdnc_password: str, schema_version: str, sdnc_id: str
 107     ):
 108         return self.common_db.decrypt(sdnc_password, schema_version, sdnc_id)
 109
 110     def get_vim_account_id(self, nsr_id: str, vnf_member_index: int) -> str:
 111         vnfr = self.get_vnfr(nsr_id, vnf_member_index)
 112         return vnfr["vim-account-id"]
 113
 114     def get_vim_accounts(self):
 115         return self.common_db.get_list("vim_accounts")
 116
 117     def get_vim_account(self, vim_account_id: str) -> dict:
 118         vim_account = self.common_db.get_one("vim_accounts", {"_id": vim_account_id})
 119         vim_account["vim_password"] = self.decrypt_vim_password(
 120             vim_account["vim_password"], vim_account["schema_version"], vim_account_id
 121         )
 122         vim_config_encrypted_dict = {
 123             "1.1": ("admin_password", "nsx_password", "vcenter_password"),
 124             "default": (
 125                 "admin_password",
 126                 "nsx_password",
 127                 "vcenter_password",
 128                 "vrops_password",
 129             ),
 130         }
 131         vim_config_encrypted = vim_config_encrypted_dict["default"]
 132         if vim_account["schema_version"] in vim_config_encrypted_dict.keys():
 133             vim_config_encrypted = vim_config_encrypted_dict[
 134                 vim_account["schema_version"]
 135             ]
 136         if "config" in vim_account:
 137             for key in vim_account["config"]:
 138                 if key in vim_config_encrypted:
 139                     vim_account["config"][key] = self.decrypt_vim_password(
 140                         vim_account["config"][key],
 141                         vim_account["schema_version"],
 142                         vim_account_id,
 143                     )
 144         return vim_account
 145
 146     def set_vim_account(self, vim_account_id: str, update_dict: dict) -> bool:
 147         try:
 148             # Set vim_account resources in mongo
 149             self.common_db.set_one("vim_accounts", {"_id": vim_account_id}, update_dict)
 150             # self.common_db.set_one('vim_accounts', {"name": "test-vim"}, update_dict)
 151             return True
 152         except Exception:
 153             return False
 154
 155     def get_sdncs(self):
 156         return self.common_db.get_list("sdns")
 157
 158     def get_sdnc(self, sdnc_id: str):
 159         return self.common_db.get_one("sdns", {"_id": sdnc_id})
 160
 161     def get_projects(self):
 162         return self.common_db.get_list("projects")
 163
 164     def get_project(self, project_id: str):
 165         return self.common_db.get_one("projects", {"_id": project_id})
 166
 167     def get_k8sclusters(self):
 168         return self.common_db.get_list("k8sclusters")
 169
 170     def create_alarm(self, alarm: Alarm):
 171         action_data = {"uuid": alarm.uuid, "action": alarm.action}
 172         self.common_db.create("alarms_action", action_data)
 173         return self.common_db.create("alarms", alarm.to_dict())
 174
 175     def delete_alarm(self, alarm_uuid: str):
 176         self.common_db.del_one("alarms_action", {"uuid": alarm_uuid})
 177         return self.common_db.del_one("alarms", {"uuid": alarm_uuid})
 178
 179     def get_alarms(self) -> List[Alarm]:
 180         alarms = []
 181         alarm_dicts = self.common_db.get_list("alarms")
 182         for alarm_dict in alarm_dicts:
 183             alarms.append(Alarm.from_dict(alarm_dict))
 184         return alarms
 185
 186     def update_alarm_status(self, alarm_state: str, uuid):
 187         modified_count = self.common_db.set_one(
 188             "alarms", {"uuid": uuid}, {"alarm_status": alarm_state}
 189         )
 190         return modified_count
 191
 192     def update_alarm_extra_labels(self, alarm_labels: dict, uuid):
 193         modified_count = self.common_db.set_one(
 194             "alarms", {"uuid": uuid}, {"extra_labels": alarm_labels}
 195         )
 196         return modified_count
 197
 198     def get_alarm_by_uuid(self, uuid: str):
 199         return self.common_db.get_one("alarms", {"uuid": uuid})
 200
 201     def get_user(self, username: str):
 202         return self.common_db.get_one("users", {"username": username})
 203
 204     def get_user_by_id(self, userid: str):
 205         return self.common_db.get_one("users", {"_id": userid})
 206
 207     def get_role_by_name(self, name: str):
 208         return self.common_db.get_one("roles", {"name": name})
 209
 210     def get_role_by_id(self, role_id: str):
 211         return self.common_db.get_one("roles", {"_id": role_id})