osmclient/sol005/ns.py

   1 # Copyright 2018 Telefonica
   2 #
   3 # All Rights Reserved.
   4 #
   5 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   6 #    not use this file except in compliance with the License. You may obtain
   7 #    a copy of the License at
   8 #
   9 #         http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 #    Unless required by applicable law or agreed to in writing, software
  12 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  13 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  14 #    License for the specific language governing permissions and limitations
  15 #    under the License.
  16
  17 """
  18 OSM ns API handling
  19 """
  20
  21 from osmclient.common import utils
  22 from osmclient.common.exceptions import ClientException
  23 from osmclient.common.exceptions import NotFound
  24 import yaml
  25 import json
  26
  27
  28 class Ns(object):
  29
  30     def __init__(self, http=None, client=None):
  31         self._http = http
  32         self._client = client
  33         self._apiName = '/nslcm'
  34         self._apiVersion = '/v1'
  35         self._apiResource = '/ns_instances_content'
  36         self._apiBase = '{}{}{}'.format(self._apiName,
  37                                         self._apiVersion, self._apiResource)
  38
  39     def list(self, filter=None):
  40         """Returns a list of NS
  41         """
  42         filter_string = ''
  43         if filter:
  44             filter_string = '?{}'.format(filter)
  45         resp = self._http.get_cmd('{}{}'.format(self._apiBase,filter_string))
  46         if resp:
  47             return resp
  48         return list()
  49
  50     def get(self, name):
  51         """Returns an NS based on name or id
  52         """
  53         if utils.validate_uuid4(name):
  54             for ns in self.list():
  55                 if name == ns['_id']:
  56                     return ns
  57         else:
  58             for ns in self.list():
  59                 if name == ns['name']:
  60                     return ns
  61         raise NotFound("ns {} not found".format(name))
  62
  63     def get_individual(self, name):
  64         ns_id = name
  65         if not utils.validate_uuid4(name):
  66             for ns in self.list():
  67                 if name == ns['name']:
  68                     ns_id = ns['_id']
  69                     break
  70         resp = self._http.get_cmd('{}/{}'.format(self._apiBase, ns_id))
  71         #resp = self._http.get_cmd('{}/{}/nsd_content'.format(self._apiBase, ns_id))
  72         #print yaml.safe_dump(resp)
  73         if resp:
  74             return resp
  75         raise NotFound("ns {} not found".format(name))
  76
  77     def delete(self, name):
  78         ns = self.get(name)
  79         http_code, resp = self._http.delete_cmd('{}/{}'.format(self._apiBase,ns['_id']))
  80         if resp:
  81             resp = json.loads(resp)
  82         #print 'RESP: {}'.format(resp)
  83         if http_code == 202:
  84             print 'Deletion in progress'
  85         elif http_code == 204:
  86             print 'Deleted'
  87         else:
  88             raise ClientException("failed to delete ns {}: {}".format(name, resp))
  89
  90     def create(self, nsd_name, nsr_name, account, config=None,
  91                ssh_keys=None, description='default description',
  92                admin_status='ENABLED'):
  93
  94         nsd = self._client.nsd.get(nsd_name)
  95
  96         vim_account_id = {}
  97
  98         def get_vim_account_id(vim_account):
  99             if vim_account_id.get(vim_account):
 100                 return vim_account_id[vim_account]
 101
 102             vim = self._client.vim.get(vim_account)
 103             if vim is None:
 104                 raise NotFound("cannot find vim account '{}'".format(vim_account))
 105             vim_account_id[vim_account] = vim['_id']
 106             return vim['_id']
 107
 108         ns = {}
 109         ns['nsdId'] = nsd['_id']
 110         ns['nsName'] = nsr_name
 111         ns['nsDescription'] = description
 112         ns['vimAccountId'] = get_vim_account_id(account)
 113         #ns['userdata'] = {}
 114         #ns['userdata']['key1']='value1'
 115         #ns['userdata']['key2']='value2'
 116
 117         if ssh_keys is not None:
 118             # ssh_keys is comma separate list
 119             # ssh_keys_format = []
 120             # for key in ssh_keys.split(','):
 121             #     ssh_keys_format.append({'key-pair-ref': key})
 122             #
 123             # ns['ssh-authorized-key'] = ssh_keys_format
 124             ns['ssh-authorized-key'] = []
 125             for pubkeyfile in ssh_keys.split(','):
 126                 with open(pubkeyfile, 'r') as f:
 127                     ns['ssh-authorized-key'].append(f.read())
 128         if config:
 129             ns_config = yaml.load(config)
 130             if "vim-network-name" in ns_config:
 131                 ns_config["vld"] = ns_config.pop("vim-network-name")
 132             if "vld" in ns_config:
 133                 for vld in ns_config["vld"]:
 134                     if vld.get("vim-network-name"):
 135                         if isinstance(vld["vim-network-name"], dict):
 136                             vim_network_name_dict = {}
 137                             for vim_account, vim_net in vld["vim-network-name"].items():
 138                                 vim_network_name_dict[get_vim_account_id(vim_account)] = vim_net
 139                             vld["vim-network-name"] = vim_network_name_dict
 140                 ns["vld"] = ns_config["vld"]
 141             if "vnf" in ns_config:
 142                 for vnf in ns_config["vnf"]:
 143                     if vnf.get("vim_account"):
 144                         vnf["vimAccountId"] = get_vim_account_id(vnf.pop("vim_account"))
 145
 146                 ns["vnf"] = ns_config["vnf"]
 147
 148         #print yaml.safe_dump(ns)
 149         try:
 150             self._apiResource = '/ns_instances_content'
 151             self._apiBase = '{}{}{}'.format(self._apiName,
 152                                             self._apiVersion, self._apiResource)
 153             http_code, resp = self._http.post_cmd(endpoint=self._apiBase,
 154                                        postfields_dict=ns)
 155             if resp:
 156                 resp = json.loads(resp)
 157             #print 'RESP: {}'.format(resp)
 158             if not resp or 'id' not in resp:
 159                 raise ClientException('unexpected response from server: '.format(
 160                                       resp))
 161             else:
 162                 print resp['id']
 163         except ClientException as exc:
 164             message="failed to create ns: {} nsd: {}\nerror:\n{}".format(
 165                     nsr_name,
 166                     nsd_name,
 167                     exc.message)
 168             raise ClientException(message)
 169
 170     def list_op(self, name, filter=None):
 171         """Returns the list of operations of a NS
 172         """
 173         ns = self.get(name)
 174         try:
 175             self._apiResource = '/ns_lcm_op_occs'
 176             self._apiBase = '{}{}{}'.format(self._apiName,
 177                                       self._apiVersion, self._apiResource)
 178             filter_string = ''
 179             if filter:
 180                 filter_string = '&{}'.format(filter)
 181             http_code, resp = self._http.get2_cmd('{}?nsInstanceId={}'.format(self._apiBase, ns['_id'],
 182                                                                   filter_string) )
 183             resp = json.loads(resp)
 184             #print 'RESP: {}'.format(resp)
 185             if http_code == 200:
 186                 return resp
 187             else:
 188                 raise ClientException('{}'.format(resp['detail']))
 189
 190         except ClientException as exc:
 191             message="failed to get operation list of NS {}:\nerror:\n{}".format(
 192                     name,
 193                     exc.message)
 194             raise ClientException(message)
 195
 196     def get_op(self, operationId):
 197         """Returns the status of an operation
 198         """
 199         try:
 200             self._apiResource = '/ns_lcm_op_occs'
 201             self._apiBase = '{}{}{}'.format(self._apiName,
 202                                       self._apiVersion, self._apiResource)
 203             http_code, resp = self._http.get2_cmd('{}/{}'.format(self._apiBase, operationId))
 204             resp = json.loads(resp)
 205             #print 'RESP: {}'.format(resp)
 206             if http_code == 200:
 207                 return resp
 208             else:
 209                 raise ClientException("{}".format(resp['detail']))
 210         except ClientException as exc:
 211             message="failed to get status of operation {}:\nerror:\n{}".format(
 212                     operationId,
 213                     exc.message)
 214             raise ClientException(message)
 215
 216     def exec_op(self, name, op_name, op_data=None):
 217         """Executes an operation on a NS
 218         """
 219         ns = self.get(name)
 220         try:
 221             self._apiResource = '/ns_instances'
 222             self._apiBase = '{}{}{}'.format(self._apiName,
 223                                             self._apiVersion, self._apiResource)
 224             endpoint = '{}/{}/{}'.format(self._apiBase, ns['_id'], op_name)
 225             #print 'OP_NAME: {}'.format(op_name)
 226             #print 'OP_DATA: {}'.format(json.dumps(op_data))
 227             http_code, resp = self._http.post_cmd(endpoint=endpoint, postfields_dict=op_data)
 228             if resp:
 229                 resp = json.loads(resp)
 230             #print 'RESP: {}'.format(resp)
 231             if not resp or 'id' not in resp:
 232                 raise ClientException('unexpected response from server: '.format(
 233                                       resp))
 234             else:
 235                 print resp['id']
 236         except ClientException as exc:
 237             message="failed to exec operation {}:\nerror:\n{}".format(
 238                     name,
 239                     exc.message)
 240             raise ClientException(message)
 241
 242     def create_alarm(self, alarm):
 243         data = {}
 244         data["create_alarm_request"] = {}
 245         data["create_alarm_request"]["alarm_create_request"] = alarm
 246         try:
 247             http_code, resp = self._http.post_cmd(endpoint='/test/message/alarm_request',
 248                                        postfields_dict=data)
 249             if http_code in (200, 201, 202, 204):
 250                 #resp = json.loads(resp)
 251                 #print 'RESP: {}'.format(resp)
 252                 print 'Alarm created'
 253             else:
 254                 raise ClientException('unexpected response from server: code: {}, resp: {}'.format(
 255                                       http_code, resp))
 256         except ClientException as exc:
 257             message="failed to create alarm: alarm {}\nerror:\n{}".format(
 258                     alarm,
 259                     exc.message)
 260             raise ClientException(message)
 261
 262     def delete_alarm(self, name):
 263         data = {}
 264         data["delete_alarm_request"] = {}
 265         data["delete_alarm_request"]["alarm_delete_request"] = {}
 266         data["delete_alarm_request"]["alarm_delete_request"]["alarm_uuid"] = name
 267         try:
 268             http_code, resp = self._http.post_cmd(endpoint='/test/message/alarm_request',
 269                                        postfields_dict=data)
 270             if http_code in (200, 201, 202, 204):
 271                 #resp = json.loads(resp)
 272                 #print 'RESP: {}'.format(resp)
 273                 print 'Alarm deleted'
 274             else:
 275                 raise ClientException('unexpected response from server: code: {}, resp: {}'.format(
 276                                       http_code, resp))
 277         except ClientException as exc:
 278             message="failed to delete alarm: alarm {}\nerror:\n{}".format(
 279                     alarm,
 280                     exc.message)
 281             raise ClientException(message)
 282
 283     def export_metric(self, metric):
 284         data = {}
 285         data["read_metric_data_request"] = metric
 286         try:
 287             http_code, resp = self._http.post_cmd(endpoint='/test/message/metric_request',
 288                                        postfields_dict=data)
 289             if http_code in (200, 201, 202, 204):
 290                 #resp = json.loads(resp)
 291                 #print 'RESP: {}'.format(resp)
 292                 return 'Metric exported'
 293             else:
 294                 raise ClientException('unexpected response from server: code: {}, resp: {}'.format(
 295                                       http_code, resp))
 296         except ClientException as exc:
 297             message="failed to export metric: metric {}\nerror:\n{}".format(
 298                     metric,
 299                     exc.message)
 300             raise ClientException(message)
 301