# -*- coding: utf-8 -*-
+# 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
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
import logging
from osm_common import dbmongo, dbmemory, fslocal, msglocal, msgkafka, version as common_version
from osm_common.dbbase import DbException
from osm_common.msgbase import MsgException
from http import HTTPStatus
from base_topic import EngineException, versiontuple
-from admin_topics import UserTopic, ProjectTopic, VimAccountTopic, SdnTopic
-from descriptor_topics import VnfdTopic, NsdTopic, PduTopic
-from instance_topics import NsrTopic, VnfrTopic, NsLcmOpTopic
+from admin_topics import UserTopic, ProjectTopic, VimAccountTopic, WimAccountTopic, SdnTopic
+from descriptor_topics import VnfdTopic, NsdTopic, PduTopic, NstTopic
+from instance_topics import NsrTopic, VnfrTopic, NsLcmOpTopic, NsiTopic, NsiLcmOpTopic
+from base64 import b64encode
+from os import urandom
+from threading import Lock
__author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
-min_common_version = "0.1.8"
+min_common_version = "0.1.16"
class Engine(object):
map_from_topic_to_class = {
"vnfds": VnfdTopic,
"nsds": NsdTopic,
+ "nsts": NstTopic,
"pdus": PduTopic,
"nsrs": NsrTopic,
"vnfrs": VnfrTopic,
"nslcmops": NsLcmOpTopic,
"vim_accounts": VimAccountTopic,
+ "wim_accounts": WimAccountTopic,
"sdns": SdnTopic,
"users": UserTopic,
"projects": ProjectTopic,
+ "nsis": NsiTopic,
+ "nsilcmops": NsiLcmOpTopic
# [NEW_TOPIC]: add an entry here
}
self.config = None
self.logger = logging.getLogger("nbi.engine")
self.map_topic = {}
+ self.write_lock = None
def start(self, config):
"""
self.msg.connect(config["message"])
else:
raise EngineException("Invalid configuration param '{}' at '[message]':'driver'".format(
- config["storage"]["driver"]))
+ config["message"]["driver"]))
+ self.write_lock = Lock()
# create one class per topic
for topic, topic_class in self.map_from_topic_to_class.items():
self.map_topic[topic] = topic_class(self.db, self.fs, self.msg)
self.db.db_disconnect()
if self.fs:
self.fs.fs_disconnect()
- if self.fs:
- self.fs.fs_disconnect()
+ if self.msg:
+ self.msg.disconnect()
+ self.write_lock = None
except (DbException, FsException, MsgException) as e:
raise EngineException(str(e), http_code=e.http_code)
"""
if topic not in self.map_topic:
raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
- return self.map_topic[topic].new(rollback, session, indata, kwargs, headers, force)
+ with self.write_lock:
+ return self.map_topic[topic].new(rollback, session, indata, kwargs, headers, force)
def upload_content(self, session, topic, _id, indata, kwargs, headers, force=False):
"""
"""
if topic not in self.map_topic:
raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
- return self.map_topic[topic].upload_content(session, _id, indata, kwargs, headers, force)
+ with self.write_lock:
+ return self.map_topic[topic].upload_content(session, _id, indata, kwargs, headers, force)
def get_item_list(self, session, topic, filter_q=None):
"""
"""
if topic not in self.map_topic:
raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
- return self.map_topic[topic].delete_list(session, _filter)
+ with self.write_lock:
+ return self.map_topic[topic].delete_list(session, _filter)
def del_item(self, session, topic, _id, force=False):
"""
"""
if topic not in self.map_topic:
raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
- return self.map_topic[topic].delete(session, _id, force)
+ with self.write_lock:
+ return self.map_topic[topic].delete(session, _id, force)
def edit_item(self, session, topic, _id, indata=None, kwargs=None, force=False):
"""
"""
if topic not in self.map_topic:
raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
- return self.map_topic[topic].edit(session, _id, indata, kwargs, force)
-
- def prune(self):
- """
- Prune database not needed content
- :return: None
- """
- return self.db.del_list("nsrs", {"_admin.to_delete": True})
+ with self.write_lock:
+ return self.map_topic[topic].edit(session, _id, indata, kwargs, force)
def create_admin(self):
"""
_id = self.map_topic["users"].new(roolback_list, fake_session, user_desc, force=True)
return _id
+ def upgrade_db(self, current_version, target_version):
+ if not target_version or current_version == target_version:
+ return
+ if target_version == '1.0':
+ if not current_version:
+ # create database version
+ serial = urandom(32)
+ version_data = {
+ "_id": 'version', # Always 'version'
+ "version_int": 1000, # version number
+ "version": '1.0', # version text
+ "date": "2018-10-25", # version date
+ "description": "added serial", # changes in this version
+ 'status': 'ENABLED', # ENABLED, DISABLED (migration in process), ERROR,
+ 'serial': b64encode(serial)
+ }
+ self.db.create("admin", version_data)
+ self.db.set_secret_key(serial)
+ return
+ # TODO add future migrations here
+
+ raise EngineException("Wrong database version '{}'. Expected '{}'"
+ ". It cannot be up/down-grade".format(current_version, target_version),
+ http_code=HTTPStatus.INTERNAL_SERVER_ERROR)
+
def init_db(self, target_version='1.0'):
"""
- Init database if empty. If not empty it checks that database version is ok.
+ Init database if empty. If not empty it checks that database version and migrates if needed
If empty, it creates a new user admin/admin at 'users' and a new entry at 'version'
+ :param target_version: check desired database version. Migrate to it if possible or raises exception
:return: None if ok, exception if error or if the version is different.
"""
- version = self.db.get_one("version", fail_on_empty=False, fail_on_more=False)
- if not version:
- # create user admin
- self.create_admin()
- # create database version
- version_data = {
- "_id": '1.0', # version text
- "version": 1000, # version number
- "date": "2018-04-12", # version date
- "description": "initial design", # changes in this version
- 'status': 'ENABLED' # ENABLED, DISABLED (migration in process), ERROR,
- }
- self.db.create("version", version_data)
- elif version["_id"] != target_version:
- # TODO implement migration process
- raise EngineException("Wrong database version '{}'. Expected '{}'".format(
- version["_id"], target_version), HTTPStatus.INTERNAL_SERVER_ERROR)
- elif version["status"] != 'ENABLED':
+
+ version_data = self.db.get_one("admin", {"_id": "version"}, fail_on_empty=False, fail_on_more=True)
+ # check database status is ok
+ if version_data and version_data.get("status") != 'ENABLED':
raise EngineException("Wrong database status '{}'".format(
- version["status"]), HTTPStatus.INTERNAL_SERVER_ERROR)
+ version_data["status"]), HTTPStatus.INTERNAL_SERVER_ERROR)
+
+ # check version
+ db_version = None if not version_data else version_data.get("version")
+ if db_version != target_version:
+ self.upgrade_db(db_version, target_version)
+
+ # create user admin if not exist
+ self.create_admin()
return
projects / osm / NBI.git / blobdiff