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