Synnefo

        d['created'] = isoformat(vm.created)

        d['flavorRef'] = vm.flavor.id

        d['imageRef'] = vm.sourceimage.id

        metadata = metadata_to_dict(vm)

        if metadata:

            d['metadata'] = {'values': metadata}

        addresses = [address_to_dict(vm.ipfour, vm.ipsix)]

        addresses.extend({'id': str(network.id), 'values': []} for network in vm.network_set.all())

        d['addresses'] = {'values': addresses}

    else:

        data = json.dumps({'server': server})

    return HttpResponse(data, status=status)

@api_method('GET')

def list_servers(request, detail=False):

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       overLimit (413)

    since = isoparse(request.GET.get('changes-since'))

    if since:

        user_vms = VirtualMachine.objects.filter(owner=request.user, updated__gte=since)

        if not user_vms:

    else:

        user_vms = VirtualMachine.objects.filter(owner=request.user, deleted=False)

    servers = [vm_to_dict(server, detail) for server in user_vms]

    if request.serialization == 'xml':

        data = render_to_string('list_servers.xml', {'servers': servers, 'detail': detail})

    else:

        data = json.dumps({'servers': {'values': servers}})

    return HttpResponse(data, status=200)

@api_method('POST')

    #                       badRequest (400),

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413)

    req = get_request_dict(request)

    try:

        server = req['server']

        name = server['name']

        flavor_id = server['flavorRef']

    except (KeyError, AssertionError):

        raise BadRequest('Malformed request.')

    image = get_image(image_id, request.user)

    flavor = get_flavor(flavor_id)

    # We must save the VM instance now, so that it gets a valid vm.backend_id.

    vm = VirtualMachine.objects.create(

        name=name,

        ipfour='0.0.0.0',

        ipsix='::1',

        flavor=flavor)

    password = random_password()

    try:

        create_instance(vm, flavor, password)

    except GanetiApiError:

        vm.delete()

        raise ServiceUnavailable('Could not create server.')

    for key, val in metadata.items():

        VirtualMachineMetadata.objects.create(meta_key=key, meta_value=val, vm=vm)

    logging.info('created vm with %s cpus, %s ram and %s storage',

                    flavor.cpu, flavor.ram, flavor.disk)

    server = vm_to_dict(vm, detail=True)

    server['status'] = 'BUILD'

    server['adminPass'] = password

    #                       badRequest (400),

    #                       itemNotFound (404),

    #                       overLimit (413)

    vm = get_vm(server_id, request.user)

    server = vm_to_dict(vm, detail=True)

    return render_server(request, server)

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       overLimit (413)

    req = get_request_dict(request)

    try:

        name = req['server']['name']

    except (TypeError, KeyError):

        raise BadRequest('Malformed request.')

    vm = get_vm(server_id, request.user)

    vm.name = name

    vm.save()

    return HttpResponse(status=204)

@api_method('DELETE')

    #                       unauthorized (401),

    #                       buildInProgress (409),

    #                       overLimit (413)

    vm = get_vm(server_id, request.user)

    delete_instance(vm)

    return HttpResponse(status=204)

    req = get_request_dict(request)

    if len(req) != 1:

        raise BadRequest('Malformed request.')

    key = req.keys()[0]

    val = req[key]

    try:

        assert isinstance(val, dict)

        return server_actions[key](request, vm, req[key])

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       overLimit (413)

    vm = get_vm(server_id, request.user)

    addresses = [address_to_dict(vm.ipfour, vm.ipsix)]

    if request.serialization == 'xml':

        data = render_to_string('list_addresses.xml', {'addresses': addresses})

    else:

        data = json.dumps({'addresses': {'values': addresses}})

    return HttpResponse(data, status=200)

@api_method('GET')

    #                       badRequest (400),

    #                       itemNotFound (404),

    #                       overLimit (413)

    vm = get_vm(server_id, request.user)

    if network_id != 'public':

        raise ItemNotFound('Unknown network.')

    address = address_to_dict(vm.ipfour, vm.ipsix)

    if request.serialization == 'xml':

        data = render_to_string('address.xml', {'address': address})

    else:

        data = json.dumps({'network': address})

    return HttpResponse(data, status=200)

@api_method('GET')

        assert isinstance(metadata, dict)

    except (KeyError, AssertionError):

        raise BadRequest('Malformed request.')

    updated = {}

    for key, val in metadata.items():

        try:

            meta = VirtualMachineMetadata.objects.get(meta_key=key, vm=vm)

            updated[key] = val

        except VirtualMachineMetadata.DoesNotExist:

            pass    # Ignore non-existent metadata

    return render_metadata(request, updated, status=201)

@api_method('GET')

    #                       itemNotFound (404),

    #                       badRequest (400),

    #                       overLimit (413)

    vm = get_vm(server_id, request.user)

    meta = get_vm_meta(vm, key)

    return render_meta(request, meta, status=200)

        assert key in metadict

    except (KeyError, AssertionError):

        raise BadRequest('Malformed request.')

    meta, created = VirtualMachineMetadata.objects.get_or_create(meta_key=key, vm=vm)

    meta.meta_value = metadict[key]

    meta.save()

    #                       buildInProgress (409),

    #                       badMediaType(415),

    #                       overLimit (413),

    vm = get_vm(server_id, request.user)

    meta = get_vm_meta(vm, key)

    meta.delete()