Synnefo

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)