Removing OpenNebula code
[osm/RO.git] / 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 traceback import format_exc as traceback_format_exc
22 from osm_ng_ro.ns_thread import NsWorker, NsWorkerException, deep_get
23 from osm_ng_ro.validation import validate_input, deploy_schema
24 from osm_common import (
25 dbmongo,
26 dbmemory,
27 fslocal,
28 fsmongo,
29 msglocal,
30 msgkafka,
31 version as common_version,
32 )
33 from osm_common.dbbase import DbException
34 from osm_common.fsbase import FsException
35 from osm_common.msgbase import MsgException
36 from http import HTTPStatus
37 from uuid import uuid4
38 from threading import Lock
39 from random import choice as random_choice
40 from time import time
41 from jinja2 import (
42 Environment,
43 TemplateError,
44 TemplateNotFound,
45 StrictUndefined,
46 UndefinedError,
47 )
48 from cryptography.hazmat.primitives import serialization as crypto_serialization
49 from cryptography.hazmat.primitives.asymmetric import rsa
50 from cryptography.hazmat.backends import default_backend as crypto_default_backend
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 _ip_profile_2_ro(ip_profile):
697 if not ip_profile:
698 return None
699
700 ro_ip_profile = {
701 "ip_version": "IPv4"
702 if "v4" in ip_profile.get("ip-version", "ipv4")
703 else "IPv6",
704 "subnet_address": ip_profile.get("subnet-address"),
705 "gateway_address": ip_profile.get("gateway-address"),
706 "dhcp_enabled": ip_profile.get("dhcp-params", {}).get(
707 "enabled", False
708 ),
709 "dhcp_start_address": ip_profile.get("dhcp-params", {}).get(
710 "start-address", None
711 ),
712 "dhcp_count": ip_profile.get("dhcp-params", {}).get("count", None),
713 }
714
715 if ip_profile.get("dns-server"):
716 ro_ip_profile["dns_address"] = ";".join(
717 [v["address"] for v in ip_profile["dns-server"]]
718 )
719
720 if ip_profile.get("security-group"):
721 ro_ip_profile["security_group"] = ip_profile["security-group"]
722
723 return ro_ip_profile
724
725 def _process_net_params(target_vld, vim_info, target_record_id):
726 nonlocal indata
727 extra_dict = {}
728
729 if vim_info.get("sdn"):
730 # vnf_preffix = "vnfrs:{}".format(vnfr_id)
731 # ns_preffix = "nsrs:{}".format(nsr_id)
732 # remove the ending ".sdn
733 vld_target_record_id, _, _ = target_record_id.rpartition(".")
734 extra_dict["params"] = {
735 k: vim_info[k]
736 for k in ("sdn-ports", "target_vim", "vlds", "type")
737 if vim_info.get(k)
738 }
739
740 # TODO needed to add target_id in the dependency.
741 if vim_info.get("target_vim"):
742 extra_dict["depends_on"] = [
743 vim_info.get("target_vim") + " " + vld_target_record_id
744 ]
745
746 return extra_dict
747
748 if vim_info.get("vim_network_name"):
749 extra_dict["find_params"] = {
750 "filter_dict": {"name": vim_info.get("vim_network_name")}
751 }
752 elif vim_info.get("vim_network_id"):
753 extra_dict["find_params"] = {
754 "filter_dict": {"id": vim_info.get("vim_network_id")}
755 }
756 elif target_vld.get("mgmt-network"):
757 extra_dict["find_params"] = {"mgmt": True, "name": target_vld["id"]}
758 else:
759 # create
760 extra_dict["params"] = {
761 "net_name": "{}-{}".format(
762 indata["name"][:16],
763 target_vld.get("name", target_vld["id"])[:16],
764 ),
765 "ip_profile": _ip_profile_2_ro(vim_info.get("ip_profile")),
766 "provider_network_profile": vim_info.get("provider_network"),
767 }
768
769 if not target_vld.get("underlay"):
770 extra_dict["params"]["net_type"] = "bridge"
771 else:
772 extra_dict["params"]["net_type"] = (
773 "ptp" if target_vld.get("type") == "ELINE" else "data"
774 )
775
776 return extra_dict
777
778 def _process_vdu_params(target_vdu, vim_info, target_record_id):
779 nonlocal vnfr_id
780 nonlocal nsr_id
781 nonlocal indata
782 nonlocal vnfr
783 nonlocal vdu2cloud_init
784 nonlocal tasks_by_target_record_id
785
786 vnf_preffix = "vnfrs:{}".format(vnfr_id)
787 ns_preffix = "nsrs:{}".format(nsr_id)
788 image_text = ns_preffix + ":image." + target_vdu["ns-image-id"]
789 flavor_text = ns_preffix + ":flavor." + target_vdu["ns-flavor-id"]
790 extra_dict = {"depends_on": [image_text, flavor_text]}
791 net_list = []
792
793 for iface_index, interface in enumerate(target_vdu["interfaces"]):
794 if interface.get("ns-vld-id"):
795 net_text = ns_preffix + ":vld." + interface["ns-vld-id"]
796 elif interface.get("vnf-vld-id"):
797 net_text = vnf_preffix + ":vld." + interface["vnf-vld-id"]
798 else:
799 self.logger.error(
800 "Interface {} from vdu {} not connected to any vld".format(
801 iface_index, target_vdu["vdu-name"]
802 )
803 )
804
805 continue # interface not connected to any vld
806
807 extra_dict["depends_on"].append(net_text)
808
809 if "port-security-enabled" in interface:
810 interface["port_security"] = interface.pop(
811 "port-security-enabled"
812 )
813
814 if "port-security-disable-strategy" in interface:
815 interface["port_security_disable_strategy"] = interface.pop(
816 "port-security-disable-strategy"
817 )
818
819 net_item = {
820 x: v
821 for x, v in interface.items()
822 if x
823 in (
824 "name",
825 "vpci",
826 "port_security",
827 "port_security_disable_strategy",
828 "floating_ip",
829 )
830 }
831 net_item["net_id"] = "TASK-" + net_text
832 net_item["type"] = "virtual"
833
834 # TODO mac_address: used for SR-IOV ifaces #TODO for other types
835 # TODO floating_ip: True/False (or it can be None)
836 if interface.get("type") in ("SR-IOV", "PCI-PASSTHROUGH"):
837 # mark the net create task as type data
838 if deep_get(
839 tasks_by_target_record_id, net_text, "params", "net_type"
840 ):
841 tasks_by_target_record_id[net_text]["params"][
842 "net_type"
843 ] = "data"
844
845 net_item["use"] = "data"
846 net_item["model"] = interface["type"]
847 net_item["type"] = interface["type"]
848 elif (
849 interface.get("type") == "OM-MGMT"
850 or interface.get("mgmt-interface")
851 or interface.get("mgmt-vnf")
852 ):
853 net_item["use"] = "mgmt"
854 else:
855 # if interface.get("type") in ("VIRTIO", "E1000", "PARAVIRT"):
856 net_item["use"] = "bridge"
857 net_item["model"] = interface.get("type")
858
859 if interface.get("ip-address"):
860 net_item["ip_address"] = interface["ip-address"]
861
862 if interface.get("mac-address"):
863 net_item["mac_address"] = interface["mac-address"]
864
865 net_list.append(net_item)
866
867 if interface.get("mgmt-vnf"):
868 extra_dict["mgmt_vnf_interface"] = iface_index
869 elif interface.get("mgmt-interface"):
870 extra_dict["mgmt_vdu_interface"] = iface_index
871
872 # cloud config
873 cloud_config = {}
874
875 if target_vdu.get("cloud-init"):
876 if target_vdu["cloud-init"] not in vdu2cloud_init:
877 vdu2cloud_init[target_vdu["cloud-init"]] = self._get_cloud_init(
878 target_vdu["cloud-init"]
879 )
880
881 cloud_content_ = vdu2cloud_init[target_vdu["cloud-init"]]
882 cloud_config["user-data"] = self._parse_jinja2(
883 cloud_content_,
884 target_vdu.get("additionalParams"),
885 target_vdu["cloud-init"],
886 )
887
888 if target_vdu.get("boot-data-drive"):
889 cloud_config["boot-data-drive"] = target_vdu.get("boot-data-drive")
890
891 ssh_keys = []
892
893 if target_vdu.get("ssh-keys"):
894 ssh_keys += target_vdu.get("ssh-keys")
895
896 if target_vdu.get("ssh-access-required"):
897 ssh_keys.append(ro_nsr_public_key)
898
899 if ssh_keys:
900 cloud_config["key-pairs"] = ssh_keys
901
902 disk_list = None
903 if target_vdu.get("virtual-storages"):
904 disk_list = [
905 {"size": disk["size-of-storage"]}
906 for disk in target_vdu["virtual-storages"]
907 if disk.get("type-of-storage")
908 == "persistent-storage:persistent-storage"
909 ]
910
911 extra_dict["params"] = {
912 "name": "{}-{}-{}-{}".format(
913 indata["name"][:16],
914 vnfr["member-vnf-index-ref"][:16],
915 target_vdu["vdu-name"][:32],
916 target_vdu.get("count-index") or 0,
917 ),
918 "description": target_vdu["vdu-name"],
919 "start": True,
920 "image_id": "TASK-" + image_text,
921 "flavor_id": "TASK-" + flavor_text,
922 "net_list": net_list,
923 "cloud_config": cloud_config or None,
924 "disk_list": disk_list,
925 "availability_zone_index": None, # TODO
926 "availability_zone_list": None, # TODO
927 }
928
929 return extra_dict
930
931 def _process_items(
932 target_list,
933 existing_list,
934 db_record,
935 db_update,
936 db_path,
937 item,
938 process_params,
939 ):
940 nonlocal db_new_tasks
941 nonlocal tasks_by_target_record_id
942 nonlocal task_index
943
944 # ensure all the target_list elements has an "id". If not assign the index as id
945 for target_index, tl in enumerate(target_list):
946 if tl and not tl.get("id"):
947 tl["id"] = str(target_index)
948
949 # step 1 items (networks,vdus,...) to be deleted/updated
950 for item_index, existing_item in enumerate(existing_list):
951 target_item = next(
952 (t for t in target_list if t["id"] == existing_item["id"]), None
953 )
954
955 for target_vim, existing_viminfo in existing_item.get(
956 "vim_info", {}
957 ).items():
958 if existing_viminfo is None:
959 continue
960
961 if target_item:
962 target_viminfo = target_item.get("vim_info", {}).get(
963 target_vim
964 )
965 else:
966 target_viminfo = None
967
968 if target_viminfo is None:
969 # must be deleted
970 self._assign_vim(target_vim)
971 target_record_id = "{}.{}".format(
972 db_record, existing_item["id"]
973 )
974 item_ = item
975
976 if target_vim.startswith("sdn"):
977 # item must be sdn-net instead of net if target_vim is a sdn
978 item_ = "sdn_net"
979 target_record_id += ".sdn"
980
981 task = _create_task(
982 target_vim,
983 item_,
984 "DELETE",
985 target_record="{}.{}.vim_info.{}".format(
986 db_record, item_index, target_vim
987 ),
988 target_record_id=target_record_id,
989 )
990 tasks_by_target_record_id[target_record_id] = task
991 db_new_tasks.append(task)
992 # TODO delete
993 # TODO check one by one the vims to be created/deleted
994
995 # step 2 items (networks,vdus,...) to be created
996 for target_item in target_list:
997 item_index = -1
998
999 for item_index, existing_item in enumerate(existing_list):
1000 if existing_item["id"] == target_item["id"]:
1001 break
1002 else:
1003 item_index += 1
1004 db_update[db_path + ".{}".format(item_index)] = target_item
1005 existing_list.append(target_item)
1006 existing_item = None
1007
1008 for target_vim, target_viminfo in target_item.get(
1009 "vim_info", {}
1010 ).items():
1011 existing_viminfo = None
1012
1013 if existing_item:
1014 existing_viminfo = existing_item.get("vim_info", {}).get(
1015 target_vim
1016 )
1017
1018 # TODO check if different. Delete and create???
1019 # TODO delete if not exist
1020 if existing_viminfo is not None:
1021 continue
1022
1023 target_record_id = "{}.{}".format(db_record, target_item["id"])
1024 item_ = item
1025
1026 if target_vim.startswith("sdn"):
1027 # item must be sdn-net instead of net if target_vim is a sdn
1028 item_ = "sdn_net"
1029 target_record_id += ".sdn"
1030
1031 extra_dict = process_params(
1032 target_item, target_viminfo, target_record_id
1033 )
1034 self._assign_vim(target_vim)
1035 task = _create_task(
1036 target_vim,
1037 item_,
1038 "CREATE",
1039 target_record="{}.{}.vim_info.{}".format(
1040 db_record, item_index, target_vim
1041 ),
1042 target_record_id=target_record_id,
1043 extra_dict=extra_dict,
1044 )
1045 tasks_by_target_record_id[target_record_id] = task
1046 db_new_tasks.append(task)
1047
1048 if target_item.get("common_id"):
1049 task["common_id"] = target_item["common_id"]
1050
1051 db_update[db_path + ".{}".format(item_index)] = target_item
1052
1053 def _process_action(indata):
1054 nonlocal db_new_tasks
1055 nonlocal task_index
1056 nonlocal db_vnfrs
1057 nonlocal db_ro_nsr
1058
1059 if indata["action"]["action"] == "inject_ssh_key":
1060 key = indata["action"].get("key")
1061 user = indata["action"].get("user")
1062 password = indata["action"].get("password")
1063
1064 for vnf in indata.get("vnf", ()):
1065 if vnf["_id"] not in db_vnfrs:
1066 raise NsException("Invalid vnf={}".format(vnf["_id"]))
1067
1068 db_vnfr = db_vnfrs[vnf["_id"]]
1069
1070 for target_vdu in vnf.get("vdur", ()):
1071 vdu_index, vdur = next(
1072 (
1073 i_v
1074 for i_v in enumerate(db_vnfr["vdur"])
1075 if i_v[1]["id"] == target_vdu["id"]
1076 ),
1077 (None, None),
1078 )
1079
1080 if not vdur:
1081 raise NsException(
1082 "Invalid vdu vnf={}.{}".format(
1083 vnf["_id"], target_vdu["id"]
1084 )
1085 )
1086
1087 target_vim, vim_info = next(
1088 k_v for k_v in vdur["vim_info"].items()
1089 )
1090 self._assign_vim(target_vim)
1091 target_record = "vnfrs:{}:vdur.{}.ssh_keys".format(
1092 vnf["_id"], vdu_index
1093 )
1094 extra_dict = {
1095 "depends_on": [
1096 "vnfrs:{}:vdur.{}".format(vnf["_id"], vdur["id"])
1097 ],
1098 "params": {
1099 "ip_address": vdur.get("ip-address"),
1100 "user": user,
1101 "key": key,
1102 "password": password,
1103 "private_key": db_ro_nsr["private_key"],
1104 "salt": db_ro_nsr["_id"],
1105 "schema_version": db_ro_nsr["_admin"][
1106 "schema_version"
1107 ],
1108 },
1109 }
1110 task = _create_task(
1111 target_vim,
1112 "vdu",
1113 "EXEC",
1114 target_record=target_record,
1115 target_record_id=None,
1116 extra_dict=extra_dict,
1117 )
1118 db_new_tasks.append(task)
1119
1120 with self.write_lock:
1121 if indata.get("action"):
1122 _process_action(indata)
1123 else:
1124 # compute network differences
1125 # NS.vld
1126 step = "process NS VLDs"
1127 _process_items(
1128 target_list=indata["ns"]["vld"] or [],
1129 existing_list=db_nsr.get("vld") or [],
1130 db_record="nsrs:{}:vld".format(nsr_id),
1131 db_update=db_nsr_update,
1132 db_path="vld",
1133 item="net",
1134 process_params=_process_net_params,
1135 )
1136
1137 step = "process NS images"
1138 _process_items(
1139 target_list=indata.get("image") or [],
1140 existing_list=db_nsr.get("image") or [],
1141 db_record="nsrs:{}:image".format(nsr_id),
1142 db_update=db_nsr_update,
1143 db_path="image",
1144 item="image",
1145 process_params=_process_image_params,
1146 )
1147
1148 step = "process NS flavors"
1149 _process_items(
1150 target_list=indata.get("flavor") or [],
1151 existing_list=db_nsr.get("flavor") or [],
1152 db_record="nsrs:{}:flavor".format(nsr_id),
1153 db_update=db_nsr_update,
1154 db_path="flavor",
1155 item="flavor",
1156 process_params=_process_flavor_params,
1157 )
1158
1159 # VNF.vld
1160 for vnfr_id, vnfr in db_vnfrs.items():
1161 # vnfr_id need to be set as global variable for among others nested method _process_vdu_params
1162 step = "process VNF={} VLDs".format(vnfr_id)
1163 target_vnf = next(
1164 (
1165 vnf
1166 for vnf in indata.get("vnf", ())
1167 if vnf["_id"] == vnfr_id
1168 ),
1169 None,
1170 )
1171 target_list = target_vnf.get("vld") if target_vnf else None
1172 _process_items(
1173 target_list=target_list or [],
1174 existing_list=vnfr.get("vld") or [],
1175 db_record="vnfrs:{}:vld".format(vnfr_id),
1176 db_update=db_vnfrs_update[vnfr["_id"]],
1177 db_path="vld",
1178 item="net",
1179 process_params=_process_net_params,
1180 )
1181
1182 target_list = target_vnf.get("vdur") if target_vnf else None
1183 step = "process VNF={} VDUs".format(vnfr_id)
1184 _process_items(
1185 target_list=target_list or [],
1186 existing_list=vnfr.get("vdur") or [],
1187 db_record="vnfrs:{}:vdur".format(vnfr_id),
1188 db_update=db_vnfrs_update[vnfr["_id"]],
1189 db_path="vdur",
1190 item="vdu",
1191 process_params=_process_vdu_params,
1192 )
1193
1194 for db_task in db_new_tasks:
1195 step = "Updating database, Appending tasks to ro_tasks"
1196 target_id = db_task.pop("target_id")
1197 common_id = db_task.get("common_id")
1198
1199 if common_id:
1200 if self.db.set_one(
1201 "ro_tasks",
1202 q_filter={
1203 "target_id": target_id,
1204 "tasks.common_id": common_id,
1205 },
1206 update_dict={"to_check_at": now, "modified_at": now},
1207 push={"tasks": db_task},
1208 fail_on_empty=False,
1209 ):
1210 continue
1211
1212 if not self.db.set_one(
1213 "ro_tasks",
1214 q_filter={
1215 "target_id": target_id,
1216 "tasks.target_record": db_task["target_record"],
1217 },
1218 update_dict={"to_check_at": now, "modified_at": now},
1219 push={"tasks": db_task},
1220 fail_on_empty=False,
1221 ):
1222 # Create a ro_task
1223 step = "Updating database, Creating ro_tasks"
1224 db_ro_task = _create_ro_task(target_id, db_task)
1225 nb_ro_tasks += 1
1226 self.db.create("ro_tasks", db_ro_task)
1227
1228 step = "Updating database, nsrs"
1229 if db_nsr_update:
1230 self.db.set_one("nsrs", {"_id": nsr_id}, db_nsr_update)
1231
1232 for vnfr_id, db_vnfr_update in db_vnfrs_update.items():
1233 if db_vnfr_update:
1234 step = "Updating database, vnfrs={}".format(vnfr_id)
1235 self.db.set_one("vnfrs", {"_id": vnfr_id}, db_vnfr_update)
1236
1237 self.logger.debug(
1238 logging_text
1239 + "Exit. Created {} ro_tasks; {} tasks".format(
1240 nb_ro_tasks, len(db_new_tasks)
1241 )
1242 )
1243
1244 return (
1245 {"status": "ok", "nsr_id": nsr_id, "action_id": action_id},
1246 action_id,
1247 True,
1248 )
1249 except Exception as e:
1250 if isinstance(e, (DbException, NsException)):
1251 self.logger.error(
1252 logging_text + "Exit Exception while '{}': {}".format(step, e)
1253 )
1254 else:
1255 e = traceback_format_exc()
1256 self.logger.critical(
1257 logging_text + "Exit Exception while '{}': {}".format(step, e),
1258 exc_info=True,
1259 )
1260
1261 raise NsException(e)
1262
1263 def delete(self, session, indata, version, nsr_id, *args, **kwargs):
1264 self.logger.debug("ns.delete version={} nsr_id={}".format(version, nsr_id))
1265 # self.db.del_list({"_id": ro_task["_id"], "tasks.nsr_id.ne": nsr_id})
1266
1267 with self.write_lock:
1268 try:
1269 NsWorker.delete_db_tasks(self.db, nsr_id, None)
1270 except NsWorkerException as e:
1271 raise NsException(e)
1272
1273 return None, None, True
1274
1275 def status(self, session, indata, version, nsr_id, action_id, *args, **kwargs):
1276 # self.logger.debug("ns.status version={} nsr_id={}, action_id={} indata={}"
1277 # .format(version, nsr_id, action_id, indata))
1278 task_list = []
1279 done = 0
1280 total = 0
1281 ro_tasks = self.db.get_list("ro_tasks", {"tasks.action_id": action_id})
1282 global_status = "DONE"
1283 details = []
1284
1285 for ro_task in ro_tasks:
1286 for task in ro_task["tasks"]:
1287 if task and task["action_id"] == action_id:
1288 task_list.append(task)
1289 total += 1
1290
1291 if task["status"] == "FAILED":
1292 global_status = "FAILED"
1293 error_text = "Error at {} {}: {}".format(
1294 task["action"].lower(),
1295 task["item"],
1296 ro_task["vim_info"].get("vim_details") or "unknown",
1297 )
1298 details.append(error_text)
1299 elif task["status"] in ("SCHEDULED", "BUILD"):
1300 if global_status != "FAILED":
1301 global_status = "BUILD"
1302 else:
1303 done += 1
1304
1305 return_data = {
1306 "status": global_status,
1307 "details": ". ".join(details)
1308 if details
1309 else "progress {}/{}".format(done, total),
1310 "nsr_id": nsr_id,
1311 "action_id": action_id,
1312 "tasks": task_list,
1313 }
1314
1315 return return_data, None, True
1316
1317 def cancel(self, session, indata, version, nsr_id, action_id, *args, **kwargs):
1318 print(
1319 "ns.cancel session={} indata={} version={} nsr_id={}, action_id={}".format(
1320 session, indata, version, nsr_id, action_id
1321 )
1322 )
1323
1324 return None, None, True
1325
1326 def get_deploy(self, session, indata, version, nsr_id, action_id, *args, **kwargs):
1327 nsrs = self.db.get_list("nsrs", {})
1328 return_data = []
1329
1330 for ns in nsrs:
1331 return_data.append({"_id": ns["_id"], "name": ns["name"]})
1332
1333 return return_data, None, True
1334
1335 def get_actions(self, session, indata, version, nsr_id, action_id, *args, **kwargs):
1336 ro_tasks = self.db.get_list("ro_tasks", {"tasks.nsr_id": nsr_id})
1337 return_data = []
1338
1339 for ro_task in ro_tasks:
1340 for task in ro_task["tasks"]:
1341 if task["action_id"] not in return_data:
1342 return_data.append(task["action_id"])
1343
1344 return return_data, None, True