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             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 # API v1
 165 # proxy handler
 166 class APIv1Identity(Identity):
 167
 168     def get(self, request, cloud_owner, cloud_region_id):
 169         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 170         return super(APIv1Identity, self).get(request, vimid)
 171
 172     def post(self, request, cloud_owner, cloud_region_id):
 173         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 174         return super(APIv1Identity, self).post(request, vimid)
 175
 176
 177 class APIv1Registry(Registry):
 178
 179     def post(self, request, cloud_owner, cloud_region_id):
 180         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 181         return super(APIv1Registry, self).post(request, vimid)
 182
 183
 184 class APIv1UnRegistry(UnRegistry):
 185
 186     def delete(self, request, cloud_owner, cloud_region_id):
 187         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 188         return super(APIv1UnRegistry, self).delete(request, vimid)
 189
 190
 191 class APIv1Extension(Extension):
 192
 193     def get(self, request, cloud_owner, cloud_region_id):
 194         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 195         return super(APIv1Extension, self).get(request, vimid)
 196
 197
 198 class APIv1VIMTypes(VIMTypes):
 199
 200     def get(self, request):
 201         return super(APIv1VIMTypes, self).get(request)
 202
 203
 204 class APIv1CheckCapacity(CheckCapacity):
 205
 206     def post(self, request):
 207         try:
 208             body = json.loads(request.body)
 209         except ValueError as e:
 210             return Response(
 211                 data={'error': 'Invalidate request body %s.' % e},
 212                 status=status.HTTP_400_BAD_REQUEST)
 213
 214         ret = {"VIMs": []}
 215         newbody = {
 216             "vCPU": body.get("vCPU", 0),
 217             "Memory": body.get("Memory", 0),
 218             "Storage": body.get("Storage", 0)
 219         }
 220         for vim in body.get("VIMs", []):
 221             cloud_owner = vim["cloud-owner"]
 222             cloud_region_id = vim["cloud-region-id"]
 223             url = request.get_full_path().replace(
 224                 "check_vim_capacity", "%s/%s/capacity_check" %
 225                                       (cloud_owner, cloud_region_id))
 226             vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 227             resp = self.send(vimid, url, json.dumps(newbody), "POST")
 228             if int(resp.status_code) != status.HTTP_200_OK:
 229                 continue
 230             try:
 231                 resp_body = json.loads(resp.content)
 232             except ValueError:
 233                 continue
 234             if not resp_body.get("result", False):
 235                 continue
 236             azCapInfo = resp_body.get("AZs", [])
 237             vim["AZs"] = azCapInfo
 238             ret['VIMs'].append(vim)
 239         return Response(data=ret, status=status.HTTP_200_OK)
 240
 241
 242 # forward  handler
 243 class APIv1Forward(Forward):
 244
 245     def get(self, request, cloud_owner, cloud_region_id):
 246         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 247         return super(APIv1Forward, self).get(request, vimid)
 248
 249     def post(self, request, cloud_owner, cloud_region_id):
 250         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 251         return super(APIv1Forward, self).post(request, vimid)
 252
 253     def patch(self, request, cloud_owner, cloud_region_id):
 254         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 255         return super(APIv1Forward, self).patch(request, vimid)
 256
 257     def delete(self, request, cloud_owner, cloud_region_id):
 258         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 259         return super(APIv1Forward, self).delete(request, vimid)
 260
 261     def head(self, request, cloud_owner, cloud_region_id):
 262         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 263         return super(APIv1Forward, self).head(request, vimid)
 264
 265     def put(self, request, cloud_owner, cloud_region_id):
 266         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 267         return super(APIv1Forward, self).put(request, vimid)
 268
 269
 270 class APIv1InfraWorkload(BaseServer):
 271
 272     def post(self, request, cloud_owner, cloud_region_id):
 273         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 274         content_type = request.META.get('CONTENT_TYPE', 'application/json')
 275         if content_type.startswith("multipart"):
 276             return self.__process_multipart(request, vimid)
 277         return self.send(vimid, request.get_full_path(), request.body, "POST",
 278                          headers=originHeaders(request))
 279
 280     def get(self, request, cloud_owner, cloud_region_id):
 281         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 282         return self.send(vimid, request.get_full_path(), request.body, "GET",
 283                          headers=originHeaders(request))
 284
 285     def delete(self, request, cloud_owner, cloud_region_id):
 286         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 287         return self.send(vimid, request.get_full_path(), request.body,
 288                          "DELETE", headers=originHeaders(request))
 289
 290     def __process_multipart(self, request, vimid):
 291         try:
 292             register_openers()
 293             dataDict = dict(request.data.iterlists())
 294             params = {}
 295             for key in dataDict.keys():
 296                 dataObj = dataDict[key][0]
 297                 if isinstance(dataObj, InMemoryUploadedFile):
 298                     f = tempfile.NamedTemporaryFile(prefix="django_",
 299                                                     suffix=dataObj._name,
 300                                                     delete=False)
 301                     f.write(dataObj.file.read())
 302                     f.seek(dataObj.file.tell(), 0)
 303                     dataObj.file.close()
 304                     params[key] = open(f.name, 'rb')
 305                 else:
 306                     params[key] = dataObj
 307             datagen, headers = multipart_encode(params)
 308             regex = re.compile('^HTTP_')
 309             for key, value in request.META.iteritems():
 310                 if key.startswith("HTTP_"):
 311                     headers[regex.sub('', key).replace('_', '-')] = value
 312             resp = self.send(vimid, request.path, datagen, "POST",
 313                              headers=headers, multipart=True)
 314         finally:
 315             for key in params:
 316                 refobj = params[key]
 317                 if type(refobj) is not unicode:
 318                     if refobj.closed is False:
 319                         print refobj.close()
 320                     os.remove(refobj.name)
 321         return resp