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 poster.encode import multipart_encode
  21 from poster.streaminghttp import register_openers
  22
  23 from rest_framework.views import APIView
  24 from rest_framework.views import Response
  25 from rest_framework.views import status
  26 from multivimbroker.forwarder.base import BaseHandler
  27 from multivimbroker.pub.utils.syscomm import originHeaders
  28 from multivimbroker.pub.utils import syscomm
  29 from rest_framework.parsers import MultiPartParser
  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             if int(resp.status_code) != status.HTTP_200_OK:
 119                 continue
 120             try:
 121                 resp_body = json.loads(resp.content)
 122             except ValueError:
 123                 continue
 124             if not resp_body.get("result", False):
 125                 continue
 126             ret['VIMs'].append(vim)
 127         return Response(data=ret, status=status.HTTP_200_OK)
 128
 129
 130 # forward  handler
 131 class Forward(BaseServer):
 132
 133     def get(self, request, vimid):
 134
 135         return self.send(vimid, request.get_full_path(), request.body, "GET",
 136                          headers=originHeaders(request))
 137
 138     def post(self, request, vimid):
 139
 140         return self.send(vimid, request.get_full_path(), request.body, "POST",
 141                          headers=originHeaders(request))
 142
 143     def patch(self, request, vimid):
 144
 145         return self.send(vimid, request.get_full_path(), request.body, "PATCH",
 146                          headers=originHeaders(request))
 147
 148     def delete(self, request, vimid):
 149
 150         return self.send(vimid, request.get_full_path(), request.body,
 151                          "DELETE", headers=originHeaders(request))
 152
 153     def head(self, request, vimid):
 154
 155         return self.send(vimid, request.get_full_path(), request.body, "HEAD",
 156                          headers=originHeaders(request))
 157
 158     def put(self, request, vimid):
 159
 160         return self.send(vimid, request.get_full_path(), request.body, "PUT",
 161                          headers=originHeaders(request))
 162
 163
 164 # Multipart view
 165 class MultiPartView(BaseServer):
 166
 167     parser_classes = (MultiPartParser, )
 168
 169     def post(self, request, vimid):
 170         try:
 171             register_openers()
 172             fileDict = dict(request.FILES.iterlists())
 173             params = {}
 174             for key in fileDict.keys():
 175                 fileObj = fileDict[key][0]
 176                 f = tempfile.NamedTemporaryFile(prefix="django_",
 177                                                 suffix=fileObj._name,
 178                                                 delete=False)
 179                 f.write(fileObj.file.read())
 180                 f.seek(fileObj.file.tell(), 0)
 181                 fileObj.file.close()
 182                 params[key] = open(f.name, 'rb')
 183             datagen, headers = multipart_encode(params)
 184             regex = re.compile('^HTTP_')
 185             for key, value in request.META.iteritems():
 186                 if key.startswith("HTTP_"):
 187                     headers[regex.sub('', key).replace('_', '-')] = value
 188             resp = self.send(vimid, request.path, datagen, "POST",
 189                              headers=headers)
 190         finally:
 191             for key in params:
 192                 fileRef = params[key]
 193                 if fileRef.closed is False:
 194                     fileRef.close()
 195                 os.remove(fileRef.name)
 196         return resp
 197
 198
 199 # API v1
 200 # proxy handler
 201 class APIv1Identity(Identity):
 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(APIv1Identity, self).get(request, vimid)
 206
 207     def post(self, request, cloud_owner, cloud_region_id):
 208         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 209         return super(APIv1Identity, self).post(request, vimid)
 210
 211
 212 class APIv1Registry(Registry):
 213
 214     def post(self, request, cloud_owner, cloud_region_id):
 215         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 216         return super(APIv1Registry, self).post(request, vimid)
 217
 218
 219 class APIv1UnRegistry(UnRegistry):
 220
 221     def delete(self, request, cloud_owner, cloud_region_id):
 222         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 223         return super(APIv1UnRegistry, self).delete(request, vimid)
 224
 225
 226 class APIv1Extension(Extension):
 227
 228     def get(self, request, cloud_owner, cloud_region_id):
 229         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 230         return super(APIv1Extension, self).get(request, vimid)
 231
 232
 233 class APIv1VIMTypes(VIMTypes):
 234
 235     def get(self, request):
 236         return super(APIv1VIMTypes, self).get(request)
 237
 238
 239 class APIv1CheckCapacity(CheckCapacity):
 240
 241     def post(self, request):
 242         try:
 243             body = json.loads(request.body)
 244         except ValueError as e:
 245             return Response(
 246                 data={'error': 'Invalidate request body %s.' % e},
 247                 status=status.HTTP_400_BAD_REQUEST)
 248
 249         ret = {"VIMs": []}
 250         newbody = {
 251             "vCPU": body.get("vCPU", 0),
 252             "Memory": body.get("Memory", 0),
 253             "Storage": body.get("Storage", 0)
 254         }
 255         for vim in body.get("VIMs", []):
 256             cloud_owner = vim["cloud-owner"]
 257             cloud_region_id = vim["cloud-region-id"]
 258             url = request.get_full_path().replace(
 259                 "check_vim_capacity", "%s/%s/capacity_check" %
 260                                       (cloud_owner, cloud_region_id))
 261             vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 262             resp = self.send(vimid, url, json.dumps(newbody), "POST")
 263             if int(resp.status_code) != status.HTTP_200_OK:
 264                 continue
 265             try:
 266                 resp_body = json.loads(resp.content)
 267             except ValueError:
 268                 continue
 269             if not resp_body.get("result", False):
 270                 continue
 271             ret['VIMs'].append(vim)
 272         return Response(data=ret, status=status.HTTP_200_OK)
 273
 274
 275 # forward  handler
 276 class APIv1Forward(Forward):
 277
 278     def get(self, request, cloud_owner, cloud_region_id):
 279         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 280         return super(APIv1Forward, self).get(request, vimid)
 281
 282     def post(self, request, cloud_owner, cloud_region_id):
 283         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 284         return super(APIv1Forward, self).post(request, vimid)
 285
 286     def patch(self, request, cloud_owner, cloud_region_id):
 287         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 288         return super(APIv1Forward, self).patch(request, vimid)
 289
 290     def delete(self, request, cloud_owner, cloud_region_id):
 291         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 292         return super(APIv1Forward, self).delete(request, vimid)
 293
 294     def head(self, request, cloud_owner, cloud_region_id):
 295         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 296         return super(APIv1Forward, self).head(request, vimid)
 297
 298     def put(self, request, cloud_owner, cloud_region_id):
 299         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 300         return super(APIv1Forward, self).put(request, vimid)
 301
 302
 303 # Multipart view
 304 class APIv1MultiPartView(MultiPartView):
 305
 306     def post(self, request, cloud_owner, cloud_region_id):
 307
 308         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 309         return super(APIv1MultiPartView, self).post(request, vimid)
 310
 311
 312 class APIv1InfraWorkload(BaseServer):
 313
 314     def post(self, request, cloud_owner, cloud_region_id):
 315         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 316         return self.send(vimid, request.get_full_path(), request.body, "POST",
 317                          headers=originHeaders(request))
 318
 319     def get(self, request, cloud_owner, cloud_region_id):
 320         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 321         return self.send(vimid, request.get_full_path(), request.body, "GET",
 322                          headers=originHeaders(request))
 323
 324     def delete(self, request, cloud_owner, cloud_region_id):
 325         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 326         return self.send(vimid, request.get_full_path(), request.body,
 327                          "DELETE", headers=originHeaders(request))