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
  21 # For those usages not covered by the Apache License, Version 2.0 please
  22 # contact: bdiaz@whitestack.com or glavado@whitestack.com
  23 ##
  24 from typing import List
  25
  26 from osm_common import dbmongo, dbmemory
  27
  28 from osm_mon.core.config import Config
  29 from osm_mon.core.models import Alarm
  30
  31
  32 class CommonDbClient:
  33     def __init__(self, config: Config):
  34         if config.get("database", "driver") == "mongo":
  35             self.common_db = dbmongo.DbMongo()
  36         elif config.get("database", "driver") == "memory":
  37             self.common_db = dbmemory.DbMemory()
  38         else:
  39             raise Exception(
  40                 "Unknown database driver {}".format(config.get("section", "driver"))
  41             )
  42         self.common_db.db_connect(config.get("database"))
  43
  44     def get_vnfr(self, nsr_id: str, member_index: int):
  45         vnfr = self.common_db.get_one(
  46             "vnfrs", {"nsr-id-ref": nsr_id, "member-vnf-index-ref": str(member_index)}
  47         )
  48         return vnfr
  49
  50     def get_vnfrs(self, nsr_id: str = None, vim_account_id: str = None):
  51         if nsr_id and vim_account_id:
  52             raise NotImplementedError("Only one filter is currently supported")
  53         if nsr_id:
  54             vnfrs = [
  55                 self.get_vnfr(nsr_id, member["member-vnf-index"])
  56                 for member in self.get_nsr(nsr_id)["nsd"]["constituent-vnfd"]
  57             ]
  58         elif vim_account_id:
  59             vnfrs = self.common_db.get_list("vnfrs", {"vim-account-id": vim_account_id})
  60         else:
  61             vnfrs = self.common_db.get_list("vnfrs")
  62         return vnfrs
  63
  64     def get_vnfd(self, vnfd_id: str):
  65         vnfd = self.common_db.get_one("vnfds", {"_id": vnfd_id})
  66         return vnfd
  67
  68     def get_vnfd_by_id(self, vnfd_id: str, filter: dict = {}):
  69         filter["id"] = vnfd_id
  70         vnfd = self.common_db.get_one("vnfds", filter)
  71         return vnfd
  72
  73     def get_vnfd_by_name(self, vnfd_name: str):
  74         # TODO: optimize way of getting single VNFD in shared enviroments (RBAC)
  75         if self.common_db.get_list("vnfds", {"name": vnfd_name}):
  76             vnfd = self.common_db.get_list("vnfds", {"name": vnfd_name})[0]
  77             return vnfd
  78         else:
  79             return None
  80
  81     def get_nsrs(self):
  82         return self.common_db.get_list("nsrs")
  83
  84     def get_nsr(self, nsr_id: str):
  85         nsr = self.common_db.get_one("nsrs", {"id": nsr_id})
  86         return nsr
  87
  88     def get_nslcmop(self, nslcmop_id):
  89         nslcmop = self.common_db.get_one("nslcmops", {"_id": nslcmop_id})
  90         return nslcmop
  91
  92     def get_vdur(self, nsr_id, member_index, vdur_name):
  93         vnfr = self.get_vnfr(nsr_id, member_index)
  94         for vdur in vnfr["vdur"]:
  95             if vdur["name"] == vdur_name:
  96                 return vdur
  97         raise ValueError(
  98             "vdur not found for nsr-id {}, member_index {} and vdur_name {}".format(
  99                 nsr_id, member_index, vdur_name
 100             )
 101         )
 102
 103     def decrypt_vim_password(self, vim_password: str, schema_version: str, vim_id: str):
 104         return self.common_db.decrypt(vim_password, schema_version, vim_id)
 105
 106     def decrypt_sdnc_password(
 107         self, sdnc_password: str, schema_version: str, sdnc_id: str
 108     ):
 109         return self.common_db.decrypt(sdnc_password, schema_version, sdnc_id)
 110
 111     def get_vim_account_id(self, nsr_id: str, vnf_member_index: int) -> str:
 112         vnfr = self.get_vnfr(nsr_id, vnf_member_index)
 113         return vnfr["vim-account-id"]
 114
 115     def get_vim_accounts(self):
 116         return self.common_db.get_list("vim_accounts")
 117
 118     def get_vim_account(self, vim_account_id: str) -> dict:
 119         vim_account = self.common_db.get_one("vim_accounts", {"_id": vim_account_id})
 120         vim_account["vim_password"] = self.decrypt_vim_password(
 121             vim_account["vim_password"], vim_account["schema_version"], vim_account_id
 122         )
 123         vim_config_encrypted_dict = {
 124             "1.1": ("admin_password", "nsx_password", "vcenter_password"),
 125             "default": (
 126                 "admin_password",
 127                 "nsx_password",
 128                 "vcenter_password",
 129                 "vrops_password",
 130             ),
 131         }
 132         vim_config_encrypted = vim_config_encrypted_dict["default"]
 133         if vim_account["schema_version"] in vim_config_encrypted_dict.keys():
 134             vim_config_encrypted = vim_config_encrypted_dict[
 135                 vim_account["schema_version"]
 136             ]
 137         if "config" in vim_account:
 138             for key in vim_account["config"]:
 139                 if key in vim_config_encrypted:
 140                     vim_account["config"][key] = self.decrypt_vim_password(
 141                         vim_account["config"][key],
 142                         vim_account["schema_version"],
 143                         vim_account_id,
 144                     )
 145         return vim_account
 146
 147     def set_vim_account(self, vim_account_id: str, update_dict: dict) -> bool:
 148         try:
 149             # Set vim_account resources in mongo
 150             self.common_db.set_one('vim_accounts', {"_id": vim_account_id}, update_dict)
 151             # self.common_db.set_one('vim_accounts', {"name": "test-vim"}, update_dict)
 152             return True
 153         except Exception:
 154             return False
 155
 156     def get_sdncs(self):
 157         return self.common_db.get_list("sdns")
 158
 159     def get_sdnc(self, sdnc_id: str):
 160         return self.common_db.get_one("sdns", {"_id": sdnc_id})
 161
 162     def get_projects(self):
 163         return self.common_db.get_list("projects")
 164
 165     def get_project(self, project_id: str):
 166         return self.common_db.get_one("projects", {"_id": project_id})
 167
 168     def create_alarm(self, alarm: Alarm):
 169         action_data = {"uuid": alarm.uuid, "action": alarm.action}
 170         self.common_db.create("alarms_action", action_data)
 171         return self.common_db.create("alarms", alarm.to_dict())
 172
 173     def delete_alarm(self, alarm_uuid: str):
 174         self.common_db.del_one("alarms_action", {"uuid": alarm_uuid})
 175         return self.common_db.del_one("alarms", {"uuid": alarm_uuid})
 176
 177     def get_alarms(self) -> List[Alarm]:
 178         alarms = []
 179         alarm_dicts = self.common_db.get_list("alarms")
 180         for alarm_dict in alarm_dicts:
 181             alarms.append(Alarm.from_dict(alarm_dict))
 182         return alarms
 183
 184     def update_alarm_status(self, alarm_state: str, uuid):
 185         modified_count = self.common_db.set_one("alarms", {"uuid": uuid}, {"alarm_status": alarm_state})
 186         return modified_count
 187
 188     def get_alarm_by_uuid(self, uuid: str):
 189         return self.common_db.get_one("alarms", {"uuid": uuid})
 190
 191     def get_user(self, username: str):
 192         return self.common_db.get_one("users", {"username": username})
 193
 194     def get_user_by_id(self, userid: str):
 195         return self.common_db.get_one("users", {"_id": userid})
 196
 197     def get_role_by_name(self, name: str):
 198         return self.common_db.get_one("roles", {"name": name})
 199
 200     def get_role_by_id(self, role_id: str):
 201         return self.common_db.get_one("roles", {"_id": role_id})