Synnefo

        ("DELETED", "The volume has been deleted"),

from synnefo import volume

UNKNOWN_NIC_PREFIX = "unknown-nic-"

UNKNOWN_DISK_PREFIX = "unknown-disk-"

            try:

                serial = quotas.handle_resource_commission(

                    vm, action,

                    action_fields=job_fields,

                    commission_name=reason,

                    force=True,

                    auto_accept=True)

            except:

                log.exception("Error while handling new commission")

                raise

            snap_info = json.loads(disk_info["snapshot_info"])

            snap_id = snap_info["snapshot_id"]

            update_snapshot(snap_id, user_id=vm.userid, job_id=jobid,

                            job_status=status, etime=etime)

        beparams = job_fields.get("beparams")

            cpu = beparams.get("vcpus")

            ram = beparams.get("maxmem")

            new_flavor = find_new_flavor(vm, cpu=cpu, ram=ram)

        # XXX: Update backendtime only for jobs that have been successfully

        if nics is not None:

            update_vm_nics(vm, nics, etime)

        if disks is not None:

            # XXX: Replace the job fields with mocked changes as produced by

            # the diff between the DB and Ganeti disks. This is required in

            # order to update quotas for disks that changed, but not from this

            # job!

            disk_changes = update_vm_disks(vm, disks, etime)

            job_fields["disks"] = disk_changes

            vm.volumes.all().update(deleted=True, status="DELETED",

                                    machine=None)

    # Update VM's state and flavor after handling of quotas, since computation

    # of quotas depends on these attributes

def find_new_flavor(vm, cpu=None, ram=None):

    """Find VM's new flavor based on the new CPU and RAM"""

    if cpu is None and ram is None:

        return None

    ram = ram if ram is not None else old_flavor.ram

    cpu = cpu if cpu is not None else old_flavor.cpu

    if cpu == old_flavor.cpu and ram == old_flavor.ram:

        return None

        new_flavor = Flavor.objects.get(cpu=cpu, ram=ram,

        raise Exception("There is no flavor to match the instance specs!"

                        " Instance: %s CPU: %s RAM %s: Disk: %s Template: %s"

                        % (vm.backend_vm_id, cpu, ram, old_flavor.disk,

                           old_flavor.disk_template))

    log.info("Flavor of VM '%s' changed from '%s' to '%s'", vm,

             old_flavor.name, new_flavor.name)

def nics_are_equal(db_nic, gnt_nic):

    """Check if DB and Ganeti NICs are equal."""

    for field in NIC_FIELDS:

        if getattr(db_nic, field) != gnt_nic[field]:

            return False

    return True

def parse_instance_nics(gnt_nics):

    """Parse NICs of a Ganeti instance"""

    nics = []

    for index, gnic in enumerate(gnt_nics):

        nic_name = gnic.get("name", None)

        if nic_name is not None:

            nic_id = utils.id_from_nic_name(nic_name)

        else:

            # Unknown NIC

            nic_id = UNKNOWN_NIC_PREFIX + str(index)

        network_name = gnic.get('network', '')

        network_id = utils.id_from_network_name(network_name)

        network = Network.objects.get(id=network_id)

        subnet6 = network.subnet6

        # Get the new nic info

        mac = gnic.get('mac')

        ipv4 = gnic.get('ip')

        ipv6 = mac2eui64(mac, subnet6.cidr) if subnet6 else None

        firewall = gnic.get('firewall')

        firewall_profile = _reverse_tags.get(firewall)

        if not firewall_profile and network.public:

            firewall_profile = settings.DEFAULT_FIREWALL_PROFILE

        nic_info = {

            'index': index,

            'network': network,

            'mac': mac,

            'ipv4_address': ipv4,

            'ipv6_address': ipv6,

            'firewall_profile': firewall_profile,

            'state': 'ACTIVE'}

        nics.append((nic_id, nic_info))

    return dict(nics)

def update_vm_nics(vm, nics, etime=None):

    """Update VM's NICs to match with the NICs of the Ganeti instance

    This function will update the VM's NICs(update, delete or create) and

    return a list of quotable changes.

    @param vm: The VirtualMachine the NICs belong to

    @type vm: VirtualMachine object

    @param nics: The NICs of the Ganeti instance

    @type nics: List of dictionaries with NIC information

    @param etime: The datetime the Ganeti instance had these NICs

    @type etime: datetime

    @return: List of quotable changes (add/remove NIC) (currently empty list)

    @rtype: List of dictionaries

    ganeti_nics = parse_instance_nics(nics)

    db_nics = dict([(nic.id, nic) for nic in vm.nics.select_related("network")

                                                    .prefetch_related("ips")])

    return []

def change_address_of_port(port, userid, old_address, new_address, version):

    """Change."""

    if old_address is not None:

        msg = ("IPv%s Address of server '%s' changed from '%s' to '%s'"

               % (version, port.machine_id, old_address, new_address))

        log.error(msg)

    # Remove the old IP address

    remove_nic_ips(port, version=version)

    if version == 4:

        ipaddress = ips.allocate_ip(port.network, userid, address=new_address)

        ipaddress.nic = port

        ipaddress.save()

    elif version == 6:

        subnet6 = port.network.subnet6

        ipaddress = IPAddress.objects.create(userid=userid,

                                             network=port.network,

                                             subnet=subnet6,

                                             nic=port,

                                             address=new_address,

                                             ipversion=6)

    else:

        raise ValueError("Unknown version: %s" % version)

    # New address log

    ip_log = IPAddressLog.objects.create(server_id=port.machine_id,

                                         network_id=port.network_id,

                                         address=new_address,

                                         active=True)

    log.info("Created IP log entry '%s' for address '%s' to server '%s'",

             ip_log.id, new_address, port.machine_id)

    return ipaddress

def update_vm_disks(vm, disks, etime=None):

    """Update VM's disks to match with the disks of the Ganeti instance

    This function will update the VM's disks(update, delete or create) and

    return a list of quotable changes.

    @param vm: The VirtualMachine the disks belong to

    @type vm: VirtualMachine object

    @param disks: The disks of the Ganeti instance

    @type disks: List of dictionaries with disk information

    @param etime: The datetime the Ganeti instance had these disks

    @type etime: datetime

    @return: List of quotable changes (add/remove disk)

    @rtype: List of dictionaries

    gnt_disks = parse_instance_disks(disks)

    changes = []

    for disk_name in set(db_disks.keys()) | set(gnt_disks.keys()):

        gnt_disk = gnt_disks.get(disk_name)

        if gnt_disk is None:

            # Disk exists in DB but not in Ganeti

                db_disk.status = "DELETED"

                changes.append(("remove", db_disk, {}))

            # Disk exists in Ganeti but not in DB

            # TODO: Automatically import disk!

        elif not disks_are_equal(db_disk, gnt_disk):

            # Disk has changed

            if gnt_disk["size"] != db_disk.size:

                # Size of the disk has changed! TODO: Fix flavor!

                size_delta = gnt_disk["size"] - db_disk.size

                changes.append(("modify", db_disk, {"size_delta": size_delta}))

            if db_disk.status == "CREATING":

                # Disk has been created

                changes.append(("add", db_disk, {}))

            # Update the disk in DB with the values from Ganeti disk

            [setattr(db_disk, f, gnt_disk[f]) for f in DISK_FIELDS]

            db_disk.save()

    return changes

    """Check if DB and Ganeti disks are equal"""

def parse_instance_disks(gnt_disks):

    """Parse disks of a Ganeti instance"""

    disks = []

    for index, gnt_disk in enumerate(gnt_disks):

        disk_name = gnt_disk.get("name", None)

        else:  # Unknown disk

            'size': gnt_disk["size"] >> 10,  # Size in GB

        disks.append((disk_id, disk_info))

    return dict(disks)

def update_snapshot(snap_id, user_id, job_id, job_status, etime):

    """Update a snapshot based on result of a Ganeti job."""

    if job_status in rapi.JOB_STATUS_FINALIZED:

        status = rapi.JOB_STATUS_SUCCESS and "AVAILABLE" or "ERROR"

        log.debug("Updating status of snapshot '%s' to '%s'", snap_id, status)

        volume.util.update_snapshot_status(snap_id, user_id, status=status)

        gnt_nics_parsed = backend_mod.parse_instance_nics(gnt_nics)

                backend_mod.process_op_status(

                    vm=vm, etime=self.event_time, jobid=-0,

                    opcode="OP_INSTANCE_SET_PARAMS", status='success',

                    logmsg="Reconciliation: simulated Ganeti event",

                    nics=gnt_nics)

        gnt_disks_parsed = backend_mod.parse_instance_disks(gnt_disks)

                backend_mod.process_op_status(

                    vm=vm, etime=self.event_time, jobid=-0,

                    opcode="OP_INSTANCE_SET_PARAMS", status='success',

                    logmsg="Reconciliation: simulated Ganeti event",

                    disks=gnt_disks)

    vm_volumes_num = vm.volumes.filter(deleted=False).count()

    if vm_volumes_num == settings.GANETI_MAX_DISKS_PER_INSTANCE:

    if volume.status == "CREATING":

        action_fields = {"disks": [("add", volume, {})]}

    comm = commands.server_command("ATTACH_VOLUME",

                                   action_fields=action_fields)

    return comm(_attach_volume)(vm, volume)

def _attach_volume(vm, volume):

    """Attach a Volume to a VM and update the Volume's status."""

    jobid = backend.attach_volume(vm, volume)

    if volume.status == "AVAILALBE":

        volume.status = "ATTACHING"

    else:

        volume.status = "CREATING"

    """Detach a Volume from a VM

    if volume.status not in ["IN_USE", "ERROR"]:

    action_fields = {"disks": [("remove", volume, {})]}

    comm = commands.server_command("DETACH_VOLUME",

                                   action_fields=action_fields)

    return comm(_detach_volume)(vm, volume)

def _detach_volume(vm, volume):

    """Detach a Volume from a VM and update the Volume's status"""

    if volume.delete_on_termination:

        volume.status = "DELETING"

    else:

        volume.status = "DETACHING"

    """Check that the Volume is attached to the VM"""

def id_to_disk_name(id):

    return "%svol-%s" % (settings.BACKEND_PREFIX_ID, str(id))

        disks = job_fields.get("disks")

        if disks:

            try:

                disk_action = disks[0][0]

                if disk_action == "add":

                    return "ATTACH_VOLUME"

                elif disk_action == "remove":

                    return "DETACH_VOLUME"

                else:

                    return None

            except:

                return None

from django.db.models import Sum

                               IPAddress, Volume)

from synnefo.logic.utils import id_from_disk_name

                     "cyclades.total_ram": flavor.ram << 20}

                            "cyclades.ram": flavor.ram << 20}

            new_volumes = resource.volumes.filter(status="CREATING")

            new_volumes_size = new_volumes.aggregate(Sum("size"))["size__sum"]

            resources["cyclades.disk"] = new_volumes_size << 30

            volumes = resource.volumes.filter(deleted=False)

            volumes_size = volumes.aggregate(Sum("size"))["size__sum"]

            resources["cyclades.disk"] = volumes_size << 30

            resources.update(online_resources)

                    "cyclades.total_ram": (ram - flavor.ram) << 20}

        elif action in ["ATTACH_VOLUME", "DETACH_VOLUME"]:

            if action_fields is not None:

                volumes_changes = action_fields.get("disks")

                if volumes_changes is not None:

                    size_delta = get_volumes_size_delta(volumes_changes)

                    if size_delta:

                        return {"cyclades.disk": size_delta << 30}

    elif isinstance(resource, Volume):

        size = resource.size

        resources = {"cyclades.disk": size << 30}

        if resource.status == "CREATING" and action == "BUILD":

            return resources

        elif action == "DESTROY":

            reverse_quantities(resources)

        else:

            return None

def get_volumes_size_delta(volumes_changes):

    """Compute the total change in the size of volumes"""

    size_delta = 0

    for vchange in volumes_changes:

        action, db_volume, info = vchange

        if action == "add":

            size_delta += int(db_volume.size)

        elif action == "remove":

            size_delta -= int(db_volume.size)

        elif action == "modify":

            size_delta += info.get("size_delta", 0)

        else:

            raise ValueError("Unknwon volume action '%s'" % action)

    return size_delta

from synnefo.db.models import VirtualMachine, Network, IPAddress, Volume

    volumes = Volume.objects.filter(deleted=False)

                                total_cpu=Sum("flavor__cpu"))

               "cyclades.total_ram": vm_res["total_ram"] << 20}

        holdings[user]["cyclades.ram"] = vm_res["ram"] << 20

    # Get disk resource

    disk_resources = volumes.values("userid").annotate(Sum("size"))

    for disk_res in disk_resources.iterator():

        user = disk_res["userid"]

        holdings.setdefault(user, {})

        holdings[user]["cyclades.disk"] = disk_res["size__sum"] << 30