Synnefo

from django.template.loader import render_to_string

from django.utils import simplejson as json

from synnefo.api.actions import server_actions

from synnefo.api.common import method_not_allowed

from synnefo.api.faults import BadRequest, ItemNotFound, ServiceUnavailable

from synnefo.db.models import VirtualMachine, VirtualMachineMetadata

from synnefo.logic.backend import create_instance, delete_instance

from synnefo.logic.utils import get_rsapi_state

        return method_not_allowed(request)

def metadata_to_dict(vm):

    vm_meta = vm.virtualmachinemetadata_set.all()

        d['status'] = get_rsapi_state(vm)

        d['progress'] = 100 if get_rsapi_state(vm) == 'ACTIVE' else 0

        d['hostId'] = vm.hostid

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

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

        if metadata:

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

    return d

def render_server(request, server, status=200):

    if request.serialization == 'xml':

    else:

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

    return HttpResponse(data, status=status)

def list_servers(request, detail=False):

    # Normal Response Codes: 200, 203

    # Error Response Codes: computeFault (400, 500),

    #                       badRequest (400),

    #                       overLimit (413)

    if since:

        if not user_vms:

            return HttpResponse(status=304)

    else:

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

    if request.serialization == 'xml':

    else:

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

    return HttpResponse(data, status=200)

def create_server(request):

    # Normal Response Code: 202

    # Error Response Codes: computeFault (400, 500),

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413)

    try:

        server = req['server']

        name = server['name']

        flavor_id = server['flavorRef']

    except (KeyError, AssertionError):

        raise BadRequest('Malformed request.')

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

    vm = VirtualMachine.objects.create(

        name=name,

        sourceimage=image,

        flavor=flavor)

    try:

        create_instance(vm, flavor, image, password)

    except GanetiApiError:

        raise ServiceUnavailable('Could not create server.')

    for key, val in metadata.items():

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

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

    server['adminPass'] = password

    return render_server(request, server, status=202)

def get_server_details(request, server_id):

    # Normal Response Codes: 200, 203

    # Error Response Codes: computeFault (400, 500),

    #                       itemNotFound (404),

    #                       overLimit (413)

    server = vm_to_dict(vm, detail=True)

    return render_server(request, server)

def update_server_name(request, server_id):

    # Normal Response Code: 204

    # Error Response Codes: computeFault (400, 500),

    #                       buildInProgress (409),

    #                       overLimit (413)

    try:

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

    except (TypeError, KeyError):

        raise BadRequest('Malformed request.')

    vm.name = name

    vm.save()

    return HttpResponse(status=204)

def delete_server(request, server_id):

    # Normal Response Codes: 204

    # Error Response Codes: computeFault (400, 500),

    #                       buildInProgress (409),

    #                       overLimit (413)

    delete_instance(vm)

    return HttpResponse(status=204)

def server_action(request, server_id):

    if len(req) != 1:

        raise BadRequest('Malformed request.')

    except AssertionError:

        raise BadRequest('Invalid argument.')

def list_addresses(request, server_id):

    # Normal Response Codes: 200, 203

    # Error Response Codes: computeFault (400, 500),

    #                       badRequest (400),

    #                       overLimit (413)

    if request.serialization == 'xml':

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

    else:

    return HttpResponse(data, status=200)

def list_addresses_by_network(request, server_id, network_id):

    # Normal Response Codes: 200, 203

    # Error Response Codes: computeFault (400, 500),

    #                       badRequest (400),

    #                       itemNotFound (404),

    #                       overLimit (413)

    if request.serialization == 'xml':

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

    else:

    return HttpResponse(data, status=200)

def list_metadata(request, server_id):

    # Normal Response Codes: 200, 203

    # Error Response Codes: computeFault (400, 500),

    #                       badRequest (400),

    #                       overLimit (413)

    metadata = metadata_to_dict(vm)

def update_metadata(request, server_id):

    # Normal Response Code: 201

    # Error Response Codes: computeFault (400, 500),

    #                       badMediaType(415),

    #                       overLimit (413)

    try:

        metadata = req['metadata']

        assert isinstance(metadata, dict)

            updated[key] = val

        except VirtualMachineMetadata.DoesNotExist:

            pass    # Ignore non-existent metadata

def get_metadata_item(request, server_id, key):

    # Normal Response Codes: 200, 203

    # Error Response Codes: computeFault (400, 500),

    #                       badRequest (400),

    #                       overLimit (413)

def create_metadata_item(request, server_id, key):

    # Normal Response Code: 201

    # Error Response Codes: computeFault (400, 500),

    #                       badMediaType(415),

    #                       overLimit (413)

    try:

        metadict = req['meta']

        assert isinstance(metadict, dict)

        assert key in metadict

    except (KeyError, AssertionError):

        raise BadRequest('Malformed request.')

    meta.meta_value = metadict[key]

    meta.save()

def delete_metadata_item(request, server_id, key):

    # Normal Response Code: 204

    # Error Response Codes: computeFault (400, 500),

    #                       badMediaType(415),

    #                       overLimit (413),

    meta.delete()

    return HttpResponse(status=204)