uncloud/uncloud/uncloud_vm/models.py

from django.db import models
from django.contrib.auth import get_user_model
import uuid

from uncloud_pay.models import Product

STATUS_CHOICES = (
    ('pending', 'Pending'),   # Initial state
    ('creating', 'Creating'), # Creating VM/image/etc.
    ('active', 'Active'),     # Is usable / active
    ('disabled', 'Disabled'), # Is usable, but cannot be used for new things
    ('unusable', 'Unusable'), # Has some kind of error
    ('deleted', 'Deleted'),   # Does not exist anymore, only DB entry as a log
)

STATUS_DEFAULT='pending'

class VMHost(models.Model):
    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)

    # 253 is the maximum DNS name length
    hostname = models.CharField(max_length=253, unique=True)

    # indirectly gives a maximum number of cores / VM - f.i. 32
    physical_cores = models.IntegerField(default=0)

    # determines the maximum usable cores - f.i. 320 if you overbook by a factor of 10
    usable_cores = models.IntegerField(default=0)

    # ram that can be used of the server
    usable_ram_in_gb = models.FloatField(default=0)


    status = models.CharField(max_length=32,
                              choices=STATUS_CHOICES,
                              default=STATUS_DEFAULT
    )


class VMProduct(Product):
    vmhost   = models.ForeignKey(VMHost,
                                 on_delete=models.CASCADE,
                                 editable=False,
                                 blank=True,
                                 null=True)

    cores = models.IntegerField()
    ram_in_gb = models.FloatField()


class VMWithOSProduct(VMProduct):
    pass


class VMDiskImageProduct(models.Model):
    """
    Images are used for cloning/linking.

    They are the base for images.

    """

    uuid = models.UUIDField(primary_key=True,
                            default=uuid.uuid4,
                            editable=False)
    owner = models.ForeignKey(get_user_model(),
                              on_delete=models.CASCADE,
                              editable=False)

    name = models.CharField(max_length=256)
    is_os_image = models.BooleanField(default=False)
    is_public = models.BooleanField(default=False)

    size_in_gb = models.FloatField(null=True,
                                   blank=True)
    import_url = models.URLField(null=True,
                                 blank=True)


    storage_class = models.CharField(max_length=32,
                              choices = (
                                  ('hdd', 'HDD'),
                                  ('ssd', 'SSD'),
                              ),
                              default='ssd'
    )

    status = models.CharField(max_length=32,
                              choices=STATUS_CHOICES,
                              default=STATUS_DEFAULT
    )

class VMDiskProduct(models.Model):
    """
    The VMDiskProduct is attached to a VM.

    It is based on a VMDiskImageProduct that will be used as a basis.

    It can be enlarged, but not shrinked compared to the VMDiskImageProduct.
    """

    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    owner = models.ForeignKey(get_user_model(),
                              on_delete=models.CASCADE,
                              editable=False)

    vm   = models.ForeignKey(VMProduct, on_delete=models.CASCADE)
    image = models.ForeignKey(VMDiskImageProduct, on_delete=models.CASCADE)

    size_in_gb = models.FloatField(blank=True)


class VMNetworkCard(models.Model):
    vm   = models.ForeignKey(VMProduct, on_delete=models.CASCADE)

    mac_address = models.IntegerField()

    ip_address = models.GenericIPAddressField(blank=True,
                                              null=True)


class VMSnapshotProduct(Product):
    gb_ssd = models.FloatField(editable=False)
    gb_hdd = models.FloatField(editable=False)

    vm = models.ForeignKey(VMProduct, on_delete=models.CASCADE)