/ - Diff - Synnefo - Greek Research and Technology Network's projects

b/.gitignore
12	12	*.installed.cfg
13	13	*.sqlite
14	14	.Python
	15	.idea
	16	.DS_Store

     from db.models import *
     from datetime import datetime
     def stop_virtual_machine(vm):
         """Send message to stop a virtual machine instance"""
         # send the message to ganeti
         return
     def charge():
     def periodically_charge():
         """Scan all virtual machines and charge each user"""
         all_vms = VirtualMachine.objects.all()
         if len(all_vms) == 0:
             print "No virtual machines found"
             return
         for vm in all_vms:
             cost = 0
             # Running and Stopped is charged, else the cost is zero
             start = vm.charged
             end = datetime.now()
             user_credits = vm.owner.charge_credits(cost, start, end)
             vm.charged = end
             # update the values in the database
             vm.save()
             vm.owner.save()
             if user_credits <= 0:
                 stop_virtual_machine(vm)
             # FIXME: not implemented!
             vm.charge()
     # vim: set ts=4 sts=4 sw=4 et ai :

             "pk": 30000,
             "fields": {
                 "name": "test db user",
                 "credit": 0,
                 "credit": 10,
                 "created": "2011-02-06",
                 "user" : 1
+       	    }
-...
             "model" : "db.Limit",
             "pk" : 30001,
             "fields" : {
                 "name" : "MAX_VIOLATIONS",
                 "name" : "MIN_CREDITS",
                 "user" : 30000,
                 "value" : 5
                 "value" : -100
+            }
         },
+        {
-...
+            }
         },
+        {
             "model": "db.Flavor",
             "pk": 30001,
             "fields": {
                 "cpu": 1,
                 "ram": 1024,
                 "disk": 20
+            }
         },
+        {
             "model" : "db.FlavorCostHistory",
             "model" : "db.FlavorCost",
             "pk" : 30000,
             "fields" : {
                 "cost_active" : 10,
-...
+            }
         },
+        {
             "model" : "db.FlavorCostHistory",
             "model" : "db.FlavorCost",
             "pk" : 30001,
             "fields" : {
                 "cost_active" : 2,
-...
+            }
         },
+        {
             "model" : "db.FlavorCost",
             "pk" : 30002,
             "fields" : {
                 "cost_active" : 5,
                 "cost_inactive" : 2,
                 "effective_from" : "2010-08-01",
                 "flavor" : 30000
+            }
         },
+        {
             "model" : "db.FlavorCost",
             "pk" : 30003,
             "fields" : {
                 "cost_active" : 4,
                 "cost_inactive" : 10,
                 "effective_from" : "2010-01-01",
                 "flavor" : 30000
+            }
         },
+        {
             "model": "db.VirtualMachine",
             "pk": 30000,
             "fields": {
-...
+            }
         },
+        {
             "model": "db.VirtualMachine",
             "pk": 30001,
             "fields": {
                 "name": "snf-1002",
                 "created": "2011-02-10 00:00:00",
                 "charged": "2011-02-10 00:00:00",
                 "sourceimage": 30000,
                 "hostid": "HAL-9000",
                 "description": "mail server",
                 "ipfour": "192.168.2.2",
                 "ipsix": "::2",
                 "flavor": 30000,
                 "_operstate": "BUILD"
+            }
         },
+        {
             "model": "db.VirtualMachine",
             "pk": 30002,
             "fields": {
                 "name": "snf-1003",
                 "created": "2009-02-10 00:00:00",
                 "charged": "2010-01-01 00:00:00",
                 "sourceimage": 30000,
                 "hostid": "HAL-9000",
                 "description": "my server",
                 "ipfour": "192.168.2.3",
                 "ipsix": "::3",
                 "flavor": 30000,
                 "_operstate": "STARTED"
+            }
         },
+        {
             "model": "db.VirtualMachine",
             "pk": 30003,
             "fields": {
                 "name": "snf-1004",
                 "created": "2011-02-10 00:00:00",
                 "charged": "2011-02-10 00:00:00",
                 "sourceimage": 30000,
                 "hostid": "HAL-9000",
                 "description": "my 2nd server",
                 "ipfour": "192.168.2.4",
                 "ipsix": "::4",
                 "flavor": 30000,
                 "_operstate": "STARTED"
+            }
         },
+        {
             "model" : "db.Debit",
             "pk" : 30000,
             "fields" : {
                 "vm" : 30000,
                 "date" : "2010-01-01",
                 "state" : "STARTED"
+            }
         },
+        {
             "model" : "db.Debit",
             "pk" : 30001,
             "fields" : {
                 "vm" : 30000,
                 "date" : "2011-02-01",
                 "state" : "STARTED"
+            }
         },
+        {
             "model" : "db.Debit",
             "pk" : 30002,
             "fields" : {
                 "vm" : 30002,
                 "date" : "2010-01-01",
                 "state" : "STARTED"
+            }
         },
+        {
             "model" : "db.Debit",
             "pk" : 30003,
             "fields" : {
                 "vm" : 30002,
                 "date" : "2010-03-01",
                 "state" : "STOPPED"
+            }
         },
+        {
             "model" : "db.Debit",
             "pk" : 30004,
             "fields" : {
                 "vm" : 30002,
                 "date" : "2011-01-01",
                 "state" : "STARTED"
+            }
         },
+        {
             "model": "db.Image",
             "pk": 30000,
             "fields": {
                 "name": "Debian Squeeze",
                 "updated": "2011-02-06 00:00:00",
                 "created": "2011-02-06 00:00:00",
                 "size" : 2000,
                 "state": "ACTIVE",
                 "description": "Full Debian Squeeze Installation",
                 "owner" : 30000
+            }
         },
+        {
             "model": "db.Image",
             "pk": 30001,
             "fields": {
                 "name": "Slackware 13.1",
                 "updated": "2011-02-10 00:00:00",
                 "created": "2011-02-10 00:00:00",
                 "state": "ACTIVE",
                 "description": "Full Slackware 13.1 Installation",
                 "owner" : 30000
+            }
         },
+        {
             "model": "db.Disk",
             "pk": 30000,
             "fields": {
-...
                 "vm" : 30000,
                 "owner" : 30000
+            }
         },
+        {
             "model": "db.Disk",
             "pk": 30001,
             "fields": {
                 "name": "My_Videos",
                 "created": "2011-02-10 00:00:00",
                 "size" : 300,
                 "vm" : 30000,
                 "owner" : 30000
+            }
+        }
+        }
+    ]

b/db/management/commands/charge_users.py
12	12	help = 'Charge the users for VM usage'
13	13
14	14	def handle_noargs(self, **options):
15		charger.charge()
	15	charger.periodically_charge()

     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
-...
         def debit_account(self, amount, vm, description):
             """Charges the user with the specified amount of credits for a vm (resource)"""
             return
             date_now = datetime.datetime.now()
             # first reduce the user's credits and save
             self.credit = self.credit - amount
             self.save()
             # then write the debit entry!
             debit = Debit()
             debit.user = self
             debit.vm = vm
             debit.when = date_now
             debit.description = description
             debit.save()
         def credit_account(self, amount, creditor, description):
             """No clue :)"""
-...
             verbose_name = u'Image'
         def __unicode__(self):
             return u'%s' % (self.name)
             return u'%s' % ( self.name, )
     class ImageMetadata(models.Model):
-...
             verbose_name = u'Enforced limit for user'
         def __unicode__(self):
             return u'Limit %s for user %s: %d' % (self.limit, self.user, self.value)
             return u'Limit %s for user %s: %d' % (self.value, self.user, self.value)
     class Flavor(models.Model):
-...
         def _get_name(self):
             """Returns flavor name (generated)"""
             return u'C%dR%dD%d' % (self.cpu, self.ram, self.disk)
         def _current_cost_active(self):
         def _current_cost(self, active):
             """Returns active/inactive cost value
             set active = True to get active cost and False for the inactive.
             """
             fch_list = FlavorCost.objects.filter(flavor=self).order_by('-effective_from')
             if len(fch_list) > 0:
                 return fch_list[0].cost_active
                 if active:
                     return fch_list[0].cost_active
                 else:
                     return fch_list[0].cost_inactive
             return 0
         def _current_cost_active(self):
             """Returns current active cost (property method)"""
             return self._current_cost(True)
         def _current_cost_inactive(self):
             fch_list = FlavorCost.objects.filter(flavor=self).order_by('-effective_from')
             if len(fch_list) > 0:
                 return fch_list[0].cost_inactive
             return 0
             """Returns current inactive cost (property method)"""
             return self._current_cost(False)
         name = property(_get_name)
         current_cost_active = property(_current_cost_active)
-...
         def __unicode__(self):
             return self.name
         def _get_costs(self, start_datetime, end_datetime, active):
             """Return a list with FlavorCost objects for the specified duration"""
             def between(enh_fc, a_date):
                 """Checks if a date is between a FlavorCost duration"""
                 if enh_fc.effective_from <= a_date and enh_fc.effective_to is None:
                     return True
                 return enh_fc.effective_from <= a_date and enh_fc.effective_to >= a_date
             def calculate_cost(start_date, end_date, cost):
                 """Calculate the total cost for the specified duration"""
                 td = end_date - start_date
                 sec = float(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / float(10**6)
                 total_hours = float(sec) / float(60.0*60.0)
                 total_cost = float(cost)*total_hours
                 return round(total_cost)
             price_list = FlavorCost.objects.filter(flavor=self).order_by('effective_from')
             for idx in range(0, len(price_list)):
                 if idx + 1 == len(price_list):
                     price_list[idx].effective_to = None
                 else:
                     price_list[idx].effective_to = price_list[idx + 1].effective_from
             price_result = []
             found_start = False
             for p in price_list:
                 if between(p, start_datetime):
                     found_start = True
                     p.effective_from = start_datetime
                 if between(p, end_datetime):
                     p.effective_to = end_datetime
                     price_result.append(p)
                     break
                 if found_start:
                     price_result.append(p)
             results = []
             for p in price_result:
                 if active:
                     cost = p.cost_active
                 else:
                     cost = p.cost_inactive
                 results.append( ( str(p.effective_from), calculate_cost(p.effective_from, p.effective_to, cost)) )
             return results
         def get_cost_active(self, start_datetime, end_datetime):
             """Returns a list with the active costs for the specified duration"""
             return []
             return self._get_costs(start_datetime, end_datetime, True)
         def get_cost_inactive(self, start_datetime, end_datetime):
             """Returns a list with the active costs for the specified duration"""
             return []
             return self._get_costs(start_datetime, end_datetime, False)
     class FlavorCost(models.Model):
         cost_active = models.PositiveIntegerField('Active Cost')
         cost_inactive = models.PositiveIntegerField('Inactive Cost')
         effective_from = models.DateField()
         effective_from = models.DateTimeField()
         flavor = models.ForeignKey(Flavor)
         class Meta:
-...
             Charges the VM owner from vm.charged to datetime.now()
             """
             return
             cur_datetime = datetime.datetime.now()
             cost_list = []
             if self._operstate == 'STARTED':
                 cost_list = self.flavor.get_cost_active(self.charged, cur_datetime)
             else:
                 cost_list = self.flavot.get_cost_inactive(self.charged, cur_datetime)
             total_cost = 0
             for cl in cost_list:
                 total_cost = total_cost + cl[1]
             # still need to set correctly the message
             self.owner.debit_account(total_cost, self, "Charged Credits to User")
             self.charged = cur_datetime
             self.save()
     class VirtualMachineGroup(models.Model):
-...
             verbose_name = u'Accounting log'
         def __unicode__(self):
             return u'%s - %s - %s' % (self.vm.name, str(self.date), self.state)
             return u'%s - %s - %s - %s' % ( self.user.id, self.vm.name, str(self.when), self.description)
     class Disk(models.Model):

     # Copyright 2010 Greek Research and Technology Network
+    #
     import unittest
     from datetime import datetime, date, timedelta
     from db.models import *
     from db import credit_allocator
     from db import charger
     from django.conf import settings
     from django.contrib.auth.models import User
     from django.test import TestCase
     class CreditAllocatorTestCase(TestCase):
         fixtures = [ 'db_test_data' ]
         def test_credit_allocator(self):
             """Credit Allocator unit test method"""
             # test the allocator
             credit_allocator.allocate_credit()
             user = SynnefoUser.objects.get(pk=30000)
             self.assertEquals(user.credit, 10, 'Allocation of credits failed, credit: (%d!=10)' % ( user.credit, ) )
             # get the quota from Limit model and check the answer
             limit_quota = user.credit_quota
             self.assertEquals(limit_quota, 100, 'User quota has not retrieved correctly (%d!=100)' % ( limit_quota, ))
             # test if the quota policy is endorced
             for i in range(1, 10):
                 credit_allocator.allocate_credit()
             user = SynnefoUser.objects.get(pk=30000)
             self.assertEquals(user.credit, limit_quota, 'User exceeded quota! (cr:%d, qu:%d)' % ( user.credit, limit_quota ) )
     class FlavorTestCase(TestCase):
         fixtures = [ 'db_test_data' ]
         def test_flavor(self):
             """Test a flavor object, its internal cost calculation and naming methods"""
             flavor = Flavor.objects.get(pk=30000)
             flavor_name = u'C%dR%dD%d' % ( flavor.cpu, flavor.ram, flavor.disk )
             self.assertEquals(flavor.cost_active, 10, 'Active cost is not calculated correctly! (%d!=10)' % ( flavor.cost_active, ) )
             self.assertEquals(flavor.cost_inactive, 5, 'Inactive cost is not calculated correctly! (%d!=5)' % ( flavor.cost_inactive, ) )
             self.assertEquals(flavor.name, flavor_name, 'Invalid flavor name!')
         def test_flavor_cost_history(self):
             """Flavor unit test (find_cost method)"""
             flavor = Flavor.objects.get(pk=30000)
             fch_list = flavor.get_price_list()
             self.assertEquals(len(fch_list), 2, 'Price list should have two objects! (%d!=2)' % ( len(fch_list), ))
             # test current active/inactive costs
             c_active = flavor.current_cost_active
             c_inactive = flavor.current_cost_inactive
             # 2010-10-10, active should be 2, inactive 1
             ex_date = date(year=2010, month=10, day=10)
             r = flavor.find_cost(ex_date)
             self.assertEqual(c_active, 10, 'flavor.cost_active should be 10! (%d)' % ( c_active, ))
             self.assertEqual(c_inactive, 5, 'flavor.cost_inactive should be 5! (%d)' % ( c_inactive, ))
             self.assertEquals(r.cost_active, 2, 'Active cost for 2010-10-10 should be 2 (%d!=2)' % ( r.cost_active, ))
             self.assertEquals(r.cost_inactive, 1, 'Inactive cosr for 2010-10-10 should be 1 (%d!=1)' % ( r.cost_inactive, ))
             # test name property, should be C1R1024D10
             f_name = flavor.name
             # 2011-11-11, active should be 10, inactive 5
             ex_date = date(year=2011, month=11, day=11)
             r = flavor.find_cost(ex_date)
             self.assertEquals(r.cost_active, 10, 'Active cost for 2011-11-11 should be 10 (%d!=10)' % ( r.cost_active, ))
             self.assertEquals(r.cost_inactive, 5, 'Inactive cost for 2011-11-11 should be 5 (%d!=5)' % ( r.cost_inactive, ))
             self.assertEqual(f_name, 'C1R1024D10', 'flavor.name is not generated correctly, C1R1024D10! (%s)' % ( f_name, ))
         def test_flavor_get_costs(self):
             flavor = Flavor.objects.get(pk=30000)
     class DebitTestCase(TestCase):
         fixtures = [ 'db_test_data' ]
         def test_accounting_log(self):
             """Test the Accounting Log unit method"""
             vm = VirtualMachine.objects.get(pk=30000)
             # get all entries, should be 2
             entries = Debit.get_log_entries(vm, datetime.datetime(year=2009, month=01, day=01))
             self.assertEquals(len(entries), 2, 'Log entries should be 2 (%d!=2)' % ( len(entries), ))
             # get enrties only for 2011, should be 1
             entries = Debit.get_log_entries(vm, datetime.datetime(year=2011, month=01, day=01))
             self.assertEquals(len(entries), 1, 'Log entries should be 1 (%d!=1)' % ( len(entries), ))
     class VirtualMachineTestCase(TestCase):
     class SynnefoUserTestCase(TestCase):
         fixtures = [ 'db_test_data' ]
         def test_virtual_machine(self):
             """Virtual Machine (model) unit test method"""
             vm = VirtualMachine.objects.get(pk=30002)
             # should be three
             acc_logs = vm.get_accounting_logs()
             self.assertEquals(len(acc_logs), 3, 'Log Entries should be 3 (%d!=3)' % ( len(acc_logs), ))
         def test_synnefo_user(self):
             """Test a SynnefoUser object"""
             s_user = SynnefoUser.objects.get(pk=30000)
             v_machine = VirtualMachine.objects.get(pk=30000)
             # charge the user
             s_user.debit_account(10, v_machine, "This should be a structured debit message!")
     class ChargerTestCase(TestCase):
         fixtures = [ 'db_test_data' ]
             # should have only one debit object
             d_list = Debit.objects.all()
         def test_charger(self):
             """Charger unit test method"""
             # user with pk=1 should have 100 credits
             user = SynnefoUser.objects.get(pk=1)
             user.credit = 100
             user.save()
             # charge when the vm is running
             charger.charge()
             user = SynnefoUser.objects.get(pk=1)
             self.assertEquals(user.credit, 90, 'Error in charging process (%d!=90, running)' % ( user.credit, ))
             # charge when the vm is stopped
             vm = VirtualMachine.objects.get(pk=1)
             vm.charged = datetime.datetime.now() - datetime.timedelta(hours=1)
             vm.save()
             charger.charge()
             user = SynnefoUser.objects.get(pk=1)
             self.assertEquals(user.credit, 85, 'Error in charging process (%d!=85, stopped)' % ( user.credit, ))
             # try charge until the user spends all his credits, see if the charger
             vm = VirtualMachine.objects.get(pk=1)
             vm.charged = datetime.datetime.now() - datetime.timedelta(hours=1)
             vm.save()
             # the user now has 85, charge until his credits drop to zero
             for i in range(1, 10):
                 vm = VirtualMachine.objects.get(pk=1)
                 vm.charged = datetime.datetime.now() - datetime.timedelta(hours=1)
                 vm.save()
                 charger.charge()
             user = SynnefoUser.objects.get(pk=1)
             self.assertEquals(user.credit, 0, 'Error in charging process (%d!=0, running)' % ( user.credit, ))
             self.assertEqual(len(d_list), 1, 'SynnefoUser.debit_account() writes more than one debit entries!')
             # retrieve the user, now he/she should have zero credits
             s_user = SynnefoUser.objects.get(pk=30000)
             self.assertEqual(0, s_user.credit, 'SynnefoUser (pk=30000) should have zero credits (%d)' % ( s_user.credit, ))

Synnefo

Revision 452d2391