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             ret['VIMs'].append(vim)
 237         return Response(data=ret, status=status.HTTP_200_OK)
 238
 239
 240 # forward  handler
 241 class APIv1Forward(Forward):
 242
 243     def get(self, request, cloud_owner, cloud_region_id):
 244         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 245         return super(APIv1Forward, self).get(request, vimid)
 246
 247     def post(self, request, cloud_owner, cloud_region_id):
 248         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 249         return super(APIv1Forward, self).post(request, vimid)
 250
 251     def patch(self, request, cloud_owner, cloud_region_id):
 252         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 253         return super(APIv1Forward, self).patch(request, vimid)
 254
 255     def delete(self, request, cloud_owner, cloud_region_id):
 256         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 257         return super(APIv1Forward, self).delete(request, vimid)
 258
 259     def head(self, request, cloud_owner, cloud_region_id):
 260         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 261         return super(APIv1Forward, self).head(request, vimid)
 262
 263     def put(self, request, cloud_owner, cloud_region_id):
 264         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 265         return super(APIv1Forward, self).put(request, vimid)
 266
 267
 268 class APIv1InfraWorkload(BaseServer):
 269
 270     def post(self, request, cloud_owner, cloud_region_id):
 271         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 272         content_type = request.META.get('CONTENT_TYPE', 'application/json')
 273         if content_type.startswith("multipart"):
 274             return self.__process_multipart(request, vimid)
 275         return self.send(vimid, request.get_full_path(), request.body, "POST",
 276                          headers=originHeaders(request))
 277
 278     def get(self, request, cloud_owner, cloud_region_id):
 279         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 280         return self.send(vimid, request.get_full_path(), request.body, "GET",
 281                          headers=originHeaders(request))
 282
 283     def delete(self, request, cloud_owner, cloud_region_id):
 284         vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)
 285         return self.send(vimid, request.get_full_path(), request.body,
 286                          "DELETE", headers=originHeaders(request))
 287
 288     def __process_multipart(self, request, vimid):
 289         try:
 290             register_openers()
 291             dataDict = dict(request.data.iterlists())
 292             params = {}
 293             for key in dataDict.keys():
 294                 dataObj = dataDict[key][0]
 295                 if isinstance(dataObj, InMemoryUploadedFile):
 296                     f = tempfile.NamedTemporaryFile(prefix="django_",
 297                                                     suffix=dataObj._name,
 298                                                     delete=False)
 299                     f.write(dataObj.file.read())
 300                     f.seek(dataObj.file.tell(), 0)
 301                     dataObj.file.close()
 302                     params[key] = open(f.name, 'rb')
 303                 else:
 304                     params[key] = dataObj
 305             datagen, headers = multipart_encode(params)
 306             regex = re.compile('^HTTP_')
 307             for key, value in request.META.iteritems():
 308                 if key.startswith("HTTP_"):
 309                     headers[regex.sub('', key).replace('_', '-')] = value
 310             resp = self.send(vimid, request.path, datagen, "POST",
 311                              headers=headers, multipart=True)
 312         finally:
 313             for key in params:
 314                 refobj = params[key]
 315                 if type(refobj) is not unicode:
 316                     if refobj.closed is False:
 317                         print refobj.close()
 318                     os.remove(refobj.name)
 319         return resp