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

Revision 2509ce17

     @api.api_method(http_method='POST', user_required=True, logger=log)
     @quotas.uses_commission
     @transaction.commit_manually
     def create_network(serials, request):
     def create_network(request):
         # Normal Response Code: 202
         # Error Response Codes: computeFault (400, 500),
         #                       serviceUnavailable (503),
-...
             # Check that user provided a valid subnet
             util.validate_network_params(subnet, gateway, subnet6, gateway6)
             # Issue commission
             serial = quotas.issue_network_commission(user_id)
             serials.append(serial)
             # Make the commission accepted, since in the end of this
             # transaction the Network will have been created in the DB.
             serial.accepted = True
             serial.save()
             try:
                 mode, link, mac_prefix, tags = util.values_from_flavor(flavor)
                 network = Network.objects.create(
-...
                     mac_prefix=mac_prefix,
                     tags=tags,
                     action='CREATE',
                     state='PENDING',
                     serial=serial)
                     state='PENDING')
             except EmptyPool:
                 log.error("Failed to allocate resources for network of type: %s",
                           flavor)
-...
             # Create BackendNetwork entries for each Backend
             network.create_backend_network()
             # Issue commission to Quotaholder and accept it since at the end of
             # this transaction the Network object will be created in the DB.
             # Note: the following call does a commit!
             quotas.issue_and_accept_commission(network)
         except:
             transaction.rollback()
             raise

     # 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.
     @quotas.uses_commission
     @transaction.commit_manually
     def create_server(serials, request):
     def create_server(request):
         # Normal Response Code: 202
         # Error Response Codes: computeFault (400, 500),
         #                       serviceUnavailable (503),
-...
             flavor.disk_provider = None
         try:
             # Issue commission
             serial = quotas.issue_vm_commission(user_id, flavor)
             serials.append(serial)
             # Make the commission accepted, since in the end of this
             # transaction the VM will have been created in the DB.
             serial.accepted = True
             serial.save()
             # Allocate IP from public network
             (network, address) = util.get_public_ip(backend)
             nic = {'ip': address, 'network': network.backend_id}
-...
                 userid=user_id,
                 imageid=image_id,
                 flavor=flavor,
                 action="CREATE",
                 serial=serial)
                 action="CREATE")
             # Create VM's public NIC. Do not wait notification form ganeti hooks to
             # create this NIC, because if the hooks never run (e.g. building error)
-...
                     meta_key=key,
                     meta_value=val,
                     vm=vm)
             # Issue commission to Quotaholder and accept it since at the end of
             # this transaction the Network object will be created in the DB.
             # Note: the following call does a commit!
             quotas.issue_and_accept_commission(vm)
         except:
             transaction.rollback()
             raise

     _reverse_tags = dict((v.split(':')[3], k) for k, v in _firewall_tags.items())
     @quotas.uses_commission
     @transaction.commit_on_success
     def process_op_status(serials, vm, etime, jobid, opcode, status, logmsg):
     def process_op_status(vm, etime, jobid, opcode, status, logmsg):
         """Process a job progress notification from the backend
         Process an incoming message from the backend (currently Ganeti).
-...
+            #
             if status == 'success' or (status == 'error' and
                                        vm.operstate == 'ERROR'):
                 # Issue commission
                 serial = quotas.issue_vm_commission(vm.userid, vm.flavor,
                                                     delete=True)
                 serials.append(serial)
                 vm.serial = serial
                 serial.accepted = True
                 serial.save()
                 release_instance_nics(vm)
                 vm.nics.all().delete()
                 vm.deleted = True
                 vm.operstate = state_for_success
                 vm.backendtime = etime
                 # Issue and accept commission to Quotaholder
                 quotas.issue_and_accept_commission(vm, delete=True)
         # Update backendtime only for jobs that have been successfully completed,
         # since only these jobs update the state of the VM. Else a "race condition"
-...
         update_network_state(back_network.network)
     @quotas.uses_commission
     def update_network_state(serials, network):
     def update_network_state(network):
         old_state = network.state
         backend_states = [s.operstate for s in
-...
             # Issue commission
             if network.userid:
                 serial = quotas.issue_network_commission(network.userid,
                                                          delete=True)
                 serials.append(serial)
                 network.serial = serial
                 serial.accepted = True
                 serial.save()
                 quotas.issue_and_accept_commission(network, delete=True)
             elif not network.public:
                 log.warning("Network %s does not have an owner!", network.id)
         network.save()

     # those of the authors and should not be interpreted as representing official
     # policies, either expressed or implied, of GRNET S.A.
     from functools import wraps
     from django.utils import simplejson as json
     from django.db import transaction
     from snf_django.lib.api import faults
     from synnefo.db.models import QuotaHolderSerial
     from synnefo.db.models import QuotaHolderSerial, VirtualMachine, Network
     from synnefo.settings import (CYCLADES_ASTAKOS_SERVICE_TOKEN as ASTAKOS_TOKEN,
                                   ASTAKOS_URL)
-...
             return cls._object
     def uses_commission(func):
         """Decorator for wrapping functions that needs commission.
         All decorated functions must take as first argument the `serials` list in
         order to extend them with the needed serial numbers, as return by the
         Quotaholder
         On successful competition of the decorated function, all serials are
         accepted to the quotaholder, otherwise they are rejected.
         """
         @wraps(func)
         def wrapper(*args, **kwargs):
             try:
                 serials = []
                 ret = func(serials, *args, **kwargs)
             except:
                 log.exception("Unexpected error")
                 try:
                     if serials:
                         reject_commission(serials=serials)
                 except:
                     log.exception("Exception while rejecting serials %s", serials)
                     raise
                 raise
             # func has completed successfully. accept serials
             try:
                 if serials:
                     accept_commission(serials)
                 return ret
             except:
                 log.exception("Exception while accepting serials %s", serials)
                 raise
         return wrapper
     ## FIXME: Wrap the following two functions inside transaction ?
     def accept_commission(serials, update_db=True):
         """Accept a list of pending commissions.
         @param serials: List of QuotaHolderSerial objects
         """
         if update_db:
             for s in serials:
                 if s.pending:
                     s.accepted = True
                     s.save()
         accept_serials = [s.serial for s in serials]
         qh_resolve_commissions(accept=accept_serials)
     def reject_commission(serials, update_db=True):
         """Reject a list of pending commissions.
         @param serials: List of QuotaHolderSerial objects
         """
         if update_db:
             for s in serials:
                 if s.pending:
                     s.rejected = True
                     s.save()
         reject_serials = [s.serial for s in serials]
         qh_resolve_commissions(reject=reject_serials)
     def issue_commission(user, source, provisions,
                          force=False, auto_accept=False):
         """Issue a new commission to the quotaholder.
-...
             raise Exception("No serial")
     # Wrapper functions for issuing commissions for each resource type.  Each
     # functions creates the `commission_info` dictionary as expected by the
     # `issue_commision` function. Commissions for deleting a resource, are the same
     # as for creating the same resource, but with negative resource sizes.
     def issue_vm_commission(user, flavor, delete=False):
         resources = get_server_resources(flavor)
         if delete:
             resources = reverse_quantities(resources)
         return issue_commission(user, DEFAULT_SOURCE, resources)
     def get_server_resources(flavor):
         return {'cyclades.vm': 1,
                 'cyclades.cpu': flavor.cpu,
                 'cyclades.disk': 1073741824 * flavor.disk,  # flavor.disk is in GB
                 # 'public_ip': 1,
                 #'disk_template': flavor.disk_template,
                 'cyclades.ram': 1048576 * flavor.ram}  # flavor.ram is in MB
     def issue_network_commission(user, delete=False):
         resources = get_network_resources()
         if delete:
             resources = reverse_quantities(resources)
         return issue_commission(user, DEFAULT_SOURCE, resources)
     def get_network_resources():
         return {"cyclades.network.private": 1}
     def reverse_quantities(resources):
         return dict((r, -s) for r, s in resources.items())
     ##
     ## Reconcile pending commissions
     ##
     def accept_commissions(accepted):
         qh_resolve_commissions(accept=accepted)
-...
         qh_resolve_commissions(reject=rejected)
     def fix_pending_commissions():
         (accepted, rejected) = resolve_pending_commissions()
         qh_resolve_commissions(accepted, rejected)
     def qh_resolve_commissions(accept=None, reject=None):
         if accept is None:
             accept = []
-...
         qh.resolve_commissions(ASTAKOS_TOKEN, accept, reject)
     def fix_pending_commissions():
         (accepted, rejected) = resolve_pending_commissions()
         qh_resolve_commissions(accepted, rejected)
     def resolve_pending_commissions():
         """Resolve quotaholder pending commissions.
-...
         min_ = qh_pending[0]
         serials = QuotaHolderSerial.objects.filter(serial__gte=min_, pending=False)
         accepted = serials.filter(accepted=True).values_list('serial', flat=True)
         accepted = serials.filter(accept=True).values_list('serial', flat=True)
         accepted = filter(lambda x: x in qh_pending, accepted)
         rejected = list(set(qh_pending) - set(accepted))
-...
                   " Available: %s, Requested: %s"\
                   % (resource, available, requested)
         return msg, details
     @transaction.commit_manually
     def issue_and_accept_commission(resource, delete=False):
         """Issue and accept a commission to Quotaholder.
         This function implements the Commission workflow, and must be called
         exactly after and in the same transaction that created/updated the
         resource. The workflow that implements is the following:
 ) Issue commission and get a serial
 ) Store the serial in DB and mark is as one to accept
 ) Correlate the serial with the resource
 ) COMMIT!
 ) Accept commission to QH (reject if failed until 5)
 ) Mark serial as resolved
 ) COMMIT!
         """
         try:
             # Convert resources in the format expected by Quotaholder
             qh_resources = prepare_qh_resources(resource)
             if delete:
                 qh_resources = reverse_quantities(qh_resources)
             # Issue commission and get the assigned serial
             serial = issue_commission(resource.userid, DEFAULT_SOURCE,
                                       qh_resources)
         except:
             transaction.rollback()
             raise
         try:
             # Mark the serial as one to accept. This step is necessary for
             # reconciliation
             serial.pending = False
             serial.accept = True
             serial.save()
             # Associate serial with the resource
             resource.serial = serial
             resource.save()
             # Commit transaction in the DB! If this commit succeeds, then the
             # serial is created in the DB with all the necessary information to
             # reconcile commission
             transaction.commit()
         except:
             transaction.rollback()
             serial.pending = False
             serial.accept = False
             serial.save()
             transaction.commit()
             raise
         if serial.accept:
             # Accept commission to Quotaholder
             accept_commissions(accepted=[serial.serial])
         else:
             reject_commissions(rejected=[serial.serial])
         # Mark the serial as resolved, indicating that no further actions are
         # needed for this serial
         serial.resolved = True
         serial.save()
         transaction.commit()
         return serial
     def prepare_qh_resources(resource):
         if isinstance(resource, VirtualMachine):
             flavor = resource.flavor
             return {'cyclades.vm': 1,
                     'cyclades.cpu': flavor.cpu,
                     'cyclades.disk': 1073741824 * flavor.disk,  # flavor.disk in GB
                     # 'public_ip': 1,
                     #'disk_template': flavor.disk_template,
                     'cyclades.ram': 1048576 * flavor.ram}  # flavor.ram is in MB
         elif isinstance(resource, Network):
             return {"cyclades.network.private": 1}
         else:
             raise ValueError("Unknown Resource '%s'" % resource)
     def reverse_quantities(resources):
         return dict((r, -s) for r, s in resources.items())

Also available in: Unified diff