Synnefo

# vim: ts=4 sts=4 et ai sw=4 fileencoding=utf-8

from django.conf import settings

from django.db import models

from django.contrib.auth.models import User

from django.utils.translation import gettext_lazy as _

import datetime

import vocabs

backend_prefix_id = settings.BACKEND_PREFIX_ID

#this needs to be called not only from inside VirtualMachine. 

#atm it is not working with the current ganeti naming - machine1, machine2

def id_from_instance_name(name):

    """ Returns VirtualMachine's Django id, given a ganeti machine name.

    Strips the ganeti prefix atm. Needs a better name!

    """

    return '%s' % (str(name).strip(backend_prefix_id))

class Limit(models.Model):

    description = models.CharField(max_length=45)

    class Meta:

        verbose_name = u'User limit'

    def __unicode__(self):

        return self.description

class OceanUser(models.Model):

    name = models.CharField(max_length=255)

    credit = models.IntegerField()

    quota = models.IntegerField()

    created = models.DateField()

    monthly_rate = models.IntegerField()

    #user = models.ForeignKey(User, unique=True)

    limits = models.ManyToManyField(Limit, through='UserLimit')

    class Meta:

        verbose_name = u'Ocean User'

    def __unicode__(self):

        return self.name

    def _total_hours(self, start, end):

        """Calculate duration in hours"""

        td = end - start

        sec = float(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / float(10**6)

        return float(sec) / float(60.0*60.0)

    def charge_credits(self, cost, start, end):

        """Reduce user credits for specified duration. 

        Returns amount of credits remaining. Negative if the user surpassed his limit."""

        total_cost = float(cost)*self._total_hours(start, end)

        self.credit = self.credit - round(total_cost)

        rcredit = self.credit

        if self.credit < 0:

            self.credit = 0

        return rcredit 

    def allocate_credits(self):

        """Allocate credits. Add monthly rate to user credit reserve."""

        self.credit = self.credit + self.monthly_rate

        # ensure that the user has not more credits than his quota

        if self.credit > self.quota:

            self.credit = self.quota

class UserLimit(models.Model):

    user = models.ForeignKey(OceanUser)

    limit = models.ForeignKey(Limit)

    value = models.IntegerField()

    class Meta:

        unique_together = ('user', 'limit')

        verbose_name = u'Enforced limit for user'

    def __unicode__(self):

        return u'Limit %s for user %s: %d' % (self.limit, self.user, self.value)

class Flavor(models.Model):

    cpu = models.IntegerField(default=0)

    ram = models.IntegerField(default=0)

    disk = models.IntegerField(default=0)

    class Meta:

        verbose_name = u'Virtual machine flavor'

    def _get_name(self):

        """Returns flavor name"""

        return u'C%dR%dD%d' % ( self.cpu, self.ram, self.disk )

    def _get_cost_inactive(self):

        self._update_costs()

        return self._cost_inactive

    def _get_cost_active(self):

        self._update_costs()

        return self._cost_active

    def _update_costs(self):

        # if _cost

        if '_cost_active' not in dir(self):

            fch = FlavorCostHistory.objects.filter(flavor=self).order_by('-effective_from')[0]

            self._cost_active = fch.cost_active

            self._cost_inactive = fch.cost_inactive

    name = property(_get_name)

    cost_active = property(_get_cost_active)

    cost_inactive = property(_get_cost_inactive)

    def __unicode__(self):

        return self.name

class FlavorCostHistory(models.Model):

    cost_active = models.PositiveIntegerField()

    cost_inactive = models.PositiveIntegerField()

    effective_from = models.DateField()

    flavor = models.ForeignKey(Flavor)

    class Meta:

        verbose_name = u'Pricing history for flavors'

    def __unicode__(self):

        return u'Costs (up, down)=(%d, %d) for %s since %s' % ( cost_active, cost_inactive, flavor.name, effective_from )

class VirtualMachine(models.Model):

    name = models.CharField(max_length=255)

    created = models.DateTimeField()

    state = models.CharField(choices=vocabs.STATES, max_length=30)

    charged = models.DateTimeField()

    imageid = models.IntegerField()

    hostid = models.CharField(max_length=100)

    server_label = models.CharField(max_length=100)

    image_version = models.CharField(max_length=100)

    ipfour = models.IPAddressField()

    ipsix = models.CharField(max_length=100)

    owner = models.ForeignKey(OceanUser)

    flavor = models.ForeignKey(Flavor)

    class Meta:

        verbose_name = u'Virtual machine instance'

        get_latest_by = 'created'

    def __unicode__(self):

        return self.name

    def _get_backend_id(self):

        """Returns the backend id for this VM by prepending backend-prefix."""

        return '%s%s' % (backend_prefix_id, str(self.id))

    backend_id = property(_get_backend_id)

class VirtualMachineGroup(models.Model):

    "Groups of VM's for OceanUsers"

    name = models.CharField(max_length=255)

    owner = models.ForeignKey(User)

    machines = models.ManyToManyField(VirtualMachine)

    created = models.DateTimeField(help_text=_("Group creation date"), default=datetime.datetime.now)

    class Meta:

        verbose_name = u'Virtual Machine Group'

        verbose_name_plural = 'Virtual Machine Groups'

        ordering = ['name']

    def __unicode__(self):

        return self.name

class VirtualMachineMetadata(models.Model):

    meta_key = models.CharField(max_length=50)

    meta_value = models.CharField(max_length=500)

    vm = models.ForeignKey(VirtualMachine)

    class Meta:

        verbose_name = u'Key-value pair of metadata for a VM.'

    def __unicode__(self):

        return u'%s, %s for %s' % ( self.key, self.value, self.vm.name )

class AccountingLog(models.Model):

    vm = models.ForeignKey(VirtualMachine)

    date = models.DateTimeField()

    state = models.CharField(choices=vocabs.STATES, max_length=30)

    class Meta:

        verbose_name = u'Accounting log'

    def __unicode__(self):

        return u'%s %s %s' % ( self.vm.name, self.date, self.state )

class Image(models.Model):

    name = models.CharField(max_length=255, help_text=_('description'))

    updated = models.DateTimeField(help_text=_("Image update date"))

    created = models.DateTimeField(help_text=_("Image creation date"), default=datetime.datetime.now)

    state = models.CharField(choices=vocabs.STATES, max_length=30)

    description = models.TextField(help_text=_('description'))

    serverid = models.IntegerField(help_text=_('description'))

    vm = models.ForeignKey(VirtualMachine)

    class Meta:

        verbose_name = u'Image'

    def __unicode__(self):

        return u'%s' % ( self.name )