Synnefo

from functools import wraps

from synnefo import quotas

                               VirtualMachineMetadata, IPAddressLog, Network,

                               Volume)

def validate_server_action(vm, action):

    if vm.deleted:

        raise faults.BadRequest("Server '%s' has been deleted." % vm.id)

    # Destroyin a server should always be permitted

    if action == "DESTROY":

        return

    # Check that there is no pending action

    pending_action = vm.task

    if pending_action:

        if pending_action == "BUILD":

            raise faults.BuildInProgress("Server '%s' is being build." % vm.id)

        raise faults.BadRequest("Cannot perform '%s' action while there is a"

                                " pending '%s'." % (action, pending_action))

    # Check if action can be performed to VM's operstate

    operstate = vm.operstate

    if operstate == "ERROR":

        raise faults.BadRequest("Cannot perform '%s' action while server is"

                                " in 'ERROR' state." % action)

    elif operstate == "BUILD" and action != "BUILD":

        raise faults.BuildInProgress("Server '%s' is being build." % vm.id)

    elif (action == "START" and operstate != "STOPPED") or\

         (action == "STOP" and operstate != "STARTED") or\

         (action == "RESIZE" and operstate != "STOPPED") or\

         (action in ["CONNECT", "DISCONNECT"]

          and operstate != "STOPPED"

          and not settings.GANETI_USE_HOTPLUG) or \

         (action in ["ATTACH_VOLUME", "DETACH_VOLUME"]

          and operstate != "STOPPED"

          and not settings.GANETI_USE_HOTPLUG):

        raise faults.BadRequest("Cannot perform '%s' action while server is"

                                " in '%s' state." % (action, operstate))

    return

def server_command(action, action_fields=None):

    """Handle execution of a server action.

    Helper function to validate and execute a server action, handle quota

    commission and update the 'task' of the VM in the DB.

    1) Check if action can be performed. If it can, then there must be no

       pending task (with the exception of DESTROY).

    2) Handle previous commission if unresolved:

       * If it is not pending and it to accept, then accept

       * If it is not pending and to reject or is pending then reject it. Since

       the action can be performed only if there is no pending task, then there

       can be no pending commission. The exception is DESTROY, but in this case

       the commission can safely be rejected, and the dispatcher will generate

       the correct ones!

    3) Issue new commission and associate it with the VM. Also clear the task.

    4) Send job to ganeti

    5) Update task and commit

    """

    def decorator(func):

        @wraps(func)

        @transaction.commit_on_success

        def wrapper(vm, *args, **kwargs):

            user_id = vm.userid

            validate_server_action(vm, action)

            vm.action = action

            commission_name = "client: api, resource: %s" % vm

            quotas.handle_resource_commission(vm, action=action,

                                              action_fields=action_fields,

                                              commission_name=commission_name)

            vm.save()

            # XXX: Special case for server creation!

            if action == "BUILD":

                # Perform a commit, because the VirtualMachine must be saved to

                # DB before the OP_INSTANCE_CREATE job in enqueued in Ganeti.

                # Otherwise, messages will arrive from snf-dispatcher about

                # this instance, before the VM is stored in DB.

                transaction.commit()

                # After committing the locks are released. Refetch the instance

                # to guarantee x-lock.

                vm = VirtualMachine.objects.select_for_update().get(id=vm.id)

            # Send the job to Ganeti and get the associated jobID

            try:

                job_id = func(vm, *args, **kwargs)

            except Exception as e:

                if vm.serial is not None:

                    # Since the job never reached Ganeti, reject the commission

                    log.debug("Rejecting commission: '%s', could not perform"

                              " action '%s': %s" % (vm.serial,  action, e))

                    transaction.rollback()

                    quotas.reject_resource_serial(vm)

                    transaction.commit()

                raise

            if action == "BUILD" and vm.serial is not None:

                # XXX: Special case for server creation: we must accept the

                # commission because the VM has been stored in DB. Also, if

                # communication with Ganeti fails, the job will never reach

                # Ganeti, and the commission will never be resolved.

                quotas.accept_resource_serial(vm)

            log.info("user: %s, vm: %s, action: %s, job_id: %s, serial: %s",

                     user_id, vm.id, action, job_id, vm.serial)

            # store the new task in the VM

            if job_id is not None:

                vm.task = action

                vm.task_job_id = job_id

            vm.save()

            return vm

        return wrapper

    return decorator

def create(userid, name, password, flavor, image, metadata={},

           personality=[], networks=None, use_backend=None):

    if image["size"] > (flavor.disk << 30):

        msg = "Flavor's disk size '%s' is smaller than the image's size '%s'"

        raise faults.BadRequest(msg % (flavor.disk << 30, image["size"]))

    # Fix flavor for archipelago

    disk_template, provider = util.get_flavor_provider(flavor)

    if provider:

        flavor.disk_template = disk_template

        flavor.disk_provider = provider

        flavor.disk_origin = None

        if provider in settings.GANETI_CLONE_PROVIDERS:

            flavor.disk_origin = image['checksum']

            image['backend_id'] = 'null'

    else:

        flavor.disk_provider = None

    volumes = create_instance_volumes(vm, flavor, image)

    vm = create_server(vm, ports, volumes, flavor, image, personality,

@server_command("BUILD")

        'img_id': image['backend_id'],

def create_instance_volumes(vm, flavor, image):

    name = "Root volume of server: %s" % vm.id

    volume = Volume.objects.create(userid=vm.userid,

                                   machine=vm,

                                   name=name,

                                   size=flavor.disk,

                                   source=Volume.SOURCE_IMAGE_PREFIX+image["id"],

                                   origin=image["checksum"],

                                   status="CREATING")

    volume.save()

    return [volume]

@server_command("DESTROY")

@server_command("START")

@server_command("STOP")

@server_command("REBOOT")

    comm = server_command("RESIZE", action_fields=action_fields)

@server_command("SET_FIREWALL_PROFILE")

@server_command("CONNECT")

@server_command("DISCONNECT")

@server_command("ATTACH_VOLUME")

def attach_volume(vm, volume):

    """Attach a volume to a server.

    The volume must be in 'AVAILABLE' status in order to be attached. Also,

    number of the volumes that are attached to the server must remain less

    than 'GANETI_MAX_DISKS_PER_INSTANCE' setting. This function will send

    the corresponding job to Ganeti backend and update the status of the

    volume to 'ATTACHING'.

    """

    # Check volume state

    if volume.status not in ["AVAILABLE", "CREATING"]:

        raise faults.BadRequest("Cannot attach volume while volume is in"

                                " '%s' status." % volume.status)

    # Check that disk templates are the same

    if volume.disk_template != vm.flavor.disk_template:

        msg = ("Volume and server must have the same disk template. Volume has"

               " disk template '%s' while server has '%s'"

               % (volume.disk_template, vm.flavor.disk_template))

        raise faults.BadRequest(msg)

    # Check maximum disk per instance hard limit

    if vm.volumes.count() == settings.GANETI_MAX_DISKS_PER_INSTANCE:

        raise faults.BadRequest("Maximum volumes per server limit reached")

    jobid = backend.attach_volume(vm, volume)

    log.info("Attached volume '%s' to server '%s'. JobID: '%s'", volume.id,

             volume.machine_id, jobid)

    volume.backendjobid = jobid

    volume.machine = vm

    volume.status = "ATTACHING"

    volume.save()

    return jobid

@server_command("DETACH_VOLUME")

def detach_volume(vm, volume):

    """Detach a volume to a server.

    The volume must be in 'IN_USE' status in order to be detached. Also,

    the root volume of the instance (index=0) can not be detached. This

    function will send the corresponding job to Ganeti backend and update the

    status of the volume to 'DETACHING'.

    """

    _check_attachment(vm, volume)

    if volume.status != "IN_USE":

        #TODO: Maybe allow other statuses as well ?

        raise faults.BadRequest("Cannot detach volume while volume is in"

                                " '%s' status." % volume.status)

    if volume.index == 0:

        raise faults.BadRequest("Cannot detach the root volume of a server")

    jobid = backend.detach_volume(vm, volume)

    log.info("Detached volume '%s' from server '%s'. JobID: '%s'", volume.id,

             volume.machine_id, jobid)

    volume.backendjobid = jobid

    volume.status = "DETACHING"

    volume.save()

    return jobid

def _check_attachment(vm, volume):

    """Check that volume is attached to vm."""

    if volume.machine_id != vm.id:

        raise faults.BadRequest("Volume '%s' is not attached to server '%s'"

                                % volume.id, vm.id)