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