ea4eb40758
This patch bumps the hacking version to 7.0.0 and fix the pep8 error: - AttributeError: 'EntryPoints' object has no attribute 'get' Closes-Bug: #2088356 Change-Id: Idb35decd157d19618b062d05951743083c04c32b
1052 lines
39 KiB
Python
1052 lines
39 KiB
Python
# Copyright 2012 OpenStack Foundation.
|
|
# Copyright 2015 Hewlett-Packard Development Company, L.P.
|
|
# All Rights Reserved
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
|
|
import logging
|
|
import re
|
|
import time
|
|
|
|
import requests
|
|
from urllib import parse as urlparse
|
|
|
|
from tackerclient import client
|
|
from tackerclient.common import exceptions
|
|
from tackerclient.common import serializer
|
|
from tackerclient.common import utils
|
|
from tackerclient.i18n import _
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
DEFAULT_DESC_LENGTH = 25
|
|
DEFAULT_ERROR_REASON_LENGTH = 100
|
|
STATUS_CODE_MAP = {
|
|
400: "badRequest",
|
|
401: "unauthorized",
|
|
403: "forbidden",
|
|
404: "itemNotFound",
|
|
405: "badMethod",
|
|
409: "conflictingRequest",
|
|
413: "overLimit",
|
|
415: "badMediaType",
|
|
429: "overLimit",
|
|
501: "notImplemented",
|
|
503: "serviceUnavailable"}
|
|
|
|
|
|
def exception_handler_v10(status_code, error_content):
|
|
"""Exception handler for API v1.0 client.
|
|
|
|
This routine generates the appropriate Tacker exception according to
|
|
the contents of the response body.
|
|
|
|
:param status_code: HTTP error status code
|
|
:param error_content: deserialized body of error response
|
|
"""
|
|
etsi_error_content = error_content
|
|
error_dict = None
|
|
if isinstance(error_content, dict):
|
|
error_dict = error_content.get('TackerError')
|
|
if not error_dict:
|
|
error_content = error_content.get(STATUS_CODE_MAP.get(status_code),
|
|
'tackerFault')
|
|
# Find real error type
|
|
bad_tacker_error_flag = False
|
|
if error_dict:
|
|
# If Tacker key is found, it will definitely contain
|
|
# a 'message' and 'type' keys?
|
|
try:
|
|
error_type = error_dict['type']
|
|
error_message = error_dict['message']
|
|
if error_dict['detail']:
|
|
error_message += "\n" + error_dict['detail']
|
|
except Exception:
|
|
bad_tacker_error_flag = True
|
|
if not bad_tacker_error_flag:
|
|
# If corresponding exception is defined, use it.
|
|
client_exc = getattr(exceptions, '%sClient' % error_type, None)
|
|
# Otherwise look up per status-code client exception
|
|
if not client_exc:
|
|
client_exc = exceptions.HTTP_EXCEPTION_MAP.get(status_code)
|
|
if client_exc:
|
|
raise client_exc(message=error_message,
|
|
status_code=status_code)
|
|
else:
|
|
raise exceptions.TackerClientException(
|
|
status_code=status_code, message=error_message)
|
|
else:
|
|
raise exceptions.TackerClientException(status_code=status_code,
|
|
message=error_dict)
|
|
else:
|
|
message = None
|
|
if isinstance(error_content, dict):
|
|
message = error_content.get('message')
|
|
if message:
|
|
raise exceptions.TackerClientException(status_code=status_code,
|
|
message=message)
|
|
# ETSI error response
|
|
if isinstance(etsi_error_content, dict):
|
|
if etsi_error_content.get('status') and \
|
|
etsi_error_content.get('detail'):
|
|
message = etsi_error_content.get('detail')
|
|
raise exceptions.TackerClientException(status_code=status_code,
|
|
message=message)
|
|
|
|
# If we end up here the exception was not a tacker error
|
|
msg = "%s-%s" % (status_code, error_content)
|
|
raise exceptions.TackerClientException(status_code=status_code,
|
|
message=msg)
|
|
|
|
|
|
class APIParamsCall(object):
|
|
"""A Decorator to support formating and tenant overriding and filters."""
|
|
|
|
def __init__(self, function):
|
|
self.function = function
|
|
|
|
def __get__(self, instance, owner):
|
|
def with_params(*args, **kwargs):
|
|
_format = instance.format
|
|
if 'format' in kwargs:
|
|
instance.format = kwargs['format']
|
|
ret = self.function(instance, *args, **kwargs)
|
|
instance.format = _format
|
|
return ret
|
|
return with_params
|
|
|
|
|
|
class ClientBase(object):
|
|
"""Client for the OpenStack Tacker v1.0 API.
|
|
|
|
:param string username: Username for authentication. (optional)
|
|
:param string user_id: User ID for authentication. (optional)
|
|
:param string password: Password for authentication. (optional)
|
|
:param string token: Token for authentication. (optional)
|
|
:param string tenant_name: Tenant name. (optional)
|
|
:param string tenant_id: Tenant id. (optional)
|
|
:param string auth_strategy: 'keystone' by default, 'noauth' for no
|
|
authentication against keystone. (optional)
|
|
:param string auth_url: Keystone service endpoint for authorization.
|
|
:param string service_type: Network service type to pull from the
|
|
keystone catalog (e.g. 'network') (optional)
|
|
:param string endpoint_type: Network service endpoint type to pull from the
|
|
keystone catalog (e.g. 'publicURL',
|
|
'internalURL', or 'adminURL') (optional)
|
|
:param string region_name: Name of a region to select when choosing an
|
|
endpoint from the service catalog.
|
|
:param string endpoint_url: A user-supplied endpoint URL for the tacker
|
|
service. Lazy-authentication is possible for API
|
|
service calls if endpoint is set at
|
|
instantiation.(optional)
|
|
:param integer timeout: Allows customization of the timeout for client
|
|
http requests. (optional)
|
|
:param bool insecure: SSL certificate validation. (optional)
|
|
:param bool log_credentials: Allow for logging of passwords or not.
|
|
Defaults to False. (optional)
|
|
:param string ca_cert: SSL CA bundle file to use. (optional)
|
|
:param integer retries: How many times idempotent (GET, PUT, DELETE)
|
|
requests to Tacker server should be retried if
|
|
they fail (default: 0).
|
|
:param bool raise_errors: If True then exceptions caused by connection
|
|
failure are propagated to the caller.
|
|
(default: True)
|
|
:param session: Keystone client auth session to use. (optional)
|
|
:param auth: Keystone auth plugin to use. (optional)
|
|
|
|
"""
|
|
|
|
# API has no way to report plurals, so we have to hard code them
|
|
# This variable should be overridden by a child class.
|
|
EXTED_PLURALS = {}
|
|
|
|
def __init__(self, **kwargs):
|
|
"""Initialize a new client for the Tacker v1.0 API."""
|
|
super(ClientBase, self).__init__()
|
|
self.retries = kwargs.pop('retries', 0)
|
|
self.raise_errors = kwargs.pop('raise_errors', True)
|
|
self.httpclient = client.construct_http_client(**kwargs)
|
|
self.version = '1.0'
|
|
self.format = 'json'
|
|
self.action_prefix = "/v%s" % (self.version)
|
|
self.retry_interval = 1
|
|
self.rel = None
|
|
self.params = None
|
|
self.accept = None
|
|
|
|
def _handle_fault_response(self, status_code, response_body):
|
|
# Create exception with HTTP status code and message
|
|
_logger.debug("Error message: %s", response_body)
|
|
# Add deserialized error message to exception arguments
|
|
try:
|
|
des_error_body = self.deserialize(response_body, status_code)
|
|
except Exception:
|
|
# If unable to deserialized body it is probably not a
|
|
# Tacker error
|
|
des_error_body = {'message': response_body}
|
|
# Raise the appropriate exception
|
|
exception_handler_v10(status_code, des_error_body)
|
|
|
|
def build_action(self, action):
|
|
action += ".%s" % self.format
|
|
action = self.action_prefix + action
|
|
return action
|
|
|
|
def _build_params_query(self, params=None):
|
|
flag_params = []
|
|
keyval_params = {}
|
|
for key, value in params.items():
|
|
if value is None:
|
|
flag_params.append(key)
|
|
else:
|
|
keyval_params[key] = value
|
|
|
|
flags_encoded = utils.safe_encode_list(flag_params) \
|
|
if flag_params else ""
|
|
keyval_encoded = utils.safe_encode_dict(keyval_params) \
|
|
if keyval_params else ""
|
|
|
|
query = ""
|
|
for flag in flags_encoded:
|
|
query = query + urlparse.quote_plus(flag) + '&'
|
|
query = query + urlparse.urlencode(keyval_encoded, doseq=1)
|
|
return query.strip('&')
|
|
|
|
def do_request(self, method, action, body=None, headers=None, params=None):
|
|
action = self.build_action(action)
|
|
# Add format and tenant_id
|
|
if type(params) is dict and params:
|
|
query = self._build_params_query(params)
|
|
action += '?' + query
|
|
|
|
if body or body == {}:
|
|
body = self.serialize(body)
|
|
|
|
if headers is None:
|
|
# self.httpclient.do_request is not accept 'headers=None'.
|
|
headers = {}
|
|
|
|
resp, replybody = self.httpclient.do_request(
|
|
action, method, body=body, headers=headers,
|
|
content_type=self.content_type(), accept=self.accept)
|
|
|
|
if 'application/zip' == resp.headers.get('Content-Type'):
|
|
self.format = 'zip'
|
|
elif 'text/plain' == resp.headers.get('Content-Type'):
|
|
self.format = 'text'
|
|
elif 'artifacts' in action:
|
|
self.format = 'any'
|
|
else:
|
|
self.format = 'json'
|
|
|
|
url = None
|
|
rel = None
|
|
|
|
link = resp.headers.get('Link', None)
|
|
if link is not None:
|
|
url = re.findall('<(.*)>', link)[0]
|
|
rel = re.findall('rel="(.*)"', link)[0]
|
|
|
|
if rel == 'next':
|
|
self.rel = 'next'
|
|
query_str = urlparse.urlparse(url).query
|
|
self.params = urlparse.parse_qs(query_str)
|
|
|
|
status_code = resp.status_code
|
|
if status_code in (requests.codes.ok,
|
|
requests.codes.created,
|
|
requests.codes.accepted,
|
|
requests.codes.no_content):
|
|
return self.deserialize(replybody, status_code)
|
|
else:
|
|
if not replybody:
|
|
replybody = resp.reason
|
|
self._handle_fault_response(status_code, replybody)
|
|
|
|
def get_auth_info(self):
|
|
return self.httpclient.get_auth_info()
|
|
|
|
def serialize(self, data):
|
|
"""Serializes a dictionary JSON.
|
|
|
|
A dictionary with a single key can be passed and it can contain any
|
|
structure.
|
|
"""
|
|
if data is None:
|
|
return None
|
|
elif self.format in ('zip', 'text'):
|
|
return data
|
|
elif type(data) is dict:
|
|
return serializer.Serializer().serialize(data, 'application/json')
|
|
else:
|
|
raise Exception(_("Unable to serialize object of type = '%s'") %
|
|
type(data))
|
|
|
|
def deserialize(self, data, status_code):
|
|
"""Deserializes an JSON string into a dictionary."""
|
|
if status_code in (204, 202) or self.format in ('zip', 'text', 'any'):
|
|
return data
|
|
return serializer.Serializer().deserialize(
|
|
data, 'application/json')['body']
|
|
|
|
def content_type(self, _format=None):
|
|
"""Returns the mime-type for either 'json, 'text', or 'zip'.
|
|
|
|
Defaults to the currently set format.
|
|
"""
|
|
_format = _format or self.format
|
|
if self.format == 'text':
|
|
return "text/plain"
|
|
elif self.format == 'both':
|
|
return "text/plain,application/zip"
|
|
else:
|
|
return "application/%s" % (_format)
|
|
|
|
def retry_request(self, method, action, body=None,
|
|
headers=None, params=None):
|
|
"""Call do_request with the default retry configuration.
|
|
|
|
Only idempotent requests should retry failed connection attempts.
|
|
:raises ConnectionFailed: if the maximum # of retries is exceeded
|
|
"""
|
|
max_attempts = self.retries + 1
|
|
for i in range(max_attempts):
|
|
try:
|
|
return self.do_request(method, action, body=body,
|
|
headers=headers, params=params)
|
|
except exceptions.ConnectionFailed:
|
|
# Exception has already been logged by do_request()
|
|
if i < self.retries:
|
|
_logger.debug('Retrying connection to Tacker service')
|
|
time.sleep(self.retry_interval)
|
|
elif self.raise_errors:
|
|
raise
|
|
|
|
if self.retries:
|
|
msg = (_("Failed to connect to Tacker server after %d attempts")
|
|
% max_attempts)
|
|
else:
|
|
msg = _("Failed to connect Tacker server")
|
|
|
|
raise exceptions.ConnectionFailed(reason=msg)
|
|
|
|
def delete(self, action, body=None, headers=None, params=None):
|
|
return self.retry_request("DELETE", action, body=body,
|
|
headers=headers, params=params)
|
|
|
|
def get(self, action, body=None, headers=None, params=None):
|
|
return self.retry_request("GET", action, body=body,
|
|
headers=headers, params=params)
|
|
|
|
def post(self, action, body=None, headers=None, params=None):
|
|
# Do not retry POST requests to avoid the orphan objects problem.
|
|
return self.do_request("POST", action, body=body,
|
|
headers=headers, params=params)
|
|
|
|
def put(self, action, body=None, headers=None, params=None):
|
|
return self.retry_request("PUT", action, body=body,
|
|
headers=headers, params=params)
|
|
|
|
def patch(self, action, body=None, headers=None, params=None):
|
|
self.format = 'merge-patch+json'
|
|
self.accept = 'json'
|
|
return self.retry_request("PATCH", action, body=body,
|
|
headers=headers, params=params)
|
|
|
|
def list(self, collection, path, retrieve_all=True, headers=None,
|
|
**params):
|
|
if retrieve_all:
|
|
res = []
|
|
for r in self._pagination(collection, path, headers, **params):
|
|
if type(r) is list:
|
|
res.extend(r)
|
|
else:
|
|
res.extend(r[collection])
|
|
return {collection: res} if collection else res
|
|
else:
|
|
return self._pagination(collection, path, headers, **params)
|
|
|
|
def _pagination(self, collection, path, headers, **params):
|
|
if params.get('page_reverse', False):
|
|
linkrel = 'previous'
|
|
else:
|
|
linkrel = 'next'
|
|
next = True
|
|
while next:
|
|
self.rel = None
|
|
res = self.get(path, headers=headers, params=params)
|
|
yield res
|
|
next = False
|
|
try:
|
|
if type(res) is list:
|
|
if self.rel == 'next':
|
|
params = self.params
|
|
next = True
|
|
|
|
else:
|
|
for link in res['%s_links' % collection]:
|
|
if link['rel'] == linkrel:
|
|
query_str = urlparse.urlparse(link['href']).query
|
|
params = urlparse.parse_qs(query_str)
|
|
next = True
|
|
break
|
|
except KeyError:
|
|
break
|
|
|
|
|
|
class LegacyClient(ClientBase):
|
|
|
|
vims_path = '/vims'
|
|
vim_path = '/vims/%s'
|
|
|
|
# API has no way to report plurals, so we have to hard code them
|
|
# EXTED_PLURALS = {}
|
|
|
|
@APIParamsCall
|
|
def show_vim(self, vim, **_params):
|
|
return self.get(self.vim_path % vim, params=_params)
|
|
|
|
_VIM = "vim"
|
|
|
|
@APIParamsCall
|
|
def create_vim(self, body):
|
|
return self.post(self.vims_path, body=body)
|
|
|
|
@APIParamsCall
|
|
def delete_vim(self, vim):
|
|
return self.delete(self.vim_path % vim)
|
|
|
|
@APIParamsCall
|
|
def update_vim(self, vim, body):
|
|
return self.put(self.vim_path % vim, body=body)
|
|
|
|
@APIParamsCall
|
|
def list_vims(self, retrieve_all=True, **_params):
|
|
return self.list('vims', self.vims_path, retrieve_all, **_params)
|
|
|
|
|
|
class VnfPackageClient(ClientBase):
|
|
"""Client for vnfpackage APIs.
|
|
|
|
Purpose of this class is to create required request url for vnfpackage
|
|
APIs.
|
|
"""
|
|
|
|
vnfpackages_path = '/vnfpkgm/v1/vnf_packages'
|
|
vnfpackage_path = '/vnfpkgm/v1/vnf_packages/%s'
|
|
vnfpackage_vnfd_path = '/vnfpkgm/v1/vnf_packages/%s/vnfd'
|
|
vnfpackage_download_path = '/vnfpkgm/v1/vnf_packages/%s/package_content'
|
|
vnfpakcage_artifact_path = '/vnfpkgm/v1/vnf_packages/%(id)s/artifacts/' \
|
|
'%(artifact_path)s'
|
|
|
|
def build_action(self, action):
|
|
return action
|
|
|
|
@APIParamsCall
|
|
def create_vnf_package(self, body):
|
|
return self.post(self.vnfpackages_path, body=body)
|
|
|
|
@APIParamsCall
|
|
def list_vnf_packages(self, retrieve_all=True, **_params):
|
|
vnf_packages = self.list("vnf_packages", self.vnfpackages_path,
|
|
retrieve_all, **_params)
|
|
return vnf_packages
|
|
|
|
@APIParamsCall
|
|
def show_vnf_package(self, vnf_package, **_params):
|
|
return self.get(self.vnfpackage_path % vnf_package, params=_params)
|
|
|
|
@APIParamsCall
|
|
def delete_vnf_package(self, vnf_package):
|
|
return self.delete(self.vnfpackage_path % vnf_package)
|
|
|
|
@APIParamsCall
|
|
def upload_vnf_package(self, vnf_package, file_data=None, **attrs):
|
|
if attrs.get('url'):
|
|
json = {'addressInformation': attrs.get('url')}
|
|
for key in ['userName', 'password']:
|
|
if attrs.get(key):
|
|
json.update({key: attrs.get(key)})
|
|
return self.post(
|
|
'{base_path}/{id}/package_content/upload_from_uri'.format(
|
|
id=vnf_package, base_path=self.vnfpackages_path),
|
|
body=json)
|
|
else:
|
|
self.format = 'zip'
|
|
self.accept = 'json'
|
|
return self.put('{base_path}/{id}/package_content'.format(
|
|
id=vnf_package,
|
|
base_path=self.vnfpackages_path),
|
|
body=file_data)
|
|
|
|
@APIParamsCall
|
|
def download_vnf_package(self, vnf_package):
|
|
self.format = 'zip'
|
|
return self.get(self.vnfpackage_download_path % vnf_package)
|
|
|
|
@APIParamsCall
|
|
def download_vnfd_from_vnf_package(self, vnf_package, accept):
|
|
"""Read VNFD of an on-boarded VNF Package.
|
|
|
|
:param vnf_package: The value can be either the ID of a vnf package
|
|
or a :class:`~openstack.nfv_orchestration.v1.
|
|
vnf_package` instance.
|
|
:param accept: Valid values are 'text/plain', 'application/zip' and
|
|
'both'. According to these values 'Accept' header will
|
|
be set as 'text/plain', 'application/zip',
|
|
'text/plain,application/zip' respectively.
|
|
|
|
:returns: If the VNFD is implemented in the form of multiple files,
|
|
a ZIP file embedding these files shall be returned.
|
|
If the VNFD is implemented as a single file, either that
|
|
file or a ZIP file embedding that file shall be returned.
|
|
"""
|
|
if accept == 'text/plain':
|
|
self.format = 'text'
|
|
elif accept == 'application/zip':
|
|
self.format = 'zip'
|
|
else:
|
|
self.format = 'both'
|
|
return self.get(self.vnfpackage_vnfd_path % vnf_package)
|
|
|
|
@APIParamsCall
|
|
def download_artifact_from_vnf_package(self, vnf_package, artifact_path):
|
|
return self.get(self.vnfpakcage_artifact_path %
|
|
{'id': vnf_package, 'artifact_path': artifact_path})
|
|
|
|
@APIParamsCall
|
|
def update_vnf_package(self, vnf_package, body):
|
|
return self.patch(self.vnfpackage_path % vnf_package, body=body)
|
|
|
|
|
|
class VnfLCMClient(ClientBase):
|
|
"""Client for vnflcm APIs.
|
|
|
|
Purpose of this class is to create required request url for vnflcm
|
|
APIs.
|
|
"""
|
|
|
|
def __init__(self, api_version, **kwargs):
|
|
super(VnfLCMClient, self).__init__(**kwargs)
|
|
self.headers = {'Version': '1.3.0'}
|
|
sol_api_version = 'v1'
|
|
if api_version == '2':
|
|
self.headers = {'Version': '2.0.0'}
|
|
sol_api_version = 'v2'
|
|
|
|
self.vnf_instances_path = (
|
|
'/vnflcm/{}/vnf_instances'.format(sol_api_version))
|
|
self.vnf_instance_path = (
|
|
'/vnflcm/{}/vnf_instances/%s'.format(sol_api_version))
|
|
self.vnf_lcm_op_occurrences_path = (
|
|
'/vnflcm/{}/vnf_lcm_op_occs'.format(sol_api_version))
|
|
self.vnf_lcm_op_occs_path = (
|
|
'/vnflcm/{}/vnf_lcm_op_occs/%s'.format(sol_api_version))
|
|
self.lccn_subscriptions_path = (
|
|
'/vnflcm/{}/subscriptions'.format(sol_api_version))
|
|
self.lccn_subscription_path = (
|
|
'/vnflcm/{}/subscriptions/%s'.format(sol_api_version))
|
|
|
|
def build_action(self, action):
|
|
return action
|
|
|
|
@APIParamsCall
|
|
def create_vnf_instance(self, body):
|
|
return self.post(self.vnf_instances_path, body=body,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def show_vnf_instance(self, vnf_id, **_params):
|
|
return self.get(self.vnf_instance_path % vnf_id,
|
|
headers=self.headers, params=_params)
|
|
|
|
@APIParamsCall
|
|
def list_vnf_instances(self, retrieve_all=True, **_params):
|
|
vnf_instances = self.list(None, self.vnf_instances_path,
|
|
retrieve_all, headers=self.headers,
|
|
**_params)
|
|
return vnf_instances
|
|
|
|
@APIParamsCall
|
|
def instantiate_vnf_instance(self, vnf_id, body):
|
|
return self.post((self.vnf_instance_path + "/instantiate") % vnf_id,
|
|
body=body, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def heal_vnf_instance(self, vnf_id, body):
|
|
return self.post((self.vnf_instance_path + "/heal") % vnf_id,
|
|
body=body, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def terminate_vnf_instance(self, vnf_id, body):
|
|
return self.post((self.vnf_instance_path + "/terminate") % vnf_id,
|
|
body=body, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def delete_vnf_instance(self, vnf_id):
|
|
return self.delete(self.vnf_instance_path % vnf_id,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def update_vnf_instance(self, vnf_id, body):
|
|
return self.patch(self.vnf_instance_path % vnf_id, body=body,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def scale_vnf_instance(self, vnf_id, body):
|
|
return self.post((self.vnf_instance_path + "/scale") % vnf_id,
|
|
body=body, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def rollback_vnf_instance(self, occ_id):
|
|
return self.post((self.vnf_lcm_op_occs_path + "/rollback") % occ_id,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def cancel_vnf_instance(self, occ_id, body):
|
|
return self.post((self.vnf_lcm_op_occs_path + "/cancel") % occ_id,
|
|
body=body)
|
|
|
|
@APIParamsCall
|
|
def fail_vnf_instance(self, occ_id):
|
|
return self.post((self.vnf_lcm_op_occs_path + "/fail") % occ_id,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def change_ext_conn_vnf_instance(self, vnf_id, body):
|
|
return self.post((self.vnf_instance_path + "/change_ext_conn") %
|
|
vnf_id, body=body, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def change_vnfpkg_vnf_instance(self, vnf_id, body):
|
|
# NOTE: it is only supported by V2-API.
|
|
if self.vnf_instance_path.split('/')[2] == 'v2':
|
|
return self.post((self.vnf_instance_path + "/change_vnfpkg") %
|
|
vnf_id, body=body, headers=self.headers)
|
|
else:
|
|
raise exceptions.UnsupportedCommandVersion(version='1')
|
|
|
|
@APIParamsCall
|
|
def retry_vnf_instance(self, occ_id):
|
|
return self.post((self.vnf_lcm_op_occs_path + "/retry") % occ_id,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def list_vnf_lcm_op_occs(self, retrieve_all=True, **_params):
|
|
vnf_lcm_op_occs = self.list(None, self.vnf_lcm_op_occurrences_path,
|
|
retrieve_all, headers=self.headers,
|
|
**_params)
|
|
return vnf_lcm_op_occs
|
|
|
|
@APIParamsCall
|
|
def show_vnf_lcm_op_occs(self, occ_id):
|
|
return self.get(self.vnf_lcm_op_occs_path % occ_id,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def create_lccn_subscription(self, body):
|
|
return self.post(self.lccn_subscriptions_path, body=body,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def delete_lccn_subscription(self, subsc_id):
|
|
return self.delete(self.lccn_subscription_path % subsc_id,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def list_lccn_subscriptions(self, retrieve_all=True, **_params):
|
|
subscriptions = self.list(None, self.lccn_subscriptions_path,
|
|
retrieve_all, headers=self.headers,
|
|
**_params)
|
|
return subscriptions
|
|
|
|
@APIParamsCall
|
|
def show_lccn_subscription(self, subsc_id):
|
|
return self.get(self.lccn_subscription_path % subsc_id,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def show_vnf_lcm_versions(self, major_version):
|
|
if major_version is None:
|
|
path = "/vnflcm/api_versions"
|
|
else:
|
|
path = "/vnflcm/{}/api_versions".format(major_version)
|
|
# NOTE: This may be called with any combination of
|
|
# --os-tacker-api-verson:[1, 2] and major_version:[None, 1, 2].
|
|
# Specifying "headers={'Version': '2.0.0'}" is most simple to
|
|
# make all cases OK.
|
|
return self.get(path, headers={'Version': '2.0.0'})
|
|
|
|
|
|
class VnfFMClient(ClientBase):
|
|
headers = {'Version': '1.3.0'}
|
|
vnf_fm_alarms_path = '/vnffm/v1/alarms'
|
|
vnf_fm_alarm_path = '/vnffm/v1/alarms/%s'
|
|
vnf_fm_subs_path = '/vnffm/v1/subscriptions'
|
|
vnf_fm_sub_path = '/vnffm/v1/subscriptions/%s'
|
|
|
|
def build_action(self, action):
|
|
return action
|
|
|
|
@APIParamsCall
|
|
def list_vnf_fm_alarms(self, retrieve_all=True, **_params):
|
|
vnf_fm_alarms = self.list(
|
|
"vnf_fm_alarms", self.vnf_fm_alarms_path, retrieve_all,
|
|
headers=self.headers, **_params)
|
|
return vnf_fm_alarms
|
|
|
|
@APIParamsCall
|
|
def show_vnf_fm_alarm(self, vnf_fm_alarm_id):
|
|
return self.get(
|
|
self.vnf_fm_alarm_path % vnf_fm_alarm_id, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def update_vnf_fm_alarm(self, vnf_fm_alarm_id, body):
|
|
return self.patch(
|
|
self.vnf_fm_alarm_path % vnf_fm_alarm_id, body=body,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def create_vnf_fm_sub(self, body):
|
|
return self.post(
|
|
self.vnf_fm_subs_path, body=body, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def list_vnf_fm_subs(self, retrieve_all=True, **_params):
|
|
vnf_fm_subs = self.list("vnf_fm_subs", self.vnf_fm_subs_path,
|
|
retrieve_all, headers=self.headers, **_params)
|
|
return vnf_fm_subs
|
|
|
|
@APIParamsCall
|
|
def show_vnf_fm_sub(self, vnf_fm_sub_id):
|
|
return self.get(
|
|
self.vnf_fm_sub_path % vnf_fm_sub_id, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def delete_vnf_fm_sub(self, vnf_fm_sub_id):
|
|
return self.delete(
|
|
self.vnf_fm_sub_path % vnf_fm_sub_id, headers=self.headers)
|
|
|
|
|
|
class VnfPMClient(ClientBase):
|
|
headers = {'Version': '2.1.0'}
|
|
vnf_pm_jobs_path = '/vnfpm/v2/pm_jobs'
|
|
vnf_pm_job_path = '/vnfpm/v2/pm_jobs/%s'
|
|
vnf_pm_reports_path = '/vnfpm/v2/pm_jobs/%(job_id)s/reports/%(report_id)s'
|
|
vnf_pm_thresholds_path = '/vnfpm/v2/thresholds'
|
|
vnf_pm_threshold_path = '/vnfpm/v2/thresholds/%s'
|
|
|
|
def build_action(self, action):
|
|
return action
|
|
|
|
@APIParamsCall
|
|
def create_vnf_pm_job(self, body):
|
|
return self.post(
|
|
self.vnf_pm_jobs_path, body=body, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def list_vnf_pm_jobs(self, retrieve_all=True, **_params):
|
|
vnf_pm_jobs = self.list(
|
|
"vnf_pm_jobs", self.vnf_pm_jobs_path, retrieve_all,
|
|
headers=self.headers, **_params)
|
|
return vnf_pm_jobs
|
|
|
|
@APIParamsCall
|
|
def show_vnf_pm_job(self, vnf_pm_job_id):
|
|
return self.get(
|
|
self.vnf_pm_job_path % vnf_pm_job_id, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def update_vnf_pm_job(self, vnf_pm_job_id, body):
|
|
return self.patch(
|
|
self.vnf_pm_job_path % vnf_pm_job_id, body=body,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def delete_vnf_pm_job(self, vnf_pm_job_id):
|
|
return self.delete(
|
|
self.vnf_pm_job_path % vnf_pm_job_id, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def show_vnf_pm_report(self, vnf_pm_job_id, vnf_pm_report_id):
|
|
return self.get(
|
|
self.vnf_pm_reports_path % {
|
|
'job_id': vnf_pm_job_id, 'report_id': vnf_pm_report_id
|
|
}, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def create_vnf_pm_threshold(self, body):
|
|
return self.post(
|
|
self.vnf_pm_thresholds_path, body=body, headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def list_vnf_pm_thresholds(self, retrieve_all=True, **_params):
|
|
return self.list(
|
|
"vnf_pm_thresholds", self.vnf_pm_thresholds_path, retrieve_all,
|
|
headers=self.headers, **_params)
|
|
|
|
@APIParamsCall
|
|
def show_vnf_pm_threshold(self, vnf_pm_threshold_id):
|
|
return self.get(
|
|
self.vnf_pm_threshold_path % vnf_pm_threshold_id,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def update_vnf_pm_threshold(self, vnf_pm_threshold_id, body):
|
|
return self.patch(
|
|
self.vnf_pm_threshold_path % vnf_pm_threshold_id, body=body,
|
|
headers=self.headers)
|
|
|
|
@APIParamsCall
|
|
def delete_vnf_pm_threshold(self, vnf_pm_threshold_id):
|
|
return self.delete(
|
|
self.vnf_pm_threshold_path % vnf_pm_threshold_id,
|
|
headers=self.headers)
|
|
|
|
|
|
class Client(object):
|
|
"""Unified interface to interact with multiple apps of tacker service.
|
|
|
|
This class is a single entry point to interact with legacy tacker apis and
|
|
vnf packages apis.
|
|
|
|
Example::
|
|
|
|
from tackerclient.v1_0 import client
|
|
tacker = client.Client(username=USER,
|
|
password=PASS,
|
|
tenant_name=TENANT_NAME,
|
|
auth_url=KEYSTONE_URL)
|
|
|
|
vnf_package = tacker.create_vnf_package(...)
|
|
nsd = tacker.create_nsd(...)
|
|
|
|
"""
|
|
|
|
def __init__(self, **kwargs):
|
|
api_version = kwargs.pop('api_version', '1')
|
|
self.vnf_lcm_client = VnfLCMClient(api_version, **kwargs)
|
|
self.vnf_fm_client = VnfFMClient(**kwargs)
|
|
self.vnf_pm_client = VnfPMClient(**kwargs)
|
|
self.vnf_package_client = VnfPackageClient(**kwargs)
|
|
self.legacy_client = LegacyClient(**kwargs)
|
|
|
|
# LegacyClient methods
|
|
|
|
def delete(self, action, body=None, headers=None, params=None):
|
|
return self.legacy_client.delete(action, body=body, headers=headers,
|
|
params=params)
|
|
|
|
def get(self, action, body=None, headers=None, params=None):
|
|
return self.legacy_client.get(action, body=body, headers=headers,
|
|
params=params)
|
|
|
|
def post(self, action, body=None, headers=None, params=None):
|
|
return self.legacy_client.post(action, body=body, headers=headers,
|
|
params=params)
|
|
|
|
def put(self, action, body=None, headers=None, params=None):
|
|
return self.legacy_client.put(action, body=body, headers=headers,
|
|
params=params)
|
|
|
|
def list(self, collection, path, retrieve_all=True, **params):
|
|
return self.legacy_client.list(collection, path,
|
|
retrieve_all=retrieve_all, **params)
|
|
|
|
def show_vim(self, vim, **_params):
|
|
return self.legacy_client.show_vim(vim, **_params)
|
|
|
|
def create_vim(self, body):
|
|
return self.legacy_client.create_vim(body)
|
|
|
|
def delete_vim(self, vim):
|
|
return self.legacy_client.delete_vim(vim)
|
|
|
|
def update_vim(self, vim, body):
|
|
return self.legacy_client.update_vim(vim, body)
|
|
|
|
def list_vims(self, retrieve_all=True, **_params):
|
|
return self.legacy_client.list_vims(retrieve_all=retrieve_all,
|
|
**_params)
|
|
|
|
# VnfPackageClient methods
|
|
|
|
def create_vnf_package(self, body):
|
|
return self.vnf_package_client.create_vnf_package(body)
|
|
|
|
def list_vnf_packages(self, retrieve_all=True, query_parameter=None,
|
|
**_params):
|
|
return self.vnf_package_client.list_vnf_packages(
|
|
retrieve_all=retrieve_all, **_params)
|
|
|
|
def show_vnf_package(self, vnf_package, **_params):
|
|
return self.vnf_package_client.show_vnf_package(vnf_package, **_params)
|
|
|
|
def upload_vnf_package(self, vnf_package, file_data=None, **_params):
|
|
return self.vnf_package_client.upload_vnf_package(
|
|
vnf_package, file_data=file_data, **_params)
|
|
|
|
def delete_vnf_package(self, vnf_package):
|
|
return self.vnf_package_client.delete_vnf_package(vnf_package)
|
|
|
|
# VnfLCMClient methods.
|
|
|
|
def create_vnf_instance(self, body):
|
|
return self.vnf_lcm_client.create_vnf_instance(body)
|
|
|
|
def show_vnf_instance(self, vnf_instance, **_params):
|
|
return self.vnf_lcm_client.show_vnf_instance(vnf_instance,
|
|
**_params)
|
|
|
|
def list_vnf_instances(self, retrieve_all=True, **_params):
|
|
return self.vnf_lcm_client.list_vnf_instances(
|
|
retrieve_all=retrieve_all, **_params)
|
|
|
|
def instantiate_vnf_instance(self, vnf_id, body):
|
|
return self.vnf_lcm_client.instantiate_vnf_instance(vnf_id, body)
|
|
|
|
def heal_vnf_instance(self, vnf_id, body):
|
|
return self.vnf_lcm_client.heal_vnf_instance(vnf_id, body)
|
|
|
|
def terminate_vnf_instance(self, vnf_id, body):
|
|
return self.vnf_lcm_client.terminate_vnf_instance(vnf_id, body)
|
|
|
|
def scale_vnf_instance(self, vnf_id, body):
|
|
return self.vnf_lcm_client.scale_vnf_instance(vnf_id, body)
|
|
|
|
def change_ext_conn_vnf_instance(self, vnf_id, body):
|
|
return self.vnf_lcm_client.change_ext_conn_vnf_instance(vnf_id, body)
|
|
|
|
def change_vnfpkg_vnf_instance(self, vnf_id, body):
|
|
return self.vnf_lcm_client.change_vnfpkg_vnf_instance(vnf_id, body)
|
|
|
|
def delete_vnf_instance(self, vnf_id):
|
|
return self.vnf_lcm_client.delete_vnf_instance(vnf_id)
|
|
|
|
def update_vnf_instance(self, vnf_id, body):
|
|
return self.vnf_lcm_client.update_vnf_instance(vnf_id, body)
|
|
|
|
def rollback_vnf_instance(self, occ_id):
|
|
return self.vnf_lcm_client.rollback_vnf_instance(occ_id)
|
|
|
|
def cancel_vnf_instance(self, occ_id, body):
|
|
return self.vnf_lcm_client.cancel_vnf_instance(occ_id, body)
|
|
|
|
def fail_vnf_instance(self, occ_id):
|
|
return self.vnf_lcm_client.fail_vnf_instance(occ_id)
|
|
|
|
def retry_vnf_instance(self, occ_id):
|
|
return self.vnf_lcm_client.retry_vnf_instance(occ_id)
|
|
|
|
def update_vnf_package(self, vnf_package, body):
|
|
return self.vnf_package_client.update_vnf_package(vnf_package, body)
|
|
|
|
def download_vnfd_from_vnf_package(self, vnf_package, accept):
|
|
return self.vnf_package_client.download_vnfd_from_vnf_package(
|
|
vnf_package, accept)
|
|
|
|
def download_artifact_from_vnf_package(self, vnf_package, artifact_path):
|
|
return self.vnf_package_client.download_artifact_from_vnf_package(
|
|
vnf_package, artifact_path
|
|
)
|
|
|
|
def download_vnf_package(self, vnf_package):
|
|
return self.vnf_package_client.download_vnf_package(vnf_package)
|
|
|
|
def list_vnf_lcm_op_occs(self, retrieve_all=True, **_params):
|
|
return self.vnf_lcm_client.list_vnf_lcm_op_occs(
|
|
retrieve_all=retrieve_all, **_params)
|
|
|
|
def show_vnf_lcm_op_occs(self, occ_id):
|
|
return self.vnf_lcm_client.show_vnf_lcm_op_occs(occ_id)
|
|
|
|
def create_lccn_subscription(self, body):
|
|
return self.vnf_lcm_client.create_lccn_subscription(body)
|
|
|
|
def delete_lccn_subscription(self, subsc_id):
|
|
return self.vnf_lcm_client.delete_lccn_subscription(subsc_id)
|
|
|
|
def list_lccn_subscriptions(self, retrieve_all=True, **_params):
|
|
return self.vnf_lcm_client.list_lccn_subscriptions(
|
|
retrieve_all=retrieve_all, **_params)
|
|
|
|
def show_lccn_subscription(self, subsc_id):
|
|
return self.vnf_lcm_client.show_lccn_subscription(subsc_id)
|
|
|
|
def show_vnf_lcm_versions(self, major_version):
|
|
return self.vnf_lcm_client.show_vnf_lcm_versions(major_version)
|
|
|
|
# VnfFMClient methods.
|
|
|
|
def list_vnf_fm_alarms(self, retrieve_all=True, **_params):
|
|
return self.vnf_fm_client.list_vnf_fm_alarms(
|
|
retrieve_all=retrieve_all, **_params)
|
|
|
|
def show_vnf_fm_alarm(self, vnf_fm_alarm_id):
|
|
return self.vnf_fm_client.show_vnf_fm_alarm(vnf_fm_alarm_id)
|
|
|
|
def update_vnf_fm_alarm(self, vnf_fm_alarm_id, body):
|
|
return self.vnf_fm_client.update_vnf_fm_alarm(vnf_fm_alarm_id, body)
|
|
|
|
def create_vnf_fm_sub(self, body):
|
|
return self.vnf_fm_client.create_vnf_fm_sub(body)
|
|
|
|
def list_vnf_fm_subs(self, retrieve_all=True, **_params):
|
|
return self.vnf_fm_client.list_vnf_fm_subs(
|
|
retrieve_all=retrieve_all, **_params)
|
|
|
|
def show_vnf_fm_sub(self, vnf_fm_sub_id):
|
|
return self.vnf_fm_client.show_vnf_fm_sub(vnf_fm_sub_id)
|
|
|
|
def delete_vnf_fm_sub(self, vnf_fm_sub_id):
|
|
return self.vnf_fm_client.delete_vnf_fm_sub(vnf_fm_sub_id)
|
|
|
|
# VnfPMClient methods.
|
|
|
|
def create_vnf_pm_job(self, body):
|
|
return self.vnf_pm_client.create_vnf_pm_job(body)
|
|
|
|
def list_vnf_pm_jobs(self, retrieve_all=True, **_params):
|
|
return self.vnf_pm_client.list_vnf_pm_jobs(
|
|
retrieve_all=retrieve_all, **_params)
|
|
|
|
def show_vnf_pm_job(self, vnf_pm_job_id):
|
|
return self.vnf_pm_client.show_vnf_pm_job(vnf_pm_job_id)
|
|
|
|
def update_vnf_pm_job(self, vnf_pm_job_id, body):
|
|
return self.vnf_pm_client.update_vnf_pm_job(vnf_pm_job_id, body)
|
|
|
|
def delete_vnf_pm_job(self, vnf_pm_job_id):
|
|
return self.vnf_pm_client.delete_vnf_pm_job(vnf_pm_job_id)
|
|
|
|
def show_vnf_pm_report(self, vnf_pm_job_id, vnf_pm_report_id):
|
|
return self.vnf_pm_client.show_vnf_pm_report(
|
|
vnf_pm_job_id, vnf_pm_report_id)
|
|
|
|
def create_vnf_pm_threshold(self, body):
|
|
return self.vnf_pm_client.create_vnf_pm_threshold(body)
|
|
|
|
def list_vnf_pm_thresholds(self, retrieve_all=True, **_params):
|
|
return self.vnf_pm_client.list_vnf_pm_thresholds(
|
|
retrieve_all=retrieve_all, **_params)
|
|
|
|
def show_vnf_pm_threshold(self, vnf_pm_threshold_id):
|
|
return self.vnf_pm_client.show_vnf_pm_threshold(vnf_pm_threshold_id)
|
|
|
|
def update_vnf_pm_threshold(self, vnf_pm_threshold_id, body):
|
|
return self.vnf_pm_client.update_vnf_pm_threshold(
|
|
vnf_pm_threshold_id, body)
|
|
|
|
def delete_vnf_pm_threshold(self, vnf_pm_threshold_id):
|
|
return self.vnf_pm_client.delete_vnf_pm_threshold(vnf_pm_threshold_id)
|