osmclient/sol005/nst.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 NST (Network Slice Template) 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 import logging
  27 import os.path
  28
  29 # from os import stat
  30 # from os.path import basename
  31
  32
  33 class Nst(object):
  34     def __init__(self, http=None, client=None):
  35         self._http = http
  36         self._client = client
  37         self._logger = logging.getLogger("osmclient")
  38         self._apiName = "/nst"
  39         self._apiVersion = "/v1"
  40         self._apiResource = "/netslice_templates"
  41         self._apiBase = "{}{}{}".format(
  42             self._apiName, self._apiVersion, self._apiResource
  43         )
  44
  45     def list(self, filter=None):
  46         self._logger.debug("")
  47         self._client.get_token()
  48         filter_string = ""
  49         if filter:
  50             filter_string = "?{}".format(filter)
  51         _, resp = self._http.get2_cmd("{}{}".format(self._apiBase, filter_string))
  52         # print(yaml.safe_dump(resp))
  53         if resp:
  54             return json.loads(resp)
  55         return list()
  56
  57     def get(self, name):
  58         self._logger.debug("")
  59         self._client.get_token()
  60         if utils.validate_uuid4(name):
  61             for nst in self.list():
  62                 if name == nst["_id"]:
  63                     return nst
  64         else:
  65             for nst in self.list():
  66                 if "name" in nst and name == nst["name"]:
  67                     return nst
  68         raise NotFound("nst {} not found".format(name))
  69
  70     def get_individual(self, name):
  71         self._logger.debug("")
  72         nst = self.get(name)
  73         # It is redundant, since the previous one already gets the whole nstinfo
  74         # The only difference is that a different primitive is exercised
  75         try:
  76             _, resp = self._http.get2_cmd("{}/{}".format(self._apiBase, nst["_id"]))
  77             # print(yaml.safe_dump(resp))
  78             if resp:
  79                 return json.loads(resp)
  80         except NotFound:
  81             raise NotFound("nst '{}' not found".format(name))
  82         raise NotFound("nst '{}' not found".format(name))
  83
  84     def get_thing(self, name, thing, filename):
  85         self._logger.debug("")
  86         nst = self.get(name)
  87         headers = self._client._headers
  88         headers["Accept"] = "application/binary"
  89         try:
  90             http_code, resp = self._http.get2_cmd(
  91                 "{}/{}/{}".format(self._apiBase, nst["_id"], thing)
  92             )
  93         except NotFound:
  94             raise NotFound("nst '{} 'not found".format(name))
  95         # print('HTTP CODE: {}'.format(http_code))
  96         # print('RESP: {}'.format(resp))
  97         # if http_code in (200, 201, 202, 204):
  98         if resp:
  99             # store in a file
 100             return json.loads(resp)
 101         # else:
 102         #    msg = ""
 103         #    if resp:
 104         #        try:
 105         #            msg = json.loads(resp)
 106         #        except ValueError:
 107         #            msg = resp
 108         #    raise ClientException("failed to get {} from {} - {}".format(thing, name, msg))
 109
 110     def get_descriptor(self, name, filename):
 111         self._logger.debug("")
 112         self.get_thing(name, "nst", filename)
 113
 114     def get_package(self, name, filename):
 115         self._logger.debug("")
 116         self.get_thing(name, "nst_content", filename)
 117
 118     def get_artifact(self, name, artifact, filename):
 119         self._logger.debug("")
 120         self.get_thing(name, "artifacts/{}".format(artifact), filename)
 121
 122     def delete(self, name, force=False):
 123         self._logger.debug("")
 124         nst = self.get(name)
 125         querystring = ""
 126         if force:
 127             querystring = "?FORCE=True"
 128         http_code, resp = self._http.delete_cmd(
 129             "{}/{}{}".format(self._apiBase, nst["_id"], querystring)
 130         )
 131         # print('HTTP CODE: {}'.format(http_code))
 132         # print('RESP: {}'.format(resp))
 133         if http_code == 202:
 134             print("Deletion in progress")
 135         elif http_code == 204:
 136             print("Deleted")
 137         else:
 138             msg = resp or ""
 139             # if resp:
 140             #     try:
 141             #         resp = json.loads(resp)
 142             #     except ValueError:
 143             #         msg = resp
 144             raise ClientException("failed to delete nst {} - {}".format(name, msg))
 145
 146     def create(self, filename, overwrite=None, update_endpoint=None):
 147         self._logger.debug("")
 148         if os.path.isdir(filename):
 149             charm_folder = filename.rstrip("/")
 150             for files in os.listdir(charm_folder):
 151                 if "nst.yaml" in files:
 152                     results = self._client.package_tool.validate(
 153                         charm_folder, recursive=False
 154                     )
 155                     for result in results:
 156                         if result["valid"] != "OK":
 157                             raise ClientException(
 158                                 "There was an error validating the file: {} "
 159                                 "with error: {}".format(result["path"], result["error"])
 160                             )
 161             result = self._client.package_tool.build(charm_folder)
 162             if "Created" in result:
 163                 filename = "{}.tar.gz".format(charm_folder)
 164             else:
 165                 raise ClientException(
 166                     "Failed in {}tar.gz creation".format(charm_folder)
 167                 )
 168             self.create(filename, overwrite, update_endpoint)
 169         else:
 170             self._client.get_token()
 171             mime_type = magic.from_file(filename, mime=True)
 172             if mime_type is None:
 173                 raise ClientException(
 174                     "Unexpected MIME type for file {}: MIME type {}".format(
 175                         filename, mime_type
 176                     )
 177                 )
 178             headers = self._client._headers
 179             if mime_type in ["application/yaml", "text/plain"]:
 180                 headers["Content-Type"] = "application/yaml"
 181             elif mime_type in ["application/gzip", "application/x-gzip"]:
 182                 headers["Content-Type"] = "application/gzip"
 183                 # headers['Content-Type'] = 'application/binary'
 184                 # Next three lines are to be removed in next version
 185                 # headers['Content-Filename'] = basename(filename)
 186                 # file_size = stat(filename).st_size
 187                 # headers['Content-Range'] = 'bytes 0-{}/{}'.format(file_size - 1, file_size)
 188             else:
 189                 raise ClientException(
 190                     "Unexpected MIME type for file {}: MIME type {}".format(
 191                         filename, mime_type
 192                     )
 193                 )
 194             headers["Content-File-MD5"] = utils.md5(filename)
 195             http_header = [
 196                 "{}: {}".format(key, val) for (key, val) in list(headers.items())
 197             ]
 198             self._http.set_http_header(http_header)
 199             if update_endpoint:
 200                 http_code, resp = self._http.put_cmd(
 201                     endpoint=update_endpoint, filename=filename
 202                 )
 203             else:
 204                 ow_string = ""
 205                 if overwrite:
 206                     ow_string = "?{}".format(overwrite)
 207                 self._apiResource = "/netslice_templates_content"
 208                 self._apiBase = "{}{}{}".format(
 209                     self._apiName, self._apiVersion, self._apiResource
 210                 )
 211                 endpoint = "{}{}".format(self._apiBase, ow_string)
 212                 http_code, resp = self._http.post_cmd(
 213                     endpoint=endpoint, filename=filename
 214                 )
 215             # print('HTTP CODE: {}'.format(http_code))
 216             # print('RESP: {}'.format(resp))
 217             # if http_code in (200, 201, 202, 204):
 218             if resp:
 219                 resp = json.loads(resp)
 220             if not resp or "id" not in resp:
 221                 raise ClientException(
 222                     "unexpected response from server - {}".format(resp)
 223                 )
 224             print(resp["id"])
 225             # else:
 226             #     msg = "Error {}".format(http_code)
 227             #     if resp:
 228             #         try:
 229             #             msg = "{} - {}".format(msg, json.loads(resp))
 230             #         except ValueError:
 231             #             msg = "{} - {}".format(msg, resp)
 232             #     raise ClientException("failed to create/update nst - {}".format(msg))
 233
 234     def update(self, name, filename):
 235         self._logger.debug("")
 236         nst = self.get(name)
 237         endpoint = "{}/{}/nst_content".format(self._apiBase, nst["_id"])
 238         self.create(filename=filename, update_endpoint=endpoint)