uncloud/uncloud_vm/views.py

261 lines
8.6 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
2020-04-18 11:51:31 +00:00
from uncloud_pay.models import Order, BillingAddress
from .serializers import *
from uncloud_pay.helpers import ProductViewSet
2020-02-27 11:31:20 +00:00
import datetime
2020-04-18 11:51:31 +00:00
###
# Generic disk image views. Do not require orders / billing.
2020-02-25 21:01:55 +00:00
2020-04-18 11:51:31 +00:00
class VMDiskImageProductViewSet(ProductViewSet):
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)
2020-04-18 11:51:31 +00:00
###
# User VM disk and snapshots.
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)
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)
2020-04-18 11:51:31 +00:00
###
# User VMs.
class VMProductViewSet(ProductViewSet):
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
if self.request.user.is_superuser:
2020-04-18 11:51:31 +00:00
obj = VMWithOSProduct.objects.all()
2020-04-18 11:51:31 +00:00
else:
2020-04-18 11:51:31 +00:00
obj = VMWithOSProduct.objects.filter(owner=self.request.user)
2020-04-18 11:51:31 +00:00
return obj
def get_serializer_class(self):
if self.action == 'create':
return OrderVMProductSerializer
else:
return VMProductSerializer
# 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 = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
order_recurring_period = serializer.validated_data.pop("recurring_period")
2020-04-18 11:51:31 +00:00
# Create disk image.
disk = VMDiskProduct(owner=request.user,
**serializer.validated_data.pop("primary_disk"))
vm = VMWithOSProduct(owner=request.user, primary_disk=disk,
**serializer.validated_data)
disk.vm = vm # XXX: Is this really needed?
# Create VM and Disk orders.
vm_order = Order.from_product(
vm,
recurring_period=order_recurring_period,
starting_date=timezone.now()
)
disk_order = Order.from_product(
disk,
2020-04-18 11:51:31 +00:00
recurring_period=order_recurring_period,
starting_date=timezone.now()
)
2020-04-18 11:51:31 +00:00
# Commit to DB.
vm.order = vm_order
vm.save()
vm_order.save()
disk.order = disk_order
disk_order.save()
disk.save()
return Response(VMProductSerializer(vm, context={'request': request}).data)
class NicoVMProductViewSet(ProductViewSet):
permission_classes = [permissions.IsAuthenticated]
serializer_class = NicoVMProductSerializer
def get_queryset(self):
obj = VMProduct.objects.filter(owner=self.request.user)
return obj
def create(self, request):
serializer = self.serializer_class(data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
vm = serializer.save(owner=request.user)
2020-05-02 18:31:36 +00:00
return Response(serializer.data)
2020-04-18 11:51:31 +00:00
2020-04-18 11:51:31 +00:00
2020-04-18 11:51:31 +00:00
###
# Admin stuff.
class VMHostViewSet(viewsets.ModelViewSet):
serializer_class = VMHostSerializer
queryset = VMHost.objects.all()
permission_classes = [permissions.IsAdminUser]
class VMClusterViewSet(viewsets.ModelViewSet):
serializer_class = VMClusterSerializer
queryset = VMCluster.objects.all()
permission_classes = [permissions.IsAdminUser]
2020-04-18 11:51:31 +00:00
##
# Nico's playground.
# 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)