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