class VimAccount(object):
"""Description of VimAccount class"""
def __init__(self, token):
"""Constructor of VimAccount class"""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Get the list of the registered vim accounts in OSM r4
Returns:
obj: a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vim_account import VimAccount
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> vim_account = VimAccount(token)
>>> entries = vim_account.get_list()
>>> print(entries.json())
"""
endpoint = '{}/osm/admin/v1/vim_accounts'.format(
OSM_COMPONENTS.get('NBI-API'))
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
def get(self, vim_account_uuid=None):
"""Get details for a project in OSM r4 by given project ID
Args:
vim_account_uuid (str): The Vim Account UUID
Returns:
obj: a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vim_account import VimAccount
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> vim_account = VimAccount(token)
>>> entry = vim_account.get("66000170-7fe9-4ab0-b113-b60a92ee196c")
>>> print(entry.json())
"""
endpoint = '{}/osm/admin/v1/vim_accounts/{}'.format(
OSM_COMPONENTS.get('NBI-API'), vim_account_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
class User(object):
"""Description of User class"""
def __init__(self, token):
"""Constructor of User class"""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Get the list of the registered users in OSM r4
Returns:
obj: a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.user import User
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> user = User(token)
>>> response = user.get_list()
>>> print(response.json())
"""
endpoint = '{}/osm/admin/v1/users'.format(
OSM_COMPONENTS.get('NBI-API'))
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
def get(self, username=None):
"""Get details of a user in OSM r4 by given username
Returns:
obj: a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.user import User
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> user = User(token)
>>> response = user.get(username="******")
>>> print(response.json())
"""
endpoint = '{}/osm/admin/v1/users/{}'.format(
OSM_COMPONENTS.get('NBI-API'), username)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
class Project(object):
"""Description of Project class"""
def __init__(self, token):
"""Constructor of Project class"""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Get the list of the registered Projects in OSM r4
Returns:
obj: a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.project import Project
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> project = Project(token)
>>> entries = project.get_list()
>>> print(entries.json())
"""
endpoint = '{}/osm/admin/v1/projects'.format(
OSM_COMPONENTS.get('NBI-API'))
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
def get(self, project_id=None):
"""Get details for a project in OSM r4 by given project ID
Returns:
obj: a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.project import Project
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> project = Project(token)
>>> entry = project.get("admin")
>>> print(entry.json())
"""
endpoint = '{}/osm/admin/v1/projects/{}'.format(
OSM_COMPONENTS.get('NBI-API'), project_id)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
class QueryRange(object):
"""QueryRange Class.
Attributes:
bearer_token (str, optional): The Prometheus Authorization Token (if any)
Methods:
get(query, from_time, to_time, step): perform a query_range request in Prometheus API
"""
def __init__(self, token=None):
"""Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get(self, query, from_time, to_time, step=14):
""" Perform a query_range request in Prometheus API (PromQL)
Args:
query (str): The query
from_time (str): The start datetime
to_time (str): The end datetime
step (int): The used step in the query. Default value is 14 secs.
Returns:
object: A list of NSs as a requests object
"""
endpoint = 'http://{}:{}/api/v1/query_range'.format(
PROMETHEUS.get('HOST'), PROMETHEUS.get('PORT'))
headers = {"Accept": "application/json"}
endpoint += "?query={}&start={}&end={}&step={}".format(
query, from_time, to_time, step)
logger.debug("Prometheus web service: {}".format(endpoint))
response = self.__client.get(url=endpoint, headers=headers)
return response
class Vnfr(object):
"""Description of Vnfr class"""
def __init__(self, token):
"""Constructor of Vnfr class"""
self.__client = Client(verify_ssl_cert=False)
self.basic_token = token
def get_list(self):
"""Get the list of the VNF records from the SO-ub container
Returns:
obj: a requests object
Examples:
>>> from soapi.vnfr import Vnfr
>>> from soapi.identity import basic_token
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = basic_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> vnfr = Vnfr(token)
>>> vnfrs = vnfr.get_list()
>>> print(int(vnfrs.status_code))
200
"""
endpoint = '{}/v1/api/operational/project/default/vnfr-catalog/vnfr'.format(
OSM_COMPONENTS.get('SO-API'))
headers = {
"Authorization": "Basic {}".format(self.basic_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
class FaaS:
def __init__(self, osm_host):
"""Constructor
Args:
osm_host (str): the host of the OSM (and the FaaS API)
"""
self.__client = Client()
self.osm_host = "{}".format(osm_host)
self.faas_polling_host = self.osm_host
self.faas_polling_ip = '5001'
self.ns_instances = []
def set_ns_instances(self):
""" Fetch the NN instances in FaaS VIM
Returns:
list: the NS instances
"""
endpoint = 'http://{}:{}/osm/instances_all'.format(self.faas_polling_host,
self.faas_polling_ip)
request = self.__client.get(endpoint)
data = request.json()
self.ns_instances = data
def search_vnf(self, container_id):
""" Search information about a serverless VNF
Args:
container_id:
Returns:
dict: The NS uuid and name in RO and the vnf name (vnfd name plus vnf index)
"""
result = {'ro_ns_uuid': None, 'ns_name': None, 'vnf_name': None}
try:
for ns in self.ns_instances:
for vnf in ns['vnfs']:
vim_info = vnf.get('vim_info', {})
if 'vim-id' not in vim_info.keys():
# On-demand serverless VNFs
records = vim_info.get('records', [])
if len(records) == 0:
continue
for record in records:
if 'vim-id' in record.keys() and record['vim-id'] == container_id:
return {'ro_ns_uuid': ns['uuid'], 'ns_name': ns['name'],
'vnf_name': vnf['vnf_name']}
else:
# core serverless VNFs
vim_id = vim_info.get('vim-id', None)
if vim_id == container_id:
return {'ro_ns_uuid': ns['uuid'], 'ns_name': ns['name'],
'vnf_name': vnf['vnf_name']}
raise Exception('No match found for container with id {}'.format(container_id))
except Exception as ex:
return result
class Vim(object):
"""Description of Project class"""
def __init__(self, token):
"""Constructor of Project class"""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Get the list of the registered VIMs in OSM r4
Returns:
obj: a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vim import Vim
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> vim = Vim(token)
>>> entries = vim.get_list()
>>> print(entries.json())
"""
endpoint = '{}/osm/admin/v1/vim_accounts'.format(OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
return response
def get(self, vim_uuid=None):
"""Get details for a VIM in OSM r4 by given VIM UUID
Returns:
obj: a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vim import Vim
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> vim = Vim(token)
>>> vim_account = vim.get("41dab0c0-35f4-4c40-b1cd-13e4a79dab48")
>>> print(vim_account.json())
"""
endpoint = '{}/osm/admin/v1/vim_accounts/{}'.format(OSM_COMPONENTS.get('NBI-API'), vim_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
return response
class Instance(object):
""" Class for Instance API
See more: https://osm.etsi.org/wikipub/index.php/RO_Northbound_Interface#Instances
"""
def __init__(self):
self.__client = Client(verify_ssl_cert=True)
def get_list(self, openmano_tenant_id, headers=None, query_params=None):
"""Fetch the list of Openmano instances by given tenant ID
Args:
openmano_tenant_id (str): The tenant UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.instances import Instance
>>> obj = Instance()
>>> instances = obj.get_list('f35d06af-ed24-40ca-87c1-4e6ae81008b4')
>>> print(int(instances.status_code))
200
>>> print(instances.json())
Openmano cli:
$ openmano instance-scenario-list -a -d
"""
endpoint = '{}/{}/instances'.format(BASE_URL, openmano_tenant_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self,
openmano_tenant_id,
instance_id,
headers=None,
query_params=None):
"""Fetch details for an Openmano instance by given tenant ID and instance ID
Args:
openmano_tenant_id (str): The tenant UUID
instance_id (str): The instance UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.instances import Instance
>>> obj = Instance()
>>> instance = obj.get('f35d06af-ed24-40ca-87c1-4e6ae81008b4', '661d343f-740a-4a98-9e7b-bbfd31ff24ef')
>>> print(int(instance.status_code))
200
>>> print(instance.json())
Openmano cli:
$ openmano instance-scenario-list {instance_id} -d
"""
endpoint = '{}/{}/instances/{}'.format(BASE_URL, openmano_tenant_id,
instance_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
class NsLcmOperation(object):
"""NsLcmOperation Class.
Attributes:
bearer_token (str): The OSM Authorization Token
Args:
token (str): The OSM Authorization Token
"""
def __init__(self, token):
"""NS LCM Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Fetch the list of operations
Returns:
object: A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.operation import NsLcmOperation
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns_operation = NsLcmOperation(token)
>>> request = ns_operation.get_list()
>>> print(request.status_code)
200
"""
endpoint = '{}/osm/nslcm/v1/ns_lcm_op_occs'.format(
OSM_COMPONENTS.get('NBI-API'))
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json",
"Content-Type": "application/json"
}
response = self.__client.list(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self, operation_uuid=None):
"""Fetch details of a specific operation
Args:
operation_uuid (str): The UUID of the performed operation
Returns:
object: A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.operation import NsLcmOperation
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns_operation = NsLcmOperation(token)
>>> request = ns_operation.get(operation_uuid='7a1bd53e-af29-40d6-bbde-ee8be69ddc3e')
>>> print(request.status_code)
200
"""
endpoint = '{}/osm/nslcm/v1/ns_lcm_op_occs/{}'.format(
OSM_COMPONENTS.get('NBI-API'), operation_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json",
"Content-Type": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
class Nsr(object):
"""Description of Nsr class"""
def __init__(self, token):
"""Constructor of Nsr class"""
self.__client = Client(verify_ssl_cert=False)
self.basic_token = token
def get_list(self):
"""Get the list of the NS records from the SO-ub container
Returns:
obj: a requests object
Examples:
>>> from soapi.nsr import Nsr
>>> from soapi.identity import basic_token
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = basic_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Nsr(token)
>>> ns_records = ns.get_list()
>>> print(int(ns_records.status_code))
200
"""
endpoint = '{}/api/running/project/default/ns-instance-config'.format(
OSM_COMPONENTS.get('SO-API'))
headers = {
"Authorization": "Basic {}".format(self.basic_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
def get(self, ns_uuid):
"""Get details for a NS record from the SO-ub container
Args:
ns_uuid (str): The ID of the network service
Returns:
obj: a requests object
Examples:
>>> from soapi.nsr import Nsr
>>> from soapi.identity import basic_token
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = basic_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Nsr(token)
>>> ns_record = ns.get('xxx')
>>> print(int(ns_record.status_code))
200
"""
endpoint = '{}/api/operational/project/default/ns-instance-opdata/nsr/{}?deep'.format(
OSM_COMPONENTS.get('SO-API'), ns_uuid)
headers = {
"Authorization": "Basic {}".format(self.basic_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
return response
def instantiate(self,
ns_descriptor,
nsr_name,
vim_account_name,
admin_status="ENABLED"):
"""Instantiate a new NS based on NS descriptor and considering the given (by user) NS name and VIM name
Args:
ns_descriptor (dict): The NS descriptor
nsr_name (str): The NS name
vim_account_name (str): The VIM name
Returns:
obj: a requests object
Examples:
>>> from soapi.nsr import Nsr
>>> from soapi.identity import basic_token
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = basic_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Nsr(token)
>>> ns_descriptor = {"name": "cirros_2vnf_ns", "constituent-vnfd": [{"member-vnf-index": 1, "vnfd-id-ref": "cirros_vnfd", "start-by-default": "true"}, {"member-vnf-index": 2, "vnfd-id-ref": "cirros_vnfd", "start-by-default": "true"} ], "description": "Generated by OSM pacakage generator", "short-name": "cirros_2vnf_ns", "id": "cirros_2vnf_nsd", "version": "1.0", "vld": [{"name": "cirros_2vnf_nsd_vld1", "vnfd-connection-point-ref": [{"vnfd-connection-point-ref": "eth0", "vnfd-id-ref": "cirros_vnfd", "member-vnf-index-ref": 1 }, {"vnfd-connection-point-ref": "eth0", "vnfd-id-ref": "cirros_vnfd", "member-vnf-index-ref": 2 } ], "short-name": "cirros_2vnf_nsd_vld1", "mgmt-network": "true", "id": "cirros_2vnf_nsd_vld1", "type": "ELAN"} ], "logo": "osm_2x.png", "vendor": "OSM"}
>>> ns_instance = ns.instantiate(ns_descriptor, "cirros_2vnf_ns_test", "devstack-ocata")
>>> print(int(ns_instance.status_code))
>>> print(ns_instance.text)
"""
endpoint = '{}/api/config/project/default/ns-instance-config/nsr'.format(
OSM_COMPONENTS.get('SO-API'))
headers = {
"Authorization": "Basic {}".format(self.basic_token),
"Accept": "application/json",
"Content-Type": "application/json"
}
nsr_id = str(uuid.uuid1())
payload = {
"nsr": [{
"short-name": nsr_name,
"datacenter": vim_account_name,
"description": nsr_name,
"resource-orchestrator": "osmopenmano",
"nsd": ns_descriptor,
"admin-status": admin_status,
"id": nsr_id,
"name": nsr_name
}]
}
response = self.__client.post(endpoint,
headers=headers,
payload=json.dumps(payload))
return response
def terminate(self, ns_uuid):
"""Terminate a running NS
Args:
ns_uuid (str, uuid): The ID of the network service
Returns:
obj: a requests object
Examples:
>>> from soapi.nsr import Nsr
>>> from soapi.identity import basic_token
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = basic_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Nsr(token)
>>> ns_instance = ns.terminate("32798fec-b042-11e8-a05b-fa163e682738")
>>> print(ns_instance.status_code)
201
>>> print(ns_instance.text)
{"success":""}
"""
endpoint = '{}/api/config/project/default/ns-instance-config/nsr/{}'.format(
OSM_COMPONENTS.get('SO-API'), ns_uuid)
headers = {
"Authorization": "Basic {}".format(self.basic_token),
"Accept": "application/json"
}
response = self.__client.delete(endpoint, headers=headers)
return response
def scale(self, ns_uuid, scaling_group_id, index):
"""Scale a NS record by given NS ID and scaling group ID
Args:
ns_uuid (str): The ID of the network service
scaling_group_id (str): The ID of the scaling group as defined in the NS descriptor
index (str): The ID of the triggered vnf
Returns:
obj: a requests object
Examples:
>>> from soapi.nsr import Nsr
>>> from soapi.identity import basic_token
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = basic_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Nsr(token)
>>> scaled_ns = ns.scale('xxx', 'scaling-group-1', '2134')
>>> print(int(scaled_ns.status_code))
200
"""
endpoint = '{}/v1/api/config/project/default/ns-instance-config/nsr/{}/scaling-group/{}/instance'.format(
OSM_COMPONENTS.get('SO-API'), ns_uuid, scaling_group_id)
headers = {
"Authorization": "Basic {}".format(self.basic_token),
"Accept": "application/json",
"Content-Type": "application/json"
}
payload = json.dumps({"instance": [{"id": str(index)}]})
response = self.__client.post(endpoint, headers, payload)
return response
class Vnf(object):
"""VNF Class.
Attributes:
bearer_token (str): The OSM Authorization Token
Args:
token (str): The OSM Authorization Token
"""
def __init__(self, token):
"""NS LCM Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Fetch a list of all VNFs.
Returns:
object: A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vnf import Vnf
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> vnf = Vnf(token)
>>> response = vnf.get_list()
OSM Cli:
$ osm vnf-list
"""
endpoint = '{}/osm/nslcm/v1/vnf_instances'.format(OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_list_by_ns(self, ns_uuid=None):
"""Fetch list of VNFs for specific NS Instance.
Args:
ns_uuid (str): The UUID of the NS to fetch VNFs for.
Returns:
object: A requests object.
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vnf import Vnf
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> vnf = Vnf(token)
>>> response = vnf.get_list_by_ns(ns_uuid='a5f506e9-45c7-42fd-b12d-b5c657ed87fb')
"""
endpoint = '{}/osm/nslcm/v1/vnf_instances?nsr-id-ref={}'.format(OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get(self, vnf_uuid=None):
"""Fetch details of a specific VNF
Args:
vnf_uuid (str): The UUID of the VNF to fetch details for
Returns:
object: A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vnf import Vnf
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> vnf = Vnf(token)
>>> response = vnf.get(vnf_uuid='a5f506e9-45c7-42fd-b12d-b5c657ed87fb')
OSM Cli:
$ osm vnf-show a5f506e9-45c7-42fd-b12d-b5c657ed87fb
"""
endpoint = '{}/osm/nslcm/v1/vnf_instances/{}'.format(OSM_COMPONENTS.get('NBI-API'), vnf_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
class NsiLcm(object):
"""NSI LCM Class.
This class serves as a wrapper for the Network Slice Instance Lifecycle Management (NSILCM) part
of the Northbound Interface (NBI) offered by OSM. The methods defined in this class help
retrieve the NSI-related entities of OSM, and instantiate or terminate an NSI.
Attributes:
bearer_token (str): The OSM Authorization Token
Args:
token (str): The OSM Authorization Token
"""
def __init__(self, token):
"""NSI LCM Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_netslice_list(self):
"""Fetch a list of all Netslice Instances
Returns:
nsi_list_obj (Response): A list of Netslice Instances as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nsilcm import NsiLcm
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nsilcm = NsiLcm(token)
>>> nsi_list_obj = nsilcm.get_netslice_list()
OSM Cli:
$ osm nsi-list
"""
endpoint = '{}/osm/nsilcm/v1/netslice_instances'.format(settings.OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_netslice(self, nsi_uuid):
"""Fetch details of a specific Netslice Instance
Args:
nsi_uuid (str): The UUID of the NS to fetch details for
Returns:
nsi_obj (Response): A NS as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nsilcm import NsiLcm
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nsilcm = NsiLcm(token)
>>> nsi_obj = nsilcm.get_netslice('07048175-660b-404f-bbc9-5be7581e74de')
OSM Cli:
$ osm nsi-show 07048175-660b-404f-bbc9-5be7581e74de
"""
endpoint = '{}/osm/nsilcm/v1/netslice_instances/{}'.format(settings.OSM_COMPONENTS.get('NBI-API'), nsi_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
class Tenant(object):
""" Class for Tenant API
See more: https://osm.etsi.org/wikipub/index.php/RO_Northbound_Interface#Tenants
"""
def __init__(self):
self.__client = Client(verify_ssl_cert=True)
def get_list(self, headers=None, query_params=None):
"""Fetch the list of Openmano tenants
Args:
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.tenants import Tenant
>>> tn = Tenant()
>>> tenants = tn.get_list()
>>> print(int(tenants.status_code))
200
>>> print(tenants.json())
{"tenants": [{"created_at": "2018-05-03T16:00:04", "description": null, "uuid": "f35d06af-ed24-40ca-87c1-4e6ae81008b4", "name": "osm"} ] }
Openmano cli:
$ openmano tenant-list -d
"""
endpoint = '{}/tenants'.format(BASE_URL)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self, openmano_tenant_id, headers=None, query_params=None):
"""Fetch details for an Openmano tenant by given tenant ID
Args:
openmano_tenant_id (str): The tenant UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.tenants import Tenant
>>> tn = Tenant()
>>> tenant = tn.get('f35d06af-ed24-40ca-87c1-4e6ae81008b4')
>>> print(int(tenant.status_code))
200
>>> print(tenant.json())
Openmano cli:
$ openmano tenant-list {openmano_tenant_id} -d
"""
endpoint = '{}/tenants/{}'.format(BASE_URL, openmano_tenant_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
class OsmAdmin(object):
"""OSM Admin Class.
This class serves as a wrapper for the Admin part of the Northbound Interface (NBI) offered
by OSM. The methods defined in this class help to retrieve the administrative entities of OSM,
i.e. VIM accounts, users, projects, tokens and SDNs as lists or single objects.
Attributes:
bearer_token (str): The OSM Authorization Token
Args:
token (str): The OSM Authorization Token
"""
def __init__(self, token):
"""NsInstance Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_vim_list(self):
"""Fetch a list of all VIM accounts.
Returns:
vim_list_obj (Response): A list of VIMs as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> vim_list_obj = osm_admin.get_vim_list()
OSM Cli:
$ osm vim-list
"""
endpoint = '{}/osm/admin/v1/vim_accounts'.format(settings.OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_vim(self, vim_uuid):
"""Fetch details of a specific VIM account
Args:
vim_uuid (str): The UUID of the VIM to fetch
Returns:
vim_obj (Response): A VIM as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> vim_obj = osm_admin.get_vim('27183ec9-55f9-47b4-a850-fd0c528dc9fc')
OSM Cli:
$ osm vim-show 27183ec9-55f9-47b4-a850-fd0c528dc9fc
"""
endpoint = '{}/osm/admin/v1/vim_accounts/{}'.format(settings.OSM_COMPONENTS.get('NBI-API'), vim_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_user_list(self):
"""Fetch a list of all users
Returns:
user_list_obj (Response): A list of users as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> user_list_obj = osm_admin.get_user_list()
"""
endpoint = '{}/osm/admin/v1/users'.format(settings.OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_user(self, user_name):
"""Fetch details of a user
Args:
user_name (str) : The name of the user to fetch details for
Returns:
user_obj (Response): A user as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> user_obj = osm_admin.get_user('user5gmedia')
"""
endpoint = '{}/osm/admin/v1/users/{}'.format(settings.OSM_COMPONENTS.get('NBI-API'), user_name)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_project_list(self):
"""Fetch a list of all projects
Returns:
project_list_obj (Response): A list of projects as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> project_list_obj = osm_admin.get_project_list()
"""
endpoint = '{}/osm/admin/v1/projects'.format(settings.OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_project(self, project_name):
"""Fetch details of a specific project
Args:
project_name (str): The name of the project to fetch details for
Returns:
project_obj (Response): A project as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> project_obj = osm_admin.get_project('5gmedia')
"""
endpoint = '{}/osm/admin/v1/projects/{}'.format(settings.OSM_COMPONENTS.get('NBI-API'), project_name)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_token_list(self):
"""Fetch a list of all authorization tokens.
Returns:
token_list_obj (Response): A list of tokens as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> token_list_obj = osm_admin.get_token_list()
"""
endpoint = '{}/osm/admin/v1/tokens'.format(settings.OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_token(self, token):
"""Fetch details of a token.
Args:
token (str): An OSM authorization token
Returns:
token_list_obj (Response): A list of tokens as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> token_obj = osm_admin.get_token('HESHId7l6HHwURmLGm4hnuGxa6njLABE')
"""
endpoint = '{}/osm/admin/v1/tokens/{}'.format(settings.OSM_COMPONENTS.get('NBI-API'), token)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_sdn_list(self):
"""Fetch a list of all SDNs.
Returns:
sdn_list_obj (Response): A list of SDNs as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> sdn_list_obj = osm_admin.get_sdn_list()
OSM Cli:
$ osm sdnc-list
"""
endpoint = '{}/osm/admin/v1/sdns'.format(settings.OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_sdn(self, sdn_uuid):
"""Fetch details of a specific SDN.
Args:
sdn_uuid (str): The UUID of the SDN to fetch details for
Returns:
sdn_obj (Response): An SDN as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.osm_admin import OsmAdmin
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> osm_admin = OsmAdmin(token)
>>> sdn_obj = osm_admin.get_sdn('n1u9k3l1-55f9-47b4-a850-fd0c5780c9fc')
OSM Cli:
$ osm sdnc-show n1u9k3l1-55f9-47b4-a850-fd0c5780c9fc
"""
endpoint = '{}/osm/admin/v1/sdns/{}'.format(settings.OSM_COMPONENTS.get('NBI-API'), sdn_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
class AccountingClient(object):
"""Accounting Client Class.
This class serves as a wrapper for the Accounting/Billing services of 5G-MEDIA project,
as they are deployed in ENG's cloud. The methods implemented in this class are intended
for logging in to the services and opening/closing of NS, VNF and VDU sessions.
"""
__instance = None
def __init__(self):
"""Accounting Client Class Constructor."""
self.__client = Client(verify_ssl_cert=True)
self.__headers = {'Content-Type': 'application/json'}
self.login()
# Singleton Class
def __new__(cls):
if cls.__instance is not None:
return cls.__instance
else:
cls.__instance = super(AccountingClient, cls).__new__(cls)
return cls.__instance
def login(self):
"""Login to the Accounting/Billing Service."""
payload = {
'username': ACCOUNTING_USERNAME,
'password': ACCOUNTING_PASSWORD
}
response = self.__client.post(url=AUTH_URL,
headers=self.__headers,
payload=json.dumps(payload))
if response.status_code == HTTP_200_OK:
self.__headers['Authorization'] = 'Bearer {}'.format(
json.loads(response.text)['id_token'])
logger.info('Successfully logged on the accounting service')
def available_user_resource_list(self):
"""Get the available user resource list.
Returns:
user_resource_obj (object): A user resource list as a requests objects
"""
url = BASE_URL + '/availableUserResourceList'
response = self.__client.get(url=url, headers=self.__headers)
if response.status_code == HTTP_200_OK:
return response
return None
def open_session_retrial(self, url, payload):
"""Retry opening a session after the authorization token has expired.
Args:
url (str): The url for the session opening request
payload (dict): The essential data to post for session opening
Returns:
session_id (int): The ID of the session that was opened
"""
self.login()
response = self.__client.post(url=url,
headers=self.__headers,
payload=json.dumps(payload))
if response.status_code == HTTP_200_OK:
session_id = int(response.text)
logger.info('Opened session with id {}'.format(session_id))
return session_id
def open_ns_session(self, ns):
"""Open a Network Service (NS) Session.
Args:
ns (obj): An NS Instance object
Returns:
ns_session_id (int): The ID of the opened NS session
"""
url = BASE_URL + '/openNsSession'
payload = {
'timestamp_sec': time(),
'catalog_tenant': ns.catalog_tenant,
'catalog_user': ns.catalog_user,
'mano_id': ns.mano_id,
'mano_project': ns.mano_project,
'mano_user': ns.mano_user,
'nfvipop_id': ns.nfvipop_id,
'ns_id': ns.uuid,
'ns_name': ns.name
}
logger.info(
'Attempting to open ns session with payload {}'.format(payload))
response = self.__client.post(url=url,
headers=self.__headers,
payload=json.dumps(payload))
logger.debug('Open ns session response: {}, Status code: {}'.format(
response.text, response.status_code))
if response.status_code == HTTP_200_OK:
ns_session_id = int(response.text)
logger.info('Opened ns session with id {}'.format(ns_session_id))
return ns_session_id
elif response.status_code in [
HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
]:
logger.warning(
'Token has expired and open_ns_sesion failed; retrying')
return self.open_session_retrial(url, payload)
def open_vnf_session(self, ns_session_id, vnf_uuid, vnf_name):
"""Open a Virtual Network Function (VNF) Session.
Args:
ns_session_id (int): The id of the NS session where the VNF belongs
vnf_uuid (str): The UUID of the VNF
vnf_name (str): The name of the VNF
Returns:
vnf_session_id (int): The ID of the opened VNF session
"""
url = BASE_URL + '/openVnfSession'
payload = {
'timestamp_sec': time(),
'ns_session_id': ns_session_id,
'vnf_id': vnf_uuid,
'vnf_name': vnf_name
}
logger.info(
'Attempting to open vnf session with payload {}'.format(payload))
response = self.__client.post(url=url,
headers=self.__headers,
payload=json.dumps(payload))
logger.debug('Open vnf session response: {}, Status code: {}'.format(
response.text, response.status_code))
if response.status_code == HTTP_200_OK:
vnf_session_id = int(response.text)
logger.info('Opened vnf session with id {}'.format(vnf_session_id))
return vnf_session_id
elif response.status_code in [
HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
]:
logger.warning(
'Token has expired and open_vnf_sesion failed; retrying')
return self.open_session_retrial(url, payload)
def open_vdu_session(self, vnf_session_id, vdu):
"""Open a Virtual Deployment Unit (VDU) session.
Args:
vnf_session_id (int): The id of the VNF session where the VDU belongs.
vdu (obj): A VDU object
Returns:
vdu_session_id (int): The VDU session id.
"""
url = BASE_URL + '/openVduSession'
payload = {
'timestamp_sec': time(),
'flavorCpuCount': vdu.vcpu,
'flavorDiskGb': vdu.vdisk,
'flavorMemoryMb': vdu.vram,
'nfvipop_id': vdu.nfvipop_id,
'vdu_id': vdu.uuid,
'vdu_type':
'FAAS_VNF' if 'faas' in vdu.nfvipop_id.lower() else 'PLAIN_VNF',
'vnf_session_id': vnf_session_id
}
logger.info(
'Attempting to open vdu session with payload {}'.format(payload))
response = self.__client.post(url=url,
headers=self.__headers,
payload=json.dumps(payload))
logger.debug('Open vdu session response: {}, Status code: {}'.format(
response.text, response.status_code))
if response.status_code == HTTP_200_OK:
vdu_session_id = int(response.text)
logger.info('Opened vdu session with id {}'.format(vdu_session_id))
return vdu_session_id
elif response.status_code in [
HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
]:
logger.warning(
'Token has expired and open_vdu_sesion failed; retrying')
return self.open_session_retrial(url, payload)
def log_vdu_consumption(self, metric_type, metric_value, vdu_session_id):
"""Send measurement of VDU consumption for logging.
Args:
metric_type (str): The type of metric
metric_value (double): The value of metric
vdu_session_id (int): The id of the VDU session that the metric refers to
"""
url = BASE_URL + '/logVduConsumption'
payload = {
'timestamp': time(),
'consumption_type': metric_type,
'consumption_value': metric_value,
'vdu_session_id': vdu_session_id
}
logger.info('Sending vdu consumption with payload {}'.format(payload))
response = self.__client.post(url=url,
headers=self.__headers,
payload=json.dumps(payload))
logger.debug(
'Log vdu consumption response: {}, Status code: {}'.format(
response.text, response.status_code))
if response.status_code == HTTP_200_OK:
logger.info('Vdu consumption logged successfully')
return
elif response.status_code in [
HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
]:
logger.warning(
'Token has expired and log_vdu_consumption failed; retrying')
self.login()
response = self.__client.post(url=url,
headers=self.__headers,
payload=json.dumps(payload))
if response.status_code == HTTP_200_OK:
logger.info('Vdu consumption logged successfully')
return json.loads(response.text)['id']
def close_session_retrial(self, url, payload):
"""Retry closing a session after the authorization token has expired.
Args:
url (str): The url of the API call
payload (dict): The payload to send to the API call
"""
self.login()
response = self.__client.post(url=url,
headers=self.__headers,
payload=json.dumps(payload))
if response.status_code == HTTP_200_OK:
logger.warning('Session was closed')
return
return
def close_session(self, session_id, session_type):
"""Close a NS, VNF or VDU session.
Args:
session_id (int): The ID of the session
session_type (str): The type of the session
"""
url = BASE_URL + CLOSE_SESSIONS[session_type]
payload = {'id': session_id}
logger.info('Closing {} session with id {}'.format(
session_type, session_id))
response = self.__client.post(url=url,
headers=self.__headers,
payload=json.dumps(payload))
logger.debug('Close {} session response: {}, Status code: {}'.format(
session_type, response.text, response.status_code))
if response.status_code == HTTP_200_OK:
logger.info('Successfully closed {} session'.format(session_type))
return
elif response.status_code in [
HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
]:
logger.warning(
'Token has expired and close_session failed; retrying')
self.close_session_retrial(url, payload)
class Nsd(object):
"""NS Descriptor Class.
This class serves as a wrapper for the Network Service Descriptor (NSD) part
of the Northbound Interface (NBI) offered by OSM. The methods defined in this
class help retrieve the NSDs of OSM.
Attributes:
bearer_token (str): The OSM Authorization Token.
Args:
token (str): The OSM Authorization Token.
"""
def __init__(self, token):
"""NS Descriptor Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_nsd_list(self):
"""Fetch a list of all NS descriptors.
Returns:
nsd_list_obj (Response): A list of NSDs as a requests object.
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nsd import Nsd
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nsd = Nsd(token)
>>> nsd_list_obj = nsd.get_nsd_list()
OSM Cli:
$ osm nsd-list
"""
endpoint = '{}/osm/nsd/v1/ns_descriptors'.format(
settings.OSM_COMPONENTS.get('NBI-API'))
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
def get_nsd(self, nsd_uuid):
"""Fetch details of a specific NS descriptor.
Args:
nsd_uuid (str): The UUID of the NSD to fetch details for.
Returns:
nsd_obj (Response): A NSD as a requests object.
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nsd import Nsd
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nsd = Nsd(token)
>>> nsd_obj = nsd.get_nsd('9c4a8f58-8317-40a1-b9fe-1db18cff6965')
OSM Cli:
$ osm nsd-show cirros_2vnf_ns
"""
endpoint = '{}/osm/nsd/v1/ns_descriptors/{}'.format(
settings.OSM_COMPONENTS.get('NBI-API'), nsd_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
class Vim(object):
""" Class for VIMs API
See more: https://osm.etsi.org/wikipub/index.php/RO_Northbound_Interface#VIMs
"""
def __init__(self):
self.__client = Client(verify_ssl_cert=True)
def get_networks(self,
openmano_tenant_id,
datacenter_id,
headers=None,
query_params=None):
"""Fetch the list of VIM networks by given tenant ID and datacenter ID
Args:
openmano_tenant_id (str): The tenant UUID
datacenter_id (str): The tenant UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.vims import Vim
>>> vim = Vim()
>>> networks = vim.get_networks('f35d06af-ed24-40ca-87c1-4e6ae81008b4', '8e430688-4f7a-11e8-b3e2-00163edc3180')
>>> print(int(networks.status_code))
200
>>> print(networks.json())
Openmano cli:
$ openmano vim-net-list --datacenter {datacenter_id} -d
"""
endpoint = '{}/{}/vim/{}/networks'.format(BASE_URL, openmano_tenant_id,
datacenter_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
def get_network(self,
openmano_tenant_id,
datacenter_id,
vim_network_id,
headers=None,
query_params=None):
"""Fetch details for a VIM datacenter by given tenant ID, datacenter ID and VIM network ID
Args:
openmano_tenant_id (str): The tenant UUID
datacenter_id (str): The tenant UUID
vim_network_id (str): The VIM network UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.vims import Vim
>>> vim = Vim()
>>> network = vim.get_network('f35d06af-ed24-40ca-87c1-4e6ae81008b4', '8e430688-4f7a-11e8-b3e2-00163edc3180', 'deed712a-8a90-42a7-ba8c-98f4c116fca7')
>>> print(int(network.status_code))
200
>>> print(network.json())
Openmano cli:
$ openmano vim-net-list --datacenter {datacenter_id} {vim_network_id} -d
"""
endpoint = '{}/{}/vim/{}/networks/{}'.format(BASE_URL,
openmano_tenant_id,
datacenter_id,
vim_network_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
def get_tenants(self,
openmano_tenant_id,
datacenter_id,
headers=None,
query_params=None):
"""Fetch the list of VIM tenants (ie. admin, demo, alt_demo in devstack) by given openmano tenant ID and datacenter ID
Args:
openmano_tenant_id (str): The openmano tenant UUID
datacenter_id (str): The tenant UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.vims import Vim
>>> vim = Vim()
>>> network = vim.get_tenants('f35d06af-ed24-40ca-87c1-4e6ae81008b4', '8e430688-4f7a-11e8-b3e2-00163edc3180')
>>> print(int(network.status_code))
200
>>> print(network.json())
Openmano cli:
$ openmano vim-tenant-list --datacenter {datacenter_id} -d
"""
endpoint = '{}/{}/vim/{}/tenants'.format(BASE_URL, openmano_tenant_id,
datacenter_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
class Scenario(object):
""" Class for Scenario API
See more: https://osm.etsi.org/wikipub/index.php/RO_Northbound_Interface#GET_.2Fopenmano.2F.7Btenant_id.7D.2Fscenarios
"""
def __init__(self):
self.__client = Client(verify_ssl_cert=True)
def get_list(self, openmano_tenant_id, headers=None, query_params=None):
"""Fetch the list of Openmano scenarios by given tenant ID
Args:
openmano_tenant_id (str): The tenant UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.scenarios import Scenario
>>> sc = Scenario()
>>> scenarios = sc.get_list('f35d06af-ed24-40ca-87c1-4e6ae81008b4')
>>> print(int(scenarios.status_code))
200
>>> print(scenarios.json())
Openmano cli:
$ openmano scenario-list -a --debug
"""
endpoint = '{}/{}/scenarios'.format(BASE_URL, openmano_tenant_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self,
openmano_tenant_id,
scenario_id,
headers=None,
query_params=None):
"""Fetch details for an Openmano scenario by given tenant ID and scenario ID
Args:
openmano_tenant_id (str): The tenant UUID
scenario_id (str): The scenario UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.scenarios import Scenario
>>> sc = Scenario()
>>> scenario = sc.get('f35d06af-ed24-40ca-87c1-4e6ae81008b4', '577185b4-45dc-4a94-980a-72e1f0068022')
>>> print(int(scenario.status_code))
200
>>> print(scenario.json())
Openmano cli:
$ openmano scenario-list {scenario_id} --debug
"""
endpoint = '{}/{}/scenarios/{}'.format(BASE_URL, openmano_tenant_id,
scenario_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
class Datacenter(object):
""" Class for Datacenter API
See more: https://osm.etsi.org/wikipub/index.php/RO_Northbound_Interface#Datacenters
"""
def __init__(self):
self.__client = Client(verify_ssl_cert=True)
def get_list(self, openmano_tenant_id, headers=None, query_params=None):
"""Fetch the list of Openmano datacenter entities by given tenant ID
Args:
openmano_tenant_id (str): The tenant UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.datacenters import Datacenter
>>> dc = Datacenter()
>>> datacenters = dc.get_list('f35d06af-ed24-40ca-87c1-4e6ae81008b4')
>>> print(int(datacenters.status_code))
200
>>> print(datacenters.json())
{"datacenters": [{"vim_url": "http://192.168.1.194/identity/v2.0", "created_at": "2018-05-04T09:07:22", "type": "openstack", "uuid": "8e430688-4f7a-11e8-b3e2-00163edc3180", "name": "devstack-pike"} ] }
Openmano cli:
$ openmano datacenter-list -a --debug
"""
endpoint = '{}/{}/datacenters'.format(BASE_URL, openmano_tenant_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self,
openmano_tenant_id,
datacenter_id,
headers=None,
query_params=None):
"""Fetch details for an Openmano datacenter by given tenant ID and datacenter ID
Args:
openmano_tenant_id (str): The tenant UUID
datacenter_id (str): The datacenter UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.datacenters import Datacenter
>>> dc = Datacenter()
>>> datacenters = dc.get('f35d06af-ed24-40ca-87c1-4e6ae81008b4', '8e430688-4f7a-11e8-b3e2-00163edc3180')
>>> print(int(datacenters.status_code))
200
>>> print(datacenters.json())
Openmano cli:
$ openmano datacenter-list {datacenter_id} -d
"""
endpoint = '{}/{}/datacenters/{}'.format(BASE_URL, openmano_tenant_id,
datacenter_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
class Vnfd(object):
""" Class for VNF API
See more: https://osm.etsi.org/wikipub/index.php/RO_Northbound_Interface#VNFs
"""
def __init__(self):
self.__client = Client(verify_ssl_cert=True)
def get_list(self, openmano_tenant_id, headers=None, query_params=None):
"""Fetch the list of Openmano VNF descriptors by given tenant ID
Args:
openmano_tenant_id (str): The tenant UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.vnfds import Vnfd
>>> vnfd = Vnfd()
>>> vnfds = vnfd.get_list('f35d06af-ed24-40ca-87c1-4e6ae81008b4')
>>> print(int(vnfds.status_code))
200
>>> print(vnfds.json())
Openmano cli:
$ openmano vnf-list -a -d
"""
endpoint = '{}/{}/vnfs'.format(BASE_URL, openmano_tenant_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self,
openmano_tenant_id,
vnfd_id,
headers=None,
query_params=None):
"""Fetch details for an Openmano datacenter by given tenant ID and VNF descriptor ID
Args:
openmano_tenant_id (str): The tenant UUID
vnfd_id (str): The VNF descriptor UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.vnfds import Vnfd
>>> vnfd = Vnfd()
>>> vnfd_entity = vnfd.get('f35d06af-ed24-40ca-87c1-4e6ae81008b4', 'cfa284c1-a6de-48d4-ac10-1d943ee279c8')
>>> print(int(vnfd_entity.status_code))
200
>>> print(vnfd_entity.json())
Openmano cli:
$ openmano vnf-list {vnfd_id} -d
"""
endpoint = '{}/{}/vnfs/{}'.format(BASE_URL, openmano_tenant_id,
vnfd_id)
response = self.__client.get(endpoint,
headers=headers,
query_params=query_params)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers,
response.text))
return response
class Nsd(object):
"""Description of Nsd class"""
def __init__(self, token):
"""Constructor of Nsr class"""
self.__client = Client(verify_ssl_cert=False)
self.basic_token = token
def get_list(self):
"""Get the list of the NS descriptors from the SO-ub container
Returns:
obj: a requests object
Examples:
>>> from soapi.nsd import Nsd
>>> from soapi.identity import basic_token
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = basic_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> nsd = Nsd(token)
>>> nsd_records = nsd.get_list()
>>> print(int(nsd_records.status_code))
200
"""
endpoint = '{}/api/running/project/default/nsd-catalog/nsd'.format(OSM_COMPONENTS.get('SO-API'))
headers = {"Authorization": "Basic {}".format(self.basic_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
return response
def search(self, nsd_name):
"""Get the NS descriptor from the SO-ub container
Args:
nsd_name (str): The name of the network service's descriptor
Returns:
obj: a requests object
Examples:
>>> from soapi.nsd import Nsd
>>> from soapi.identity import basic_token
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = basic_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> nsd = Nsd(token)
>>> nsd_record = nsd.search('cirros_2vnf_ns')
>>> print(nsd_record)
Descriptor sample:
--
{
"name": "cirros_2vnf_ns",
"constituent-vnfd": [
{
"member-vnf-index": 1,
"vnfd-id-ref": "cirros_vnfd",
"start-by-default": "true"
},
{
"member-vnf-index": 2,
"vnfd-id-ref": "cirros_vnfd",
"start-by-default": "true"
}
],
"description": "Generated by OSM pacakage generator",
"short-name": "cirros_2vnf_ns",
"id": "cirros_2vnf_nsd",
"version": "1.0",
"vld": [
{
"name": "cirros_2vnf_nsd_vld1",
"vnfd-connection-point-ref": [
{
"vnfd-connection-point-ref": "eth0",
"vnfd-id-ref": "cirros_vnfd",
"member-vnf-index-ref": 1
},
{
"vnfd-connection-point-ref": "eth0",
"vnfd-id-ref": "cirros_vnfd",
"member-vnf-index-ref": 2
}
],
"short-name": "cirros_2vnf_nsd_vld1",
"mgmt-network": "true",
"id": "cirros_2vnf_nsd_vld1",
"type": "ELAN"
}
],
"logo": "osm_2x.png",
"vendor": "OSM"
}
"""
descriptor = {}
try:
# Get the list of NSDs
nsd_response = self.get_list()
nsd_records = nsd_response.json()
actual_records = nsd_records.get('project-nsd:nsd', [])
# Search for the NSD by given NSD name
for record in actual_records:
record_name = record.get("name", None)
if record_name is not None and record_name == nsd_name:
descriptor = record
break
except Exception as e:
logger.exception(e)
finally:
return descriptor
class NetworkServicePolling:
def __init__(self, osm_host, osm_faas_host, osm_faas_port, ns_name):
""" Initialize the object
Args:
osm_host (str): The OSM host
osm_faas_host (str): The FaaS VIM host (normally it is the same with OSM host)
osm_faas_port (str): The FaaS VIM port
ns_name (str): The NS name
"""
self.__client = Client()
self.osm_host = osm_host
self.faas_polling_host = osm_faas_host
self.faas_polling_ip = osm_faas_port
self.bootstrap_ingress_url = None
self.ns_name = ns_name
def get_vnfs_info(self):
""" Get information about the involved VNFs
Returns:
dict:
Response Example:
[
{
"vnf_name": "vcdn_bootstrap_vnfd.1",
"status": "ACTIVE",
"records": 0,
"ip_address": "0.0.0.0"
},
{
"vnf_name": "vcache_vnfd.2",
"status": "ACTIVE",
"records": 2,
"ip_address": "0.0.0.0"
},
{
"vnf_name": "vCache_mid_UC3_5GMEDIA.3",
"status": "ACTIVE",
"records": 0,
"ip_address": "192.168.111.19"
},
{
"vnf_name": "vCache_edge_UC3_5GMEDIA.4",
"status": "ACTIVE",
"records": 0,
"ip_address": "192.168.111.27"
}
]
"""
vnfs_list = []
endpoint = 'http://{}:{}/osm/{}'.format(self.faas_polling_host, self.faas_polling_ip,
self.ns_name)
request = self.__client.get(endpoint)
response_status = request.status_code
data = request.json()
for vnf in data['vnfs']:
vnf_name = vnf.get('vnf_name', None)
ip_address = vnf.get('ip_address', None)
status = vnf.get('status', None)
vim_info = vnf.get('vim_info', {})
records = 0
if 'records' in vim_info.keys():
records = len(vim_info['records'])
vnf_entry = {'vnf_name': vnf_name, 'ip_address': ip_address, 'status': status,
'records': records}
vnfs_list.append(vnf_entry)
return vnfs_list
def get_bootstrap_ingress_url(self):
""" Get the Ingress Url of the bootstrap serverless VNF
Returns:
str: the Ingress Url of the bootstrap serverless VNF
"""
bootstrap_ingress_url = None
endpoint = 'http://{}:{}/osm/{}'.format(self.faas_polling_host, self.faas_polling_ip,
self.ns_name)
request = self.__client.get(endpoint)
response_status = request.status_code
data = request.json()
if response_status != 200:
return bootstrap_ingress_url
for vnf in data['vnfs']:
ingress_url = vnf.get('vim_info', {}).get('IngressUrl', None)
if ingress_url is not None:
bootstrap_ingress_url = ingress_url
break
return bootstrap_ingress_url
def set_bootstrap_ingress_url(self, bootstrap_ingress_url):
"""
Set the Ingress Url of the bootstrap serverless VNF
"""
self.bootstrap_ingress_url = bootstrap_ingress_url
class NsLcm(object):
"""NS LCM Class.
This class serves as a wrapper for the Network Service Lifecycle Management (NSLCM) part
of the Northbound Interface (NBI) offered by OSM. The methods defined in this class help
retrieve the NS-related entities of OSM, i.e. NS and VNFs or terminate an NS instance.
Attributes:
bearer_token (str): The OSM Authorization Token
Args:
token (str): The OSM Authorization Token
"""
def __init__(self, token):
"""NS LCM Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_ns_list(self):
"""Fetch a list of all NS Instances
Returns:
ns_list_obj (Response): A list of NSs as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nslcm import NsLcm
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nslcm = NsLcm(token)
>>> ns_list_obj = nslcm.get_ns_list()
OSM Cli:
$ osm ns-list
"""
endpoint = '{}/osm/nslcm/v1/ns_instances'.format(settings.OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_ns(self, ns_uuid):
"""Fetch details of a specific NS Instance
Args:
ns_uuid (str): The UUID of the NS to fetch details for
Returns:
ns_obj (Response): A NS as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nslcm import NsLcm
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nslcm = NsLcm(token)
>>> ns_obj = nslcm.get_ns('07048175-660b-404f-bbc9-5be7581e74de')
OSM Cli:
$ osm ns-show 07048175-660b-404f-bbc9-5be7581e74de
"""
endpoint = '{}/osm/nslcm/v1/ns_instances/{}'.format(settings.OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def terminate_ns(self, ns_uuid):
"""Terminate a NS Instance.
Args:
ns_uuid (str): The UUID of the NS to terminate
Returns:
response (Response): A requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nslcm import NsLcm
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nslcm = NsLcm(token)
>>> response = nslcm.terminate_ns('07048175-660b-404f-bbc9-5be7581e74de')
"""
endpoint = '{}/osm/nslcm/v1/ns_instances/{}/terminate'.format(settings.OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.post(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_vnf_list(self):
"""Fetch a list of all VNFs.
Returns:
vnf_list_obj (Response): A list of VNFs as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nslcm import NsLcm
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nslcm = NsLcm(token)
>>> vnf_list_obj = nslcm.get_vnf_list()
OSM Cli:
$ osm vnf-list
"""
endpoint = '{}/osm/nslcm/v1/vnf_instances'.format(settings.OSM_COMPONENTS.get('NBI-API'))
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_vnf(self, vnf_uuid):
"""Fetch details of a specific VNF
Args:
vnf_uuid (str): The UUID of the VNF to fetch details for
Returns:
vnf_obj (Response): A VNF as a requests object
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nslcm import NsLcm
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nslcm = NsLcm(token)
>>> vnf_obj = nslcm.get_vnf('a5f506e9-45c7-42fd-b12d-b5c657ed87fb')
OSM Cli:
$ osm vnf-show a5f506e9-45c7-42fd-b12d-b5c657ed87fb
"""
endpoint = '{}/osm/nslcm/v1/vnf_instances/{}'.format(settings.OSM_COMPONENTS.get('NBI-API'), vnf_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
def get_vnf_list_by_ns(self, ns_uuid):
"""Fetch list of VNFs for specific NS Instance.
Args:
ns_uuid (str): The UUID of the NS to fetch VNFs for.
Returns:
vnf_list_obj (Response): A list of VNFs as a requests object.
Examples:
>>> from django.conf import settings
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.nslcm import NsLcm
>>> token = bearer_token(settings.OSM_ADMIN_CREDENTIALS.get('username'), settings.OSM_ADMIN_CREDENTIALS.get('password'))
>>> nslcm = NsLcm(token)
>>> vnf_list_obj = nslcm.get_vnf('a5f506e9-45c7-42fd-b12d-b5c657ed87fb')
"""
endpoint = '{}/osm/nslcm/v1/vnf_instances?nsr-id-ref={}'.format(settings.OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {"Authorization": "Bearer {}".format(self.bearer_token), "Accept": "application/json"}
response = self.__client.get(endpoint, headers)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers, response.text))
return response
class Action(object):
""" Class for Action API
"""
def __init__(self):
self.__client = Client(verify_ssl_cert=True)
def get_any(self, tenant_id, headers=None, query_params=None):
"""Fetch the list of actions for an instance by given tenant ID
Args:
tenant_id (str): The tenant UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.actions import Action
>>> obj = Action()
>>> actions = obj.get_any('f35d06af-ed24-40ca-87c1-4e6ae81008b4')
>>> print(int(actions.status_code))
200
>>> print(actions.json())
Openmano cli:
$ openmano action-list --all ALL --debug
"""
endpoint = '{}/{}/instances/any/action'.format(BASE_URL, tenant_id)
response = self.__client.get(endpoint, headers=headers, query_params=query_params)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers, response.text))
return response
def get_list(self, tenant_id, instance_id, headers=None, query_params=None):
"""Fetch the list of actions by given tenant ID and instance ID
Args:
tenant_id (str): The tenant UUID
instance_id (str): The instance UUID
headers (dict, optional): the required HTTP headers, e.g., Accept: application/json
query_params (dict, optional): Additional arguments will be passed to the request.
Returns:
obj: a requests object
Examples:
>>> from httpclient.client import Client
>>> from openmanoapi.actions import Action
>>> obj = Action()
>>> actions = obj.get_list('f35d06af-ed24-40ca-87c1-4e6ae81008b4', '22bbb91d-51a6-43ba-9850-d9697915921b')
>>> print(int(actions.status_code))
200
>>> print(actions.json())
Openmano cli:
$ openmano action-list --instance {instance_id} --debug
"""
endpoint = '{}/{}/instances/{}/action'.format(BASE_URL, tenant_id, instance_id)
response = self.__client.get(endpoint, headers=headers, query_params=query_params)
logger.debug("Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
"".format(response.url, response.status_code, response.headers, response.text))
return response
class Ns(object):
"""NS Class.
Attributes:
bearer_token (str): The OSM Authorization Token
Args:
token (str): The OSM Authorization Token
"""
def __init__(self, token):
"""NS LCM Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Fetch a list of all NS Instances
Returns:
object: A list of NSs as a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.ns import Ns
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Ns(token)
>>> response = ns.get_list()
>>> print(response.json())
OSM Cli:
$ osm ns-list
"""
endpoint = '{}/osm/nslcm/v1/ns_instances'.format(
OSM_COMPONENTS.get('NBI-API'))
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self, ns_uuid=None):
"""Fetch details of a specific NS Instance
Args:
ns_uuid (str): The UUID of the NS to fetch details for
Returns:
object: A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.ns import Ns
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Ns(token)
>>> response = ns.get(ns_uuid='07048175-660b-404f-bbc9-5be7581e74de')
OSM Cli:
$ osm ns-show 07048175-660b-404f-bbc9-5be7581e74de
"""
endpoint = '{}/osm/nslcm/v1/ns_instances/{}'.format(
OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
def scale_vnf(self,
ns_uuid,
vnf_index,
scaling_group_name,
scale_out=True):
""" Scale in or out in VNF level
Args:
ns_uuid (str): The NS uuid
vnf_index (int): The VNF index to be scaled
scaling_group_name (str): The name in the VNF scaling_group_descriptor
scale_out (bool): Decide scale in or out action. By default, scale out is performed.
Returns:
object: A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.ns import Ns
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Ns(token)
>>> response = ns.scale_vnf(ns_uuid="199b1fcd-eb32-4c6f-b149-34410acc2a32", vnf_index=2, scaling_group_name="scale_by_one", scale_out=False)
# >>> response = ns.scale_vnf(ns_uuid="199b1fcd-eb32-4c6f-b149-34410acc2a32", vnf_index=2, scaling_group_name="scale_by_one", scale_out=False)
OSM Cli:
$ osm vnf-scale <ns_uuid> <vnf_index> --scale-in # scale in
Scaling group: <scaling_group_name>
$ osm vnf-scale <ns_uuid> <vnf_index> --scale-out # scale out (default)
Scaling group: <scaling_group_name>
"""
endpoint = '{}/osm/nslcm/v1/ns_instances/{}/scale'.format(
OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
# Set value based on scale action
scale_action = "SCALE_IN"
if scale_out:
scale_action = "SCALE_OUT"
payload = {
"scaleVnfData": {
"scaleVnfType": scale_action,
"scaleByStepData": {
"member-vnf-index": str(vnf_index),
"scaling-group-descriptor": str(scaling_group_name)
}
},
"scaleType": "SCALE_VNF"
}
response = self.__client.post(endpoint,
headers,
payload=json.dumps(payload))
logger.debug(
"Request `POST {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
def terminate(self, ns_uuid=None):
"""Terminate a NS Instance.
Args:
ns_uuid (str): The UUID of the NS to terminate
Returns:
response (object): A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.ns import Ns
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Ns(token)
>>> response = ns.terminate(ns_uuid='07048175-660b-404f-bbc9-5be7581e74de')
"""
endpoint = '{}/osm/nslcm/v1/ns_instances/{}/terminate'.format(
OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.post(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
class Vnfd(object):
"""VNF Descriptor Class.
This class serves as a wrapper for the Virtual Network Function Descriptor (VNFD)
part of the Northbound Interface (NBI) offered by OSM. The methods defined in this
class help retrieve the VNFDs of OSM.
Attributes:
bearer_token (str): The OSM Authorization Token.
Args:
token (str): The OSM Authorization Token.
"""
def __init__(self, token):
"""VNF Descriptor Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Fetch a list of the VNF descriptors.
Returns:
object: A requests object that includes the list of VNFDs
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vnfd import Vnfd
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('password'))
>>> vnfd = Vnfd(token)
>>> response = vnfd.get_list()
OSM Cli:
$ osm vnfd-list
"""
endpoint = '{}/osm/vnfpkgm/v1/vnf_packages'.format(
OSM_COMPONENTS.get('NBI-API'))
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self, vnfd_uuid=None):
"""Fetch details of a specific VNF descriptor.
Args:
vnfd_uuid (str): The UUID of the VNFD to fetch details for.
Returns:
object: A requests object.
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.vnfd import Vnfd
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('password'))
>>> vnfd = Vnfd(token)
>>> response = vnfd.get(vnfd_uuid='89f66f1b-73b5-4dc1-8226-a473a2615627')
OSM Cli:
$ osm vnfd-show cirros_vnf
"""
endpoint = '{}/osm/vnfpkgm/v1/vnf_packages/{}'.format(
OSM_COMPONENTS.get('NBI-API'), vnfd_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
class Ns(object):
"""NS Class.
Attributes:
bearer_token (str): The OSM Authorization Token
Args:
token (str): The OSM Authorization Token
"""
def __init__(self, token):
"""NS LCM Class Constructor."""
self.__client = Client(verify_ssl_cert=False)
self.bearer_token = token
def get_list(self):
"""Fetch a list of all NS Instances
Returns:
object: A list of NSs as a requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.ns import Ns
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Ns(token)
>>> response = ns.get_list()
>>> print(response.json())
OSM Cli:
$ osm ns-list
"""
endpoint = '{}/osm/nslcm/v1/ns_instances'.format(
OSM_COMPONENTS.get('NBI-API'))
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
def get(self, ns_uuid=None):
"""Fetch details of a specific NS Instance
Args:
ns_uuid (str): The UUID of the NS to fetch details for
Returns:
object: A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.ns import Ns
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Ns(token)
>>> response = ns.get(ns_uuid='07048175-660b-404f-bbc9-5be7581e74de')
OSM Cli:
$ osm ns-show 07048175-660b-404f-bbc9-5be7581e74de
"""
endpoint = '{}/osm/nslcm/v1/ns_instances/{}'.format(
OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.get(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
def terminate(self, ns_uuid=None):
"""Terminate a NS Instance.
Args:
ns_uuid (str): The UUID of the NS to terminate
Returns:
response (object): A requests object
Examples:
>>> from nbiapi.identity import bearer_token
>>> from nbiapi.ns import Ns
>>> from settings import OSM_ADMIN_CREDENTIALS
>>> token = bearer_token(OSM_ADMIN_CREDENTIALS.get('username'), OSM_ADMIN_CREDENTIALS.get('username'))
>>> ns = Ns(token)
>>> response = ns.terminate(ns_uuid='07048175-660b-404f-bbc9-5be7581e74de')
"""
endpoint = '{}/osm/nslcm/v1/ns_instances/{}/terminate'.format(
OSM_COMPONENTS.get('NBI-API'), ns_uuid)
headers = {
"Authorization": "Bearer {}".format(self.bearer_token),
"Accept": "application/json"
}
response = self.__client.post(endpoint, headers)
logger.debug(
"Request `GET {}` returns HTTP status `{}`, headers `{}` and body `{}`."
.format(response.url, response.status_code, response.headers,
response.text))
return response
