Synnefo

from synnefo import quotas

from synnefo.api.util import release_resource

from synnefo.util.mac2eui64 import mac2eui64

from logging import getLogger

log = getLogger(__name__)

    rejected, since they reflect a previous state of the VM.

    """

        return vm

    # Check successful completion of a job will trigger any quotable change in

        # if fails, must be accepted, as the user must manually remove the

        # failed server

        serial = vm.serial

            quotas.accept_serial(serial)

            log.debug("Job %s failed. Rejecting related serial %s", job_id,

                      serial)

            quotas.reject_serial(serial)

        vm.serial = None

        log.debug("Expected job was %s. Processing job %s. Commission for"

                  " this job: %s", vm.task_job_id, job_id, commission_info)

        # Commission for this change has not been issued, or the issued

    vm.backendopcode = opcode

    vm.backendlogmsg = logmsg

        vm.save()

        return

    state_for_success = VirtualMachine.OPER_STATE_FROM_OPCODE.get(opcode)

    # Notifications of success change the operating state

        if state_for_success is not None:

            vm.operstate = state_for_success

        beparams = job_fields.get("beparams", None)

        # in reversed order.

        vm.backendtime = etime

        # Update the NICs of the VM

        _process_net_status(vm, etime, nics)

    # Special case: if OP_INSTANCE_CREATE fails --> ERROR

        vm.operstate = 'ERROR'

        vm.backendtime = etime

        # Update state of associated NICs

        # Special case: OP_INSTANCE_REMOVE fails for machines in ERROR,

        # when no instance exists at the Ganeti backend.

        # See ticket #799 for all the details.

            # VM has been deleted

            for nic in vm.nics.all():

                # Release the IP

            vm.deleted = True

            vm.operstate = state_for_success

            vm.backendtime = etime

        # Job is finalized: Handle quotas/commissioning

        vm = handle_vm_quotas(vm, job_id=jobid, job_opcode=opcode,

                              job_status=status, job_fields=job_fields)

    # Notifications of success change the operating state

    state_for_success = BackendNetwork.OPER_STATE_FROM_OPCODE.get(opcode, None)

        back_network.operstate = state_for_success

        back_network.operstate = 'ERROR'

        back_network.backendtime = etime

    if opcode == 'OP_NETWORK_REMOVE':

                                  network_exists_in_backend(back_network)):

            back_network.operstate = state_for_success

            back_network.deleted = True

            back_network.backendtime = etime

        back_network.backendtime = etime

    back_network.save()

    # Also you must update the state of the Network!!

        for ip in add_reserved_ips:

            network.reserve_address(ip, external=True)

        back_network.backendtime = etime

    back_network.save()

                   "network": nic.network.backend_id,

                   "ip": nic.ipv4_address}

                  for nic in nics]

    backend = vm.backend

    depend_jobs = []

    for nic in nics:

    # Defined in settings.GANETI_CREATEINSTANCE_KWARGS

    # kw['os'] = settings.GANETI_OS_PROVIDER

    try:

        get_instance_info(vm)

        return True

        if e.code == 404:

            return False

        raise e

    try:

        get_network_info(backend_network)

        return True

        if e.code == 404:

            return False

def create_network(network, backend, connect=True):

    """Create a network in a Ganeti backend"""

    log.debug("Creating network %s in backend %s", network, backend)

    else:

        conflicts_check = False

    with pooled_rapi_client(backend) as client:

        groups = [group] if group is not None else client.GetGroups()

        job_ids = []

def _delete_network(network, backend, depends=[]):

    with pooled_rapi_client(backend) as client:

        return client.DeleteNetwork(network.backend_id, depends)

def connect_to_network(vm, nic):

    network = nic.network

    backend = vm.backend

    nic = {'name': nic.backend_uuid,

           'network': network.backend_id,

def create_network_synced(network, backend):

    result = _create_network_synced(network, backend)

        return result

    result = connect_network_synced(network, backend)

    return result

            job = client.ConnectNetwork(network.backend_id, group,

                                        network.mode, network.link)

            result = wait_for_job(client, job)

                return result

    return result

def wait_for_job(client, jobid):

    result = client.WaitForJobChange(jobid, ['status', 'opresult'], None, None)

    status = result['job_info'][0]

        result = client.WaitForJobChange(jobid, ['status', 'opresult'],

                                         [result], None)

        status = result['job_info'][0]

        return (status, None)

    else:

        error = result['job_info'][1]

        return (status, error)