+++ /dev/null
-# -*- coding: utf-8 -*-
-
-##
-# Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U.
-# This file is part of openmano
-# All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-# For those usages not covered by the Apache License, Version 2.0 please
-# contact with: nfvlabs@tid.es
-##
-
-'''
-NFVO engine, implementing all the methods for the creation, deletion and management of vnfs, scenarios and instances
-'''
-__author__="Alfonso Tierno, Gerardo Garcia, Pablo Montes"
-__date__ ="$16-sep-2014 22:05:01$"
-
-# import imp
-import json
-import string
-import yaml
-from random import choice as random_choice
-from osm_ro import utils
-from osm_ro.utils import deprecated
-from osm_ro.vim_thread import vim_thread
-import osm_ro.console_proxy_thread as cli
-from osm_ro_plugin.vim_dummy import VimDummyConnector
-from osm_ro_plugin.sdn_dummy import SdnDummyConnector
-from osm_ro_plugin.sdn_failing import SdnFailingConnector
-from osm_ro_plugin import vimconn, sdnconn
-import logging
-import collections
-import math
-from uuid import uuid4
-from osm_ro.db_base import db_base_Exception
-
-from osm_ro import nfvo_db
-from threading import Lock
-import time as t
-from osm_ro.sdn import Sdn, SdnException as ovimException
-
-from Crypto.PublicKey import RSA
-
-import osm_im.vnfd as vnfd_catalog
-import osm_im.nsd as nsd_catalog
-from pyangbind.lib.serialise import pybindJSONDecoder
-from copy import deepcopy
-from pkg_resources import iter_entry_points
-
-
-# WIM
-from .http_tools import errors as httperrors
-from .wim.engine import WimEngine
-from .wim.persistence import WimPersistence
-from copy import deepcopy
-from pprint import pformat
-#
-
-global global_config
-# WIM
-global wim_engine
-wim_engine = None
-global sdnconn_imported
-#
-global logger
-global default_volume_size
-default_volume_size = '5' #size in GB
-global ovim
-ovim = None
-global_config = None
-
-plugins = {} # dictionary with VIM type as key, loaded module as value
-vim_threads = {"running":{}, "deleting": {}, "names": []} # threads running for attached-VIMs
-vim_persistent_info = {}
-# WIM
-sdnconn_imported = {} # dictionary with WIM type as key, loaded module as value
-wim_threads = {"running":{}, "deleting": {}, "names": []} # threads running for attached-WIMs
-wim_persistent_info = {}
-#
-
-logger = logging.getLogger('openmano.nfvo')
-task_lock = Lock()
-last_task_id = 0.0
-db = None
-db_lock = Lock()
-
-worker_id = None
-
-class NfvoException(httperrors.HttpMappedError):
- """Common Class for NFVO errors"""
-
-def _load_plugin(name, type="vim"):
- # type can be vim or sdn
- global plugins
- try:
- for v in iter_entry_points('osm_ro{}.plugins'.format(type), name):
- plugins[name] = v.load()
- except Exception as e:
- logger.critical("Cannot load osm_{}: {}".format(name, e))
- if name:
- plugins[name] = SdnFailingConnector("Cannot load osm_{}: {}".format(name, e))
- if name and name not in plugins:
- error_text = "Cannot load a module for {t} type '{n}'. The plugin 'osm_{n}' has not been" \
- " registered".format(t=type, n=name)
- logger.critical(error_text)
- plugins[name] = SdnFailingConnector(error_text)
- # raise NfvoException("Cannot load a module for {t} type '{n}'. The plugin 'osm_{n}' has not been registered".
- # format(t=type, n=name), httperrors.Bad_Request)
-
-def get_task_id():
- global last_task_id
- task_id = t.time()
- if task_id <= last_task_id:
- task_id = last_task_id + 0.000001
- last_task_id = task_id
- return "ACTION-{:.6f}".format(task_id)
- # return (t.strftime("%Y%m%dT%H%M%S.{}%Z", t.localtime(task_id))).format(int((task_id % 1)*1e6))
-
-
-def new_task(name, params, depends=None):
- """Deprected!!!"""
- task_id = get_task_id()
- task = {"status": "enqueued", "id": task_id, "name": name, "params": params}
- if depends:
- task["depends"] = depends
- return task
-
-
-def is_task_id(id):
- return True if id[:5] == "TASK-" else False
-
-def get_process_id():
- """
- Obtain a unique ID for this process. If running from inside docker, it will get docker ID. If not it
- will provide a random one
- :return: Obtained ID
- """
- # Try getting docker id. If fails, get pid
- try:
- with open("/proc/self/cgroup", "r") as f:
- for text_id_ in f.readlines():
- if "docker/" not in text_id_:
- continue
- _, _, text_id = text_id_.rpartition("/")
- text_id = text_id.replace("\n", "")[:12]
- if text_id:
- return text_id
- except Exception:
- pass
- # Return a random id
- return "".join(random_choice("0123456789abcdef") for _ in range(12))
-
-def get_non_used_vim_name(datacenter_name, datacenter_id):
- return "{}:{}:{}".format(
- worker_id[:12], datacenter_id.replace("-", "")[:32], datacenter_name[:16]
- )
-
-# -- Move
-def get_non_used_wim_name(wim_name, wim_id, tenant_name, tenant_id):
- name = wim_name[:16]
- if name not in wim_threads["names"]:
- wim_threads["names"].append(name)
- return name
- name = wim_name[:16] + "." + tenant_name[:16]
- if name not in wim_threads["names"]:
- wim_threads["names"].append(name)
- return name
- name = wim_id + "-" + tenant_id
- wim_threads["names"].append(name)
- return name
-
-
-def start_service(mydb, persistence=None, wim=None):
- global db, global_config, plugins, ovim, worker_id
- db = nfvo_db.nfvo_db(lock=db_lock)
- mydb.lock = db_lock
- db.connect(global_config['db_host'], global_config['db_user'], global_config['db_passwd'], global_config['db_name'])
-
- persistence = persistence or WimPersistence(db)
-
- try:
- worker_id = get_process_id()
- if "rosdn_dummy" not in plugins:
- plugins["rosdn_dummy"] = SdnDummyConnector
- if "rovim_dummy" not in plugins:
- plugins["rovim_dummy"] = VimDummyConnector
- # starts ovim library
- ovim = Sdn(db, plugins)
-
- global wim_engine
- wim_engine = wim or WimEngine(persistence, plugins)
- wim_engine.ovim = ovim
-
- ovim.start_service()
-
- #delete old unneeded vim_wim_actions
- clean_db(mydb)
-
- # starts vim_threads
- from_= 'tenants_datacenters as td join datacenters as d on td.datacenter_id=d.uuid join '\
- 'datacenter_tenants as dt on td.datacenter_tenant_id=dt.uuid'
- select_ = ('type', 'd.config as config', 'd.uuid as datacenter_id', 'vim_url', 'vim_url_admin',
- 'd.name as datacenter_name', 'dt.uuid as datacenter_tenant_id',
- 'dt.vim_tenant_name as vim_tenant_name', 'dt.vim_tenant_id as vim_tenant_id',
- 'user', 'passwd', 'dt.config as dt_config', 'nfvo_tenant_id')
- vims = mydb.get_rows(FROM=from_, SELECT=select_)
- for vim in vims:
- extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'),
- 'datacenter_id': vim.get('datacenter_id')}
- if vim["config"]:
- extra.update(yaml.load(vim["config"], Loader=yaml.Loader))
- if vim.get('dt_config'):
- extra.update(yaml.load(vim["dt_config"], Loader=yaml.Loader))
- plugin_name = "rovim_" + vim["type"]
- if plugin_name not in plugins:
- _load_plugin(plugin_name, type="vim")
-
- thread_id = vim['datacenter_tenant_id']
- vim_persistent_info[thread_id] = {}
- try:
- #if not tenant:
- # return -httperrors.Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"])
- myvim = plugins[plugin_name](
- uuid=vim['datacenter_id'], name=vim['datacenter_name'],
- tenant_id=vim['vim_tenant_id'], tenant_name=vim['vim_tenant_name'],
- url=vim['vim_url'], url_admin=vim['vim_url_admin'],
- user=vim['user'], passwd=vim['passwd'],
- config=extra, persistent_info=vim_persistent_info[thread_id]
- )
- except vimconn.VimConnException as e:
- myvim = e
- logger.error("Cannot launch thread for VIM {} '{}': {}".format(vim['datacenter_name'],
- vim['datacenter_id'], e))
- except Exception as e:
- logger.critical("Cannot launch thread for VIM {} '{}': {}".format(vim['datacenter_name'],
- vim['datacenter_id'], e))
- # raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, e),
- # httperrors.Internal_Server_Error)
- thread_name = get_non_used_vim_name(vim['datacenter_name'], vim['datacenter_id'])
- new_thread = vim_thread(task_lock, plugins, thread_name, None,
- vim['datacenter_tenant_id'], db=db)
- new_thread.start()
- vim_threads["running"][thread_id] = new_thread
- wims = mydb.get_rows(FROM="wim_accounts join wims on wim_accounts.wim_id=wims.uuid",
- WHERE={"sdn": "true"},
- SELECT=("wim_accounts.uuid as uuid", "type", "wim_accounts.name as name"))
- for wim in wims:
- plugin_name = "rosdn_" + wim["type"]
- if plugin_name not in plugins:
- _load_plugin(plugin_name, type="sdn")
-
- thread_id = wim['uuid']
- thread_name = get_non_used_vim_name(wim['name'], wim['uuid'])
- new_thread = vim_thread(task_lock, plugins, thread_name, wim['uuid'], None, db=db)
- new_thread.start()
- vim_threads["running"][thread_id] = new_thread
- wim_engine.start_threads()
- except db_base_Exception as e:
- raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code)
- except ovimException as e:
- message = str(e)
- if message[:22] == "DATABASE wrong version":
- message = "DATABASE wrong version of lib_osm_openvim {msg} -d{dbname} -u{dbuser} -p{dbpass} {ver}' "\
- "at host {dbhost}".format(
- msg=message[22:-3], dbname=global_config["db_ovim_name"],
- dbuser=global_config["db_ovim_user"], dbpass=global_config["db_ovim_passwd"],
- ver=message[-3:-1], dbhost=global_config["db_ovim_host"])
- raise NfvoException(message, httperrors.Bad_Request)
-
-
-def stop_service():
- global ovim, global_config
- if ovim:
- ovim.stop_service()
- for thread_id, thread in vim_threads["running"].items():
- thread.insert_task("exit")
- vim_threads["deleting"][thread_id] = thread
- vim_threads["running"] = {}
-
- if wim_engine:
- wim_engine.stop_threads()
-
- if global_config and global_config.get("console_thread"):
- for thread in global_config["console_thread"]:
- thread.terminate = True
-
-def get_version():
- return ("openmanod version {} {}\n(c) Copyright Telefonica".format(global_config["version"],
- global_config["version_date"] ))
-
-def clean_db(mydb):
- """
- Clean unused or old entries at database to avoid unlimited growing
- :param mydb: database connector
- :return: None
- """
- # get and delete unused vim_wim_actions: all elements deleted, one week before, instance not present
- now = t.time()-3600*24*7
- instance_action_id = None
- nb_deleted = 0
- while True:
- actions_to_delete = mydb.get_rows(
- SELECT=("item", "item_id", "instance_action_id"),
- FROM="vim_wim_actions as va join instance_actions as ia on va.instance_action_id=ia.uuid "
- "left join instance_scenarios as i on ia.instance_id=i.uuid",
- WHERE={"va.action": "DELETE", "va.modified_at<": now, "i.uuid": None,
- "va.status": ("DONE", "SUPERSEDED")},
- LIMIT=100
- )
- for to_delete in actions_to_delete:
- mydb.delete_row(FROM="vim_wim_actions", WHERE=to_delete)
- if instance_action_id != to_delete["instance_action_id"]:
- instance_action_id = to_delete["instance_action_id"]
- mydb.delete_row(FROM="instance_actions", WHERE={"uuid": instance_action_id})
- nb_deleted += len(actions_to_delete)
- if len(actions_to_delete) < 100:
- break
- # clean locks
- mydb.update_rows("vim_wim_actions", UPDATE={"worker": None}, WHERE={"worker<>": None})
-
- if nb_deleted:
- logger.debug("Removed {} unused vim_wim_actions".format(nb_deleted))
-
-
-def get_flavorlist(mydb, vnf_id, nfvo_tenant=None):
- '''Obtain flavorList
- return result, content:
- <0, error_text upon error
- nb_records, flavor_list on success
- '''
- WHERE_dict={}
- WHERE_dict['vnf_id'] = vnf_id
- if nfvo_tenant is not None:
- WHERE_dict['nfvo_tenant_id'] = nfvo_tenant
-
- #result, content = mydb.get_table(FROM='vms join vnfs on vms.vnf_id = vnfs.uuid',SELECT=('uuid'),WHERE=WHERE_dict )
- #result, content = mydb.get_table(FROM='vms',SELECT=('vim_flavor_id',),WHERE=WHERE_dict )
- flavors = mydb.get_rows(FROM='vms join flavors on vms.flavor_id=flavors.uuid',SELECT=('flavor_id',),WHERE=WHERE_dict )
- #print "get_flavor_list result:", result
- #print "get_flavor_list content:", content
- flavorList=[]
- for flavor in flavors:
- flavorList.append(flavor['flavor_id'])
- return flavorList
-
-
-def get_imagelist(mydb, vnf_id, nfvo_tenant=None):
- """
- Get used images of all vms belonging to this VNFD
- :param mydb: database conector
- :param vnf_id: vnfd uuid
- :param nfvo_tenant: tenant, not used
- :return: The list of image uuid used
- """
- image_list = []
- vms = mydb.get_rows(SELECT=('image_id','image_list'), FROM='vms', WHERE={'vnf_id': vnf_id})
- for vm in vms:
- if vm["image_id"] and vm["image_id"] not in image_list:
- image_list.append(vm["image_id"])
- if vm["image_list"]:
- vm_image_list = yaml.load(vm["image_list"], Loader=yaml.Loader)
- for image_dict in vm_image_list:
- if image_dict["image_id"] not in image_list:
- image_list.append(image_dict["image_id"])
- return image_list
-
-
-def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, datacenter_tenant_id=None,
- vim_tenant=None, vim_tenant_name=None, vim_user=None, vim_passwd=None, ignore_errors=False):
- '''Obtain a dictionary of VIM (datacenter) classes with some of the input parameters
- return dictionary with {datacenter_id: vim_class, ... }. vim_class contain:
- 'nfvo_tenant_id','datacenter_id','vim_tenant_id','vim_url','vim_url_admin','datacenter_name','type','user','passwd'
- raise exception upon error
- '''
- global plugins
- WHERE_dict={}
- if nfvo_tenant is not None: WHERE_dict['nfvo_tenant_id'] = nfvo_tenant
- if datacenter_id is not None: WHERE_dict['d.uuid'] = datacenter_id
- if datacenter_tenant_id is not None: WHERE_dict['datacenter_tenant_id'] = datacenter_tenant_id
- if datacenter_name is not None: WHERE_dict['d.name'] = datacenter_name
- if vim_tenant is not None: WHERE_dict['dt.vim_tenant_id'] = vim_tenant
- if vim_tenant_name is not None: WHERE_dict['vim_tenant_name'] = vim_tenant_name
- if nfvo_tenant or vim_tenant or vim_tenant_name or datacenter_tenant_id:
- from_= 'tenants_datacenters as td join datacenters as d on td.datacenter_id=d.uuid join datacenter_tenants as dt on td.datacenter_tenant_id=dt.uuid'
- select_ = ('type','d.config as config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name',
- 'dt.uuid as datacenter_tenant_id','dt.vim_tenant_name as vim_tenant_name','dt.vim_tenant_id as vim_tenant_id',
- 'user','passwd', 'dt.config as dt_config')
- else:
- from_ = 'datacenters as d'
- select_ = ('type','config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name')
- try:
- vims = mydb.get_rows(FROM=from_, SELECT=select_, WHERE=WHERE_dict )
- vim_dict={}
- for vim in vims:
- extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'),
- 'datacenter_id': vim.get('datacenter_id'),
- '_vim_type_internal': vim.get('type')}
- if vim["config"]:
- extra.update(yaml.load(vim["config"], Loader=yaml.Loader))
- if vim.get('dt_config'):
- extra.update(yaml.load(vim["dt_config"], Loader=yaml.Loader))
- plugin_name = "rovim_" + vim["type"]
- if plugin_name not in plugins:
- try:
- _load_plugin(plugin_name, type="vim")
- except NfvoException as e:
- if ignore_errors:
- logger.error("{}".format(e))
- continue
- else:
- raise
- try:
- if 'datacenter_tenant_id' in vim:
- thread_id = vim["datacenter_tenant_id"]
- if thread_id not in vim_persistent_info:
- vim_persistent_info[thread_id] = {}
- persistent_info = vim_persistent_info[thread_id]
- else:
- persistent_info = {}
- #if not tenant:
- # return -httperrors.Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"])
- vim_dict[vim['datacenter_id']] = plugins[plugin_name](
- uuid=vim['datacenter_id'], name=vim['datacenter_name'],
- tenant_id=vim.get('vim_tenant_id',vim_tenant),
- tenant_name=vim.get('vim_tenant_name',vim_tenant_name),
- url=vim['vim_url'], url_admin=vim['vim_url_admin'],
- user=vim.get('user',vim_user), passwd=vim.get('passwd',vim_passwd),
- config=extra, persistent_info=persistent_info
- )
- except Exception as e:
- if ignore_errors:
- logger.error("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)))
- continue
- http_code = httperrors.Internal_Server_Error
- if isinstance(e, vimconn.VimConnException):
- http_code = e.http_code
- raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)), http_code)
- return vim_dict
- except db_base_Exception as e:
- raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code)
-
-
-def rollback(mydb, vims, rollback_list):
- undeleted_items=[]
- #delete things by reverse order
- for i in range(len(rollback_list)-1, -1, -1):
- item = rollback_list[i]
- if item["where"]=="vim":
- if item["vim_id"] not in vims:
- continue
- if is_task_id(item["uuid"]):
- continue
- vim = vims[item["vim_id"]]
- try:
- if item["what"]=="image":
- vim.delete_image(item["uuid"])
- mydb.delete_row(FROM="datacenters_images", WHERE={"datacenter_vim_id": vim["id"], "vim_id":item["uuid"]})
- elif item["what"]=="flavor":
- vim.delete_flavor(item["uuid"])
- mydb.delete_row(FROM="datacenters_flavors", WHERE={"datacenter_vim_id": vim["id"], "vim_id":item["uuid"]})
- elif item["what"]=="network":
- vim.delete_network(item["uuid"])
- elif item["what"]=="vm":
- vim.delete_vminstance(item["uuid"])
- except vimconn.VimConnException as e:
- logger.error("Error in rollback. Not possible to delete VIM %s '%s'. Message: %s", item['what'], item["uuid"], str(e))
- undeleted_items.append("{} {} from VIM {}".format(item['what'], item["uuid"], vim["name"]))
- except db_base_Exception as e:
- logger.error("Error in rollback. Not possible to delete %s '%s' from DB.datacenters Message: %s", item['what'], item["uuid"], str(e))
-
- else: # where==mano
- try:
- if item["what"]=="image":
- mydb.delete_row(FROM="images", WHERE={"uuid": item["uuid"]})
- elif item["what"]=="flavor":
- mydb.delete_row(FROM="flavors", WHERE={"uuid": item["uuid"]})
- except db_base_Exception as e:
- logger.error("Error in rollback. Not possible to delete %s '%s' from DB. Message: %s", item['what'], item["uuid"], str(e))
- undeleted_items.append("{} '{}'".format(item['what'], item["uuid"]))
- if len(undeleted_items)==0:
- return True, "Rollback successful."
- else:
- return False, "Rollback fails to delete: " + str(undeleted_items)
-
-
-def check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=1):
- global global_config
- #create a dictionary with vnfc-name: vnfc:interface-list key:values pairs
- vnfc_interfaces={}
- for vnfc in vnf_descriptor["vnf"]["VNFC"]:
- name_dict = {}
- #dataplane interfaces
- for numa in vnfc.get("numas",() ):
- for interface in numa.get("interfaces",()):
- if interface["name"] in name_dict:
- raise NfvoException(
- "Error at vnf:VNFC[name:'{}']:numas:interfaces:name, interface name '{}' already used in this VNFC".format(
- vnfc["name"], interface["name"]),
- httperrors.Bad_Request)
- name_dict[ interface["name"] ] = "underlay"
- #bridge interfaces
- for interface in vnfc.get("bridge-ifaces",() ):
- if interface["name"] in name_dict:
- raise NfvoException(
- "Error at vnf:VNFC[name:'{}']:bridge-ifaces:name, interface name '{}' already used in this VNFC".format(
- vnfc["name"], interface["name"]),
- httperrors.Bad_Request)
- name_dict[ interface["name"] ] = "overlay"
- vnfc_interfaces[ vnfc["name"] ] = name_dict
- # check bood-data info
- # if "boot-data" in vnfc:
- # # check that user-data is incompatible with users and config-files
- # if (vnfc["boot-data"].get("users") or vnfc["boot-data"].get("config-files")) and vnfc["boot-data"].get("user-data"):
- # raise NfvoException(
- # "Error at vnf:VNFC:boot-data, fields 'users' and 'config-files' are not compatible with 'user-data'",
- # httperrors.Bad_Request)
-
- #check if the info in external_connections matches with the one in the vnfcs
- name_list=[]
- for external_connection in vnf_descriptor["vnf"].get("external-connections",() ):
- if external_connection["name"] in name_list:
- raise NfvoException(
- "Error at vnf:external-connections:name, value '{}' already used as an external-connection".format(
- external_connection["name"]),
- httperrors.Bad_Request)
- name_list.append(external_connection["name"])
- if external_connection["VNFC"] not in vnfc_interfaces:
- raise NfvoException(
- "Error at vnf:external-connections[name:'{}']:VNFC, value '{}' does not match any VNFC".format(
- external_connection["name"], external_connection["VNFC"]),
- httperrors.Bad_Request)
-
- if external_connection["local_iface_name"] not in vnfc_interfaces[ external_connection["VNFC"] ]:
- raise NfvoException(
- "Error at vnf:external-connections[name:'{}']:local_iface_name, value '{}' does not match any interface of this VNFC".format(
- external_connection["name"],
- external_connection["local_iface_name"]),
- httperrors.Bad_Request )
-
- #check if the info in internal_connections matches with the one in the vnfcs
- name_list=[]
- for internal_connection in vnf_descriptor["vnf"].get("internal-connections",() ):
- if internal_connection["name"] in name_list:
- raise NfvoException(
- "Error at vnf:internal-connections:name, value '{}' already used as an internal-connection".format(
- internal_connection["name"]),
- httperrors.Bad_Request)
- name_list.append(internal_connection["name"])
- #We should check that internal-connections of type "ptp" have only 2 elements
-
- if len(internal_connection["elements"])>2 and (internal_connection.get("type") == "ptp" or internal_connection.get("type") == "e-line"):
- raise NfvoException(
- "Error at 'vnf:internal-connections[name:'{}']:elements', size must be 2 for a '{}' type. Consider change it to '{}' type".format(
- internal_connection["name"],
- 'ptp' if vnf_descriptor_version==1 else 'e-line',
- 'data' if vnf_descriptor_version==1 else "e-lan"),
- httperrors.Bad_Request)
- for port in internal_connection["elements"]:
- vnf = port["VNFC"]
- iface = port["local_iface_name"]
- if vnf not in vnfc_interfaces:
- raise NfvoException(
- "Error at vnf:internal-connections[name:'{}']:elements[]:VNFC, value '{}' does not match any VNFC".format(
- internal_connection["name"], vnf),
- httperrors.Bad_Request)
- if iface not in vnfc_interfaces[ vnf ]:
- raise NfvoException(
- "Error at vnf:internal-connections[name:'{}']:elements[]:local_iface_name, value '{}' does not match any interface of this VNFC".format(
- internal_connection["name"], iface),
- httperrors.Bad_Request)
- return -httperrors.Bad_Request,
- if vnf_descriptor_version==1 and "type" not in internal_connection:
- if vnfc_interfaces[vnf][iface] == "overlay":
- internal_connection["type"] = "bridge"
- else:
- internal_connection["type"] = "data"
- if vnf_descriptor_version==2 and "implementation" not in internal_connection:
- if vnfc_interfaces[vnf][iface] == "overlay":
- internal_connection["implementation"] = "overlay"
- else:
- internal_connection["implementation"] = "underlay"
- if (internal_connection.get("type") == "data" or internal_connection.get("type") == "ptp" or \
- internal_connection.get("implementation") == "underlay") and vnfc_interfaces[vnf][iface] == "overlay":
- raise NfvoException(
- "Error at vnf:internal-connections[name:'{}']:elements[]:{}, interface of type {} connected to an {} network".format(
- internal_connection["name"],
- iface, 'bridge' if vnf_descriptor_version==1 else 'overlay',
- 'data' if vnf_descriptor_version==1 else 'underlay'),
- httperrors.Bad_Request)
- if (internal_connection.get("type") == "bridge" or internal_connection.get("implementation") == "overlay") and \
- vnfc_interfaces[vnf][iface] == "underlay":
- raise NfvoException(
- "Error at vnf:internal-connections[name:'{}']:elements[]:{}, interface of type {} connected to an {} network".format(
- internal_connection["name"], iface,
- 'data' if vnf_descriptor_version==1 else 'underlay',
- 'bridge' if vnf_descriptor_version==1 else 'overlay'),
- httperrors.Bad_Request)
-
-
-def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error=None):
- #look if image exist
- if only_create_at_vim:
- image_mano_id = image_dict['uuid']
- if return_on_error == None:
- return_on_error = True
- else:
- if image_dict['location']:
- images = mydb.get_rows(FROM="images", WHERE={'location':image_dict['location'], 'metadata':image_dict['metadata']})
- else:
- images = mydb.get_rows(FROM="images", WHERE={'universal_name':image_dict['universal_name'], 'checksum':image_dict['checksum']})
- if len(images)>=1:
- image_mano_id = images[0]['uuid']
- else:
- #create image in MANO DB
- temp_image_dict={'name':image_dict['name'], 'description':image_dict.get('description',None),
- 'location':image_dict['location'], 'metadata':image_dict.get('metadata',None),
- 'universal_name':image_dict['universal_name'] , 'checksum':image_dict['checksum']
- }
- #temp_image_dict['location'] = image_dict.get('new_location') if image_dict['location'] is None
- image_mano_id = mydb.new_row('images', temp_image_dict, add_uuid=True)
- rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id})
- #create image at every vim
- for vim_id,vim in vims.items():
- datacenter_vim_id = vim["config"]["datacenter_tenant_id"]
- image_created="false"
- #look at database
- image_db = mydb.get_rows(FROM="datacenters_images",
- WHERE={'datacenter_vim_id': datacenter_vim_id, 'image_id': image_mano_id})
- #look at VIM if this image exist
- try:
- if image_dict['location'] is not None:
- image_vim_id = vim.get_image_id_from_path(image_dict['location'])
- else:
- filter_dict = {}
- filter_dict['name'] = image_dict['universal_name']
- if image_dict.get('checksum') != None:
- filter_dict['checksum'] = image_dict['checksum']
- #logger.debug('>>>>>>>> Filter dict: %s', str(filter_dict))
- vim_images = vim.get_image_list(filter_dict)
- #logger.debug('>>>>>>>> VIM images: %s', str(vim_images))
- if len(vim_images) > 1:
- raise vimconn.VimConnException("More than one candidate VIM image found for filter: {}".format(str(filter_dict)), httperrors.Conflict)
- elif len(vim_images) == 0:
- raise vimconn.VimConnNotFoundException("Image not found at VIM with filter: '{}'".format(str(filter_dict)))
- else:
- #logger.debug('>>>>>>>> VIM image 0: %s', str(vim_images[0]))
- image_vim_id = vim_images[0]['id']
-
- except vimconn.VimConnNotFoundException as e:
- #Create the image in VIM only if image_dict['location'] or image_dict['new_location'] is not None
- try:
- #image_dict['location']=image_dict.get('new_location') if image_dict['location'] is None
- if image_dict['location']:
- image_vim_id = vim.new_image(image_dict)
- rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"image","uuid":image_vim_id})
- image_created="true"
- else:
- #If we reach this point, then the image has image name, and optionally checksum, and could not be found
- raise vimconn.VimConnException(str(e))
- except vimconn.VimConnException as e:
- if return_on_error:
- logger.error("Error creating image at VIM '%s': %s", vim["name"], str(e))
- raise
- image_vim_id = None
- logger.warn("Error creating image at VIM '%s': %s", vim["name"], str(e))
- continue
- except vimconn.VimConnException as e:
- if return_on_error:
- logger.error("Error contacting VIM to know if the image exists at VIM: %s", str(e))
- raise
- logger.warn("Error contacting VIM to know if the image exists at VIM: %s", str(e))
- image_vim_id = None
- continue
- #if we reach here, the image has been created or existed
- if len(image_db)==0:
- #add new vim_id at datacenters_images
- mydb.new_row('datacenters_images', {'datacenter_vim_id': datacenter_vim_id,
- 'image_id':image_mano_id,
- 'vim_id': image_vim_id,
- 'created':image_created})
- elif image_db[0]["vim_id"]!=image_vim_id:
- #modify existing vim_id at datacenters_images
- mydb.update_rows('datacenters_images', UPDATE={'vim_id':image_vim_id}, WHERE={'datacenter_vim_id':vim_id, 'image_id':image_mano_id})
-
- return image_vim_id if only_create_at_vim else image_mano_id
-
-
-def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_vim=False, return_on_error = None):
- temp_flavor_dict= {'disk':flavor_dict.get('disk',0),
- 'ram':flavor_dict.get('ram'),
- 'vcpus':flavor_dict.get('vcpus'),
- }
- if 'extended' in flavor_dict and flavor_dict['extended']==None:
- del flavor_dict['extended']
- if 'extended' in flavor_dict:
- temp_flavor_dict['extended']=yaml.safe_dump(flavor_dict['extended'],default_flow_style=True,width=256)
-
- #look if flavor exist
- if only_create_at_vim:
- flavor_mano_id = flavor_dict['uuid']
- if return_on_error == None:
- return_on_error = True
- else:
- flavors = mydb.get_rows(FROM="flavors", WHERE=temp_flavor_dict)
- if len(flavors)>=1:
- flavor_mano_id = flavors[0]['uuid']
- else:
- #create flavor
- #create one by one the images of aditional disks
- dev_image_list=[] #list of images
- if 'extended' in flavor_dict and flavor_dict['extended']!=None:
- dev_nb=0
- for device in flavor_dict['extended'].get('devices',[]):
- if "image" not in device and "image name" not in device:
- continue
- image_dict={}
- image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img")
- image_dict['universal_name']=device.get('image name')
- image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img"
- image_dict['location']=device.get('image')
- #image_dict['new_location']=vnfc.get('image location')
- image_dict['checksum']=device.get('image checksum')
- image_metadata_dict = device.get('image metadata', None)
- image_metadata_str = None
- if image_metadata_dict != None:
- image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
- image_dict['metadata']=image_metadata_str
- image_id = create_or_use_image(mydb, vims, image_dict, rollback_list)
- #print "Additional disk image id for VNFC %s: %s" % (flavor_dict['name']+str(dev_nb)+"-img", image_id)
- dev_image_list.append(image_id)
- dev_nb += 1
- temp_flavor_dict['name'] = flavor_dict['name']
- temp_flavor_dict['description'] = flavor_dict.get('description',None)
- content = mydb.new_row('flavors', temp_flavor_dict, add_uuid=True)
- flavor_mano_id= content
- rollback_list.append({"where":"mano", "what":"flavor","uuid":flavor_mano_id})
- #create flavor at every vim
- if 'uuid' in flavor_dict:
- del flavor_dict['uuid']
- flavor_vim_id=None
- for vim_id,vim in vims.items():
- datacenter_vim_id = vim["config"]["datacenter_tenant_id"]
- flavor_created="false"
- #look at database
- flavor_db = mydb.get_rows(FROM="datacenters_flavors",
- WHERE={'datacenter_vim_id': datacenter_vim_id, 'flavor_id': flavor_mano_id})
- #look at VIM if this flavor exist SKIPPED
- #res_vim, flavor_vim_id = vim.get_flavor_id_from_path(flavor_dict['location'])
- #if res_vim < 0:
- # print "Error contacting VIM to know if the flavor %s existed previously." %flavor_vim_id
- # continue
- #elif res_vim==0:
-
- # Create the flavor in VIM
- # Translate images at devices from MANO id to VIM id
- disk_list = []
- if 'extended' in flavor_dict and flavor_dict['extended']!=None and "devices" in flavor_dict['extended']:
- # make a copy of original devices
- devices_original=[]
-
- for device in flavor_dict["extended"].get("devices",[]):
- dev={}
- dev.update(device)
- devices_original.append(dev)
- if 'image' in device:
- del device['image']
- if 'image metadata' in device:
- del device['image metadata']
- if 'image checksum' in device:
- del device['image checksum']
- dev_nb = 0
- for index in range(0,len(devices_original)) :
- device=devices_original[index]
- if "image" not in device and "image name" not in device:
- # if 'size' in device:
- disk_list.append({'size': device.get('size', default_volume_size), 'name': device.get('name')})
- continue
- image_dict={}
- image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img")
- image_dict['universal_name']=device.get('image name')
- image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img"
- image_dict['location']=device.get('image')
- # image_dict['new_location']=device.get('image location')
- image_dict['checksum']=device.get('image checksum')
- image_metadata_dict = device.get('image metadata', None)
- image_metadata_str = None
- if image_metadata_dict != None:
- image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
- image_dict['metadata']=image_metadata_str
- image_mano_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error=return_on_error )
- image_dict["uuid"]=image_mano_id
- image_vim_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=True, return_on_error=return_on_error)
-
- #save disk information (image must be based on and size
- disk_list.append({'image_id': image_vim_id, 'size': device.get('size', default_volume_size)})
-
- flavor_dict["extended"]["devices"][index]['imageRef']=image_vim_id
- dev_nb += 1
- if len(flavor_db)>0:
- #check that this vim_id exist in VIM, if not create
- flavor_vim_id=flavor_db[0]["vim_id"]
- try:
- vim.get_flavor(flavor_vim_id)
- continue #flavor exist
- except vimconn.VimConnException:
- pass
- #create flavor at vim
- logger.debug("nfvo.create_or_use_flavor() adding flavor to VIM %s", vim["name"])
- try:
- flavor_vim_id = None
- flavor_vim_id=vim.get_flavor_id_from_data(flavor_dict)
- flavor_created="false"
- except vimconn.VimConnException as e:
- pass
- try:
- if not flavor_vim_id:
- flavor_vim_id = vim.new_flavor(flavor_dict)
- rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"flavor","uuid":flavor_vim_id})
- flavor_created="true"
- except vimconn.VimConnException as e:
- if return_on_error:
- logger.error("Error creating flavor at VIM %s: %s.", vim["name"], str(e))
- raise
- logger.warn("Error creating flavor at VIM %s: %s.", vim["name"], str(e))
- flavor_vim_id = None
- continue
- #if reach here the flavor has been create or exist
- if len(flavor_db)==0:
- #add new vim_id at datacenters_flavors
- extended_devices_yaml = None
- if len(disk_list) > 0:
- extended_devices = dict()
- extended_devices['disks'] = disk_list
- extended_devices_yaml = yaml.safe_dump(extended_devices,default_flow_style=True,width=256)
- mydb.new_row('datacenters_flavors',
- {'datacenter_vim_id': datacenter_vim_id, 'flavor_id': flavor_mano_id, 'vim_id': flavor_vim_id,
- 'created': flavor_created, 'extended': extended_devices_yaml})
- elif flavor_db[0]["vim_id"]!=flavor_vim_id:
- #modify existing vim_id at datacenters_flavors
- mydb.update_rows('datacenters_flavors', UPDATE={'vim_id':flavor_vim_id},
- WHERE={'datacenter_vim_id': datacenter_vim_id, 'flavor_id': flavor_mano_id})
-
- return flavor_vim_id if only_create_at_vim else flavor_mano_id
-
-
-def get_str(obj, field, length):
- """
- Obtain the str value,
- :param obj:
- :param length:
- :return:
- """
- value = obj.get(field)
- if value is not None:
- value = str(value)[:length]
- return value
-
-def _lookfor_or_create_image(db_image, mydb, descriptor):
- """
- fill image content at db_image dictionary. Check if the image with this image and checksum exist
- :param db_image: dictionary to insert data
- :param mydb: database connector
- :param descriptor: yang descriptor
- :return: uuid if the image exist at DB, or None if a new image must be created with the data filled at db_image
- """
-
- db_image["name"] = get_str(descriptor, "image", 255)
- db_image["checksum"] = get_str(descriptor, "image-checksum", 32)
- if not db_image["checksum"]: # Ensure that if empty string, None is stored
- db_image["checksum"] = None
- if db_image["name"].startswith("/"):
- db_image["location"] = db_image["name"]
- existing_images = mydb.get_rows(FROM="images", WHERE={'location': db_image["location"]})
- else:
- db_image["universal_name"] = db_image["name"]
- existing_images = mydb.get_rows(FROM="images", WHERE={'universal_name': db_image['universal_name'],
- 'checksum': db_image['checksum']})
- if existing_images:
- return existing_images[0]["uuid"]
- else:
- image_uuid = str(uuid4())
- db_image["uuid"] = image_uuid
- return None
-
-def get_resource_allocation_params(quota_descriptor):
- """
- read the quota_descriptor from vnfd and fetch the resource allocation properties from the descriptor object
- :param quota_descriptor: cpu/mem/vif/disk-io quota descriptor
- :return: quota params for limit, reserve, shares from the descriptor object
- """
- quota = {}
- if quota_descriptor.get("limit"):
- quota["limit"] = int(quota_descriptor["limit"])
- if quota_descriptor.get("reserve"):
- quota["reserve"] = int(quota_descriptor["reserve"])
- if quota_descriptor.get("shares"):
- quota["shares"] = int(quota_descriptor["shares"])
- return quota
-
-def new_vnfd_v3(mydb, tenant_id, vnf_descriptor):
- """
- Parses an OSM IM vnfd_catalog and insert at DB
- :param mydb:
- :param tenant_id:
- :param vnf_descriptor:
- :return: The list of cretated vnf ids
- """
- try:
- myvnfd = vnfd_catalog.vnfd()
- try:
- pybindJSONDecoder.load_ietf_json(vnf_descriptor, None, None, obj=myvnfd, path_helper=True,
- skip_unknown=True)
- except Exception as e:
- raise NfvoException("Error. Invalid VNF descriptor format " + str(e), httperrors.Bad_Request)
- db_vnfs = []
- db_nets = []
- db_vms = []
- db_vms_index = 0
- db_interfaces = []
- db_images = []
- db_flavors = []
- db_ip_profiles_index = 0
- db_ip_profiles = []
- uuid_list = []
- vnfd_uuid_list = []
- vnfd_catalog_descriptor = vnf_descriptor.get("vnfd:vnfd-catalog")
- if not vnfd_catalog_descriptor:
- vnfd_catalog_descriptor = vnf_descriptor.get("vnfd-catalog")
- vnfd_descriptor_list = vnfd_catalog_descriptor.get("vnfd")
- if not vnfd_descriptor_list:
- vnfd_descriptor_list = vnfd_catalog_descriptor.get("vnfd:vnfd")
- for vnfd_yang in myvnfd.vnfd_catalog.vnfd.values():
- vnfd = vnfd_yang.get()
-
- # table vnf
- vnf_uuid = str(uuid4())
- uuid_list.append(vnf_uuid)
- vnfd_uuid_list.append(vnf_uuid)
- vnfd_id = get_str(vnfd, "id", 255)
- db_vnf = {
- "uuid": vnf_uuid,
- "osm_id": vnfd_id,
- "name": get_str(vnfd, "name", 255),
- "description": get_str(vnfd, "description", 255),
- "tenant_id": tenant_id,
- "vendor": get_str(vnfd, "vendor", 255),
- "short_name": get_str(vnfd, "short-name", 255),
- "descriptor": str(vnf_descriptor)[:60000]
- }
-
- for vnfd_descriptor in vnfd_descriptor_list:
- if vnfd_descriptor["id"] == str(vnfd["id"]):
- break
-
- # table ip_profiles (ip-profiles)
- ip_profile_name2db_table_index = {}
- for ip_profile in vnfd.get("ip-profiles").values():
- db_ip_profile = {
- "ip_version": str(ip_profile["ip-profile-params"].get("ip-version", "ipv4")),
- "subnet_address": str(ip_profile["ip-profile-params"].get("subnet-address")),
- "gateway_address": str(ip_profile["ip-profile-params"].get("gateway-address")),
- "dhcp_enabled": str(ip_profile["ip-profile-params"]["dhcp-params"].get("enabled", True)),
- "dhcp_start_address": str(ip_profile["ip-profile-params"]["dhcp-params"].get("start-address")),
- "dhcp_count": str(ip_profile["ip-profile-params"]["dhcp-params"].get("count")),
- }
- dns_list = []
- for dns in ip_profile["ip-profile-params"]["dns-server"].values():
- dns_list.append(str(dns.get("address")))
- db_ip_profile["dns_address"] = ";".join(dns_list)
- if ip_profile["ip-profile-params"].get('security-group'):
- db_ip_profile["security_group"] = ip_profile["ip-profile-params"]['security-group']
- ip_profile_name2db_table_index[str(ip_profile["name"])] = db_ip_profiles_index
- db_ip_profiles_index += 1
- db_ip_profiles.append(db_ip_profile)
-
- # table nets (internal-vld)
- net_id2uuid = {} # for mapping interface with network
- net_id2index = {} # for mapping interface with network
- for vld in vnfd.get("internal-vld").values():
- net_uuid = str(uuid4())
- uuid_list.append(net_uuid)
- db_net = {
- "name": get_str(vld, "name", 255),
- "vnf_id": vnf_uuid,
- "uuid": net_uuid,
- "description": get_str(vld, "description", 255),
- "osm_id": get_str(vld, "id", 255),
- "type": "bridge", # TODO adjust depending on connection point type
- }
- net_id2uuid[vld.get("id")] = net_uuid
- net_id2index[vld.get("id")] = len(db_nets)
- db_nets.append(db_net)
- # ip-profile, link db_ip_profile with db_sce_net
- if vld.get("ip-profile-ref"):
- ip_profile_name = vld.get("ip-profile-ref")
- if ip_profile_name not in ip_profile_name2db_table_index:
- raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{}]':'vld[{}]':'ip-profile-ref':"
- "'{}'. Reference to a non-existing 'ip_profiles'".format(
- str(vnfd["id"]), str(vld["id"]), str(vld["ip-profile-ref"])),
- httperrors.Bad_Request)
- db_ip_profiles[ip_profile_name2db_table_index[ip_profile_name]]["net_id"] = net_uuid
- else: #check no ip-address has been defined
- for icp in vld.get("internal-connection-point").values():
- if icp.get("ip-address"):
- raise NfvoException("Error at 'vnfd[{}]':'vld[{}]':'internal-connection-point[{}]' "
- "contains an ip-address but no ip-profile has been defined at VLD".format(
- str(vnfd["id"]), str(vld["id"]), str(icp["id"])),
- httperrors.Bad_Request)
-
- # connection points vaiable declaration
- cp_name2iface_uuid = {}
- cp_name2vdu_id = {}
- cp_name2vm_uuid = {}
- cp_name2db_interface = {}
- vdu_id2cp_name = {} # stored only when one external connection point is presented at this VDU
-
- # table vms (vdus)
- vdu_id2uuid = {}
- vdu_id2db_table_index = {}
- mgmt_access = {}
- for vdu in vnfd.get("vdu").values():
-
- for vdu_descriptor in vnfd_descriptor["vdu"]:
- if vdu_descriptor["id"] == str(vdu["id"]):
- break
- vm_uuid = str(uuid4())
- uuid_list.append(vm_uuid)
- vdu_id = get_str(vdu, "id", 255)
- db_vm = {
- "uuid": vm_uuid,
- "osm_id": vdu_id,
- "name": get_str(vdu, "name", 255),
- "description": get_str(vdu, "description", 255),
- "pdu_type": get_str(vdu, "pdu-type", 255),
- "vnf_id": vnf_uuid,
- }
- vdu_id2uuid[db_vm["osm_id"]] = vm_uuid
- vdu_id2db_table_index[db_vm["osm_id"]] = db_vms_index
- if vdu.get("count"):
- db_vm["count"] = int(vdu["count"])
-
- # table image
- image_present = False
- if vdu.get("image"):
- image_present = True
- db_image = {}
- image_uuid = _lookfor_or_create_image(db_image, mydb, vdu)
- if not image_uuid:
- image_uuid = db_image["uuid"]
- db_images.append(db_image)
- db_vm["image_id"] = image_uuid
- if vdu.get("alternative-images"):
- vm_alternative_images = []
- for alt_image in vdu.get("alternative-images").values():
- db_image = {}
- image_uuid = _lookfor_or_create_image(db_image, mydb, alt_image)
- if not image_uuid:
- image_uuid = db_image["uuid"]
- db_images.append(db_image)
- vm_alternative_images.append({
- "image_id": image_uuid,
- "vim_type": str(alt_image["vim-type"]),
- # "universal_name": str(alt_image["image"]),
- # "checksum": str(alt_image["image-checksum"]) if alt_image.get("image-checksum") else None
- })
-
- db_vm["image_list"] = yaml.safe_dump(vm_alternative_images, default_flow_style=True, width=256)
-
- # volumes
- devices = []
- if vdu.get("volumes"):
- for volume_key in vdu["volumes"]:
- volume = vdu["volumes"][volume_key]
- if not image_present:
- # Convert the first volume to vnfc.image
- image_present = True
- db_image = {}
- image_uuid = _lookfor_or_create_image(db_image, mydb, volume)
- if not image_uuid:
- image_uuid = db_image["uuid"]
- db_images.append(db_image)
- db_vm["image_id"] = image_uuid
- else:
- # Add Openmano devices
- device = {"name": str(volume.get("name"))}
- device["type"] = str(volume.get("device-type"))
- if volume.get("size"):
- device["size"] = int(volume["size"])
- if volume.get("image"):
- device["image name"] = str(volume["image"])
- if volume.get("image-checksum"):
- device["image checksum"] = str(volume["image-checksum"])
-
- devices.append(device)
-
- if not db_vm.get("image_id"):
- if not db_vm["pdu_type"]:
- raise NfvoException("Not defined image for VDU")
- # create a fake image
-
- # cloud-init
- boot_data = {}
- if vdu.get("cloud-init"):
- boot_data["user-data"] = str(vdu["cloud-init"])
- elif vdu.get("cloud-init-file"):
- # TODO Where this file content is present???
- # boot_data["user-data"] = vnfd_yang.files[vdu["cloud-init-file"]]
- boot_data["user-data"] = str(vdu["cloud-init-file"])
-
- if vdu.get("supplemental-boot-data"):
- if vdu["supplemental-boot-data"].get('boot-data-drive'):
- boot_data['boot-data-drive'] = True
- if vdu["supplemental-boot-data"].get('config-file'):
- om_cfgfile_list = list()
- for custom_config_file in vdu["supplemental-boot-data"]['config-file'].values():
- # TODO Where this file content is present???
- cfg_source = str(custom_config_file["source"])
- om_cfgfile_list.append({"dest": custom_config_file["dest"],
- "content": cfg_source})
- boot_data['config-files'] = om_cfgfile_list
- if boot_data:
- db_vm["boot_data"] = yaml.safe_dump(boot_data, default_flow_style=True, width=256)
-
- db_vms.append(db_vm)
- db_vms_index += 1
-
- # table interfaces (internal/external interfaces)
- flavor_epa_interfaces = []
- # for iface in chain(vdu.get("internal-interface").values(), vdu.get("external-interface").values()):
- for iface in vdu.get("interface").values():
- flavor_epa_interface = {}
- iface_uuid = str(uuid4())
- uuid_list.append(iface_uuid)
- db_interface = {
- "uuid": iface_uuid,
- "internal_name": get_str(iface, "name", 255),
- "vm_id": vm_uuid,
- }
- flavor_epa_interface["name"] = db_interface["internal_name"]
- if iface.get("virtual-interface").get("vpci"):
- db_interface["vpci"] = get_str(iface.get("virtual-interface"), "vpci", 12)
- flavor_epa_interface["vpci"] = db_interface["vpci"]
-
- if iface.get("virtual-interface").get("bandwidth"):
- bps = int(iface.get("virtual-interface").get("bandwidth"))
- db_interface["bw"] = int(math.ceil(bps / 1000000.0))
- flavor_epa_interface["bandwidth"] = "{} Mbps".format(db_interface["bw"])
-
- if iface.get("virtual-interface").get("type") == "OM-MGMT":
- db_interface["type"] = "mgmt"
- elif iface.get("virtual-interface").get("type") in ("VIRTIO", "E1000", "PARAVIRT"):
- db_interface["type"] = "bridge"
- db_interface["model"] = get_str(iface.get("virtual-interface"), "type", 12)
- elif iface.get("virtual-interface").get("type") in ("SR-IOV", "PCI-PASSTHROUGH"):
- db_interface["type"] = "data"
- db_interface["model"] = get_str(iface.get("virtual-interface"), "type", 12)
- flavor_epa_interface["dedicated"] = "no" if iface["virtual-interface"]["type"] == "SR-IOV" \
- else "yes"
- flavor_epa_interfaces.append(flavor_epa_interface)
- else:
- raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{}]':'vdu[{}]':'interface':'virtual"
- "-interface':'type':'{}'. Interface type is not supported".format(
- vnfd_id, vdu_id, iface.get("virtual-interface").get("type")),
- httperrors.Bad_Request)
-
- if iface.get("mgmt-interface"):
- db_interface["type"] = "mgmt"
-
- if iface.get("external-connection-point-ref"):
- try:
- cp = vnfd.get("connection-point")[iface.get("external-connection-point-ref")]
- db_interface["external_name"] = get_str(cp, "name", 255)
- cp_name2iface_uuid[db_interface["external_name"]] = iface_uuid
- cp_name2vdu_id[db_interface["external_name"]] = vdu_id
- cp_name2vm_uuid[db_interface["external_name"]] = vm_uuid
- cp_name2db_interface[db_interface["external_name"]] = db_interface
- for cp_descriptor in vnfd_descriptor["connection-point"]:
- if cp_descriptor["name"] == db_interface["external_name"]:
- break
- else:
- raise KeyError()
-
- if vdu_id in vdu_id2cp_name:
- vdu_id2cp_name[vdu_id] = None # more than two connection point for this VDU
- else:
- vdu_id2cp_name[vdu_id] = db_interface["external_name"]
-
- # port security
- if "port-security-disable-strategy" in cp_descriptor or str(cp_descriptor.get("port-security-enabled")).lower() == "false":
- db_interface["port_security"] = 0
- db_interface["port_security_disable_strategy"] = cp_descriptor.get("port-security-disable-strategy", "full")
- elif str(cp_descriptor.get("port-security-enabled")).lower() == "true":
- db_interface["port_security"] = 1
- except KeyError:
- raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'vdu[{vdu}]':"
- "'interface[{iface}]':'vnfd-connection-point-ref':'{cp}' is not present"
- " at connection-point".format(
- vnf=vnfd_id, vdu=vdu_id, iface=iface["name"],
- cp=iface.get("vnfd-connection-point-ref")),
- httperrors.Bad_Request)
- elif iface.get("internal-connection-point-ref"):
- try:
- for icp_descriptor in vdu_descriptor["internal-connection-point"]:
- if icp_descriptor["id"] == str(iface.get("internal-connection-point-ref")):
- break
- else:
- raise KeyError("does not exist at vdu:internal-connection-point")
- icp = None
- icp_vld = None
- for vld in vnfd.get("internal-vld").values():
- for cp in vld.get("internal-connection-point").values():
- if cp.get("id-ref") == iface.get("internal-connection-point-ref"):
- if icp:
- raise KeyError("is referenced by more than one 'internal-vld'")
- icp = cp
- icp_vld = vld
- if not icp:
- raise KeyError("is not referenced by any 'internal-vld'")
-
- # set network type as data
- if iface.get("virtual-interface") and iface["virtual-interface"].get("type") in \
- ("SR-IOV", "PCI-PASSTHROUGH"):
- db_nets[net_id2index[icp_vld.get("id")]]["type"] = "data"
- db_interface["net_id"] = net_id2uuid[icp_vld.get("id")]
- if "port-security-disable-strategy" in icp_descriptor or str(icp_descriptor.get("port-security-enabled")).lower() == "false":
- db_interface["port_security"] = 0
- db_interface["port_security_disable_strategy"] = icp_descriptor.get("port-security-disable-strategy", "full")
- elif str(icp_descriptor.get("port-security-enabled")).lower() == "true":
- db_interface["port_security"] = 1
- if icp.get("ip-address"):
- if not icp_vld.get("ip-profile-ref"):
- raise NfvoException
- db_interface["ip_address"] = str(icp.get("ip-address"))
- except KeyError as e:
- raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'vdu[{vdu}]':"
- "'interface[{iface}]':'internal-connection-point-ref':'{cp}'"
- " {msg}".format(
- vnf=vnfd_id, vdu=vdu_id, iface=iface["name"],
- cp=iface.get("internal-connection-point-ref"), msg=str(e)),
- httperrors.Bad_Request)
- if iface.get("position"):
- db_interface["created_at"] = int(iface.get("position")) * 50
- if iface.get("mac-address"):
- db_interface["mac"] = str(iface.get("mac-address"))
- db_interfaces.append(db_interface)
-
- # table flavors
- db_flavor = {
- "name": get_str(vdu, "name", 250) + "-flv",
- "vcpus": int(vdu["vm-flavor"].get("vcpu-count", 1)),
- "ram": int(vdu["vm-flavor"].get("memory-mb", 1)),
- "disk": int(vdu["vm-flavor"].get("storage-gb", 0)),
- }
- # TODO revise the case of several numa-node-policy node
- extended = {}
- numa = {}
- if devices:
- extended["devices"] = devices
- if flavor_epa_interfaces:
- numa["interfaces"] = flavor_epa_interfaces
- if vdu.get("guest-epa"): # TODO or dedicated_int:
- epa_vcpu_set = False
- if vdu["guest-epa"].get("numa-node-policy"): # TODO or dedicated_int:
- numa_node_policy = vdu["guest-epa"].get("numa-node-policy")
- if numa_node_policy.get("node"):
- numa_node = next(iter(numa_node_policy["node"].values()))
- if numa_node.get("num-cores"):
- numa["cores"] = numa_node["num-cores"]
- epa_vcpu_set = True
- if numa_node.get("paired-threads"):
- if numa_node["paired-threads"].get("num-paired-threads"):
- numa["paired-threads"] = int(numa_node["paired-threads"]["num-paired-threads"])
- epa_vcpu_set = True
- if len(numa_node["paired-threads"].get("paired-thread-ids")):
- numa["paired-threads-id"] = []
- for pair in numa_node["paired-threads"]["paired-thread-ids"].values():
- numa["paired-threads-id"].append(
- (str(pair["thread-a"]), str(pair["thread-b"]))
- )
- if numa_node.get("num-threads"):
- numa["threads"] = int(numa_node["num-threads"])
- epa_vcpu_set = True
- if numa_node.get("memory-mb"):
- numa["memory"] = max(int(numa_node["memory-mb"] / 1024), 1)
- if vdu["guest-epa"].get("mempage-size"):
- if vdu["guest-epa"]["mempage-size"] != "SMALL":
- numa["memory"] = max(int(db_flavor["ram"] / 1024), 1)
- if vdu["guest-epa"].get("cpu-pinning-policy") and not epa_vcpu_set:
- if vdu["guest-epa"]["cpu-pinning-policy"] == "DEDICATED":
- if vdu["guest-epa"].get("cpu-thread-pinning-policy") and \
- vdu["guest-epa"]["cpu-thread-pinning-policy"] != "PREFER":
- numa["cores"] = max(db_flavor["vcpus"], 1)
- else:
- numa["threads"] = max(db_flavor["vcpus"], 1)
- epa_vcpu_set = True
- if vdu["guest-epa"].get("cpu-quota") and not epa_vcpu_set:
- cpuquota = get_resource_allocation_params(vdu["guest-epa"].get("cpu-quota"))
- if cpuquota:
- extended["cpu-quota"] = cpuquota
- if vdu["guest-epa"].get("mem-quota"):
- vduquota = get_resource_allocation_params(vdu["guest-epa"].get("mem-quota"))
- if vduquota:
- extended["mem-quota"] = vduquota
- if vdu["guest-epa"].get("disk-io-quota"):
- diskioquota = get_resource_allocation_params(vdu["guest-epa"].get("disk-io-quota"))
- if diskioquota:
- extended["disk-io-quota"] = diskioquota
- if vdu["guest-epa"].get("vif-quota"):
- vifquota = get_resource_allocation_params(vdu["guest-epa"].get("vif-quota"))
- if vifquota:
- extended["vif-quota"] = vifquota
- if numa:
- extended["numas"] = [numa]
- if extended:
- extended_text = yaml.safe_dump(extended, default_flow_style=True, width=256)
- db_flavor["extended"] = extended_text
- # look if flavor exist
- temp_flavor_dict = {'disk': db_flavor.get('disk', 0),
- 'ram': db_flavor.get('ram'),
- 'vcpus': db_flavor.get('vcpus'),
- 'extended': db_flavor.get('extended')
- }
- existing_flavors = mydb.get_rows(FROM="flavors", WHERE=temp_flavor_dict)
- if existing_flavors:
- flavor_uuid = existing_flavors[0]["uuid"]
- else:
- flavor_uuid = str(uuid4())
- uuid_list.append(flavor_uuid)
- db_flavor["uuid"] = flavor_uuid
- db_flavors.append(db_flavor)
- db_vm["flavor_id"] = flavor_uuid
-
- # VNF affinity and antiaffinity
- for pg in vnfd.get("placement-groups").values():
- pg_name = get_str(pg, "name", 255)
- for vdu in pg.get("member-vdus").values():
- vdu_id = get_str(vdu, "member-vdu-ref", 255)
- if vdu_id not in vdu_id2db_table_index:
- raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'placement-groups[{pg}]':"
- "'member-vdus':'{vdu}'. Reference to a non-existing vdu".format(
- vnf=vnfd_id, pg=pg_name, vdu=vdu_id),
- httperrors.Bad_Request)
- db_vms[vdu_id2db_table_index[vdu_id]]["availability_zone"] = pg_name
- # TODO consider the case of isolation and not colocation
- # if pg.get("strategy") == "ISOLATION":
-
- # VNF mgmt configuration
- if vnfd["mgmt-interface"].get("vdu-id"):
- mgmt_vdu_id = get_str(vnfd["mgmt-interface"], "vdu-id", 255)
- if mgmt_vdu_id not in vdu_id2uuid:
- raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'mgmt-interface':'vdu-id':"
- "'{vdu}'. Reference to a non-existing vdu".format(
- vnf=vnfd_id, vdu=mgmt_vdu_id),
- httperrors.Bad_Request)
- mgmt_access["vm_id"] = vdu_id2uuid[mgmt_vdu_id]
- mgmt_access["vdu-id"] = mgmt_vdu_id
- # if only one cp is defined by this VDU, mark this interface as of type "mgmt"
- if vdu_id2cp_name.get(mgmt_vdu_id):
- if cp_name2db_interface[vdu_id2cp_name[mgmt_vdu_id]]:
- cp_name2db_interface[vdu_id2cp_name[mgmt_vdu_id]]["type"] = "mgmt"
-
- if vnfd["mgmt-interface"].get("ip-address"):
- mgmt_access["ip-address"] = str(vnfd["mgmt-interface"].get("ip-address"))
- if vnfd["mgmt-interface"].get("cp") and vnfd.get("vdu"):
- if vnfd["mgmt-interface"]["cp"] not in cp_name2iface_uuid:
- raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'mgmt-interface':'cp'['{cp}']. "
- "Reference to a non-existing connection-point".format(
- vnf=vnfd_id, cp=vnfd["mgmt-interface"]["cp"]),
- httperrors.Bad_Request)
- mgmt_access["vm_id"] = cp_name2vm_uuid[vnfd["mgmt-interface"]["cp"]]
- mgmt_access["interface_id"] = cp_name2iface_uuid[vnfd["mgmt-interface"]["cp"]]
- mgmt_access["vdu-id"] = cp_name2vdu_id[vnfd["mgmt-interface"]["cp"]]
- # mark this interface as of type mgmt
- if cp_name2db_interface[vnfd["mgmt-interface"]["cp"]]:
- cp_name2db_interface[vnfd["mgmt-interface"]["cp"]]["type"] = "mgmt"
-
- default_user = get_str(vnfd.get("vnf-configuration", {}).get("config-access", {}).get("ssh-access", {}),
- "default-user", 64)
- if default_user:
- mgmt_access["default_user"] = default_user
-
- required = get_str(vnfd.get("vnf-configuration", {}).get("config-access", {}).get("ssh-access", {}),
- "required", 6)
- if required:
- mgmt_access["required"] = required
-
- password_ = get_str(vnfd.get("vnf-configuration", {}).get("config-access", {}),
- "password", 64)
- if password_:
- mgmt_access["password"] = password_
-
- if mgmt_access:
- db_vnf["mgmt_access"] = yaml.safe_dump(mgmt_access, default_flow_style=True, width=256)
-
- db_vnfs.append(db_vnf)
- db_tables=[
- {"vnfs": db_vnfs},
- {"nets": db_nets},
- {"images": db_images},
- {"flavors": db_flavors},
- {"ip_profiles": db_ip_profiles},
- {"vms": db_vms},
- {"interfaces": db_interfaces},
- ]
-
- logger.debug("create_vnf Deployment done vnfDict: %s",
- yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
- mydb.new_rows(db_tables, uuid_list)
- return vnfd_uuid_list
- except NfvoException:
- raise
- except Exception as e:
- logger.error("Exception {}".format(e))
- raise # NfvoException("Exception {}".format(e), httperrors.Bad_Request)
-
-
-@deprecated("Use new_vnfd_v3")
-def new_vnf(mydb, tenant_id, vnf_descriptor):
- global global_config
-
- # Step 1. Check the VNF descriptor
- check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=1)
- # Step 2. Check tenant exist
- vims = {}
- if tenant_id != "any":
- check_tenant(mydb, tenant_id)
- if "tenant_id" in vnf_descriptor["vnf"]:
- if vnf_descriptor["vnf"]["tenant_id"] != tenant_id:
- raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id),
- httperrors.Unauthorized)
- else:
- vnf_descriptor['vnf']['tenant_id'] = tenant_id
- # Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter
- if global_config["auto_push_VNF_to_VIMs"]:
- vims = get_vim(mydb, tenant_id, ignore_errors=True)
-
- # Step 4. Review the descriptor and add missing fields
- #print vnf_descriptor
- #logger.debug("Refactoring VNF descriptor with fields: description, public (default: true)")
- vnf_name = vnf_descriptor['vnf']['name']
- vnf_descriptor['vnf']['description'] = vnf_descriptor['vnf'].get("description", vnf_name)
- if "physical" in vnf_descriptor['vnf']:
- del vnf_descriptor['vnf']['physical']
- #print vnf_descriptor
-
- # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM
- logger.debug('BEGIN creation of VNF "%s"' % vnf_name)
- logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC'])))
-
- #For each VNFC, we add it to the VNFCDict and we create a flavor.
- VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database
- rollback_list = [] # It will contain the new images created in mano. It is used for rollback
- try:
- logger.debug("Creating additional disk images and new flavors in the VIM for each VNFC")
- for vnfc in vnf_descriptor['vnf']['VNFC']:
- VNFCitem={}
- VNFCitem["name"] = vnfc['name']
- VNFCitem["availability_zone"] = vnfc.get('availability_zone')
- VNFCitem["description"] = vnfc.get("description", 'VM {} of the VNF {}'.format(vnfc['name'],vnf_name))
-
- #print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"])
-
- myflavorDict = {}
- myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists
- myflavorDict["description"] = VNFCitem["description"]
- myflavorDict["ram"] = vnfc.get("ram", 0)
- myflavorDict["vcpus"] = vnfc.get("vcpus", 0)
- myflavorDict["disk"] = vnfc.get("disk", 0)
- myflavorDict["extended"] = {}
-
- devices = vnfc.get("devices")
- if devices != None:
- myflavorDict["extended"]["devices"] = devices
-
- # TODO:
- # Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table
- # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host
-
- # Previous code has been commented
- #if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" :
- # myflavorDict["flavor"]['extended']['processor_ranking'] = 200
- #elif vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-2697 v2 @ 2.70GHz" :
- # myflavorDict["flavor"]['extended']['processor_ranking'] = 300
- #else:
- # result2, message = rollback(myvim, myvimURL, myvim_tenant, flavorList, imageList)
- # if result2:
- # print "Error creating flavor: unknown processor model. Rollback successful."
- # return -httperrors.Bad_Request, "Error creating flavor: unknown processor model. Rollback successful."
- # else:
- # return -httperrors.Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message
- myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done
-
- if 'numas' in vnfc and len(vnfc['numas'])>0:
- myflavorDict['extended']['numas'] = vnfc['numas']
-
- #print myflavorDict
-
- # Step 6.2 New flavors are created in the VIM
- flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list)
-
- #print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id)
- VNFCitem["flavor_id"] = flavor_id
- VNFCDict[vnfc['name']] = VNFCitem
-
- logger.debug("Creating new images in the VIM for each VNFC")
- # Step 6.3 New images are created in the VIM
- #For each VNFC, we must create the appropriate image.
- #This "for" loop might be integrated with the previous one
- #In case this integration is made, the VNFCDict might become a VNFClist.
- for vnfc in vnf_descriptor['vnf']['VNFC']:
- #print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description'])
- image_dict={}
- image_dict['name']=vnfc.get('image name',vnf_name+"-"+vnfc['name']+"-img")
- image_dict['universal_name']=vnfc.get('image name')
- image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description'])
- image_dict['location']=vnfc.get('VNFC image')
- #image_dict['new_location']=vnfc.get('image location')
- image_dict['checksum']=vnfc.get('image checksum')
- image_metadata_dict = vnfc.get('image metadata', None)
- image_metadata_str = None
- if image_metadata_dict is not None:
- image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
- image_dict['metadata']=image_metadata_str
- #print "create_or_use_image", mydb, vims, image_dict, rollback_list
- image_id = create_or_use_image(mydb, vims, image_dict, rollback_list)
- #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id)
- VNFCDict[vnfc['name']]["image_id"] = image_id
- VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image')
- VNFCDict[vnfc['name']]["count"] = vnfc.get('count', 1)
- if vnfc.get("boot-data"):
- VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256)
-
-
- # Step 7. Storing the VNF descriptor in the repository
- if "descriptor" not in vnf_descriptor["vnf"]:
- vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False)
-
- # Step 8. Adding the VNF to the NFVO DB
- vnf_id = mydb.new_vnf_as_a_whole(tenant_id,vnf_name,vnf_descriptor,VNFCDict)
- return vnf_id
- except (db_base_Exception, vimconn.VimConnException, KeyError) as e:
- _, message = rollback(mydb, vims, rollback_list)
- if isinstance(e, db_base_Exception):
- error_text = "Exception at database"
- elif isinstance(e, KeyError):
- error_text = "KeyError exception "
- e.http_code = httperrors.Internal_Server_Error
- else:
- error_text = "Exception at VIM"
- error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
- #logger.error("start_scenario %s", error_text)
- raise NfvoException(error_text, e.http_code)
-
-
-@deprecated("Use new_vnfd_v3")
-def new_vnf_v02(mydb, tenant_id, vnf_descriptor):
- global global_config
-
- # Step 1. Check the VNF descriptor
- check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=2)
- # Step 2. Check tenant exist
- vims = {}
- if tenant_id != "any":
- check_tenant(mydb, tenant_id)
- if "tenant_id" in vnf_descriptor["vnf"]:
- if vnf_descriptor["vnf"]["tenant_id"] != tenant_id:
- raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id),
- httperrors.Unauthorized)
- else:
- vnf_descriptor['vnf']['tenant_id'] = tenant_id
- # Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter
- if global_config["auto_push_VNF_to_VIMs"]:
- vims = get_vim(mydb, tenant_id, ignore_errors=True)
-
- # Step 4. Review the descriptor and add missing fields
- #print vnf_descriptor
- #logger.debug("Refactoring VNF descriptor with fields: description, public (default: true)")
- vnf_name = vnf_descriptor['vnf']['name']
- vnf_descriptor['vnf']['description'] = vnf_descriptor['vnf'].get("description", vnf_name)
- if "physical" in vnf_descriptor['vnf']:
- del vnf_descriptor['vnf']['physical']
- #print vnf_descriptor
-
- # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM
- logger.debug('BEGIN creation of VNF "%s"' % vnf_name)
- logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC'])))
-
- #For each VNFC, we add it to the VNFCDict and we create a flavor.
- VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database
- rollback_list = [] # It will contain the new images created in mano. It is used for rollback
- try:
- logger.debug("Creating additional disk images and new flavors in the VIM for each VNFC")
- for vnfc in vnf_descriptor['vnf']['VNFC']:
- VNFCitem={}
- VNFCitem["name"] = vnfc['name']
- VNFCitem["description"] = vnfc.get("description", 'VM {} of the VNF {}'.format(vnfc['name'],vnf_name))
-
- #print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"])
-
- myflavorDict = {}
- myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists
- myflavorDict["description"] = VNFCitem["description"]
- myflavorDict["ram"] = vnfc.get("ram", 0)
- myflavorDict["vcpus"] = vnfc.get("vcpus", 0)
- myflavorDict["disk"] = vnfc.get("disk", 0)
- myflavorDict["extended"] = {}
-
- devices = vnfc.get("devices")
- if devices != None:
- myflavorDict["extended"]["devices"] = devices
-
- # TODO:
- # Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table
- # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host
-
- # Previous code has been commented
- #if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" :
- # myflavorDict["flavor"]['extended']['processor_ranking'] = 200
- #elif vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-2697 v2 @ 2.70GHz" :
- # myflavorDict["flavor"]['extended']['processor_ranking'] = 300
- #else:
- # result2, message = rollback(myvim, myvimURL, myvim_tenant, flavorList, imageList)
- # if result2:
- # print "Error creating flavor: unknown processor model. Rollback successful."
- # return -httperrors.Bad_Request, "Error creating flavor: unknown processor model. Rollback successful."
- # else:
- # return -httperrors.Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message
- myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done
-
- if 'numas' in vnfc and len(vnfc['numas'])>0:
- myflavorDict['extended']['numas'] = vnfc['numas']
-
- #print myflavorDict
-
- # Step 6.2 New flavors are created in the VIM
- flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list)
-
- #print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id)
- VNFCitem["flavor_id"] = flavor_id
- VNFCDict[vnfc['name']] = VNFCitem
-
- logger.debug("Creating new images in the VIM for each VNFC")
- # Step 6.3 New images are created in the VIM
- #For each VNFC, we must create the appropriate image.
- #This "for" loop might be integrated with the previous one
- #In case this integration is made, the VNFCDict might become a VNFClist.
- for vnfc in vnf_descriptor['vnf']['VNFC']:
- #print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description'])
- image_dict={}
- image_dict['name']=vnfc.get('image name',vnf_name+"-"+vnfc['name']+"-img")
- image_dict['universal_name']=vnfc.get('image name')
- image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description'])
- image_dict['location']=vnfc.get('VNFC image')
- #image_dict['new_location']=vnfc.get('image location')
- image_dict['checksum']=vnfc.get('image checksum')
- image_metadata_dict = vnfc.get('image metadata', None)
- image_metadata_str = None
- if image_metadata_dict is not None:
- image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
- image_dict['metadata']=image_metadata_str
- #print "create_or_use_image", mydb, vims, image_dict, rollback_list
- image_id = create_or_use_image(mydb, vims, image_dict, rollback_list)
- #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id)
- VNFCDict[vnfc['name']]["image_id"] = image_id
- VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image')
- VNFCDict[vnfc['name']]["count"] = vnfc.get('count', 1)
- if vnfc.get("boot-data"):
- VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256)
-
- # Step 7. Storing the VNF descriptor in the repository
- if "descriptor" not in vnf_descriptor["vnf"]:
- vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False)
-
- # Step 8. Adding the VNF to the NFVO DB
- vnf_id = mydb.new_vnf_as_a_whole2(tenant_id,vnf_name,vnf_descriptor,VNFCDict)
- return vnf_id
- except (db_base_Exception, vimconn.VimConnException, KeyError) as e:
- _, message = rollback(mydb, vims, rollback_list)
- if isinstance(e, db_base_Exception):
- error_text = "Exception at database"
- elif isinstance(e, KeyError):
- error_text = "KeyError exception "
- e.http_code = httperrors.Internal_Server_Error
- else:
- error_text = "Exception at VIM"
- error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
- #logger.error("start_scenario %s", error_text)
- raise NfvoException(error_text, e.http_code)
-
-
-def get_vnf_id(mydb, tenant_id, vnf_id):
- #check valid tenant_id
- check_tenant(mydb, tenant_id)
- #obtain data
- where_or = {}
- if tenant_id != "any":
- where_or["tenant_id"] = tenant_id
- where_or["public"] = True
- vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND")
-
- vnf_id = vnf["uuid"]
- filter_keys = ('uuid', 'name', 'description', 'public', "tenant_id", "osm_id", "created_at")
- filtered_content = dict( (k,v) for k,v in vnf.items() if k in filter_keys )
- #change_keys_http2db(filtered_content, http2db_vnf, reverse=True)
- data={'vnf' : filtered_content}
- #GET VM
- content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id',
- SELECT=('vms.uuid as uuid', 'vms.osm_id as osm_id', 'vms.name as name', 'vms.description as description',
- 'boot_data'),
- WHERE={'vnfs.uuid': vnf_id} )
- if len(content) != 0:
- #raise NfvoException("vnf '{}' not found".format(vnf_id), httperrors.Not_Found)
- # change boot_data into boot-data
- for vm in content:
- if vm.get("boot_data"):
- vm["boot-data"] = yaml.safe_load(vm["boot_data"])
- del vm["boot_data"]
-
- data['vnf']['VNFC'] = content
- #TODO: GET all the information from a VNFC and include it in the output.
-
- #GET NET
- content = mydb.get_rows(FROM='vnfs join nets on vnfs.uuid=nets.vnf_id',
- SELECT=('nets.uuid as uuid','nets.name as name','nets.description as description', 'nets.type as type', 'nets.multipoint as multipoint'),
- WHERE={'vnfs.uuid': vnf_id} )
- data['vnf']['nets'] = content
-
- #GET ip-profile for each net
- for net in data['vnf']['nets']:
- ipprofiles = mydb.get_rows(FROM='ip_profiles',
- SELECT=('ip_version','subnet_address','gateway_address','dns_address','dhcp_enabled','dhcp_start_address','dhcp_count'),
- WHERE={'net_id': net["uuid"]} )
- if len(ipprofiles)==1:
- net["ip_profile"] = ipprofiles[0]
- elif len(ipprofiles)>1:
- raise NfvoException("More than one ip-profile found with this criteria: net_id='{}'".format(net['uuid']), httperrors.Bad_Request)
-
-
- #TODO: For each net, GET its elements and relevant info per element (VNFC, iface, ip_address) and include them in the output.
-
- #GET External Interfaces
- content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces on vms.uuid=interfaces.vm_id',\
- SELECT=('interfaces.uuid as uuid','interfaces.external_name as external_name', 'vms.name as vm_name', 'interfaces.vm_id as vm_id', \
- 'interfaces.internal_name as internal_name', 'interfaces.type as type', 'interfaces.vpci as vpci','interfaces.bw as bw'),\
- WHERE={'vnfs.uuid': vnf_id, 'interfaces.external_name<>': None} )
- #print content
- data['vnf']['external-connections'] = content
-
- return data
-
-
-def delete_vnf(mydb,tenant_id,vnf_id,datacenter=None,vim_tenant=None):
- # Check tenant exist
- if tenant_id != "any":
- check_tenant(mydb, tenant_id)
- # Get the URL of the VIM from the nfvo_tenant and the datacenter
- vims = get_vim(mydb, tenant_id, ignore_errors=True)
- else:
- vims={}
-
- # Checking if it is a valid uuid and, if not, getting the uuid assuming that the name was provided"
- where_or = {}
- if tenant_id != "any":
- where_or["tenant_id"] = tenant_id
- where_or["public"] = True
- vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND")
- vnf_id = vnf["uuid"]
-
- # "Getting the list of flavors and tenants of the VNF"
- flavorList = get_flavorlist(mydb, vnf_id)
- if len(flavorList)==0:
- logger.warn("delete_vnf error. No flavors found for the VNF id '%s'", vnf_id)
-
- imageList = get_imagelist(mydb, vnf_id)
- if len(imageList)==0:
- logger.warn( "delete_vnf error. No images found for the VNF id '%s'", vnf_id)
-
- deleted = mydb.delete_row_by_id('vnfs', vnf_id)
- if deleted == 0:
- raise NfvoException("vnf '{}' not found".format(vnf_id), httperrors.Not_Found)
-
- undeletedItems = []
- for flavor in flavorList:
- #check if flavor is used by other vnf
- try:
- c = mydb.get_rows(FROM='vms', WHERE={'flavor_id':flavor} )
- if len(c) > 0:
- logger.debug("Flavor '%s' not deleted because it is being used by another VNF", flavor)
- continue
- #flavor not used, must be deleted
- #delelte at VIM
- c = mydb.get_rows(FROM='datacenters_flavors', WHERE={'flavor_id': flavor})
- for flavor_vim in c:
- if not flavor_vim['created']: # skip this flavor because not created by openmano
- continue
- # look for vim
- myvim = None
- for vim in vims.values():
- if vim["config"]["datacenter_tenant_id"] == flavor_vim["datacenter_vim_id"]:
- myvim = vim
- break
- if not myvim:
- continue
- try:
- myvim.delete_flavor(flavor_vim["vim_id"])
- except vimconn.VimConnNotFoundException:
- logger.warn("VIM flavor %s not exist at datacenter %s", flavor_vim["vim_id"],
- flavor_vim["datacenter_vim_id"] )
- except vimconn.VimConnException as e:
- logger.error("Not possible to delete VIM flavor %s from datacenter %s: %s %s",
- flavor_vim["vim_id"], flavor_vim["datacenter_vim_id"], type(e).__name__, str(e))
- undeletedItems.append("flavor {} from VIM {}".format(flavor_vim["vim_id"],
- flavor_vim["datacenter_vim_id"]))
- # delete flavor from Database, using table flavors and with cascade foreign key also at datacenters_flavors
- mydb.delete_row_by_id('flavors', flavor)
- except db_base_Exception as e:
- logger.error("delete_vnf_error. Not possible to get flavor details and delete '%s'. %s", flavor, str(e))
- undeletedItems.append("flavor {}".format(flavor))
-
-
- for image in imageList:
- try:
- #check if image is used by other vnf
- c = mydb.get_rows(FROM='vms', WHERE=[{'image_id': image}, {'image_list LIKE ': '%' + image + '%'}])
- if len(c) > 0:
- logger.debug("Image '%s' not deleted because it is being used by another VNF", image)
- continue
- #image not used, must be deleted
- #delelte at VIM
- c = mydb.get_rows(FROM='datacenters_images', WHERE={'image_id':image})
- for image_vim in c:
- if image_vim["datacenter_vim_id"] not in vims: # TODO change to datacenter_tenant_id
- continue
- if image_vim['created']=='false': #skip this image because not created by openmano
- continue
- myvim=vims[ image_vim["datacenter_id"] ]
- try:
- myvim.delete_image(image_vim["vim_id"])
- except vimconn.VimConnNotFoundException as e:
- logger.warn("VIM image %s not exist at datacenter %s", image_vim["vim_id"], image_vim["datacenter_id"] )
- except vimconn.VimConnException as e:
- logger.error("Not possible to delete VIM image %s from datacenter %s: %s %s",
- image_vim["vim_id"], image_vim["datacenter_id"], type(e).__name__, str(e))
- undeletedItems.append("image {} from VIM {}".format(image_vim["vim_id"], image_vim["datacenter_id"] ))
- #delete image from Database, using table images and with cascade foreign key also at datacenters_images
- mydb.delete_row_by_id('images', image)
- except db_base_Exception as e:
- logger.error("delete_vnf_error. Not possible to get image details and delete '%s'. %s", image, str(e))
- undeletedItems.append("image {}".format(image))
-
- return vnf_id + " " + vnf["name"]
- #if undeletedItems:
- # return "delete_vnf. Undeleted: %s" %(undeletedItems)
-
-
-@deprecated("Not used")
-def get_hosts_info(mydb, nfvo_tenant_id, datacenter_name=None):
- result, vims = get_vim(mydb, nfvo_tenant_id, None, datacenter_name)
- if result < 0:
- return result, vims
- elif result == 0:
- return -httperrors.Not_Found, "datacenter '{}' not found".format(datacenter_name)
- myvim = next(iter(vims.values()))
- result,servers = myvim.get_hosts_info()
- if result < 0:
- return result, servers
- topology = {'name':myvim['name'] , 'servers': servers}
- return result, topology
-
-
-def get_hosts(mydb, nfvo_tenant_id):
- vims = get_vim(mydb, nfvo_tenant_id)
- if len(vims) == 0:
- raise NfvoException("No datacenter found for tenant '{}'".format(str(nfvo_tenant_id)), httperrors.Not_Found)
- elif len(vims)>1:
- #print "nfvo.datacenter_action() error. Several datacenters found"
- raise NfvoException("More than one datacenters found, try to identify with uuid", httperrors.Conflict)
- myvim = next(iter(vims.values()))
- try:
- hosts = myvim.get_hosts()
- logger.debug('VIM hosts response: '+ yaml.safe_dump(hosts, indent=4, default_flow_style=False))
-
- datacenter = {'Datacenters': [ {'name':myvim['name'],'servers':[]} ] }
- for host in hosts:
- server={'name':host['name'], 'vms':[]}
- for vm in host['instances']:
- #get internal name and model
- try:
- c = mydb.get_rows(SELECT=('name',), FROM='instance_vms as iv join vms on iv.vm_id=vms.uuid',\
- WHERE={'vim_vm_id':vm['id']} )
- if len(c) == 0:
- logger.warn("nfvo.get_hosts virtual machine at VIM '{}' not found at tidnfvo".format(vm['id']))
- continue
- server['vms'].append( {'name':vm['name'] , 'model':c[0]['name']} )
-
- except db_base_Exception as e:
- logger.warn("nfvo.get_hosts virtual machine at VIM '{}' error {}".format(vm['id'], str(e)))
- datacenter['Datacenters'][0]['servers'].append(server)
- #return -400, "en construccion"
-
- #print 'datacenters '+ json.dumps(datacenter, indent=4)
- return datacenter
- except vimconn.VimConnException as e:
- raise NfvoException("Not possible to get_host_list from VIM: {}".format(str(e)), e.http_code)
-
-
-@deprecated("Use new_nsd_v3")
-def new_scenario(mydb, tenant_id, topo):
-
-# result, vims = get_vim(mydb, tenant_id)
-# if result < 0:
-# return result, vims
-#1: parse input
- if tenant_id != "any":
- check_tenant(mydb, tenant_id)
- if "tenant_id" in topo:
- if topo["tenant_id"] != tenant_id:
- raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(topo["tenant_id"], tenant_id),
- httperrors.Unauthorized)
- else:
- tenant_id=None
-
-#1.1: get VNFs and external_networks (other_nets).
- vnfs={}
- other_nets={} #external_networks, bridge_networks and data_networkds
- nodes = topo['topology']['nodes']
- for k in nodes.keys():
- if nodes[k]['type'] == 'VNF':
- vnfs[k] = nodes[k]
- vnfs[k]['ifaces'] = {}
- elif nodes[k]['type'] == 'other_network' or nodes[k]['type'] == 'external_network':
- other_nets[k] = nodes[k]
- other_nets[k]['external']=True
- elif nodes[k]['type'] == 'network':
- other_nets[k] = nodes[k]
- other_nets[k]['external']=False
-
-
-#1.2: Check that VNF are present at database table vnfs. Insert uuid, description and external interfaces
- for name,vnf in vnfs.items():
- where = {"OR": {"tenant_id": tenant_id, 'public': "true"}}
- error_text = ""
- error_pos = "'topology':'nodes':'" + name + "'"
- if 'vnf_id' in vnf:
- error_text += " 'vnf_id' " + vnf['vnf_id']
- where['uuid'] = vnf['vnf_id']
- if 'VNF model' in vnf:
- error_text += " 'VNF model' " + vnf['VNF model']
- where['name'] = vnf['VNF model']
- if len(where) == 1:
- raise NfvoException("Descriptor need a 'vnf_id' or 'VNF model' field at " + error_pos, httperrors.Bad_Request)
-
- vnf_db = mydb.get_rows(SELECT=('uuid','name','description'),
- FROM='vnfs',
- WHERE=where)
- if len(vnf_db)==0:
- raise NfvoException("unknown" + error_text + " at " + error_pos, httperrors.Not_Found)
- elif len(vnf_db)>1:
- raise NfvoException("more than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", httperrors.Conflict)
- vnf['uuid']=vnf_db[0]['uuid']
- vnf['description']=vnf_db[0]['description']
- #get external interfaces
- ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'),
- FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
- WHERE={'vnfs.uuid':vnf['uuid'], 'external_name<>': None} )
- for ext_iface in ext_ifaces:
- vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']}
-
-#1.4 get list of connections
- conections = topo['topology']['connections']
- conections_list = []
- conections_list_name = []
- for k in conections.keys():
- if type(conections[k]['nodes'])==dict: #dict with node:iface pairs
- ifaces_list = conections[k]['nodes'].items()
- elif type(conections[k]['nodes'])==list: #list with dictionary
- ifaces_list=[]
- conection_pair_list = map(lambda x: x.items(), conections[k]['nodes'] )
- for k2 in conection_pair_list:
- ifaces_list += k2
-
- con_type = conections[k].get("type", "link")
- if con_type != "link":
- if k in other_nets:
- raise NfvoException("Format error. Reapeted network name at 'topology':'connections':'{}'".format(str(k)), httperrors.Bad_Request)
- other_nets[k] = {'external': False}
- if conections[k].get("graph"):
- other_nets[k]["graph"] = conections[k]["graph"]
- ifaces_list.append( (k, None) )
-
-
- if con_type == "external_network":
- other_nets[k]['external'] = True
- if conections[k].get("model"):
- other_nets[k]["model"] = conections[k]["model"]
- else:
- other_nets[k]["model"] = k
- if con_type == "dataplane_net" or con_type == "bridge_net":
- other_nets[k]["model"] = con_type
-
- conections_list_name.append(k)
- conections_list.append(set(ifaces_list)) #from list to set to operate as a set (this conversion removes elements that are repeated in a list)
- #print set(ifaces_list)
- #check valid VNF and iface names
- for iface in ifaces_list:
- if iface[0] not in vnfs and iface[0] not in other_nets :
- raise NfvoException("format error. Invalid VNF name at 'topology':'connections':'{}':'nodes':'{}'".format(
- str(k), iface[0]), httperrors.Not_Found)
- if iface[0] in vnfs and iface[1] not in vnfs[ iface[0] ]['ifaces']:
- raise NfvoException("format error. Invalid interface name at 'topology':'connections':'{}':'nodes':'{}':'{}'".format(
- str(k), iface[0], iface[1]), httperrors.Not_Found)
-
-#1.5 unify connections from the pair list to a consolidated list
- index=0
- while index < len(conections_list):
- index2 = index+1
- while index2 < len(conections_list):
- if len(conections_list[index] & conections_list[index2])>0: #common interface, join nets
- conections_list[index] |= conections_list[index2]
- del conections_list[index2]
- del conections_list_name[index2]
- else:
- index2 += 1
- conections_list[index] = list(conections_list[index]) # from set to list again
- index += 1
- #for k in conections_list:
- # print k
-
-
-
-#1.6 Delete non external nets
-# for k in other_nets.keys():
-# if other_nets[k]['model']=='bridge' or other_nets[k]['model']=='dataplane_net' or other_nets[k]['model']=='bridge_net':
-# for con in conections_list:
-# delete_indexes=[]
-# for index in range(0,len(con)):
-# if con[index][0] == k: delete_indexes.insert(0,index) #order from higher to lower
-# for index in delete_indexes:
-# del con[index]
-# del other_nets[k]
-#1.7: Check external_ports are present at database table datacenter_nets
- for k,net in other_nets.items():
- error_pos = "'topology':'nodes':'" + k + "'"
- if net['external']==False:
- if 'name' not in net:
- net['name']=k
- if 'model' not in net:
- raise NfvoException("needed a 'model' at " + error_pos, httperrors.Bad_Request)
- if net['model']=='bridge_net':
- net['type']='bridge';
- elif net['model']=='dataplane_net':
- net['type']='data';
- else:
- raise NfvoException("unknown 'model' '"+ net['model'] +"' at " + error_pos, httperrors.Not_Found)
- else: #external
-#IF we do not want to check that external network exist at datacenter
- pass
-#ELSE
-# error_text = ""
-# WHERE_={}
-# if 'net_id' in net:
-# error_text += " 'net_id' " + net['net_id']
-# WHERE_['uuid'] = net['net_id']
-# if 'model' in net:
-# error_text += " 'model' " + net['model']
-# WHERE_['name'] = net['model']
-# if len(WHERE_) == 0:
-# return -httperrors.Bad_Request, "needed a 'net_id' or 'model' at " + error_pos
-# r,net_db = mydb.get_table(SELECT=('uuid','name','description','type','shared'),
-# FROM='datacenter_nets', WHERE=WHERE_ )
-# if r<0:
-# print "nfvo.new_scenario Error getting datacenter_nets",r,net_db
-# elif r==0:
-# print "nfvo.new_scenario Error" +error_text+ " is not present at database"
-# return -httperrors.Bad_Request, "unknown " +error_text+ " at " + error_pos
-# elif r>1:
-# print "nfvo.new_scenario Error more than one external_network for " +error_text+ " is present at database"
-# return -httperrors.Bad_Request, "more than one external_network for " +error_text+ "at "+ error_pos + " Concrete with 'net_id'"
-# other_nets[k].update(net_db[0])
-#ENDIF
- net_list={}
- net_nb=0 #Number of nets
- for con in conections_list:
- #check if this is connected to a external net
- other_net_index=-1
- #print
- #print "con", con
- for index in range(0,len(con)):
- #check if this is connected to a external net
- for net_key in other_nets.keys():
- if con[index][0]==net_key:
- if other_net_index>=0:
- error_text = "There is some interface connected both to net '{}' and net '{}'".format(
- con[other_net_index][0], net_key)
- #print "nfvo.new_scenario " + error_text
- raise NfvoException(error_text, httperrors.Bad_Request)
- else:
- other_net_index = index
- net_target = net_key
- break
- #print "other_net_index", other_net_index
- try:
- if other_net_index>=0:
- del con[other_net_index]
-#IF we do not want to check that external network exist at datacenter
- if other_nets[net_target]['external'] :
- if "name" not in other_nets[net_target]:
- other_nets[net_target]['name'] = other_nets[net_target]['model']
- if other_nets[net_target]["type"] == "external_network":
- if vnfs[ con[0][0] ]['ifaces'][ con[0][1] ]["type"] == "data":
- other_nets[net_target]["type"] = "data"
- else:
- other_nets[net_target]["type"] = "bridge"
-#ELSE
-# if other_nets[net_target]['external'] :
-# type_='data' if len(con)>1 else 'ptp' #an external net is connected to a external port, so it is ptp if only one connection is done to this net
-# if type_=='data' and other_nets[net_target]['type']=="ptp":
-# error_text = "Error connecting %d nodes on a not multipoint net %s" % (len(con), net_target)
-# print "nfvo.new_scenario " + error_text
-# return -httperrors.Bad_Request, error_text
-#ENDIF
- for iface in con:
- vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target
- else:
- #create a net
- net_type_bridge=False
- net_type_data=False
- net_target = "__-__net"+str(net_nb)
- net_list[net_target] = {'name': conections_list_name[net_nb], #"net-"+str(net_nb),
- 'description':"net-{} in scenario {}".format(net_nb,topo['name']),
- 'external':False}
- for iface in con:
- vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target
- iface_type = vnfs[ iface[0] ]['ifaces'][ iface[1] ]['type']
- if iface_type=='mgmt' or iface_type=='bridge':
- net_type_bridge = True
- else:
- net_type_data = True
- if net_type_bridge and net_type_data:
- error_text = "Error connection interfaces of bridge type with data type. Firs node {}, iface {}".format(iface[0], iface[1])
- #print "nfvo.new_scenario " + error_text
- raise NfvoException(error_text, httperrors.Bad_Request)
- elif net_type_bridge:
- type_='bridge'
- else:
- type_='data' if len(con)>2 else 'ptp'
- net_list[net_target]['type'] = type_
- net_nb+=1
- except Exception:
- error_text = "Error connection node {} : {} does not match any VNF or interface".format(iface[0], iface[1])
- #print "nfvo.new_scenario " + error_text
- #raise e
- raise NfvoException(error_text, httperrors.Bad_Request)
-
-#1.8: Connect to management net all not already connected interfaces of type 'mgmt'
- #1.8.1 obtain management net
- mgmt_net = mydb.get_rows(SELECT=('uuid','name','description','type','shared'),
- FROM='datacenter_nets', WHERE={'name':'mgmt'} )
- #1.8.2 check all interfaces from all vnfs
- if len(mgmt_net)>0:
- add_mgmt_net = False
- for vnf in vnfs.values():
- for iface in vnf['ifaces'].values():
- if iface['type']=='mgmt' and 'net_key' not in iface:
- #iface not connected
- iface['net_key'] = 'mgmt'
- add_mgmt_net = True
- if add_mgmt_net and 'mgmt' not in net_list:
- net_list['mgmt']=mgmt_net[0]
- net_list['mgmt']['external']=True
- net_list['mgmt']['graph']={'visible':False}
-
- net_list.update(other_nets)
- #print
- #print 'net_list', net_list
- #print
- #print 'vnfs', vnfs
- #print
-
-#2: insert scenario. filling tables scenarios,sce_vnfs,sce_interfaces,sce_nets
- c = mydb.new_scenario( { 'vnfs':vnfs, 'nets':net_list,
- 'tenant_id':tenant_id, 'name':topo['name'],
- 'description':topo.get('description',topo['name']),
- 'public': topo.get('public', False)
- })
-
- return c
-
-
-@deprecated("Use new_nsd_v3")
-def new_scenario_v02(mydb, tenant_id, scenario_dict, version):
- """ This creates a new scenario for version 0.2 and 0.3"""
- scenario = scenario_dict["scenario"]
- if tenant_id != "any":
- check_tenant(mydb, tenant_id)
- if "tenant_id" in scenario:
- if scenario["tenant_id"] != tenant_id:
- # print "nfvo.new_scenario_v02() tenant '%s' not found" % tenant_id
- raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(
- scenario["tenant_id"], tenant_id), httperrors.Unauthorized)
- else:
- tenant_id=None
-
- # 1: Check that VNF are present at database table vnfs and update content into scenario dict
- for name,vnf in scenario["vnfs"].items():
- where = {"OR": {"tenant_id": tenant_id, 'public': "true"}}
- error_text = ""
- error_pos = "'scenario':'vnfs':'" + name + "'"
- if 'vnf_id' in vnf:
- error_text += " 'vnf_id' " + vnf['vnf_id']
- where['uuid'] = vnf['vnf_id']
- if 'vnf_name' in vnf:
- error_text += " 'vnf_name' " + vnf['vnf_name']
- where['name'] = vnf['vnf_name']
- if len(where) == 1:
- raise NfvoException("Needed a 'vnf_id' or 'vnf_name' at " + error_pos, httperrors.Bad_Request)
- vnf_db = mydb.get_rows(SELECT=('uuid', 'name', 'description'),
- FROM='vnfs',
- WHERE=where)
- if len(vnf_db) == 0:
- raise NfvoException("Unknown" + error_text + " at " + error_pos, httperrors.Not_Found)
- elif len(vnf_db) > 1:
- raise NfvoException("More than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", httperrors.Conflict)
- vnf['uuid'] = vnf_db[0]['uuid']
- vnf['description'] = vnf_db[0]['description']
- vnf['ifaces'] = {}
- # get external interfaces
- ext_ifaces = mydb.get_rows(SELECT=('external_name as name', 'i.uuid as iface_uuid', 'i.type as type'),
- FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
- WHERE={'vnfs.uuid':vnf['uuid'], 'external_name<>': None} )
- for ext_iface in ext_ifaces:
- vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type': ext_iface['type']}
- # TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly
-
- # 2: Insert net_key and ip_address at every vnf interface
- for net_name, net in scenario["networks"].items():
- net_type_bridge = False
- net_type_data = False
- for iface_dict in net["interfaces"]:
- if version == "0.2":
- temp_dict = iface_dict
- ip_address = None
- elif version == "0.3":
- temp_dict = {iface_dict["vnf"] : iface_dict["vnf_interface"]}
- ip_address = iface_dict.get('ip_address', None)
- for vnf, iface in temp_dict.items():
- if vnf not in scenario["vnfs"]:
- error_text = "Error at 'networks':'{}':'interfaces' VNF '{}' not match any VNF at 'vnfs'".format(
- net_name, vnf)
- # logger.debug("nfvo.new_scenario_v02 " + error_text)
- raise NfvoException(error_text, httperrors.Not_Found)
- if iface not in scenario["vnfs"][vnf]['ifaces']:
- error_text = "Error at 'networks':'{}':'interfaces':'{}' interface not match any VNF interface"\
- .format(net_name, iface)
- # logger.debug("nfvo.new_scenario_v02 " + error_text)
- raise NfvoException(error_text, httperrors.Bad_Request)
- if "net_key" in scenario["vnfs"][vnf]['ifaces'][iface]:
- error_text = "Error at 'networks':'{}':'interfaces':'{}' interface already connected at network"\
- "'{}'".format(net_name, iface,scenario["vnfs"][vnf]['ifaces'][iface]['net_key'])
- # logger.debug("nfvo.new_scenario_v02 " + error_text)
- raise NfvoException(error_text, httperrors.Bad_Request)
- scenario["vnfs"][vnf]['ifaces'][ iface ]['net_key'] = net_name
- scenario["vnfs"][vnf]['ifaces'][iface]['ip_address'] = ip_address
- iface_type = scenario["vnfs"][vnf]['ifaces'][iface]['type']
- if iface_type == 'mgmt' or iface_type == 'bridge':
- net_type_bridge = True
- else:
- net_type_data = True
-
- if net_type_bridge and net_type_data:
- error_text = "Error connection interfaces of 'bridge' type and 'data' type at 'networks':'{}':'interfaces'"\
- .format(net_name)
- # logger.debug("nfvo.new_scenario " + error_text)
- raise NfvoException(error_text, httperrors.Bad_Request)
- elif net_type_bridge:
- type_ = 'bridge'
- else:
- type_ = 'data' if len(net["interfaces"]) > 2 else 'ptp'
-
- if net.get("implementation"): # for v0.3
- if type_ == "bridge" and net["implementation"] == "underlay":
- error_text = "Error connecting interfaces of data type to a network declared as 'underlay' at "\
- "'network':'{}'".format(net_name)
- # logger.debug(error_text)
- raise NfvoException(error_text, httperrors.Bad_Request)
- elif type_ != "bridge" and net["implementation"] == "overlay":
- error_text = "Error connecting interfaces of data type to a network declared as 'overlay' at "\
- "'network':'{}'".format(net_name)
- # logger.debug(error_text)
- raise NfvoException(error_text, httperrors.Bad_Request)
- net.pop("implementation")
- if "type" in net and version == "0.3": # for v0.3
- if type_ == "data" and net["type"] == "e-line":
- error_text = "Error connecting more than 2 interfaces of data type to a network declared as type "\
- "'e-line' at 'network':'{}'".format(net_name)
- # logger.debug(error_text)
- raise NfvoException(error_text, httperrors.Bad_Request)
- elif type_ == "ptp" and net["type"] == "e-lan":
- type_ = "data"
-
- net['type'] = type_
- net['name'] = net_name
- net['external'] = net.get('external', False)
-
- # 3: insert at database
- scenario["nets"] = scenario["networks"]
- scenario['tenant_id'] = tenant_id
- scenario_id = mydb.new_scenario(scenario)
- return scenario_id
-
-
-def new_nsd_v3(mydb, tenant_id, nsd_descriptor):
- """
- Parses an OSM IM nsd_catalog and insert at DB
- :param mydb:
- :param tenant_id:
- :param nsd_descriptor:
- :return: The list of created NSD ids
- """
- try:
- mynsd = nsd_catalog.nsd()
- try:
- pybindJSONDecoder.load_ietf_json(nsd_descriptor, None, None, obj=mynsd, skip_unknown=True)
- except Exception as e:
- raise NfvoException("Error. Invalid NS descriptor format: " + str(e), httperrors.Bad_Request)
- db_scenarios = []
- db_sce_nets = []
- db_sce_vnfs = []
- db_sce_interfaces = []
- db_sce_vnffgs = []
- db_sce_rsps = []
- db_sce_rsp_hops = []
- db_sce_classifiers = []
- db_sce_classifier_matches = []
- db_ip_profiles = []
- db_ip_profiles_index = 0
- uuid_list = []
- nsd_uuid_list = []
- for nsd_yang in mynsd.nsd_catalog.nsd.values():
- nsd = nsd_yang.get()
-
- # table scenarios
- scenario_uuid = str(uuid4())
- uuid_list.append(scenario_uuid)
- nsd_uuid_list.append(scenario_uuid)
- db_scenario = {
- "uuid": scenario_uuid,
- "osm_id": get_str(nsd, "id", 255),
- "name": get_str(nsd, "name", 255),
- "description": get_str(nsd, "description", 255),
- "tenant_id": tenant_id,
- "vendor": get_str(nsd, "vendor", 255),
- "short_name": get_str(nsd, "short-name", 255),
- "descriptor": str(nsd_descriptor)[:60000],
- }
- db_scenarios.append(db_scenario)
-
- # table sce_vnfs (constituent-vnfd)
- vnf_index2scevnf_uuid = {}
- vnf_index2vnf_uuid = {}
- for vnf in nsd.get("constituent-vnfd").values():
- existing_vnf = mydb.get_rows(FROM="vnfs", WHERE={'osm_id': str(vnf["vnfd-id-ref"])[:255],
- 'tenant_id': tenant_id})
- if not existing_vnf:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'constituent-vnfd':'vnfd-id-ref':"
- "'{}'. Reference to a non-existing VNFD in the catalog".format(
- str(nsd["id"]), str(vnf["vnfd-id-ref"])[:255]),
- httperrors.Bad_Request)
- sce_vnf_uuid = str(uuid4())
- uuid_list.append(sce_vnf_uuid)
- db_sce_vnf = {
- "uuid": sce_vnf_uuid,
- "scenario_id": scenario_uuid,
- # "name": get_str(vnf, "member-vnf-index", 255),
- "name": existing_vnf[0]["name"][:200] + "." + get_str(vnf, "member-vnf-index", 50),
- "vnf_id": existing_vnf[0]["uuid"],
- "member_vnf_index": str(vnf["member-vnf-index"]),
- # TODO 'start-by-default': True
- }
- vnf_index2scevnf_uuid[str(vnf['member-vnf-index'])] = sce_vnf_uuid
- vnf_index2vnf_uuid[str(vnf['member-vnf-index'])] = existing_vnf[0]["uuid"]
- db_sce_vnfs.append(db_sce_vnf)
-
- # table ip_profiles (ip-profiles)
- ip_profile_name2db_table_index = {}
- for ip_profile in nsd.get("ip-profiles").values():
- db_ip_profile = {
- "ip_version": str(ip_profile["ip-profile-params"].get("ip-version", "ipv4")),
- "subnet_address": str(ip_profile["ip-profile-params"].get("subnet-address")),
- "gateway_address": str(ip_profile["ip-profile-params"].get("gateway-address")),
- "dhcp_enabled": str(ip_profile["ip-profile-params"]["dhcp-params"].get("enabled", True)),
- "dhcp_start_address": str(ip_profile["ip-profile-params"]["dhcp-params"].get("start-address")),
- "dhcp_count": str(ip_profile["ip-profile-params"]["dhcp-params"].get("count")),
- }
- dns_list = []
- for dns in ip_profile["ip-profile-params"]["dns-server"].values():
- dns_list.append(str(dns.get("address")))
- db_ip_profile["dns_address"] = ";".join(dns_list)
- if ip_profile["ip-profile-params"].get('security-group'):
- db_ip_profile["security_group"] = ip_profile["ip-profile-params"]['security-group']
- ip_profile_name2db_table_index[str(ip_profile["name"])] = db_ip_profiles_index
- db_ip_profiles_index += 1
- db_ip_profiles.append(db_ip_profile)
-
- # table sce_nets (internal-vld)
- for vld in nsd.get("vld").values():
- sce_net_uuid = str(uuid4())
- uuid_list.append(sce_net_uuid)
- db_sce_net = {
- "uuid": sce_net_uuid,
- "name": get_str(vld, "name", 255),
- "scenario_id": scenario_uuid,
- # "type": #TODO
- "multipoint": not vld.get("type") == "ELINE",
- "osm_id": get_str(vld, "id", 255),
- # "external": #TODO
- "description": get_str(vld, "description", 255),
- }
- # guess type of network
- if vld.get("mgmt-network"):
- db_sce_net["type"] = "bridge"
- db_sce_net["external"] = True
- elif vld.get("provider-network").get("overlay-type") == "VLAN":
- db_sce_net["type"] = "data"
- else:
- # later on it will be fixed to bridge or data depending on the type of interfaces attached to it
- db_sce_net["type"] = None
- db_sce_nets.append(db_sce_net)
-
- # ip-profile, link db_ip_profile with db_sce_net
- if vld.get("ip-profile-ref"):
- ip_profile_name = vld.get("ip-profile-ref")
- if ip_profile_name not in ip_profile_name2db_table_index:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'vld[{}]':'ip-profile-ref':'{}'."
- " Reference to a non-existing 'ip_profiles'".format(
- str(nsd["id"]), str(vld["id"]), str(vld["ip-profile-ref"])),
- httperrors.Bad_Request)
- db_ip_profiles[ip_profile_name2db_table_index[ip_profile_name]]["sce_net_id"] = sce_net_uuid
- elif vld.get("vim-network-name"):
- db_sce_net["vim_network_name"] = get_str(vld, "vim-network-name", 255)
-
- # table sce_interfaces (vld:vnfd-connection-point-ref)
- for iface in vld.get("vnfd-connection-point-ref").values():
- # Check if there are VDUs in the descriptor
- vnf_index = str(iface['member-vnf-index-ref'])
- existing_vdus = mydb.get_rows(SELECT=('vms.uuid'), FROM="vms", WHERE={'vnf_id': vnf_index2vnf_uuid[vnf_index]})
- if existing_vdus:
- # check correct parameters
- if vnf_index not in vnf_index2vnf_uuid:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'vld[{}]':'vnfd-connection-point"
- "-ref':'member-vnf-index-ref':'{}'. Reference to a non-existing index at "
- "'nsd':'constituent-vnfd'".format(
- str(nsd["id"]), str(vld["id"]), str(iface["member-vnf-index-ref"])),
- httperrors.Bad_Request)
-
- existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid', 'i.type as iface_type'),
- FROM="interfaces as i join vms on i.vm_id=vms.uuid",
- WHERE={'vnf_id': vnf_index2vnf_uuid[vnf_index],
- 'external_name': get_str(iface, "vnfd-connection-point-ref",
- 255)})
- if not existing_ifaces:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'vld[{}]':'vnfd-connection-point"
- "-ref':'vnfd-connection-point-ref':'{}'. Reference to a non-existing "
- "connection-point name at VNFD '{}'".format(
- str(nsd["id"]), str(vld["id"]), str(iface["vnfd-connection-point-ref"]),
- str(iface.get("vnfd-id-ref"))[:255]),
- httperrors.Bad_Request)
- interface_uuid = existing_ifaces[0]["uuid"]
- if existing_ifaces[0]["iface_type"] == "data":
- db_sce_net["type"] = "data"
- sce_interface_uuid = str(uuid4())
- uuid_list.append(sce_net_uuid)
- iface_ip_address = None
- if iface.get("ip-address"):
- iface_ip_address = str(iface.get("ip-address"))
- db_sce_interface = {
- "uuid": sce_interface_uuid,
- "sce_vnf_id": vnf_index2scevnf_uuid[vnf_index],
- "sce_net_id": sce_net_uuid,
- "interface_id": interface_uuid,
- "ip_address": iface_ip_address,
- }
- db_sce_interfaces.append(db_sce_interface)
- if not db_sce_net["type"]:
- db_sce_net["type"] = "bridge"
-
- # table sce_vnffgs (vnffgd)
- for vnffg in nsd.get("vnffgd").values():
- sce_vnffg_uuid = str(uuid4())
- uuid_list.append(sce_vnffg_uuid)
- db_sce_vnffg = {
- "uuid": sce_vnffg_uuid,
- "name": get_str(vnffg, "name", 255),
- "scenario_id": scenario_uuid,
- "vendor": get_str(vnffg, "vendor", 255),
- "description": get_str(vld, "description", 255),
- }
- db_sce_vnffgs.append(db_sce_vnffg)
-
- # deal with rsps
- for rsp in vnffg.get("rsp").values():
- sce_rsp_uuid = str(uuid4())
- uuid_list.append(sce_rsp_uuid)
- db_sce_rsp = {
- "uuid": sce_rsp_uuid,
- "name": get_str(rsp, "name", 255),
- "sce_vnffg_id": sce_vnffg_uuid,
- "id": get_str(rsp, "id", 255), # only useful to link with classifiers; will be removed later in the code
- }
- db_sce_rsps.append(db_sce_rsp)
- for iface in rsp.get("vnfd-connection-point-ref").values():
- vnf_index = str(iface['member-vnf-index-ref'])
- if_order = int(iface['order'])
- # check correct parameters
- if vnf_index not in vnf_index2vnf_uuid:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
- "-ref':'member-vnf-index-ref':'{}'. Reference to a non-existing index at "
- "'nsd':'constituent-vnfd'".format(
- str(nsd["id"]), str(rsp["id"]), str(iface["member-vnf-index-ref"])),
- httperrors.Bad_Request)
-
- ingress_existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid',),
- FROM="interfaces as i join vms on i.vm_id=vms.uuid",
- WHERE={
- 'vnf_id': vnf_index2vnf_uuid[vnf_index],
- 'external_name': get_str(iface, "vnfd-ingress-connection-point-ref",
- 255)})
- if not ingress_existing_ifaces:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
- "-ref':'vnfd-ingress-connection-point-ref':'{}'. Reference to a non-existing "
- "connection-point name at VNFD '{}'".format(
- str(nsd["id"]), str(rsp["id"]), str(iface["vnfd-ingress-connection-point-ref"]),
- str(iface.get("vnfd-id-ref"))[:255]), httperrors.Bad_Request)
-
- egress_existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid',),
- FROM="interfaces as i join vms on i.vm_id=vms.uuid",
- WHERE={
- 'vnf_id': vnf_index2vnf_uuid[vnf_index],
- 'external_name': get_str(iface, "vnfd-egress-connection-point-ref",
- 255)})
- if not egress_existing_ifaces:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
- "-ref':'vnfd-egress-connection-point-ref':'{}'. Reference to a non-existing "
- "connection-point name at VNFD '{}'".format(
- str(nsd["id"]), str(rsp["id"]), str(iface["vnfd-egress-connection-point-ref"]),
- str(iface.get("vnfd-id-ref"))[:255]), HTTP_Bad_Request)
-
- ingress_interface_uuid = ingress_existing_ifaces[0]["uuid"]
- egress_interface_uuid = egress_existing_ifaces[0]["uuid"]
- sce_rsp_hop_uuid = str(uuid4())
- uuid_list.append(sce_rsp_hop_uuid)
- db_sce_rsp_hop = {
- "uuid": sce_rsp_hop_uuid,
- "if_order": if_order,
- "ingress_interface_id": ingress_interface_uuid,
- "egress_interface_id": egress_interface_uuid,
- "sce_vnf_id": vnf_index2scevnf_uuid[vnf_index],
- "sce_rsp_id": sce_rsp_uuid,
- }
- db_sce_rsp_hops.append(db_sce_rsp_hop)
-
- # deal with classifiers
- for classifier in vnffg.get("classifier").values():
- sce_classifier_uuid = str(uuid4())
- uuid_list.append(sce_classifier_uuid)
-
- # source VNF
- vnf_index = str(classifier['member-vnf-index-ref'])
- if vnf_index not in vnf_index2vnf_uuid:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'classifier[{}]':'vnfd-connection-point"
- "-ref':'member-vnf-index-ref':'{}'. Reference to a non-existing index at "
- "'nsd':'constituent-vnfd'".format(
- str(nsd["id"]), str(classifier["id"]), str(classifier["member-vnf-index-ref"])),
- httperrors.Bad_Request)
- existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid',),
- FROM="interfaces as i join vms on i.vm_id=vms.uuid",
- WHERE={'vnf_id': vnf_index2vnf_uuid[vnf_index],
- 'external_name': get_str(classifier, "vnfd-connection-point-ref",
- 255)})
- if not existing_ifaces:
- raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
- "-ref':'vnfd-connection-point-ref':'{}'. Reference to a non-existing "
- "connection-point name at VNFD '{}'".format(
- str(nsd["id"]), str(rsp["id"]), str(iface["vnfd-connection-point-ref"]),
- str(iface.get("vnfd-id-ref"))[:255]),
- httperrors.Bad_Request)
- interface_uuid = existing_ifaces[0]["uuid"]
-
- db_sce_classifier = {
- "uuid": sce_classifier_uuid,
- "name": get_str(classifier, "name", 255),
- "sce_vnffg_id": sce_vnffg_uuid,
- "sce_vnf_id": vnf_index2scevnf_uuid[vnf_index],
- "interface_id": interface_uuid,
- }
- rsp_id = get_str(classifier, "rsp-id-ref", 255)
- rsp = next((item for item in db_sce_rsps if item["id"] == rsp_id), None)
- db_sce_classifier["sce_rsp_id"] = rsp["uuid"]
- db_sce_classifiers.append(db_sce_classifier)
-
- for match in classifier.get("match-attributes").values():
- sce_classifier_match_uuid = str(uuid4())
- uuid_list.append(sce_classifier_match_uuid)
- db_sce_classifier_match = {
- "uuid": sce_classifier_match_uuid,
- "ip_proto": get_str(match, "ip-proto", 2),
- "source_ip": get_str(match, "source-ip-address", 16),
- "destination_ip": get_str(match, "destination-ip-address", 16),
- "source_port": get_str(match, "source-port", 5),
- "destination_port": get_str(match, "destination-port", 5),
- "sce_classifier_id": sce_classifier_uuid,
- }
- db_sce_classifier_matches.append(db_sce_classifier_match)
- # TODO: vnf/cp keys
-
- # remove unneeded id's in sce_rsps
- for rsp in db_sce_rsps:
- rsp.pop('id')
-
- db_tables = [
- {"scenarios": db_scenarios},
- {"sce_nets": db_sce_nets},
- {"ip_profiles": db_ip_profiles},
- {"sce_vnfs": db_sce_vnfs},
- {"sce_interfaces": db_sce_interfaces},
- {"sce_vnffgs": db_sce_vnffgs},
- {"sce_rsps": db_sce_rsps},
- {"sce_rsp_hops": db_sce_rsp_hops},
- {"sce_classifiers": db_sce_classifiers},
- {"sce_classifier_matches": db_sce_classifier_matches},
- ]
-
- logger.debug("new_nsd_v3 done: %s",
- yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
- mydb.new_rows(db_tables, uuid_list)
- return nsd_uuid_list
- except NfvoException:
- raise
- except Exception as e:
- logger.error("Exception {}".format(e))
- raise # NfvoException("Exception {}".format(e), httperrors.Bad_Request)
-
-
-def edit_scenario(mydb, tenant_id, scenario_id, data):
- data["uuid"] = scenario_id
- data["tenant_id"] = tenant_id
- c = mydb.edit_scenario( data )
- return c
-
-
-@deprecated("Use create_instance")
-def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instance_scenario_description, datacenter=None,vim_tenant=None, startvms=True):
- #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter, vim_tenant=vim_tenant)
- vims = {datacenter_id: myvim}
- myvim_tenant = myvim['tenant_id']
- datacenter_name = myvim['name']
-
- rollbackList=[]
- try:
- #print "Checking that the scenario_id exists and getting the scenario dictionary"
- scenarioDict = mydb.get_scenario(scenario_id, tenant_id, datacenter_id=datacenter_id)
- scenarioDict['datacenter2tenant'] = { datacenter_id: myvim['config']['datacenter_tenant_id'] }
- scenarioDict['datacenter_id'] = datacenter_id
- #print '================scenarioDict======================='
- #print json.dumps(scenarioDict, indent=4)
- #print 'BEGIN launching instance scenario "%s" based on "%s"' % (instance_scenario_name,scenarioDict['name'])
-
- logger.debug("start_scenario Scenario %s: consisting of %d VNF(s)", scenarioDict['name'],len(scenarioDict['vnfs']))
- #print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)
-
- auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id
- auxNetDict['scenario'] = {}
-
- logger.debug("start_scenario 1. Creating new nets (sce_nets) in the VIM")
- for sce_net in scenarioDict['nets']:
- #print "Net name: %s. Description: %s" % (sce_net["name"], sce_net["description"])
-
- myNetName = "{}.{}".format(instance_scenario_name, sce_net['name'])
- myNetName = myNetName[0:255] #limit length
- myNetType = sce_net['type']
- myNetDict = {}
- myNetDict["name"] = myNetName
- myNetDict["type"] = myNetType
- myNetDict["tenant_id"] = myvim_tenant
- myNetIPProfile = sce_net.get('ip_profile', None)
- myProviderNetwork = sce_net.get('provider_network', None)
- #TODO:
- #We should use the dictionary as input parameter for new_network
- #print myNetDict
- if not sce_net["external"]:
- network_id, _ = myvim.new_network(myNetName, myNetType, myNetIPProfile, provider_network_profile=myProviderNetwork)
- #print "New VIM network created for scenario %s. Network id: %s" % (scenarioDict['name'],network_id)
- sce_net['vim_id'] = network_id
- auxNetDict['scenario'][sce_net['uuid']] = network_id
- rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id})
- sce_net["created"] = True
- else:
- if sce_net['vim_id'] == None:
- error_text = "Error, datacenter '{}' does not have external network '{}'.".format(
- datacenter_name, sce_net['name'])
- _, message = rollback(mydb, vims, rollbackList)
- logger.error("nfvo.start_scenario: %s", error_text)
- raise NfvoException(error_text, httperrors.Bad_Request)
- logger.debug("Using existent VIM network for scenario %s. Network id %s", scenarioDict['name'],sce_net['vim_id'])
- auxNetDict['scenario'][sce_net['uuid']] = sce_net['vim_id']
-
- logger.debug("start_scenario 2. Creating new nets (vnf internal nets) in the VIM")
- #For each vnf net, we create it and we add it to instanceNetlist.
-
- for sce_vnf in scenarioDict['vnfs']:
- for net in sce_vnf['nets']:
- #print "Net name: %s. Description: %s" % (net["name"], net["description"])
-
- myNetName = "{}.{}".format(instance_scenario_name,net['name'])
- myNetName = myNetName[0:255] #limit length
- myNetType = net['type']
- myNetDict = {}
- myNetDict["name"] = myNetName
- myNetDict["type"] = myNetType
- myNetDict["tenant_id"] = myvim_tenant
- myNetIPProfile = net.get('ip_profile', None)
- myProviderNetwork = sce_net.get('provider_network', None)
- #print myNetDict
- #TODO:
- #We should use the dictionary as input parameter for new_network
- network_id, _ = myvim.new_network(myNetName, myNetType, myNetIPProfile, provider_network_profile=myProviderNetwork)
- #print "VIM network id for scenario %s: %s" % (scenarioDict['name'],network_id)
- net['vim_id'] = network_id
- if sce_vnf['uuid'] not in auxNetDict:
- auxNetDict[sce_vnf['uuid']] = {}
- auxNetDict[sce_vnf['uuid']][net['uuid']] = network_id
- rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id})
- net["created"] = True
-
- #print "auxNetDict:"
- #print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False)
-
- logger.debug("start_scenario 3. Creating new vm instances in the VIM")
- #myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
- i = 0
- for sce_vnf in scenarioDict['vnfs']:
- vnf_availability_zones = []
- for vm in sce_vnf['vms']:
- vm_av = vm.get('availability_zone')
- if vm_av and vm_av not in vnf_availability_zones:
- vnf_availability_zones.append(vm_av)
-
- # check if there is enough availability zones available at vim level.
- if myvims[datacenter_id].availability_zone and vnf_availability_zones:
- if len(vnf_availability_zones) > len(myvims[datacenter_id].availability_zone):
- raise NfvoException('No enough availability zones at VIM for this deployment', httperrors.Bad_Request)
-
- for vm in sce_vnf['vms']:
- i += 1
- myVMDict = {}
- #myVMDict['name'] = "%s-%s-%s" % (scenarioDict['name'],sce_vnf['name'], vm['name'])
- myVMDict['name'] = "{}.{}.{}".format(instance_scenario_name,sce_vnf['name'],chr(96+i))
- #myVMDict['description'] = vm['description']
- myVMDict['description'] = myVMDict['name'][0:99]
- if not startvms:
- myVMDict['start'] = "no"
- myVMDict['name'] = myVMDict['name'][0:255] #limit name length
- #print "VM name: %s. Description: %s" % (myVMDict['name'], myVMDict['name'])
-
- #create image at vim in case it not exist
- image_dict = mydb.get_table_by_uuid_name("images", vm['image_id'])
- image_id = create_or_use_image(mydb, vims, image_dict, [], True)
- vm['vim_image_id'] = image_id
-
- #create flavor at vim in case it not exist
- flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id'])
- if flavor_dict['extended']!=None:
- flavor_dict['extended']= yaml.load(flavor_dict['extended'], Loader=yaml.Loader)
- flavor_id = create_or_use_flavor(mydb, vims, flavor_dict, [], True)
- vm['vim_flavor_id'] = flavor_id
-
-
- myVMDict['imageRef'] = vm['vim_image_id']
- myVMDict['flavorRef'] = vm['vim_flavor_id']
- myVMDict['networks'] = []
- for iface in vm['interfaces']:
- netDict = {}
- if iface['type']=="data":
- netDict['type'] = iface['model']
- elif "model" in iface and iface["model"]!=None:
- netDict['model']=iface['model']
- #TODO in future, remove this because mac_address will not be set, and the type of PV,VF is obtained from iterface table model
- #discover type of interface looking at flavor
- for numa in flavor_dict.get('extended',{}).get('numas',[]):
- for flavor_iface in numa.get('interfaces',[]):
- if flavor_iface.get('name') == iface['internal_name']:
- if flavor_iface['dedicated'] == 'yes':
- netDict['type']="PF" #passthrough
- elif flavor_iface['dedicated'] == 'no':
- netDict['type']="VF" #siov
- elif flavor_iface['dedicated'] == 'yes:sriov':
- netDict['type']="VFnotShared" #sriov but only one sriov on the PF
- netDict["mac_address"] = flavor_iface.get("mac_address")
- break;
- netDict["use"]=iface['type']
- if netDict["use"]=="data" and not netDict.get("type"):
- #print "netDict", netDict
- #print "iface", iface
- e_text = "Cannot determine the interface type PF or VF of VNF '{}' VM '{}' iface '{}'".format(
- sce_vnf['name'], vm['name'], iface['internal_name'])
- if flavor_dict.get('extended')==None:
- raise NfvoException(e_text + "After database migration some information is not available. \
- Try to delete and create the scenarios and VNFs again", httperrors.Conflict)
- else:
- raise NfvoException(e_text, httperrors.Internal_Server_Error)
- if netDict["use"]=="mgmt" or netDict["use"]=="bridge":
- netDict["type"]="virtual"
- if "vpci" in iface and iface["vpci"] is not None:
- netDict['vpci'] = iface['vpci']
- if "mac" in iface and iface["mac"] is not None:
- netDict['mac_address'] = iface['mac']
- if "port-security" in iface and iface["port-security"] is not None:
- netDict['port_security'] = iface['port-security']
- if "floating-ip" in iface and iface["floating-ip"] is not None:
- netDict['floating_ip'] = iface['floating-ip']
- netDict['name'] = iface['internal_name']
- if iface['net_id'] is None:
- for vnf_iface in sce_vnf["interfaces"]:
- #print iface
- #print vnf_iface
- if vnf_iface['interface_id']==iface['uuid']:
- netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ]
- break
- else:
- netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ]
- #skip bridge ifaces not connected to any net
- #if 'net_id' not in netDict or netDict['net_id']==None:
- # continue
- myVMDict['networks'].append(netDict)
- #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
- #print myVMDict['name']
- #print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False)
- #print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False)
- #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
-
- if 'availability_zone' in myVMDict:
- av_index = vnf_availability_zones.index(myVMDict['availability_zone'])
- else:
- av_index = None
-
- vm_id, _ = myvim.new_vminstance(myVMDict['name'], myVMDict['description'], myVMDict.get('start', None),
- myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'],
- availability_zone_index=av_index,
- availability_zone_list=vnf_availability_zones)
- #print "VIM vm instance id (server id) for scenario %s: %s" % (scenarioDict['name'],vm_id)
- vm['vim_id'] = vm_id
- rollbackList.append({'what':'vm','where':'vim','vim_id':datacenter_id,'uuid':vm_id})
- #put interface uuid back to scenario[vnfs][vms[[interfaces]
- for net in myVMDict['networks']:
- if "vim_id" in net:
- for iface in vm['interfaces']:
- if net["name"]==iface["internal_name"]:
- iface["vim_id"]=net["vim_id"]
- break
-
- logger.debug("start scenario Deployment done")
- #print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)
- #r,c = mydb.new_instance_scenario_as_a_whole(nfvo_tenant,scenarioDict['name'],scenarioDict)
- instance_id = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_scenario_name, instance_scenario_description, scenarioDict)
- return mydb.get_instance_scenario(instance_id)
-
- except (db_base_Exception, vimconn.VimConnException) as e:
- _, message = rollback(mydb, vims, rollbackList)
- if isinstance(e, db_base_Exception):
- error_text = "Exception at database"
- else:
- error_text = "Exception at VIM"
- error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
- #logger.error("start_scenario %s", error_text)
- raise NfvoException(error_text, e.http_code)
-
-def unify_cloud_config(cloud_config_preserve, cloud_config):
- """ join the cloud config information into cloud_config_preserve.
- In case of conflict cloud_config_preserve preserves
- None is allowed
- """
- if not cloud_config_preserve and not cloud_config:
- return None
-
- new_cloud_config = {"key-pairs":[], "users":[]}
- # key-pairs
- if cloud_config_preserve:
- for key in cloud_config_preserve.get("key-pairs", () ):
- if key not in new_cloud_config["key-pairs"]:
- new_cloud_config["key-pairs"].append(key)
- if cloud_config:
- for key in cloud_config.get("key-pairs", () ):
- if key not in new_cloud_config["key-pairs"]:
- new_cloud_config["key-pairs"].append(key)
- if not new_cloud_config["key-pairs"]:
- del new_cloud_config["key-pairs"]
-
- # users
- if cloud_config:
- new_cloud_config["users"] += cloud_config.get("users", () )
- if cloud_config_preserve:
- new_cloud_config["users"] += cloud_config_preserve.get("users", () )
- index_to_delete = []
- users = new_cloud_config.get("users", [])
- for index0 in range(0,len(users)):
- if index0 in index_to_delete:
- continue
- for index1 in range(index0+1,len(users)):
- if index1 in index_to_delete:
- continue
- if users[index0]["name"] == users[index1]["name"]:
- index_to_delete.append(index1)
- for key in users[index1].get("key-pairs",()):
- if "key-pairs" not in users[index0]:
- users[index0]["key-pairs"] = [key]
- elif key not in users[index0]["key-pairs"]:
- users[index0]["key-pairs"].append(key)
- index_to_delete.sort(reverse=True)
- for index in index_to_delete:
- del users[index]
- if not new_cloud_config["users"]:
- del new_cloud_config["users"]
-
- #boot-data-drive
- if cloud_config and cloud_config.get("boot-data-drive") != None:
- new_cloud_config["boot-data-drive"] = cloud_config["boot-data-drive"]
- if cloud_config_preserve and cloud_config_preserve.get("boot-data-drive") != None:
- new_cloud_config["boot-data-drive"] = cloud_config_preserve["boot-data-drive"]
-
- # user-data
- new_cloud_config["user-data"] = []
- if cloud_config and cloud_config.get("user-data"):
- if isinstance(cloud_config["user-data"], list):
- new_cloud_config["user-data"] += cloud_config["user-data"]
- else:
- new_cloud_config["user-data"].append(cloud_config["user-data"])
- if cloud_config_preserve and cloud_config_preserve.get("user-data"):
- if isinstance(cloud_config_preserve["user-data"], list):
- new_cloud_config["user-data"] += cloud_config_preserve["user-data"]
- else:
- new_cloud_config["user-data"].append(cloud_config_preserve["user-data"])
- if not new_cloud_config["user-data"]:
- del new_cloud_config["user-data"]
-
- # config files
- new_cloud_config["config-files"] = []
- if cloud_config and cloud_config.get("config-files") != None:
- new_cloud_config["config-files"] += cloud_config["config-files"]
- if cloud_config_preserve:
- for file in cloud_config_preserve.get("config-files", ()):
- for index in range(0, len(new_cloud_config["config-files"])):
- if new_cloud_config["config-files"][index]["dest"] == file["dest"]:
- new_cloud_config["config-files"][index] = file
- break
- else:
- new_cloud_config["config-files"].append(file)
- if not new_cloud_config["config-files"]:
- del new_cloud_config["config-files"]
- return new_cloud_config
-
-
-def get_vim_thread(mydb, tenant_id, datacenter_id_name=None, datacenter_tenant_id=None):
- global plugins
- datacenter_id = None
- datacenter_name = None
- thread = None
- try:
- if datacenter_tenant_id:
- thread_id = datacenter_tenant_id
- thread = vim_threads["running"].get(datacenter_tenant_id)
- if not thread:
- where_={"td.nfvo_tenant_id": tenant_id}
- if datacenter_id_name:
- if utils.check_valid_uuid(datacenter_id_name):
- datacenter_id = datacenter_id_name
- where_["dt.datacenter_id"] = datacenter_id
- else:
- datacenter_name = datacenter_id_name
- where_["d.name"] = datacenter_name
- if datacenter_tenant_id:
- where_["dt.uuid"] = datacenter_tenant_id
- datacenters = mydb.get_rows(
- SELECT=("dt.uuid as datacenter_tenant_id, d.name as datacenter_name", "d.type as type"),
- FROM="datacenter_tenants as dt join tenants_datacenters as td on dt.uuid=td.datacenter_tenant_id "
- "join datacenters as d on d.uuid=dt.datacenter_id",
- WHERE=where_)
- if len(datacenters) > 1:
- raise NfvoException("More than one datacenters found, try to identify with uuid", httperrors.Conflict)
- elif datacenters:
- thread_id = datacenters[0]["datacenter_tenant_id"]
- datacenter_name = datacenters[0]["datacenter_name"]
- thread = vim_threads["running"].get(thread_id)
- if not thread:
- datacenter_type = datacenters[0]["type"]
- plugin_name = "rovim_" + datacenter_type
- if plugin_name not in plugins:
- _load_plugin(plugin_name, type="vim")
- thread_name = get_non_used_vim_name(datacenter_name, datacenter_id)
- thread = vim_thread(task_lock, plugins, thread_name, None,
- thread_id, db=mydb)
- thread.start()
- vim_threads["running"][thread_id] = thread
- if not thread:
- raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), httperrors.Not_Found)
- return thread_id, thread
- except db_base_Exception as e:
- raise NfvoException("{} {}".format(type(e).__name__ , str(e)), e.http_code)
-
-
-def get_datacenter_uuid(mydb, tenant_id, datacenter_id_name):
- WHERE_dict={}
- if utils.check_valid_uuid(datacenter_id_name):
- WHERE_dict['d.uuid'] = datacenter_id_name
- else:
- WHERE_dict['d.name'] = datacenter_id_name
-
- if tenant_id:
- WHERE_dict['nfvo_tenant_id'] = tenant_id
- from_= "tenants_datacenters as td join datacenters as d on td.datacenter_id=d.uuid join datacenter_tenants as" \
- " dt on td.datacenter_tenant_id=dt.uuid"
- else:
- from_ = 'datacenters as d'
- vimaccounts = mydb.get_rows(FROM=from_, SELECT=("d.uuid as uuid", "d.name as name", "d.type as type"),
- WHERE=WHERE_dict)
- if len(vimaccounts) == 0:
- raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), httperrors.Not_Found)
- elif len(vimaccounts) > 1:
- # print "nfvo.datacenter_action() error. Several datacenters found"
- raise NfvoException("More than one datacenters found, try to identify with uuid", httperrors.Conflict)
- return vimaccounts[0]["uuid"], vimaccounts[0]
-
-
-def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter):
- datacenter_id = None
- datacenter_name = None
- if datacenter_id_name:
- if utils.check_valid_uuid(datacenter_id_name):
- datacenter_id = datacenter_id_name
- else:
- datacenter_name = datacenter_id_name
- vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, **extra_filter)
- if len(vims) == 0:
- raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), httperrors.Not_Found)
- elif len(vims)>1:
- #print "nfvo.datacenter_action() error. Several datacenters found"
- raise NfvoException("More than one datacenters found, try to identify with uuid", httperrors.Conflict)
- for vim_id, vim_content in vims.items():
- return vim_id, vim_content
-
-
-def update(d, u):
- """Takes dict d and updates it with the values in dict u.
- It merges all depth levels"""
- for k, v in u.items():
- if isinstance(v, collections.Mapping):
- r = update(d.get(k, {}), v)
- d[k] = r
- else:
- d[k] = u[k]
- return d
-
-
-def _get_wim(db, wim_account_id):
- # get wim from wim_account
- wim_accounts = db.get_rows(FROM='wim_accounts', WHERE={"uuid": wim_account_id})
- if not wim_accounts:
- raise NfvoException("Not found sdn id={}".format(wim_account_id), http_code=httperrors.Not_Found)
- return wim_accounts[0]["wim_id"]
-
-
-def create_instance(mydb, tenant_id, instance_dict):
- # print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
- # logger.debug("Creating instance...")
-
- scenario = instance_dict["scenario"]
-
- # find main datacenter
- myvims = {}
- myvim_threads_id = {}
- datacenter = instance_dict.get("datacenter")
- default_wim_account = instance_dict.get("wim_account")
- default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
- myvims[default_datacenter_id] = vim
- myvim_threads_id[default_datacenter_id], _ = get_vim_thread(mydb, tenant_id, default_datacenter_id)
- tenant = mydb.get_rows_by_id('nfvo_tenants', tenant_id)
- # myvim_tenant = myvim['tenant_id']
- rollbackList = []
-
- # print "Checking that the scenario exists and getting the scenario dictionary"
- if isinstance(scenario, str):
- scenarioDict = mydb.get_scenario(scenario, tenant_id, datacenter_vim_id=myvim_threads_id[default_datacenter_id],
- datacenter_id=default_datacenter_id)
- else:
- scenarioDict = scenario
- scenarioDict["uuid"] = None
-
- # logger.debug(">>>>>> Dictionaries before merging")
- # logger.debug(">>>>>> InstanceDict:\n{}".format(yaml.safe_dump(instance_dict,default_flow_style=False, width=256)))
- # logger.debug(">>>>>> ScenarioDict:\n{}".format(yaml.safe_dump(scenarioDict,default_flow_style=False, width=256)))
-
- db_instance_vnfs = []
- db_instance_vms = []
- db_instance_interfaces = []
- db_instance_sfis = []
- db_instance_sfs = []
- db_instance_classifications = []
- db_instance_sfps = []
- db_ip_profiles = []
- db_vim_actions = []
- uuid_list = []
- task_index = 0
- instance_name = instance_dict["name"]
- instance_uuid = str(uuid4())
- uuid_list.append(instance_uuid)
- db_instance_scenario = {
- "uuid": instance_uuid,
- "name": instance_name,
- "tenant_id": tenant_id,
- "scenario_id": scenarioDict['uuid'],
- "datacenter_id": default_datacenter_id,
- # filled bellow 'datacenter_tenant_id'
- "description": instance_dict.get("description"),
- }
- if scenarioDict.get("cloud-config"):
- db_instance_scenario["cloud_config"] = yaml.safe_dump(scenarioDict["cloud-config"],
- default_flow_style=True, width=256)
- instance_action_id = get_task_id()
- db_instance_action = {
- "uuid": instance_action_id, # same uuid for the instance and the action on create
- "tenant_id": tenant_id,
- "instance_id": instance_uuid,
- "description": "CREATE",
- }
-
- # Auxiliary dictionaries from x to y
- sce_net2wim_instance = {}
- sce_net2instance = {}
- net2task_id = {'scenario': {}}
- # Mapping between local networks and WIMs
- wim_usage = {}
-
- def ip_profile_IM2RO(ip_profile_im):
- # translate from input format to database format
- ip_profile_ro = {}
- if 'subnet-address' in ip_profile_im:
- ip_profile_ro['subnet_address'] = ip_profile_im['subnet-address']
- if 'ip-version' in ip_profile_im:
- ip_profile_ro['ip_version'] = ip_profile_im['ip-version']
- if 'gateway-address' in ip_profile_im:
- ip_profile_ro['gateway_address'] = ip_profile_im['gateway-address']
- if 'dns-address' in ip_profile_im:
- ip_profile_ro['dns_address'] = ip_profile_im['dns-address']
- if isinstance(ip_profile_ro['dns_address'], (list, tuple)):
- ip_profile_ro['dns_address'] = ";".join(ip_profile_ro['dns_address'])
- if 'dhcp' in ip_profile_im:
- ip_profile_ro['dhcp_start_address'] = ip_profile_im['dhcp'].get('start-address')
- ip_profile_ro['dhcp_enabled'] = ip_profile_im['dhcp'].get('enabled', True)
- ip_profile_ro['dhcp_count'] = ip_profile_im['dhcp'].get('count')
- return ip_profile_ro
-
- # logger.debug("Creating instance from scenario-dict:\n%s",
- # yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False))
- try:
- # 0 check correct parameters
- for net_name, net_instance_desc in instance_dict.get("networks", {}).items():
- for scenario_net in scenarioDict['nets']:
- if net_name == scenario_net.get("name") or net_name == scenario_net.get("osm_id") or net_name == scenario_net.get("uuid"):
- break
- else:
- raise NfvoException("Invalid scenario network name or id '{}' at instance:networks".format(net_name),
- httperrors.Bad_Request)
- if "sites" not in net_instance_desc:
- net_instance_desc["sites"] = [ {} ]
- site_without_datacenter_field = False
- for site in net_instance_desc["sites"]:
- if site.get("datacenter"):
- site["datacenter"], _ = get_datacenter_uuid(mydb, tenant_id, site["datacenter"])
- if site["datacenter"] not in myvims:
- # Add this datacenter to myvims
- d, v = get_datacenter_by_name_uuid(mydb, tenant_id, site["datacenter"])
- myvims[d] = v
- myvim_threads_id[d], _ = get_vim_thread(mydb, tenant_id, site["datacenter"])
- site["datacenter"] = d # change name to id
- else:
- if site_without_datacenter_field:
- raise NfvoException("Found more than one entries without datacenter field at "
- "instance:networks:{}:sites".format(net_name), httperrors.Bad_Request)
- site_without_datacenter_field = True
- site["datacenter"] = default_datacenter_id # change name to id
-
- for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).items():
- for scenario_vnf in scenarioDict['vnfs']:
- if vnf_name == scenario_vnf['member_vnf_index'] or vnf_name == scenario_vnf['uuid'] or vnf_name == scenario_vnf['name']:
- break
- else:
- raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_name), httperrors.Bad_Request)
- if "datacenter" in vnf_instance_desc:
- # Add this datacenter to myvims
- vnf_instance_desc["datacenter"], _ = get_datacenter_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"])
- if vnf_instance_desc["datacenter"] not in myvims:
- d, v = get_datacenter_by_name_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"])
- myvims[d] = v
- myvim_threads_id[d], _ = get_vim_thread(mydb, tenant_id, vnf_instance_desc["datacenter"])
- scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"]
-
- for net_id, net_instance_desc in vnf_instance_desc.get("networks", {}).items():
- for scenario_net in scenario_vnf['nets']:
- if net_id == scenario_net['osm_id'] or net_id == scenario_net['uuid'] or net_id == scenario_net["name"]:
- break
- else:
- raise NfvoException("Invalid net id or name '{}' at instance:vnfs:networks".format(net_id), httperrors.Bad_Request)
- if net_instance_desc.get("vim-network-name"):
- scenario_net["vim-network-name"] = net_instance_desc["vim-network-name"]
- if net_instance_desc.get("vim-network-id"):
- scenario_net["vim-network-id"] = net_instance_desc["vim-network-id"]
- if net_instance_desc.get("name"):
- scenario_net["name"] = net_instance_desc["name"]
- if 'ip-profile' in net_instance_desc:
- ipprofile_db = ip_profile_IM2RO(net_instance_desc['ip-profile'])
- if 'ip_profile' not in scenario_net:
- scenario_net['ip_profile'] = ipprofile_db
- else:
- update(scenario_net['ip_profile'], ipprofile_db)
-
- if net_instance_desc.get('provider-network'):
- provider_network_db = net_instance_desc['provider-network']
- if 'provider_network' not in scenario_net:
- scenario_net['provider_network'] = provider_network_db
- else:
- update(scenario_net['provider_network'], provider_network_db)
-
- for vdu_id, vdu_instance_desc in vnf_instance_desc.get("vdus", {}).items():
- for scenario_vm in scenario_vnf['vms']:
- if vdu_id == scenario_vm['osm_id'] or vdu_id == scenario_vm["name"]:
- break
- else:
- raise NfvoException("Invalid vdu id or name '{}' at instance:vnfs:vdus".format(vdu_id), httperrors.Bad_Request)
- scenario_vm["instance_parameters"] = vdu_instance_desc
- for iface_id, iface_instance_desc in vdu_instance_desc.get("interfaces", {}).items():
- for scenario_interface in scenario_vm['interfaces']:
- if iface_id == scenario_interface['internal_name'] or iface_id == scenario_interface["external_name"]:
- scenario_interface.update(iface_instance_desc)
- break
- else:
- raise NfvoException("Invalid vdu id or name '{}' at instance:vnfs:vdus".format(vdu_id), httperrors.Bad_Request)
-
- # 0.1 parse cloud-config parameters
- cloud_config = unify_cloud_config(instance_dict.get("cloud-config"), scenarioDict.get("cloud-config"))
-
- # 0.2 merge instance information into scenario
- # Ideally, the operation should be as simple as: update(scenarioDict,instance_dict)
- # However, this is not possible yet.
- for net_name, net_instance_desc in instance_dict.get("networks", {}).items():
- for scenario_net in scenarioDict['nets']:
- if net_name == scenario_net.get("name") or net_name == scenario_net.get("osm_id") or net_name == scenario_net.get("uuid"):
- if "wim_account" in net_instance_desc and net_instance_desc["wim_account"] is not None:
- scenario_net["wim_account"] = net_instance_desc["wim_account"]
- if 'ip-profile' in net_instance_desc:
- ipprofile_db = ip_profile_IM2RO(net_instance_desc['ip-profile'])
- if 'ip_profile' not in scenario_net:
- scenario_net['ip_profile'] = ipprofile_db
- else:
- update(scenario_net['ip_profile'], ipprofile_db)
- if 'provider-network' in net_instance_desc:
- provider_network_db = net_instance_desc['provider-network']
-
- if 'provider-network' not in scenario_net:
- scenario_net['provider_network'] = provider_network_db
- else:
- update(scenario_net['provider-network'], provider_network_db)
-
- for interface in net_instance_desc.get('interfaces', ()):
- if 'ip_address' in interface:
- for vnf in scenarioDict['vnfs']:
- if interface['vnf'] == vnf['name']:
- for vnf_interface in vnf['interfaces']:
- if interface['vnf_interface'] == vnf_interface['external_name']:
- vnf_interface['ip_address'] = interface['ip_address']
-
- # logger.debug(">>>>>>>> Merged dictionary")
- # logger.debug("Creating instance scenario-dict MERGED:\n%s",
- # yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False))
-
-
- # 1. Creating new nets (sce_nets) in the VIM"
- number_mgmt_networks = 0
- db_instance_nets = []
- db_instance_wim_nets = []
- for sce_net in scenarioDict['nets']:
-
- sce_net_uuid = sce_net.get('uuid', sce_net["name"])
- # get involved datacenters where this network need to be created
- involved_datacenters = []
- for sce_vnf in scenarioDict.get("vnfs", ()):
- vnf_datacenter = sce_vnf.get("datacenter", default_datacenter_id)
- if vnf_datacenter in involved_datacenters:
- continue
- if sce_vnf.get("interfaces"):
- for sce_vnf_ifaces in sce_vnf["interfaces"]:
- if sce_vnf_ifaces.get("sce_net_id") == sce_net["uuid"]:
- involved_datacenters.append(vnf_datacenter)
- break
- if not involved_datacenters:
- involved_datacenters.append(default_datacenter_id)
- target_wim_account = sce_net.get("wim_account", default_wim_account)
-
- descriptor_net = {}
- if instance_dict.get("networks"):
- if sce_net.get("uuid") in instance_dict["networks"]:
- descriptor_net = instance_dict["networks"][sce_net["uuid"]]
- descriptor_net_name = sce_net["uuid"]
- elif sce_net.get("osm_id") in instance_dict["networks"]:
- descriptor_net = instance_dict["networks"][sce_net["osm_id"]]
- descriptor_net_name = sce_net["osm_id"]
- elif sce_net["name"] in instance_dict["networks"]:
- descriptor_net = instance_dict["networks"][sce_net["name"]]
- descriptor_net_name = sce_net["name"]
- net_name = descriptor_net.get("vim-network-name")
- # add datacenters from instantiation parameters
- if descriptor_net.get("sites"):
- for site in descriptor_net["sites"]:
- if site.get("datacenter") and site["datacenter"] not in involved_datacenters:
- involved_datacenters.append(site["datacenter"])
- sce_net2instance[sce_net_uuid] = {}
- sce_net2wim_instance[sce_net_uuid] = {}
- net2task_id['scenario'][sce_net_uuid] = {}
-
- use_network = None
- related_network = None
- if descriptor_net.get("use-network"):
- target_instance_nets = mydb.get_rows(
- SELECT="related",
- FROM="instance_nets",
- WHERE={"instance_scenario_id": descriptor_net["use-network"]["instance_scenario_id"],
- "osm_id": descriptor_net["use-network"]["osm_id"]},
- )
- if not target_instance_nets:
- raise NfvoException(
- "Cannot find the target network at instance:networks[{}]:use-network".format(
- descriptor_net_name), httperrors.Bad_Request)
- else:
- use_network = target_instance_nets[0]["related"]
-
- if sce_net["external"]:
- number_mgmt_networks += 1
-
- # --> WIM
- # TODO: use this information during network creation
- wim_account_id = wim_account_name = None
- if len(involved_datacenters) > 1 and 'uuid' in sce_net:
- urls = [myvims[v].url for v in involved_datacenters]
- if len(set(urls)) < 2:
- wim_usage[sce_net['uuid']] = False
- elif target_wim_account is None or target_wim_account is True: # automatic selection of WIM
- # OBS: sce_net without uuid are used internally to VNFs
- # and the assumption is that VNFs will not be split among
- # different datacenters
- wim_account = wim_engine.find_suitable_wim_account(
- involved_datacenters, tenant_id)
- wim_account_id = wim_account['uuid']
- wim_account_name = wim_account['name']
- wim_usage[sce_net['uuid']] = wim_account_id
- elif isinstance(target_wim_account, str): # manual selection of WIM
- wim_account.persist.get_wim_account_by(target_wim_account, tenant_id)
- wim_account_id = wim_account['uuid']
- wim_account_name = wim_account['name']
- wim_usage[sce_net['uuid']] = wim_account_id
- else: # not WIM usage
- wim_usage[sce_net['uuid']] = False
- # <-- WIM
-
- for datacenter_id in involved_datacenters:
- netmap_use = None
- netmap_create = None
- if descriptor_net.get("sites"):
- for site in descriptor_net["sites"]:
- if site.get("datacenter") == datacenter_id:
- netmap_use = site.get("netmap-use")
- netmap_create = site.get("netmap-create")
- break
-
- vim = myvims[datacenter_id]
- myvim_thread_id = myvim_threads_id[datacenter_id]
-
- net_type = sce_net['type']
- net_vim_name = None
- lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} # 'shared': True
-
- if not net_name:
- if sce_net["external"]:
- net_name = sce_net["name"]
- else:
- net_name = "{}-{}".format(instance_name, sce_net["name"])
- net_name = net_name[:255] # limit length
-
- if netmap_use or netmap_create:
- create_network = False
- lookfor_network = False
- if netmap_use:
- lookfor_network = True
- if utils.check_valid_uuid(netmap_use):
- lookfor_filter["id"] = netmap_use
- else:
- lookfor_filter["name"] = netmap_use
- if netmap_create:
- create_network = True
- net_vim_name = net_name
- if isinstance(netmap_create, str):
- net_vim_name = netmap_create
- elif sce_net.get("vim_network_name"):
- create_network = False
- lookfor_network = True
- lookfor_filter["name"] = sce_net.get("vim_network_name")
- elif sce_net["external"]:
- if sce_net.get('vim_id'):
- # there is a netmap at datacenter_nets database # TODO REVISE!!!!
- create_network = False
- lookfor_network = True
- lookfor_filter["id"] = sce_net['vim_id']
- elif vim["config"].get("management_network_id") or vim["config"].get("management_network_name"):
- if number_mgmt_networks > 1:
- raise NfvoException("Found several VLD of type mgmt. "
- "You must concrete what vim-network must be use for each one",
- httperrors.Bad_Request)
- create_network = False
- lookfor_network = True
- if vim["config"].get("management_network_id"):
- lookfor_filter["id"] = vim["config"]["management_network_id"]
- else:
- lookfor_filter["name"] = vim["config"]["management_network_name"]
- else:
- # There is not a netmap, look at datacenter for a net with this name and create if not found
- create_network = True
- lookfor_network = True
- lookfor_filter["name"] = sce_net["name"]
- net_vim_name = sce_net["name"]
- else:
- net_vim_name = net_name
- create_network = True
- lookfor_network = False
-
- task_extra = {}
- if create_network:
- task_action = "CREATE"
- task_extra["params"] = (net_vim_name, net_type, sce_net.get('ip_profile', None), False,
- sce_net.get('provider_network', None), wim_account_name)
-
- if lookfor_network:
- task_extra["find"] = (lookfor_filter,)
- elif lookfor_network:
- task_action = "FIND"
- task_extra["params"] = (lookfor_filter,)
-
- # fill database content
- net_uuid = str(uuid4())
- uuid_list.append(net_uuid)
- sce_net2instance[sce_net_uuid][datacenter_id] = net_uuid
- if not related_network: # all db_instance_nets will have same related
- related_network = use_network or net_uuid
- sdn_net_id = None
- sdn_controller = vim.config.get('sdn-controller')
- sce_net2wim_instance[sce_net_uuid][datacenter_id] = None
- if sdn_controller and net_type in ("data", "ptp"):
- wim_id = _get_wim(mydb, sdn_controller)
- sdn_net_id = str(uuid4())
- sce_net2wim_instance[sce_net_uuid][datacenter_id] = sdn_net_id
- task_extra["sdn_net_id"] = sdn_net_id
- db_instance_wim_nets.append({
- "uuid": sdn_net_id,
- "instance_scenario_id": instance_uuid,
- "sce_net_id": sce_net.get("uuid"),
- "wim_id": wim_id,
- "wim_account_id": sdn_controller,
- 'status': 'BUILD', # if create_network else "ACTIVE"
- "related": related_network,
- 'multipoint': True if net_type=="data" else False,
- "created": create_network, # TODO py3
- "sdn": True,
- })
-
- task_wim_extra = {"params": [net_type, wim_account_name]}
- # add sdn interfaces
- if sce_net.get('provider_network') and sce_net['provider_network'].get("sdn-ports"):
- task_wim_extra["sdn-ports"] = sce_net['provider_network'].get("sdn-ports")
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "status": "SCHEDULED",
- "task_index": task_index,
- # "datacenter_vim_id": myvim_thread_id,
- "wim_account_id": sdn_controller,
- "action": task_action,
- "item": "instance_wim_nets",
- "item_id": sdn_net_id,
- "related": related_network,
- "extra": yaml.safe_dump(task_wim_extra, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
- db_net = {
- "uuid": net_uuid,
- "osm_id": sce_net.get("osm_id") or sce_net["name"],
- "related": related_network,
- 'vim_net_id': None,
- "vim_name": net_vim_name,
- "instance_scenario_id": instance_uuid,
- "sce_net_id": sce_net.get("uuid"),
- "created": create_network,
- 'datacenter_id': datacenter_id,
- 'datacenter_tenant_id': myvim_thread_id,
- 'status': 'BUILD', # if create_network else "ACTIVE"
- 'sdn_net_id': sdn_net_id,
- }
- db_instance_nets.append(db_net)
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "status": "SCHEDULED",
- "task_index": task_index,
- "datacenter_vim_id": myvim_thread_id,
- "action": task_action,
- "item": "instance_nets",
- "item_id": net_uuid,
- "related": related_network,
- "extra": yaml.safe_dump(task_extra, default_flow_style=True, width=256)
- }
- net2task_id['scenario'][sce_net_uuid][datacenter_id] = task_index
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- if 'ip_profile' in sce_net:
- db_ip_profile={
- 'instance_net_id': net_uuid,
- 'ip_version': sce_net['ip_profile']['ip_version'],
- 'subnet_address': sce_net['ip_profile']['subnet_address'],
- 'gateway_address': sce_net['ip_profile']['gateway_address'],
- 'dns_address': sce_net['ip_profile']['dns_address'],
- 'dhcp_enabled': sce_net['ip_profile']['dhcp_enabled'],
- 'dhcp_start_address': sce_net['ip_profile']['dhcp_start_address'],
- 'dhcp_count': sce_net['ip_profile']['dhcp_count'],
- }
- db_ip_profiles.append(db_ip_profile)
-
- # Create VNFs
- vnf_params = {
- "default_datacenter_id": default_datacenter_id,
- "myvim_threads_id": myvim_threads_id,
- "instance_uuid": instance_uuid,
- "instance_name": instance_name,
- "instance_action_id": instance_action_id,
- "myvims": myvims,
- "cloud_config": cloud_config,
- "RO_pub_key": tenant[0].get('RO_pub_key'),
- "instance_parameters": instance_dict,
- }
- vnf_params_out = {
- "task_index": task_index,
- "uuid_list": uuid_list,
- "db_instance_nets": db_instance_nets,
- "db_instance_wim_nets": db_instance_wim_nets,
- "db_vim_actions": db_vim_actions,
- "db_ip_profiles": db_ip_profiles,
- "db_instance_vnfs": db_instance_vnfs,
- "db_instance_vms": db_instance_vms,
- "db_instance_interfaces": db_instance_interfaces,
- "net2task_id": net2task_id,
- "sce_net2instance": sce_net2instance,
- "sce_net2wim_instance": sce_net2wim_instance,
- }
- # sce_vnf_list = sorted(scenarioDict['vnfs'], key=lambda k: k['name'])
- for sce_vnf in scenarioDict.get('vnfs', ()): # sce_vnf_list:
- instantiate_vnf(mydb, sce_vnf, vnf_params, vnf_params_out, rollbackList)
- task_index = vnf_params_out["task_index"]
- uuid_list = vnf_params_out["uuid_list"]
-
- # Create VNFFGs
- # task_depends_on = []
- for vnffg in scenarioDict.get('vnffgs', ()):
- for rsp in vnffg['rsps']:
- sfs_created = []
- for cp in rsp['connection_points']:
- count = mydb.get_rows(
- SELECT='vms.count',
- FROM="vms join interfaces on vms.uuid=interfaces.vm_id join sce_rsp_hops as h "
- "on interfaces.uuid=h.ingress_interface_id",
- WHERE={'h.uuid': cp['uuid']})[0]['count']
- instance_vnf = next((item for item in db_instance_vnfs if item['sce_vnf_id'] == cp['sce_vnf_id']), None)
- instance_vms = [item for item in db_instance_vms if item['instance_vnf_id'] == instance_vnf['uuid']]
- dependencies = []
- for instance_vm in instance_vms:
- action = next((item for item in db_vim_actions if item['item_id'] == instance_vm['uuid']), None)
- if action:
- dependencies.append(action['task_index'])
- # TODO: throw exception if count != len(instance_vms)
- # TODO: and action shouldn't ever be None
- sfis_created = []
- for i in range(count):
- # create sfis
- sfi_uuid = str(uuid4())
- extra_params = {
- "ingress_interface_id": cp["ingress_interface_id"],
- "egress_interface_id": cp["egress_interface_id"]
- }
- uuid_list.append(sfi_uuid)
- db_sfi = {
- "uuid": sfi_uuid,
- "related": sfi_uuid,
- "instance_scenario_id": instance_uuid,
- 'sce_rsp_hop_id': cp['uuid'],
- 'datacenter_id': datacenter_id,
- 'datacenter_tenant_id': myvim_thread_id,
- "vim_sfi_id": None, # vim thread will populate
- }
- db_instance_sfis.append(db_sfi)
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": myvim_thread_id,
- "action": "CREATE",
- "status": "SCHEDULED",
- "item": "instance_sfis",
- "item_id": sfi_uuid,
- "related": sfi_uuid,
- "extra": yaml.safe_dump({"params": extra_params, "depends_on": [dependencies[i]]},
- default_flow_style=True, width=256)
- }
- sfis_created.append(task_index)
- task_index += 1
- db_vim_actions.append(db_vim_action)
- # create sfs
- sf_uuid = str(uuid4())
- uuid_list.append(sf_uuid)
- db_sf = {
- "uuid": sf_uuid,
- "related": sf_uuid,
- "instance_scenario_id": instance_uuid,
- 'sce_rsp_hop_id': cp['uuid'],
- 'datacenter_id': datacenter_id,
- 'datacenter_tenant_id': myvim_thread_id,
- "vim_sf_id": None, # vim thread will populate
- }
- db_instance_sfs.append(db_sf)
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": myvim_thread_id,
- "action": "CREATE",
- "status": "SCHEDULED",
- "item": "instance_sfs",
- "item_id": sf_uuid,
- "related": sf_uuid,
- "extra": yaml.safe_dump({"params": "", "depends_on": sfis_created},
- default_flow_style=True, width=256)
- }
- sfs_created.append(task_index)
- task_index += 1
- db_vim_actions.append(db_vim_action)
- classifier = rsp['classifier']
-
- # TODO the following ~13 lines can be reused for the sfi case
- count = mydb.get_rows(
- SELECT=('vms.count'),
- FROM="vms join interfaces on vms.uuid=interfaces.vm_id join sce_classifiers as c on interfaces.uuid=c.interface_id",
- WHERE={'c.uuid': classifier['uuid']})[0]['count']
- instance_vnf = next((item for item in db_instance_vnfs if item['sce_vnf_id'] == classifier['sce_vnf_id']), None)
- instance_vms = [item for item in db_instance_vms if item['instance_vnf_id'] == instance_vnf['uuid']]
- dependencies = []
- for instance_vm in instance_vms:
- action = next((item for item in db_vim_actions if item['item_id'] == instance_vm['uuid']), None)
- if action:
- dependencies.append(action['task_index'])
- # TODO: throw exception if count != len(instance_vms)
- # TODO: and action shouldn't ever be None
- classifications_created = []
- for i in range(count):
- for match in classifier['matches']:
- # create classifications
- classification_uuid = str(uuid4())
- uuid_list.append(classification_uuid)
- db_classification = {
- "uuid": classification_uuid,
- "related": classification_uuid,
- "instance_scenario_id": instance_uuid,
- 'sce_classifier_match_id': match['uuid'],
- 'datacenter_id': datacenter_id,
- 'datacenter_tenant_id': myvim_thread_id,
- "vim_classification_id": None, # vim thread will populate
- }
- db_instance_classifications.append(db_classification)
- classification_params = {
- "ip_proto": match["ip_proto"],
- "source_ip": match["source_ip"],
- "destination_ip": match["destination_ip"],
- "source_port": match["source_port"],
- "destination_port": match["destination_port"],
- "logical_source_port": classifier["interface_id"]
- }
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": myvim_thread_id,
- "action": "CREATE",
- "status": "SCHEDULED",
- "item": "instance_classifications",
- "item_id": classification_uuid,
- "related": classification_uuid,
- "extra": yaml.safe_dump({"params": classification_params, "depends_on": [dependencies[i]]},
- default_flow_style=True, width=256)
- }
- classifications_created.append(task_index)
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- # create sfps
- sfp_uuid = str(uuid4())
- uuid_list.append(sfp_uuid)
- db_sfp = {
- "uuid": sfp_uuid,
- "related": sfp_uuid,
- "instance_scenario_id": instance_uuid,
- 'sce_rsp_id': rsp['uuid'],
- 'datacenter_id': datacenter_id,
- 'datacenter_tenant_id': myvim_thread_id,
- "vim_sfp_id": None, # vim thread will populate
- }
- db_instance_sfps.append(db_sfp)
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": myvim_thread_id,
- "action": "CREATE",
- "status": "SCHEDULED",
- "item": "instance_sfps",
- "item_id": sfp_uuid,
- "related": sfp_uuid,
- "extra": yaml.safe_dump({"params": "", "depends_on": sfs_created + classifications_created},
- default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
- db_instance_action["number_tasks"] = task_index
-
- # --> WIM
- logger.debug('wim_usage:\n%s\n\n', pformat(wim_usage))
- wan_links = wim_engine.derive_wan_links(wim_usage, db_instance_nets, tenant_id)
- wim_actions = wim_engine.create_actions(wan_links)
- wim_actions, db_instance_action = (
- wim_engine.incorporate_actions(wim_actions, db_instance_action))
- # <-- WIM
-
- scenarioDict["datacenter2tenant"] = myvim_threads_id
-
- db_instance_scenario['datacenter_tenant_id'] = myvim_threads_id[default_datacenter_id]
- db_instance_scenario['datacenter_id'] = default_datacenter_id
- db_tables=[
- {"instance_scenarios": db_instance_scenario},
- {"instance_vnfs": db_instance_vnfs},
- {"instance_nets": db_instance_nets},
- {"ip_profiles": db_ip_profiles},
- {"instance_vms": db_instance_vms},
- {"instance_interfaces": db_instance_interfaces},
- {"instance_actions": db_instance_action},
- {"instance_sfis": db_instance_sfis},
- {"instance_sfs": db_instance_sfs},
- {"instance_classifications": db_instance_classifications},
- {"instance_sfps": db_instance_sfps},
- {"instance_wim_nets": db_instance_wim_nets + wan_links},
- {"vim_wim_actions": db_vim_actions + wim_actions}
- ]
-
- logger.debug("create_instance done DB tables: %s",
- yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
- mydb.new_rows(db_tables, uuid_list)
- for myvim_thread_id in myvim_threads_id.values():
- vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions)
-
- wim_engine.dispatch(wim_actions)
-
- returned_instance = mydb.get_instance_scenario(instance_uuid)
- returned_instance["action_id"] = instance_action_id
- return returned_instance
- except (NfvoException, vimconn.VimConnException, sdnconn.SdnConnectorError, db_base_Exception) as e:
- _, message = rollback(mydb, myvims, rollbackList)
- if isinstance(e, db_base_Exception):
- error_text = "database Exception"
- elif isinstance(e, vimconn.VimConnException):
- error_text = "VIM Exception"
- elif isinstance(e, sdnconn.SdnConnectorError):
- error_text = "WIM Exception"
- else:
- error_text = "Exception " + str(type(e).__name__)
- error_text += " {}. {}".format(e, message)
- # logger.error("create_instance: %s", error_text)
- logger.exception(e)
- raise NfvoException(error_text, e.http_code)
-
-def increment_ip_mac(ip_mac, vm_index=1):
- if not isinstance(ip_mac, str):
- return ip_mac
- try:
- # try with ipv4 look for last dot
- i = ip_mac.rfind(".")
- if i > 0:
- i += 1
- return "{}{}".format(ip_mac[:i], int(ip_mac[i:]) + vm_index)
- # try with ipv6 or mac look for last colon. Operate in hex
- i = ip_mac.rfind(":")
- if i > 0:
- i += 1
- # format in hex, len can be 2 for mac or 4 for ipv6
- return ("{}{:0" + str(len(ip_mac) - i) + "x}").format(ip_mac[:i], int(ip_mac[i:], 16) + vm_index)
- except:
- pass
- return None
-
-
-def instantiate_vnf(mydb, sce_vnf, params, params_out, rollbackList):
- default_datacenter_id = params["default_datacenter_id"]
- myvim_threads_id = params["myvim_threads_id"]
- instance_uuid = params["instance_uuid"]
- instance_name = params["instance_name"]
- instance_action_id = params["instance_action_id"]
- myvims = params["myvims"]
- cloud_config = params["cloud_config"]
- RO_pub_key = params["RO_pub_key"]
-
- task_index = params_out["task_index"]
- uuid_list = params_out["uuid_list"]
- db_instance_nets = params_out["db_instance_nets"]
- db_instance_wim_nets = params_out["db_instance_wim_nets"]
- db_vim_actions = params_out["db_vim_actions"]
- db_ip_profiles = params_out["db_ip_profiles"]
- db_instance_vnfs = params_out["db_instance_vnfs"]
- db_instance_vms = params_out["db_instance_vms"]
- db_instance_interfaces = params_out["db_instance_interfaces"]
- net2task_id = params_out["net2task_id"]
- sce_net2instance = params_out["sce_net2instance"]
- sce_net2wim_instance = params_out["sce_net2wim_instance"]
-
- vnf_net2instance = {}
- vnf_net2wim_instance = {}
-
- # 2. Creating new nets (vnf internal nets) in the VIM"
- # For each vnf net, we create it and we add it to instanceNetlist.
- if sce_vnf.get("datacenter"):
- vim = myvims[sce_vnf["datacenter"]]
- datacenter_id = sce_vnf["datacenter"]
- myvim_thread_id = myvim_threads_id[sce_vnf["datacenter"]]
- else:
- vim = myvims[default_datacenter_id]
- datacenter_id = default_datacenter_id
- myvim_thread_id = myvim_threads_id[default_datacenter_id]
- for net in sce_vnf['nets']:
- # TODO revis
- # descriptor_net = instance_dict.get("vnfs", {}).get(sce_vnf["name"], {})
- # net_name = descriptor_net.get("name")
- net_name = None
- if not net_name:
- net_name = "{}-{}".format(instance_name, net["name"])
- net_name = net_name[:255] # limit length
- net_type = net['type']
-
- if sce_vnf['uuid'] not in vnf_net2instance:
- vnf_net2instance[sce_vnf['uuid']] = {}
- if sce_vnf['uuid'] not in net2task_id:
- net2task_id[sce_vnf['uuid']] = {}
-
- # fill database content
- net_uuid = str(uuid4())
- uuid_list.append(net_uuid)
- vnf_net2instance[sce_vnf['uuid']][net['uuid']] = net_uuid
-
- sdn_controller = vim.config.get('sdn-controller')
- sdn_net_id = None
- if sdn_controller and net_type in ("data", "ptp"):
- wim_id = _get_wim(mydb, sdn_controller)
- sdn_net_id = str(uuid4())
- db_instance_wim_nets.append({
- "uuid": sdn_net_id,
- "instance_scenario_id": instance_uuid,
- "wim_id": wim_id,
- "wim_account_id": sdn_controller,
- 'status': 'BUILD', # if create_network else "ACTIVE"
- "related": net_uuid,
- 'multipoint': True if net_type == "data" else False,
- "created": True, # TODO py3
- "sdn": True,
- })
- vnf_net2wim_instance[net_uuid] = sdn_net_id
-
- db_net = {
- "uuid": net_uuid,
- "related": net_uuid,
- 'vim_net_id': None,
- "vim_name": net_name,
- "instance_scenario_id": instance_uuid,
- "net_id": net["uuid"],
- "created": True,
- 'datacenter_id': datacenter_id,
- 'datacenter_tenant_id': myvim_thread_id,
- 'sdn_net_id': sdn_net_id,
- }
- db_instance_nets.append(db_net)
-
- lookfor_filter = {}
- if net.get("vim-network-name"):
- lookfor_filter["name"] = net["vim-network-name"]
- if net.get("vim-network-id"):
- lookfor_filter["id"] = net["vim-network-id"]
- if lookfor_filter:
- task_action = "FIND"
- task_extra = {"params": (lookfor_filter,)}
- else:
- task_action = "CREATE"
- task_extra = {"params": (net_name, net_type, net.get('ip_profile', None))}
- if sdn_net_id:
- task_extra["sdn_net_id"] = sdn_net_id
-
- if sdn_net_id:
- task_wim_extra = {"params": [net_type, None]}
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "status": "SCHEDULED",
- "task_index": task_index,
- # "datacenter_vim_id": myvim_thread_id,
- "wim_account_id": sdn_controller,
- "action": task_action,
- "item": "instance_wim_nets",
- "item_id": sdn_net_id,
- "related": net_uuid,
- "extra": yaml.safe_dump(task_wim_extra, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": myvim_thread_id,
- "status": "SCHEDULED",
- "action": task_action,
- "item": "instance_nets",
- "item_id": net_uuid,
- "related": net_uuid,
- "extra": yaml.safe_dump(task_extra, default_flow_style=True, width=256)
- }
- net2task_id[sce_vnf['uuid']][net['uuid']] = task_index
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- if 'ip_profile' in net:
- db_ip_profile = {
- 'instance_net_id': net_uuid,
- 'ip_version': net['ip_profile']['ip_version'],
- 'subnet_address': net['ip_profile']['subnet_address'],
- 'gateway_address': net['ip_profile']['gateway_address'],
- 'dns_address': net['ip_profile']['dns_address'],
- 'dhcp_enabled': net['ip_profile']['dhcp_enabled'],
- 'dhcp_start_address': net['ip_profile']['dhcp_start_address'],
- 'dhcp_count': net['ip_profile']['dhcp_count'],
- }
- db_ip_profiles.append(db_ip_profile)
-
- # print "vnf_net2instance:"
- # print yaml.safe_dump(vnf_net2instance, indent=4, default_flow_style=False)
-
- # 3. Creating new vm instances in the VIM
- # myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
- ssh_access = None
- if sce_vnf.get('mgmt_access'):
- ssh_access = sce_vnf['mgmt_access'].get('config-access', {}).get('ssh-access')
- vnf_availability_zones = []
- for vm in sce_vnf.get('vms'):
- vm_av = vm.get('availability_zone')
- if vm_av and vm_av not in vnf_availability_zones:
- vnf_availability_zones.append(vm_av)
-
- # check if there is enough availability zones available at vim level.
- if myvims[datacenter_id].availability_zone and vnf_availability_zones:
- if len(vnf_availability_zones) > len(myvims[datacenter_id].availability_zone):
- raise NfvoException('No enough availability zones at VIM for this deployment', httperrors.Bad_Request)
-
- if sce_vnf.get("datacenter"):
- vim = myvims[sce_vnf["datacenter"]]
- myvim_thread_id = myvim_threads_id[sce_vnf["datacenter"]]
- datacenter_id = sce_vnf["datacenter"]
- else:
- vim = myvims[default_datacenter_id]
- myvim_thread_id = myvim_threads_id[default_datacenter_id]
- datacenter_id = default_datacenter_id
- sce_vnf["datacenter_id"] = datacenter_id
- i = 0
-
- vnf_uuid = str(uuid4())
- uuid_list.append(vnf_uuid)
- db_instance_vnf = {
- 'uuid': vnf_uuid,
- 'instance_scenario_id': instance_uuid,
- 'vnf_id': sce_vnf['vnf_id'],
- 'sce_vnf_id': sce_vnf['uuid'],
- 'datacenter_id': datacenter_id,
- 'datacenter_tenant_id': myvim_thread_id,
- }
- db_instance_vnfs.append(db_instance_vnf)
-
- for vm in sce_vnf['vms']:
- # skip PDUs
- if vm.get("pdu_type"):
- continue
-
- myVMDict = {}
- sce_vnf_name = sce_vnf['member_vnf_index'] if sce_vnf['member_vnf_index'] else sce_vnf['name']
- myVMDict['name'] = "{}-{}-{}".format(instance_name[:64], sce_vnf_name[:64], vm["name"][:64])
- myVMDict['description'] = myVMDict['name'][0:99]
- # if not startvms:
- # myVMDict['start'] = "no"
- if vm.get("instance_parameters") and vm["instance_parameters"].get("name"):
- myVMDict['name'] = vm["instance_parameters"].get("name")
- myVMDict['name'] = myVMDict['name'][0:255] # limit name length
- # create image at vim in case it not exist
- image_uuid = vm['image_id']
- if vm.get("image_list"):
- for alternative_image in vm["image_list"]:
- if alternative_image["vim_type"] == vim["config"]["_vim_type_internal"]:
- image_uuid = alternative_image['image_id']
- break
- image_dict = mydb.get_table_by_uuid_name("images", image_uuid)
- image_id = create_or_use_image(mydb, {datacenter_id: vim}, image_dict, [], True)
- vm['vim_image_id'] = image_id
-
- # create flavor at vim in case it not exist
- flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id'])
- if flavor_dict['extended'] != None:
- flavor_dict['extended'] = yaml.load(flavor_dict['extended'], Loader=yaml.Loader)
- flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True)
-
- # Obtain information for additional disks
- extended_flavor_dict = mydb.get_rows(FROM='datacenters_flavors', SELECT=('extended',),
- WHERE={'vim_id': flavor_id})
- if not extended_flavor_dict:
- raise NfvoException("flavor '{}' not found".format(flavor_id), httperrors.Not_Found)
-
- # extended_flavor_dict_yaml = yaml.load(extended_flavor_dict[0], Loader=yaml.Loader)
- myVMDict['disks'] = None
- extended_info = extended_flavor_dict[0]['extended']
- if extended_info != None:
- extended_flavor_dict_yaml = yaml.load(extended_info, Loader=yaml.Loader)
- if 'disks' in extended_flavor_dict_yaml:
- myVMDict['disks'] = extended_flavor_dict_yaml['disks']
- if vm.get("instance_parameters") and vm["instance_parameters"].get("devices"):
- for disk in myVMDict['disks']:
- if disk.get("name") in vm["instance_parameters"]["devices"]:
- disk.update(vm["instance_parameters"]["devices"][disk.get("name")])
-
- vm['vim_flavor_id'] = flavor_id
- myVMDict['imageRef'] = vm['vim_image_id']
- myVMDict['flavorRef'] = vm['vim_flavor_id']
- myVMDict['availability_zone'] = vm.get('availability_zone')
- myVMDict['networks'] = []
- task_depends_on = []
- # TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true
- is_management_vm = False
- db_vm_ifaces = []
- for iface in vm['interfaces']:
- netDict = {}
- if iface['type'] == "data":
- netDict['type'] = iface['model']
- elif "model" in iface and iface["model"] != None:
- netDict['model'] = iface['model']
- # TODO in future, remove this because mac_address will not be set, and the type of PV,VF
- # is obtained from iterface table model
- # discover type of interface looking at flavor
- for numa in flavor_dict.get('extended', {}).get('numas', []):
- for flavor_iface in numa.get('interfaces', []):
- if flavor_iface.get('name') == iface['internal_name']:
- if flavor_iface['dedicated'] == 'yes':
- netDict['type'] = "PF" # passthrough
- elif flavor_iface['dedicated'] == 'no':
- netDict['type'] = "VF" # siov
- elif flavor_iface['dedicated'] == 'yes:sriov':
- netDict['type'] = "VFnotShared" # sriov but only one sriov on the PF
- netDict["mac_address"] = flavor_iface.get("mac_address")
- break
- netDict["use"] = iface['type']
- if netDict["use"] == "data" and not netDict.get("type"):
- # print "netDict", netDict
- # print "iface", iface
- e_text = "Cannot determine the interface type PF or VF of VNF '{}' VM '{}' iface '{}'".fromat(
- sce_vnf['name'], vm['name'], iface['internal_name'])
- if flavor_dict.get('extended') == None:
- raise NfvoException(e_text + "After database migration some information is not available. \
- Try to delete and create the scenarios and VNFs again", httperrors.Conflict)
- else:
- raise NfvoException(e_text, httperrors.Internal_Server_Error)
- if netDict["use"] == "mgmt":
- is_management_vm = True
- netDict["type"] = "virtual"
- if netDict["use"] == "bridge":
- netDict["type"] = "virtual"
- if iface.get("vpci"):
- netDict['vpci'] = iface['vpci']
- if iface.get("mac"):
- netDict['mac_address'] = iface['mac']
- if iface.get("mac_address"):
- netDict['mac_address'] = iface['mac_address']
- if iface.get("ip_address"):
- netDict['ip_address'] = iface['ip_address']
- if iface.get("port-security") is not None:
- netDict['port_security'] = iface['port-security']
- if iface.get("port_security_disable_strategy") is not None:
- netDict['port_security_disable_strategy'] = iface['port_security_disable_strategy']
- if iface.get("floating-ip") is not None:
- netDict['floating_ip'] = iface['floating-ip']
- netDict['name'] = iface['internal_name']
- if iface['net_id'] is None:
- for vnf_iface in sce_vnf["interfaces"]:
- # print iface
- # print vnf_iface
- if vnf_iface['interface_id'] == iface['uuid']:
- netDict['net_id'] = "TASK-{}".format(
- net2task_id['scenario'][vnf_iface['sce_net_id']][datacenter_id])
- instance_net_id = sce_net2instance[vnf_iface['sce_net_id']][datacenter_id]
- instance_wim_net_id = sce_net2wim_instance[vnf_iface['sce_net_id']][datacenter_id]
- task_depends_on.append(net2task_id['scenario'][vnf_iface['sce_net_id']][datacenter_id])
- break
- else:
- netDict['net_id'] = "TASK-{}".format(net2task_id[sce_vnf['uuid']][iface['net_id']])
- instance_net_id = vnf_net2instance[sce_vnf['uuid']][iface['net_id']]
- instance_wim_net_id = vnf_net2wim_instance.get(instance_net_id)
- task_depends_on.append(net2task_id[sce_vnf['uuid']][iface['net_id']])
- # skip bridge ifaces not connected to any net
- if 'net_id' not in netDict or netDict['net_id'] == None:
- continue
- myVMDict['networks'].append(netDict)
- db_vm_iface = {
- # "uuid"
- # 'instance_vm_id': instance_vm_uuid,
- "instance_net_id": instance_net_id,
- "instance_wim_net_id": instance_wim_net_id,
- 'interface_id': iface['uuid'],
- # 'vim_interface_id': ,
- 'type': 'external' if iface['external_name'] is not None else 'internal',
- 'model': iface['model'],
- 'ip_address': iface.get('ip_address'),
- 'mac_address': iface.get('mac'),
- 'floating_ip': int(iface.get('floating-ip', False)),
- 'port_security': int(iface.get('port-security', True))
- }
- db_vm_ifaces.append(db_vm_iface)
- # print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
- # print myVMDict['name']
- # print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False)
- # print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False)
- # print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
-
- # We add the RO key to cloud_config if vnf will need ssh access
- cloud_config_vm = cloud_config
- if is_management_vm and params["instance_parameters"].get("mgmt_keys"):
- cloud_config_vm = unify_cloud_config({"key-pairs": params["instance_parameters"]["mgmt_keys"]},
- cloud_config_vm)
-
- if vm.get("instance_parameters") and "mgmt_keys" in vm["instance_parameters"]:
- if vm["instance_parameters"]["mgmt_keys"]:
- cloud_config_vm = unify_cloud_config({"key-pairs": vm["instance_parameters"]["mgmt_keys"]},
- cloud_config_vm)
- if RO_pub_key:
- cloud_config_vm = unify_cloud_config(cloud_config_vm, {"key-pairs": [RO_pub_key]})
- if vm.get("boot_data"):
- cloud_config_vm = unify_cloud_config(vm["boot_data"], cloud_config_vm)
-
- if myVMDict.get('availability_zone'):
- av_index = vnf_availability_zones.index(myVMDict['availability_zone'])
- else:
- av_index = None
- for vm_index in range(0, vm.get('count', 1)):
- if vm.get("instance_parameters") and vm["instance_parameters"].get("cloud_init"):
- cloud_config_vm_ = unify_cloud_config(cloud_config_vm,
- {"user-data": vm["instance_parameters"]["cloud_init"][vm_index]})
- else:
- cloud_config_vm_ = cloud_config_vm
-
- vm_name = myVMDict['name'] + "-" + str(vm_index+1)
- vm_networks = deepcopy(myVMDict['networks'])
- task_params = (vm_name, myVMDict['description'], myVMDict.get('start', None),
- myVMDict['imageRef'], myVMDict['flavorRef'], vm_networks, cloud_config_vm_,
- myVMDict['disks'], av_index, vnf_availability_zones)
-
- vm_uuid = str(uuid4())
- uuid_list.append(vm_uuid)
- db_vm = {
- "uuid": vm_uuid,
- "related": vm_uuid,
- 'instance_vnf_id': vnf_uuid,
- # TODO delete "vim_vm_id": vm_id,
- "vm_id": vm["uuid"],
- "vim_name": vm_name,
- # "status":
- }
- db_instance_vms.append(db_vm)
-
- # put interface uuid back to scenario[vnfs][vms[[interfaces]
- for net in vm_networks:
- if "vim_id" in net:
- for iface in vm['interfaces']:
- if net["name"] == iface["internal_name"]:
- iface["vim_id"] = net["vim_id"]
- break
-
- if vm_index > 0:
- if net.get("ip_address"):
- net["ip_address"] = increment_ip_mac(net.get("ip_address"), vm_index)
- if net.get("mac_address"):
- net["mac_address"] = increment_ip_mac(net.get("mac_address"), vm_index)
-
- for iface_index, db_vm_iface in enumerate(db_vm_ifaces):
- iface_uuid = str(uuid4())
- uuid_list.append(iface_uuid)
- db_vm_iface_instance = {
- "uuid": iface_uuid,
- "instance_vm_id": vm_uuid,
- "ip_address": vm_networks[iface_index].get("ip_address"),
- "mac_address": vm_networks[iface_index].get("mac_address")
- }
- db_vm_iface_instance.update(db_vm_iface)
- db_instance_interfaces.append(db_vm_iface_instance)
- vm_networks[iface_index]["uuid"] = iface_uuid
-
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": myvim_thread_id,
- "action": "CREATE",
- "status": "SCHEDULED",
- "item": "instance_vms",
- "item_id": vm_uuid,
- "related": vm_uuid,
- "extra": yaml.safe_dump({"params": task_params, "depends_on": task_depends_on},
- default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
- params_out["task_index"] = task_index
- params_out["uuid_list"] = uuid_list
-
-
-def delete_instance(mydb, tenant_id, instance_id):
- # print "Checking that the instance_id exists and getting the instance dictionary"
- instanceDict = mydb.get_instance_scenario(instance_id, tenant_id)
- # print yaml.safe_dump(instanceDict, indent=4, default_flow_style=False)
- tenant_id = instanceDict["tenant_id"]
-
- # --> WIM
- # We need to retrieve the WIM Actions now, before the instance_scenario is
- # deleted. The reason for that is that: ON CASCADE rules will delete the
- # instance_wim_nets record in the database
- wim_actions = wim_engine.delete_actions(instance_scenario_id=instance_id)
- # <-- WIM
-
- # print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
- # 1. Delete from Database
- message = mydb.delete_instance_scenario(instance_id, tenant_id)
-
- # 2. delete from VIM
- error_msg = ""
- myvims = {}
- myvim_threads = {}
- vimthread_affected = {}
- net2vm_dependencies = {}
-
- task_index = 0
- instance_action_id = get_task_id()
- db_vim_actions = []
- db_instance_action = {
- "uuid": instance_action_id, # same uuid for the instance and the action on create
- "tenant_id": tenant_id,
- "instance_id": instance_id,
- "description": "DELETE",
- # "number_tasks": 0 # filled bellow
- }
-
- # 2.1 deleting VNFFGs
- for sfp in instanceDict.get('sfps', ()):
- vimthread_affected[sfp["datacenter_tenant_id"]] = None
- datacenter_key = (sfp["datacenter_id"], sfp["datacenter_tenant_id"])
- if datacenter_key not in myvims:
- try:
- _, myvim_thread = get_vim_thread(mydb, tenant_id, sfp["datacenter_id"], sfp["datacenter_tenant_id"])
- except NfvoException as e:
- logger.error(str(e))
- myvim_thread = None
- myvim_threads[datacenter_key] = myvim_thread
- vims = get_vim(mydb, tenant_id, datacenter_id=sfp["datacenter_id"],
- datacenter_tenant_id=sfp["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sfp["datacenter_id"], sfp["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = next(iter(vims.values()))
- myvim = myvims[datacenter_key]
- myvim_thread = myvim_threads[datacenter_key]
-
- if not myvim:
- error_msg += "\n vim_sfp_id={} cannot be deleted because datacenter={} not found".format(sfp['vim_sfp_id'], sfp["datacenter_id"])
- continue
- extra = {"params": (sfp['vim_sfp_id'])}
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": sfp["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_sfps",
- "item_id": sfp["uuid"],
- "related": sfp["related"],
- "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- for classification in instanceDict['classifications']:
- vimthread_affected[classification["datacenter_tenant_id"]] = None
- datacenter_key = (classification["datacenter_id"], classification["datacenter_tenant_id"])
- if datacenter_key not in myvims:
- try:
- _, myvim_thread = get_vim_thread(mydb, tenant_id, classification["datacenter_id"], classification["datacenter_tenant_id"])
- except NfvoException as e:
- logger.error(str(e))
- myvim_thread = None
- myvim_threads[datacenter_key] = myvim_thread
- vims = get_vim(mydb, tenant_id, datacenter_id=classification["datacenter_id"],
- datacenter_tenant_id=classification["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(classification["datacenter_id"],
- classification["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = next(iter(vims.values()))
- myvim = myvims[datacenter_key]
- myvim_thread = myvim_threads[datacenter_key]
-
- if not myvim:
- error_msg += "\n vim_classification_id={} cannot be deleted because datacenter={} not found".format(classification['vim_classification_id'],
- classification["datacenter_id"])
- continue
- depends_on = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfps"]
- extra = {"params": (classification['vim_classification_id']), "depends_on": depends_on}
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": classification["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_classifications",
- "item_id": classification["uuid"],
- "related": classification["related"],
- "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- for sf in instanceDict.get('sfs', ()):
- vimthread_affected[sf["datacenter_tenant_id"]] = None
- datacenter_key = (sf["datacenter_id"], sf["datacenter_tenant_id"])
- if datacenter_key not in myvims:
- try:
- _, myvim_thread = get_vim_thread(mydb, tenant_id, sf["datacenter_id"], sf["datacenter_tenant_id"])
- except NfvoException as e:
- logger.error(str(e))
- myvim_thread = None
- myvim_threads[datacenter_key] = myvim_thread
- vims = get_vim(mydb, tenant_id, datacenter_id=sf["datacenter_id"],
- datacenter_tenant_id=sf["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sf["datacenter_id"], sf["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = next(iter(vims.values()))
- myvim = myvims[datacenter_key]
- myvim_thread = myvim_threads[datacenter_key]
-
- if not myvim:
- error_msg += "\n vim_sf_id={} cannot be deleted because datacenter={} not found".format(sf['vim_sf_id'], sf["datacenter_id"])
- continue
- depends_on = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfps"]
- extra = {"params": (sf['vim_sf_id']), "depends_on": depends_on}
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": sf["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_sfs",
- "item_id": sf["uuid"],
- "related": sf["related"],
- "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- for sfi in instanceDict.get('sfis', ()):
- vimthread_affected[sfi["datacenter_tenant_id"]] = None
- datacenter_key = (sfi["datacenter_id"], sfi["datacenter_tenant_id"])
- if datacenter_key not in myvims:
- try:
- _, myvim_thread = get_vim_thread(mydb, tenant_id, sfi["datacenter_id"], sfi["datacenter_tenant_id"])
- except NfvoException as e:
- logger.error(str(e))
- myvim_thread = None
- myvim_threads[datacenter_key] = myvim_thread
- vims = get_vim(mydb, tenant_id, datacenter_id=sfi["datacenter_id"],
- datacenter_tenant_id=sfi["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sfi["datacenter_id"], sfi["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = next(iter(vims.values()))
- myvim = myvims[datacenter_key]
- myvim_thread = myvim_threads[datacenter_key]
-
- if not myvim:
- error_msg += "\n vim_sfi_id={} cannot be deleted because datacenter={} not found".format(sfi['vim_sfi_id'], sfi["datacenter_id"])
- continue
- depends_on = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfs"]
- extra = {"params": (sfi['vim_sfi_id']), "depends_on": depends_on}
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": sfi["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_sfis",
- "item_id": sfi["uuid"],
- "related": sfi["related"],
- "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- # 2.2 deleting VMs
- # vm_fail_list=[]
- for sce_vnf in instanceDict.get('vnfs', ()):
- datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
- vimthread_affected[sce_vnf["datacenter_tenant_id"]] = None
- if datacenter_key not in myvims:
- try:
- _, myvim_thread = get_vim_thread(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
- except NfvoException as e:
- logger.error(str(e))
- myvim_thread = None
- myvim_threads[datacenter_key] = myvim_thread
- vims = get_vim(mydb, tenant_id, datacenter_id=sce_vnf["datacenter_id"],
- datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"],
- sce_vnf["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = next(iter(vims.values()))
- myvim = myvims[datacenter_key]
- myvim_thread = myvim_threads[datacenter_key]
-
- for vm in sce_vnf['vms']:
- if not myvim:
- error_msg += "\n VM id={} cannot be deleted because datacenter={} not found".format(vm['vim_vm_id'], sce_vnf["datacenter_id"])
- continue
- sfi_dependencies = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfis"]
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": sce_vnf["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_vms",
- "item_id": vm["uuid"],
- "related": vm["related"],
- "extra": yaml.safe_dump({"params": vm["interfaces"], "depends_on": sfi_dependencies},
- default_flow_style=True, width=256)
- }
- db_vim_actions.append(db_vim_action)
- for interface in vm["interfaces"]:
- if not interface.get("instance_net_id"):
- continue
- if interface["instance_net_id"] not in net2vm_dependencies:
- net2vm_dependencies[interface["instance_net_id"]] = []
- net2vm_dependencies[interface["instance_net_id"]].append(task_index)
- task_index += 1
-
- # 2.3 deleting NETS
- # net_fail_list=[]
- for net in instanceDict['nets']:
- vimthread_affected[net["datacenter_tenant_id"]] = None
- datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
- if datacenter_key not in myvims:
- try:
- _,myvim_thread = get_vim_thread(mydb, tenant_id, net["datacenter_id"], net["datacenter_tenant_id"])
- except NfvoException as e:
- logger.error(str(e))
- myvim_thread = None
- myvim_threads[datacenter_key] = myvim_thread
- vims = get_vim(mydb, tenant_id, datacenter_id=net["datacenter_id"],
- datacenter_tenant_id=net["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = next(iter(vims.values()))
- myvim = myvims[datacenter_key]
- myvim_thread = myvim_threads[datacenter_key]
-
- if not myvim:
- error_msg += "\n Net VIM_id={} cannot be deleted because datacenter={} not found".format(net['vim_net_id'], net["datacenter_id"])
- continue
- extra = {"params": (net['vim_net_id'], net['sdn_net_id'])}
- if net2vm_dependencies.get(net["uuid"]):
- extra["depends_on"] = net2vm_dependencies[net["uuid"]]
- sfi_dependencies = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfis"]
- if len(sfi_dependencies) > 0:
- if "depends_on" in extra:
- extra["depends_on"] += sfi_dependencies
- else:
- extra["depends_on"] = sfi_dependencies
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": net["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_nets",
- "item_id": net["uuid"],
- "related": net["related"],
- "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
- for sdn_net in instanceDict['sdn_nets']:
- if not sdn_net["sdn"]:
- continue
- extra = {}
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "wim_account_id": sdn_net["wim_account_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_wim_nets",
- "item_id": sdn_net["uuid"],
- "related": sdn_net["related"],
- "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- db_instance_action["number_tasks"] = task_index
-
- # --> WIM
- wim_actions, db_instance_action = (
- wim_engine.incorporate_actions(wim_actions, db_instance_action))
- # <-- WIM
-
- db_tables = [
- {"instance_actions": db_instance_action},
- {"vim_wim_actions": db_vim_actions + wim_actions}
- ]
-
- logger.debug("delete_instance done DB tables: %s",
- yaml.safe_dump(db_tables, indent=4, default_flow_style=False))
- mydb.new_rows(db_tables, ())
- for myvim_thread_id in vimthread_affected.keys():
- vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions)
-
- wim_engine.dispatch(wim_actions)
-
- if len(error_msg) > 0:
- return 'action_id={} instance {} deleted but some elements could not be deleted, or already deleted '\
- '(error: 404) from VIM: {}'.format(instance_action_id, message, error_msg)
- else:
- return "action_id={} instance {} deleted".format(instance_action_id, message)
-
-def get_instance_id(mydb, tenant_id, instance_id):
- global ovim
- #check valid tenant_id
- check_tenant(mydb, tenant_id)
- #obtain data
-
- instance_dict = mydb.get_instance_scenario(instance_id, tenant_id, verbose=True)
- # TODO py3
- # for net in instance_dict["nets"]:
- # if net.get("sdn_net_id"):
- # net_sdn = ovim.show_network(net["sdn_net_id"])
- # net["sdn_info"] = {
- # "admin_state_up": net_sdn.get("admin_state_up"),
- # "flows": net_sdn.get("flows"),
- # "last_error": net_sdn.get("last_error"),
- # "ports": net_sdn.get("ports"),
- # "type": net_sdn.get("type"),
- # "status": net_sdn.get("status"),
- # "vlan": net_sdn.get("vlan"),
- # }
- return instance_dict
-
-@deprecated("Instance is automatically refreshed by vim_threads")
-def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenant=None):
- '''Refreshes a scenario instance. It modifies instanceDict'''
- '''Returns:
- - result: <0 if there is any unexpected error, n>=0 if no errors where n is the number of vms and nets that couldn't be updated in the database
- - error_msg
- '''
- # # Assumption: nfvo_tenant and instance_id were checked before entering into this function
- # #print "nfvo.refresh_instance begins"
- # #print json.dumps(instanceDict, indent=4)
- #
- # #print "Getting the VIM URL and the VIM tenant_id"
- # myvims={}
- #
- # # 1. Getting VIM vm and net list
- # vms_updated = [] #List of VM instance uuids in openmano that were updated
- # vms_notupdated=[]
- # vm_list = {}
- # for sce_vnf in instanceDict['vnfs']:
- # datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
- # if datacenter_key not in vm_list:
- # vm_list[datacenter_key] = []
- # if datacenter_key not in myvims:
- # vims = get_vim(mydb, nfvo_tenant, datacenter_id=sce_vnf["datacenter_id"],
- # datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
- # if len(vims) == 0:
- # logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]))
- # myvims[datacenter_key] = None
- # else:
- # myvims[datacenter_key] = next(iter(vims.values()))
- # for vm in sce_vnf['vms']:
- # vm_list[datacenter_key].append(vm['vim_vm_id'])
- # vms_notupdated.append(vm["uuid"])
- #
- # nets_updated = [] #List of VM instance uuids in openmano that were updated
- # nets_notupdated=[]
- # net_list = {}
- # for net in instanceDict['nets']:
- # datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
- # if datacenter_key not in net_list:
- # net_list[datacenter_key] = []
- # if datacenter_key not in myvims:
- # vims = get_vim(mydb, nfvo_tenant, datacenter_id=net["datacenter_id"],
- # datacenter_tenant_id=net["datacenter_tenant_id"])
- # if len(vims) == 0:
- # logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
- # myvims[datacenter_key] = None
- # else:
- # myvims[datacenter_key] = next(iter(vims.values()))
- #
- # net_list[datacenter_key].append(net['vim_net_id'])
- # nets_notupdated.append(net["uuid"])
- #
- # # 1. Getting the status of all VMs
- # vm_dict={}
- # for datacenter_key in myvims:
- # if not vm_list.get(datacenter_key):
- # continue
- # failed = True
- # failed_message=""
- # if not myvims[datacenter_key]:
- # failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
- # else:
- # try:
- # vm_dict.update(myvims[datacenter_key].refresh_vms_status(vm_list[datacenter_key]) )
- # failed = False
- # except vimconn.VimConnException as e:
- # logger.error("VIM exception %s %s", type(e).__name__, str(e))
- # failed_message = str(e)
- # if failed:
- # for vm in vm_list[datacenter_key]:
- # vm_dict[vm] = {'status': "VIM_ERROR", 'error_msg': failed_message}
- #
- # # 2. Update the status of VMs in the instanceDict, while collects the VMs whose status changed
- # for sce_vnf in instanceDict['vnfs']:
- # for vm in sce_vnf['vms']:
- # vm_id = vm['vim_vm_id']
- # interfaces = vm_dict[vm_id].pop('interfaces', [])
- # #2.0 look if contain manamgement interface, and if not change status from ACTIVE:NoMgmtIP to ACTIVE
- # has_mgmt_iface = False
- # for iface in vm["interfaces"]:
- # if iface["type"]=="mgmt":
- # has_mgmt_iface = True
- # if vm_dict[vm_id]['status'] == "ACTIVE:NoMgmtIP" and not has_mgmt_iface:
- # vm_dict[vm_id]['status'] = "ACTIVE"
- # if vm_dict[vm_id].get('error_msg') and len(vm_dict[vm_id]['error_msg']) >= 1024:
- # vm_dict[vm_id]['error_msg'] = vm_dict[vm_id]['error_msg'][:516] + " ... " + vm_dict[vm_id]['error_msg'][-500:]
- # if vm['status'] != vm_dict[vm_id]['status'] or vm.get('error_msg')!=vm_dict[vm_id].get('error_msg') or vm.get('vim_info')!=vm_dict[vm_id].get('vim_info'):
- # vm['status'] = vm_dict[vm_id]['status']
- # vm['error_msg'] = vm_dict[vm_id].get('error_msg')
- # vm['vim_info'] = vm_dict[vm_id].get('vim_info')
- # # 2.1. Update in openmano DB the VMs whose status changed
- # try:
- # updates = mydb.update_rows('instance_vms', UPDATE=vm_dict[vm_id], WHERE={'uuid':vm["uuid"]})
- # vms_notupdated.remove(vm["uuid"])
- # if updates>0:
- # vms_updated.append(vm["uuid"])
- # except db_base_Exception as e:
- # logger.error("nfvo.refresh_instance error database update: %s", str(e))
- # # 2.2. Update in openmano DB the interface VMs
- # for interface in interfaces:
- # #translate from vim_net_id to instance_net_id
- # network_id_list=[]
- # for net in instanceDict['nets']:
- # if net["vim_net_id"] == interface["vim_net_id"]:
- # network_id_list.append(net["uuid"])
- # if not network_id_list:
- # continue
- # del interface["vim_net_id"]
- # try:
- # for network_id in network_id_list:
- # mydb.update_rows('instance_interfaces', UPDATE=interface, WHERE={'instance_vm_id':vm["uuid"], "instance_net_id":network_id})
- # except db_base_Exception as e:
- # logger.error( "nfvo.refresh_instance error with vm=%s, interface_net_id=%s", vm["uuid"], network_id)
- #
- # # 3. Getting the status of all nets
- # net_dict = {}
- # for datacenter_key in myvims:
- # if not net_list.get(datacenter_key):
- # continue
- # failed = True
- # failed_message = ""
- # if not myvims[datacenter_key]:
- # failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
- # else:
- # try:
- # net_dict.update(myvims[datacenter_key].refresh_nets_status(net_list[datacenter_key]) )
- # failed = False
- # except vimconn.VimConnException as e:
- # logger.error("VIM exception %s %s", type(e).__name__, str(e))
- # failed_message = str(e)
- # if failed:
- # for net in net_list[datacenter_key]:
- # net_dict[net] = {'status': "VIM_ERROR", 'error_msg': failed_message}
- #
- # # 4. Update the status of nets in the instanceDict, while collects the nets whose status changed
- # # TODO: update nets inside a vnf
- # for net in instanceDict['nets']:
- # net_id = net['vim_net_id']
- # if net_dict[net_id].get('error_msg') and len(net_dict[net_id]['error_msg']) >= 1024:
- # net_dict[net_id]['error_msg'] = net_dict[net_id]['error_msg'][:516] + " ... " + net_dict[vm_id]['error_msg'][-500:]
- # if net['status'] != net_dict[net_id]['status'] or net.get('error_msg')!=net_dict[net_id].get('error_msg') or net.get('vim_info')!=net_dict[net_id].get('vim_info'):
- # net['status'] = net_dict[net_id]['status']
- # net['error_msg'] = net_dict[net_id].get('error_msg')
- # net['vim_info'] = net_dict[net_id].get('vim_info')
- # # 5.1. Update in openmano DB the nets whose status changed
- # try:
- # updated = mydb.update_rows('instance_nets', UPDATE=net_dict[net_id], WHERE={'uuid':net["uuid"]})
- # nets_notupdated.remove(net["uuid"])
- # if updated>0:
- # nets_updated.append(net["uuid"])
- # except db_base_Exception as e:
- # logger.error("nfvo.refresh_instance error database update: %s", str(e))
- #
- # # Returns appropriate output
- # #print "nfvo.refresh_instance finishes"
- # logger.debug("VMs updated in the database: %s; nets updated in the database %s; VMs not updated: %s; nets not updated: %s",
- # str(vms_updated), str(nets_updated), str(vms_notupdated), str(nets_notupdated))
- instance_id = instanceDict['uuid']
- # if len(vms_notupdated)+len(nets_notupdated)>0:
- # error_msg = "VMs not updated: " + str(vms_notupdated) + "; nets not updated: " + str(nets_notupdated)
- # return len(vms_notupdated)+len(nets_notupdated), 'Scenario instance ' + instance_id + ' refreshed but some elements could not be updated in the database: ' + error_msg
-
- return 0, 'Scenario instance ' + instance_id + ' refreshed.'
-
-def instance_action(mydb,nfvo_tenant,instance_id, action_dict):
- #print "Checking that the instance_id exists and getting the instance dictionary"
- instanceDict = mydb.get_instance_scenario(instance_id, nfvo_tenant)
- #print yaml.safe_dump(instanceDict, indent=4, default_flow_style=False)
-
- #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
- vims = get_vim(mydb, nfvo_tenant, instanceDict['datacenter_id'])
- if len(vims) == 0:
- raise NfvoException("datacenter '{}' not found".format(str(instanceDict['datacenter_id'])), httperrors.Not_Found)
- myvim = next(iter(vims.values()))
- vm_result = {}
- vm_error = 0
- vm_ok = 0
-
- myvim_threads_id = {}
- if action_dict.get("vdu-scaling"):
- db_instance_vms = []
- db_vim_actions = []
- db_instance_interfaces = []
- instance_action_id = get_task_id()
- db_instance_action = {
- "uuid": instance_action_id, # same uuid for the instance and the action on create
- "tenant_id": nfvo_tenant,
- "instance_id": instance_id,
- "description": "SCALE",
- }
- vm_result["instance_action_id"] = instance_action_id
- vm_result["created"] = []
- vm_result["deleted"] = []
- task_index = 0
- for vdu in action_dict["vdu-scaling"]:
- vdu_id = vdu.get("vdu-id")
- osm_vdu_id = vdu.get("osm_vdu_id")
- member_vnf_index = vdu.get("member-vnf-index")
- vdu_count = vdu.get("count", 1)
- if vdu_id:
- target_vms = mydb.get_rows(
- FROM="instance_vms as vms join instance_vnfs as vnfs on vms.instance_vnf_id=vnfs.uuid",
- WHERE={"vms.uuid": vdu_id},
- ORDER_BY="vms.created_at"
- )
- if not target_vms:
- raise NfvoException("Cannot find the vdu with id {}".format(vdu_id), httperrors.Not_Found)
- else:
- if not osm_vdu_id and not member_vnf_index:
- raise NfvoException("Invalid input vdu parameters. Must supply either 'vdu-id' of 'osm_vdu_id','member-vnf-index'")
- target_vms = mydb.get_rows(
- # SELECT=("ivms.uuid", "ivnfs.datacenter_id", "ivnfs.datacenter_tenant_id"),
- FROM="instance_vms as ivms join instance_vnfs as ivnfs on ivms.instance_vnf_id=ivnfs.uuid"\
- " join sce_vnfs as svnfs on ivnfs.sce_vnf_id=svnfs.uuid"\
- " join vms on ivms.vm_id=vms.uuid",
- WHERE={"vms.osm_id": osm_vdu_id, "svnfs.member_vnf_index": member_vnf_index,
- "ivnfs.instance_scenario_id": instance_id},
- ORDER_BY="ivms.created_at"
- )
- if not target_vms:
- raise NfvoException("Cannot find the vdu with osm_vdu_id {} and member-vnf-index {}".format(osm_vdu_id, member_vnf_index), httperrors.Not_Found)
- vdu_id = target_vms[-1]["uuid"]
- target_vm = target_vms[-1]
- datacenter = target_vm["datacenter_id"]
- myvim_threads_id[datacenter], _ = get_vim_thread(mydb, nfvo_tenant, datacenter)
-
- if vdu["type"] == "delete":
- for index in range(0, vdu_count):
- target_vm = target_vms[-1-index]
- vdu_id = target_vm["uuid"]
- # look for nm
- vm_interfaces = None
- for sce_vnf in instanceDict['vnfs']:
- for vm in sce_vnf['vms']:
- if vm["uuid"] == vdu_id:
- # TODO revise this should not be vm["uuid"] instance_vms["vm_id"]
- vm_interfaces = vm["interfaces"]
- break
-
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": target_vm["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_vms",
- "item_id": vdu_id,
- "related": target_vm["related"],
- "extra": yaml.safe_dump({"params": vm_interfaces},
- default_flow_style=True, width=256)
- }
- # get affected instance_interfaces (deleted on cascade) to check if a wim_network must be updated
- deleted_interfaces = mydb.get_rows(
- SELECT=("instance_wim_net_id", ),
- FROM="instance_interfaces",
- WHERE={"instance_vm_id": vdu_id, "instance_wim_net_id<>": None},
- )
- for deleted_interface in deleted_interfaces:
- db_vim_actions.append({"TO-UPDATE": {}, "WHERE": {
- "item": "instance_wim_nets", "item_id": deleted_interface["instance_wim_net_id"]}})
-
- task_index += 1
- db_vim_actions.append(db_vim_action)
- vm_result["deleted"].append(vdu_id)
- # delete from database
- db_instance_vms.append({"TO-DELETE": vdu_id})
-
- else: # vdu["type"] == "create":
- iface2iface = {}
- where = {"item": "instance_vms", "item_id": target_vm["uuid"], "action": "CREATE"}
-
- vim_action_to_clone = mydb.get_rows(FROM="vim_wim_actions", WHERE=where)
- if not vim_action_to_clone:
- raise NfvoException("Cannot find the vim_action at database with {}".format(where), httperrors.Internal_Server_Error)
- vim_action_to_clone = vim_action_to_clone[0]
- extra = yaml.safe_load(vim_action_to_clone["extra"])
-
- # generate a new depends_on. Convert format TASK-Y into new format TASK-ACTION-XXXX.XXXX.Y
- # TODO do the same for flavor and image when available
- task_depends_on = []
- task_params = extra["params"]
- for iface in task_params[5]:
- if iface["net_id"].startswith("TASK-"):
- if "." not in iface["net_id"]:
- task_depends_on.append("{}.{}".format(vim_action_to_clone["instance_action_id"],
- iface["net_id"][5:]))
- iface["net_id"] = "TASK-{}.{}".format(vim_action_to_clone["instance_action_id"],
- iface["net_id"][5:])
- else:
- task_depends_on.append(iface["net_id"][5:])
-
- vm_ifaces_to_clone = mydb.get_rows(FROM="instance_interfaces", WHERE={"instance_vm_id": target_vm["uuid"]})
- for index in range(0, vdu_count):
- vm_uuid = str(uuid4())
- vm_name = target_vm.get('vim_name')
- try:
- suffix = vm_name.rfind("-")
- vm_name = vm_name[:suffix+1] + str(index + 1 + int(vm_name[suffix+1:]))
- except Exception:
- pass
- db_instance_vm = {
- "uuid": vm_uuid,
- 'related': vm_uuid,
- 'instance_vnf_id': target_vm['instance_vnf_id'],
- 'vm_id': target_vm['vm_id'],
- 'vim_name': vm_name,
- }
- db_instance_vms.append(db_instance_vm)
-
- for vm_iface in vm_ifaces_to_clone:
- iface_uuid = str(uuid4())
- iface2iface[vm_iface["uuid"]] = iface_uuid
- db_vm_iface = {
- "uuid": iface_uuid,
- 'instance_vm_id': vm_uuid,
- "instance_net_id": vm_iface["instance_net_id"],
- "instance_wim_net_id": vm_iface["instance_wim_net_id"],
- 'interface_id': vm_iface['interface_id'],
- 'type': vm_iface['type'],
- 'model': vm_iface['model'],
- 'floating_ip': vm_iface['floating_ip'],
- 'port_security': vm_iface['port_security']
- }
- db_instance_interfaces.append(db_vm_iface)
- if db_vm_iface["instance_wim_net_id"]:
- db_vim_actions.append({"TO-UPDATE": {}, "WHERE": {
- "item": "instance_wim_nets", "item_id": db_vm_iface["instance_wim_net_id"]}})
- task_params_copy = deepcopy(task_params)
- cloud_config_vm = task_params_copy[6] or {}
- if vdu.get("cloud_init"):
- cloud_config_vm.pop("user-data", None)
- cloud_config_vm_ = unify_cloud_config(cloud_config_vm, {"user-data": vdu["cloud_init"][index]})
- task_params_copy[6] = cloud_config_vm_
- for iface in task_params_copy[5]:
- iface["uuid"] = iface2iface[iface["uuid"]]
- # increment ip_address
- if iface.get("ip_address"):
- iface["ip_address"] = increment_ip_mac(iface.get("ip_address"), index+1)
- if iface.get("mac_address"):
- iface["mac_address"] = increment_ip_mac(iface.get("mac_address"), index+1)
-
- if vm_name:
- task_params_copy[0] = vm_name
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": vim_action_to_clone["datacenter_vim_id"],
- "action": "CREATE",
- "status": "SCHEDULED",
- "item": "instance_vms",
- "item_id": vm_uuid,
- "related": vm_uuid,
- # ALF
- # ALF
- # TODO examinar parametros, quitar MAC o incrementar. Incrementar IP y colocar las dependencias con ACTION-asdfasd.
- # ALF
- # ALF
- "extra": yaml.safe_dump({"params": task_params_copy, "depends_on": task_depends_on}, default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
- vm_result["created"].append(vm_uuid)
-
- db_instance_action["number_tasks"] = task_index
- db_tables = [
- {"instance_vms": db_instance_vms},
- {"instance_interfaces": db_instance_interfaces},
- {"instance_actions": db_instance_action},
- # TODO revise sfps
- # {"instance_sfis": db_instance_sfis},
- # {"instance_sfs": db_instance_sfs},
- # {"instance_classifications": db_instance_classifications},
- # {"instance_sfps": db_instance_sfps},
- {"vim_wim_actions": db_vim_actions}
- ]
- logger.debug("create_vdu done DB tables: %s",
- yaml.safe_dump(db_tables, indent=4, default_flow_style=False))
- mydb.new_rows(db_tables, [])
- for myvim_thread in myvim_threads_id.values():
- vim_threads["running"][myvim_thread].insert_task(db_vim_actions)
-
- return vm_result
-
- input_vnfs = action_dict.pop("vnfs", [])
- input_vms = action_dict.pop("vms", [])
- action_over_all = True if not input_vnfs and not input_vms else False
- for sce_vnf in instanceDict['vnfs']:
- for vm in sce_vnf['vms']:
- if not action_over_all and sce_vnf['uuid'] not in input_vnfs and sce_vnf['vnf_name'] not in input_vnfs and \
- sce_vnf['member_vnf_index'] not in input_vnfs and \
- vm['uuid'] not in input_vms and vm['name'] not in input_vms and \
- sce_vnf['member_vnf_index'] + "-" + vm['vdu_osm_id'] not in input_vms: # TODO conside vm_count_index
- continue
- try:
- if "add_public_key" in action_dict:
- if sce_vnf.get('mgmt_access'):
- mgmt_access = yaml.load(sce_vnf['mgmt_access'], Loader=yaml.Loader)
- if not input_vms and mgmt_access.get("vdu-id") != vm['vdu_osm_id']:
- continue
- default_user = mgmt_access.get("default-user")
- password = mgmt_access.get("password")
- if mgmt_access.get(vm['vdu_osm_id']):
- default_user = mgmt_access[vm['vdu_osm_id']].get("default-user", default_user)
- password = mgmt_access[vm['vdu_osm_id']].get("password", password)
-
- tenant = mydb.get_rows_by_id('nfvo_tenants', nfvo_tenant)
- try:
- if 'ip_address' in vm:
- mgmt_ip = vm['ip_address'].split(';')
- priv_RO_key = decrypt_key(tenant[0]['encrypted_RO_priv_key'], tenant[0]['uuid'])
- data = myvim.inject_user_key(mgmt_ip[0], action_dict.get('user', default_user),
- action_dict['add_public_key'],
- password=password, ro_key=priv_RO_key)
- vm_result[ vm['uuid'] ] = {"vim_result": 200,
- "description": "Public key injected",
- "name":vm['name']
- }
- except KeyError:
- raise NfvoException("Unable to inject ssh key in vm: {} - Aborting".format(vm['uuid']),
- httperrors.Internal_Server_Error)
- else:
- raise NfvoException("Unable to inject ssh key in vm: {} - Aborting".format(vm['uuid']),
- httperrors.Internal_Server_Error)
- else:
- data = myvim.action_vminstance(vm['vim_vm_id'], action_dict)
- if "console" in action_dict:
- if not global_config["http_console_proxy"]:
- vm_result[ vm['uuid'] ] = {"vim_result": 200,
- "description": "{protocol}//{ip}:{port}/{suffix}".format(
- protocol=data["protocol"],
- ip = data["server"],
- port = data["port"],
- suffix = data["suffix"]),
- "name":vm['name']
- }
- vm_ok +=1
- elif data["server"]=="127.0.0.1" or data["server"]=="localhost":
- vm_result[ vm['uuid'] ] = {"vim_result": -httperrors.Unauthorized,
- "description": "this console is only reachable by local interface",
- "name":vm['name']
- }
- vm_error+=1
- else:
- #print "console data", data
- try:
- console_thread = create_or_use_console_proxy_thread(data["server"], data["port"])
- vm_result[ vm['uuid'] ] = {"vim_result": 200,
- "description": "{protocol}//{ip}:{port}/{suffix}".format(
- protocol=data["protocol"],
- ip = global_config["http_console_host"],
- port = console_thread.port,
- suffix = data["suffix"]),
- "name":vm['name']
- }
- vm_ok +=1
- except NfvoException as e:
- vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)}
- vm_error+=1
-
- else:
- vm_result[ vm['uuid'] ] = {"vim_result": 200, "description": "ok", "name":vm['name']}
- vm_ok +=1
- except vimconn.VimConnException as e:
- vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)}
- vm_error+=1
-
- if vm_ok==0: #all goes wrong
- return vm_result
- else:
- return vm_result
-
-def instance_action_get(mydb, nfvo_tenant, instance_id, action_id):
- filter = {}
- if nfvo_tenant and nfvo_tenant != "any":
- filter["tenant_id"] = nfvo_tenant
- if instance_id and instance_id != "any":
- filter["instance_id"] = instance_id
- if action_id:
- filter["uuid"] = action_id
- rows = mydb.get_rows(FROM="instance_actions", WHERE=filter)
- if action_id:
- if not rows:
- raise NfvoException("Not found any action with this criteria", httperrors.Not_Found)
- vim_wim_actions = mydb.get_rows(FROM="vim_wim_actions", WHERE={"instance_action_id": action_id})
- rows[0]["vim_wim_actions"] = vim_wim_actions
- # for backward compatibility set vim_actions = vim_wim_actions
- rows[0]["vim_actions"] = vim_wim_actions
- return {"actions": rows}
-
-
-def create_or_use_console_proxy_thread(console_server, console_port):
- #look for a non-used port
- console_thread_key = console_server + ":" + str(console_port)
- if console_thread_key in global_config["console_thread"]:
- #global_config["console_thread"][console_thread_key].start_timeout()
- return global_config["console_thread"][console_thread_key]
-
- for port in global_config["console_port_iterator"]():
- #print "create_or_use_console_proxy_thread() port:", port
- if port in global_config["console_ports"]:
- continue
- try:
- clithread = cli.ConsoleProxyThread(global_config['http_host'], port, console_server, console_port)
- clithread.start()
- global_config["console_thread"][console_thread_key] = clithread
- global_config["console_ports"][port] = console_thread_key
- return clithread
- except cli.ConsoleProxyExceptionPortUsed as e:
- #port used, try with onoher
- continue
- except cli.ConsoleProxyException as e:
- raise NfvoException(str(e), httperrors.Bad_Request)
- raise NfvoException("Not found any free 'http_console_ports'", httperrors.Conflict)
-
-
-def check_tenant(mydb, tenant_id):
- '''check that tenant exists at database'''
- tenant = mydb.get_rows(FROM='nfvo_tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id})
- if not tenant:
- raise NfvoException("tenant '{}' not found".format(tenant_id), httperrors.Not_Found)
- return
-
-def new_tenant(mydb, tenant_dict):
-
- tenant_uuid = str(uuid4())
- tenant_dict['uuid'] = tenant_uuid
- try:
- pub_key, priv_key = create_RO_keypair(tenant_uuid)
- tenant_dict['RO_pub_key'] = pub_key
- tenant_dict['encrypted_RO_priv_key'] = priv_key
- mydb.new_row("nfvo_tenants", tenant_dict, confidential_data=True)
- except db_base_Exception as e:
- raise NfvoException("Error creating the new tenant: {} ".format(tenant_dict['name']) + str(e), e.http_code)
- return tenant_uuid
-
-def delete_tenant(mydb, tenant):
- #get nfvo_tenant info
-
- tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant, 'tenant')
- mydb.delete_row_by_id("nfvo_tenants", tenant_dict['uuid'])
- return tenant_dict['uuid'] + " " + tenant_dict["name"]
-
-
-def new_datacenter(mydb, datacenter_descriptor):
- sdn_port_mapping = None
- if "config" in datacenter_descriptor:
- sdn_port_mapping = datacenter_descriptor["config"].pop("sdn-port-mapping", None)
- datacenter_descriptor["config"] = yaml.safe_dump(datacenter_descriptor["config"], default_flow_style=True,
- width=256)
- # Check that datacenter-type is correct
- datacenter_type = datacenter_descriptor.get("type", "openvim");
- # module_info = None
-
- for url_field in ('vim_url', 'vim_url_admin'):
- # It is common that users copy and paste the URL from the VIM website
- # (example OpenStack), therefore a common mistake is to include blank
- # characters at the end of the URL. Let's remove it and just in case,
- # lets remove trailing slash as well.
- url = datacenter_descriptor.get(url_field)
- if url:
- datacenter_descriptor[url_field] = url.strip(string.whitespace + '/')
-
- # load plugin
- plugin_name = "rovim_" + datacenter_type
- if plugin_name not in plugins:
- _load_plugin(plugin_name, type="vim")
-
- datacenter_id = mydb.new_row("datacenters", datacenter_descriptor, add_uuid=True, confidential_data=True)
- if sdn_port_mapping:
- try:
- datacenter_sdn_port_mapping_set(mydb, None, datacenter_id, sdn_port_mapping)
- except Exception as e:
- mydb.delete_row_by_id("datacenters", datacenter_id) # Rollback
- raise e
- return datacenter_id
-
-
-def edit_datacenter(mydb, datacenter_id_name, datacenter_descriptor):
- # obtain data, check that only one exist
- datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id_name)
-
- # edit data
- datacenter_id = datacenter['uuid']
- where = {'uuid': datacenter['uuid']}
- remove_port_mapping = False
- new_sdn_port_mapping = None
- if "config" in datacenter_descriptor:
- if datacenter_descriptor['config'] != None:
- try:
- new_config_dict = datacenter_descriptor["config"]
- if "sdn-port-mapping" in new_config_dict:
- remove_port_mapping = True
- new_sdn_port_mapping = new_config_dict.pop("sdn-port-mapping")
- # delete null fields
- to_delete = []
- for k in new_config_dict:
- if new_config_dict[k] is None:
- to_delete.append(k)
- if k == 'sdn-controller':
- remove_port_mapping = True
-
- config_text = datacenter.get("config")
- if not config_text:
- config_text = '{}'
- config_dict = yaml.load(config_text, Loader=yaml.Loader)
- config_dict.update(new_config_dict)
- # delete null fields
- for k in to_delete:
- del config_dict[k]
- except Exception as e:
- raise NfvoException("Bad format at datacenter:config " + str(e), httperrors.Bad_Request)
- if config_dict:
- datacenter_descriptor["config"] = yaml.safe_dump(config_dict, default_flow_style=True, width=256)
- else:
- datacenter_descriptor["config"] = None
- if remove_port_mapping:
- try:
- datacenter_sdn_port_mapping_delete(mydb, None, datacenter_id)
- except ovimException as e:
- raise NfvoException("Error deleting datacenter-port-mapping " + str(e), httperrors.Conflict)
-
- mydb.update_rows('datacenters', datacenter_descriptor, where)
- if new_sdn_port_mapping:
- try:
- datacenter_sdn_port_mapping_set(mydb, None, datacenter_id, new_sdn_port_mapping)
- except ovimException as e:
- # Rollback
- mydb.update_rows('datacenters', datacenter, where)
- raise NfvoException("Error adding datacenter-port-mapping " + str(e), httperrors.Conflict)
- return datacenter_id
-
-
-def delete_datacenter(mydb, datacenter):
- #get nfvo_tenant info
- datacenter_dict = mydb.get_table_by_uuid_name('datacenters', datacenter, 'datacenter')
- mydb.delete_row_by_id("datacenters", datacenter_dict['uuid'])
- try:
- datacenter_sdn_port_mapping_delete(mydb, None, datacenter_dict['uuid'])
- except ovimException as e:
- raise NfvoException("Error deleting datacenter-port-mapping " + str(e))
- return datacenter_dict['uuid'] + " " + datacenter_dict['name']
-
-
-def create_vim_account(mydb, nfvo_tenant, datacenter_id, name=None, vim_id=None, vim_tenant=None, vim_tenant_name=None,
- vim_username=None, vim_password=None, config=None):
- global plugins
- # get datacenter info
- try:
- if not datacenter_id:
- if not vim_id:
- raise NfvoException("You must provide 'vim_id", http_code=httperrors.Bad_Request)
- datacenter_id = vim_id
- datacenter_id, datacenter = get_datacenter_uuid(mydb, None, datacenter_id)
- datacenter_name = datacenter["name"]
- datacenter_type = datacenter["type"]
-
- create_vim_tenant = True if not vim_tenant and not vim_tenant_name else False
-
- # get nfvo_tenant info
- tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', nfvo_tenant)
- if vim_tenant_name is None:
- vim_tenant_name = tenant_dict['name']
-
- tenants_datacenter_dict = {"nfvo_tenant_id": tenant_dict['uuid'], "datacenter_id": datacenter_id}
- # #check that this association does not exist before
- # tenants_datacenters = mydb.get_rows(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict)
- # if len(tenants_datacenters)>0:
- # raise NfvoException("datacenter '{}' and tenant'{}' are already attached".format(
- # datacenter_id, tenant_dict['uuid']), httperrors.Conflict)
-
- vim_tenant_id_exist_atdb = False
- if not create_vim_tenant:
- where_={"datacenter_id": datacenter_id}
- if vim_tenant is not None:
- where_["vim_tenant_id"] = vim_tenant
- if vim_tenant_name is not None:
- where_["vim_tenant_name"] = vim_tenant_name
- # check if vim_tenant_id is already at database
- datacenter_tenants_dict = mydb.get_rows(FROM='datacenter_tenants', WHERE=where_)
- if len(datacenter_tenants_dict) >= 1:
- datacenter_tenants_dict = datacenter_tenants_dict[0]
- vim_tenant_id_exist_atdb = True
- # TODO check if a field has changed and edit entry at datacenter_tenants at DB
- else: # result=0
- datacenter_tenants_dict = {}
- # insert at table datacenter_tenants
- else: # if vim_tenant==None:
- # create tenant at VIM if not provided
- try:
- _, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter_id, vim_user=vim_username,
- vim_passwd=vim_password)
- datacenter_name = myvim["name"]
- vim_tenant = myvim.new_tenant(vim_tenant_name, "created by openmano for datacenter "+datacenter_name)
- except vimconn.VimConnException as e:
- raise NfvoException("Not possible to create vim_tenant {} at VIM: {}".format(vim_tenant_name, e),
- httperrors.Internal_Server_Error)
- datacenter_tenants_dict = {"created": "true"}
-
- # fill datacenter_tenants table
- if not vim_tenant_id_exist_atdb:
- datacenter_tenants_dict["vim_tenant_id"] = vim_tenant
- datacenter_tenants_dict["vim_tenant_name"] = vim_tenant_name
- datacenter_tenants_dict["user"] = vim_username
- datacenter_tenants_dict["passwd"] = vim_password
- datacenter_tenants_dict["datacenter_id"] = datacenter_id
- if name:
- datacenter_tenants_dict["name"] = name
- else:
- datacenter_tenants_dict["name"] = datacenter_name
- if config:
- datacenter_tenants_dict["config"] = yaml.safe_dump(config, default_flow_style=True, width=256)
- id_ = mydb.new_row('datacenter_tenants', datacenter_tenants_dict, add_uuid=True, confidential_data=True)
- datacenter_tenants_dict["uuid"] = id_
-
- # fill tenants_datacenters table
- datacenter_tenant_id = datacenter_tenants_dict["uuid"]
- tenants_datacenter_dict["datacenter_tenant_id"] = datacenter_tenant_id
- mydb.new_row('tenants_datacenters', tenants_datacenter_dict)
-
- # load plugin and create thread
- plugin_name = "rovim_" + datacenter_type
- if plugin_name not in plugins:
- _load_plugin(plugin_name, type="vim")
- thread_name = get_non_used_vim_name(datacenter_name, datacenter_id)
- new_thread = vim_thread(task_lock, plugins, thread_name, None, datacenter_tenant_id, db=db)
- new_thread.start()
- thread_id = datacenter_tenants_dict["uuid"]
- vim_threads["running"][thread_id] = new_thread
- return thread_id
- except vimconn.VimConnException as e:
- raise NfvoException(str(e), httperrors.Bad_Request)
-
-
-def edit_vim_account(mydb, nfvo_tenant, datacenter_tenant_id, datacenter_id=None, name=None, vim_tenant=None,
- vim_tenant_name=None, vim_username=None, vim_password=None, config=None):
-
- # get vim_account; check is valid for this tenant
- from_ = "datacenter_tenants as dt JOIN tenants_datacenters as td ON dt.uuid=td.datacenter_tenant_id"
- where_ = {"td.nfvo_tenant_id": nfvo_tenant}
- if datacenter_tenant_id:
- where_["dt.uuid"] = datacenter_tenant_id
- if datacenter_id:
- where_["dt.datacenter_id"] = datacenter_id
- vim_accounts = mydb.get_rows(SELECT="dt.uuid as uuid, config", FROM=from_, WHERE=where_)
- if not vim_accounts:
- raise NfvoException("vim_account not found for this tenant", http_code=httperrors.Not_Found)
- elif len(vim_accounts) > 1:
- raise NfvoException("found more than one vim_account for this tenant", http_code=httperrors.Conflict)
- datacenter_tenant_id = vim_accounts[0]["uuid"]
- original_config = vim_accounts[0]["config"]
-
- update_ = {}
- if config:
- original_config_dict = yaml.load(original_config, Loader=yaml.Loader)
- original_config_dict.update(config)
- update_["config"] = yaml.safe_dump(original_config_dict, default_flow_style=True, width=256)
- if name:
- update_['name'] = name
- if vim_tenant:
- update_['vim_tenant_id'] = vim_tenant
- if vim_tenant_name:
- update_['vim_tenant_name'] = vim_tenant_name
- if vim_username:
- update_['user'] = vim_username
- if vim_password:
- update_['passwd'] = vim_password
- if update_:
- mydb.update_rows("datacenter_tenants", UPDATE=update_, WHERE={"uuid": datacenter_tenant_id})
-
- vim_threads["running"][datacenter_tenant_id].insert_task("reload")
- return datacenter_tenant_id
-
-def delete_vim_account(mydb, tenant_id, vim_account_id, datacenter=None):
- #get nfvo_tenant info
- if not tenant_id or tenant_id=="any":
- tenant_uuid = None
- else:
- tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant_id)
- tenant_uuid = tenant_dict['uuid']
-
- #check that this association exist before
- tenants_datacenter_dict = {}
- if datacenter:
- datacenter_id, _ = get_datacenter_uuid(mydb, tenant_uuid, datacenter)
- tenants_datacenter_dict["datacenter_id"] = datacenter_id
- elif vim_account_id:
- tenants_datacenter_dict["datacenter_tenant_id"] = vim_account_id
- if tenant_uuid:
- tenants_datacenter_dict["nfvo_tenant_id"] = tenant_uuid
- tenant_datacenter_list = mydb.get_rows(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict)
- if len(tenant_datacenter_list)==0 and tenant_uuid:
- raise NfvoException("datacenter '{}' and tenant '{}' are not attached".format(datacenter_id, tenant_dict['uuid']), httperrors.Not_Found)
-
- #delete this association
- mydb.delete_row(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict)
-
- #get vim_tenant info and deletes
- warning=''
- for tenant_datacenter_item in tenant_datacenter_list:
- vim_tenant_dict = mydb.get_table_by_uuid_name('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id'])
- #try to delete vim:tenant
- try:
- mydb.delete_row_by_id('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id'])
- if vim_tenant_dict['created']=='true':
- #delete tenant at VIM if created by NFVO
- try:
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
- myvim.delete_tenant(vim_tenant_dict['vim_tenant_id'])
- except vimconn.VimConnException as e:
- warning = "Not possible to delete vim_tenant_id {} from VIM: {} ".format(vim_tenant_dict['vim_tenant_id'], str(e))
- logger.warn(warning)
- except db_base_Exception as e:
- logger.error("Cannot delete datacenter_tenants " + str(e))
- pass # the error will be caused because dependencies, vim_tenant can not be deleted
- thread_id = tenant_datacenter_item["datacenter_tenant_id"]
- thread = vim_threads["running"].get(thread_id)
- if thread:
- thread.insert_task("exit")
- vim_threads["deleting"][thread_id] = thread
- return "datacenter {} detached. {}".format(datacenter_id, warning)
-
-
-def datacenter_action(mydb, tenant_id, datacenter, action_dict):
- #DEPRECATED
- #get datacenter info
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
-
- if 'check-connectivity' in action_dict:
- try:
- myvim.check_vim_connectivity()
- except vimconn.VimConnException as e:
- #logger.error("nfvo.datacenter_action() Not possible to get_network_list from VIM: %s ", str(e))
- raise NfvoException(str(e), e.http_code)
- elif 'net-update' in action_dict:
- try:
- nets = myvim.get_network_list(filter_dict={'shared': True, 'admin_state_up': True, 'status': 'ACTIVE'})
- #print content
- except vimconn.VimConnException as e:
- #logger.error("nfvo.datacenter_action() Not possible to get_network_list from VIM: %s ", str(e))
- raise NfvoException(str(e), httperrors.Internal_Server_Error)
- #update nets Change from VIM format to NFVO format
- net_list=[]
- for net in nets:
- net_nfvo={'datacenter_id': datacenter_id}
- net_nfvo['name'] = net['name']
- #net_nfvo['description']= net['name']
- net_nfvo['vim_net_id'] = net['id']
- net_nfvo['type'] = net['type'][0:6] #change from ('ptp','data','bridge_data','bridge_man') to ('bridge','data','ptp')
- net_nfvo['shared'] = net['shared']
- net_nfvo['multipoint'] = False if net['type']=='ptp' else True
- net_list.append(net_nfvo)
- inserted, deleted = mydb.update_datacenter_nets(datacenter_id, net_list)
- logger.info("Inserted %d nets, deleted %d old nets", inserted, deleted)
- return inserted
- elif 'net-edit' in action_dict:
- net = action_dict['net-edit'].pop('net')
- what = 'vim_net_id' if utils.check_valid_uuid(net) else 'name'
- result = mydb.update_rows('datacenter_nets', action_dict['net-edit'],
- WHERE={'datacenter_id':datacenter_id, what: net})
- return result
- elif 'net-delete' in action_dict:
- net = action_dict['net-deelte'].get('net')
- what = 'vim_net_id' if utils.check_valid_uuid(net) else 'name'
- result = mydb.delete_row(FROM='datacenter_nets',
- WHERE={'datacenter_id':datacenter_id, what: net})
- return result
-
- else:
- raise NfvoException("Unknown action " + str(action_dict), httperrors.Bad_Request)
-
-
-def datacenter_edit_netmap(mydb, tenant_id, datacenter, netmap, action_dict):
- #get datacenter info
- datacenter_id, _ = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
-
- what = 'uuid' if utils.check_valid_uuid(netmap) else 'name'
- result = mydb.update_rows('datacenter_nets', action_dict['netmap'],
- WHERE={'datacenter_id':datacenter_id, what: netmap})
- return result
-
-
-def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None):
- #get datacenter info
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
- filter_dict={}
- if action_dict:
- action_dict = action_dict["netmap"]
- if 'vim_id' in action_dict:
- filter_dict["id"] = action_dict['vim_id']
- if 'vim_name' in action_dict:
- filter_dict["name"] = action_dict['vim_name']
- else:
- filter_dict["shared"] = True
-
- try:
- vim_nets = myvim.get_network_list(filter_dict=filter_dict)
- except vimconn.VimConnException as e:
- #logger.error("nfvo.datacenter_new_netmap() Not possible to get_network_list from VIM: %s ", str(e))
- raise NfvoException(str(e), httperrors.Internal_Server_Error)
- if len(vim_nets)>1 and action_dict:
- raise NfvoException("more than two networks found, specify with vim_id", httperrors.Conflict)
- elif len(vim_nets)==0: # and action_dict:
- raise NfvoException("Not found a network at VIM with " + str(filter_dict), httperrors.Not_Found)
- net_list=[]
- for net in vim_nets:
- net_nfvo={'datacenter_id': datacenter_id}
- if action_dict and "name" in action_dict:
- net_nfvo['name'] = action_dict['name']
- else:
- net_nfvo['name'] = net['name']
- #net_nfvo['description']= net['name']
- net_nfvo['vim_net_id'] = net['id']
- net_nfvo['type'] = net['type'][0:6] #change from ('ptp','data','bridge_data','bridge_man') to ('bridge','data','ptp')
- net_nfvo['shared'] = net['shared']
- net_nfvo['multipoint'] = False if net['type']=='ptp' else True
- try:
- net_id = mydb.new_row("datacenter_nets", net_nfvo, add_uuid=True)
- net_nfvo["status"] = "OK"
- net_nfvo["uuid"] = net_id
- except db_base_Exception as e:
- if action_dict:
- raise
- else:
- net_nfvo["status"] = "FAIL: " + str(e)
- net_list.append(net_nfvo)
- return net_list
-
-def get_sdn_net_id(mydb, tenant_id, datacenter, network_id):
- # obtain all network data
- try:
- if utils.check_valid_uuid(network_id):
- filter_dict = {"id": network_id}
- else:
- filter_dict = {"name": network_id}
-
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
- network = myvim.get_network_list(filter_dict=filter_dict)
- except vimconn.VimConnException as e:
- raise NfvoException("Not possible to get_sdn_net_id from VIM: {}".format(str(e)), e.http_code)
-
- # ensure the network is defined
- if len(network) == 0:
- raise NfvoException("Network {} is not present in the system".format(network_id),
- httperrors.Bad_Request)
-
- # ensure there is only one network with the provided name
- if len(network) > 1:
- raise NfvoException("Multiple networks present in vim identified by {}".format(network_id), httperrors.Bad_Request)
-
- # ensure it is a dataplane network
- if network[0]['type'] != 'data':
- return None
-
- # ensure we use the id
- network_id = network[0]['id']
-
- # search in dabase mano_db in table instance nets for the sdn_net_id that corresponds to the vim_net_id==network_id
- # and with instance_scenario_id==NULL
- #search_dict = {'vim_net_id': network_id, 'instance_scenario_id': None}
- search_dict = {'vim_net_id': network_id}
-
- try:
- #sdn_network_id = mydb.get_rows(SELECT=('sdn_net_id',), FROM='instance_nets', WHERE=search_dict)[0]['sdn_net_id']
- result = mydb.get_rows(SELECT=('sdn_net_id',), FROM='instance_nets', WHERE=search_dict)
- except db_base_Exception as e:
- raise NfvoException("db_base_Exception obtaining SDN network to associated to vim network {}".format(
- network_id) + str(e), e.http_code)
-
- sdn_net_counter = 0
- for net in result:
- if net['sdn_net_id'] != None:
- sdn_net_counter+=1
- sdn_net_id = net['sdn_net_id']
-
- if sdn_net_counter == 0:
- return None
- elif sdn_net_counter == 1:
- return sdn_net_id
- else:
- raise NfvoException("More than one SDN network is associated to vim network {}".format(
- network_id), httperrors.Internal_Server_Error)
-
-def get_sdn_controller_id(mydb, datacenter):
- # Obtain sdn controller id
- config = mydb.get_rows(SELECT=('config',), FROM='datacenters', WHERE={'uuid': datacenter})[0].get('config', '{}')
- if not config:
- return None
-
- return yaml.load(config, Loader=yaml.Loader).get('sdn-controller')
-
-def vim_net_sdn_attach(mydb, tenant_id, datacenter, network_id, descriptor):
- try:
- sdn_network_id = get_sdn_net_id(mydb, tenant_id, datacenter, network_id)
- if not sdn_network_id:
- raise NfvoException("No SDN network is associated to vim-network {}".format(network_id), httperrors.Internal_Server_Error)
-
- #Obtain sdn controller id
- controller_id = get_sdn_controller_id(mydb, datacenter)
- if not controller_id:
- raise NfvoException("No SDN controller is set for datacenter {}".format(datacenter), httperrors.Internal_Server_Error)
-
- #Obtain sdn controller info
- sdn_controller = ovim.show_of_controller(controller_id)
-
- port_data = {
- 'name': 'external_port',
- 'net_id': sdn_network_id,
- 'ofc_id': controller_id,
- 'switch_dpid': sdn_controller['dpid'],
- 'switch_port': descriptor['port']
- }
-
- if 'vlan' in descriptor:
- port_data['vlan'] = descriptor['vlan']
- if 'mac' in descriptor:
- port_data['mac'] = descriptor['mac']
-
- result = ovim.new_port(port_data)
- except ovimException as e:
- raise NfvoException("ovimException attaching SDN network {} to vim network {}".format(
- sdn_network_id, network_id) + str(e), httperrors.Internal_Server_Error)
- except db_base_Exception as e:
- raise NfvoException("db_base_Exception attaching SDN network to vim network {}".format(
- network_id) + str(e), e.http_code)
-
- return 'Port uuid: '+ result
-
-def vim_net_sdn_detach(mydb, tenant_id, datacenter, network_id, port_id=None):
- if port_id:
- filter = {'uuid': port_id}
- else:
- sdn_network_id = get_sdn_net_id(mydb, tenant_id, datacenter, network_id)
- if not sdn_network_id:
- raise NfvoException("No SDN network is associated to vim-network {}".format(network_id),
- httperrors.Internal_Server_Error)
- #in case no port_id is specified only ports marked as 'external_port' will be detached
- filter = {'name': 'external_port', 'net_id': sdn_network_id}
-
- try:
- port_list = ovim.get_ports(columns={'uuid'}, filter=filter)
- except ovimException as e:
- raise NfvoException("ovimException obtaining external ports for net {}. ".format(network_id) + str(e),
- httperrors.Internal_Server_Error)
-
- if len(port_list) == 0:
- raise NfvoException("No ports attached to the network {} were found with the requested criteria".format(network_id),
- httperrors.Bad_Request)
-
- port_uuid_list = []
- for port in port_list:
- try:
- port_uuid_list.append(port['uuid'])
- ovim.delete_port(port['uuid'])
- except ovimException as e:
- raise NfvoException("ovimException deleting port {} for net {}. ".format(port['uuid'], network_id) + str(e), httperrors.Internal_Server_Error)
-
- return 'Detached ports uuid: {}'.format(','.join(port_uuid_list))
-
-def vim_action_get(mydb, tenant_id, datacenter, item, name):
- #get datacenter info
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
- filter_dict={}
- if name:
- if utils.check_valid_uuid(name):
- filter_dict["id"] = name
- else:
- filter_dict["name"] = name
- try:
- if item=="networks":
- #filter_dict['tenant_id'] = myvim['tenant_id']
- content = myvim.get_network_list(filter_dict=filter_dict)
-
- if len(content) == 0:
- raise NfvoException("Network {} is not present in the system. ".format(name),
- httperrors.Bad_Request)
-
- #Update the networks with the attached ports
- for net in content:
- sdn_network_id = get_sdn_net_id(mydb, tenant_id, datacenter, net['id'])
- if sdn_network_id != None:
- try:
- #port_list = ovim.get_ports(columns={'uuid', 'switch_port', 'vlan'}, filter={'name': 'external_port', 'net_id': sdn_network_id})
- port_list = ovim.get_ports(columns={'uuid', 'switch_port', 'vlan','name'}, filter={'net_id': sdn_network_id})
- except ovimException as e:
- raise NfvoException("ovimException obtaining external ports for net {}. ".format(network_id) + str(e), httperrors.Internal_Server_Error)
- #Remove field name and if port name is external_port save it as 'type'
- for port in port_list:
- if port['name'] == 'external_port':
- port['type'] = "External"
- del port['name']
- net['sdn_network_id'] = sdn_network_id
- net['sdn_attached_ports'] = port_list
-
- elif item=="tenants":
- content = myvim.get_tenant_list(filter_dict=filter_dict)
- elif item == "images":
-
- content = myvim.get_image_list(filter_dict=filter_dict)
- else:
- raise NfvoException(item + "?", httperrors.Method_Not_Allowed)
- logger.debug("vim_action response %s", content) #update nets Change from VIM format to NFVO format
- if name and len(content)==1:
- return {item[:-1]: content[0]}
- elif name and len(content)==0:
- raise NfvoException("No {} found with ".format(item[:-1]) + " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), filter_dict.items())),
- datacenter)
- else:
- return {item: content}
- except vimconn.VimConnException as e:
- print("vim_action Not possible to get_{}_list from VIM: {} ".format(item, str(e)))
- raise NfvoException("Not possible to get_{}_list from VIM: {}".format(item, str(e)), e.http_code)
-
-
-def vim_action_delete(mydb, tenant_id, datacenter, item, name):
- #get datacenter info
- if tenant_id == "any":
- tenant_id=None
-
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
- #get uuid name
- content = vim_action_get(mydb, tenant_id, datacenter, item, name)
- logger.debug("vim_action_delete vim response: " + str(content))
- items = next(iter(content.values()))
- if type(items)==list and len(items)==0:
- raise NfvoException("Not found " + item, httperrors.Not_Found)
- elif type(items)==list and len(items)>1:
- raise NfvoException("Found more than one {} with this name. Use uuid.".format(item), httperrors.Not_Found)
- else: # it is a dict
- item_id = items["id"]
- item_name = str(items.get("name"))
-
- try:
- if item=="networks":
- # If there is a SDN network associated to the vim-network, proceed to clear the relationship and delete it
- sdn_network_id = get_sdn_net_id(mydb, tenant_id, datacenter, item_id)
- if sdn_network_id != None:
- #Delete any port attachment to this network
- try:
- port_list = ovim.get_ports(columns={'uuid'}, filter={'net_id': sdn_network_id})
- except ovimException as e:
- raise NfvoException(
- "ovimException obtaining external ports for net {}. ".format(sdn_network_id) + str(e),
- httperrors.Internal_Server_Error)
-
- # By calling one by one all ports to be detached we ensure that not only the external_ports get detached
- for port in port_list:
- vim_net_sdn_detach(mydb, tenant_id, datacenter, item_id, port['uuid'])
-
- #Delete from 'instance_nets' the correspondence between the vim-net-id and the sdn-net-id
- try:
- mydb.delete_row(FROM='instance_nets', WHERE={'instance_scenario_id': None,
- 'sdn_net_id': sdn_network_id,
- 'vim_net_id': item_id})
- except db_base_Exception as e:
- raise NfvoException("Error deleting correspondence for VIM/SDN dataplane networks{}: {}".format(
- item_id, e), e.http_code)
-
- #Delete the SDN network
- try:
- ovim.delete_network(sdn_network_id)
- except ovimException as e:
- logger.error("ovimException deleting SDN network={} ".format(sdn_network_id) + str(e), exc_info=True)
- raise NfvoException("ovimException deleting SDN network={} ".format(sdn_network_id) + str(e),
- httperrors.Internal_Server_Error)
-
- content = myvim.delete_network(item_id)
- elif item=="tenants":
- content = myvim.delete_tenant(item_id)
- elif item == "images":
- content = myvim.delete_image(item_id)
- else:
- raise NfvoException(item + "?", httperrors.Method_Not_Allowed)
- except vimconn.VimConnException as e:
- #logger.error( "vim_action Not possible to delete_{} {}from VIM: {} ".format(item, name, str(e)))
- raise NfvoException("Not possible to delete_{} {} from VIM: {}".format(item, name, str(e)), e.http_code)
-
- return "{} {} {} deleted".format(item[:-1], item_id,item_name)
-
-
-def vim_action_create(mydb, tenant_id, datacenter, item, descriptor):
- #get datacenter info
- logger.debug("vim_action_create descriptor %s", str(descriptor))
- if tenant_id == "any":
- tenant_id=None
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
- try:
- if item=="networks":
- net = descriptor["network"]
- net_name = net.pop("name")
- net_type = net.pop("type", "bridge")
- net_public = net.pop("shared", False)
- net_ipprofile = net.pop("ip_profile", None)
- net_vlan = net.pop("vlan", None)
- net_provider_network_profile = None
- if net_vlan:
- net_provider_network_profile = {"segmentation-id": net_vlan}
- content, _ = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, provider_network_profile=net_provider_network_profile) #, **net)
-
- #If the datacenter has a SDN controller defined and the network is of dataplane type, then create the sdn network
- if get_sdn_controller_id(mydb, datacenter) != None and (net_type == 'data' or net_type == 'ptp'):
- #obtain datacenter_tenant_id
- datacenter_tenant_id = mydb.get_rows(SELECT=('uuid',),
- FROM='datacenter_tenants',
- WHERE={'datacenter_id': datacenter})[0]['uuid']
- try:
- sdn_network = {}
- sdn_network['vlan'] = net_vlan
- sdn_network['type'] = net_type
- sdn_network['name'] = net_name
- sdn_network['region'] = datacenter_tenant_id
- ovim_content = ovim.new_network(sdn_network)
- except ovimException as e:
- logger.error("ovimException creating SDN network={} ".format(
- sdn_network) + str(e), exc_info=True)
- raise NfvoException("ovimException creating SDN network={} ".format(sdn_network) + str(e),
- httperrors.Internal_Server_Error)
-
- # Save entry in in dabase mano_db in table instance_nets to stablish a dictionary vim_net_id <->sdn_net_id
- # use instance_scenario_id=None to distinguish from real instaces of nets
- correspondence = {'instance_scenario_id': None,
- 'sdn_net_id': ovim_content,
- 'vim_net_id': content,
- 'datacenter_tenant_id': datacenter_tenant_id
- }
- try:
- mydb.new_row('instance_nets', correspondence, add_uuid=True)
- except db_base_Exception as e:
- raise NfvoException("Error saving correspondence for VIM/SDN dataplane networks{}: {}".format(
- correspondence, e), e.http_code)
- elif item=="tenants":
- tenant = descriptor["tenant"]
- content = myvim.new_tenant(tenant["name"], tenant.get("description"))
- else:
- raise NfvoException(item + "?", httperrors.Method_Not_Allowed)
- except vimconn.VimConnException as e:
- raise NfvoException("Not possible to create {} at VIM: {}".format(item, str(e)), e.http_code)
-
- return vim_action_get(mydb, tenant_id, datacenter, item, content)
-
-def sdn_controller_create(mydb, tenant_id, sdn_controller):
- try:
- wim_id = ovim.new_of_controller(sdn_controller)
-
- # Load plugin if not previously loaded
- controller_type = sdn_controller.get("type")
- plugin_name = "rosdn_" + controller_type
- if plugin_name not in plugins:
- _load_plugin(plugin_name, type="sdn")
-
- thread_name = get_non_used_vim_name(sdn_controller['name'], wim_id)
- new_thread = vim_thread(task_lock, plugins, thread_name, wim_id, None, db=db)
- new_thread.start()
- thread_id = wim_id
- vim_threads["running"][thread_id] = new_thread
- logger.debug('New SDN controller created with uuid {}'.format(wim_id))
- return wim_id
- except ovimException as e:
- raise NfvoException(e) from e
-
-def sdn_controller_update(mydb, tenant_id, controller_id, sdn_controller):
- data = ovim.edit_of_controller(controller_id, sdn_controller)
- msg = 'SDN controller {} updated'.format(data)
- vim_threads["running"][controller_id].insert_task("reload")
- logger.debug(msg)
- return msg
-
-def sdn_controller_list(mydb, tenant_id, controller_id=None):
- if controller_id == None:
- data = ovim.get_of_controllers()
- else:
- data = ovim.show_of_controller(controller_id)
-
- msg = 'SDN controller list:\n {}'.format(data)
- logger.debug(msg)
- return data
-
-def sdn_controller_delete(mydb, tenant_id, controller_id):
- select_ = ('uuid', 'config')
- datacenters = mydb.get_rows(FROM='datacenters', SELECT=select_)
- for datacenter in datacenters:
- if datacenter['config']:
- config = yaml.load(datacenter['config'], Loader=yaml.Loader)
- if 'sdn-controller' in config and config['sdn-controller'] == controller_id:
- raise NfvoException("SDN controller {} is in use by datacenter {}".format(controller_id, datacenter['uuid']), httperrors.Conflict)
-
- data = ovim.delete_of_controller(controller_id)
- msg = 'SDN controller {} deleted'.format(data)
- logger.debug(msg)
- return msg
-
-def datacenter_sdn_port_mapping_set(mydb, tenant_id, datacenter_id, sdn_port_mapping):
- controller = mydb.get_rows(FROM="datacenters", SELECT=("config",), WHERE={"uuid":datacenter_id})
- if len(controller) < 1:
- raise NfvoException("Datacenter {} not present in the database".format(datacenter_id), httperrors.Not_Found)
-
- try:
- sdn_controller_id = yaml.load(controller[0]["config"], Loader=yaml.Loader)["sdn-controller"]
- except:
- raise NfvoException("The datacenter {} has not an SDN controller associated".format(datacenter_id), httperrors.Bad_Request)
-
- sdn_controller = ovim.show_of_controller(sdn_controller_id)
- switch_dpid = sdn_controller["dpid"]
-
- maps = list()
- for compute_node in sdn_port_mapping:
- #element = {"ofc_id": sdn_controller_id, "region": datacenter_id, "switch_dpid": switch_dpid}
- element = dict()
- element["compute_node"] = compute_node["compute_node"]
- if compute_node["ports"]:
- for port in compute_node["ports"]:
- pci = port.get("pci")
- element["switch_port"] = port.get("switch_port")
- element["switch_mac"] = port.get("switch_mac")
- element["switch_dpid"] = port.get("switch_dpid")
- element["switch_id"] = port.get("switch_id")
- if not element["switch_port"] and not element["switch_mac"]:
- raise NfvoException ("The mapping must contain 'switch_port' or 'switch_mac'", httperrors.Bad_Request)
- for pci_expanded in utils.expand_brackets(pci):
- element["pci"] = pci_expanded
- maps.append(dict(element))
-
- out = ovim.set_of_port_mapping(maps, sdn_id=sdn_controller_id, switch_dpid=switch_dpid, vim_id=datacenter_id)
- vim_threads["running"][sdn_controller_id].insert_task("reload")
- return out
-
-def datacenter_sdn_port_mapping_list(mydb, tenant_id, datacenter_id):
- maps = ovim.get_of_port_mappings(db_filter={"datacenter_id": datacenter_id})
-
- result = {
- "sdn-controller": None,
- "datacenter-id": datacenter_id,
- "dpid": None,
- "ports_mapping": list()
- }
-
- datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id)
- if datacenter['config']:
- config = yaml.load(datacenter['config'], Loader=yaml.Loader)
- if 'sdn-controller' in config:
- controller_id = config['sdn-controller']
- sdn_controller = sdn_controller_list(mydb, tenant_id, controller_id)
- result["sdn-controller"] = controller_id
- result["dpid"] = sdn_controller["dpid"]
-
- if result["sdn-controller"] == None:
- raise NfvoException("SDN controller is not defined for datacenter {}".format(datacenter_id), httperrors.Bad_Request)
- if result["dpid"] == None:
- raise NfvoException("It was not possible to determine DPID for SDN controller {}".format(result["sdn-controller"]),
- httperrors.Internal_Server_Error)
-
- if len(maps) == 0:
- return result
-
- ports_correspondence_dict = dict()
- for link in maps:
- if result["sdn-controller"] != link["wim_id"]:
- raise NfvoException("The sdn-controller specified for different port mappings differ", httperrors.Internal_Server_Error)
- if result["dpid"] != link["switch_dpid"]:
- raise NfvoException("The dpid specified for different port mappings differ", httperrors.Internal_Server_Error)
- link_config = link["service_mapping_info"]
- element = dict()
- element["pci"] = link.get("device_interface_id")
- if link["switch_port"]:
- element["switch_port"] = link["switch_port"]
- if link_config["switch_mac"]:
- element["switch_mac"] = link_config.get("switch_mac")
-
- if not link.get("interface_id") in ports_correspondence_dict:
- content = dict()
- content["compute_node"] = link.get("interface_id")
- content["ports"] = list()
- ports_correspondence_dict[link.get("interface_id")] = content
-
- ports_correspondence_dict[link["interface_id"]]["ports"].append(element)
-
- for key in sorted(ports_correspondence_dict):
- result["ports_mapping"].append(ports_correspondence_dict[key])
-
- return result
-
-def datacenter_sdn_port_mapping_delete(mydb, tenant_id, datacenter_id):
- return ovim.clear_of_port_mapping(db_filter={"datacenter_id":datacenter_id})
-
-def create_RO_keypair(tenant_id):
- """
- Creates a public / private keys for a RO tenant and returns their values
- Params:
- tenant_id: ID of the tenant
- Return:
- public_key: Public key for the RO tenant
- private_key: Encrypted private key for RO tenant
- """
-
- bits = 2048
- key = RSA.generate(bits)
- try:
- public_key = key.publickey().exportKey('OpenSSH')
- if isinstance(public_key, ValueError):
- raise NfvoException("Unable to create public key: {}".format(public_key), httperrors.Internal_Server_Error)
- private_key = key.exportKey(passphrase=tenant_id, pkcs=8)
- except (ValueError, NameError) as e:
- raise NfvoException("Unable to create private key: {}".format(e), httperrors.Internal_Server_Error)
- if isinstance(public_key, bytes):
- public_key = public_key.decode(encoding='UTF-8')
- if isinstance(private_key, bytes):
- private_key = private_key.decode(encoding='UTF-8')
- return public_key, private_key
-
-def decrypt_key (key, tenant_id):
- """
- Decrypts an encrypted RSA key
- Params:
- key: Private key to be decrypted
- tenant_id: ID of the tenant
- Return:
- unencrypted_key: Unencrypted private key for RO tenant
- """
- try:
- key = RSA.importKey(key,tenant_id)
- unencrypted_key = key.exportKey('PEM')
- if isinstance(unencrypted_key, ValueError):
- raise NfvoException("Unable to decrypt the private key: {}".format(unencrypted_key), httperrors.Internal_Server_Error)
- if isinstance(unencrypted_key, bytes):
- unencrypted_key = unencrypted_key.decode(encoding='UTF-8')
- except ValueError as e:
- raise NfvoException("Unable to decrypt the private key: {}".format(e), httperrors.Internal_Server_Error)
- return unencrypted_key
projects / osm / RO.git / blobdiff