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 import utils
  24 import json
  25 import magic
  26 import logging
  27 import os.path
  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         try:
  74             _, resp = self._http.get2_cmd('{}/{}'.format(self._apiBase, nst['_id']))
  75             #print(yaml.safe_dump(resp))
  76             if resp:
  77                 return json.loads(resp)
  78         except NotFound:
  79             raise NotFound("nst '{}' not found".format(name))
  80         raise NotFound("nst '{}' not found".format(name))
  81
  82     def get_thing(self, name, thing, filename):
  83         self._logger.debug("")
  84         nst = self.get(name)
  85         headers = self._client._headers
  86         headers['Accept'] = 'application/binary'
  87         try:
  88             http_code, resp = self._http.get2_cmd('{}/{}/{}'.format(self._apiBase, nst['_id'], thing))
  89         except NotFound:
  90             raise NotFound("nst '{} 'not found".format(name))
  91         #print('HTTP CODE: {}'.format(http_code))
  92         #print('RESP: {}'.format(resp))
  93         #if http_code in (200, 201, 202, 204):
  94         if resp:
  95             #store in a file
  96             return json.loads(resp)
  97         #else:
  98         #    msg = ""
  99         #    if resp:
 100         #        try:
 101         #            msg = json.loads(resp)
 102         #        except ValueError:
 103         #            msg = resp
 104         #    raise ClientException("failed to get {} from {} - {}".format(thing, name, msg))
 105
 106     def get_descriptor(self, name, filename):
 107         self._logger.debug("")
 108         self.get_thing(name, 'nst', filename)
 109
 110     def get_package(self, name, filename):
 111         self._logger.debug("")
 112         self.get_thing(name, 'nst_content', filename)
 113
 114     def get_artifact(self, name, artifact, filename):
 115         self._logger.debug("")
 116         self.get_thing(name, 'artifacts/{}'.format(artifact), filename)
 117
 118     def delete(self, name, force=False):
 119         self._logger.debug("")
 120         nst = self.get(name)
 121         querystring = ''
 122         if force:
 123             querystring = '?FORCE=True'
 124         http_code, resp = self._http.delete_cmd('{}/{}{}'.format(self._apiBase,
 125                                          nst['_id'], querystring))
 126         #print('HTTP CODE: {}'.format(http_code))
 127         #print('RESP: {}'.format(resp))
 128         if http_code == 202:
 129             print('Deletion in progress')
 130         elif http_code == 204:
 131             print('Deleted')
 132         else:
 133             msg = resp or ""
 134             # if resp:
 135             #     try:
 136             #         resp = json.loads(resp)
 137             #     except ValueError:
 138             #         msg = resp
 139             raise ClientException("failed to delete nst {} - {}".format(name, msg))
 140
 141     def create(self, filename, overwrite=None, update_endpoint=None):
 142         self._logger.debug("")
 143         if os.path.isdir(filename):
 144             charm_folder = filename.rstrip('/')
 145             for files in os.listdir(charm_folder):
 146                 if "nst.yaml" in files:
 147                     results = self._client.package_tool.validate(charm_folder, recursive=False)
 148                     for result in results:
 149                         if result["valid"] != "OK":
 150                             raise ClientException('There was an error validating the file: {} '
 151                                                   'with error: {}'.format(result["path"], result["error"]))
 152             result = self._client.package_tool.build(charm_folder)
 153             if 'Created' in result:
 154                 filename = "{}.tar.gz".format(charm_folder)
 155             else:
 156                 raise ClientException('Failed in {}tar.gz creation'.format(charm_folder))
 157             self.create(filename, overwrite, update_endpoint)
 158         else:
 159             self._client.get_token()
 160             mime_type = magic.from_file(filename, mime=True)
 161             if mime_type is None:
 162                 raise ClientException(
 163                          "Unexpected MIME type for file {}: MIME type {}".format(
 164                              filename, mime_type)
 165                       )
 166             headers= self._client._headers
 167             if mime_type in ['application/yaml', 'text/plain']:
 168                 headers['Content-Type'] = 'application/yaml'
 169             elif mime_type in ['application/gzip', 'application/x-gzip']:
 170                 headers['Content-Type'] = 'application/gzip'
 171                 #headers['Content-Type'] = 'application/binary'
 172                 # Next three lines are to be removed in next version
 173                 #headers['Content-Filename'] = basename(filename)
 174                 #file_size = stat(filename).st_size
 175                 #headers['Content-Range'] = 'bytes 0-{}/{}'.format(file_size - 1, file_size)
 176             else:
 177                 raise ClientException(
 178                          "Unexpected MIME type for file {}: MIME type {}".format(
 179                              filename, mime_type)
 180                       )
 181             headers["Content-File-MD5"] = utils.md5(filename)
 182             http_header = ['{}: {}'.format(key,val)
 183                           for (key,val) in list(headers.items())]
 184             self._http.set_http_header(http_header)
 185             if update_endpoint:
 186                 http_code, resp = self._http.put_cmd(endpoint=update_endpoint, filename=filename)
 187             else:
 188                 ow_string = ''
 189                 if overwrite:
 190                     ow_string = '?{}'.format(overwrite)
 191                 self._apiResource = '/netslice_templates_content'
 192                 self._apiBase = '{}{}{}'.format(self._apiName,
 193                                                 self._apiVersion, self._apiResource)
 194                 endpoint = '{}{}'.format(self._apiBase,ow_string)
 195                 http_code, resp = self._http.post_cmd(endpoint=endpoint, filename=filename)
 196             #print('HTTP CODE: {}'.format(http_code))
 197             #print('RESP: {}'.format(resp))
 198             # if http_code in (200, 201, 202, 204):
 199             if resp:
 200                 resp = json.loads(resp)
 201             if not resp or 'id' not in resp:
 202                 raise ClientException('unexpected response from server - {}'.format(resp))
 203             print(resp['id'])
 204             # else:
 205             #     msg = "Error {}".format(http_code)
 206             #     if resp:
 207             #         try:
 208             #             msg = "{} - {}".format(msg, json.loads(resp))
 209             #         except ValueError:
 210             #             msg = "{} - {}".format(msg, resp)
 211             #     raise ClientException("failed to create/update nst - {}".format(msg))
 212
 213     def update(self, name, filename):
 214         self._logger.debug("")
 215         nst = self.get(name)
 216         endpoint = '{}/{}/nst_content'.format(self._apiBase, nst['_id'])
 217         self.create(filename=filename, update_endpoint=endpoint)
 218