osmclient/sol005/vnfd.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 vnfd 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 Vnfd(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 = '/vnfpkgm'
  38         self._apiVersion = '/v1'
  39         self._apiResource = '/vnf_packages'
  40         self._apiBase = '{}{}{}'.format(self._apiName,
  41                                         self._apiVersion, self._apiResource)
  42         #self._apiBase='/vnfds'
  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.get2_cmd('{}{}'.format(self._apiBase,filter_string))
  51         if resp:
  52             return json.loads(resp)
  53         return list()
  54
  55     def get(self, name):
  56         self._logger.debug("")
  57         self._client.get_token()
  58         if utils.validate_uuid4(name):
  59             for vnfd in self.list():
  60                 if name == vnfd['_id']:
  61                     return vnfd
  62         else:
  63             for vnfd in self.list():
  64                 if 'name' in vnfd and name == vnfd['name']:
  65                     return vnfd
  66         raise NotFound("vnfd {} not found".format(name))
  67
  68     def get_individual(self, name):
  69         self._logger.debug("")
  70         vnfd = self.get(name)
  71         # It is redundant, since the previous one already gets the whole vnfpkginfo
  72         # The only difference is that a different primitive is exercised
  73         try:
  74             _, resp = self._http.get2_cmd('{}/{}'.format(self._apiBase, vnfd['_id']))
  75             #print(yaml.safe_dump(resp))
  76             if resp:
  77                 return json.loads(resp)
  78         except NotFound:
  79             raise NotFound("vnfd '{}' not found".format(name))
  80         raise NotFound("vnfd '{}' not found".format(name))
  81
  82     def get_thing(self, name, thing, filename):
  83         self._logger.debug("")
  84         vnfd = self.get(name)
  85         headers = self._client._headers
  86         headers['Accept'] = 'application/binary'
  87         http_code, resp = self._http.get2_cmd('{}/{}/{}'.format(self._apiBase, vnfd['_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 json.loads(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, 'vnfd', 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         self._client.get_token()
 118         vnfd = self.get(name)
 119         querystring = ''
 120         if force:
 121             querystring = '?FORCE=True'
 122         http_code, resp = self._http.delete_cmd('{}/{}{}'.format(self._apiBase,
 123                                          vnfd['_id'], querystring))
 124         #print('HTTP CODE: {}'.format(http_code))
 125         #print('RESP: {}'.format(resp))
 126         if http_code == 202:
 127             print('Deletion in progress')
 128         elif http_code == 204:
 129             print('Deleted')
 130         else:
 131             msg = resp or ""
 132             # if resp:
 133             #     try:
 134             #         msg = json.loads(resp)
 135             #     except ValueError:
 136             #         msg = resp
 137             raise ClientException("failed to delete vnfd {} - {}".format(name, msg))
 138
 139     def create(self, filename, overwrite=None, update_endpoint=None):
 140         self._logger.debug("")
 141         self._client.get_token()
 142         mime_type = magic.from_file(filename, mime=True)
 143         if mime_type is None:
 144             raise ClientException(
 145                      "failed to guess MIME type for file '{}'".format(filename))
 146         headers= self._client._headers
 147         headers['Content-Filename'] = basename(filename)
 148         if mime_type in ['application/yaml', 'text/plain', 'application/json']:
 149             headers['Content-Type'] = 'text/plain'
 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 = '/vnf_packages_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):
 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         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 vnfd - {}".format(msg))
 195
 196     def update(self, name, filename):
 197         self._logger.debug("")
 198         self._client.get_token()
 199         vnfd = self.get(name)
 200         endpoint = '{}/{}/package_content'.format(self._apiBase, vnfd['_id'])
 201         self.create(filename=filename, update_endpoint=endpoint)
 202