osmclient/sol005/nst.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 NST (Network Slice Template) API handling
  19 """
  20
  21 from osmclient.common.exceptions import NotFound
  22 from osmclient.common.exceptions import ClientException
  23 from osmclient.common.exceptions import OsmHttpException
  24 from osmclient.common import utils
  25 import json
  26 import magic
  27 import logging
  28 #from os import stat
  29 #from os.path import basename
  30
  31 class Nst(object):
  32
  33     def __init__(self, http=None, client=None):
  34         self._http = http
  35         self._client = client
  36         self._logger = logging.getLogger('osmclient')
  37         self._apiName = '/nst'
  38         self._apiVersion = '/v1'
  39         self._apiResource = '/netslice_templates'
  40         self._apiBase = '{}{}{}'.format(self._apiName,
  41                                         self._apiVersion, self._apiResource)
  42
  43     def list(self, filter=None):
  44         self._logger.debug("")
  45         self._client.get_token()
  46         filter_string = ''
  47         if filter:
  48             filter_string = '?{}'.format(filter)
  49         _, resp = self._http.get2_cmd('{}{}'.format(self._apiBase, filter_string))
  50         #print(yaml.safe_dump(resp))
  51         if resp:
  52             return json.loads(resp)
  53         return list()
  54
  55     def get(self, name):
  56         self._logger.debug("")
  57         self._client.get_token()
  58         if utils.validate_uuid4(name):
  59             for nst in self.list():
  60                 if name == nst['_id']:
  61                     return nst
  62         else:
  63             for nst in self.list():
  64                 if 'name' in nst and name == nst['name']:
  65                     return nst
  66         raise NotFound("nst {} not found".format(name))
  67
  68     def get_individual(self, name):
  69         self._logger.debug("")
  70         nst = self.get(name)
  71         # It is redundant, since the previous one already gets the whole nstinfo
  72         # The only difference is that a different primitive is exercised
  73         _, resp = self._http.get2_cmd('{}/{}'.format(self._apiBase, nst['_id']))
  74         #print(yaml.safe_dump(resp))
  75         if resp:
  76             return json.loads(resp)
  77         raise NotFound("nst {} not found".format(name))
  78
  79     def get_thing(self, name, thing, filename):
  80         self._logger.debug("")
  81         nst = self.get(name)
  82         headers = self._client._headers
  83         headers['Accept'] = 'application/binary'
  84         http_code, resp = self._http.get2_cmd('{}/{}/{}'.format(self._apiBase, nst['_id'], thing))
  85         #print('HTTP CODE: {}'.format(http_code))
  86         #print('RESP: {}'.format(resp))
  87         #if http_code in (200, 201, 202, 204):
  88         if resp:
  89             #store in a file
  90             return json.loads(resp)
  91         #else:
  92         #    msg = ""
  93         #    if resp:
  94         #        try:
  95         #            msg = json.loads(resp)
  96         #        except ValueError:
  97         #            msg = resp
  98         #    raise ClientException("failed to get {} from {} - {}".format(thing, name, msg))
  99
 100     def get_descriptor(self, name, filename):
 101         self._logger.debug("")
 102         self.get_thing(name, 'nst', filename)
 103
 104     def get_package(self, name, filename):
 105         self._logger.debug("")
 106         self.get_thing(name, 'nst_content', filename)
 107
 108     def get_artifact(self, name, artifact, filename):
 109         self._logger.debug("")
 110         self.get_thing(name, 'artifacts/{}'.format(artifact), filename)
 111
 112     def delete(self, name, force=False):
 113         self._logger.debug("")
 114         nst = self.get(name)
 115         querystring = ''
 116         if force:
 117             querystring = '?FORCE=True'
 118         http_code, resp = self._http.delete_cmd('{}/{}{}'.format(self._apiBase,
 119                                          nst['_id'], querystring))
 120         #print('HTTP CODE: {}'.format(http_code))
 121         #print('RESP: {}'.format(resp))
 122         if http_code == 202:
 123             print('Deletion in progress')
 124         elif http_code == 204:
 125             print('Deleted')
 126         else:
 127             msg = ""
 128             if resp:
 129                 try:
 130                     resp = json.loads(resp)
 131                 except ValueError:
 132                     msg = resp
 133             raise OsmHttpException("failed to delete nst {} - {}".format(name, msg))
 134
 135     def create(self, filename, overwrite=None, update_endpoint=None):
 136         self._logger.debug("")
 137         self._client.get_token()
 138         mime_type = magic.from_file(filename, mime=True)
 139         if mime_type is None:
 140             raise ClientException(
 141                      "failed to guess MIME type for file '{}'".format(filename))
 142         headers= self._client._headers
 143         if mime_type in ['application/yaml', 'text/plain']:
 144             headers['Content-Type'] = 'application/yaml'
 145         elif mime_type in ['application/gzip', 'application/x-gzip']:
 146             headers['Content-Type'] = 'application/gzip'
 147             #headers['Content-Type'] = 'application/binary'
 148             # Next three lines are to be removed in next version
 149             #headers['Content-Filename'] = basename(filename)
 150             #file_size = stat(filename).st_size
 151             #headers['Content-Range'] = 'bytes 0-{}/{}'.format(file_size - 1, file_size)
 152         else:
 153             raise ClientException(
 154                      "Unexpected MIME type for file {}: MIME type {}".format(
 155                          filename, mime_type)
 156                   )
 157         headers["Content-File-MD5"] = utils.md5(filename)
 158         http_header = ['{}: {}'.format(key,val)
 159                       for (key,val) in list(headers.items())]
 160         self._http.set_http_header(http_header)
 161         if update_endpoint:
 162             http_code, resp = self._http.put_cmd(endpoint=update_endpoint, filename=filename)
 163         else:
 164             ow_string = ''
 165             if overwrite:
 166                 ow_string = '?{}'.format(overwrite)
 167             self._apiResource = '/netslice_templates_content'
 168             self._apiBase = '{}{}{}'.format(self._apiName,
 169                                             self._apiVersion, self._apiResource)
 170             endpoint = '{}{}'.format(self._apiBase,ow_string)
 171             http_code, resp = self._http.post_cmd(endpoint=endpoint, filename=filename)
 172         #print('HTTP CODE: {}'.format(http_code))
 173         #print('RESP: {}'.format(resp))
 174         # if http_code in (200, 201, 202, 204):
 175         if resp:
 176             resp = json.loads(resp)
 177         if not resp or 'id' not in resp:
 178             raise OsmHttpException('unexpected response from server - {}'.format(resp))
 179         print(resp['id'])
 180         # else:
 181         #     msg = "Error {}".format(http_code)
 182         #     if resp:
 183         #         try:
 184         #             msg = "{} - {}".format(msg, json.loads(resp))
 185         #         except ValueError:
 186         #             msg = "{} - {}".format(msg, resp)
 187         #     raise ClientException("failed to create/update nst - {}".format(msg))
 188
 189     def update(self, name, filename):
 190         self._logger.debug("")
 191         nst = self.get(name)
 192         endpoint = '{}/{}/nst_content'.format(self._apiBase, nst['_id'])
 193         self.create(filename=filename, update_endpoint=endpoint)
 194