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