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 yaml
  25 import json
  26 import magic
  27 #from os import stat
  28 #from os.path import basename
  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         if mime_type in ['application/yaml', 'text/plain']:
 131             headers['Content-Type'] = 'application/yaml'
 132         elif mime_type == 'application/gzip':
 133             headers['Content-Type'] = 'application/gzip'
 134             #headers['Content-Type'] = 'application/binary'
 135             # Next three lines are to be removed in next version
 136             #headers['Content-Filename'] = basename(filename)
 137             #file_size = stat(filename).st_size
 138             #headers['Content-Range'] = 'bytes 0-{}/{}'.format(file_size - 1, file_size)
 139         else:
 140             raise ClientException(
 141                      "Unexpected MIME type for file {}: MIME type {}".format(
 142                          filename, mime_type)
 143                   )
 144         headers["Content-File-MD5"] = utils.md5(filename)
 145         http_header = ['{}: {}'.format(key,val)
 146                       for (key,val) in headers.items()]
 147         self._http.set_http_header(http_header)
 148         if update_endpoint:
 149             http_code, resp = self._http.put_cmd(endpoint=update_endpoint, filename=filename)
 150         else:
 151             ow_string = ''
 152             if overwrite:
 153                 ow_string = '?{}'.format(overwrite)
 154             self._apiResource = '/ns_descriptors_content'
 155             self._apiBase = '{}{}{}'.format(self._apiName,
 156                                             self._apiVersion, self._apiResource)
 157             endpoint = '{}{}'.format(self._apiBase,ow_string)
 158             http_code, resp = self._http.post_cmd(endpoint=endpoint, filename=filename)
 159         #print 'HTTP CODE: {}'.format(http_code)
 160         #print 'RESP: {}'.format(resp)
 161         if http_code in (200, 201, 202, 204):
 162             if resp:
 163                 resp = json.loads(resp)
 164             if not resp or 'id' not in resp:
 165                 raise ClientException('unexpected response from server - {}'.format(
 166                                       resp))
 167             print resp['id']
 168         else:
 169             msg = ""
 170             if resp:
 171                 try:
 172                     msg = json.loads(resp)
 173                 except ValueError:
 174                     msg = resp
 175             raise ClientException("failed to create/update nsd - {}".format(name, msg))
 176
 177     def update(self, name, filename):
 178         nsd = self.get(name)
 179         endpoint = '{}/{}/nsd_content'.format(self._apiBase, nsd['_id'])
 180         self.create(filename=filename, update_endpoint=endpoint)
 181