uncloud-mravi/uncloud_django_based/uncloud/uncloud_vm/views.py

218 lines
7.5 KiB
Python
Raw Normal View History

from django.db import transaction
from django.shortcuts import render
2020-04-09 12:52:56 +00:00
from django.utils import timezone
from django.contrib.auth.models import User
from django.shortcuts import get_object_or_404
from rest_framework import viewsets, permissions
from rest_framework.response import Response
from rest_framework.exceptions import ValidationError
2020-03-22 19:55:11 +00:00
from .models import VMHost, VMProduct, VMSnapshotProduct, VMDiskProduct, VMDiskImageProduct, VMCluster
from uncloud_pay.models import Order
from .serializers import *
from uncloud_pay.helpers import ProductViewSet
2020-02-27 11:31:20 +00:00
import datetime
class VMHostViewSet(viewsets.ModelViewSet):
serializer_class = VMHostSerializer
queryset = VMHost.objects.all()
permission_classes = [permissions.IsAdminUser]
2020-02-25 21:01:55 +00:00
2020-03-22 19:55:11 +00:00
class VMClusterViewSet(viewsets.ModelViewSet):
serializer_class = VMClusterSerializer
queryset = VMCluster.objects.all()
permission_classes = [permissions.IsAdminUser]
class VMDiskImageProductViewSet(viewsets.ModelViewSet):
permission_classes = [permissions.IsAuthenticated]
serializer_class = VMDiskImageProductSerializer
def get_queryset(self):
if self.request.user.is_superuser:
obj = VMDiskImageProduct.objects.all()
else:
obj = VMDiskImageProduct.objects.filter(owner=self.request.user) | VMDiskImageProduct.objects.filter(is_public=True)
return obj
def create(self, request):
serializer = VMDiskImageProductSerializer(data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
# did not specify size NOR import url?
if not serializer.validated_data['size_in_gb']:
if not serializer.validated_data['import_url']:
raise ValidationError(detail={ 'error_mesage': 'Specify either import_url or size_in_gb' })
serializer.save(owner=request.user)
return Response(serializer.data)
class VMDiskImageProductPublicViewSet(viewsets.ReadOnlyModelViewSet):
permission_classes = [permissions.IsAuthenticated]
serializer_class = VMDiskImageProductSerializer
def get_queryset(self):
return VMDiskImageProduct.objects.filter(is_public=True)
class VMDiskProductViewSet(viewsets.ModelViewSet):
"""
Let a user modify their own VMDisks
"""
permission_classes = [permissions.IsAuthenticated]
serializer_class = VMDiskProductSerializer
def get_queryset(self):
2020-03-18 14:43:01 +00:00
if self.request.user.is_superuser:
obj = VMDiskProduct.objects.all()
else:
obj = VMDiskProduct.objects.filter(owner=self.request.user)
return obj
def create(self, request):
serializer = VMDiskProductSerializer(data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
# get disk size from image, if not specified
if not 'size_in_gb' in serializer.validated_data:
size_in_gb = serializer.validated_data['image'].size_in_gb
else:
size_in_gb = serializer.validated_data['size_in_gb']
if size_in_gb < serializer.validated_data['image'].size_in_gb:
raise ValidationError(detail={ 'error_mesage': 'Size is smaller than original image' })
serializer.save(owner=request.user, size_in_gb=size_in_gb)
return Response(serializer.data)
class VMProductViewSet(ProductViewSet):
2020-02-25 21:01:55 +00:00
permission_classes = [permissions.IsAuthenticated]
serializer_class = VMProductSerializer
def get_queryset(self):
2020-03-17 13:50:14 +00:00
if self.request.user.is_superuser:
obj = VMProduct.objects.all()
else:
obj = VMProduct.objects.filter(owner=self.request.user)
return obj
2020-02-25 21:01:55 +00:00
# Use a database transaction so that we do not get half-created structure
# if something goes wrong.
@transaction.atomic
2020-02-25 21:01:55 +00:00
def create(self, request):
# Extract serializer data.
serializer = VMProductSerializer(data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
order_recurring_period = serializer.validated_data.pop("recurring_period")
2020-02-27 19:58:12 +00:00
# Create base order.
order = Order(
recurring_period=order_recurring_period,
2020-04-09 12:52:56 +00:00
owner=request.user,
starting_date=timezone.now()
2020-02-27 19:58:12 +00:00
)
# Create disk image.
disk = VMDiskProduct(owner=request.user, order=order,
**serializer.validated_data.pop("primary_disk"))
2020-02-27 19:58:12 +00:00
# Create VM.
vm = serializer.save(owner=request.user, order=order, primary_disk=disk)
disk.vm = vm
disk.save()
2020-02-27 19:58:12 +00:00
2020-02-25 21:01:55 +00:00
return Response(serializer.data)
2020-02-27 10:36:50 +00:00
class VMSnapshotProductViewSet(viewsets.ModelViewSet):
permission_classes = [permissions.IsAuthenticated]
serializer_class = VMSnapshotProductSerializer
def get_queryset(self):
2020-03-22 19:55:11 +00:00
if self.request.user.is_superuser:
obj = VMSnapshotProduct.objects.all()
else:
obj = VMSnapshotProduct.objects.filter(owner=self.request.user)
return obj
2020-02-27 10:36:50 +00:00
def create(self, request):
2020-02-27 11:31:20 +00:00
serializer = VMSnapshotProductSerializer(data=request.data, context={'request': request})
# This verifies that the VM belongs to the request user
2020-02-27 10:36:50 +00:00
serializer.is_valid(raise_exception=True)
vm = vm=serializer.validated_data['vm']
disks = VMDiskProduct.objects.filter(vm=vm)
ssds_size = sum([d.size_in_gb for d in disks if d.image.storage_class == 'ssd'])
hdds_size = sum([d.size_in_gb for d in disks if d.image.storage_class == 'hdd'])
recurring_price = serializer.pricing['per_gb_ssd'] * ssds_size + serializer.pricing['per_gb_hdd'] * hdds_size
recurring_period = serializer.pricing['recurring_period']
# Create order
2020-02-27 11:31:20 +00:00
now = datetime.datetime.now()
order = Order(owner=request.user,
recurring_period=recurring_period)
2020-02-27 11:31:20 +00:00
order.save()
order.add_record(one_time_price=0,
recurring_price=recurring_price,
description="Snapshot of VM {} from {}".format(vm, now))
2020-02-27 11:31:20 +00:00
serializer.save(owner=request.user,
order=order,
gb_ssd=ssds_size,
gb_hdd=hdds_size)
2020-02-27 10:36:50 +00:00
return Response(serializer.data)
# Also create:
# - /dcl/available_os
# Basically a view of public and my disk images
# -
class DCLCreateVMProductViewSet(ProductViewSet):
"""
This view resembles the way how DCL VMs are created by default.
The user chooses an OS, os disk size, ram, cpu and whether or not to have a mapped IPv4 address
"""
permission_classes = [permissions.IsAuthenticated]
serializer_class = DCLVMProductSerializer
def get_queryset(self):
return VMProduct.objects.filter(owner=self.request.user)
# Use a database transaction so that we do not get half-created structure
# if something goes wrong.
@transaction.atomic
def create(self, request):
# Extract serializer data.
serializer = VMProductSerializer(data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
order_recurring_period = serializer.validated_data.pop("recurring_period")
# Create base order.
order = Order.objects.create(
recurring_period=order_recurring_period,
owner=request.user
)
order.save()
# Create VM.
vm = serializer.save(owner=request.user, order=order)
return Response(serializer.data)