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