Synnefo

from synnefo.api.faults import BadRequest, ServiceUnavailable

from synnefo.api.util import random_password, get_vm

from synnefo.util.vapclient import request_forwarding as request_vnc_forwarding

from synnefo.logic.utils import get_rsapi_state

    reboot_type = args.get('type', '')

    if reboot_type not in ('SOFT', 'HARD'):

        raise BadRequest('Malformed Request.')

    return HttpResponse(status=202)

@server_action('start')

    if args:

        raise BadRequest('Malformed Request.')

    return HttpResponse(status=202)

@server_action('shutdown')

    if args:

        raise BadRequest('Malformed Request.')

    return HttpResponse(status=202)

@server_action('rebuild')

    if settings.TEST:

        console_data = {'kind': 'vnc', 'host': 'ganeti_node', 'port': 1000}

    else:

    if console_data['kind'] != 'vnc':

    # Let vncauthproxy decide on the source port.

    # The alternative: static allocation, e.g.

    if not server_id:

        raise BadRequest('Malformed Request.')

    vm = get_vm(server_id, request.user)

    net.save()

    return HttpResponse(status=202)

    if not server_id:

        raise BadRequest('Malformed Request.')

    vm = get_vm(server_id, request.user)

    net.save()

    return HttpResponse(status=202)

class BuildInProgress(Fault):

    code = 409

class ServiceUnavailable(Fault):

    code = 503

            "charged": "2011-02-06 00:00:00",

            "sourceimage": 1,

            "hostid": "HAL-9000",

            "flavor": 1,

            "operstate": "STOPPED"

        }

            "charged": "2011-02-10 00:00:00",

            "sourceimage": 1,

            "hostid": "HAL-9000",

            "flavor": 1,

            "operstate": "BUILD"

        }

            "charged": "2011-02-10 00:00:00",

            "sourceimage": 1,

            "hostid": "HAL-9000",

            "flavor": 1,

            "operstate": "STARTED"

        }

            "charged": "2011-02-10 00:00:00",

            "sourceimage": 1,

            "hostid": "HAL-9000",

            "flavor": 1,

            "operstate": "STARTED"

        }

from django.template.loader import render_to_string

from django.utils import simplejson as json

from synnefo.db.models import Flavor

    return d

def list_flavors(request, detail=False):

    # Normal Response Codes: 200, 203

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

    flavors = [flavor_to_dict(flavor, detail) for flavor in all_flavors]

    if request.serialization == 'xml':

    else:

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

    return HttpResponse(data, status=200)

def get_flavor_details(request, flavor_id):

    # Normal Response Codes: 200, 203

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

    #                       itemNotFound (404),

    #                       overLimit (413)

    flavordict = flavor_to_dict(flavor, detail=True)

    if request.serialization == 'xml':

# Copyright (c) 2010 Greek Research and Technology Network

#

from django.conf.urls.defaults import patterns

from django.http import HttpResponse

from django.template.loader import render_to_string

from django.utils import simplejson as json

urlpatterns = patterns('synnefo.api.images',

    (r'^(?:/|.json|.xml)?$', 'demux'),

def image_to_dict(image, detail=True):

    d = {'id': image.id, 'name': image.name}

    if detail:

        d['status'] = image.state

        d['progress'] = 100 if image.state == 'ACTIVE' else 0

        if image.sourcevm:

    return dict((meta.meta_key, meta.meta_value) for meta in image_meta)

def list_images(request, detail=False):

    # Normal Response Codes: 200, 203

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

    #                       badRequest (400),

    #                       overLimit (413)

    if since:

        if not avail_images:

            return HttpResponse(status=304)

    else:

    images = [image_to_dict(image, detail) for image in avail_images]

    if request.serialization == 'xml':

    else:

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

    return HttpResponse(data, status=200)

def create_image(request):

    # Normal Response Code: 202

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

    #                       backupOrResizeInProgress (409),

    #                       overLimit (413)

    try:

        d = req['image']

        raise BadRequest('Malformed request.')

    owner = request.user

    image = Image.objects.create(name=name, owner=owner, sourcevm=vm)

    imagedict = image_to_dict(image)

    return HttpResponse(data, status=202)

def get_image_details(request, image_id):

    # Normal Response Codes: 200, 203

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

    #                       itemNotFound (404),

    #                       overLimit (413)

    imagedict = image_to_dict(image)

    if request.serialization == 'xml':

    return HttpResponse(data, status=200)

def delete_image(request, image_id):

    # Normal Response Code: 204

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

    #                       itemNotFound (404),

    #                       overLimit (413)

    image.delete()

    return HttpResponse(status=204)

def list_metadata(request, image_id):

    # Normal Response Codes: 200, 203

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

    #                       badRequest (400),

    #                       overLimit (413)

    metadata = metadata_to_dict(image)

def update_metadata(request, image_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 ImageMetadata.DoesNotExist:

            pass    # Ignore non-existent metadata

def get_metadata_item(request, image_id, key):

    # Normal Response Codes: 200, 203

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

    #                       badRequest (400),

    #                       overLimit (413)

def create_metadata_item(request, image_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, image_id, key):

    # Normal Response Code: 204

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

    #                       badMediaType(415),

    #                       overLimit (413),

    meta.delete()

    return HttpResponse(status=204)

from django.conf.urls.defaults import patterns

from django.http import HttpResponse

from django.utils import simplejson as json

urlpatterns = patterns('synnefo.api.networks',

    (r'^(?:/|.json|.xml)?$', 'demux'),

def network_to_dict(network, detail=True):

    if detail:

        d['servers'] = {'values': [vm.id for vm in network.machines.all()]}

    return d

def render_network(request, networkdict, status=200):

    return HttpResponse(data, status=status)

def list_networks(request, detail=False):

    # Normal Response Codes: 200, 203

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

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       overLimit (413)

    if since:

        if not user_networks:

            return HttpResponse(status=304)

    else:

    networks = [network_to_dict(network, detail) for network in user_networks]

    if request.serialization == 'xml':

    else:

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

    return HttpResponse(data, status=200)

def create_network(request):

    # Normal Response Code: 202

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

    #                       badRequest (400),

    #                       overLimit (413)

    try:

        d = req['network']

        name = d['name']

    except (KeyError, ValueError):

        raise BadRequest('Malformed request.')

    networkdict = network_to_dict(network)

    return render_network(request, networkdict, status=202)

def get_network_details(request, network_id):

    # Normal Response Codes: 200, 203

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

    #                       itemNotFound (404),

    #                       overLimit (413)

    netdict = network_to_dict(net)

    return render_network(request, netdict)

def update_network_name(request, network_id):

    # Normal Response Code: 204

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

    #                       itemNotFound (404),

    #                       overLimit (413)

    try:

        name = req['network']['name']

    except (TypeError, KeyError):

        raise BadRequest('Malformed request.')

    net.name = name

    net.save()

    return HttpResponse(status=204)

def delete_network(request, network_id):

    # Normal Response Code: 204

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

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       overLimit (413)

    return HttpResponse(status=204)

def network_action(request, network_id):

    if len(req) != 1:

        raise BadRequest('Malformed request.')

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)

{% spaceless %}

<?xml version="1.0" encoding="UTF-8"?>

<image xmlns="http://docs.openstack.org/compute/api/v1.1" xmlns:atom="http://www.w3.org/2005/Atom" id="{{ image.id }}" name="{{ image.name }}" serverRef="{{ image.serverRef }}" updated="{{ image.updated }}" created="{{ image.created }}" status="{{ image.status }}" progress="{{ image.progress }}">

{% if image.metadata %}

<metadata>

  {% for key, val in image.metadata.values.items %}

  {% endfor %}

</metadata>

{% endif %}

{% endspaceless %}

            owner=choice(users),

            sourceimage=choice(images),

            hostid=str(i),

            flavor=choice(flavors))

def create_server_metadata(n=1):

            meta_value='Value %d' % (i + 1),

            vm = choice(servers))

class AssertInvariant(object):

    def __init__(self, callable, *args, **kwargs):

    SERVERS = 1

    SERVER_METADATA = 0

    IMAGE_METADATA = 0

    def setUp(self):

        self.client = AaiClient()

        create_image_metadata(self.IMAGE_METADATA)

        create_servers(self.SERVERS)

        create_server_metadata(self.SERVER_METADATA)

    def assertFault(self, response, status_code, name):

        self.assertEqual(response.status_code, status_code)

        return reply

    def get_network_details(self, network_id):

        response = self.client.get(path)

        self.assertEqual(response.status_code, 200)

        reply = json.loads(response.content)

        return reply['network']

    def update_network_name(self, network_id, new_name):

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

        response = self.client.put(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 204)

    def delete_network(self, network_id):

        response = self.client.delete(path)

        self.assertEqual(response.status_code, 204)

    def add_to_network(self, network_id, server_id):

        data = json.dumps({'add': {'serverRef': server_id}})

        response = self.client.post(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 202)

    def remove_from_network(self, network_id, server_id):

        data = json.dumps({'remove': {'serverRef': server_id}})

        response = self.client.post(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 202)

class ListNetworks(BaseTestCase):

    SERVERS = 5

    def setUp(self):

        BaseTestCase.setUp(self)

        machines = VirtualMachine.objects.all()

        for network in Network.objects.all():

            n = randint(0, self.SERVERS)

    def test_list_networks(self):

        networks = self.list_networks()

        for net in Network.objects.all():

            self.assertEqual(network['name'], net.name)

        self.assertEqual(networks, [])

    def test_list_networks_detail(self):

        networks = self.list_networks(detail=True)

        for net in Network.objects.all():

            self.assertEqual(network['name'], net.name)

            machines = set(vm.id for vm in net.machines.all())

            self.assertEqual(set(network['servers']['values']), machines)

class CreateNetwork(BaseTestCase):

    def test_create_network(self):

        self.create_network('net')

class GetNetworkDetails(BaseTestCase):

    SERVERS = 5

    def test_get_network_details(self):

        servers = VirtualMachine.objects.all()

        net = self.get_network_details(network.id)

        self.assertEqual(net['servers']['values'], [])

        server_id = choice(servers).id

        self.add_to_network(network.id, server_id)

        net = self.get_network_details(network.id)

        self.assertEqual(net['name'], network.name)

class UpdateNetworkName(BaseTestCase):

    def test_update_network_name(self):

        networks = self.list_networks(detail=True)

        network_id = network['id']

        new_name = network['name'] + '_2'

        self.update_network_name(network_id, new_name)

        network['name'] = new_name

class DeleteNetwork(BaseTestCase):

    def test_delete_network(self):

        networks = self.list_networks()

        network_id = network['id']

        self.delete_network(network_id)

class NetworkActions(BaseTestCase):

    SERVERS = 20

    def test_add_remove_server(self):

        server_ids = [vm.id for vm in VirtualMachine.objects.all()]

        network_id = network['id']

        to_add = set(sample(server_ids, 10))

        for server_id in to_add:

            self.add_to_network(network_id, server_id)

        to_remove = set(sample(to_add, 5))

        for server_id in to_remove:

            self.remove_from_network(network_id, server_id)

from django.template.loader import render_to_string

from django.utils import simplejson as json

from synnefo.db.models import (SynnefoUser, Flavor, Image, ImageMetadata,

class UTC(tzinfo):

    """Return a Network instance or raise ItemNotFound."""

    try:

    except ValueError:

        raise BadRequest('Invalid network ID.')

    except Network.DoesNotExist:

        raise ItemNotFound('Network not found.')

def get_request_dict(request):

    """Returns data sent by the client as a python dict."""

    if request.serialization == 'xml':

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

    else:

        data = json.dumps(d)

    return HttpResponse(data, status=status)

    if request.serialization == 'xml':

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

    else:

        data = json.dumps(d)

    resp = HttpResponse(data, status=fault.code)

        @wraps(func)

        def wrapper(request, *args, **kwargs):

            try:

                if not request.user:

                    raise Unauthorized('No user found.')

                if http_method and request.method != http_method: