NG-RO/osm_ng_ro/ns.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2020 Telefonica Investigacion y Desarrollo, S.A.U.
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #    http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  14 # implied.
  15 # See the License for the specific language governing permissions and
  16 # limitations under the License.
  17 ##
  18
  19 # import yaml
  20 import logging
  21 from typing import Any, Dict, Tuple
  22 from traceback import format_exc as traceback_format_exc
  23 from osm_ng_ro.ns_thread import NsWorker, NsWorkerException, deep_get
  24 from osm_ng_ro.validation import validate_input, deploy_schema
  25 from osm_common import (
  26     dbmongo,
  27     dbmemory,
  28     fslocal,
  29     fsmongo,
  30     msglocal,
  31     msgkafka,
  32     version as common_version,
  33 )
  34 from osm_common.dbbase import DbException
  35 from osm_common.fsbase import FsException
  36 from osm_common.msgbase import MsgException
  37 from http import HTTPStatus
  38 from uuid import uuid4
  39 from threading import Lock
  40 from random import choice as random_choice
  41 from time import time
  42 from jinja2 import (
  43     Environment,
  44     TemplateError,
  45     TemplateNotFound,
  46     StrictUndefined,
  47     UndefinedError,
  48 )
  49 from cryptography.hazmat.primitives import serialization as crypto_serialization
  50 from cryptography.hazmat.primitives.asymmetric import rsa
  51 from cryptography.hazmat.backends import default_backend as crypto_default_backend
  52
  53 __author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
  54 min_common_version = "0.1.16"
  55
  56
  57 class NsException(Exception):
  58     def __init__(self, message, http_code=HTTPStatus.BAD_REQUEST):
  59         self.http_code = http_code
  60         super(Exception, self).__init__(message)
  61
  62
  63 def get_process_id():
  64     """
  65     Obtain a unique ID for this process. If running from inside docker, it will get docker ID. If not it
  66     will provide a random one
  67     :return: Obtained ID
  68     """
  69     # Try getting docker id. If fails, get pid
  70     try:
  71         with open("/proc/self/cgroup", "r") as f:
  72             text_id_ = f.readline()
  73             _, _, text_id = text_id_.rpartition("/")
  74             text_id = text_id.replace("\n", "")[:12]
  75
  76             if text_id:
  77                 return text_id
  78     except Exception:
  79         pass
  80
  81     # Return a random id
  82     return "".join(random_choice("0123456789abcdef") for _ in range(12))
  83
  84
  85 def versiontuple(v):
  86     """utility for compare dot separate versions. Fills with zeros to proper number comparison"""
  87     filled = []
  88
  89     for point in v.split("."):
  90         filled.append(point.zfill(8))
  91
  92     return tuple(filled)
  93
  94
  95 class Ns(object):
  96     def __init__(self):
  97         self.db = None
  98         self.fs = None
  99         self.msg = None
 100         self.config = None
 101         # self.operations = None
 102         self.logger = None
 103         # ^ Getting logger inside method self.start because parent logger (ro) is not available yet.
 104         # If done now it will not be linked to parent not getting its handler and level
 105         self.map_topic = {}
 106         self.write_lock = None
 107         self.vims_assigned = {}
 108         self.next_worker = 0
 109         self.plugins = {}
 110         self.workers = []
 111
 112     def init_db(self, target_version):
 113         pass
 114
 115     def start(self, config):
 116         """
 117         Connect to database, filesystem storage, and messaging
 118         :param config: two level dictionary with configuration. Top level should contain 'database', 'storage',
 119         :param config: Configuration of db, storage, etc
 120         :return: None
 121         """
 122         self.config = config
 123         self.config["process_id"] = get_process_id()  # used for HA identity
 124         self.logger = logging.getLogger("ro.ns")
 125
 126         # check right version of common
 127         if versiontuple(common_version) < versiontuple(min_common_version):
 128             raise NsException(
 129                 "Not compatible osm/common version '{}'. Needed '{}' or higher".format(
 130                     common_version, min_common_version
 131                 )
 132             )
 133
 134         try:
 135             if not self.db:
 136                 if config["database"]["driver"] == "mongo":
 137                     self.db = dbmongo.DbMongo()
 138                     self.db.db_connect(config["database"])
 139                 elif config["database"]["driver"] == "memory":
 140                     self.db = dbmemory.DbMemory()
 141                     self.db.db_connect(config["database"])
 142                 else:
 143                     raise NsException(
 144                         "Invalid configuration param '{}' at '[database]':'driver'".format(
 145                             config["database"]["driver"]
 146                         )
 147                     )
 148
 149             if not self.fs:
 150                 if config["storage"]["driver"] == "local":
 151                     self.fs = fslocal.FsLocal()
 152                     self.fs.fs_connect(config["storage"])
 153                 elif config["storage"]["driver"] == "mongo":
 154                     self.fs = fsmongo.FsMongo()
 155                     self.fs.fs_connect(config["storage"])
 156                 elif config["storage"]["driver"] is None:
 157                     pass
 158                 else:
 159                     raise NsException(
 160                         "Invalid configuration param '{}' at '[storage]':'driver'".format(
 161                             config["storage"]["driver"]
 162                         )
 163                     )
 164
 165             if not self.msg:
 166                 if config["message"]["driver"] == "local":
 167                     self.msg = msglocal.MsgLocal()
 168                     self.msg.connect(config["message"])
 169                 elif config["message"]["driver"] == "kafka":
 170                     self.msg = msgkafka.MsgKafka()
 171                     self.msg.connect(config["message"])
 172                 else:
 173                     raise NsException(
 174                         "Invalid configuration param '{}' at '[message]':'driver'".format(
 175                             config["message"]["driver"]
 176                         )
 177                     )
 178
 179             # TODO load workers to deal with exising database tasks
 180
 181             self.write_lock = Lock()
 182         except (DbException, FsException, MsgException) as e:
 183             raise NsException(str(e), http_code=e.http_code)
 184
 185     def get_assigned_vims(self):
 186         return list(self.vims_assigned.keys())
 187
 188     def stop(self):
 189         try:
 190             if self.db:
 191                 self.db.db_disconnect()
 192
 193             if self.fs:
 194                 self.fs.fs_disconnect()
 195
 196             if self.msg:
 197                 self.msg.disconnect()
 198
 199             self.write_lock = None
 200         except (DbException, FsException, MsgException) as e:
 201             raise NsException(str(e), http_code=e.http_code)
 202
 203         for worker in self.workers:
 204             worker.insert_task(("terminate",))
 205
 206     def _create_worker(self):
 207         """
 208         Look for a worker thread in idle status. If not found it creates one unless the number of threads reach the
 209         limit of 'server.ns_threads' configuration. If reached, it just assigns one existing thread
 210         return the index of the assigned worker thread. Worker threads are storead at self.workers
 211         """
 212         # Look for a thread in idle status
 213         worker_id = next(
 214             (
 215                 i
 216                 for i in range(len(self.workers))
 217                 if self.workers[i] and self.workers[i].idle
 218             ),
 219             None,
 220         )
 221
 222         if worker_id is not None:
 223             # unset idle status to avoid race conditions
 224             self.workers[worker_id].idle = False
 225         else:
 226             worker_id = len(self.workers)
 227
 228             if worker_id < self.config["global"]["server.ns_threads"]:
 229                 # create a new worker
 230                 self.workers.append(
 231                     NsWorker(worker_id, self.config, self.plugins, self.db)
 232                 )
 233                 self.workers[worker_id].start()
 234             else:
 235                 # reached maximum number of threads, assign VIM to an existing one
 236                 worker_id = self.next_worker
 237                 self.next_worker = (self.next_worker + 1) % self.config["global"][
 238                     "server.ns_threads"
 239                 ]
 240
 241         return worker_id
 242
 243     def assign_vim(self, target_id):
 244         with self.write_lock:
 245             return self._assign_vim(target_id)
 246
 247     def _assign_vim(self, target_id):
 248         if target_id not in self.vims_assigned:
 249             worker_id = self.vims_assigned[target_id] = self._create_worker()
 250             self.workers[worker_id].insert_task(("load_vim", target_id))
 251
 252     def reload_vim(self, target_id):
 253         # send reload_vim to the thread working with this VIM and inform all that a VIM has been changed,
 254         # this is because database VIM information is cached for threads working with SDN
 255         with self.write_lock:
 256             for worker in self.workers:
 257                 if worker and not worker.idle:
 258                     worker.insert_task(("reload_vim", target_id))
 259
 260     def unload_vim(self, target_id):
 261         with self.write_lock:
 262             return self._unload_vim(target_id)
 263
 264     def _unload_vim(self, target_id):
 265         if target_id in self.vims_assigned:
 266             worker_id = self.vims_assigned[target_id]
 267             self.workers[worker_id].insert_task(("unload_vim", target_id))
 268             del self.vims_assigned[target_id]
 269
 270     def check_vim(self, target_id):
 271         with self.write_lock:
 272             if target_id in self.vims_assigned:
 273                 worker_id = self.vims_assigned[target_id]
 274             else:
 275                 worker_id = self._create_worker()
 276
 277         worker = self.workers[worker_id]
 278         worker.insert_task(("check_vim", target_id))
 279
 280     def unload_unused_vims(self):
 281         with self.write_lock:
 282             vims_to_unload = []
 283
 284             for target_id in self.vims_assigned:
 285                 if not self.db.get_one(
 286                     "ro_tasks",
 287                     q_filter={
 288                         "target_id": target_id,
 289                         "tasks.status": ["SCHEDULED", "BUILD", "DONE", "FAILED"],
 290                     },
 291                     fail_on_empty=False,
 292                 ):
 293                     vims_to_unload.append(target_id)
 294
 295             for target_id in vims_to_unload:
 296                 self._unload_vim(target_id)
 297
 298     def _get_cloud_init(self, where):
 299         """
 300         Not used as cloud init content is provided in the http body. This method reads cloud init from a file
 301         :param where: can be 'vnfr_id:file:file_name' or 'vnfr_id:vdu:vdu_idex'
 302         :return:
 303         """
 304         vnfd_id, _, other = where.partition(":")
 305         _type, _, name = other.partition(":")
 306         vnfd = self.db.get_one("vnfds", {"_id": vnfd_id})
 307
 308         if _type == "file":
 309             base_folder = vnfd["_admin"]["storage"]
 310             cloud_init_file = "{}/{}/cloud_init/{}".format(
 311                 base_folder["folder"], base_folder["pkg-dir"], name
 312             )
 313
 314             if not self.fs:
 315                 raise NsException(
 316                     "Cannot read file '{}'. Filesystem not loaded, change configuration at storage.driver".format(
 317                         cloud_init_file
 318                     )
 319                 )
 320
 321             with self.fs.file_open(cloud_init_file, "r") as ci_file:
 322                 cloud_init_content = ci_file.read()
 323         elif _type == "vdu":
 324             cloud_init_content = vnfd["vdu"][int(name)]["cloud-init"]
 325         else:
 326             raise NsException("Mismatch descriptor for cloud init: {}".format(where))
 327
 328         return cloud_init_content
 329
 330     def _parse_jinja2(self, cloud_init_content, params, context):
 331         try:
 332             env = Environment(undefined=StrictUndefined)
 333             template = env.from_string(cloud_init_content)
 334
 335             return template.render(params or {})
 336         except UndefinedError as e:
 337             raise NsException(
 338                 "Variable '{}' defined at vnfd='{}' must be provided in the instantiation parameters"
 339                 "inside the 'additionalParamsForVnf' block".format(e, context)
 340             )
 341         except (TemplateError, TemplateNotFound) as e:
 342             raise NsException(
 343                 "Error parsing Jinja2 to cloud-init content at vnfd='{}': {}".format(
 344                     context, e
 345                 )
 346             )
 347
 348     def _create_db_ro_nsrs(self, nsr_id, now):
 349         try:
 350             key = rsa.generate_private_key(
 351                 backend=crypto_default_backend(), public_exponent=65537, key_size=2048
 352             )
 353             private_key = key.private_bytes(
 354                 crypto_serialization.Encoding.PEM,
 355                 crypto_serialization.PrivateFormat.PKCS8,
 356                 crypto_serialization.NoEncryption(),
 357             )
 358             public_key = key.public_key().public_bytes(
 359                 crypto_serialization.Encoding.OpenSSH,
 360                 crypto_serialization.PublicFormat.OpenSSH,
 361             )
 362             private_key = private_key.decode("utf8")
 363             # Change first line because Paramiko needs a explicit start with 'BEGIN RSA PRIVATE KEY'
 364             i = private_key.find("\n")
 365             private_key = "-----BEGIN RSA PRIVATE KEY-----" + private_key[i:]
 366             public_key = public_key.decode("utf8")
 367         except Exception as e:
 368             raise NsException("Cannot create ssh-keys: {}".format(e))
 369
 370         schema_version = "1.1"
 371         private_key_encrypted = self.db.encrypt(
 372             private_key, schema_version=schema_version, salt=nsr_id
 373         )
 374         db_content = {
 375             "_id": nsr_id,
 376             "_admin": {
 377                 "created": now,
 378                 "modified": now,
 379                 "schema_version": schema_version,
 380             },
 381             "public_key": public_key,
 382             "private_key": private_key_encrypted,
 383             "actions": [],
 384         }
 385         self.db.create("ro_nsrs", db_content)
 386
 387         return db_content
 388
 389     @staticmethod
 390     def _create_task(
 391         deployment_info: Dict[str, Any],
 392         target_id: str,
 393         item: str,
 394         action: str,
 395         target_record: str,
 396         target_record_id: str,
 397         extra_dict: Dict[str, Any] = None,
 398     ) -> Dict[str, Any]:
 399         """Function to create task dict from deployment information.
 400
 401         Args:
 402             deployment_info (Dict[str, Any]): [description]
 403             target_id (str): [description]
 404             item (str): [description]
 405             action (str): [description]
 406             target_record (str): [description]
 407             target_record_id (str): [description]
 408             extra_dict (Dict[str, Any], optional): [description]. Defaults to None.
 409
 410         Returns:
 411             Dict[str, Any]: [description]
 412         """
 413         task = {
 414             "target_id": target_id,  # it will be removed before pushing at database
 415             "action_id": deployment_info.get("action_id"),
 416             "nsr_id": deployment_info.get("nsr_id"),
 417             "task_id": f"{deployment_info.get('action_id')}:{deployment_info.get('task_index')}",
 418             "status": "SCHEDULED",
 419             "action": action,
 420             "item": item,
 421             "target_record": target_record,
 422             "target_record_id": target_record_id,
 423         }
 424
 425         if extra_dict:
 426             task.update(extra_dict)  # params, find_params, depends_on
 427
 428         deployment_info["task_index"] = deployment_info.get("task_index", 0) + 1
 429
 430         return task
 431
 432     @staticmethod
 433     def _create_ro_task(
 434         target_id: str,
 435         task: Dict[str, Any],
 436     ) -> Dict[str, Any]:
 437         """Function to create an RO task from task information.
 438
 439         Args:
 440             target_id (str): [description]
 441             task (Dict[str, Any]): [description]
 442
 443         Returns:
 444             Dict[str, Any]: [description]
 445         """
 446         now = time()
 447
 448         _id = task.get("task_id")
 449         db_ro_task = {
 450             "_id": _id,
 451             "locked_by": None,
 452             "locked_at": 0.0,
 453             "target_id": target_id,
 454             "vim_info": {
 455                 "created": False,
 456                 "created_items": None,
 457                 "vim_id": None,
 458                 "vim_name": None,
 459                 "vim_status": None,
 460                 "vim_details": None,
 461                 "refresh_at": None,
 462             },
 463             "modified_at": now,
 464             "created_at": now,
 465             "to_check_at": now,
 466             "tasks": [task],
 467         }
 468
 469         return db_ro_task
 470
 471     @staticmethod
 472     def _process_image_params(
 473         target_image: Dict[str, Any],
 474         indata: Dict[str, Any],
 475         vim_info: Dict[str, Any],
 476         target_record_id: str,
 477     ) -> Dict[str, Any]:
 478         """Function to process VDU image parameters.
 479
 480         Args:
 481             target_image (Dict[str, Any]): [description]
 482             indata (Dict[str, Any]): [description]
 483             vim_info (Dict[str, Any]): [description]
 484             target_record_id (str): [description]
 485
 486         Returns:
 487             Dict[str, Any]: [description]
 488         """
 489         find_params = {}
 490
 491         if target_image.get("image"):
 492             find_params["filter_dict"] = {"name": target_image.get("image")}
 493
 494         if target_image.get("vim_image_id"):
 495             find_params["filter_dict"] = {"id": target_image.get("vim_image_id")}
 496
 497         if target_image.get("image_checksum"):
 498             find_params["filter_dict"] = {
 499                 "checksum": target_image.get("image_checksum")
 500             }
 501
 502         return {"find_params": find_params}
 503
 504     @staticmethod
 505     def _get_resource_allocation_params(
 506         quota_descriptor: Dict[str, Any],
 507     ) -> Dict[str, Any]:
 508         """Read the quota_descriptor from vnfd and fetch the resource allocation properties from the
 509         descriptor object.
 510
 511         Args:
 512             quota_descriptor (Dict[str, Any]): cpu/mem/vif/disk-io quota descriptor
 513
 514         Returns:
 515             Dict[str, Any]: quota params for limit, reserve, shares from the descriptor object
 516         """
 517         quota = {}
 518
 519         if quota_descriptor.get("limit"):
 520             quota["limit"] = int(quota_descriptor["limit"])
 521
 522         if quota_descriptor.get("reserve"):
 523             quota["reserve"] = int(quota_descriptor["reserve"])
 524
 525         if quota_descriptor.get("shares"):
 526             quota["shares"] = int(quota_descriptor["shares"])
 527
 528         return quota
 529
 530     @staticmethod
 531     def _process_guest_epa_quota_params(
 532         guest_epa_quota: Dict[str, Any],
 533         epa_vcpu_set: bool,
 534     ) -> Dict[str, Any]:
 535         """Function to extract the guest epa quota parameters.
 536
 537         Args:
 538             guest_epa_quota (Dict[str, Any]): [description]
 539             epa_vcpu_set (bool): [description]
 540
 541         Returns:
 542             Dict[str, Any]: [description]
 543         """
 544         result = {}
 545
 546         if guest_epa_quota.get("cpu-quota") and not epa_vcpu_set:
 547             cpuquota = Ns._get_resource_allocation_params(
 548                 guest_epa_quota.get("cpu-quota")
 549             )
 550
 551             if cpuquota:
 552                 result["cpu-quota"] = cpuquota
 553
 554         if guest_epa_quota.get("mem-quota"):
 555             vduquota = Ns._get_resource_allocation_params(
 556                 guest_epa_quota.get("mem-quota")
 557             )
 558
 559             if vduquota:
 560                 result["mem-quota"] = vduquota
 561
 562         if guest_epa_quota.get("disk-io-quota"):
 563             diskioquota = Ns._get_resource_allocation_params(
 564                 guest_epa_quota.get("disk-io-quota")
 565             )
 566
 567             if diskioquota:
 568                 result["disk-io-quota"] = diskioquota
 569
 570         if guest_epa_quota.get("vif-quota"):
 571             vifquota = Ns._get_resource_allocation_params(
 572                 guest_epa_quota.get("vif-quota")
 573             )
 574
 575             if vifquota:
 576                 result["vif-quota"] = vifquota
 577
 578         return result
 579
 580     @staticmethod
 581     def _process_guest_epa_numa_params(
 582         guest_epa_quota: Dict[str, Any],
 583     ) -> Tuple[Dict[str, Any], bool]:
 584         """[summary]
 585
 586         Args:
 587             guest_epa_quota (Dict[str, Any]): [description]
 588
 589         Returns:
 590             Tuple[Dict[str, Any], bool]: [description]
 591         """
 592         numa = {}
 593         epa_vcpu_set = False
 594
 595         if guest_epa_quota.get("numa-node-policy"):
 596             numa_node_policy = guest_epa_quota.get("numa-node-policy")
 597
 598             if numa_node_policy.get("node"):
 599                 numa_node = numa_node_policy["node"][0]
 600
 601                 if numa_node.get("num-cores"):
 602                     numa["cores"] = numa_node["num-cores"]
 603                     epa_vcpu_set = True
 604
 605                 paired_threads = numa_node.get("paired-threads", {})
 606                 if paired_threads.get("num-paired-threads"):
 607                     numa["paired-threads"] = int(
 608                         numa_node["paired-threads"]["num-paired-threads"]
 609                     )
 610                     epa_vcpu_set = True
 611
 612                 if paired_threads.get("paired-thread-ids"):
 613                     numa["paired-threads-id"] = []
 614
 615                     for pair in paired_threads["paired-thread-ids"]:
 616                         numa["paired-threads-id"].append(
 617                             (
 618                                 str(pair["thread-a"]),
 619                                 str(pair["thread-b"]),
 620                             )
 621                         )
 622
 623                 if numa_node.get("num-threads"):
 624                     numa["threads"] = int(numa_node["num-threads"])
 625                     epa_vcpu_set = True
 626
 627                 if numa_node.get("memory-mb"):
 628                     numa["memory"] = max(int(int(numa_node["memory-mb"]) / 1024), 1)
 629
 630         return numa, epa_vcpu_set
 631
 632     @staticmethod
 633     def _process_guest_epa_cpu_pinning_params(
 634         guest_epa_quota: Dict[str, Any],
 635         vcpu_count: int,
 636         epa_vcpu_set: bool,
 637     ) -> Tuple[Dict[str, Any], bool]:
 638         """[summary]
 639
 640         Args:
 641             guest_epa_quota (Dict[str, Any]): [description]
 642             vcpu_count (int): [description]
 643             epa_vcpu_set (bool): [description]
 644
 645         Returns:
 646             Tuple[Dict[str, Any], bool]: [description]
 647         """
 648         numa = {}
 649         local_epa_vcpu_set = epa_vcpu_set
 650
 651         if (
 652             guest_epa_quota.get("cpu-pinning-policy") == "DEDICATED"
 653             and not epa_vcpu_set
 654         ):
 655             numa[
 656                 "cores"
 657                 if guest_epa_quota.get("cpu-thread-pinning-policy") != "PREFER"
 658                 else "threads"
 659             ] = max(vcpu_count, 1)
 660             local_epa_vcpu_set = True
 661
 662         return numa, local_epa_vcpu_set
 663
 664     @staticmethod
 665     def _process_epa_params(
 666         target_flavor: Dict[str, Any],
 667     ) -> Dict[str, Any]:
 668         """[summary]
 669
 670         Args:
 671             target_flavor (Dict[str, Any]): [description]
 672
 673         Returns:
 674             Dict[str, Any]: [description]
 675         """
 676         extended = {}
 677         numa = {}
 678
 679         if target_flavor.get("guest-epa"):
 680             guest_epa = target_flavor["guest-epa"]
 681
 682             numa, epa_vcpu_set = Ns._process_guest_epa_numa_params(
 683                 guest_epa_quota=guest_epa
 684             )
 685
 686             if guest_epa.get("mempage-size"):
 687                 extended["mempage-size"] = guest_epa.get("mempage-size")
 688
 689             tmp_numa, epa_vcpu_set = Ns._process_guest_epa_cpu_pinning_params(
 690                 guest_epa_quota=guest_epa,
 691                 vcpu_count=int(target_flavor.get("vcpu-count", 1)),
 692                 epa_vcpu_set=epa_vcpu_set,
 693             )
 694             numa.update(tmp_numa)
 695
 696             extended.update(
 697                 Ns._process_guest_epa_quota_params(
 698                     guest_epa_quota=guest_epa,
 699                     epa_vcpu_set=epa_vcpu_set,
 700                 )
 701             )
 702
 703         if numa:
 704             extended["numas"] = [numa]
 705
 706         return extended
 707
 708     @staticmethod
 709     def _process_flavor_params(
 710         target_flavor: Dict[str, Any],
 711         indata: Dict[str, Any],
 712         vim_info: Dict[str, Any],
 713         target_record_id: str,
 714     ) -> Dict[str, Any]:
 715         """[summary]
 716
 717         Args:
 718             target_flavor (Dict[str, Any]): [description]
 719             indata (Dict[str, Any]): [description]
 720             vim_info (Dict[str, Any]): [description]
 721             target_record_id (str): [description]
 722
 723         Returns:
 724             Dict[str, Any]: [description]
 725         """
 726         flavor_data = {
 727             "disk": int(target_flavor["storage-gb"]),
 728             "ram": int(target_flavor["memory-mb"]),
 729             "vcpus": int(target_flavor["vcpu-count"]),
 730         }
 731
 732         target_vdur = {}
 733         for vnf in indata.get("vnf", []):
 734             for vdur in vnf.get("vdur", []):
 735                 if vdur.get("ns-flavor-id") == target_flavor["id"]:
 736                     target_vdur = vdur
 737
 738         for storage in target_vdur.get("virtual-storages", []):
 739             if (
 740                 storage.get("type-of-storage")
 741                 == "etsi-nfv-descriptors:ephemeral-storage"
 742             ):
 743                 flavor_data["ephemeral"] = int(storage.get("size-of-storage", 0))
 744             elif storage.get("type-of-storage") == "etsi-nfv-descriptors:swap-storage":
 745                 flavor_data["swap"] = int(storage.get("size-of-storage", 0))
 746
 747         extended = Ns._process_epa_params(target_flavor)
 748         if extended:
 749             flavor_data["extended"] = extended
 750
 751         extra_dict = {"find_params": {"flavor_data": flavor_data}}
 752         flavor_data_name = flavor_data.copy()
 753         flavor_data_name["name"] = target_flavor["name"]
 754         extra_dict["params"] = {"flavor_data": flavor_data_name}
 755
 756         return extra_dict
 757
 758     @staticmethod
 759     def _ip_profile_to_ro(
 760         ip_profile: Dict[str, Any],
 761     ) -> Dict[str, Any]:
 762         """[summary]
 763
 764         Args:
 765             ip_profile (Dict[str, Any]): [description]
 766
 767         Returns:
 768             Dict[str, Any]: [description]
 769         """
 770         if not ip_profile:
 771             return None
 772
 773         ro_ip_profile = {
 774             "ip_version": "IPv4"
 775             if "v4" in ip_profile.get("ip-version", "ipv4")
 776             else "IPv6",
 777             "subnet_address": ip_profile.get("subnet-address"),
 778             "gateway_address": ip_profile.get("gateway-address"),
 779             "dhcp_enabled": ip_profile.get("dhcp-params", {}).get("enabled", False),
 780             "dhcp_start_address": ip_profile.get("dhcp-params", {}).get(
 781                 "start-address", None
 782             ),
 783             "dhcp_count": ip_profile.get("dhcp-params", {}).get("count", None),
 784         }
 785
 786         if ip_profile.get("dns-server"):
 787             ro_ip_profile["dns_address"] = ";".join(
 788                 [v["address"] for v in ip_profile["dns-server"] if v.get("address")]
 789             )
 790
 791         if ip_profile.get("security-group"):
 792             ro_ip_profile["security_group"] = ip_profile["security-group"]
 793
 794         return ro_ip_profile
 795
 796     def deploy(self, session, indata, version, nsr_id, *args, **kwargs):
 797         self.logger.debug("ns.deploy nsr_id={} indata={}".format(nsr_id, indata))
 798         validate_input(indata, deploy_schema)
 799         action_id = indata.get("action_id", str(uuid4()))
 800         task_index = 0
 801         # get current deployment
 802         db_nsr_update = {}  # update operation on nsrs
 803         db_vnfrs_update = {}
 804         db_vnfrs = {}  # vnf's info indexed by _id
 805         nb_ro_tasks = 0  # for logging
 806         vdu2cloud_init = indata.get("cloud_init_content") or {}
 807         step = ""
 808         logging_text = "Task deploy nsr_id={} action_id={} ".format(nsr_id, action_id)
 809         self.logger.debug(logging_text + "Enter")
 810
 811         try:
 812             step = "Getting ns and vnfr record from db"
 813             db_nsr = self.db.get_one("nsrs", {"_id": nsr_id})
 814             db_new_tasks = []
 815             tasks_by_target_record_id = {}
 816             # read from db: vnf's of this ns
 817             step = "Getting vnfrs from db"
 818             db_vnfrs_list = self.db.get_list("vnfrs", {"nsr-id-ref": nsr_id})
 819
 820             if not db_vnfrs_list:
 821                 raise NsException("Cannot obtain associated VNF for ns")
 822
 823             for vnfr in db_vnfrs_list:
 824                 db_vnfrs[vnfr["_id"]] = vnfr
 825                 db_vnfrs_update[vnfr["_id"]] = {}
 826
 827             now = time()
 828             db_ro_nsr = self.db.get_one("ro_nsrs", {"_id": nsr_id}, fail_on_empty=False)
 829
 830             if not db_ro_nsr:
 831                 db_ro_nsr = self._create_db_ro_nsrs(nsr_id, now)
 832
 833             ro_nsr_public_key = db_ro_nsr["public_key"]
 834
 835             # check that action_id is not in the list of actions. Suffixed with :index
 836             if action_id in db_ro_nsr["actions"]:
 837                 index = 1
 838
 839                 while True:
 840                     new_action_id = "{}:{}".format(action_id, index)
 841
 842                     if new_action_id not in db_ro_nsr["actions"]:
 843                         action_id = new_action_id
 844                         self.logger.debug(
 845                             logging_text
 846                             + "Changing action_id in use to {}".format(action_id)
 847                         )
 848                         break
 849
 850                     index += 1
 851
 852             def _process_net_params(target_vld, indata, vim_info, target_record_id):
 853                 extra_dict = {}
 854
 855                 if vim_info.get("sdn"):
 856                     # vnf_preffix = "vnfrs:{}".format(vnfr_id)
 857                     # ns_preffix = "nsrs:{}".format(nsr_id)
 858                     # remove the ending ".sdn
 859                     vld_target_record_id, _, _ = target_record_id.rpartition(".")
 860                     extra_dict["params"] = {
 861                         k: vim_info[k]
 862                         for k in ("sdn-ports", "target_vim", "vlds", "type")
 863                         if vim_info.get(k)
 864                     }
 865
 866                     # TODO needed to add target_id in the dependency.
 867                     if vim_info.get("target_vim"):
 868                         extra_dict["depends_on"] = [
 869                             vim_info.get("target_vim") + " " + vld_target_record_id
 870                         ]
 871
 872                     return extra_dict
 873
 874                 if vim_info.get("vim_network_name"):
 875                     extra_dict["find_params"] = {
 876                         "filter_dict": {"name": vim_info.get("vim_network_name")}
 877                     }
 878                 elif vim_info.get("vim_network_id"):
 879                     extra_dict["find_params"] = {
 880                         "filter_dict": {"id": vim_info.get("vim_network_id")}
 881                     }
 882                 elif target_vld.get("mgmt-network"):
 883                     extra_dict["find_params"] = {"mgmt": True, "name": target_vld["id"]}
 884                 else:
 885                     # create
 886                     extra_dict["params"] = {
 887                         "net_name": "{}-{}".format(
 888                             indata["name"][:16],
 889                             target_vld.get("name", target_vld["id"])[:16],
 890                         ),
 891                         "ip_profile": Ns._ip_profile_to_ro(vim_info.get("ip_profile")),
 892                         "provider_network_profile": vim_info.get("provider_network"),
 893                     }
 894
 895                     if not target_vld.get("underlay"):
 896                         extra_dict["params"]["net_type"] = "bridge"
 897                     else:
 898                         extra_dict["params"]["net_type"] = (
 899                             "ptp" if target_vld.get("type") == "ELINE" else "data"
 900                         )
 901
 902                 return extra_dict
 903
 904             def _process_vdu_params(target_vdu, indata, vim_info, target_record_id):
 905                 nonlocal vnfr_id
 906                 nonlocal nsr_id
 907                 nonlocal vnfr
 908                 nonlocal vdu2cloud_init
 909                 nonlocal tasks_by_target_record_id
 910
 911                 vnf_preffix = "vnfrs:{}".format(vnfr_id)
 912                 ns_preffix = "nsrs:{}".format(nsr_id)
 913                 image_text = ns_preffix + ":image." + target_vdu["ns-image-id"]
 914                 flavor_text = ns_preffix + ":flavor." + target_vdu["ns-flavor-id"]
 915                 extra_dict = {"depends_on": [image_text, flavor_text]}
 916                 net_list = []
 917
 918                 for iface_index, interface in enumerate(target_vdu["interfaces"]):
 919                     if interface.get("ns-vld-id"):
 920                         net_text = ns_preffix + ":vld." + interface["ns-vld-id"]
 921                     elif interface.get("vnf-vld-id"):
 922                         net_text = vnf_preffix + ":vld." + interface["vnf-vld-id"]
 923                     else:
 924                         self.logger.error(
 925                             "Interface {} from vdu {} not connected to any vld".format(
 926                                 iface_index, target_vdu["vdu-name"]
 927                             )
 928                         )
 929
 930                         continue  # interface not connected to any vld
 931
 932                     extra_dict["depends_on"].append(net_text)
 933
 934                     if "port-security-enabled" in interface:
 935                         interface["port_security"] = interface.pop(
 936                             "port-security-enabled"
 937                         )
 938
 939                     if "port-security-disable-strategy" in interface:
 940                         interface["port_security_disable_strategy"] = interface.pop(
 941                             "port-security-disable-strategy"
 942                         )
 943
 944                     net_item = {
 945                         x: v
 946                         for x, v in interface.items()
 947                         if x
 948                         in (
 949                             "name",
 950                             "vpci",
 951                             "port_security",
 952                             "port_security_disable_strategy",
 953                             "floating_ip",
 954                         )
 955                     }
 956                     net_item["net_id"] = "TASK-" + net_text
 957                     net_item["type"] = "virtual"
 958
 959                     # TODO mac_address: used for  SR-IOV ifaces #TODO for other types
 960                     # TODO floating_ip: True/False (or it can be None)
 961                     if interface.get("type") in ("SR-IOV", "PCI-PASSTHROUGH"):
 962                         # mark the net create task as type data
 963                         if deep_get(
 964                             tasks_by_target_record_id, net_text, "params", "net_type"
 965                         ):
 966                             tasks_by_target_record_id[net_text]["params"][
 967                                 "net_type"
 968                             ] = "data"
 969
 970                         net_item["use"] = "data"
 971                         net_item["model"] = interface["type"]
 972                         net_item["type"] = interface["type"]
 973                     elif (
 974                         interface.get("type") == "OM-MGMT"
 975                         or interface.get("mgmt-interface")
 976                         or interface.get("mgmt-vnf")
 977                     ):
 978                         net_item["use"] = "mgmt"
 979                     else:
 980                         # if interface.get("type") in ("VIRTIO", "E1000", "PARAVIRT"):
 981                         net_item["use"] = "bridge"
 982                         net_item["model"] = interface.get("type")
 983
 984                     if interface.get("ip-address"):
 985                         net_item["ip_address"] = interface["ip-address"]
 986
 987                     if interface.get("mac-address"):
 988                         net_item["mac_address"] = interface["mac-address"]
 989
 990                     net_list.append(net_item)
 991
 992                     if interface.get("mgmt-vnf"):
 993                         extra_dict["mgmt_vnf_interface"] = iface_index
 994                     elif interface.get("mgmt-interface"):
 995                         extra_dict["mgmt_vdu_interface"] = iface_index
 996
 997                 # cloud config
 998                 cloud_config = {}
 999
1000                 if target_vdu.get("cloud-init"):
1001                     if target_vdu["cloud-init"] not in vdu2cloud_init:
1002                         vdu2cloud_init[target_vdu["cloud-init"]] = self._get_cloud_init(
1003                             target_vdu["cloud-init"]
1004                         )
1005
1006                     cloud_content_ = vdu2cloud_init[target_vdu["cloud-init"]]
1007                     cloud_config["user-data"] = self._parse_jinja2(
1008                         cloud_content_,
1009                         target_vdu.get("additionalParams"),
1010                         target_vdu["cloud-init"],
1011                     )
1012
1013                 if target_vdu.get("boot-data-drive"):
1014                     cloud_config["boot-data-drive"] = target_vdu.get("boot-data-drive")
1015
1016                 ssh_keys = []
1017
1018                 if target_vdu.get("ssh-keys"):
1019                     ssh_keys += target_vdu.get("ssh-keys")
1020
1021                 if target_vdu.get("ssh-access-required"):
1022                     ssh_keys.append(ro_nsr_public_key)
1023
1024                 if ssh_keys:
1025                     cloud_config["key-pairs"] = ssh_keys
1026
1027                 disk_list = None
1028                 if target_vdu.get("virtual-storages"):
1029                     disk_list = [
1030                         {"size": disk["size-of-storage"]}
1031                         for disk in target_vdu["virtual-storages"]
1032                         if disk.get("type-of-storage")
1033                         == "persistent-storage:persistent-storage"
1034                     ]
1035
1036                 extra_dict["params"] = {
1037                     "name": "{}-{}-{}-{}".format(
1038                         indata["name"][:16],
1039                         vnfr["member-vnf-index-ref"][:16],
1040                         target_vdu["vdu-name"][:32],
1041                         target_vdu.get("count-index") or 0,
1042                     ),
1043                     "description": target_vdu["vdu-name"],
1044                     "start": True,
1045                     "image_id": "TASK-" + image_text,
1046                     "flavor_id": "TASK-" + flavor_text,
1047                     "net_list": net_list,
1048                     "cloud_config": cloud_config or None,
1049                     "disk_list": disk_list,
1050                     "availability_zone_index": None,  # TODO
1051                     "availability_zone_list": None,  # TODO
1052                 }
1053
1054                 return extra_dict
1055
1056             def _process_items(
1057                 target_list,
1058                 existing_list,
1059                 db_record,
1060                 db_update,
1061                 db_path,
1062                 item,
1063                 process_params,
1064             ):
1065                 nonlocal db_new_tasks
1066                 nonlocal tasks_by_target_record_id
1067                 nonlocal action_id
1068                 nonlocal nsr_id
1069                 nonlocal task_index
1070                 nonlocal indata
1071
1072                 # ensure all the target_list elements has an "id". If not assign the index as id
1073                 for target_index, tl in enumerate(target_list):
1074                     if tl and not tl.get("id"):
1075                         tl["id"] = str(target_index)
1076
1077                 # step 1 items (networks,vdus,...) to be deleted/updated
1078                 for item_index, existing_item in enumerate(existing_list):
1079                     target_item = next(
1080                         (t for t in target_list if t["id"] == existing_item["id"]), None
1081                     )
1082
1083                     for target_vim, existing_viminfo in existing_item.get(
1084                         "vim_info", {}
1085                     ).items():
1086                         if existing_viminfo is None:
1087                             continue
1088
1089                         if target_item:
1090                             target_viminfo = target_item.get("vim_info", {}).get(
1091                                 target_vim
1092                             )
1093                         else:
1094                             target_viminfo = None
1095
1096                         if target_viminfo is None:
1097                             # must be deleted
1098                             self._assign_vim(target_vim)
1099                             target_record_id = "{}.{}".format(
1100                                 db_record, existing_item["id"]
1101                             )
1102                             item_ = item
1103
1104                             if target_vim.startswith("sdn"):
1105                                 # item must be sdn-net instead of net if target_vim is a sdn
1106                                 item_ = "sdn_net"
1107                                 target_record_id += ".sdn"
1108
1109                             deployment_info = {
1110                                 "action_id": action_id,
1111                                 "nsr_id": nsr_id,
1112                                 "task_index": task_index,
1113                             }
1114
1115                             task = Ns._create_task(
1116                                 deployment_info=deployment_info,
1117                                 target_id=target_vim,
1118                                 item=item_,
1119                                 action="DELETE",
1120                                 target_record=f"{db_record}.{item_index}.vim_info.{target_vim}",
1121                                 target_record_id=target_record_id,
1122                             )
1123
1124                             task_index = deployment_info.get("task_index")
1125
1126                             tasks_by_target_record_id[target_record_id] = task
1127                             db_new_tasks.append(task)
1128                             # TODO delete
1129                     # TODO check one by one the vims to be created/deleted
1130
1131                 # step 2 items (networks,vdus,...) to be created
1132                 for target_item in target_list:
1133                     item_index = -1
1134
1135                     for item_index, existing_item in enumerate(existing_list):
1136                         if existing_item["id"] == target_item["id"]:
1137                             break
1138                     else:
1139                         item_index += 1
1140                         db_update[db_path + ".{}".format(item_index)] = target_item
1141                         existing_list.append(target_item)
1142                         existing_item = None
1143
1144                     for target_vim, target_viminfo in target_item.get(
1145                         "vim_info", {}
1146                     ).items():
1147                         existing_viminfo = None
1148
1149                         if existing_item:
1150                             existing_viminfo = existing_item.get("vim_info", {}).get(
1151                                 target_vim
1152                             )
1153
1154                         # TODO check if different. Delete and create???
1155                         # TODO delete if not exist
1156                         if existing_viminfo is not None:
1157                             continue
1158
1159                         target_record_id = "{}.{}".format(db_record, target_item["id"])
1160                         item_ = item
1161
1162                         if target_vim.startswith("sdn"):
1163                             # item must be sdn-net instead of net if target_vim is a sdn
1164                             item_ = "sdn_net"
1165                             target_record_id += ".sdn"
1166
1167                         extra_dict = process_params(
1168                             target_item, indata, target_viminfo, target_record_id
1169                         )
1170                         self._assign_vim(target_vim)
1171
1172                         deployment_info = {
1173                             "action_id": action_id,
1174                             "nsr_id": nsr_id,
1175                             "task_index": task_index,
1176                         }
1177
1178                         task = Ns._create_task(
1179                             deployment_info=deployment_info,
1180                             target_id=target_vim,
1181                             item=item_,
1182                             action="CREATE",
1183                             target_record=f"{db_record}.{item_index}.vim_info.{target_vim}",
1184                             target_record_id=target_record_id,
1185                             extra_dict=extra_dict,
1186                         )
1187
1188                         task_index = deployment_info.get("task_index")
1189
1190                         tasks_by_target_record_id[target_record_id] = task
1191                         db_new_tasks.append(task)
1192
1193                         if target_item.get("common_id"):
1194                             task["common_id"] = target_item["common_id"]
1195
1196                         db_update[db_path + ".{}".format(item_index)] = target_item
1197
1198             def _process_action(indata):
1199                 nonlocal db_new_tasks
1200                 nonlocal action_id
1201                 nonlocal nsr_id
1202                 nonlocal task_index
1203                 nonlocal db_vnfrs
1204                 nonlocal db_ro_nsr
1205
1206                 if indata["action"]["action"] == "inject_ssh_key":
1207                     key = indata["action"].get("key")
1208                     user = indata["action"].get("user")
1209                     password = indata["action"].get("password")
1210
1211                     for vnf in indata.get("vnf", ()):
1212                         if vnf["_id"] not in db_vnfrs:
1213                             raise NsException("Invalid vnf={}".format(vnf["_id"]))
1214
1215                         db_vnfr = db_vnfrs[vnf["_id"]]
1216
1217                         for target_vdu in vnf.get("vdur", ()):
1218                             vdu_index, vdur = next(
1219                                 (
1220                                     i_v
1221                                     for i_v in enumerate(db_vnfr["vdur"])
1222                                     if i_v[1]["id"] == target_vdu["id"]
1223                                 ),
1224                                 (None, None),
1225                             )
1226
1227                             if not vdur:
1228                                 raise NsException(
1229                                     "Invalid vdu vnf={}.{}".format(
1230                                         vnf["_id"], target_vdu["id"]
1231                                     )
1232                                 )
1233
1234                             target_vim, vim_info = next(
1235                                 k_v for k_v in vdur["vim_info"].items()
1236                             )
1237                             self._assign_vim(target_vim)
1238                             target_record = "vnfrs:{}:vdur.{}.ssh_keys".format(
1239                                 vnf["_id"], vdu_index
1240                             )
1241                             extra_dict = {
1242                                 "depends_on": [
1243                                     "vnfrs:{}:vdur.{}".format(vnf["_id"], vdur["id"])
1244                                 ],
1245                                 "params": {
1246                                     "ip_address": vdur.get("ip-address"),
1247                                     "user": user,
1248                                     "key": key,
1249                                     "password": password,
1250                                     "private_key": db_ro_nsr["private_key"],
1251                                     "salt": db_ro_nsr["_id"],
1252                                     "schema_version": db_ro_nsr["_admin"][
1253                                         "schema_version"
1254                                     ],
1255                                 },
1256                             }
1257
1258                             deployment_info = {
1259                                 "action_id": action_id,
1260                                 "nsr_id": nsr_id,
1261                                 "task_index": task_index,
1262                             }
1263
1264                             task = Ns._create_task(
1265                                 deployment_info=deployment_info,
1266                                 target_id=target_vim,
1267                                 item="vdu",
1268                                 action="EXEC",
1269                                 target_record=target_record,
1270                                 target_record_id=None,
1271                                 extra_dict=extra_dict,
1272                             )
1273
1274                             task_index = deployment_info.get("task_index")
1275
1276                             db_new_tasks.append(task)
1277
1278             with self.write_lock:
1279                 if indata.get("action"):
1280                     _process_action(indata)
1281                 else:
1282                     # compute network differences
1283                     # NS.vld
1284                     step = "process NS VLDs"
1285                     _process_items(
1286                         target_list=indata["ns"]["vld"] or [],
1287                         existing_list=db_nsr.get("vld") or [],
1288                         db_record="nsrs:{}:vld".format(nsr_id),
1289                         db_update=db_nsr_update,
1290                         db_path="vld",
1291                         item="net",
1292                         process_params=_process_net_params,
1293                     )
1294
1295                     step = "process NS images"
1296                     _process_items(
1297                         target_list=indata.get("image") or [],
1298                         existing_list=db_nsr.get("image") or [],
1299                         db_record="nsrs:{}:image".format(nsr_id),
1300                         db_update=db_nsr_update,
1301                         db_path="image",
1302                         item="image",
1303                         process_params=Ns._process_image_params,
1304                     )
1305
1306                     step = "process NS flavors"
1307                     _process_items(
1308                         target_list=indata.get("flavor") or [],
1309                         existing_list=db_nsr.get("flavor") or [],
1310                         db_record="nsrs:{}:flavor".format(nsr_id),
1311                         db_update=db_nsr_update,
1312                         db_path="flavor",
1313                         item="flavor",
1314                         process_params=Ns._process_flavor_params,
1315                     )
1316
1317                     # VNF.vld
1318                     for vnfr_id, vnfr in db_vnfrs.items():
1319                         # vnfr_id need to be set as global variable for among others nested method _process_vdu_params
1320                         step = "process VNF={} VLDs".format(vnfr_id)
1321                         target_vnf = next(
1322                             (
1323                                 vnf
1324                                 for vnf in indata.get("vnf", ())
1325                                 if vnf["_id"] == vnfr_id
1326                             ),
1327                             None,
1328                         )
1329                         target_list = target_vnf.get("vld") if target_vnf else None
1330                         _process_items(
1331                             target_list=target_list or [],
1332                             existing_list=vnfr.get("vld") or [],
1333                             db_record="vnfrs:{}:vld".format(vnfr_id),
1334                             db_update=db_vnfrs_update[vnfr["_id"]],
1335                             db_path="vld",
1336                             item="net",
1337                             process_params=_process_net_params,
1338                         )
1339
1340                         target_list = target_vnf.get("vdur") if target_vnf else None
1341                         step = "process VNF={} VDUs".format(vnfr_id)
1342                         _process_items(
1343                             target_list=target_list or [],
1344                             existing_list=vnfr.get("vdur") or [],
1345                             db_record="vnfrs:{}:vdur".format(vnfr_id),
1346                             db_update=db_vnfrs_update[vnfr["_id"]],
1347                             db_path="vdur",
1348                             item="vdu",
1349                             process_params=_process_vdu_params,
1350                         )
1351
1352                 for db_task in db_new_tasks:
1353                     step = "Updating database, Appending tasks to ro_tasks"
1354                     target_id = db_task.pop("target_id")
1355                     common_id = db_task.get("common_id")
1356
1357                     if common_id:
1358                         if self.db.set_one(
1359                             "ro_tasks",
1360                             q_filter={
1361                                 "target_id": target_id,
1362                                 "tasks.common_id": common_id,
1363                             },
1364                             update_dict={"to_check_at": now, "modified_at": now},
1365                             push={"tasks": db_task},
1366                             fail_on_empty=False,
1367                         ):
1368                             continue
1369
1370                     if not self.db.set_one(
1371                         "ro_tasks",
1372                         q_filter={
1373                             "target_id": target_id,
1374                             "tasks.target_record": db_task["target_record"],
1375                         },
1376                         update_dict={"to_check_at": now, "modified_at": now},
1377                         push={"tasks": db_task},
1378                         fail_on_empty=False,
1379                     ):
1380                         # Create a ro_task
1381                         step = "Updating database, Creating ro_tasks"
1382                         db_ro_task = Ns._create_ro_task(target_id, db_task)
1383                         nb_ro_tasks += 1
1384                         self.db.create("ro_tasks", db_ro_task)
1385
1386                 step = "Updating database, nsrs"
1387                 if db_nsr_update:
1388                     self.db.set_one("nsrs", {"_id": nsr_id}, db_nsr_update)
1389
1390                 for vnfr_id, db_vnfr_update in db_vnfrs_update.items():
1391                     if db_vnfr_update:
1392                         step = "Updating database, vnfrs={}".format(vnfr_id)
1393                         self.db.set_one("vnfrs", {"_id": vnfr_id}, db_vnfr_update)
1394
1395             self.logger.debug(
1396                 logging_text
1397                 + "Exit. Created {} ro_tasks; {} tasks".format(
1398                     nb_ro_tasks, len(db_new_tasks)
1399                 )
1400             )
1401
1402             return (
1403                 {"status": "ok", "nsr_id": nsr_id, "action_id": action_id},
1404                 action_id,
1405                 True,
1406             )
1407         except Exception as e:
1408             if isinstance(e, (DbException, NsException)):
1409                 self.logger.error(
1410                     logging_text + "Exit Exception while '{}': {}".format(step, e)
1411                 )
1412             else:
1413                 e = traceback_format_exc()
1414                 self.logger.critical(
1415                     logging_text + "Exit Exception while '{}': {}".format(step, e),
1416                     exc_info=True,
1417                 )
1418
1419             raise NsException(e)
1420
1421     def delete(self, session, indata, version, nsr_id, *args, **kwargs):
1422         self.logger.debug("ns.delete version={} nsr_id={}".format(version, nsr_id))
1423         # self.db.del_list({"_id": ro_task["_id"], "tasks.nsr_id.ne": nsr_id})
1424
1425         with self.write_lock:
1426             try:
1427                 NsWorker.delete_db_tasks(self.db, nsr_id, None)
1428             except NsWorkerException as e:
1429                 raise NsException(e)
1430
1431         return None, None, True
1432
1433     def status(self, session, indata, version, nsr_id, action_id, *args, **kwargs):
1434         # self.logger.debug("ns.status version={} nsr_id={}, action_id={} indata={}"
1435         #                   .format(version, nsr_id, action_id, indata))
1436         task_list = []
1437         done = 0
1438         total = 0
1439         ro_tasks = self.db.get_list("ro_tasks", {"tasks.action_id": action_id})
1440         global_status = "DONE"
1441         details = []
1442
1443         for ro_task in ro_tasks:
1444             for task in ro_task["tasks"]:
1445                 if task and task["action_id"] == action_id:
1446                     task_list.append(task)
1447                     total += 1
1448
1449                     if task["status"] == "FAILED":
1450                         global_status = "FAILED"
1451                         error_text = "Error at {} {}: {}".format(
1452                             task["action"].lower(),
1453                             task["item"],
1454                             ro_task["vim_info"].get("vim_details") or "unknown",
1455                         )
1456                         details.append(error_text)
1457                     elif task["status"] in ("SCHEDULED", "BUILD"):
1458                         if global_status != "FAILED":
1459                             global_status = "BUILD"
1460                     else:
1461                         done += 1
1462
1463         return_data = {
1464             "status": global_status,
1465             "details": ". ".join(details)
1466             if details
1467             else "progress {}/{}".format(done, total),
1468             "nsr_id": nsr_id,
1469             "action_id": action_id,
1470             "tasks": task_list,
1471         }
1472
1473         return return_data, None, True
1474
1475     def cancel(self, session, indata, version, nsr_id, action_id, *args, **kwargs):
1476         print(
1477             "ns.cancel session={} indata={} version={} nsr_id={}, action_id={}".format(
1478                 session, indata, version, nsr_id, action_id
1479             )
1480         )
1481
1482         return None, None, True
1483
1484     def get_deploy(self, session, indata, version, nsr_id, action_id, *args, **kwargs):
1485         nsrs = self.db.get_list("nsrs", {})
1486         return_data = []
1487
1488         for ns in nsrs:
1489             return_data.append({"_id": ns["_id"], "name": ns["name"]})
1490
1491         return return_data, None, True
1492
1493     def get_actions(self, session, indata, version, nsr_id, action_id, *args, **kwargs):
1494         ro_tasks = self.db.get_list("ro_tasks", {"tasks.nsr_id": nsr_id})
1495         return_data = []
1496
1497         for ro_task in ro_tasks:
1498             for task in ro_task["tasks"]:
1499                 if task["action_id"] not in return_data:
1500                     return_data.append(task["action_id"])
1501
1502         return return_data, None, True