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.get_cmd('{}{}'.format(self._apiBase,filter_string))
  51         if resp:
  52             return 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         resp = self._http.get_cmd('{}/{}'.format(self._apiBase, vnfd['_id']))
  74         #print(yaml.safe_dump(resp))
  75         if resp:
  76             return resp
  77         raise NotFound("vnfd {} not found".format(name))
  78
  79     def get_thing(self, name, thing, filename):
  80         self._logger.debug("")
  81         vnfd = self.get(name)
  82         headers = self._client._headers
  83         headers['Accept'] = 'application/binary'
  84         http_code, resp = self._http.get2_cmd('{}/{}/{}'.format(self._apiBase, vnfd['_id'], thing))
  85         #print('HTTP CODE: {}'.format(http_code))
  86         #print('RESP: {}'.format(resp))
  87         if http_code in (200, 201, 202, 204):
  88             if resp:
  89                 #store in a file
  90                 return resp
  91         else:
  92             msg = ""
  93             if resp:
  94                 try:
  95                     msg = json.loads(resp)
  96                 except ValueError:
  97                     msg = resp
  98             raise ClientException("failed to get {} from {} - {}".format(thing, name, msg))
  99
 100     def get_descriptor(self, name, filename):
 101         self._logger.debug("")
 102         self.get_thing(name, 'vnfd', filename)
 103
 104     def get_package(self, name, filename):
 105         self._logger.debug("")
 106         self.get_thing(name, 'package_content', filename)
 107
 108     def get_artifact(self, name, artifact, filename):
 109         self._logger.debug("")
 110         self.get_thing(name, 'artifacts/{}'.format(artifact), filename)
 111
 112     def delete(self, name, force=False):
 113         self._logger.debug("")
 114         self._client.get_token()
 115         vnfd = self.get(name)
 116         querystring = ''
 117         if force:
 118             querystring = '?FORCE=True'
 119         http_code, resp = self._http.delete_cmd('{}/{}{}'.format(self._apiBase,
 120                                          vnfd['_id'], querystring))
 121         #print('HTTP CODE: {}'.format(http_code))
 122         #print('RESP: {}'.format(resp))
 123         if http_code == 202:
 124             print('Deletion in progress')
 125         elif http_code == 204:
 126             print('Deleted')
 127         else:
 128             msg = ""
 129             if resp:
 130                 try:
 131                     msg = json.loads(resp)
 132                 except ValueError:
 133                     msg = resp
 134             raise ClientException("failed to delete vnfd {} - {}".format(name, msg))
 135
 136     def create(self, filename, overwrite=None, update_endpoint=None):
 137         self._logger.debug("")
 138         self._client.get_token()
 139         mime_type = magic.from_file(filename, mime=True)
 140         if mime_type is None:
 141             raise ClientException(
 142                      "failed to guess MIME type for file '{}'".format(filename))
 143         headers= self._client._headers
 144         headers['Content-Filename'] = basename(filename)
 145         if mime_type in ['application/yaml', 'text/plain', 'application/json']:
 146             headers['Content-Type'] = 'text/plain'
 147         elif mime_type in ['application/gzip', 'application/x-gzip']:
 148             headers['Content-Type'] = 'application/gzip'
 149             #headers['Content-Type'] = 'application/binary'
 150             # Next three lines are to be removed in next version
 151             #headers['Content-Filename'] = basename(filename)
 152             #file_size = stat(filename).st_size
 153             #headers['Content-Range'] = 'bytes 0-{}/{}'.format(file_size - 1, file_size)
 154         else:
 155             raise ClientException(
 156                      "Unexpected MIME type for file {}: MIME type {}".format(
 157                          filename, mime_type)
 158                   )
 159         headers["Content-File-MD5"] = utils.md5(filename)
 160         http_header = ['{}: {}'.format(key,val)
 161                       for (key,val) in list(headers.items())]
 162         self._http.set_http_header(http_header)
 163         if update_endpoint:
 164             http_code, resp = self._http.put_cmd(endpoint=update_endpoint, filename=filename)
 165         else:
 166             ow_string = ''
 167             if overwrite:
 168                 ow_string = '?{}'.format(overwrite)
 169             self._apiResource = '/vnf_packages_content'
 170             self._apiBase = '{}{}{}'.format(self._apiName,
 171                                             self._apiVersion, self._apiResource)
 172             endpoint = '{}{}'.format(self._apiBase,ow_string)
 173             http_code, resp = self._http.post_cmd(endpoint=endpoint, filename=filename)
 174         #print('HTTP CODE: {}'.format(http_code))
 175         #print('RESP: {}'.format(resp))
 176         if http_code in (200, 201, 202):
 177             if resp:
 178                 resp = json.loads(resp)
 179             if not resp or 'id' not in resp:
 180                 raise ClientException('unexpected response from server: '.format(
 181                                       resp))
 182             print(resp['id'])
 183         elif http_code == 204:
 184             print('Updated')
 185         else:
 186             msg = "Error {}".format(http_code)
 187             if resp:
 188                 try:
 189                     msg = "{} - {}".format(msg, json.loads(resp))
 190                 except ValueError:
 191                     msg = "{} - {}".format(msg, resp)
 192             raise ClientException("failed to create/update vnfd - {}".format(msg))
 193
 194     def update(self, name, filename):
 195         self._logger.debug("")
 196         self._client.get_token()
 197         vnfd = self.get(name)
 198         endpoint = '{}/{}/package_content'.format(self._apiBase, vnfd['_id'])
 199         self.create(filename=filename, update_endpoint=endpoint)
 200