multivimbroker/multivimbroker/forwarder/views.py

   1 # Copyright 2017 Wind River Systems, Inc.
   2 # Copyright (c) 2017-2018 VMware, Inc.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 #         http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 # import os
  17 import json
  18 # import re
  19 # import tempfile
  20 # from django.core.files.uploadedfile import InMemoryUploadedFile
  21 # from poster.encode import multipart_encode
  22 # from poster.streaminghttp import register_openers
  23
  24 from rest_framework.views import APIView
  25 from rest_framework.views import Response
  26 from rest_framework.views import status
  27 from multivimbroker.forwarder.base import BaseHandler
  28 from multivimbroker.pub.utils.syscomm import originHeaders
  29 from multivimbroker.pub.utils import syscomm
  30 from multivimbroker.pub.msapi import extsys
  31
  32
  33 class BaseServer(BaseHandler, APIView):
  34
  35     def get(self, request, vimid):
  36         raise NotImplementedError()
  37
  38     def post(self, request, vimid):
  39         raise NotImplementedError()
  40
  41     def put(self, request, vimid):
  42         raise NotImplementedError()
  43
  44     def delete(self, request, vimid):
  45         raise NotImplementedError()
  46
  47     def head(self, request, vimid):
  48         raise NotImplementedError()
  49
  50     def patch(self, request, vimid):
  51         raise NotImplementedError()
  52
  53
  54 # proxy handler
  55 class Identity(BaseServer):
  56
  57     def get(self, request, vimid):
  58
  59         return self.send(vimid, request.get_full_path(), request.body, "GET",
  60                          headers=originHeaders(request))
  61
  62     def post(self, request, vimid):
  63
  64         return self.send(vimid, request.get_full_path(), request.body, "POST",
  65                          headers=originHeaders(request))
  66
  67
  68 class Registry(BaseServer):
  69
  70     def post(self, request, vimid):
  71
  72         return self.send(vimid, request.get_full_path(), request.body, "POST",
  73                          headers=originHeaders(request))
  74
  75
  76 class UnRegistry(BaseServer):
  77
  78     def delete(self, request, vimid):
  79
  80         return self.send(vimid, request.get_full_path(), request.body,
  81                          "DELETE", headers=originHeaders(request))
  82
  83
  84 class Extension(BaseServer):
  85
  86     def get(self, request, vimid):
  87
  88         return self.send(vimid, request.get_full_path(), request.body, "GET",
  89                          headers=originHeaders(request))
  90
  91
  92 class VIMTypes(BaseServer):
  93
  94     def get(self, request):
  95         return Response(data=syscomm.getVIMTypes(), status=status.HTTP_200_OK)
  96
  97
  98 class CheckCapacity(BaseServer):
  99
 100     def post(self, request):
 101         try:
 102             body = json.loads(request.body)
 103         except ValueError as e:
 104             return Response(
 105                 data={'error': 'Invalidate request body %s.' % e},
 106                 status=status.HTTP_400_BAD_REQUEST)
 107
 108         ret = {"VIMs": []}
 109         newbody = {
 110             "vCPU": body.get("vCPU", 0),
 111             "Memory": body.get("Memory", 0),
 112             "Storage": body.get("Storage", 0)
 113         }
 114         for vim in body.get("VIMs", []):
 115             url = request.get_full_path().replace(
 116                 "check_vim_capacity", "%s/capacity_check" % vim)
 117             resp = self.send(vim, url, json.dumps(newbody), "POST",
 118                              headers=originHeaders(request))
 119             if int(resp.status_code) != status.HTTP_200_OK:
 120                 continue
 121             try:
 122                 resp_body = json.loads(resp.content)
 123             except ValueError:
 124                 continue
 125             if not resp_body.get("result", False):
 126                 continue
 127             ret['VIMs'].append(vim)
 128         return Response(data=ret, status=status.HTTP_200_OK)
 129
 130
 131 # forward  handler
 132 class Forward(BaseServer):
 133
 134     def get(self, request, vimid):
 135
 136         return self.send(vimid, request.get_full_path(), request.body, "GET",
 137                          headers=originHeaders(request))
 138
 139     def post(self, request, vimid):
 140
 141         return self.send(vimid, request.get_full_path(), request.body, "POST",
 142                          headers=originHeaders(request))
 143
 144     def patch(self, request, vimid):
 145
 146         return self.send(vimid, request.get_full_path(), request.body, "PATCH",
 147                          headers=originHeaders(request))
 148
 149     def delete(self, request, vimid):
 150
 151         return self.send(vimid, request.get_full_path(), request.body,
 152                          "DELETE", headers=originHeaders(request))
 153
 154     def head(self, request, vimid):
 155
 156         return self.send(vimid, request.get_full_path(), request.body, "HEAD",
 157                          headers=originHeaders(request))
 158
 159     def put(self, request, vimid):
 160
 161         return self.send(vimid, request.get_full_path(), request.body, "PUT",
 162                          headers=originHeaders(request))
 163
 164
 165 # API v1
 166 # proxy handler
 167 class APIv1Identity(Identity):
 168
 169     def get(self, request, cloud_owner, cloud_region_id):
 170         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 171         return super(APIv1Identity, self).get(request, vimid)
 172
 173     def post(self, request, cloud_owner, cloud_region_id):
 174         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 175         return super(APIv1Identity, self).post(request, vimid)
 176
 177
 178 class APIv1Registry(Registry):
 179
 180     def post(self, request, cloud_owner, cloud_region_id):
 181         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 182         return super(APIv1Registry, self).post(request, vimid)
 183
 184
 185 class APIv1UnRegistry(UnRegistry):
 186
 187     def delete(self, request, cloud_owner, cloud_region_id):
 188         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 189         return super(APIv1UnRegistry, self).delete(request, vimid)
 190
 191
 192 class APIv1Extension(Extension):
 193
 194     def get(self, request, cloud_owner, cloud_region_id):
 195         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 196         return super(APIv1Extension, self).get(request, vimid)
 197
 198
 199 class APIv1VIMTypes(VIMTypes):
 200
 201     def get(self, request):
 202         return super(APIv1VIMTypes, self).get(request)
 203
 204
 205 class APIv1CheckCapacity(CheckCapacity):
 206
 207     def post(self, request):
 208         try:
 209             body = json.loads(request.body)
 210         except ValueError as e:
 211             return Response(
 212                 data={'error': 'Invalidate request body %s.' % e},
 213                 status=status.HTTP_400_BAD_REQUEST)
 214
 215         ret = {"VIMs": []}
 216         newbody = {
 217             "vCPU": body.get("vCPU", 0),
 218             "Memory": body.get("Memory", 0),
 219             "Storage": body.get("Storage", 0)
 220         }
 221         for vim in body.get("VIMs", []):
 222             cloud_owner = vim["cloud-owner"]
 223             cloud_region_id = vim["cloud-region-id"]
 224             url = request.get_full_path().replace(
 225                 "check_vim_capacity", "%s/%s/capacity_check" %
 226                                       (cloud_owner, cloud_region_id))
 227             vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 228             resp = self.send(vimid, url, json.dumps(newbody), "POST",
 229                              headers=originHeaders(request))
 230
 231             if int(resp.status_code) != status.HTTP_200_OK:
 232                 continue
 233
 234             try:
 235                 resp_body = json.loads(resp.content)
 236             except ValueError:
 237                 continue
 238             if not resp_body.get("result", False):
 239                 continue
 240             azCapInfo = resp_body.get("AZs", [])
 241             vim["AZs"] = azCapInfo
 242             ret['VIMs'].append(vim)
 243         return Response(data=ret, status=status.HTTP_200_OK)
 244
 245
 246 # forward  handler
 247 class APIv1Forward(Forward):
 248
 249     def get(self, request, cloud_owner, cloud_region_id):
 250         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 251         return super(APIv1Forward, self).get(request, vimid)
 252
 253     def post(self, request, cloud_owner, cloud_region_id):
 254         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 255         return super(APIv1Forward, self).post(request, vimid)
 256
 257     def patch(self, request, cloud_owner, cloud_region_id):
 258         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 259         return super(APIv1Forward, self).patch(request, vimid)
 260
 261     def delete(self, request, cloud_owner, cloud_region_id):
 262         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 263         return super(APIv1Forward, self).delete(request, vimid)
 264
 265     def head(self, request, cloud_owner, cloud_region_id):
 266         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 267         return super(APIv1Forward, self).head(request, vimid)
 268
 269     def put(self, request, cloud_owner, cloud_region_id):
 270         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 271         return super(APIv1Forward, self).put(request, vimid)
 272
 273
 274 class APIv1InfraWorkload(BaseServer):
 275
 276     def post(self, request, cloud_owner, cloud_region_id):
 277         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 278         content_type = request.META.get('CONTENT_TYPE', 'application/json')
 279         if content_type.startswith("multipart"):
 280             return self.__process_multipart(request, vimid)
 281         return self.send(vimid, request.get_full_path(), request.body, "POST",
 282                          headers=originHeaders(request))
 283
 284     def get(self, request, cloud_owner, cloud_region_id):
 285         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 286         return self.send(vimid, request.get_full_path(), request.body, "GET",
 287                          headers=originHeaders(request))
 288
 289     def delete(self, request, cloud_owner, cloud_region_id):
 290         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 291         return self.send(vimid, request.get_full_path(), request.body,
 292                          "DELETE", headers=originHeaders(request))
 293
 294     def __process_multipart(self, request, vimid):
 295         return Response(
 296             data={'error': 'multipart API is not supported yet'},
 297             status=status.HTTP_400_BAD_REQUEST)
 298 #        try:
 299 #            API is depreciated due to poster not available in py3
 300 #            register_openers()
 301 #            dataDict = dict(request.data.iterlists())
 302 #            params = {}
 303 #            for key in dataDict.keys():
 304 #                dataObj = dataDict[key][0]
 305 #                if isinstance(dataObj, InMemoryUploadedFile):
 306 #                    f = tempfile.NamedTemporaryFile(prefix="django_",
 307 #                                                    suffix=dataObj._name,
 308 #                                                    delete=False)
 309 #                    f.write(dataObj.file.read())
 310 #                    f.seek(dataObj.file.tell(), 0)
 311 #                    dataObj.file.close()
 312 #                    params[key] = open(f.name, 'rb')
 313 #                else:
 314 #                    params[key] = dataObj
 315 #             datagen, headers = multipart_encode(params)
 316 #             regex = re.compile('^HTTP_')
 317 #             for key, value in request.META.iteritems():
 318 #                if key.startswith("HTTP_"):
 319 #                    headers[regex.sub('', key).replace('_', '-')] = value
 320 #             resp = self.send(vimid, request.path, datagen, "POST",
 321 #                             headers=headers, multipart=True)
 322 #        finally:
 323 #             for key in params or {}:
 324 #                refobj = params[key]
 325 #                if type(refobj) is not unicode:
 326 #                    if refobj.closed is False:
 327 #                        print (refobj.close())
 328 #                    os.remove(refobj.name)
 329 #        return resp