Synnefo

VOLUME_SOURCE_TYPES = [

    "snapshot",

    "image",

    "volume",

    "blank"

]

    volumes = None

    dev_map = server.get("block_device_mapping_v2")

    if dev_map is not None:

        volumes = parse_block_device_mapping(dev_map)

    vm = servers.create(user_id, name, password, flavor, image_id,

                        networks=networks, volumes=volumes)

def parse_block_device_mapping(dev_map):

    """Parse 'block_device_mapping_v2' attribute"""

    if not isinstance(dev_map, list):

        raise faults.BadRequest("Block Device Mapping is Invalid")

    return [_parse_block_device(device) for device in dev_map]

def _parse_block_device(device):

    """Parse and validate a block device mapping"""

    if not isinstance(device, dict):

        raise faults.BadRequest("Block Device Mapping is Invalid")

    # Validate source type

    source_type = device.get("source_type")

    if source_type is None:

        raise faults.BadRequest("Block Device Mapping is Invalid: Invalid"

                                " source_type field")

    elif source_type not in VOLUME_SOURCE_TYPES:

        raise faults.BadRequest("Block Device Mapping is Invalid: source_type"

                                " must be on of %s"

                                % ", ".join(VOLUME_SOURCE_TYPES))

    # Validate source UUID

    uuid = device.get("uuid")

    if uuid is None and source_type != "blank":

        raise faults.BadRequest("Block Device Mapping is Invalid: uuid of"

                                " %s is missing" % source_type)

    # Validate volume size

    size = device.get("volume_size")

    if size is not None:

        try:

            size = int(size)

        except (TypeError, ValueError):

            raise faults.BadRequest("Block Device Mapping is Invalid: Invalid"

                                    " size field")

    # Validate 'delete_on_termination'

    delete_on_termination = device.get("delete_on_termination")

    if delete_on_termination is not None:

        if not isinstance(delete_on_termination, bool):

            raise faults.BadRequest("Block Device Mapping is Invalid: Invalid"

                                    " delete_on_termination field")

    else:

        if source_type == "volume":

            delete_on_termination = False

        else:

            delete_on_termination = True

    # Unused API Attributes

    # boot_index = device.get("boot_index")

    # destination_type = device.get("destination_type")

    return {"source_type": source_type,

            "source_uuid": uuid,

            "size": size,

            "delete_on_termination": delete_on_termination}

            "device": ""}  # TODO: What device to return?

                               IPAddress, NetworkInterface, Volume)

                            "size": 1024,

                            "is_snapshot": False,

@patch('synnefo.volume.util.get_snapshot', fixed_image)

    def test_create_server_with_volumes(self, mrapi):

        user = "test_user"

        mrapi().CreateInstance.return_value = 42

        # Test creation without any volumes. Server will use flavor+image

        request = deepcopy(self.request)

        request["server"]["block_device_mapping_v2"] = []

        with mocked_quotaholder():

            response = self.mypost("servers", user,

                                   json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202, msg=response.content)

        vm_id = json.loads(response.content)["server"]["id"]

        volume = Volume.objects.get(machine_id=vm_id)

        self.assertEqual(volume.disk_template, self.flavor.disk_template)

        self.assertEqual(volume.size, self.flavor.disk)

        self.assertEqual(volume.source, "image:%s" % fixed_image()["id"])

        self.assertEqual(volume.delete_on_termination, True)

        self.assertEqual(volume.userid, user)

        # Test using an image

        request["server"]["block_device_mapping_v2"] = [

            {"source_type": "image",

             "uuid": fixed_image()["id"],

             "volume_size": 10,

             "delete_on_termination": False}

        ]

        with mocked_quotaholder():

            response = self.mypost("servers", user,

                                   json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202, msg=response.content)

        vm_id = json.loads(response.content)["server"]["id"]

        volume = Volume.objects.get(machine_id=vm_id)

        self.assertEqual(volume.disk_template, self.flavor.disk_template)

        self.assertEqual(volume.size, 10)

        self.assertEqual(volume.source, "image:%s" % fixed_image()["id"])

        self.assertEqual(volume.delete_on_termination, False)

        self.assertEqual(volume.userid, user)

        self.assertEqual(volume.origin, "pithos:" + fixed_image()["checksum"])

        # Test using a snapshot

        request["server"]["block_device_mapping_v2"] = [

            {"source_type": "snapshot",

             "uuid": fixed_image()["id"],

             "volume_size": 10,

             "delete_on_termination": False}

        ]

        with mocked_quotaholder():

            response = self.mypost("servers", user,

                                   json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202, msg=response.content)

        vm_id = json.loads(response.content)["server"]["id"]

        volume = Volume.objects.get(machine_id=vm_id)

        self.assertEqual(volume.disk_template, self.flavor.disk_template)

        self.assertEqual(volume.size, 10)

        self.assertEqual(volume.source, "snapshot:%s" % fixed_image()["id"])

        self.assertEqual(volume.origin, fixed_image()["checksum"])

        self.assertEqual(volume.delete_on_termination, False)

        self.assertEqual(volume.userid, user)

        source_volume = volume

        # Test using source volume

        request["server"]["block_device_mapping_v2"] = [

            {"source_type": "volume",

             "uuid": source_volume.id,

             "volume_size": source_volume.size,

             "delete_on_termination": False}

        ]

        with mocked_quotaholder():

            response = self.mypost("servers", user,

                                   json.dumps(request), 'json')

        # This will fail because the volume is not AVAILABLE.

        self.assertBadRequest(response)

        # Test using a blank volume

        request["server"]["block_device_mapping_v2"] = [

            {"source_type": "blank",

             "volume_size": 10,

             "delete_on_termination": True}

        ]

        with mocked_quotaholder():

            response = self.mypost("servers", user,

                                   json.dumps(request), 'json')

        self.assertBadRequest(response)

    kw['disk_template'] = volumes[0].template

# Copyright 2011, 2012, 2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

#   1. Redistributions of source code must retain the above copyright

#      notice, this list of conditions and the following disclaimer.

#

#  2. Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

# SUCH DAMAGE.

#

# The views and conclusions contained in the software and documentation are

# those of the authors and should not be interpreted as representing official

# policies, either expressed or implied, of GRNET S.A.

import logging

from functools import wraps

from django.db import transaction

from django.conf import settings

from snf_django.lib.api import faults

from synnefo import quotas

from synnefo.db.models import VirtualMachine

log = logging.getLogger(__name__)

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

        server = servers.create(user_id, name, password, flavor, image["id"],

# Copyright 2011, 2012, 2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

#   1. Redistributions of source code must retain the above copyright

#      notice, this list of conditions and the following disclaimer.

#

#  2. Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

# SUCH DAMAGE.

#

# The views and conclusions contained in the software and documentation are

# those of the authors and should not be interpreted as representing official

# policies, either expressed or implied, of GRNET S.A.

import logging

from snf_django.lib.api import faults

from django.conf import settings

from synnefo.logic import backend, commands

log = logging.getLogger(__name__)

@commands.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

@commands.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)

                               VirtualMachineMetadata, IPAddressLog, Network)

from synnefo.volume.volumes import _create_volume

from synnefo.volume.util import get_volume

from synnefo.logic import commands

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

           personality=[], networks=None, volumes=None,

           use_backend=None):

    # Get image information

    # TODO: Image is not mandatory if disks are specified

    image = util.get_image_dict(image_id, userid)

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

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

               "size '%s'" % (flavor.disk << 30, image["size"]))

        raise faults.BadRequest(msg)

    # If no volumes are specified, we automatically create a volume with the

    # size of the flavor and filled with the specified image.

    if not volumes:

        volumes = [{"source_type": "image",

                    "source_uuid": image["id"],

                    "size": flavor.disk,

                    "delete_on_termination": True}]

    assert(len(volumes) > 0), "Cannot create server without volumes"

    if volumes[0]["source_type"] == "blank":

        raise faults.BadRequest("Root volume cannot be blank")

    server_volumes = []

    for index, vol_info in enumerate(volumes):

        if vol_info["source_type"] == "volume":

            uuid = vol_info["source_uuid"]

            v = get_volume(userid, uuid, for_update=True,

                           exception=faults.BadRequest)

            if v.status != "AVAILABLE":

                raise faults.BadRequest("Cannot use volume while it is in %s"

                                        " status" % v.status)

            v.delete_on_termination = vol_info["delete_on_termination"]

            v.index = index

            v.save()

        else:

            v = _create_volume(server=vm, user_id=userid,

                               index=index, **vol_info)

        server_volumes.append(v)

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

@commands.server_command("BUILD")

    # If the root volume has a provider, then inform snf-image to not fill

    # the volume with data

    image_id = image["backend_id"]

    root_volume = volumes[0]

    if root_volume.origin is not None:

        image_id = "null"

        'img_id': image_id,

@commands.server_command("DESTROY")

@commands.server_command("START")

@commands.server_command("STOP")

@commands.server_command("REBOOT")

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

@commands.server_command("SET_FIREWALL_PROFILE")

@commands.server_command("CONNECT")

@commands.server_command("DISCONNECT")

from synnefo.db.models import Volume

from synnefo.logic import server_attachments

    # Currently we cannot create volumes without being attached to a server

    if source_volume_id is not None:

        source_type = "volume"

        source_uuid = source_volume_id

    elif source_snapshot_id is not None:

        source_type = "snapshot"

        source_uuid = source_snapshot_id

    elif source_image_id is not None:

        source_type = "image"

        source_uuid = source_image_id

    else:

        source_type = source_uuid = None

    volume = _create_volume(server, user_id, size, source_type, source_uuid,

                            name, description, index=None)

    if metadata is not None:

        for meta_key, meta_val in metadata.items():

            volume.metadata.create(key=meta_key, value=meta_val)

    server_attachments.attach_volume(server, volume)

    return volume

def _create_volume(server, user_id, size, source_type, source_uuid,

                   name=None, description=None, index=None,

                   delete_on_termination=True):

    # Only ext_ disk template supports cloning from another source. Otherwise

    # is must be the root volume so that 'snf-image' fill the volume

    can_have_source = (index == 0 or disk_template.startswith("ext_"))

    if not can_have_source and source_type != "blank":

    # TODO: Check Volume/Snapshot Status

    if source_type == "volume":

        source_volume = util.get_volume(user_id, source_uuid,

        if source_volume.status != "IN_USE":

            raise faults.BadRequest("Cannot clone volume while it is in '%s'"

                                    " status" % source_volume.status)

        # If no size is specified, use the size of the volume

        if size is None:

            size = source_volume.size

        elif size < source_volume.size:

            raise faults.BadRequest("Volume size cannot be smaller than the"

                                    " source volume")

        source = Volume.prefix_source(source_uuid, source_type="volume")

    elif source_type == "snapshot":

        source_snapshot = util.get_snapshot(user_id, source_uuid,

        source = Volume.prefix_source(source_uuid,

        if size is None:

            raise faults.BadRequest("Volume size is required")

        elif (size << 30) < int(source_snapshot["size"]):

            raise faults.BadRequest("Volume size '%s' is smaller than"

                                    " snapshot's size '%s'"

                                    % (size << 30, source_snapshot["size"]))

    elif source_type == "image":

        source_image = util.get_image(user_id, source_uuid,

        if size is None:

            raise faults.BadRequest("Volume size is required")

        elif (size << 30) < int(source_image["size"]):

            raise faults.BadRequest("Volume size '%s' is smaller than"

                                    " image's size '%s'"

                                    % (size << 30, source_image["size"]))

        source = Volume.prefix_source(source_uuid, source_type="image")

    elif source_type == "blank":

        if size is None:

            raise faults.BadRequest("Volume size is required")

        source = origin = None

    else:

        raise faults.BadRequest("Unknwon source type")

                                   delete_on_termination=delete_on_termination,

        server_attachments.detach_volume(volume.machine, volume)