Fix Bug 934. OSM CLI crashes for listing operations with insufficient permissions

[osm/osmclient.git] / osmclient / sol005 / ns.py

diff --git a/osmclient/sol005/ns.py b/osmclient/sol005/ns.py
index b0c37f1..c8e2a77 100644 (file)
--- a/osmclient/sol005/ns.py
+++ b/osmclient/sol005/ns.py
@@ -22,8 +22,10 @@ from osmclient.common import utils
 from osmclient.common import wait as WaitForStatus
 from osmclient.common.exceptions import ClientException
 from osmclient.common.exceptions import NotFound
 from osmclient.common import wait as WaitForStatus
 from osmclient.common.exceptions import ClientException
 from osmclient.common.exceptions import NotFound

+from osmclient.common.exceptions import OsmHttpException

 import yaml
 import json
 import yaml
 import json

+import logging

 
 
 class Ns(object):
 
 
 class Ns(object):


@@ -31,6 +33,7 @@ class Ns(object):
     def __init__(self, http=None, client=None):
         self._http = http
         self._client = client
     def __init__(self, http=None, client=None):
         self._http = http
         self._client = client

+        self._logger = logging.getLogger('osmclient')

         self._apiName = '/nslcm'
         self._apiVersion = '/v1'
         self._apiResource = '/ns_instances_content'
         self._apiName = '/nslcm'
         self._apiVersion = '/v1'
         self._apiResource = '/ns_instances_content'


@@ -39,6 +42,7 @@ class Ns(object):
 
     # NS '--wait' option
     def _wait(self, id, deleteFlag=False):
 
     # NS '--wait' option
     def _wait(self, id, deleteFlag=False):

+        self._logger.debug("")

         # Endpoint to get operation status
         apiUrlStatus = '{}{}{}'.format(self._apiName, self._apiVersion, '/ns_lcm_op_occs')
         # Wait for status for NS instance creation/update/deletion
         # Endpoint to get operation status
         apiUrlStatus = '{}{}{}'.format(self._apiName, self._apiVersion, '/ns_lcm_op_occs')
         # Wait for status for NS instance creation/update/deletion


@@ -53,18 +57,20 @@ class Ns(object):
     def list(self, filter=None):
         """Returns a list of NS
         """
     def list(self, filter=None):
         """Returns a list of NS
         """

+        self._logger.debug("")

         self._client.get_token()
         filter_string = ''
         if filter:
             filter_string = '?{}'.format(filter)
         self._client.get_token()
         filter_string = ''
         if filter:
             filter_string = '?{}'.format(filter)

-        resp = self._http.get_cmd('{}{}'.format(self._apiBase,filter_string))
+        _, resp = self._http.get2_cmd('{}{}'.format(self._apiBase,filter_string))

         if resp:
         if resp:

-            return resp
+            return json.loads(resp)

         return list()
 
     def get(self, name):
         """Returns an NS based on name or id
         """
         return list()
 
     def get(self, name):
         """Returns an NS based on name or id
         """

+        self._logger.debug("")

         self._client.get_token()
         if utils.validate_uuid4(name):
             for ns in self.list():
         self._client.get_token()
         if utils.validate_uuid4(name):
             for ns in self.list():


@@ -77,6 +83,7 @@ class Ns(object):
         raise NotFound("ns {} not found".format(name))
 
     def get_individual(self, name):
         raise NotFound("ns {} not found".format(name))
 
     def get_individual(self, name):

+        self._logger.debug("")

         self._client.get_token()
         ns_id = name
         if not utils.validate_uuid4(name):
         self._client.get_token()
         ns_id = name
         if not utils.validate_uuid4(name):


@@ -84,14 +91,15 @@ class Ns(object):
                 if name == ns['name']:
                     ns_id = ns['_id']
                     break
                 if name == ns['name']:
                     ns_id = ns['_id']
                     break

-        resp = self._http.get_cmd('{}/{}'.format(self._apiBase, ns_id))
+        _, resp = self._http.get2_cmd('{}/{}'.format(self._apiBase, ns_id))

         #resp = self._http.get_cmd('{}/{}/nsd_content'.format(self._apiBase, ns_id))
         #print(yaml.safe_dump(resp))
         if resp:
         #resp = self._http.get_cmd('{}/{}/nsd_content'.format(self._apiBase, ns_id))
         #print(yaml.safe_dump(resp))
         if resp:

-            return resp
+            return json.loads(resp)

         raise NotFound("ns {} not found".format(name))
 
     def delete(self, name, force=False, wait=False):
         raise NotFound("ns {} not found".format(name))
 
     def delete(self, name, force=False, wait=False):

+        self._logger.debug("")

         ns = self.get(name)
         querystring = ''
         if force:
         ns = self.get(name)
         querystring = ''
         if force:


@@ -116,11 +124,12 @@ class Ns(object):
                     msg = json.loads(resp)
                 except ValueError:
                     msg = resp
                     msg = json.loads(resp)
                 except ValueError:
                     msg = resp

-            raise ClientException("failed to delete ns {} - {}".format(name, msg))
+            raise OsmHttpException("failed to delete ns {} - {}".format(name, msg))

 
     def create(self, nsd_name, nsr_name, account, config=None,
                ssh_keys=None, description='default description',
                admin_status='ENABLED', wait=False):
 
     def create(self, nsd_name, nsr_name, account, config=None,
                ssh_keys=None, description='default description',
                admin_status='ENABLED', wait=False):

+        self._logger.debug("")

         self._client.get_token()
         nsd = self._client.nsd.get(nsd_name)
 
         self._client.get_token()
         nsd = self._client.nsd.get(nsd_name)
 


@@ -128,6 +137,7 @@ class Ns(object):
         wim_account_id = {}
 
         def get_vim_account_id(vim_account):
         wim_account_id = {}
 
         def get_vim_account_id(vim_account):

+            self._logger.debug("")

             if vim_account_id.get(vim_account):
                 return vim_account_id[vim_account]
 
             if vim_account_id.get(vim_account):
                 return vim_account_id[vim_account]
 


@@ -138,6 +148,7 @@ class Ns(object):
             return vim['_id']
 
         def get_wim_account_id(wim_account):
             return vim['_id']
 
         def get_wim_account_id(wim_account):

+            self._logger.debug("")

             if not isinstance(wim_account, str):
                 return wim_account
             if wim_account_id.get(wim_account):
             if not isinstance(wim_account, str):
                 return wim_account
             if wim_account_id.get(wim_account):


@@ -198,13 +209,12 @@ class Ns(object):
                     if not additional_param_vnf.get("member-vnf-index"):
                         raise ValueError("Error at --config 'additionalParamsForVnf' items must contain "
                                          "'member-vnf-index'")
                     if not additional_param_vnf.get("member-vnf-index"):
                         raise ValueError("Error at --config 'additionalParamsForVnf' items must contain "
                                          "'member-vnf-index'")

-                    if not additional_param_vnf.get("additionalParams"):
-                        raise ValueError("Error at --config 'additionalParamsForVnf' items must contain "
-                                         "'additionalParams'")

             if "wim_account" in ns_config:
                 wim_account = ns_config.pop("wim_account")
                 if wim_account is not None:
                     ns['wimAccountId'] = get_wim_account_id(wim_account)
             if "wim_account" in ns_config:
                 wim_account = ns_config.pop("wim_account")
                 if wim_account is not None:
                     ns['wimAccountId'] = get_wim_account_id(wim_account)

+            if "timeout_ns_deploy" in ns_config:
+                ns["timeout_ns_deploy"] = ns_config.pop("timeout_ns_deploy")

 
         # print(yaml.safe_dump(ns))
         try:
 
         # print(yaml.safe_dump(ns))
         try:


@@ -217,37 +227,38 @@ class Ns(object):
                           for (key,val) in list(headers.items())]
             self._http.set_http_header(http_header)
             http_code, resp = self._http.post_cmd(endpoint=self._apiBase,
                           for (key,val) in list(headers.items())]
             self._http.set_http_header(http_header)
             http_code, resp = self._http.post_cmd(endpoint=self._apiBase,

-                                       postfields_dict=ns)
+                                   postfields_dict=ns)

             # print('HTTP CODE: {}'.format(http_code))
             # print('RESP: {}'.format(resp))
             # print('HTTP CODE: {}'.format(http_code))
             # print('RESP: {}'.format(resp))

-            if http_code in (200, 201, 202, 204):
-                if resp:
-                    resp = json.loads(resp)
-                if not resp or 'id' not in resp:
-                    raise ClientException('unexpected response from server - {} '.format(
+            #if http_code in (200, 201, 202, 204):
+            if resp:
+                resp = json.loads(resp)
+            if not resp or 'id' not in resp:
+                raise ClientException('unexpected response from server - {} '.format(

                                       resp))
                                       resp))

-                if wait:
-                    # Wait for status for NS instance creation
-                    self._wait(resp.get('nslcmop_id'))
-                return resp['id']
-            else:
-                msg = ""
-                if resp:
-                    try:
-                        msg = json.loads(resp)
-                    except ValueError:
-                        msg = resp
-                raise ClientException(msg)
+            if wait:
+                # Wait for status for NS instance creation
+                self._wait(resp.get('nslcmop_id'))
+            return resp['id']
+            #else:
+            #    msg = ""
+            #    if resp:
+            #        try:
+            #            msg = json.loads(resp)
+            #        except ValueError:
+            #            msg = resp
+            #    raise ClientException(msg)

         except ClientException as exc:
             message="failed to create ns: {} nsd: {}\nerror:\n{}".format(
                     nsr_name,
                     nsd_name,
         except ClientException as exc:
             message="failed to create ns: {} nsd: {}\nerror:\n{}".format(
                     nsr_name,
                     nsd_name,

-                    exc.message)
-            raise ClientException(message)
+                    str(exc))
+            raise OsmHttpException(message)

 
     def list_op(self, name, filter=None):
         """Returns the list of operations of a NS
         """
 
     def list_op(self, name, filter=None):
         """Returns the list of operations of a NS
         """

+        self._logger.debug("")

         ns = self.get(name)
         try:
             self._apiResource = '/ns_lcm_op_occs'
         ns = self.get(name)
         try:
             self._apiResource = '/ns_lcm_op_occs'


@@ -255,36 +266,37 @@ class Ns(object):
                                       self._apiVersion, self._apiResource)
             filter_string = ''
             if filter:
                                       self._apiVersion, self._apiResource)
             filter_string = ''
             if filter:

-                filter_string = '&{}'.format(filter)
+                 filter_string = '&{}'.format(filter)

             http_code, resp = self._http.get2_cmd('{}?nsInstanceId={}'.format(
                                                        self._apiBase, ns['_id'],
                                                        filter_string) )
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))
             http_code, resp = self._http.get2_cmd('{}?nsInstanceId={}'.format(
                                                        self._apiBase, ns['_id'],
                                                        filter_string) )
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))

-            if http_code == 200:
-                if resp:
-                    resp = json.loads(resp)
-                    return resp
-                else:
-                    raise ClientException('unexpected response from server')
+            #if http_code == 200:
+            if resp:
+                resp = json.loads(resp)
+                return resp

             else:
             else:

-                msg = ""
-                if resp:
-                    try:
-                        resp = json.loads(resp)
-                        msg = resp['detail']
-                    except ValueError:
-                        msg = resp
-                raise ClientException(msg)
+                raise ClientException('unexpected response from server')
+            #else:
+            #    msg = ""
+            #    if resp:
+            #        try:
+            #            resp = json.loads(resp)
+            #            msg = resp['detail']
+            #        except ValueError:
+            #            msg = resp
+            #    raise ClientException(msg)

         except ClientException as exc:
             message="failed to get operation list of NS {}:\nerror:\n{}".format(
                     name,
         except ClientException as exc:
             message="failed to get operation list of NS {}:\nerror:\n{}".format(
                     name,

-                    exc.message)
-            raise ClientException(message)
+                    str(exc))
+            raise OsmHttpException(message)

 
     def get_op(self, operationId):
         """Returns the status of an operation
         """
 
     def get_op(self, operationId):
         """Returns the status of an operation
         """

+        self._logger.debug("")

         self._client.get_token()
         try:
             self._apiResource = '/ns_lcm_op_occs'
         self._client.get_token()
         try:
             self._apiResource = '/ns_lcm_op_occs'


@@ -293,32 +305,34 @@ class Ns(object):
             http_code, resp = self._http.get2_cmd('{}/{}'.format(self._apiBase, operationId))
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))
             http_code, resp = self._http.get2_cmd('{}/{}'.format(self._apiBase, operationId))
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))

-            if http_code == 200:
-                if resp:
-                    resp = json.loads(resp)
-                    return resp
-                else:
-                    raise ClientException('unexpected response from server')
+            #if http_code == 200:
+            if resp:
+                resp = json.loads(resp)
+                return resp

             else:
             else:

-                msg = ""
-                if resp:
-                    try:
-                        resp = json.loads(resp)
-                        msg = resp['detail']
-                    except ValueError:
-                        msg = resp
-                raise ClientException(msg)
+                raise ClientException('unexpected response from server')
+            #else:
+            #    msg = ""
+            #    if resp:
+            #        try:
+            #            resp = json.loads(resp)
+            #            msg = resp['detail']
+            #        except ValueError:
+            #            msg = resp
+            #    raise ClientException(msg)

         except ClientException as exc:
             message="failed to get status of operation {}:\nerror:\n{}".format(
                     operationId,
         except ClientException as exc:
             message="failed to get status of operation {}:\nerror:\n{}".format(
                     operationId,

-                    exc.message)
-            raise ClientException(message)
+                    str(exc))
+            raise OsmHttpException(message)

 
 

-    def exec_op(self, name, op_name, op_data=None, wait=False):
+    def exec_op(self, name, op_name, op_data=None, wait=False, ):

         """Executes an operation on a NS
         """
         """Executes an operation on a NS
         """

+        self._logger.debug("")

         ns = self.get(name)
         try:
         ns = self.get(name)
         try:

+            ns = self.get(name)

             self._apiResource = '/ns_instances'
             self._apiBase = '{}{}{}'.format(self._apiName,
                                             self._apiVersion, self._apiResource)
             self._apiResource = '/ns_instances'
             self._apiBase = '{}{}{}'.format(self._apiName,
                                             self._apiVersion, self._apiResource)


@@ -328,34 +342,35 @@ class Ns(object):
             http_code, resp = self._http.post_cmd(endpoint=endpoint, postfields_dict=op_data)
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))
             http_code, resp = self._http.post_cmd(endpoint=endpoint, postfields_dict=op_data)
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))

-            if http_code in (200, 201, 202, 204):
-                if resp:
-                    resp = json.loads(resp)
-                if not resp or 'id' not in resp:
-                    raise ClientException('unexpected response from server - {}'.format(
-                                      resp))
-                if wait:
-                    # Wait for status for NS instance action
-                    # For the 'action' operation, 'id' is used
-                    self._wait(resp.get('id'))
-                print(resp['id'])
-            else:
-                msg = ""
-                if resp:
-                    try:
-                        msg = json.loads(resp)
-                    except ValueError:
-                        msg = resp
-                raise ClientException(msg)
+            #if http_code in (200, 201, 202, 204):
+            if resp:
+                resp = json.loads(resp)
+            if not resp or 'id' not in resp:
+                raise ClientException('unexpected response from server - {}'.format(
+                                  resp))
+            if wait:
+                # Wait for status for NS instance action
+                # For the 'action' operation, 'id' is used
+                self._wait(resp.get('id'))
+            return resp['id']
+            #else:
+            #    msg = ""
+            #    if resp:
+            #        try:
+            #            msg = json.loads(resp)
+            #        except ValueError:
+            #            msg = resp
+            #    raise ClientException(msg)

         except ClientException as exc:
             message="failed to exec operation {}:\nerror:\n{}".format(
                     name,
         except ClientException as exc:
             message="failed to exec operation {}:\nerror:\n{}".format(
                     name,

-                    exc.message)
-            raise ClientException(message)
+                    str(exc))
+            raise OsmHttpException(message)

 
     def scale_vnf(self, ns_name, vnf_name, scaling_group, scale_in, scale_out, wait=False):
         """Scales a VNF by adding/removing VDUs
         """
 
     def scale_vnf(self, ns_name, vnf_name, scaling_group, scale_in, scale_out, wait=False):
         """Scales a VNF by adding/removing VDUs
         """

+        self._logger.debug("")

         self._client.get_token()
         try:
             op_data={}
         self._client.get_token()
         try:
             op_data={}


@@ -369,97 +384,102 @@ class Ns(object):
                 "member-vnf-index": vnf_name,
                 "scaling-group-descriptor": scaling_group,
             }
                 "member-vnf-index": vnf_name,
                 "scaling-group-descriptor": scaling_group,
             }

-            self.exec_op(ns_name, op_name='scale', op_data=op_data, wait=wait)
+            op_id = self.exec_op(ns_name, op_name='scale', op_data=op_data, wait=wait)
+            print(str(op_id))

         except ClientException as exc:
             message="failed to scale vnf {} of ns {}:\nerror:\n{}".format(
         except ClientException as exc:
             message="failed to scale vnf {} of ns {}:\nerror:\n{}".format(

-                    vnf_name, ns_name, exc.message)
+                    vnf_name, ns_name, str(exc))

             raise ClientException(message)
 
     def create_alarm(self, alarm):
             raise ClientException(message)
 
     def create_alarm(self, alarm):

+        self._logger.debug("")

         self._client.get_token()
         data = {}
         data["create_alarm_request"] = {}
         data["create_alarm_request"]["alarm_create_request"] = alarm
         self._client.get_token()
         data = {}
         data["create_alarm_request"] = {}
         data["create_alarm_request"]["alarm_create_request"] = alarm

-        try:
-            http_code, resp = self._http.post_cmd(endpoint='/test/message/alarm_request',
-                                       postfields_dict=data)
+        #try:
+        http_code, resp = self._http.post_cmd(endpoint='/test/message/alarm_request',
+                                   postfields_dict=data)

             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))

-            if http_code in (200, 201, 202, 204):
-                #resp = json.loads(resp)
-                print('Alarm created')
-            else:
-                msg = ""
-                if resp:
-                    try:
-                        msg = json.loads(resp)
-                    except ValueError:
-                        msg = resp
-                raise ClientException('error: code: {}, resp: {}'.format(
-                                      http_code, msg))
-        except ClientException as exc:
-            message="failed to create alarm: alarm {}\n{}".format(
-                    alarm,
-                    exc.message)
-            raise ClientException(message)
+            #if http_code in (200, 201, 202, 204):
+            #resp = json.loads(resp)
+        print('Alarm created')
+            #else:
+            #    msg = ""
+            #    if resp:
+            #        try:
+            #            msg = json.loads(resp)
+            #        except ValueError:
+            #            msg = resp
+            #    raise ClientException('error: code: {}, resp: {}'.format(
+            #                          http_code, msg))
+        #except ClientException as exc:
+        #    message="failed to create alarm: alarm {}\n{}".format(
+        #            alarm,
+        #            str(exc))
+        #    raise ClientException(message)

 
     def delete_alarm(self, name):
 
     def delete_alarm(self, name):

+        self._logger.debug("")

         self._client.get_token()
         data = {}
         data["delete_alarm_request"] = {}
         data["delete_alarm_request"]["alarm_delete_request"] = {}
         data["delete_alarm_request"]["alarm_delete_request"]["alarm_uuid"] = name
         self._client.get_token()
         data = {}
         data["delete_alarm_request"] = {}
         data["delete_alarm_request"]["alarm_delete_request"] = {}
         data["delete_alarm_request"]["alarm_delete_request"]["alarm_uuid"] = name

-        try:
-            http_code, resp = self._http.post_cmd(endpoint='/test/message/alarm_request',
-                                       postfields_dict=data)
+        #try:
+        http_code, resp = self._http.post_cmd(endpoint='/test/message/alarm_request',
+                                   postfields_dict=data)

             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))

-            if http_code in (200, 201, 202, 204):
-                #resp = json.loads(resp)
-                print('Alarm deleted')
-            else:
-                msg = ""
-                if resp:
-                    try:
-                        msg = json.loads(resp)
-                    except ValueError:
-                        msg = resp
-                raise ClientException('error: code: {}, resp: {}'.format(
-                                      http_code, msg))
-        except ClientException as exc:
-            message="failed to delete alarm: alarm {}\n{}".format(
-                    name,
-                    exc.message)
-            raise ClientException(message)
+            #if http_code in (200, 201, 202, 204):
+            #resp = json.loads(resp)
+        print('Alarm deleted')
+            #else:
+            #    msg = ""
+            #    if resp:
+            #        try:
+            #            msg = json.loads(resp)
+            #        except ValueError:
+            #            msg = resp
+            #    raise ClientException('error: code: {}, resp: {}'.format(
+            #                          http_code, msg))
+        #except ClientException as exc:
+        #    message="failed to delete alarm: alarm {}\n{}".format(
+        #            name,
+        #            str(exc))
+        #    raise ClientException(message)

 
     def export_metric(self, metric):
 
     def export_metric(self, metric):

+        self._logger.debug("")

         self._client.get_token()
         data = {}
         data["read_metric_data_request"] = metric
         self._client.get_token()
         data = {}
         data["read_metric_data_request"] = metric

-        try:
-            http_code, resp = self._http.post_cmd(endpoint='/test/message/metric_request',
-                                       postfields_dict=data)
+        #try:
+        http_code, resp = self._http.post_cmd(endpoint='/test/message/metric_request',
+                                   postfields_dict=data)

             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))
             #print('HTTP CODE: {}'.format(http_code))
             #print('RESP: {}'.format(resp))

-            if http_code in (200, 201, 202, 204):
-                #resp = json.loads(resp)
-                return 'Metric exported'
-            else:
-                msg = ""
-                if resp:
-                    try:
-                        msg = json.loads(resp)
-                    except ValueError:
-                        msg = resp
-                raise ClientException('error: code: {}, resp: {}'.format(
-                                      http_code, msg))
-        except ClientException as exc:
-            message="failed to export metric: metric {}\n{}".format(
-                    metric,
-                    exc.message)
-            raise ClientException(message)
+            #if http_code in (200, 201, 202, 204):
+            #resp = json.loads(resp)
+        return 'Metric exported'
+            #else:
+            #    msg = ""
+            #    if resp:
+            #        try:
+            #            msg = json.loads(resp)
+            #        except ValueError:
+            #            msg = resp
+            #    raise ClientException('error: code: {}, resp: {}'.format(
+            #                          http_code, msg))
+        #except ClientException as exc:
+        #    message="failed to export metric: metric {}\n{}".format(
+        #            metric,
+        #            str(exc))
+        #    raise ClientException(message)

 
     def get_field(self, ns_name, field):
 
     def get_field(self, ns_name, field):

+        self._logger.debug("")

         nsr = self.get(ns_name)
         print(yaml.safe_dump(nsr))
         if nsr is None:
         nsr = self.get(ns_name)
         print(yaml.safe_dump(nsr))
         if nsr is None:


@@ -469,3 +489,4 @@ class Ns(object):
             return nsr[field]
 
         raise NotFound("failed to find {} in ns {}".format(field, ns_name))
             return nsr[field]
 
         raise NotFound("failed to find {} in ns {}".format(field, ns_name))

+