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     def get(self, request, vimid):
  76
  77         return self.send(vimid, request.get_full_path(), request.body, "GET",
  78                          headers=originHeaders(request))
  79
  80
  81 class UnRegistry(BaseServer):
  82
  83     def delete(self, request, vimid):
  84
  85         return self.send(vimid, request.get_full_path(), request.body,
  86                          "DELETE", headers=originHeaders(request))
  87
  88
  89 class Extension(BaseServer):
  90
  91     def get(self, request, vimid):
  92
  93         return self.send(vimid, request.get_full_path(), request.body, "GET",
  94                          headers=originHeaders(request))
  95
  96
  97 class VIMTypes(BaseServer):
  98
  99     def get(self, request):
 100         return Response(data=syscomm.getVIMTypes(), status=status.HTTP_200_OK)
 101
 102
 103 class CheckCapacity(BaseServer):
 104
 105     def post(self, request):
 106         try:
 107             body = json.loads(request.body)
 108         except ValueError as e:
 109             return Response(
 110                 data={'error': 'Invalidate request body %s.' % e},
 111                 status=status.HTTP_400_BAD_REQUEST)
 112
 113         ret = {"VIMs": []}
 114         newbody = {
 115             "vCPU": body.get("vCPU", 0),
 116             "Memory": body.get("Memory", 0),
 117             "Storage": body.get("Storage", 0)
 118         }
 119         for vim in body.get("VIMs", []):
 120             url = request.get_full_path().replace(
 121                 "check_vim_capacity", "%s/capacity_check" % vim)
 122             resp = self.send(vim, url, json.dumps(newbody), "POST",
 123                              headers=originHeaders(request))
 124             if int(resp.status_code) != status.HTTP_200_OK:
 125                 continue
 126             try:
 127                 resp_body = json.loads(resp.content)
 128             except ValueError:
 129                 continue
 130             if not resp_body.get("result", False):
 131                 continue
 132             ret['VIMs'].append(vim)
 133         return Response(data=ret, status=status.HTTP_200_OK)
 134
 135
 136 # forward  handler
 137 class Forward(BaseServer):
 138
 139     def get(self, request, vimid):
 140
 141         return self.send(vimid, request.get_full_path(), request.body, "GET",
 142                          headers=originHeaders(request))
 143
 144     def post(self, request, vimid):
 145
 146         return self.send(vimid, request.get_full_path(), request.body, "POST",
 147                          headers=originHeaders(request))
 148
 149     def patch(self, request, vimid):
 150
 151         return self.send(vimid, request.get_full_path(), request.body, "PATCH",
 152                          headers=originHeaders(request))
 153
 154     def delete(self, request, vimid):
 155
 156         return self.send(vimid, request.get_full_path(), request.body,
 157                          "DELETE", headers=originHeaders(request))
 158
 159     def head(self, request, vimid):
 160
 161         return self.send(vimid, request.get_full_path(), request.body, "HEAD",
 162                          headers=originHeaders(request))
 163
 164     def put(self, request, vimid):
 165
 166         return self.send(vimid, request.get_full_path(), request.body, "PUT",
 167                          headers=originHeaders(request))
 168
 169
 170 # API v1
 171 # proxy handler
 172 class APIv1Identity(Identity):
 173
 174     def get(self, request, cloud_owner, cloud_region_id):
 175         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 176         return super(APIv1Identity, self).get(request, vimid)
 177
 178     def post(self, request, cloud_owner, cloud_region_id):
 179         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 180         return super(APIv1Identity, self).post(request, vimid)
 181
 182
 183 class APIv1Registry(Registry):
 184
 185     def get(self, request, cloud_owner, cloud_region_id):
 186         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 187         return super(APIv1Registry, self).get(request, vimid)
 188
 189     def post(self, request, cloud_owner, cloud_region_id):
 190         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 191         return super(APIv1Registry, self).post(request, vimid)
 192
 193
 194 class APIv1UnRegistry(UnRegistry):
 195
 196     def delete(self, request, cloud_owner, cloud_region_id):
 197         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 198         return super(APIv1UnRegistry, self).delete(request, vimid)
 199
 200
 201 class APIv1Extension(Extension):
 202
 203     def get(self, request, cloud_owner, cloud_region_id):
 204         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 205         return super(APIv1Extension, self).get(request, vimid)
 206
 207
 208 class APIv1VIMTypes(VIMTypes):
 209
 210     def get(self, request):
 211         return super(APIv1VIMTypes, self).get(request)
 212
 213
 214 class APIv1CheckCapacity(CheckCapacity):
 215
 216     def post(self, request):
 217         try:
 218             body = json.loads(request.body)
 219         except ValueError as e:
 220             return Response(
 221                 data={'error': 'Invalidate request body %s.' % e},
 222                 status=status.HTTP_400_BAD_REQUEST)
 223
 224         ret = {"VIMs": []}
 225         newbody = {
 226             "vCPU": body.get("vCPU", 0),
 227             "Memory": body.get("Memory", 0),
 228             "Storage": body.get("Storage", 0)
 229         }
 230         for vim in body.get("VIMs", []):
 231             cloud_owner = vim["cloud-owner"]
 232             cloud_region_id = vim["cloud-region-id"]
 233             url = request.get_full_path().replace(
 234                 "check_vim_capacity", "%s/%s/capacity_check" %
 235                                       (cloud_owner, cloud_region_id))
 236             vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 237             resp = self.send(vimid, url, json.dumps(newbody), "POST",
 238                              headers=originHeaders(request))
 239
 240             if int(resp.status_code) != status.HTTP_200_OK:
 241                 continue
 242
 243             try:
 244                 resp_body = json.loads(resp.content)
 245             except ValueError:
 246                 continue
 247             if not resp_body.get("result", False):
 248                 continue
 249             azCapInfo = resp_body.get("AZs", [])
 250             vim["AZs"] = azCapInfo
 251             ret['VIMs'].append(vim)
 252         return Response(data=ret, status=status.HTTP_200_OK)
 253
 254
 255 # forward  handler
 256 class APIv1Forward(Forward):
 257
 258     def get(self, request, cloud_owner, cloud_region_id):
 259         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 260         return super(APIv1Forward, self).get(request, vimid)
 261
 262     def post(self, request, cloud_owner, cloud_region_id):
 263         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 264         return super(APIv1Forward, self).post(request, vimid)
 265
 266     def patch(self, request, cloud_owner, cloud_region_id):
 267         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 268         return super(APIv1Forward, self).patch(request, vimid)
 269
 270     def delete(self, request, cloud_owner, cloud_region_id):
 271         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 272         return super(APIv1Forward, self).delete(request, vimid)
 273
 274     def head(self, request, cloud_owner, cloud_region_id):
 275         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 276         return super(APIv1Forward, self).head(request, vimid)
 277
 278     def put(self, request, cloud_owner, cloud_region_id):
 279         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 280         return super(APIv1Forward, self).put(request, vimid)
 281
 282
 283 class APIv1InfraWorkload(BaseServer):
 284
 285     def post(self, request, cloud_owner, cloud_region_id):
 286         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 287         content_type = request.META.get('CONTENT_TYPE', 'application/json')
 288         if content_type.startswith("multipart"):
 289             return self.__process_multipart(request, vimid)
 290         return self.send(vimid, request.get_full_path(), request.body, "POST",
 291                          headers=originHeaders(request))
 292
 293     def get(self, request, cloud_owner, cloud_region_id):
 294         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 295         return self.send(vimid, request.get_full_path(), request.body, "GET",
 296                          headers=originHeaders(request))
 297
 298     def delete(self, request, cloud_owner, cloud_region_id):
 299         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 300         return self.send(vimid, request.get_full_path(), request.body,
 301                          "DELETE", headers=originHeaders(request))
 302
 303     def __process_multipart(self, request, vimid):
 304         return Response(
 305             data={'error': 'multipart API is not supported yet'},
 306             status=status.HTTP_400_BAD_REQUEST)
 307 #        try:
 308 #            API is depreciated due to poster not available in py3
 309 #            register_openers()
 310 #            dataDict = dict(request.data.iterlists())
 311 #            params = {}
 312 #            for key in dataDict.keys():
 313 #                dataObj = dataDict[key][0]
 314 #                if isinstance(dataObj, InMemoryUploadedFile):
 315 #                    f = tempfile.NamedTemporaryFile(prefix="django_",
 316 #                                                    suffix=dataObj._name,
 317 #                                                    delete=False)
 318 #                    f.write(dataObj.file.read())
 319 #                    f.seek(dataObj.file.tell(), 0)
 320 #                    dataObj.file.close()
 321 #                    params[key] = open(f.name, 'rb')
 322 #                else:
 323 #                    params[key] = dataObj
 324 #             datagen, headers = multipart_encode(params)
 325 #             regex = re.compile('^HTTP_')
 326 #             for key, value in request.META.iteritems():
 327 #                if key.startswith("HTTP_"):
 328 #                    headers[regex.sub('', key).replace('_', '-')] = value
 329 #             resp = self.send(vimid, request.path, datagen, "POST",
 330 #                             headers=headers, multipart=True)
 331 #        finally:
 332 #             for key in params or {}:
 333 #                refobj = params[key]
 334 #                if type(refobj) is not unicode:
 335 #                    if refobj.closed is False:
 336 #                        print (refobj.close())
 337 #                    os.remove(refobj.name)
 338 #        return resp