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
  26
  27 class Ns(object):
  28
  29     def __init__(self, http=None, client=None):
  30         self._http = http
  31         self._client = client
  32         self._apiName = '/nslcm'
  33         self._apiVersion = '/v1'
  34         self._apiResource = '/ns_instances_content'
  35         self._apiBase = '{}{}{}'.format(self._apiName,
  36                                         self._apiVersion, self._apiResource)
  37
  38     def list(self, filter=None):
  39         """Returns a list of NS
  40         """
  41         filter_string = ''
  42         if filter:
  43             filter_string = '?{}'.format(filter)
  44         resp = self._http.get_cmd('{}{}'.format(self._apiBase,filter_string))
  45         if resp:
  46             return resp
  47         return list()
  48
  49     def get(self, name):
  50         """Returns an NS based on name or id
  51         """
  52         if utils.validate_uuid4(name):
  53             for ns in self.list():
  54                 if name == ns['_id']:
  55                     return ns
  56         else:
  57             for ns in self.list():
  58                 if name == ns['name']:
  59                     return ns
  60         raise NotFound("ns {} not found".format(name))
  61
  62     def get_individual(self, name):
  63         ns_id = name
  64         if not utils.validate_uuid4(name):
  65             for ns in self.list():
  66                 if name == ns['name']:
  67                     ns_id = ns['_id']
  68                     break
  69         resp = self._http.get_cmd('{}/{}'.format(self._apiBase, ns_id))
  70         #resp = self._http.get_cmd('{}/{}/nsd_content'.format(self._apiBase, ns_id))
  71         #print yaml.safe_dump(resp)
  72         if resp:
  73             return resp
  74         raise NotFound("ns {} not found".format(name))
  75
  76     def delete(self, name):
  77         ns = self.get(name)
  78         resp = self._http.delete_cmd('{}/{}'.format(self._apiBase,ns['_id']))
  79         # print 'RESP: {}'.format(resp)
  80         if resp is None:
  81             print 'Deleted'
  82         else:
  83             raise ClientException("failed to delete ns {}: {}".format(name, resp))
  84
  85     def create(self, nsd_name, nsr_name, account, config=None,
  86                ssh_keys=None, description='default description',
  87                admin_status='ENABLED'):
  88
  89         nsd = self._client.nsd.get(nsd_name)
  90
  91         vim_account_id = {}
  92
  93         def get_vim_account_id(vim_account):
  94             if vim_account_id.get(vim_account):
  95                 return vim_account_id[vim_account]
  96
  97             vim = self._client.vim.get(vim_account)
  98             if vim is None:
  99                 raise NotFound("cannot find vim account '{}'".format(vim_account))
 100             vim_account_id[vim_account] = vim['_id']
 101             return vim['_id']
 102
 103         ns = {}
 104         ns['nsdId'] = nsd['_id']
 105         ns['nsName'] = nsr_name
 106         ns['nsDescription'] = description
 107         ns['vimAccountId'] = get_vim_account_id(account)
 108         #ns['userdata'] = {}
 109         #ns['userdata']['key1']='value1'
 110         #ns['userdata']['key2']='value2'
 111
 112         if ssh_keys is not None:
 113             # ssh_keys is comma separate list
 114             # ssh_keys_format = []
 115             # for key in ssh_keys.split(','):
 116             #     ssh_keys_format.append({'key-pair-ref': key})
 117             #
 118             # ns['ssh-authorized-key'] = ssh_keys_format
 119             ns['ssh-authorized-key'] = ssh_keys.split(',')
 120         if config:
 121             ns_config = yaml.load(config)
 122             if "vim-network-name" in ns_config:
 123                 ns_config["vld"] = ns_config.pop("vim-network-name")
 124             if "vld" in ns_config:
 125                 for vld in ns_config["vld"]:
 126                     if vld.get("vim-network-name"):
 127                         if isinstance(vld["vim-network-name"], dict):
 128                             vim_network_name_dict = {}
 129                             for vim_account, vim_net in vld["vim-network-name"].items():
 130                                 vim_network_name_dict[get_vim_account_id(vim_account)] = vim_net
 131                             vld["vim-network-name"] = vim_network_name_dict
 132                 ns["vld"] = ns_config["vld"]
 133             if "vnf" in ns_config:
 134                 for vnf in ns_config["vnf"]:
 135                     if vnf.get("vim_account"):
 136                         vnf["vimAccountId"] = get_vim_account_id(vnf.pop("vim_account"))
 137
 138                 ns["vnf"] = ns_config["vnf"]
 139
 140         #print yaml.safe_dump(ns)
 141         try:
 142             self._apiResource = '/ns_instances_content'
 143             self._apiBase = '{}{}{}'.format(self._apiName,
 144                                             self._apiVersion, self._apiResource)
 145             #print resp
 146             resp = self._http.post_cmd(endpoint=self._apiBase,
 147                                        postfields_dict=ns)
 148             if not resp or 'id' not in resp:
 149                 raise ClientException('unexpected response from server: '.format(
 150                                       resp))
 151             else:
 152                 print resp['id']
 153         except ClientException as exc:
 154             message="failed to create ns: {} nsd: {}\nerror:\n{}".format(
 155                     nsr_name,
 156                     nsd_name,
 157                     exc.message)
 158             raise ClientException(message)
 159