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