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