return None
- def _get_db_all_tasks(self):
- """
- Read all content of table ro_tasks to log it
- :return: None
- """
- try:
- # Checking the content of the BD:
-
- # read and return
- ro_task = self.db.get_list("ro_tasks")
- for rt in ro_task:
- self._log_ro_task(rt, None, None, "TASK_WF", "GET_ALL_TASKS")
- return ro_task
-
- except DbException as e:
- self.logger.error("Database exception at _get_db_all_tasks: {}".format(e))
- except Exception as e:
- self.logger.critical(
- "Unexpected exception at _get_db_all_tasks: {}".format(e), exc_info=True
- )
-
- return None
-
- def _log_ro_task(self, ro_task, db_ro_task_update, db_ro_task_delete, mark, event):
- """
- Generate a log with the following format:
-
- Mark;Event;ro_task_id;locked_at;modified_at;created_at;to_check_at;locked_by;
- target_id;vim_info.refresh_at;vim_info;no_of_tasks;task_status;action_id;
- task_array_index;task_id;task_action;task_item;task_args
-
- Example:
-
- TASK_WF;GET_TASK;888f1864-749a-4fc2-bc1a-97c0fffd6a6f:2;1642158724.8210013;
- 1642158640.7986135;1642158640.7986135;1642158640.7986135;b134c9494e75:0a
- ;vim:b7ff9e24-8868-4d68-8a57-a59dc11d0327;None;{'created': False,
- 'created_items': None, 'vim_id': None, 'vim_name': None, 'vim_status': None,
- 'vim_details': None, 'vim_message': None, 'refresh_at': None};1;SCHEDULED;
- 888f1864-749a-4fc2-bc1a-97c0fffd6a6f;0;888f1864-749a-4fc2-bc1a-97c0fffd6a6f:2;
- CREATE;image;{'filter_dict': {'name': 'ubuntu-os-cloud:image-family:ubuntu-1804-lts'}}
- """
- try:
- line = []
- i = 0
- if ro_task is not None and isinstance(ro_task, dict):
- for t in ro_task["tasks"]:
- line.clear()
- line.append(mark)
- line.append(event)
- line.append(ro_task.get("_id", ""))
- line.append(str(ro_task.get("locked_at", "")))
- line.append(str(ro_task.get("modified_at", "")))
- line.append(str(ro_task.get("created_at", "")))
- line.append(str(ro_task.get("to_check_at", "")))
- line.append(str(ro_task.get("locked_by", "")))
- line.append(str(ro_task.get("target_id", "")))
- line.append(str(ro_task.get("vim_info", {}).get("refresh_at", "")))
- line.append(str(ro_task.get("vim_info", "")))
- line.append(str(ro_task.get("tasks", "")))
- if isinstance(t, dict):
- line.append(str(t.get("status", "")))
- line.append(str(t.get("action_id", "")))
- line.append(str(i))
- line.append(str(t.get("task_id", "")))
- line.append(str(t.get("action", "")))
- line.append(str(t.get("item", "")))
- line.append(str(t.get("find_params", "")))
- line.append(str(t.get("params", "")))
- else:
- line.extend([""] * 2)
- line.append(str(i))
- line.extend([""] * 5)
-
- i += 1
- self.logger.debug(";".join(line))
- elif db_ro_task_update is not None and isinstance(db_ro_task_update, dict):
- i = 0
- while True:
- st = "tasks.{}.status".format(i)
- if st not in db_ro_task_update:
- break
- line.clear()
- line.append(mark)
- line.append(event)
- line.append(db_ro_task_update.get("_id", ""))
- line.append(str(db_ro_task_update.get("locked_at", "")))
- line.append(str(db_ro_task_update.get("modified_at", "")))
- line.append("")
- line.append(str(db_ro_task_update.get("to_check_at", "")))
- line.append(str(db_ro_task_update.get("locked_by", "")))
- line.append("")
- line.append(str(db_ro_task_update.get("vim_info.refresh_at", "")))
- line.append("")
- line.append(str(db_ro_task_update.get("vim_info", "")))
- line.append(str(str(db_ro_task_update).count(".status")))
- line.append(db_ro_task_update.get(st, ""))
- line.append("")
- line.append(str(i))
- line.extend([""] * 3)
- i += 1
- self.logger.debug(";".join(line))
-
- elif db_ro_task_delete is not None and isinstance(db_ro_task_delete, dict):
- line.clear()
- line.append(mark)
- line.append(event)
- line.append(db_ro_task_delete.get("_id", ""))
- line.append("")
- line.append(db_ro_task_delete.get("modified_at", ""))
- line.extend([""] * 13)
- self.logger.debug(";".join(line))
-
- else:
- line.clear()
- line.append(mark)
- line.append(event)
- line.extend([""] * 16)
- self.logger.debug(";".join(line))
-
- except Exception as e:
- self.logger.error("Error logging ro_task: {}".format(e))
-
def _delete_task(self, ro_task, task_index, task_depends, db_update):
"""
Determine if this task need to be done or superseded
\r
return new_data\r
\r
- def get_pending_tasks(self):\r
- return self.cvpClientApi.get_tasks_by_status("Pending")\r
-\r
- def get_pending_tasks_old(self):\r
- taskList = []\r
- tasksField = {\r
- "workOrderId": "workOrderId",\r
- "workOrderState": "workOrderState",\r
- "currentTaskName": "currentTaskName",\r
- "description": "description",\r
- "workOrderUserDefinedStatus": "workOrderUserDefinedStatus",\r
- "note": "note",\r
- "taskStatus": "taskStatus",\r
- "workOrderDetails": "workOrderDetails",\r
- }\r
- tasks = self.cvpClientApi.get_tasks_by_status("Pending")\r
-\r
- # Reduce task data to required fields\r
- for task in tasks:\r
- taskFacts = {}\r
- for field in task.keys():\r
- if field in tasksField:\r
- taskFacts[tasksField[field]] = task[field]\r
-\r
- taskList.append(taskFacts)\r
-\r
- return taskList\r
-\r
def task_action(self, tasks, wait, state):\r
changed = False\r
data = dict()\r
import copy
import json
-from time import time
import requests
from requests.exceptions import ConnectionError
return resp.json()
- def post_headers_cmd(self, url, headers, post_fields_dict=None):
- self._logger.debug("")
-
- # obfuscate password before logging dict
- if (
- post_fields_dict.get("auth", {})
- .get("identity", {})
- .get("password", {})
- .get("user", {})
- .get("password")
- ):
- post_fields_dict_copy = copy.deepcopy(post_fields_dict)
- post_fields_dict["auth"]["identity"]["password"]["user"][
- "password"
- ] = "******"
- json_data_log = post_fields_dict_copy
- else:
- json_data_log = post_fields_dict
-
- self._logger.debug("Request POSTFIELDS: {}".format(json.dumps(json_data_log)))
- resp = self._request("POST_HEADERS", url, headers, data=post_fields_dict)
-
- return resp.text
-
def post_cmd(self, url, headers, post_fields_dict=None):
self._logger.debug("")
return resp.text
- def _get_token(self, headers):
- if self.auth_url:
- self._logger.debug("Current Token: {}".format(self.token))
- auth_url = self.auth_url + "auth/tokens"
-
- if self.token is None or self._token_expired():
- if not self.auth_url:
- self.token = ""
-
- resp = self._request_noauth(
- url=auth_url, op="POST", headers=headers, data=self.auth_dict
- )
- self.token = resp.headers.get("x-subject-token")
- self.last_token_time = time.time()
- self._logger.debug("Obtained token: {}".format(self.token))
-
- return self.token
-
- def _token_expired(self):
- current_time = time.time()
-
- if self.last_token_time and (
- current_time - self.last_token_time < self.token_timeout
- ):
- return False
- else:
- return True
-
def _request(self, op, url, http_headers, data=None, retry_auth_error=True):
headers = http_headers.copy()
"virtual-port-group"
)
- def get_vpgs(self):
- return self.get_all_by_type(self.controller_url, "virtual-port-groups")
-
def get_vpg_by_name(self, vpg_name):
fq_name = ["default-global-system-config", self.fabric, vpg_name]
def get_url(self):
return self.url
- def get_overlay_url(self):
- return self.overlay_url
-
def _create_port(self, switch_id, switch_port, network, vlan):
"""
1 - Look for virtual port groups for provided switch_id, switch_port using name
raise vimconn.VimConnConnectionException(type(e).__name__ + ": " + str(e))
- def get_availability_zones_list(self):
- """Obtain AvailabilityZones from AWS"""
- try:
- self._reload_connection()
- az_list = []
-
- for az in self.conn.get_all_zones():
- az_list.append(az.name)
-
- return az_list
- except Exception as e:
- self.format_vimconn_exception(e)
-
def get_tenant_list(self, filter_dict={}):
"""Obtain tenants of VIM
filter_dict dictionary that can contain the following keys:
from azure.core.exceptions import ResourceNotFoundError
from azure.identity import ClientSecretCredential
from azure.mgmt.compute import ComputeManagementClient
-from azure.mgmt.compute.models import DiskCreateOption
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.resource import ResourceManagementClient
from azure.profiles import ProfileDefinition
virtual_machine = creation_result.result()
self.logger.debug("created vm name: %s", vm_name)
- """ Por ahora no hacer polling para ver si tarda menos
- # Add disks if they are provided
- if disk_list:
- for disk_index, disk in enumerate(disk_list):
- self.logger.debug(
- "add disk size: %s, image: %s",
- disk.get("size"),
- disk.get("image"),
- )
- self._add_newvm_disk(
- virtual_machine, vm_name, disk_index, disk, created_items
- )
-
- if start:
- self.conn_compute.virtual_machines.start(self.resource_group, vm_name)
- # start_result.wait()
- """
-
return virtual_machine.id, created_items
- # run_command_parameters = {
- # "command_id": "RunShellScript", # For linux, don't change it
- # "script": [
- # "date > /tmp/test.txt"
- # ]
- # }
except Exception as e:
# Rollback vm creacion
vm_id = None
def _get_azure_availability_zones(self):
return self.AZURE_ZONES
- def _add_newvm_disk(
- self, virtual_machine, vm_name, disk_index, disk, created_items={}
- ):
- disk_name = None
- data_disk = None
-
- # Check if must create empty disk or from image
- if disk.get("vim_id"):
- # disk already exists, just get
- parsed_id = azure_tools.parse_resource_id(disk.get("vim_id"))
- disk_name = parsed_id.get("name")
- data_disk = self.conn_compute.disks.get(self.resource_group, disk_name)
- else:
- disk_name = vm_name + "_DataDisk_" + str(disk_index)
- if not disk.get("image_id"):
- self.logger.debug("create new data disk name: %s", disk_name)
- async_disk_creation = self.conn_compute.disks.begin_create_or_update(
- self.resource_group,
- disk_name,
- {
- "location": self.region,
- "disk_size_gb": disk.get("size"),
- "creation_data": {"create_option": DiskCreateOption.empty},
- },
- )
- data_disk = async_disk_creation.result()
- created_items[data_disk.id] = True
- else:
- image_id = disk.get("image_id")
-
- if azure_tools.is_valid_resource_id(image_id):
- parsed_id = azure_tools.parse_resource_id(image_id)
-
- # Check if image is snapshot or disk
- image_name = parsed_id.get("name")
- type = parsed_id.get("resource_type")
-
- if type == "snapshots" or type == "disks":
- self.logger.debug("create disk from copy name: %s", image_name)
- # ¿Should check that snapshot exists?
- async_disk_creation = (
- self.conn_compute.disks.begin_create_or_update(
- self.resource_group,
- disk_name,
- {
- "location": self.region,
- "creation_data": {
- "create_option": "Copy",
- "source_uri": image_id,
- },
- },
- )
- )
- data_disk = async_disk_creation.result()
- created_items[data_disk.id] = True
- else:
- raise vimconn.VimConnNotFoundException(
- "Invalid image_id: %s ", image_id
- )
- else:
- raise vimconn.VimConnNotFoundException(
- "Invalid image_id: %s ", image_id
- )
-
- # Attach the disk created
- virtual_machine.storage_profile.data_disks.append(
- {
- "lun": disk_index,
- "name": disk_name,
- "create_option": DiskCreateOption.attach,
- "managed_disk": {"id": data_disk.id},
- "disk_size_gb": disk.get("size"),
- }
- )
- self.logger.debug("attach disk name: %s", disk_name)
- self.conn_compute.virtual_machines.begin_create_or_update(
- self.resource_group, virtual_machine.name, virtual_machine
- )
-
- # It is necesary extract from image_id data to create the VM with this format
- # "image_reference": {
- # "publisher": vm_reference["publisher"],
- # "offer": vm_reference["offer"],
- # "sku": vm_reference["sku"],
- # "version": vm_reference["version"]
- # },
def _get_image_reference(self, image_id):
try:
# The data input format example:
log_level=None,
config=config,
)
-
- """
- logger.debug("List images")
- image = azure.get_image_list({"name": "Canonical:UbuntuServer:18.04-LTS:18.04.201809110"})
- logger.debug("image: {}".format(image))
-
- logger.debug("List networks")
- network_list = azure.get_network_list({"name": "internal"})
- logger.debug("Network_list: {}".format(network_list))
-
- logger.debug("List flavors")
- flavors = azure.get_flavor_id_from_data({"vcpus": 2})
- logger.debug("flavors: {}".format(flavors))
- """
-
- """
- # Create network and test machine
- #new_network_id, _ = azure.new_network("testnet1", "data")
- new_network_id = ("/subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/resourceGroups/{}/providers")
- "/Microsoft.Network/virtualNetworks/osm_vnet/subnets/testnet1"
- ).format(test_params["resource_group"])
- logger.debug("new_network_id: {}".format(new_network_id))
-
- logger.debug("Delete network")
- new_network_id = azure.delete_network(new_network_id)
- logger.debug("deleted network_id: {}".format(new_network_id))
- """
-
- """
- logger.debug("List networks")
- network_list = azure.get_network_list({"name": "internal"})
- logger.debug("Network_list: {}".format(network_list))
-
- logger.debug("Show machine isabelvm")
- vmachine = azure.get_vminstance( ("/subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/resourceGroups/{}"
- "/providers/Microsoft.Compute/virtualMachines/isabelVM"
- ).format(test_params["resource_group"])
- )
- logger.debug("Vmachine: {}".format(vmachine))
- """
-
- """
- logger.debug("List images")
- image = azure.get_image_list({"name": "Canonical:UbuntuServer:16.04"})
- # image = azure.get_image_list({"name": "Canonical:UbuntuServer:18.04-LTS"})
- logger.debug("image: {}".format(image))
- """
-
- """
- # Create network and test machine
- new_network_id, _ = azure.new_network("testnet1", "data")
- image_id = ("/Subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/Providers/Microsoft.Compute"
- "/Locations/northeurope/Publishers/Canonical/ArtifactTypes/VMImage/Offers/UbuntuServer"
- "/Skus/18.04-LTS/Versions/18.04.201809110")
- """
- """
-
- network_id = ("subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/resourceGroups/{}
- "/providers/Microsoft.Network/virtualNetworks/osm_vnet/subnets/internal"
- ).format(test_params["resource_group"])
- """
-
- """
- logger.debug("Create machine")
- image_id = ("/Subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/Providers/Microsoft.Compute/Locations"
- "/northeurope/Publishers/Canonical/ArtifactTypes/VMImage/Offers/UbuntuServer/Skus/18.04-LTS"
- "/Versions/18.04.202103151")
- cloud_config = {"user-data": (
- "#cloud-config\n"
- "password: osm4u\n"
- "chpasswd: { expire: False }\n"
- "ssh_pwauth: True\n\n"
- "write_files:\n"
- "- content: |\n"
- " # My new helloworld file\n\n"
- " owner: root:root\n"
- " permissions: '0644'\n"
- " path: /root/helloworld.txt",
- "key-pairs": [
- ("ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC/p7fuw/W0+6uhx9XNPY4dN/K2cXZweDfjJN8W/sQ1AhKvn"
- "j0MF+dbBdsd2tfq6XUhx5LiKoGTunRpRonOw249ivH7pSyNN7FYpdLaij7Krn3K+QRNEOahMI4eoqdglVftA3"
- "vlw4Oe/aZOU9BXPdRLxfr9hRKzg5zkK91/LBkEViAijpCwK6ODPZLDDUwY4iihYK9R5eZ3fmM4+3k3Jd0hPRk"
- "B5YbtDQOu8ASWRZ9iTAWqr1OwQmvNc6ohSVg1tbq3wSxj/5bbz0J24A7TTpY0giWctne8Qkl/F2e0ZSErvbBB"
- "GXKxfnq7sc23OK1hPxMAuS+ufzyXsnL1+fB4t2iF azureuser@osm-test-client\n"
- )]
- }
- network_id = ("subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/resourceGroups/{}/providers"
- "/Microsoft.Network/virtualNetworks/osm_vnet/subnets/internal"
- ).format(test_params["resource_group"])
- vm = azure.new_vminstance(name="isabelvm",
- description="testvm",
- start=True,
- image_id=image_id,
- flavor_id="Standard_B1ls",
- net_list = [{"net_id": network_id, "name": "internal", "use": "mgmt", "floating_ip":True}],
- cloud_config = cloud_config)
- logger.debug("vm: {}".format(vm))
- """
-
- """
- # Delete nonexistent vm
- try:
- logger.debug("Delete machine")
- vm_id = ("/subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/resourceGroups/{}/providers/Microsoft.Compute/"
- "virtualMachines/isabelvm"
- ).format(test_params["resource_group"])
- created_items = {
- ("/subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/resourceGroups/{}/providers/Microsoft.Network"
- "/networkInterfaces/isabelvm-nic-0"
- ).format(test_params["resource_group"]): True,
- ("/subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/resourceGroups/{}/providers/Microsoft.Network"
- "/publicIPAddresses/isabelvm-nic-0-public-ip"
- ).format(test_params["resource_group"]): True
- }
- azure.delete_vminstance(vm_id, created_items)
- except vimconn.VimConnNotFoundException as e:
- print("Ok: excepcion no encontrada")
- """
-
- """
- network_id = ("/subscriptions/5c1a2458-dfde-4adf-a4e3-08fa0e21d171/resourceGroups/{}/providers/Microsoft.Network"
- "/virtualNetworks/osm_vnet/subnets/hfcloudinit-internal-1"
- ).format(test_params["resource_group"])
- azure.delete_network(network_id)
- """
from random import choice as random_choice
import time
-from cryptography.hazmat.backends import default_backend as crypto_default_backend
-from cryptography.hazmat.primitives import serialization as crypto_serialization
-from cryptography.hazmat.primitives.asymmetric import rsa
from google.oauth2 import service_account
import googleapiclient.discovery
from osm_ro_plugin import vimconn
except Exception as e:
self._format_vimconn_exception(e)
- def delete_inuse_nic(self, nic_name):
- raise vimconn.VimConnNotImplemented("Not necessary")
-
def delete_image(self, image_id):
raise vimconn.VimConnNotImplemented("Not implemented")
# either password of ssh-keys are required
# we will always use ssh-keys, in case it is not available we will generate it
- """
- if cloud_config and cloud_config.get("key-pairs"):
- key_data = ""
- key_pairs = {}
- if cloud_config.get("key-pairs"):
- if isinstance(cloud_config["key-pairs"], list):
- # Transform the format "<key> <user@host>" into "<user>:<key>"
- key_data = ""
- for key in cloud_config.get("key-pairs"):
- key_data = key_data + key + "\n"
- key_pairs = {
- "key": "ssh-keys",
- "value": key_data
- }
- else:
- # If there is no ssh key in cloud config, a new key is generated:
- _, key_data = self._generate_keys()
- key_pairs = {
- "key": "ssh-keys",
- "value": "" + key_data
- }
- self.logger.debug("generated keys: %s", key_data)
-
- metadata["items"].append(key_pairs)
- """
self.logger.debug("metadata: %s", metadata)
return metadata
- def _generate_keys(self):
- """Method used to generate a pair of private/public keys.
- This method is used because to create a vm in Azure we always need a key or a password
- In some cases we may have a password in a cloud-init file but it may not be available
- """
- key = rsa.generate_private_key(
- backend=crypto_default_backend(), public_exponent=65537, key_size=2048
- )
- private_key = key.private_bytes(
- crypto_serialization.Encoding.PEM,
- crypto_serialization.PrivateFormat.PKCS8,
- crypto_serialization.NoEncryption(),
- )
- public_key = key.public_key().public_bytes(
- crypto_serialization.Encoding.OpenSSH,
- crypto_serialization.PublicFormat.OpenSSH,
- )
- private_key = private_key.decode("utf8")
- # Change first line because Paramiko needs a explicit start with 'BEGIN RSA PRIVATE KEY'
- i = private_key.find("\n")
- private_key = "-----BEGIN RSA PRIVATE KEY-----" + private_key[i:]
- public_key = public_key.decode("utf8")
-
- return private_key, public_key
-
- def _get_unused_vm_name(self, vm_name):
- """
- Checks the vm name and in case it is used adds a suffix to the name to allow creation
- :return:
- """
- all_vms = (
- self.conn_compute.instances()
- .list(project=self.project, zone=self.zone)
- .execute()
- )
- # Filter to vms starting with the indicated name
- vms = list(filter(lambda vm: (vm.name.startswith(vm_name)), all_vms))
- vm_names = [str(vm.name) for vm in vms]
-
- # get the name with the first not used suffix
- name_suffix = 0
- # name = subnet_name + "-" + str(name_suffix)
- name = vm_name # first subnet created will have no prefix
-
- while name in vm_names:
- name_suffix += 1
- name = vm_name + "-" + str(name_suffix)
-
- return name
-
def get_vminstance(self, vm_id):
"""
Obtaing the vm instance data from v_id
else:
self._format_vimconn_exception(e)
- def _get_net_name_from_resource_id(self, resource_id):
- try:
- net_name = str(resource_id.split("/")[-1])
-
- return net_name
- except Exception:
- raise vimconn.VimConnException(
- "Unable to get google cloud net_name from invalid resource_id format '{}'".format(
- resource_id
- )
- )
-
def _get_resource_name_from_resource_id(self, resource_id):
"""
Obtains resource_name from the google cloud complete identifier: resource_name will always be last item
)
self._format_vimconn_exception(e)
- def _get_default_admin_user(self, image_id):
- if "ubuntu" in image_id.lower():
- return "ubuntu"
- else:
- return self._default_admin_user
-
def _create_firewall_rules(self, network):
"""
Creates the necessary firewall rules to allow the traffic in the network
This module contains unit tests for the OpenStack VIM connector
Run this directly with python2 or python3.
"""
-import copy
from copy import deepcopy
import logging
import unittest
-import mock
from mock import MagicMock, patch
-from neutronclient.v2_0.client import Client
from novaclient import exceptions as nvExceptions
from novaclient.exceptions import ClientException, Conflict
-from osm_ro_plugin import vimconn
from osm_ro_plugin.vimconn import (
VimConnConnectionException,
VimConnException,
}
-class TestSfcOperations(unittest.TestCase):
- @mock.patch("logging.getLogger", autospec=True)
- def setUp(self, mock_logger):
- # Instantiate dummy VIM connector so we can test it
- # It throws exception because of dummy parameters,
- # We are disabling the logging of exception not to print them to console.
- mock_logger = logging.getLogger()
- mock_logger.disabled = True
- self.vimconn = vimconnector(
- "123",
- "openstackvim",
- "456",
- "789",
- "http://dummy.url",
- None,
- "user",
- "pass",
- )
-
- def _test_new_sfi(
- self,
- create_sfc_port_pair,
- sfc_encap,
- ingress_ports=["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
- egress_ports=["230cdf1b-de37-4891-bc07-f9010cf1f967"],
- ):
- # input to VIM connector
- name = "osm_sfi"
- # + ingress_ports
- # + egress_ports
- # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
- correlation = "nsh"
- if sfc_encap is not None:
- if not sfc_encap:
- correlation = None
-
- # what OpenStack is assumed to respond (patch OpenStack"s return value)
- dict_from_neutron = {
- "port_pair": {
- "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
- "name": name,
- "description": "",
- "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
- "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
- "ingress": ingress_ports[0] if len(ingress_ports) else None,
- "egress": egress_ports[0] if len(egress_ports) else None,
- "service_function_parameters": {"correlation": correlation},
- }
- }
- create_sfc_port_pair.return_value = dict_from_neutron
-
- # what the VIM connector is expected to
- # send to OpenStack based on the input
- dict_to_neutron = {
- "port_pair": {
- "name": name,
- "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "egress": "230cdf1b-de37-4891-bc07-f9010cf1f967",
- "service_function_parameters": {"correlation": correlation},
- }
- }
-
- # call the VIM connector
- if sfc_encap is None:
- result = self.vimconn.new_sfi(name, ingress_ports, egress_ports)
- else:
- result = self.vimconn.new_sfi(name, ingress_ports, egress_ports, sfc_encap)
-
- # assert that the VIM connector made the expected call to OpenStack
- create_sfc_port_pair.assert_called_with(dict_to_neutron)
- # assert that the VIM connector had the expected result / return value
- self.assertEqual(result, dict_from_neutron["port_pair"]["id"])
-
- def _test_new_sf(self, create_sfc_port_pair_group):
- # input to VIM connector
- name = "osm_sf"
- instances = [
- "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
- "12ba215e-3987-4892-bd3a-d0fd91eecf98",
- "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
- ]
-
- # what OpenStack is assumed to respond (patch OpenStack"s return value)
- dict_from_neutron = {
- "port_pair_group": {
- "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
- "name": name,
- "description": "",
- "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
- "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
- "port_pairs": instances,
- "group_id": 1,
- "port_pair_group_parameters": {
- "lb_fields": [],
- "ppg_n_tuple_mapping": {
- "ingress_n_tuple": {},
- "egress_n_tuple": {},
- },
- },
- }
- }
- create_sfc_port_pair_group.return_value = dict_from_neutron
-
- # what the VIM connector is expected to
- # send to OpenStack based on the input
- dict_to_neutron = {
- "port_pair_group": {
- "name": name,
- "port_pairs": [
- "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
- "12ba215e-3987-4892-bd3a-d0fd91eecf98",
- "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
- ],
- }
- }
-
- # call the VIM connector
- result = self.vimconn.new_sf(name, instances)
-
- # assert that the VIM connector made the expected call to OpenStack
- create_sfc_port_pair_group.assert_called_with(dict_to_neutron)
- # assert that the VIM connector had the expected result / return value
- self.assertEqual(result, dict_from_neutron["port_pair_group"]["id"])
-
- def _test_new_sfp(self, create_sfc_port_chain, sfc_encap, spi):
- # input to VIM connector
- name = "osm_sfp"
- classifications = [
- "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
- "00f23389-bdfa-43c2-8b16-5815f2582fa8",
- ]
- sfs = [
- "2314daec-c262-414a-86e3-69bb6fa5bc16",
- "d8bfdb5d-195e-4f34-81aa-6135705317df",
- ]
-
- # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
- correlation = "nsh"
- chain_id = 33
- if spi:
- chain_id = spi
-
- # what OpenStack is assumed to respond (patch OpenStack"s return value)
- dict_from_neutron = {
- "port_chain": {
- "id": "5bc05721-079b-4b6e-a235-47cac331cbb6",
- "name": name,
- "description": "",
- "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
- "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
- "chain_id": chain_id,
- "flow_classifiers": classifications,
- "port_pair_groups": sfs,
- "chain_parameters": {"correlation": correlation},
- }
- }
- create_sfc_port_chain.return_value = dict_from_neutron
-
- # what the VIM connector is expected to
- # send to OpenStack based on the input
- dict_to_neutron = {
- "port_chain": {
- "name": name,
- "flow_classifiers": [
- "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
- "00f23389-bdfa-43c2-8b16-5815f2582fa8",
- ],
- "port_pair_groups": [
- "2314daec-c262-414a-86e3-69bb6fa5bc16",
- "d8bfdb5d-195e-4f34-81aa-6135705317df",
- ],
- "chain_parameters": {"correlation": correlation},
- }
- }
- if spi:
- dict_to_neutron["port_chain"]["chain_id"] = spi
-
- # call the VIM connector
- if sfc_encap is None:
- dict_to_neutron["port_chain"]["chain_parameters"] = {"correlation": "mpls"}
- if spi is None:
- result = self.vimconn.new_sfp(
- name, classifications, sfs, sfc_encap=False
- )
- else:
- result = self.vimconn.new_sfp(
- name, classifications, sfs, sfc_encap=False, spi=spi
- )
- else:
- if spi is None:
- result = self.vimconn.new_sfp(name, classifications, sfs, sfc_encap)
- else:
- result = self.vimconn.new_sfp(
- name, classifications, sfs, sfc_encap, spi
- )
-
- # assert that the VIM connector made the expected call to OpenStack
- create_sfc_port_chain.assert_called_with(dict_to_neutron)
- # assert that the VIM connector had the expected result / return value
- self.assertEqual(result, dict_from_neutron["port_chain"]["id"])
-
- def _test_new_classification(self, create_sfc_flow_classifier, ctype):
- # input to VIM connector
- name = "osm_classification"
- definition = {
- "ethertype": "IPv4",
- "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
- "protocol": "tcp",
- "source_ip_prefix": "192.168.2.0/24",
- "source_port_range_max": 99,
- "source_port_range_min": 50,
- }
-
- # what OpenStack is assumed to respond (patch OpenStack"s return value)
- dict_from_neutron = {"flow_classifier": copy.copy(definition)}
- dict_from_neutron["flow_classifier"][
- "id"
- ] = "7735ec2c-fddf-4130-9712-32ed2ab6a372"
- dict_from_neutron["flow_classifier"]["name"] = name
- dict_from_neutron["flow_classifier"]["description"] = ""
- dict_from_neutron["flow_classifier"][
- "tenant_id"
- ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
- dict_from_neutron["flow_classifier"][
- "project_id"
- ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
- create_sfc_flow_classifier.return_value = dict_from_neutron
-
- # what the VIM connector is expected to
- # send to OpenStack based on the input
- dict_to_neutron = {"flow_classifier": copy.copy(definition)}
- dict_to_neutron["flow_classifier"]["name"] = "osm_classification"
-
- # call the VIM connector
- result = self.vimconn.new_classification(name, ctype, definition)
-
- # assert that the VIM connector made the expected call to OpenStack
- create_sfc_flow_classifier.assert_called_with(dict_to_neutron)
- # assert that the VIM connector had the expected result / return value
- self.assertEqual(result, dict_from_neutron["flow_classifier"]["id"])
-
- @mock.patch.object(Client, "create_sfc_flow_classifier")
- def test_new_classification(self, create_sfc_flow_classifier):
- self._test_new_classification(
- create_sfc_flow_classifier, "legacy_flow_classifier"
- )
-
- @mock.patch.object(Client, "create_sfc_flow_classifier")
- def test_new_classification_unsupported_type(self, create_sfc_flow_classifier):
- self.assertRaises(
- vimconn.VimConnNotSupportedException,
- self._test_new_classification,
- create_sfc_flow_classifier,
- "h265",
- )
-
- @mock.patch.object(Client, "create_sfc_port_pair")
- def test_new_sfi_with_sfc_encap(self, create_sfc_port_pair):
- self._test_new_sfi(create_sfc_port_pair, True)
-
- @mock.patch.object(Client, "create_sfc_port_pair")
- def test_new_sfi_without_sfc_encap(self, create_sfc_port_pair):
- self._test_new_sfi(create_sfc_port_pair, False)
-
- @mock.patch.object(Client, "create_sfc_port_pair")
- def test_new_sfi_default_sfc_encap(self, create_sfc_port_pair):
- self._test_new_sfi(create_sfc_port_pair, None)
-
- @mock.patch.object(Client, "create_sfc_port_pair")
- def test_new_sfi_bad_ingress_ports(self, create_sfc_port_pair):
- ingress_ports = [
- "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "a0273f64-82c9-11e7-b08f-6328e53f0fa7",
- ]
- self.assertRaises(
- vimconn.VimConnNotSupportedException,
- self._test_new_sfi,
- create_sfc_port_pair,
- True,
- ingress_ports=ingress_ports,
- )
- ingress_ports = []
- self.assertRaises(
- vimconn.VimConnNotSupportedException,
- self._test_new_sfi,
- create_sfc_port_pair,
- True,
- ingress_ports=ingress_ports,
- )
-
- @mock.patch.object(Client, "create_sfc_port_pair")
- def test_new_sfi_bad_egress_ports(self, create_sfc_port_pair):
- egress_ports = [
- "230cdf1b-de37-4891-bc07-f9010cf1f967",
- "b41228fe-82c9-11e7-9b44-17504174320b",
- ]
- self.assertRaises(
- vimconn.VimConnNotSupportedException,
- self._test_new_sfi,
- create_sfc_port_pair,
- True,
- egress_ports=egress_ports,
- )
- egress_ports = []
- self.assertRaises(
- vimconn.VimConnNotSupportedException,
- self._test_new_sfi,
- create_sfc_port_pair,
- True,
- egress_ports=egress_ports,
- )
-
- @mock.patch.object(vimconnector, "get_sfi")
- @mock.patch.object(Client, "create_sfc_port_pair_group")
- def test_new_sf(self, create_sfc_port_pair_group, get_sfi):
- get_sfi.return_value = {"sfc_encap": True}
- self._test_new_sf(create_sfc_port_pair_group)
-
- @mock.patch.object(vimconnector, "get_sfi")
- @mock.patch.object(Client, "create_sfc_port_pair_group")
- def test_new_sf_inconsistent_sfc_encap(self, create_sfc_port_pair_group, get_sfi):
- get_sfi.return_value = {"sfc_encap": "nsh"}
- self.assertRaises(
- vimconn.VimConnNotSupportedException,
- self._test_new_sf,
- create_sfc_port_pair_group,
- )
-
- @mock.patch.object(Client, "create_sfc_port_chain")
- def test_new_sfp_with_sfc_encap(self, create_sfc_port_chain):
- self._test_new_sfp(create_sfc_port_chain, True, None)
-
- @mock.patch.object(Client, "create_sfc_port_chain")
- def test_new_sfp_without_sfc_encap(self, create_sfc_port_chain):
- self._test_new_sfp(create_sfc_port_chain, None, None)
- self._test_new_sfp(create_sfc_port_chain, None, 25)
-
- @mock.patch.object(Client, "create_sfc_port_chain")
- def test_new_sfp_default_sfc_encap(self, create_sfc_port_chain):
- self._test_new_sfp(create_sfc_port_chain, None, None)
-
- @mock.patch.object(Client, "create_sfc_port_chain")
- def test_new_sfp_with_sfc_encap_spi(self, create_sfc_port_chain):
- self._test_new_sfp(create_sfc_port_chain, True, 25)
-
- @mock.patch.object(Client, "create_sfc_port_chain")
- def test_new_sfp_default_sfc_encap_spi(self, create_sfc_port_chain):
- self._test_new_sfp(create_sfc_port_chain, None, 25)
-
- @mock.patch.object(Client, "list_sfc_flow_classifiers")
- def test_get_classification_list(self, list_sfc_flow_classifiers):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_flow_classifiers.return_value = {
- "flow_classifiers": [
- {
- "source_port_range_min": 2000,
- "destination_ip_prefix": "192.168.3.0/24",
- "protocol": "udp",
- "description": "",
- "ethertype": "IPv4",
- "l7_parameters": {},
- "source_port_range_max": 2000,
- "destination_port_range_min": 3000,
- "source_ip_prefix": "192.168.2.0/24",
- "logical_destination_port": None,
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "destination_port_range_max": None,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
- "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
- "name": "fc1",
- }
- ]
- }
-
- # call the VIM connector
- filter_dict = {"protocol": "tcp", "ethertype": "IPv4"}
- result = self.vimconn.get_classification_list(filter_dict.copy())
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_flow_classifiers.assert_called_with(**filter_dict)
- # assert that the VIM connector successfully
- # translated and returned the OpenStack result
- self.assertEqual(
- result,
- [
- {
- "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
- "name": "fc1",
- "description": "",
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "ctype": "legacy_flow_classifier",
- "definition": {
- "source_port_range_min": 2000,
- "destination_ip_prefix": "192.168.3.0/24",
- "protocol": "udp",
- "ethertype": "IPv4",
- "l7_parameters": {},
- "source_port_range_max": 2000,
- "destination_port_range_min": 3000,
- "source_ip_prefix": "192.168.2.0/24",
- "logical_destination_port": None,
- "destination_port_range_max": None,
- "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
- },
- }
- ],
- )
-
- def _test_get_sfi_list(self, list_port_pair, correlation, sfc_encap):
- # what OpenStack is assumed to return to the VIM connector
- list_port_pair.return_value = {
- "port_pairs": [
- {
- "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "service_function_parameters": {"correlation": correlation},
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
- "name": "osm_sfi",
- }
- ]
- }
-
- # call the VIM connector
- filter_dict = {"name": "osm_sfi", "description": ""}
- result = self.vimconn.get_sfi_list(filter_dict.copy())
-
- # assert that VIM connector called OpenStack with the expected filter
- list_port_pair.assert_called_with(**filter_dict)
- # assert that the VIM connector successfully
- # translated and returned the OpenStack result
- self.assertEqual(
- result,
- [
- {
- "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
- "sfc_encap": sfc_encap,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
- "name": "osm_sfi",
- }
- ],
- )
-
- @mock.patch.object(Client, "list_sfc_port_pairs")
- def test_get_sfi_list_with_sfc_encap(self, list_sfc_port_pairs):
- self._test_get_sfi_list(list_sfc_port_pairs, "nsh", True)
-
- @mock.patch.object(Client, "list_sfc_port_pairs")
- def test_get_sfi_list_without_sfc_encap(self, list_sfc_port_pairs):
- self._test_get_sfi_list(list_sfc_port_pairs, None, False)
-
- @mock.patch.object(Client, "list_sfc_port_pair_groups")
- def test_get_sf_list(self, list_sfc_port_pair_groups):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_pair_groups.return_value = {
- "port_pair_groups": [
- {
- "port_pairs": [
- "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
- "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
- ],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "port_pair_group_parameters": {},
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
- "name": "osm_sf",
- }
- ]
- }
-
- # call the VIM connector
- filter_dict = {"name": "osm_sf", "description": ""}
- result = self.vimconn.get_sf_list(filter_dict.copy())
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_pair_groups.assert_called_with(**filter_dict)
- # assert that the VIM connector successfully
- # translated and returned the OpenStack result
- self.assertEqual(
- result,
- [
- {
- "sfis": [
- "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
- "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
- ],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
- "name": "osm_sf",
- }
- ],
- )
-
- def _test_get_sfp_list(self, list_sfc_port_chains, correlation, sfc_encap):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_chains.return_value = {
- "port_chains": [
- {
- "port_pair_groups": [
- "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
- "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
- ],
- "flow_classifiers": [
- "1333c2f4-82d7-11e7-a5df-9327f33d104e",
- "1387ab44-82d7-11e7-9bb0-476337183905",
- ],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "chain_parameters": {"correlation": correlation},
- "chain_id": 40,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
- "name": "osm_sfp",
- }
- ]
- }
-
- # call the VIM connector
- filter_dict = {"name": "osm_sfp", "description": ""}
- result = self.vimconn.get_sfp_list(filter_dict.copy())
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_chains.assert_called_with(**filter_dict)
- # assert that the VIM connector successfully
- # translated and returned the OpenStack result
- self.assertEqual(
- result,
- [
- {
- "service_functions": [
- "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
- "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
- ],
- "classifications": [
- "1333c2f4-82d7-11e7-a5df-9327f33d104e",
- "1387ab44-82d7-11e7-9bb0-476337183905",
- ],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "sfc_encap": sfc_encap,
- "spi": 40,
- "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
- "name": "osm_sfp",
- }
- ],
- )
-
- @mock.patch.object(Client, "list_sfc_port_chains")
- def test_get_sfp_list_with_sfc_encap(self, list_sfc_port_chains):
- self._test_get_sfp_list(list_sfc_port_chains, "nsh", True)
-
- @mock.patch.object(Client, "list_sfc_port_chains")
- def test_get_sfp_list_without_sfc_encap(self, list_sfc_port_chains):
- self._test_get_sfp_list(list_sfc_port_chains, None, False)
-
- @mock.patch.object(Client, "list_sfc_flow_classifiers")
- def test_get_classification(self, list_sfc_flow_classifiers):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_flow_classifiers.return_value = {
- "flow_classifiers": [
- {
- "source_port_range_min": 2000,
- "destination_ip_prefix": "192.168.3.0/24",
- "protocol": "udp",
- "description": "",
- "ethertype": "IPv4",
- "l7_parameters": {},
- "source_port_range_max": 2000,
- "destination_port_range_min": 3000,
- "source_ip_prefix": "192.168.2.0/24",
- "logical_destination_port": None,
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "destination_port_range_max": None,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
- "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
- "name": "fc1",
- }
- ]
- }
-
- # call the VIM connector
- result = self.vimconn.get_classification("22198366-d4e8-4d6b-b4d2-637d5d6cbb7d")
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_flow_classifiers.assert_called_with(
- id="22198366-d4e8-4d6b-b4d2-637d5d6cbb7d"
- )
- # assert that VIM connector successfully returned the OpenStack result
- self.assertEqual(
- result,
- {
- "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
- "name": "fc1",
- "description": "",
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "ctype": "legacy_flow_classifier",
- "definition": {
- "source_port_range_min": 2000,
- "destination_ip_prefix": "192.168.3.0/24",
- "protocol": "udp",
- "ethertype": "IPv4",
- "l7_parameters": {},
- "source_port_range_max": 2000,
- "destination_port_range_min": 3000,
- "source_ip_prefix": "192.168.2.0/24",
- "logical_destination_port": None,
- "destination_port_range_max": None,
- "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
- },
- },
- )
-
- @mock.patch.object(Client, "list_sfc_flow_classifiers")
- def test_get_classification_many_results(self, list_sfc_flow_classifiers):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_flow_classifiers.return_value = {
- "flow_classifiers": [
- {
- "source_port_range_min": 2000,
- "destination_ip_prefix": "192.168.3.0/24",
- "protocol": "udp",
- "description": "",
- "ethertype": "IPv4",
- "l7_parameters": {},
- "source_port_range_max": 2000,
- "destination_port_range_min": 3000,
- "source_ip_prefix": "192.168.2.0/24",
- "logical_destination_port": None,
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "destination_port_range_max": None,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
- "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
- "name": "fc1",
- },
- {
- "source_port_range_min": 1000,
- "destination_ip_prefix": "192.168.3.0/24",
- "protocol": "udp",
- "description": "",
- "ethertype": "IPv4",
- "l7_parameters": {},
- "source_port_range_max": 1000,
- "destination_port_range_min": 3000,
- "source_ip_prefix": "192.168.2.0/24",
- "logical_destination_port": None,
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "destination_port_range_max": None,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
- "id": "3196bafc-82dd-11e7-a205-9bf6c14b0721",
- "name": "fc2",
- },
- ]
- }
-
- # call the VIM connector
- self.assertRaises(
- vimconn.VimConnConflictException,
- self.vimconn.get_classification,
- "3196bafc-82dd-11e7-a205-9bf6c14b0721",
- )
-
- # assert the VIM connector called OpenStack with the expected filter
- list_sfc_flow_classifiers.assert_called_with(
- id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
- )
-
- @mock.patch.object(Client, "list_sfc_flow_classifiers")
- def test_get_classification_no_results(self, list_sfc_flow_classifiers):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_flow_classifiers.return_value = {"flow_classifiers": []}
-
- # call the VIM connector
- self.assertRaises(
- vimconn.VimConnNotFoundException,
- self.vimconn.get_classification,
- "3196bafc-82dd-11e7-a205-9bf6c14b0721",
- )
-
- # assert the VIM connector called OpenStack with the expected filter
- list_sfc_flow_classifiers.assert_called_with(
- id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
- )
-
- @mock.patch.object(Client, "list_sfc_port_pairs")
- def test_get_sfi(self, list_sfc_port_pairs):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_pairs.return_value = {
- "port_pairs": [
- {
- "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "service_function_parameters": {"correlation": "nsh"},
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
- "name": "osm_sfi1",
- },
- ]
- }
-
- # call the VIM connector
- result = self.vimconn.get_sfi("c121ebdd-7f2d-4213-b933-3325298a6966")
-
- # assert the VIM connector called OpenStack with the expected filter
- list_sfc_port_pairs.assert_called_with(
- id="c121ebdd-7f2d-4213-b933-3325298a6966"
- )
- # assert the VIM connector successfully returned the OpenStack result
- self.assertEqual(
- result,
- {
- "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
- "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
- "sfc_encap": True,
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
- "name": "osm_sfi1",
- },
- )
-
- @mock.patch.object(Client, "list_sfc_port_pairs")
- def test_get_sfi_many_results(self, list_sfc_port_pairs):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_pairs.return_value = {
- "port_pairs": [
- {
- "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "service_function_parameters": {"correlation": "nsh"},
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
- "name": "osm_sfi1",
- },
- {
- "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
- "service_function_parameters": {"correlation": "nsh"},
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "c0436d92-82db-11e7-8f9c-5fa535f1261f",
- "name": "osm_sfi2",
- },
- ]
- }
-
- # call the VIM connector
- self.assertRaises(
- vimconn.VimConnConflictException,
- self.vimconn.get_sfi,
- "c0436d92-82db-11e7-8f9c-5fa535f1261f",
- )
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_pairs.assert_called_with(
- id="c0436d92-82db-11e7-8f9c-5fa535f1261f"
- )
-
- @mock.patch.object(Client, "list_sfc_port_pairs")
- def test_get_sfi_no_results(self, list_sfc_port_pairs):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_pairs.return_value = {"port_pairs": []}
-
- # call the VIM connector
- self.assertRaises(
- vimconn.VimConnNotFoundException,
- self.vimconn.get_sfi,
- "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
- )
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_pairs.assert_called_with(
- id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
- )
-
- @mock.patch.object(Client, "list_sfc_port_pair_groups")
- def test_get_sf(self, list_sfc_port_pair_groups):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_pair_groups.return_value = {
- "port_pair_groups": [
- {
- "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "port_pair_group_parameters": {},
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
- "name": "osm_sf1",
- }
- ]
- }
-
- # call the VIM connector
- result = self.vimconn.get_sf("b22892fc-82d9-11e7-ae85-0fea6a3b3757")
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_pair_groups.assert_called_with(
- id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
- )
- # assert that VIM connector successfully returned the OpenStack result
- self.assertEqual(
- result,
- {
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "sfis": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
- "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
- "name": "osm_sf1",
- },
- )
-
- @mock.patch.object(Client, "list_sfc_port_pair_groups")
- def test_get_sf_many_results(self, list_sfc_port_pair_groups):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_pair_groups.return_value = {
- "port_pair_groups": [
- {
- "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "port_pair_group_parameters": {},
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
- "name": "osm_sf1",
- },
- {
- "port_pairs": ["0d63799c-82d6-11e7-8deb-a746bb3ae9f5"],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "port_pair_group_parameters": {},
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
- "name": "osm_sf2",
- },
- ]
- }
-
- # call the VIM connector
- self.assertRaises(
- vimconn.VimConnConflictException,
- self.vimconn.get_sf,
- "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
- )
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_pair_groups.assert_called_with(
- id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
- )
-
- @mock.patch.object(Client, "list_sfc_port_pair_groups")
- def test_get_sf_no_results(self, list_sfc_port_pair_groups):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_pair_groups.return_value = {"port_pair_groups": []}
-
- # call the VIM connector
- self.assertRaises(
- vimconn.VimConnNotFoundException,
- self.vimconn.get_sf,
- "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
- )
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_pair_groups.assert_called_with(
- id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
- )
-
- @mock.patch.object(Client, "list_sfc_port_chains")
- def test_get_sfp(self, list_sfc_port_chains):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_chains.return_value = {
- "port_chains": [
- {
- "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
- "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "chain_parameters": {"correlation": "nsh"},
- "chain_id": 40,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
- "name": "osm_sfp1",
- }
- ]
- }
-
- # call the VIM connector
- result = self.vimconn.get_sfp("821bc9be-82d7-11e7-8ce3-23a08a27ab47")
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_chains.assert_called_with(
- id="821bc9be-82d7-11e7-8ce3-23a08a27ab47"
- )
- # assert that VIM connector successfully returned the OpenStack result
- self.assertEqual(
- result,
- {
- "service_functions": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
- "classifications": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "sfc_encap": True,
- "spi": 40,
- "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
- "name": "osm_sfp1",
- },
- )
-
- @mock.patch.object(Client, "list_sfc_port_chains")
- def test_get_sfp_many_results(self, list_sfc_port_chains):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_chains.return_value = {
- "port_chains": [
- {
- "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
- "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "chain_parameters": {"correlation": "nsh"},
- "chain_id": 40,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
- "name": "osm_sfp1",
- },
- {
- "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
- "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
- "description": "",
- "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "chain_parameters": {"correlation": "nsh"},
- "chain_id": 50,
- "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
- "id": "5d002f38-82de-11e7-a770-f303f11ce66a",
- "name": "osm_sfp2",
- },
- ]
- }
-
- # call the VIM connector
- self.assertRaises(
- vimconn.VimConnConflictException,
- self.vimconn.get_sfp,
- "5d002f38-82de-11e7-a770-f303f11ce66a",
- )
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_chains.assert_called_with(
- id="5d002f38-82de-11e7-a770-f303f11ce66a"
- )
-
- @mock.patch.object(Client, "list_sfc_port_chains")
- def test_get_sfp_no_results(self, list_sfc_port_chains):
- # what OpenStack is assumed to return to the VIM connector
- list_sfc_port_chains.return_value = {"port_chains": []}
-
- # call the VIM connector
- self.assertRaises(
- vimconn.VimConnNotFoundException,
- self.vimconn.get_sfp,
- "5d002f38-82de-11e7-a770-f303f11ce66a",
- )
-
- # assert that VIM connector called OpenStack with the expected filter
- list_sfc_port_chains.assert_called_with(
- id="5d002f38-82de-11e7-a770-f303f11ce66a"
- )
-
- @mock.patch.object(Client, "delete_sfc_flow_classifier")
- def test_delete_classification(self, delete_sfc_flow_classifier):
- result = self.vimconn.delete_classification(
- "638f957c-82df-11e7-b7c8-132706021464"
- )
- delete_sfc_flow_classifier.assert_called_with(
- "638f957c-82df-11e7-b7c8-132706021464"
- )
- self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
-
- @mock.patch.object(Client, "delete_sfc_port_pair")
- def test_delete_sfi(self, delete_sfc_port_pair):
- result = self.vimconn.delete_sfi("638f957c-82df-11e7-b7c8-132706021464")
- delete_sfc_port_pair.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
- self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
-
- @mock.patch.object(Client, "delete_sfc_port_pair_group")
- def test_delete_sf(self, delete_sfc_port_pair_group):
- result = self.vimconn.delete_sf("638f957c-82df-11e7-b7c8-132706021464")
- delete_sfc_port_pair_group.assert_called_with(
- "638f957c-82df-11e7-b7c8-132706021464"
- )
- self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
-
- @mock.patch.object(Client, "delete_sfc_port_chain")
- def test_delete_sfp(self, delete_sfc_port_chain):
- result = self.vimconn.delete_sfp("638f957c-82df-11e7-b7c8-132706021464")
- delete_sfc_port_chain.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
- self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
-
-
class Status:
def __init__(self, s):
self.status = s
)
)
- def delete_user(self, user_id):
- """Delete a user from openstack VIM
- Returns the user identifier"""
- if self.debug:
- print("osconnector: Deleting a user from VIM")
-
- try:
- self._reload_connection()
- self.keystone.users.delete(user_id)
-
- return 1, user_id
- except ksExceptions.ConnectionError as e:
- error_value = -vimconn.HTTP_Bad_Request
- error_text = (
- type(e).__name__
- + ": "
- + (str(e) if len(e.args) == 0 else str(e.args[0]))
- )
- except ksExceptions.NotFound as e:
- error_value = -vimconn.HTTP_Not_Found
- error_text = (
- type(e).__name__
- + ": "
- + (str(e) if len(e.args) == 0 else str(e.args[0]))
- )
- except ksExceptions.ClientException as e: # TODO remove
- error_value = -vimconn.HTTP_Bad_Request
- error_text = (
- type(e).__name__
- + ": "
- + (str(e) if len(e.args) == 0 else str(e.args[0]))
- )
-
- # TODO insert exception vimconn.HTTP_Unauthorized
- # if reaching here is because an exception
- self.logger.debug("delete_tenant " + error_text)
-
- return error_value, error_text
-
def get_hosts_info(self):
"""Get the information of deployed hosts
Returns the hosts content"""
return error_value, error_text
- def new_classification(self, name, ctype, definition):
- self.logger.debug(
- "Adding a new (Traffic) Classification to VIM, named %s", name
- )
-
- try:
- new_class = None
- self._reload_connection()
-
- if ctype not in supportedClassificationTypes:
- raise vimconn.VimConnNotSupportedException(
- "OpenStack VIM connector does not support provided "
- "Classification Type {}, supported ones are: {}".format(
- ctype, supportedClassificationTypes
- )
- )
-
- if not self._validate_classification(ctype, definition):
- raise vimconn.VimConnException(
- "Incorrect Classification definition for the type specified."
- )
-
- classification_dict = definition
- classification_dict["name"] = name
- new_class = self.neutron.create_sfc_flow_classifier(
- {"flow_classifier": classification_dict}
- )
-
- return new_class["flow_classifier"]["id"]
- except (
- neExceptions.ConnectionFailed,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self.logger.error("Creation of Classification failed.")
- self._format_exception(e)
-
- def get_classification(self, class_id):
- self.logger.debug(" Getting Classification %s from VIM", class_id)
- filter_dict = {"id": class_id}
- class_list = self.get_classification_list(filter_dict)
-
- if len(class_list) == 0:
- raise vimconn.VimConnNotFoundException(
- "Classification '{}' not found".format(class_id)
- )
- elif len(class_list) > 1:
- raise vimconn.VimConnConflictException(
- "Found more than one Classification with this criteria"
- )
-
- classification = class_list[0]
-
- return classification
-
- def get_classification_list(self, filter_dict={}):
- self.logger.debug(
- "Getting Classifications from VIM filter: '%s'", str(filter_dict)
- )
-
- try:
- filter_dict_os = filter_dict.copy()
- self._reload_connection()
-
- if self.api_version3 and "tenant_id" in filter_dict_os:
- filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
-
- classification_dict = self.neutron.list_sfc_flow_classifiers(
- **filter_dict_os
- )
- classification_list = classification_dict["flow_classifiers"]
- self.__classification_os2mano(classification_list)
-
- return classification_list
- except (
- neExceptions.ConnectionFailed,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self._format_exception(e)
-
- def delete_classification(self, class_id):
- self.logger.debug("Deleting Classification '%s' from VIM", class_id)
-
- try:
- self._reload_connection()
- self.neutron.delete_sfc_flow_classifier(class_id)
-
- return class_id
- except (
- neExceptions.ConnectionFailed,
- neExceptions.NeutronException,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self._format_exception(e)
-
- def new_sfi(self, name, ingress_ports, egress_ports, sfc_encap=True):
- self.logger.debug(
- "Adding a new Service Function Instance to VIM, named '%s'", name
- )
-
- try:
- new_sfi = None
- self._reload_connection()
- correlation = None
-
- if sfc_encap:
- correlation = "nsh"
-
- if len(ingress_ports) != 1:
- raise vimconn.VimConnNotSupportedException(
- "OpenStack VIM connector can only have 1 ingress port per SFI"
- )
-
- if len(egress_ports) != 1:
- raise vimconn.VimConnNotSupportedException(
- "OpenStack VIM connector can only have 1 egress port per SFI"
- )
-
- sfi_dict = {
- "name": name,
- "ingress": ingress_ports[0],
- "egress": egress_ports[0],
- "service_function_parameters": {"correlation": correlation},
- }
- new_sfi = self.neutron.create_sfc_port_pair({"port_pair": sfi_dict})
-
- return new_sfi["port_pair"]["id"]
- except (
- neExceptions.ConnectionFailed,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- if new_sfi:
- try:
- self.neutron.delete_sfc_port_pair(new_sfi["port_pair"]["id"])
- except Exception:
- self.logger.error(
- "Creation of Service Function Instance failed, with "
- "subsequent deletion failure as well."
- )
-
- self._format_exception(e)
-
- def get_sfi(self, sfi_id):
- self.logger.debug("Getting Service Function Instance %s from VIM", sfi_id)
- filter_dict = {"id": sfi_id}
- sfi_list = self.get_sfi_list(filter_dict)
-
- if len(sfi_list) == 0:
- raise vimconn.VimConnNotFoundException(
- "Service Function Instance '{}' not found".format(sfi_id)
- )
- elif len(sfi_list) > 1:
- raise vimconn.VimConnConflictException(
- "Found more than one Service Function Instance with this criteria"
- )
-
- sfi = sfi_list[0]
-
- return sfi
-
- def get_sfi_list(self, filter_dict={}):
- self.logger.debug(
- "Getting Service Function Instances from VIM filter: '%s'", str(filter_dict)
- )
-
- try:
- self._reload_connection()
- filter_dict_os = filter_dict.copy()
-
- if self.api_version3 and "tenant_id" in filter_dict_os:
- filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
-
- sfi_dict = self.neutron.list_sfc_port_pairs(**filter_dict_os)
- sfi_list = sfi_dict["port_pairs"]
- self.__sfi_os2mano(sfi_list)
-
- return sfi_list
- except (
- neExceptions.ConnectionFailed,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self._format_exception(e)
-
- def delete_sfi(self, sfi_id):
- self.logger.debug("Deleting Service Function Instance '%s' from VIM", sfi_id)
-
- try:
- self._reload_connection()
- self.neutron.delete_sfc_port_pair(sfi_id)
-
- return sfi_id
- except (
- neExceptions.ConnectionFailed,
- neExceptions.NeutronException,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self._format_exception(e)
-
- def new_sf(self, name, sfis, sfc_encap=True):
- self.logger.debug("Adding a new Service Function to VIM, named '%s'", name)
-
- try:
- new_sf = None
- self._reload_connection()
- # correlation = None
- # if sfc_encap:
- # correlation = "nsh"
-
- for instance in sfis:
- sfi = self.get_sfi(instance)
-
- if sfi.get("sfc_encap") != sfc_encap:
- raise vimconn.VimConnNotSupportedException(
- "OpenStack VIM connector requires all SFIs of the "
- "same SF to share the same SFC Encapsulation"
- )
-
- sf_dict = {"name": name, "port_pairs": sfis}
- new_sf = self.neutron.create_sfc_port_pair_group(
- {"port_pair_group": sf_dict}
- )
-
- return new_sf["port_pair_group"]["id"]
- except (
- neExceptions.ConnectionFailed,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- if new_sf:
- try:
- self.neutron.delete_sfc_port_pair_group(
- new_sf["port_pair_group"]["id"]
- )
- except Exception:
- self.logger.error(
- "Creation of Service Function failed, with "
- "subsequent deletion failure as well."
- )
-
- self._format_exception(e)
-
- def get_sf(self, sf_id):
- self.logger.debug("Getting Service Function %s from VIM", sf_id)
- filter_dict = {"id": sf_id}
- sf_list = self.get_sf_list(filter_dict)
-
- if len(sf_list) == 0:
- raise vimconn.VimConnNotFoundException(
- "Service Function '{}' not found".format(sf_id)
- )
- elif len(sf_list) > 1:
- raise vimconn.VimConnConflictException(
- "Found more than one Service Function with this criteria"
- )
-
- sf = sf_list[0]
-
- return sf
-
- def get_sf_list(self, filter_dict={}):
- self.logger.debug(
- "Getting Service Function from VIM filter: '%s'", str(filter_dict)
- )
-
- try:
- self._reload_connection()
- filter_dict_os = filter_dict.copy()
-
- if self.api_version3 and "tenant_id" in filter_dict_os:
- filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
-
- sf_dict = self.neutron.list_sfc_port_pair_groups(**filter_dict_os)
- sf_list = sf_dict["port_pair_groups"]
- self.__sf_os2mano(sf_list)
-
- return sf_list
- except (
- neExceptions.ConnectionFailed,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self._format_exception(e)
-
- def delete_sf(self, sf_id):
- self.logger.debug("Deleting Service Function '%s' from VIM", sf_id)
-
- try:
- self._reload_connection()
- self.neutron.delete_sfc_port_pair_group(sf_id)
-
- return sf_id
- except (
- neExceptions.ConnectionFailed,
- neExceptions.NeutronException,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self._format_exception(e)
-
- def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None):
- self.logger.debug("Adding a new Service Function Path to VIM, named '%s'", name)
-
- try:
- new_sfp = None
- self._reload_connection()
- # In networking-sfc the MPLS encapsulation is legacy
- # should be used when no full SFC Encapsulation is intended
- correlation = "mpls"
-
- if sfc_encap:
- correlation = "nsh"
-
- sfp_dict = {
- "name": name,
- "flow_classifiers": classifications,
- "port_pair_groups": sfs,
- "chain_parameters": {"correlation": correlation},
- }
-
- if spi:
- sfp_dict["chain_id"] = spi
-
- new_sfp = self.neutron.create_sfc_port_chain({"port_chain": sfp_dict})
-
- return new_sfp["port_chain"]["id"]
- except (
- neExceptions.ConnectionFailed,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- if new_sfp:
- try:
- self.neutron.delete_sfc_port_chain(new_sfp["port_chain"]["id"])
- except Exception:
- self.logger.error(
- "Creation of Service Function Path failed, with "
- "subsequent deletion failure as well."
- )
-
- self._format_exception(e)
-
- def get_sfp(self, sfp_id):
- self.logger.debug(" Getting Service Function Path %s from VIM", sfp_id)
-
- filter_dict = {"id": sfp_id}
- sfp_list = self.get_sfp_list(filter_dict)
-
- if len(sfp_list) == 0:
- raise vimconn.VimConnNotFoundException(
- "Service Function Path '{}' not found".format(sfp_id)
- )
- elif len(sfp_list) > 1:
- raise vimconn.VimConnConflictException(
- "Found more than one Service Function Path with this criteria"
- )
-
- sfp = sfp_list[0]
-
- return sfp
-
- def get_sfp_list(self, filter_dict={}):
- self.logger.debug(
- "Getting Service Function Paths from VIM filter: '%s'", str(filter_dict)
- )
-
- try:
- self._reload_connection()
- filter_dict_os = filter_dict.copy()
-
- if self.api_version3 and "tenant_id" in filter_dict_os:
- filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
-
- sfp_dict = self.neutron.list_sfc_port_chains(**filter_dict_os)
- sfp_list = sfp_dict["port_chains"]
- self.__sfp_os2mano(sfp_list)
-
- return sfp_list
- except (
- neExceptions.ConnectionFailed,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self._format_exception(e)
-
- def delete_sfp(self, sfp_id):
- self.logger.debug("Deleting Service Function Path '%s' from VIM", sfp_id)
-
- try:
- self._reload_connection()
- self.neutron.delete_sfc_port_chain(sfp_id)
-
- return sfp_id
- except (
- neExceptions.ConnectionFailed,
- neExceptions.NeutronException,
- ksExceptions.ClientException,
- neExceptions.NeutronException,
- ConnectionError,
- ) as e:
- self._format_exception(e)
-
- def refresh_sfps_status(self, sfp_list):
- """Get the status of the service function path
- Params: the list of sfp identifiers
- Returns a dictionary with:
- vm_id: #VIM id of this service function path
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE,
- # CREATING (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)F
- """
- sfp_dict = {}
- self.logger.debug(
- "refresh_sfps status: Getting tenant SFP information from VIM"
- )
-
- for sfp_id in sfp_list:
- sfp = {}
-
- try:
- sfp_vim = self.get_sfp(sfp_id)
-
- if sfp_vim["spi"]:
- sfp["status"] = vmStatus2manoFormat["ACTIVE"]
- else:
- sfp["status"] = "OTHER"
- sfp["error_msg"] = "VIM status reported " + sfp["status"]
-
- sfp["vim_info"] = self.serialize(sfp_vim)
-
- if sfp_vim.get("fault"):
- sfp["error_msg"] = str(sfp_vim["fault"])
- except vimconn.VimConnNotFoundException as e:
- self.logger.error("Exception getting sfp status: %s", str(e))
- sfp["status"] = "DELETED"
- sfp["error_msg"] = str(e)
- except vimconn.VimConnException as e:
- self.logger.error("Exception getting sfp status: %s", str(e))
- sfp["status"] = "VIM_ERROR"
- sfp["error_msg"] = str(e)
-
- sfp_dict[sfp_id] = sfp
-
- return sfp_dict
-
- def refresh_sfis_status(self, sfi_list):
- """Get the status of the service function instances
- Params: the list of sfi identifiers
- Returns a dictionary with:
- vm_id: #VIM id of this service function instance
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE,
- # CREATING (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
- """
- sfi_dict = {}
- self.logger.debug(
- "refresh_sfis status: Getting tenant sfi information from VIM"
- )
-
- for sfi_id in sfi_list:
- sfi = {}
-
- try:
- sfi_vim = self.get_sfi(sfi_id)
-
- if sfi_vim:
- sfi["status"] = vmStatus2manoFormat["ACTIVE"]
- else:
- sfi["status"] = "OTHER"
- sfi["error_msg"] = "VIM status reported " + sfi["status"]
-
- sfi["vim_info"] = self.serialize(sfi_vim)
-
- if sfi_vim.get("fault"):
- sfi["error_msg"] = str(sfi_vim["fault"])
- except vimconn.VimConnNotFoundException as e:
- self.logger.error("Exception getting sfi status: %s", str(e))
- sfi["status"] = "DELETED"
- sfi["error_msg"] = str(e)
- except vimconn.VimConnException as e:
- self.logger.error("Exception getting sfi status: %s", str(e))
- sfi["status"] = "VIM_ERROR"
- sfi["error_msg"] = str(e)
-
- sfi_dict[sfi_id] = sfi
-
- return sfi_dict
-
- def refresh_sfs_status(self, sf_list):
- """Get the status of the service functions
- Params: the list of sf identifiers
- Returns a dictionary with:
- vm_id: #VIM id of this service function
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE,
- # CREATING (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
- """
- sf_dict = {}
- self.logger.debug("refresh_sfs status: Getting tenant sf information from VIM")
-
- for sf_id in sf_list:
- sf = {}
-
- try:
- sf_vim = self.get_sf(sf_id)
-
- if sf_vim:
- sf["status"] = vmStatus2manoFormat["ACTIVE"]
- else:
- sf["status"] = "OTHER"
- sf["error_msg"] = "VIM status reported " + sf_vim["status"]
-
- sf["vim_info"] = self.serialize(sf_vim)
-
- if sf_vim.get("fault"):
- sf["error_msg"] = str(sf_vim["fault"])
- except vimconn.VimConnNotFoundException as e:
- self.logger.error("Exception getting sf status: %s", str(e))
- sf["status"] = "DELETED"
- sf["error_msg"] = str(e)
- except vimconn.VimConnException as e:
- self.logger.error("Exception getting sf status: %s", str(e))
- sf["status"] = "VIM_ERROR"
- sf["error_msg"] = str(e)
-
- sf_dict[sf_id] = sf
-
- return sf_dict
-
- def refresh_classifications_status(self, classification_list):
- """Get the status of the classifications
- Params: the list of classification identifiers
- Returns a dictionary with:
- vm_id: #VIM id of this classifier
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE,
- # CREATING (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
- """
- classification_dict = {}
- self.logger.debug(
- "refresh_classifications status: Getting tenant classification information from VIM"
- )
-
- for classification_id in classification_list:
- classification = {}
-
- try:
- classification_vim = self.get_classification(classification_id)
-
- if classification_vim:
- classification["status"] = vmStatus2manoFormat["ACTIVE"]
- else:
- classification["status"] = "OTHER"
- classification["error_msg"] = (
- "VIM status reported " + classification["status"]
- )
-
- classification["vim_info"] = self.serialize(classification_vim)
-
- if classification_vim.get("fault"):
- classification["error_msg"] = str(classification_vim["fault"])
- except vimconn.VimConnNotFoundException as e:
- self.logger.error("Exception getting classification status: %s", str(e))
- classification["status"] = "DELETED"
- classification["error_msg"] = str(e)
- except vimconn.VimConnException as e:
- self.logger.error("Exception getting classification status: %s", str(e))
- classification["status"] = "VIM_ERROR"
- classification["error_msg"] = str(e)
-
- classification_dict[classification_id] = classification
-
- return classification_dict
-
def new_affinity_group(self, affinity_group_data):
"""Adds a server group to VIM
affinity_group_data contains a dictionary with information, keys:
except (requests.exceptions.RequestException, js_e.ValidationError) as e:
self._format_request_exception(e)
- def new_vminstancefromJSON(self, vm_data):
- """Adds a VM instance to VIM"""
- """Returns the instance identifier"""
- try:
- self._get_my_tenant()
- except Exception as e:
- return -vimconn.HTTP_Not_Found, str(e)
- print("VIMConnector: Adding a new VM instance from JSON to VIM")
- payload_req = vm_data
- try:
- vim_response = requests.post(
- self.url + "/" + self.tenant + "/servers",
- headers=self.headers_req,
- data=payload_req,
- )
- except requests.exceptions.RequestException as e:
- print("new_vminstancefromJSON Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- # print vim_response
- # print vim_response.status_code
- if vim_response.status_code == 200:
- # print vim_response.json()
- # print json.dumps(vim_response.json(), indent=4)
- res, http_content = self._format_in(vim_response, new_image_response_schema)
- # print http_content
- if res:
- r = self._remove_extra_items(http_content, new_image_response_schema)
- if r is not None:
- print("Warning: remove extra items ", r)
- # print http_content
- vminstance_id = http_content["server"]["id"]
- print("Tenant image id: ", vminstance_id)
- return vim_response.status_code, vminstance_id
- else:
- return -vimconn.HTTP_Bad_Request, http_content
- else:
- # print vim_response.text
- jsonerror = self._format_jsonerror(vim_response)
- text = 'Error in VIM "{}": not possible to add new vm instance. HTTP Response: {}. Error: {}'.format(
- self.url, vim_response.status_code, jsonerror
- )
- # print text
- return -vim_response.status_code, text
-
def new_vminstance(
self,
name,
except (requests.exceptions.RequestException, js_e.ValidationError) as e:
self._format_request_exception(e)
- # NOT USED METHODS in current version
-
- def host_vim2gui(self, host, server_dict):
- """Transform host dictionary from VIM format to GUI format,
- and append to the server_dict
- """
- if type(server_dict) is not dict:
- print(
- "vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary"
- )
- return
- RAD = {}
- occupation = {}
- for numa in host["host"]["numas"]:
- RAD_item = {}
- occupation_item = {}
- # memory
- RAD_item["memory"] = {
- "size": str(numa["memory"]) + "GB",
- "eligible": str(numa["hugepages"]) + "GB",
- }
- occupation_item["memory"] = str(numa["hugepages_consumed"]) + "GB"
- # cpus
- RAD_item["cpus"] = {}
- RAD_item["cpus"]["cores"] = []
- RAD_item["cpus"]["eligible_cores"] = []
- occupation_item["cores"] = []
- for _ in range(0, len(numa["cores"]) // 2):
- RAD_item["cpus"]["cores"].append([])
- for core in numa["cores"]:
- RAD_item["cpus"]["cores"][core["core_id"]].append(core["thread_id"])
- if "status" not in core:
- RAD_item["cpus"]["eligible_cores"].append(core["thread_id"])
- if "instance_id" in core:
- occupation_item["cores"].append(core["thread_id"])
- # ports
- RAD_item["ports"] = {}
- occupation_item["ports"] = {}
- for iface in numa["interfaces"]:
- RAD_item["ports"][iface["pci"]] = "speed:" + str(iface["Mbps"]) + "M"
- occupation_item["ports"][iface["pci"]] = {
- "occupied": str(100 * iface["Mbps_consumed"] // iface["Mbps"]) + "%"
- }
-
- RAD[numa["numa_socket"]] = RAD_item
- occupation[numa["numa_socket"]] = occupation_item
- server_dict[host["host"]["name"]] = {"RAD": RAD, "occupation": occupation}
-
- def get_hosts_info(self):
- """Get the information of deployed hosts
- Returns the hosts content"""
- # obtain hosts list
- url = self.url + "/hosts"
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print("get_hosts_info Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print(
- "vim get", url, "response:", vim_response.status_code, vim_response.json()
- )
- # print vim_response.status_code
- # print json.dumps(vim_response.json(), indent=4)
- if vim_response.status_code != 200:
- # TODO: get error
- print(
- "vimconnector.get_hosts_info error getting host list {} {}".format(
- vim_response.status_code, vim_response.json()
- )
- )
- return -vim_response.status_code, "Error getting host list"
-
- res, hosts = self._format_in(vim_response, get_hosts_response_schema)
-
- if not res:
- print(
- "vimconnector.get_hosts_info error parsing GET HOSTS vim response",
- hosts,
- )
- return vimconn.HTTP_Internal_Server_Error, hosts
- # obtain hosts details
- hosts_dict = {}
- for host in hosts["hosts"]:
- url = self.url + "/hosts/" + host["id"]
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print("get_hosts_info Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print(
- "vim get",
- url,
- "response:",
- vim_response.status_code,
- vim_response.json(),
- )
- if vim_response.status_code != 200:
- print(
- "vimconnector.get_hosts_info error getting detailed host {} {}".format(
- vim_response.status_code, vim_response.json()
- )
- )
- continue
- res, host_detail = self._format_in(
- vim_response, get_host_detail_response_schema
- )
- if not res:
- print(
- "vimconnector.get_hosts_info error parsing GET HOSTS/{} vim response {}".format(
- host["id"], host_detail
- ),
- )
- continue
- # print 'host id '+host['id'], json.dumps(host_detail, indent=4)
- self.host_vim2gui(host_detail, hosts_dict)
- return 200, hosts_dict
-
- def get_hosts(self, vim_tenant):
- """Get the hosts and deployed instances
- Returns the hosts content"""
- # obtain hosts list
- url = self.url + "/hosts"
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print("get_hosts Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print(
- "vim get", url, "response:", vim_response.status_code, vim_response.json()
- )
- # print vim_response.status_code
- # print json.dumps(vim_response.json(), indent=4)
- if vim_response.status_code != 200:
- # TODO: get error
- print(
- "vimconnector.get_hosts error getting host list {} {}".format(
- vim_response.status_code, vim_response.json()
- )
- )
- return -vim_response.status_code, "Error getting host list"
-
- res, hosts = self._format_in(vim_response, get_hosts_response_schema)
-
- if not res:
- print("vimconnector.get_host error parsing GET HOSTS vim response", hosts)
- return vimconn.HTTP_Internal_Server_Error, hosts
- # obtain instances from hosts
- for host in hosts["hosts"]:
- url = self.url + "/" + vim_tenant + "/servers?hostId=" + host["id"]
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print("get_hosts Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print(
- "vim get",
- url,
- "response:",
- vim_response.status_code,
- vim_response.json(),
- )
- if vim_response.status_code != 200:
- print(
- "vimconnector.get_hosts error getting instances at host {} {}".format(
- vim_response.status_code, vim_response.json()
- )
- )
- continue
- res, servers = self._format_in(vim_response, get_server_response_schema)
- if not res:
- print(
- "vimconnector.get_host error parsing GET SERVERS/{} vim response {}".format(
- host["id"], servers
- ),
- )
- continue
- # print 'host id '+host['id'], json.dumps(host_detail, indent=4)
- host["instances"] = servers["servers"]
- return 200, hosts["hosts"]
-
- def get_processor_rankings(self):
- """Get the processor rankings in the VIM database"""
- url = self.url + "/processor_ranking"
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print("get_processor_rankings Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print(
- "vim get", url, "response:", vim_response.status_code, vim_response.json()
- )
- # print vim_response.status_code
- # print json.dumps(vim_response.json(), indent=4)
- if vim_response.status_code != 200:
- # TODO: get error
- print(
- "vimconnector.get_processor_rankings error getting processor rankings {} {}".format(
- vim_response.status_code, vim_response.json()
- )
- )
- return -vim_response.status_code, "Error getting processor rankings"
-
- res, rankings = self._format_in(
- vim_response, get_processor_rankings_response_schema
- )
- return res, rankings["rankings"]
-
- def new_host(self, host_data):
- """Adds a new host to VIM"""
- """Returns status code of the VIM response"""
- payload_req = host_data
- try:
- url = self.url_admin + "/hosts"
- self.logger.info("Adding a new host POST %s", url)
- vim_response = requests.post(
- url, headers=self.headers_req, data=payload_req
- )
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- # print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, new_host_response_schema)
- r = self._remove_extra_items(response, new_host_response_schema)
- if r is not None:
- self.logger.warn("Warning: remove extra items %s", str(r))
- host_id = response["host"]["id"]
- return host_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def new_external_port(self, port_data):
- """Adds a external port to VIM"""
- """Returns the port identifier"""
- # TODO change to logging exception code policies
- print("VIMConnector: Adding a new external port")
- payload_req = port_data
- try:
- vim_response = requests.post(
- self.url_admin + "/ports", headers=self.headers_req, data=payload_req
- )
- except requests.exceptions.RequestException as e:
- self.logger.error("new_external_port Exception: ", str(e))
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print(vim_response)
- # print vim_response.status_code
- if vim_response.status_code == 200:
- # print vim_response.json()
- # print json.dumps(vim_response.json(), indent=4)
- res, http_content = self._format_in(vim_response, new_port_response_schema)
- # print http_content
- if res:
- r = self._remove_extra_items(http_content, new_port_response_schema)
- if r is not None:
- print("Warning: remove extra items ", r)
- # print http_content
- port_id = http_content["port"]["id"]
- print("Port id: ", port_id)
- return vim_response.status_code, port_id
- else:
- return -vimconn.HTTP_Bad_Request, http_content
- else:
- # print vim_response.text
- jsonerror = self._format_jsonerror(vim_response)
- text = 'Error in VIM "{}": not possible to add new external port. HTTP Response: {}. Error: {}'.format(
- self.url_admin, vim_response.status_code, jsonerror
- )
- # print text
- return -vim_response.status_code, text
-
- def new_external_network(self, net_name, net_type):
- """Adds a external network to VIM (shared)"""
- """Returns the network identifier"""
- # TODO change to logging exception code policies
- print(
- "VIMConnector: Adding external shared network to VIM (type "
- + net_type
- + "): "
- + net_name
- )
-
- payload_req = (
- '{"network":{"name": "'
- + net_name
- + '","shared":true,"type": "'
- + net_type
- + '"}}'
- )
- try:
- vim_response = requests.post(
- self.url + "/networks", headers=self.headers_req, data=payload_req
- )
- except requests.exceptions.RequestException as e:
- self.logger.error("new_external_network Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print(vim_response)
- # print vim_response.status_code
- if vim_response.status_code == 200:
- # print vim_response.json()
- # print json.dumps(vim_response.json(), indent=4)
- res, http_content = self._format_in(
- vim_response, new_network_response_schema
- )
- # print http_content
- if res:
- r = self._remove_extra_items(http_content, new_network_response_schema)
- if r is not None:
- print("Warning: remove extra items ", r)
- # print http_content
- network_id = http_content["network"]["id"]
- print("Network id: ", network_id)
- return vim_response.status_code, network_id
- else:
- return -vimconn.HTTP_Bad_Request, http_content
- else:
- # print vim_response.text
- jsonerror = self._format_jsonerror(vim_response)
- text = 'Error in VIM "{}": not possible to add new external network. HTTP Response: {}. Error: {}'.format(
- self.url, vim_response.status_code, jsonerror
- )
- # print text
- return -vim_response.status_code, text
-
- def connect_port_network(self, port_id, network_id, admin=False):
- """Connects a external port to a network"""
- """Returns status code of the VIM response"""
- # TODO change to logging exception code policies
- print("VIMConnector: Connecting external port to network")
-
- payload_req = '{"port":{"network_id":"' + network_id + '"}}'
- if admin:
- if self.url_admin is None:
- return (
- -vimconn.HTTP_Unauthorized,
- "datacenter cannot contain admin URL",
- )
- url = self.url_admin
- else:
- url = self.url
- try:
- vim_response = requests.put(
- url + "/ports/" + port_id, headers=self.headers_req, data=payload_req
- )
- except requests.exceptions.RequestException as e:
- print("connect_port_network Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print(vim_response)
- # print vim_response.status_code
- if vim_response.status_code == 200:
- # print vim_response.json()
- # print json.dumps(vim_response.json(), indent=4)
- res, http_content = self._format_in(vim_response, new_port_response_schema)
- # print http_content
- if res:
- r = self._remove_extra_items(http_content, new_port_response_schema)
- if r is not None:
- print("Warning: remove extra items ", r)
- # print http_content
- port_id = http_content["port"]["id"]
- print("Port id: ", port_id)
- return vim_response.status_code, port_id
- else:
- return -vimconn.HTTP_Bad_Request, http_content
- else:
- print(vim_response.text)
- jsonerror = self._format_jsonerror(vim_response)
- text = (
- 'Error in VIM "{}": not possible to connect external port to network. HTTP Response: {}.'
- " Error: {}".format(self.url_admin, vim_response.status_code, jsonerror)
- )
- print(text)
- return -vim_response.status_code, text
-
def migrate_instance(self, vm_id, compute_host=None):
"""
Migrate a vdu
"Failed create a new network {}".format(net_name)
)
- def get_vcd_network_list(self):
- """Method available organization for a logged in tenant
-
- Returns:
- The return vca object that letter can be used to connect to vcloud direct as admin
- """
-
- self.logger.debug(
- "get_vcd_network_list(): retrieving network list for vcd {}".format(
- self.tenant_name
- )
- )
-
- if not self.tenant_name:
- raise vimconn.VimConnConnectionException("Tenant name is empty.")
-
- _, vdc = self.get_vdc_details()
- if vdc is None:
- raise vimconn.VimConnConnectionException(
- "Can't retrieve information for a VDC {}".format(self.tenant_name)
- )
-
- vdc_uuid = vdc.get("id").split(":")[3]
- if self.client._session:
- headers = {
- "Accept": "application/*+xml;version=" + API_VERSION,
- "x-vcloud-authorization": self.client._session.headers[
- "x-vcloud-authorization"
- ],
- }
- response = self.perform_request(
- req_type="GET", url=vdc.get("href"), headers=headers
- )
-
- if response.status_code != 200:
- self.logger.error("Failed to get vdc content")
- raise vimconn.VimConnNotFoundException("Failed to get vdc content")
- else:
- content = XmlElementTree.fromstring(response.text)
-
- network_list = []
- try:
- for item in content:
- if item.tag.split("}")[-1] == "AvailableNetworks":
- for net in item:
- response = self.perform_request(
- req_type="GET", url=net.get("href"), headers=headers
- )
-
- if response.status_code != 200:
- self.logger.error("Failed to get network content")
- raise vimconn.VimConnNotFoundException(
- "Failed to get network content"
- )
- else:
- net_details = XmlElementTree.fromstring(response.text)
-
- filter_dict = {}
- net_uuid = net_details.get("id").split(":")
-
- if len(net_uuid) != 4:
- continue
- else:
- net_uuid = net_uuid[3]
- # create dict entry
- self.logger.debug(
- "get_vcd_network_list(): Adding network {} "
- "to a list vcd id {} network {}".format(
- net_uuid, vdc_uuid, net_details.get("name")
- )
- )
- filter_dict["name"] = net_details.get("name")
- filter_dict["id"] = net_uuid
-
- if [
- i.text
- for i in net_details
- if i.tag.split("}")[-1] == "IsShared"
- ][0] == "true":
- shared = True
- else:
- shared = False
-
- filter_dict["shared"] = shared
- filter_dict["tenant_id"] = vdc_uuid
-
- if int(net_details.get("status")) == 1:
- filter_dict["admin_state_up"] = True
- else:
- filter_dict["admin_state_up"] = False
-
- filter_dict["status"] = "ACTIVE"
- filter_dict["type"] = "bridge"
- network_list.append(filter_dict)
- self.logger.debug(
- "get_vcd_network_list adding entry {}".format(
- filter_dict
- )
- )
- except Exception:
- self.logger.debug("Error in get_vcd_network_list", exc_info=True)
- pass
-
- self.logger.debug("get_vcd_network_list returning {}".format(network_list))
-
- return network_list
-
def get_network_list(self, filter_dict={}):
"""Obtain tenant networks of VIM
Filter_dict can be:
:param created_items: dictionary with extra items to be deleted. provided by method new_network
Returns the network identifier or raises an exception upon error or when network is not found
"""
-
- # ############# Stub code for SRIOV #################
- # dvport_group = self.get_dvport_group(net_id)
- # if dvport_group:
- # #delete portgroup
- # status = self.destroy_dvport_group(net_id)
- # if status:
- # # Remove vlanID from persistent info
- # if net_id in self.persistent_info["used_vlanIDs"]:
- # del self.persistent_info["used_vlanIDs"][net_id]
- #
- # return net_id
-
vcd_network = self.get_vcd_network(network_uuid=net_id)
if vcd_network is not None and vcd_network:
if self.delete_network_action(network_uuid=net_id):
"Exception occured while retriving catalog items {}".format(exp)
)
- def get_vappid(self, vdc=None, vapp_name=None):
- """Method takes vdc object and vApp name and returns vapp uuid or None
-
- Args:
- vdc: The VDC object.
- vapp_name: is application vappp name identifier
-
- Returns:
- The return vApp name otherwise None
- """
- if vdc is None or vapp_name is None:
- return None
-
- # UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
- try:
- refs = [
- ref
- for ref in vdc.ResourceEntities.ResourceEntity
- if ref.name == vapp_name
- and ref.type_ == "application/vnd.vmware.vcloud.vApp+xml"
- ]
-
- if len(refs) == 1:
- return refs[0].href.split("vapp")[1][1:]
- except Exception as e:
- self.logger.exception(e)
- return False
-
- return None
-
- def check_vapp(self, vdc=None, vapp_uuid=None):
- """Method Method returns True or False if vapp deployed in vCloud director
-
- Args:
- vca: Connector to VCA
- vdc: The VDC object.
- vappid: vappid is application identifier
-
- Returns:
- The return True if vApp deployed
- :param vdc:
- :param vapp_uuid:
- """
- try:
- refs = [
- ref
- for ref in vdc.ResourceEntities.ResourceEntity
- if ref.type_ == "application/vnd.vmware.vcloud.vApp+xml"
- ]
-
- for ref in refs:
- vappid = ref.href.split("vapp")[1][1:]
- # find vapp with respected vapp uuid
-
- if vappid == vapp_uuid:
- return True
- except Exception as e:
- self.logger.exception(e)
-
- return False
-
- return False
-
def get_namebyvappid(self, vapp_uuid=None):
"""Method returns vApp name from vCD and lookup done by vapp_id.
"The upload iso task failed with status {}".format(result.get("status"))
)
- def get_vcd_availibility_zones(self, respool_href, headers):
- """Method to find presence of av zone is VIM resource pool
-
- Args:
- respool_href - resource pool href
- headers - header information
-
- Returns:
- vcd_az - list of azone present in vCD
- """
- vcd_az = []
- url = respool_href
- resp = self.perform_request(req_type="GET", url=respool_href, headers=headers)
-
- if resp.status_code != requests.codes.ok:
- self.logger.debug(
- "REST API call {} failed. Return status code {}".format(
- url, resp.status_code
- )
- )
- else:
- # Get the href to hostGroups and find provided hostGroup is present in it
- resp_xml = XmlElementTree.fromstring(resp.content)
- for child in resp_xml:
- if "VMWProviderVdcResourcePool" in child.tag:
- for schild in child:
- if "Link" in schild.tag:
- if (
- schild.attrib.get("type")
- == "application/vnd.vmware.admin.vmwHostGroupsType+xml"
- ):
- hostGroup = schild.attrib.get("href")
- hg_resp = self.perform_request(
- req_type="GET", url=hostGroup, headers=headers
- )
-
- if hg_resp.status_code != requests.codes.ok:
- self.logger.debug(
- "REST API call {} failed. Return status code {}".format(
- hostGroup, hg_resp.status_code
- )
- )
- else:
- hg_resp_xml = XmlElementTree.fromstring(
- hg_resp.content
- )
- for hostGroup in hg_resp_xml:
- if "HostGroup" in hostGroup.tag:
- # append host group name to the list
- vcd_az.append(hostGroup.attrib.get("name"))
-
- return vcd_az
-
def set_availability_zones(self):
"""
Set vim availability zone
raise vimconn.VimConnException(msg)
- # #
- # #
- # # based on current discussion
- # #
- # #
- # # server:
- # created: '2016-09-08T11:51:58'
- # description: simple-instance.linux1.1
- # flavor: ddc6776e-75a9-11e6-ad5f-0800273e724c
- # hostId: e836c036-74e7-11e6-b249-0800273e724c
- # image: dde30fe6-75a9-11e6-ad5f-0800273e724c
- # status: ACTIVE
- # error_msg:
- # interfaces: …
- #
def get_vminstance(self, vim_vm_uuid=None):
"""Returns the VM instance information from VIM"""
self.logger.debug("Client requesting vm instance {} ".format(vim_vm_uuid))
return console_dict
- # NOT USED METHODS in current version
-
- def host_vim2gui(self, host, server_dict):
- """Transform host dictionary from VIM format to GUI format,
- and append to the server_dict
- """
- raise vimconn.VimConnNotImplemented("Should have implemented this")
-
def get_hosts_info(self):
"""Get the information of deployed hosts
Returns the hosts content"""
Returns the hosts content"""
raise vimconn.VimConnNotImplemented("Should have implemented this")
- def get_processor_rankings(self):
- """Get the processor rankings in the VIM database"""
- raise vimconn.VimConnNotImplemented("Should have implemented this")
-
- def new_host(self, host_data):
- """Adds a new host to VIM"""
- """Returns status code of the VIM response"""
- raise vimconn.VimConnNotImplemented("Should have implemented this")
-
- def new_external_port(self, port_data):
- """Adds a external port to VIM"""
- """Returns the port identifier"""
- raise vimconn.VimConnNotImplemented("Should have implemented this")
-
- def new_external_network(self, net_name, net_type):
- """Adds a external network to VIM (shared)"""
- """Returns the network identifier"""
- raise vimconn.VimConnNotImplemented("Should have implemented this")
-
- def connect_port_network(self, port_id, network_id, admin=False):
- """Connects a external port to a network"""
- """Returns status code of the VIM response"""
- raise vimconn.VimConnNotImplemented("Should have implemented this")
-
- def new_vminstancefromJSON(self, vm_data):
- """Adds a VM instance to VIM"""
- """Returns the instance identifier"""
- raise vimconn.VimConnNotImplemented("Should have implemented this")
-
def get_network_name_by_id(self, network_uuid=None):
"""Method gets vcloud director network named based on supplied uuid.
return None
- def get_vapp_list(self, vdc_name=None):
- """
- Method retrieves vApp list deployed vCloud director and returns a dictionary
- contains a list of all vapp deployed for queried VDC.
- The key for a dictionary is vApp UUID
-
-
- Args:
- vca - is active VCA connection.
- vdc_name - is a vdc name that will be used to query vms action
-
- Returns:
- The return dictionary and key for each entry vapp UUID
- """
- vapp_dict = {}
-
- if vdc_name is None:
- return vapp_dict
-
- content = self.vms_view_action(vdc_name=vdc_name)
- try:
- vm_list_xmlroot = XmlElementTree.fromstring(content)
- for vm_xml in vm_list_xmlroot:
- if vm_xml.tag.split("}")[1] == "VMRecord":
- if vm_xml.attrib["isVAppTemplate"] == "true":
- rawuuid = vm_xml.attrib["container"].split("/")[-1:]
- if "vappTemplate-" in rawuuid[0]:
- # vm in format vappTemplate-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
- # vm and use raw UUID as key
- vapp_dict[rawuuid[0][13:]] = vm_xml.attrib
- except Exception:
- pass
-
- return vapp_dict
-
- def get_vm_list(self, vdc_name=None):
- """
- Method retrieves VM's list deployed vCloud director. It returns a dictionary
- contains a list of all VM's deployed for queried VDC.
- The key for a dictionary is VM UUID
-
-
- Args:
- vca - is active VCA connection.
- vdc_name - is a vdc name that will be used to query vms action
-
- Returns:
- The return dictionary and key for each entry vapp UUID
- """
- vm_dict = {}
-
- if vdc_name is None:
- return vm_dict
-
- content = self.vms_view_action(vdc_name=vdc_name)
- try:
- vm_list_xmlroot = XmlElementTree.fromstring(content)
- for vm_xml in vm_list_xmlroot:
- if vm_xml.tag.split("}")[1] == "VMRecord":
- if vm_xml.attrib["isVAppTemplate"] == "false":
- rawuuid = vm_xml.attrib["href"].split("/")[-1:]
- if "vm-" in rawuuid[0]:
- # vm in format vm-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
- # vm and use raw UUID as key
- vm_dict[rawuuid[0][3:]] = vm_xml.attrib
- except Exception:
- pass
-
- return vm_dict
-
def get_vapp(self, vdc_name=None, vapp_name=None, isuuid=False):
"""
Method retrieves VM deployed vCloud director. It returns VM attribute as dictionary
return None
- def create_vdc_rest(self, vdc_name=None):
+ def get_vapp_details_rest(self, vapp_uuid=None, need_admin_access=False):
"""
- Method create network in vCloud director
+ Method retrieve vapp detail from vCloud director
Args:
- vdc_name - vdc name to be created
+ vapp_uuid - is vapp identifier.
+
Returns:
- The return response
+ The return network uuid or return None
"""
- self.logger.info("Creating new vdc {}".format(vdc_name))
- vca = self.connect_as_admin()
+ parsed_respond = {}
+ vca = None
+
+ if need_admin_access:
+ vca = self.connect_as_admin()
+ else:
+ vca = self.client
if not vca:
raise vimconn.VimConnConnectionException("Failed to connect vCD")
-
- if vdc_name is None:
+ if vapp_uuid is None:
return None
- url_list = [self.url, "/api/admin/org/", self.org_uuid]
- vm_list_rest_call = "".join(url_list)
+ url_list = [self.url, "/api/vApp/vapp-", vapp_uuid]
+ get_vapp_restcall = "".join(url_list)
if vca._session:
headers = {
"Accept": "application/*+xml;version=" + API_VERSION,
- "x-vcloud-authorization": self.client._session.headers[
- "x-vcloud-authorization"
- ],
- }
- response = self.perform_request(
- req_type="GET", url=vm_list_rest_call, headers=headers
- )
- provider_vdc_ref = None
- add_vdc_rest_url = None
- # available_networks = None
-
- if response.status_code != requests.codes.ok:
- self.logger.debug(
- "REST API call {} failed. Return status code {}".format(
- vm_list_rest_call, response.status_code
- )
- )
-
- return None
- else:
- try:
- vm_list_xmlroot = XmlElementTree.fromstring(response.text)
- for child in vm_list_xmlroot:
- # application/vnd.vmware.admin.providervdc+xml
- if child.tag.split("}")[1] == "Link":
- if (
- child.attrib.get("type")
- == "application/vnd.vmware.admin.createVdcParams+xml"
- and child.attrib.get("rel") == "add"
- ):
- add_vdc_rest_url = child.attrib.get("href")
- except Exception:
- self.logger.debug(
- "Failed parse respond for rest api call {}".format(
- vm_list_rest_call
- )
- )
- self.logger.debug("Respond body {}".format(response.text))
-
- return None
-
- response = self.get_provider_rest(vca=vca)
- try:
- vm_list_xmlroot = XmlElementTree.fromstring(response)
- for child in vm_list_xmlroot:
- if child.tag.split("}")[1] == "ProviderVdcReferences":
- for sub_child in child:
- provider_vdc_ref = sub_child.attrib.get("href")
- except Exception:
- self.logger.debug(
- "Failed parse respond for rest api call {}".format(
- vm_list_rest_call
- )
- )
- self.logger.debug("Respond body {}".format(response))
-
- return None
-
- if add_vdc_rest_url is not None and provider_vdc_ref is not None:
- data = """ <CreateVdcParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5"><Description>{1:s}</Description>
- <AllocationModel>ReservationPool</AllocationModel>
- <ComputeCapacity><Cpu><Units>MHz</Units><Allocated>2048</Allocated><Limit>2048</Limit></Cpu>
- <Memory><Units>MB</Units><Allocated>2048</Allocated><Limit>2048</Limit></Memory>
- </ComputeCapacity><NicQuota>0</NicQuota><NetworkQuota>100</NetworkQuota>
- <VdcStorageProfile><Enabled>true</Enabled><Units>MB</Units><Limit>20480</Limit><Default>true</Default></VdcStorageProfile>
- <ProviderVdcReference
- name="Main Provider"
- href="{2:s}" />
- <UsesFastProvisioning>true</UsesFastProvisioning></CreateVdcParams>""".format(
- escape(vdc_name), escape(vdc_name), provider_vdc_ref
- )
- headers[
- "Content-Type"
- ] = "application/vnd.vmware.admin.createVdcParams+xml"
- response = self.perform_request(
- req_type="POST",
- url=add_vdc_rest_url,
- headers=headers,
- data=data,
- )
-
- # if we all ok we respond with content otherwise by default None
- if response.status_code == 201:
- return response.text
-
- return None
-
- def get_vapp_details_rest(self, vapp_uuid=None, need_admin_access=False):
- """
- Method retrieve vapp detail from vCloud director
-
- Args:
- vapp_uuid - is vapp identifier.
-
- Returns:
- The return network uuid or return None
- """
- parsed_respond = {}
- vca = None
-
- if need_admin_access:
- vca = self.connect_as_admin()
- else:
- vca = self.client
-
- if not vca:
- raise vimconn.VimConnConnectionException("Failed to connect vCD")
- if vapp_uuid is None:
- return None
-
- url_list = [self.url, "/api/vApp/vapp-", vapp_uuid]
- get_vapp_restcall = "".join(url_list)
-
- if vca._session:
- headers = {
- "Accept": "application/*+xml;version=" + API_VERSION,
- "x-vcloud-authorization": vca._session.headers[
+ "x-vcloud-authorization": vca._session.headers[
"x-vcloud-authorization"
],
}
return parsed_respond
- def acquire_console(self, vm_uuid=None):
- if vm_uuid is None:
- return None
-
- if self.client._session:
- headers = {
- "Accept": "application/*+xml;version=" + API_VERSION,
- "x-vcloud-authorization": self.client._session.headers[
- "x-vcloud-authorization"
- ],
- }
- vm_dict = self.get_vapp_details_rest(vapp_uuid=vm_uuid)
- console_dict = vm_dict["acquireTicket"]
- console_rest_call = console_dict["href"]
-
- response = self.perform_request(
- req_type="POST", url=console_rest_call, headers=headers
- )
-
- if response.status_code == 403:
- response = self.retry_rest("POST", console_rest_call)
-
- if response.status_code == requests.codes.ok:
- return response.text
-
- return None
-
def modify_vm_disk(self, vapp_uuid, flavor_disk):
"""
Method retrieve vm disk details
"affinity".format(exp)
)
- def cloud_init(self, vapp, cloud_config):
- """
- Method to inject ssh-key
- vapp - vapp object
- cloud_config a dictionary with:
- 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
- 'users': (optional) list of users to be inserted, each item is a dict with:
- 'name': (mandatory) user name,
- 'key-pairs': (optional) list of strings with the public key to be inserted to the user
- 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
- or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
- 'config-files': (optional). List of files to be transferred. Each item is a dict with:
- 'dest': (mandatory) string with the destination absolute path
- 'encoding': (optional, by default text). Can be one of:
- 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
- 'content' (mandatory): string with the content of the file
- 'permissions': (optional) string with file permissions, typically octal notation '0644'
- 'owner': (optional) file owner, string with the format 'owner:group'
- 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk
- """
- try:
- if not isinstance(cloud_config, dict):
- raise Exception(
- "cloud_init : parameter cloud_config is not a dictionary"
- )
- else:
- key_pairs = []
- userdata = []
-
- if "key-pairs" in cloud_config:
- key_pairs = cloud_config["key-pairs"]
-
- if "users" in cloud_config:
- userdata = cloud_config["users"]
-
- self.logger.debug("cloud_init : Guest os customization started..")
- customize_script = self.format_script(
- key_pairs=key_pairs, users_list=userdata
- )
- customize_script = customize_script.replace("&", "&")
- self.guest_customization(vapp, customize_script)
- except Exception as exp:
- self.logger.error(
- "cloud_init : exception occurred while injecting " "ssh-key"
- )
-
- raise vimconn.VimConnException(
- "cloud_init : Error {} failed to inject " "ssh-key".format(exp)
- )
-
- def format_script(self, key_pairs=[], users_list=[]):
- bash_script = """#!/bin/sh
-echo performing customization tasks with param $1 at `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"`>> /root/customization.log
-if [ "$1" = "precustomization" ];then
- echo performing precustomization tasks on `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
-"""
-
- keys = "\n".join(key_pairs)
- if keys:
- keys_data = """
- if [ ! -d /root/.ssh ];then
- mkdir /root/.ssh
- chown root:root /root/.ssh
- chmod 700 /root/.ssh
- touch /root/.ssh/authorized_keys
- chown root:root /root/.ssh/authorized_keys
- chmod 600 /root/.ssh/authorized_keys
- # make centos with selinux happy
- which restorecon && restorecon -Rv /root/.ssh
- else
- touch /root/.ssh/authorized_keys
- chown root:root /root/.ssh/authorized_keys
- chmod 600 /root/.ssh/authorized_keys
- fi
- echo '{key}' >> /root/.ssh/authorized_keys
- """.format(
- key=keys
- )
-
- bash_script += keys_data
-
- for user in users_list:
- if "name" in user:
- user_name = user["name"]
-
- if "key-pairs" in user:
- user_keys = "\n".join(user["key-pairs"])
- else:
- user_keys = None
-
- add_user_name = """
- useradd -d /home/{user_name} -m -g users -s /bin/bash {user_name}
- """.format(
- user_name=user_name
- )
-
- bash_script += add_user_name
-
- if user_keys:
- user_keys_data = """
- mkdir /home/{user_name}/.ssh
- chown {user_name}:{user_name} /home/{user_name}/.ssh
- chmod 700 /home/{user_name}/.ssh
- touch /home/{user_name}/.ssh/authorized_keys
- chown {user_name}:{user_name} /home/{user_name}/.ssh/authorized_keys
- chmod 600 /home/{user_name}/.ssh/authorized_keys
- # make centos with selinux happy
- which restorecon && restorecon -Rv /home/{user_name}/.ssh
- echo '{user_key}' >> /home/{user_name}/.ssh/authorized_keys
- """.format(
- user_name=user_name, user_key=user_keys
- )
- bash_script += user_keys_data
-
- return bash_script + "\n\tfi"
-
- def guest_customization(self, vapp, customize_script):
- """
- Method to customize guest os
- vapp - Vapp object
- customize_script - Customize script to be run at first boot of VM.
- """
- for vm in vapp.get_all_vms():
- vm_id = vm.get("id").split(":")[-1]
- vm_name = vm.get("name")
- vm_name = vm_name.replace("_", "-")
-
- vm_customization_url = (
- "{}/api/vApp/vm-{}/guestCustomizationSection/".format(self.url, vm_id)
- )
- headers = {
- "Accept": "application/*+xml;version=" + API_VERSION,
- "x-vcloud-authorization": self.client._session.headers[
- "x-vcloud-authorization"
- ],
- }
-
- headers[
- "Content-Type"
- ] = "application/vnd.vmware.vcloud.guestCustomizationSection+xml"
-
- data = """<GuestCustomizationSection
- xmlns="http://www.vmware.com/vcloud/v1.5"
- xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
- ovf:required="false" href="{}"
- type="application/vnd.vmware.vcloud.guestCustomizationSection+xml">
- <ovf:Info>Specifies Guest OS Customization Settings</ovf:Info>
- <Enabled>true</Enabled>
- <ChangeSid>false</ChangeSid>
- <VirtualMachineId>{}</VirtualMachineId>
- <JoinDomainEnabled>false</JoinDomainEnabled>
- <UseOrgSettings>false</UseOrgSettings>
- <AdminPasswordEnabled>false</AdminPasswordEnabled>
- <AdminPasswordAuto>true</AdminPasswordAuto>
- <AdminAutoLogonEnabled>false</AdminAutoLogonEnabled>
- <AdminAutoLogonCount>0</AdminAutoLogonCount>
- <ResetPasswordRequired>false</ResetPasswordRequired>
- <CustomizationScript>{}</CustomizationScript>
- <ComputerName>{}</ComputerName>
- <Link href="{}"
- type="application/vnd.vmware.vcloud.guestCustomizationSection+xml" rel="edit"/>
- </GuestCustomizationSection>
- """.format(
- vm_customization_url,
- vm_id,
- customize_script,
- vm_name,
- vm_customization_url,
- )
-
- response = self.perform_request(
- req_type="PUT", url=vm_customization_url, headers=headers, data=data
- )
- if response.status_code == 202:
- guest_task = self.get_task_from_response(response.text)
- self.client.get_task_monitor().wait_for_success(task=guest_task)
- self.logger.info(
- "guest_customization : customized guest os task "
- "completed for VM {}".format(vm_name)
- )
- else:
- self.logger.error(
- "guest_customization : task for customized guest os"
- "failed for VM {}".format(vm_name)
- )
-
- raise vimconn.VimConnException(
- "guest_customization : failed to perform"
- "guest os customization on VM {}".format(vm_name)
- )
-
def add_new_disk(self, vapp_uuid, disk_size):
"""
Method to create an empty vm disk
elif exp_type == "NotFound":
raise vimconn.VimConnNotFoundException(message=msg)
- def add_sriov(self, vapp_uuid, sriov_nets, vmname_andid):
- """
- Method to attach SRIOV adapters to VM
-
- Args:
- vapp_uuid - uuid of vApp/VM
- sriov_nets - SRIOV devices infromation as specified in VNFD (flavor)
- vmname_andid - vmname
-
- Returns:
- The status of add SRIOV adapter task , vm object and
- vcenter_conect object
- """
- vm_obj = None
- vcenter_conect, content = self.get_vcenter_content()
- vm_moref_id = self.get_vm_moref_id(vapp_uuid)
-
- if vm_moref_id:
- try:
- no_of_sriov_devices = len(sriov_nets)
- if no_of_sriov_devices > 0:
- # Get VM and its host
- host_obj, vm_obj = self.get_vm_obj(content, vm_moref_id)
- self.logger.info(
- "VM {} is currently on host {}".format(vm_obj, host_obj)
- )
-
- if host_obj and vm_obj:
- # get SRIOV devies from host on which vapp is currently installed
- avilable_sriov_devices = self.get_sriov_devices(
- host_obj,
- no_of_sriov_devices,
- )
-
- if len(avilable_sriov_devices) == 0:
- # find other hosts with active pci devices
- (
- new_host_obj,
- avilable_sriov_devices,
- ) = self.get_host_and_sriov_devices(
- content,
- no_of_sriov_devices,
- )
-
- if (
- new_host_obj is not None
- and len(avilable_sriov_devices) > 0
- ):
- # Migrate vm to the host where SRIOV devices are available
- self.logger.info(
- "Relocate VM {} on new host {}".format(
- vm_obj, new_host_obj
- )
- )
- task = self.relocate_vm(new_host_obj, vm_obj)
-
- if task is not None:
- result = self.wait_for_vcenter_task(
- task, vcenter_conect
- )
- self.logger.info(
- "Migrate VM status: {}".format(result)
- )
- host_obj = new_host_obj
- else:
- self.logger.info(
- "Fail to migrate VM : {}".format(result)
- )
-
- raise vimconn.VimConnNotFoundException(
- "Fail to migrate VM : {} to host {}".format(
- vmname_andid, new_host_obj
- )
- )
-
- if (
- host_obj is not None
- and avilable_sriov_devices is not None
- and len(avilable_sriov_devices) > 0
- ):
- # Add SRIOV devices one by one
- for sriov_net in sriov_nets:
- network_name = sriov_net.get("net_id")
- self.create_dvPort_group(network_name)
-
- if (
- sriov_net.get("type") == "VF"
- or sriov_net.get("type") == "SR-IOV"
- ):
- # add vlan ID ,Modify portgroup for vlan ID
- self.configure_vlanID(
- content, vcenter_conect, network_name
- )
-
- task = self.add_sriov_to_vm(
- content,
- vm_obj,
- host_obj,
- network_name,
- avilable_sriov_devices[0],
- )
-
- if task:
- status = self.wait_for_vcenter_task(
- task, vcenter_conect
- )
-
- if status:
- self.logger.info(
- "Added SRIOV {} to VM {}".format(
- no_of_sriov_devices, str(vm_obj)
- )
- )
- else:
- self.logger.error(
- "Fail to add SRIOV {} to VM {}".format(
- no_of_sriov_devices, str(vm_obj)
- )
- )
-
- raise vimconn.VimConnUnexpectedResponse(
- "Fail to add SRIOV adapter in VM {}".format(
- str(vm_obj)
- )
- )
-
- return True, vm_obj, vcenter_conect
- else:
- self.logger.error(
- "Currently there is no host with"
- " {} number of avaialble SRIOV "
- "VFs required for VM {}".format(
- no_of_sriov_devices, vmname_andid
- )
- )
-
- raise vimconn.VimConnNotFoundException(
- "Currently there is no host with {} "
- "number of avaialble SRIOV devices required for VM {}".format(
- no_of_sriov_devices, vmname_andid
- )
- )
- else:
- self.logger.debug(
- "No infromation about SRIOV devices {} ", sriov_nets
- )
- except vmodl.MethodFault as error:
- self.logger.error("Error occurred while adding SRIOV {} ", error)
-
- return None, vm_obj, vcenter_conect
-
def get_sriov_devices(self, host, no_of_vfs):
"""
Method to get the details of SRIOV devices on given host
return sriovInfo
- def get_host_and_sriov_devices(self, content, no_of_vfs):
- """
- Method to get the details of SRIOV devices infromation on all hosts
-
- Args:
- content - vSphere host object
- no_of_vfs - number of pci VFs needed on host
-
- Returns:
- array of SRIOV devices and host object
- """
- host_obj = None
- sriov_device_objs = None
-
- try:
- if content:
- container = content.viewManager.CreateContainerView(
- content.rootFolder, [vim.HostSystem], True
- )
-
- for host in container.view:
- devices = self.get_sriov_devices(host, no_of_vfs)
-
- if devices:
- host_obj = host
- sriov_device_objs = devices
- break
- except Exception as exp:
- self.logger.error(
- "Error {} occurred while finding SRIOV devices on host: {}".format(
- exp, host_obj
- )
- )
-
- return host_obj, sriov_device_objs
-
- def add_sriov_to_vm(self, content, vm_obj, host_obj, network_name, sriov_device):
- """
- Method to add SRIOV adapter to vm
-
- Args:
- host_obj - vSphere host object
- vm_obj - vSphere vm object
- content - vCenter content object
- network_name - name of distributed virtaul portgroup
- sriov_device - SRIOV device info
-
- Returns:
- task object
- """
- devices = []
- vnic_label = "sriov nic"
-
- try:
- dvs_portgr = self.get_dvport_group(network_name)
- network_name = dvs_portgr.name
- nic = vim.vm.device.VirtualDeviceSpec()
- # VM device
- nic.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
- nic.device = vim.vm.device.VirtualSriovEthernetCard()
- nic.device.addressType = "assigned"
- # nic.device.key = 13016
- nic.device.deviceInfo = vim.Description()
- nic.device.deviceInfo.label = vnic_label
- nic.device.deviceInfo.summary = network_name
- nic.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
-
- nic.device.backing.network = self.get_obj(
- content, [vim.Network], network_name
- )
- nic.device.backing.deviceName = network_name
- nic.device.backing.useAutoDetect = False
- nic.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
- nic.device.connectable.startConnected = True
- nic.device.connectable.allowGuestControl = True
-
- nic.device.sriovBacking = (
- vim.vm.device.VirtualSriovEthernetCard.SriovBackingInfo()
- )
- nic.device.sriovBacking.physicalFunctionBacking = (
- vim.vm.device.VirtualPCIPassthrough.DeviceBackingInfo()
- )
- nic.device.sriovBacking.physicalFunctionBacking.id = sriov_device.id
-
- devices.append(nic)
- vmconf = vim.vm.ConfigSpec(deviceChange=devices)
- task = vm_obj.ReconfigVM_Task(vmconf)
-
- return task
- except Exception as exp:
- self.logger.error(
- "Error {} occurred while adding SRIOV adapter in VM: {}".format(
- exp, vm_obj
- )
- )
-
- return None
-
- def create_dvPort_group(self, network_name):
- """
- Method to create disributed virtual portgroup
-
- Args:
- network_name - name of network/portgroup
-
- Returns:
- portgroup key
- """
- try:
- new_network_name = [network_name, "-", str(uuid.uuid4())]
- network_name = "".join(new_network_name)
- vcenter_conect, content = self.get_vcenter_content()
-
- dv_switch = self.get_obj(
- content, [vim.DistributedVirtualSwitch], self.dvs_name
- )
-
- if dv_switch:
- dv_pg_spec = vim.dvs.DistributedVirtualPortgroup.ConfigSpec()
- dv_pg_spec.name = network_name
-
- dv_pg_spec.type = (
- vim.dvs.DistributedVirtualPortgroup.PortgroupType.earlyBinding
- )
- dv_pg_spec.defaultPortConfig = (
- vim.dvs.VmwareDistributedVirtualSwitch.VmwarePortConfigPolicy()
- )
- dv_pg_spec.defaultPortConfig.securityPolicy = (
- vim.dvs.VmwareDistributedVirtualSwitch.SecurityPolicy()
- )
- dv_pg_spec.defaultPortConfig.securityPolicy.allowPromiscuous = (
- vim.BoolPolicy(value=False)
- )
- dv_pg_spec.defaultPortConfig.securityPolicy.forgedTransmits = (
- vim.BoolPolicy(value=False)
- )
- dv_pg_spec.defaultPortConfig.securityPolicy.macChanges = vim.BoolPolicy(
- value=False
- )
-
- task = dv_switch.AddDVPortgroup_Task([dv_pg_spec])
- self.wait_for_vcenter_task(task, vcenter_conect)
-
- dvPort_group = self.get_obj(
- content, [vim.dvs.DistributedVirtualPortgroup], network_name
- )
-
- if dvPort_group:
- self.logger.info(
- "Created disributed virtaul port group: {}".format(dvPort_group)
- )
- return dvPort_group.key
- else:
- self.logger.debug(
- "No disributed virtual switch found with name {}".format(
- network_name
- )
- )
-
- except Exception as exp:
- self.logger.error(
- "Error occurred while creating disributed virtaul port group {}"
- " : {}".format(network_name, exp)
- )
-
- return None
-
def reconfig_portgroup(self, content, dvPort_group_name, config_info={}):
"""
Method to reconfigure disributed virtual portgroup
return None
- def destroy_dvport_group(self, dvPort_group_name):
- """
- Method to destroy disributed virtual portgroup
-
- Args:
- network_name - name of network/portgroup
-
- Returns:
- True if portgroup successfully got deleted else false
- """
- vcenter_conect, _ = self.get_vcenter_content()
-
- try:
- status = None
- dvPort_group = self.get_dvport_group(dvPort_group_name)
-
- if dvPort_group:
- task = dvPort_group.Destroy_Task()
- status = self.wait_for_vcenter_task(task, vcenter_conect)
-
- return status
- except vmodl.MethodFault as exp:
- self.logger.error(
- "Caught vmodl fault {} while deleting disributed virtaul port group {}".format(
- exp, dvPort_group_name
- )
- )
-
- return None
-
def get_dvport_group(self, dvPort_group_name):
"""
Method to get disributed virtual portgroup
return vlanId
- def configure_vlanID(self, content, vcenter_conect, dvPort_group_name):
- """
- Method to configure vlanID in disributed virtual portgroup vlanID
-
- Args:
- network_name - name of network/portgroup
-
- Returns:
- None
- """
- vlanID = self.get_vlanID_from_dvs_portgr(dvPort_group_name)
-
- if vlanID == 0:
- # configure vlanID
- vlanID = self.genrate_vlanID(dvPort_group_name)
- config = {"vlanID": vlanID}
- task = self.reconfig_portgroup(
- content, dvPort_group_name, config_info=config
- )
-
- if task:
- status = self.wait_for_vcenter_task(task, vcenter_conect)
-
- if status:
- self.logger.info(
- "Reconfigured Port group {} for vlan ID {}".format(
- dvPort_group_name, vlanID
- )
- )
- else:
- self.logger.error(
- "Fail reconfigure portgroup {} for vlanID{}".format(
- dvPort_group_name, vlanID
- )
- )
-
- def genrate_vlanID(self, network_name):
- """
- Method to get unused vlanID
- Args:
- network_name - name of network/portgroup
- Returns:
- vlanID
- """
- vlan_id = None
- used_ids = []
-
- if self.config.get("vlanID_range") is None:
- raise vimconn.VimConnConflictException(
- "You must provide a 'vlanID_range' "
- "at config value before creating sriov network with vlan tag"
- )
-
- if "used_vlanIDs" not in self.persistent_info:
- self.persistent_info["used_vlanIDs"] = {}
- else:
- used_ids = list(self.persistent_info["used_vlanIDs"].values())
-
- for vlanID_range in self.config.get("vlanID_range"):
- start_vlanid, end_vlanid = vlanID_range.split("-")
-
- if start_vlanid > end_vlanid:
- raise vimconn.VimConnConflictException(
- "Invalid vlan ID range {}".format(vlanID_range)
- )
-
- for vid in range(int(start_vlanid), int(end_vlanid) + 1):
- if vid not in used_ids:
- vlan_id = vid
- self.persistent_info["used_vlanIDs"][network_name] = vlan_id
- return vlan_id
-
- if vlan_id is None:
- raise vimconn.VimConnConflictException("All Vlan IDs are in use")
-
- def get_obj(self, content, vimtype, name):
- """
- Get the vsphere object associated with a given text name
- """
- obj = None
- container = content.viewManager.CreateContainerView(
- content.rootFolder, vimtype, True
- )
-
- for item in container.view:
- if item.name == name:
- obj = item
- break
-
- return obj
-
def insert_media_to_vm(self, vapp, image_id):
"""
Method to insert media CD-ROM (ISO image) from catalog to vm.
"""
raise VimConnNotImplemented("Should have implemented this")
- def new_classification(self, name, ctype, definition):
- """Creates a traffic classification in the VIM
- Params:
- 'name': name of this classification
- 'ctype': type of this classification
- 'definition': definition of this classification (type-dependent free-form text)
- Returns the VIM's classification ID on success or raises an exception on failure
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def get_classification(self, classification_id):
- """Obtain classification details of the VIM's classification with ID='classification_id'
- Return a dict that contains:
- 'id': VIM's classification ID (same as classification_id)
- 'name': VIM's classification name
- 'type': type of this classification
- 'definition': definition of the classification
- 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
- 'error_msg': (optional) text that explains the ERROR status
- other VIM specific fields: (optional) whenever possible
- Raises an exception upon error or when classification is not found
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def get_classification_list(self, filter_dict={}):
- """Obtain classifications from the VIM
- Params:
- 'filter_dict' (optional): contains the entries to filter the classifications on and only return those that
- match ALL:
- id: string => returns classifications with this VIM's classification ID, which implies a return of one
- classification at most
- name: string => returns only classifications with this name
- type: string => returns classifications of this type
- definition: string => returns classifications that have this definition
- tenant_id: string => returns only classifications that belong to this tenant/project
- Returns a list of classification dictionaries, each dictionary contains:
- 'id': (mandatory) VIM's classification ID
- 'name': (mandatory) VIM's classification name
- 'type': type of this classification
- 'definition': definition of the classification
- other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
- List can be empty if no classification matches the filter_dict. Raise an exception only upon VIM connectivity,
- authorization, or some other unspecific error
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def refresh_classifications_status(self, classification_list):
- """Get the status of the classifications
- Params: the list of classification identifiers
- Returns a dictionary with:
- vm_id: #VIM id of this classifier
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE,
- # CREATING (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
- """
- raise VimConnNotImplemented("Should have implemented this")
-
- def delete_classification(self, classification_id):
- """Deletes a classification from the VIM
- Returns the classification ID (classification_id) or raises an exception upon error or when classification is
- not found
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def new_sfi(self, name, ingress_ports, egress_ports, sfc_encap=True):
- """Creates a service function instance in the VIM
- Params:
- 'name': name of this service function instance
- 'ingress_ports': set of ingress ports (VIM's port IDs)
- 'egress_ports': set of egress ports (VIM's port IDs)
- 'sfc_encap': boolean stating whether this specific instance supports IETF SFC Encapsulation
- Returns the VIM's service function instance ID on success or raises an exception on failure
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def get_sfi(self, sfi_id):
- """Obtain service function instance details of the VIM's service function instance with ID='sfi_id'
- Return a dict that contains:
- 'id': VIM's sfi ID (same as sfi_id)
- 'name': VIM's sfi name
- 'ingress_ports': set of ingress ports (VIM's port IDs)
- 'egress_ports': set of egress ports (VIM's port IDs)
- 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
- 'error_msg': (optional) text that explains the ERROR status
- other VIM specific fields: (optional) whenever possible
- Raises an exception upon error or when service function instance is not found
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def get_sfi_list(self, filter_dict={}):
- """Obtain service function instances from the VIM
- Params:
- 'filter_dict' (optional): contains the entries to filter the sfis on and only return those that match ALL:
- id: string => returns sfis with this VIM's sfi ID, which implies a return of one sfi at most
- name: string => returns only service function instances with this name
- tenant_id: string => returns only service function instances that belong to this tenant/project
- Returns a list of service function instance dictionaries, each dictionary contains:
- 'id': (mandatory) VIM's sfi ID
- 'name': (mandatory) VIM's sfi name
- 'ingress_ports': set of ingress ports (VIM's port IDs)
- 'egress_ports': set of egress ports (VIM's port IDs)
- other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
- List can be empty if no sfi matches the filter_dict. Raise an exception only upon VIM connectivity,
- authorization, or some other unspecific error
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def delete_sfi(self, sfi_id):
- """Deletes a service function instance from the VIM
- Returns the service function instance ID (sfi_id) or raises an exception upon error or when sfi is not found
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def refresh_sfis_status(self, sfi_list):
- """Get the status of the service function instances
- Params: the list of sfi identifiers
- Returns a dictionary with:
- vm_id: #VIM id of this service function instance
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE,
- # CREATING (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
- """
- raise VimConnNotImplemented("Should have implemented this")
-
- def new_sf(self, name, sfis, sfc_encap=True):
- """Creates (an abstract) service function in the VIM
- Params:
- 'name': name of this service function
- 'sfis': set of service function instances of this (abstract) service function
- 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
- Returns the VIM's service function ID on success or raises an exception on failure
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def get_sf(self, sf_id):
- """Obtain service function details of the VIM's service function with ID='sf_id'
- Return a dict that contains:
- 'id': VIM's sf ID (same as sf_id)
- 'name': VIM's sf name
- 'sfis': VIM's sf's set of VIM's service function instance IDs
- 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
- 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
- 'error_msg': (optional) text that explains the ERROR status
- other VIM specific fields: (optional) whenever possible
- Raises an exception upon error or when sf is not found
- """
-
- def get_sf_list(self, filter_dict={}):
- """Obtain service functions from the VIM
- Params:
- 'filter_dict' (optional): contains the entries to filter the sfs on and only return those that match ALL:
- id: string => returns sfs with this VIM's sf ID, which implies a return of one sf at most
- name: string => returns only service functions with this name
- tenant_id: string => returns only service functions that belong to this tenant/project
- Returns a list of service function dictionaries, each dictionary contains:
- 'id': (mandatory) VIM's sf ID
- 'name': (mandatory) VIM's sf name
- 'sfis': VIM's sf's set of VIM's service function instance IDs
- 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
- other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
- List can be empty if no sf matches the filter_dict. Raise an exception only upon VIM connectivity,
- authorization, or some other unspecific error
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def delete_sf(self, sf_id):
- """Deletes (an abstract) service function from the VIM
- Returns the service function ID (sf_id) or raises an exception upon error or when sf is not found
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def refresh_sfs_status(self, sf_list):
- """Get the status of the service functions
- Params: the list of sf identifiers
- Returns a dictionary with:
- vm_id: #VIM id of this service function
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE,
- # CREATING (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
- """
- raise VimConnNotImplemented("Should have implemented this")
-
- def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None):
- """Creates a service function path
- Params:
- 'name': name of this service function path
- 'classifications': set of traffic classifications that should be matched on to get into this sfp
- 'sfs': list of every service function that constitutes this path , from first to last
- 'sfc_encap': whether this is an SFC-Encapsulated chain (i.e using NSH), True by default
- 'spi': (optional) the Service Function Path identifier (SPI: Service Path Identifier) for this path
- Returns the VIM's sfp ID on success or raises an exception on failure
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def get_sfp(self, sfp_id):
- """Obtain service function path details of the VIM's sfp with ID='sfp_id'
- Return a dict that contains:
- 'id': VIM's sfp ID (same as sfp_id)
- 'name': VIM's sfp name
- 'classifications': VIM's sfp's list of VIM's classification IDs
- 'sfs': VIM's sfp's list of VIM's service function IDs
- 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
- 'error_msg': (optional) text that explains the ERROR status
- other VIM specific fields: (optional) whenever possible
- Raises an exception upon error or when sfp is not found
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def get_sfp_list(self, filter_dict={}):
- """Obtain service function paths from VIM
- Params:
- 'filter_dict' (optional): contains the entries to filter the sfps on, and only return those that match ALL:
- id: string => returns sfps with this VIM's sfp ID , which implies a return of one sfp at most
- name: string => returns only sfps with this name
- tenant_id: string => returns only sfps that belong to this tenant/project
- Returns a list of service function path dictionaries, each dictionary contains:
- 'id': (mandatory) VIM's sfp ID
- 'name': (mandatory) VIM's sfp name
- 'classifications': VIM's sfp's list of VIM's classification IDs
- 'sfs': VIM's sfp's list of VIM's service function IDs
- other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
- List can be empty if no sfp matches the filter_dict. Raise an exception only upon VIM connectivity,
- authorization, or some other unspecific error
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
- def refresh_sfps_status(self, sfp_list):
- """Get the status of the service function path
- Params: the list of sfp identifiers
- Returns a dictionary with:
- vm_id: #VIM id of this service function path
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE,
- # CREATING (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)F
- """
- raise VimConnNotImplemented("Should have implemented this")
-
- def delete_sfp(self, sfp_id):
- """Deletes a service function path from the VIM
- Returns the sfp ID (sfp_id) or raises an exception upon error or when sf is not found
- """
- raise VimConnNotImplemented("SFC support not implemented")
-
def migrate_instance(self, vm_id, compute_host=None):
"""Migrate a vdu
Params:
flavor_id: flavor_id to resize the vdu to
"""
raise VimConnNotImplemented("Should have implemented this")
-
- # NOT USED METHODS in current version. Deprecated
- @deprecated
- def host_vim2gui(self, host, server_dict):
- """Transform host dictionary from VIM format to GUI format,
- and append to the server_dict
- """
- raise VimConnNotImplemented("Should have implemented this")
-
- @deprecated
- def get_hosts_info(self):
- """Get the information of deployed hosts
- Returns the hosts content"""
- raise VimConnNotImplemented("Should have implemented this")
-
- @deprecated
- def get_hosts(self, vim_tenant):
- """Get the hosts and deployed instances
- Returns the hosts content"""
- raise VimConnNotImplemented("Should have implemented this")
-
- @deprecated
- def get_processor_rankings(self):
- """Get the processor rankings in the VIM database"""
- raise VimConnNotImplemented("Should have implemented this")
-
- @deprecated
- def new_host(self, host_data):
- """Adds a new host to VIM"""
- """Returns status code of the VIM response"""
- raise VimConnNotImplemented("Should have implemented this")
-
- @deprecated
- def new_external_port(self, port_data):
- """Adds a external port to VIM"""
- """Returns the port identifier"""
- raise VimConnNotImplemented("Should have implemented this")
-
- @deprecated
- def new_external_network(self, net_name, net_type):
- """Adds a external network to VIM (shared)"""
- """Returns the network identifier"""
- raise VimConnNotImplemented("Should have implemented this")
-
- @deprecated
- def connect_port_network(self, port_id, network_id, admin=False):
- """Connects a external port to a network"""
- """Returns status code of the VIM response"""
- raise VimConnNotImplemented("Should have implemented this")
-
- @deprecated
- def new_vminstancefromJSON(self, vm_data):
- """Adds a VM instance to VIM"""
- """Returns the instance identifier"""
- raise VimConnNotImplemented("Should have implemented this")
--- /dev/null
+#######################################################################################
+# Copyright ETSI Contributors and Others.
+#
+# 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.
+#######################################################################################
+---
+other:
+ - |
+ Removing unused methods from RO module to get rid of unmaintained code.
projects / osm / RO.git / commitdiff