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

     @util.api_method('POST')
     @transaction.commit_on_success
     # Use manual transactions. Backend and IP pool allocations need exclusive
     # access (SELECT..FOR UPDATE). Running create_server with commit_on_success
     # would result in backends and public networks to be locked until the job is
     # sent to the Ganeti backend.
     @transaction.commit_manually
     def create_server(request):
         # Normal Response Code: 202
         # Error Response Codes: computeFault (400, 500),
-...
         backend_allocator = BackendAllocator()
         backend = backend_allocator.allocate(flavor)
         if backend is None:
             transaction.rollback()
             raise Exception
         transaction.commit()
         if settings.PUBLIC_ROUTED_USE_POOL:
             (network, address) = util.allocate_public_address(backend)
             if address is None:
                 transaction.rollback()
                 raise faults.OverLimit("Can not allocate IP for new machine."
                                        " Public networks are full.")
             transaction.commit()
             nic = {'ip': address, 'network': network.backend_id}
         else:
             nic = {'ip': 'pool', 'network': network.backend_id}
         # We must save the VM instance now, so that it gets a valid
         # vm.backend_vm_id.
-...
             flavor=flavor)
         try:
             jobID = create_instance(vm, flavor, image, password, personality)
             jobID = create_instance(vm, nic, flavor, image, password, personality)
         except GanetiApiError:
             vm.delete()
             raise
-...
         server = vm_to_dict(vm, detail=True)
         server['status'] = 'BUILD'
         server['adminPass'] = password
         return render_server(request, server, status=202)
         respsone = render_server(request, server, status=202)
         transaction.commit()
         return respsone
     @util.api_method('GET')

     from synnefo.db.models import (Flavor, VirtualMachine, VirtualMachineMetadata,
                                    Network, BackendNetwork, NetworkInterface,
                                    BridgePoolTable, MacPrefixPoolTable)
     from synnefo.db.pools import EmptyPool
     from synnefo.lib.astakos import get_user
     from synnefo.plankton.backend import ImageBackend
-...
         return cidr_block <= 29 and cidr_block > MAX_CIDR_BLOCK
     def allocate_public_address(backend):
         """Allocate a public IP for a vm."""
         for network in backend_public_networks(backend):
             try:
                 address = get_network_free_address(network)
                 return (network, address)
             except EmptyPool:
                 pass
         return (None, None)
     def backend_public_networks(backend):
         """Return available public networks of the backend.

                                                 params)
     class ProtectedDeleteManager(Manager):
     class ProtectedDeleteManager(ForUpdateManager):
         """ Manager for protecting Backend deletion.
             Call Backend delete() method in order to prevent deletion

     from synnefo.db.models import (Backend, VirtualMachine, Network,
                                    BackendNetwork, BACKEND_STATUSES)
     from synnefo.logic import utils
     from synnefo.db.pools import EmptyPool
     from synnefo.api.faults import OverLimit
     from synnefo.api.util import backend_public_networks, get_network_free_address
     from synnefo.util.rapi import GanetiRapiClient
     log = getLogger('synnefo.logic')
-...
         vm.save()
     @transaction.commit_on_success
     def create_instance(vm, flavor, image, password, personality):
     def create_instance(vm, public_nic, flavor, image, password, personality):
         """`image` is a dictionary which should contain the keys:
                 'backend_id', 'format' and 'metadata'
             metadata value should be a dictionary.
         """
         if settings.PUBLIC_ROUTED_USE_POOL:
             (network, address) = allocate_public_address(vm)
             if address is None:
                 raise OverLimit("Can not allocate IP for new machine."
                                 " Public networks are full.")
             nic = {'ip': address, 'network': network.backend_id}
         else:
             nic = {'ip': 'pool', 'network': network.backend_id}
         if settings.IGNORE_FLAVOR_DISK_SIZES:
             if image['backend_id'].find("windows") >= 0:
                 sz = 14000
-...
         if provider:
             kw['disks'][0]['provider'] = provider
         kw['nics'] = [nic]
         kw['nics'] = [public_nic]
         if settings.GANETI_USE_HOTPLUG:
             kw['hotplug'] = True
         # Defined in settings.GANETI_CREATEINSTANCE_KWARGS
-...
         return vm.client.CreateInstance(**kw)
     def allocate_public_address(vm):
         """Allocate a public IP for a vm."""
         for network in backend_public_networks(vm.backend):
             try:
                 address = get_network_free_address(network)
                 return (network, address)
             except EmptyPool:
                 pass
         return (None, None)
     def delete_instance(vm):
         start_action(vm, 'DESTROY')
         vm.client.DeleteInstance(vm.backend_vm_id, dry_run=settings.TEST)

                 importlib.import_module(settings.BACKEND_ALLOCATOR_MODULE)
         def allocate(self, flavor):
             """Allocate a vm of the specified flavor to a backend.
             Warning!!: An explicit commit is required after calling this function,
             in order to release the locks acquired by the get_available_backends
             function.
             """
             # Get the size of the vm
             disk = flavor_disk(flavor)
             ram = flavor.ram
-...
         """Get available backends from db.
         """
         return Backend.objects.filter(drained=False, offline=False)
         return list(Backend.objects.select_for_update().filter(drained=False,
                                                                offline=False))
     def flavor_disk(flavor):

Synnefo

Revision adc46059