Synnefo

    '''Decorator for functions implementing server actions.

    `name` is the key in the dict passed by the client.

    '''

    def decorator(func):

        server_actions[name] = func

        return func

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       overLimit (413)

    try:

        password = args['adminPass']

    except KeyError:

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       overLimit (413)

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

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

        raise BadRequest('Malformed Request.')

    # Normal Response Code: 202

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404)

    if args:

        raise BadRequest('Malformed Request.')

    startup_instance(vm)

    # Normal Response Code: 202

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404)

    if args:

        raise BadRequest('Malformed Request.')

    shutdown_instance(vm)

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413),

    #                       resizeNotAllowed (403)

    raise ServiceUnavailable('Resize not supported.')

@server_action('confirmResize')

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413),

    #                       resizeNotAllowed (403)

    raise ServiceUnavailable('Resize not supported.')

@server_action('revertResize')

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       overLimit (413)

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

    if console_type != 'vnc':

        raise BadRequest('Type can only be "vnc".')

    # Use RAPI to get VNC console information for this instance

    if get_rsapi_state(vm) != 'ACTIVE':

        raise BadRequest('Server not in ACTIVE state.')

    if settings.TEST:

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

    else:

        console_data = get_instance_console(vm)

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

        raise ServiceUnavailable('Could not create a console of requested type.')

    # Let vncauthproxy decide on the source port.

    # The alternative: static allocation, e.g.

    # sport = console_data['port'] - 1000

    daddr = console_data['host']

    dport = console_data['port']

    password = random_password()

    try:

        if settings.TEST:

            fwd = {'source_port': 1234, 'status': 'OK'}

    if fwd['status'] != "OK":

        raise ServiceUnavailable('Could not allocate VNC console.')

    console = {

        'type': 'vnc',

        'host': getfqdn(),

        'port': fwd['source_port'],

        'password': password}

    if request.serialization == 'xml':

        mimetype = 'application/xml'

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

    else:

        mimetype = 'application/json'

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

    return HttpResponse(data, mimetype=mimetype, status=200)

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       overLimit (413)

    server_id = args.get('serverRef', None)

    if not server_id:

        raise BadRequest('Malformed Request.')

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       overLimit (413)

    server_id = args.get('serverRef', None)

    if not server_id:

        raise BadRequest('Malformed Request.')

        "fields": {

            "cpu": 1,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 1,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 1,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 1,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 1,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 1,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 1,

            "ram": 4096,

        }

    },

    {

        "fields": {

            "cpu": 1,

            "ram": 4096,

        }

    },

    {

        "fields": {

            "cpu": 1,

            "ram": 4096,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 4096,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 4096,

        }

    },

    {

        "fields": {

            "cpu": 2,

            "ram": 4096,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 1024,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 2048,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 4096,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 4096,

        }

    },

    {

        "fields": {

            "cpu": 4,

            "ram": 4096,

        }

    },

    {

            "sourcevm": 1001

        }

    }

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       overLimit (413)

    all_flavors = Flavor.objects.all()

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

    if request.serialization == 'xml':

        data = render_to_string('list_flavors.xml', {'flavors': flavors, 'detail': detail})

    else:

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

    return HttpResponse(data, status=200)

@api_method('GET')

    #                       badRequest (400),

    #                       itemNotFound (404),

    #                       overLimit (413)

    flavor = get_flavor(flavor_id)

    flavordict = flavor_to_dict(flavor, detail=True)

    if request.serialization == 'xml':

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

    else:

        data = json.dumps({'flavor': flavordict})

    return HttpResponse(data, status=200)

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

        if image.sourcevm:

            d['serverRef'] = image.sourcevm.id

        metadata = {}

        for meta in ImageMetadata.objects.filter(image=image):

            metadata[meta.meta_key] = meta.meta_value

        if metadata:

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

    return d

def metadata_to_dict(image):

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       overLimit (413)

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

    if since:

        avail_images = Image.objects.filter(owner=request.user, updated__gte=since)

        if not avail_images:

            return HttpResponse(status=304)

    else:

        avail_images = Image.objects.filter(owner=request.user)

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

    if request.serialization == 'xml':

        data = render_to_string('list_images.xml', {'images': images, 'detail': detail})

    else:

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

    return HttpResponse(data, status=200)

@api_method('POST')

    #                       resizeNotAllowed (403),

    #                       backupOrResizeInProgress (409),

    #                       overLimit (413)

    req = get_request_dict(request)

    try:

        d = req['image']

        server_id = d['serverRef']

        name = d['name']

    except (KeyError, ValueError):

        raise BadRequest('Malformed request.')

    owner = request.user

    vm = get_vm(server_id, owner)

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

    imagedict = image_to_dict(image)

    if request.serialization == 'xml':

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

    else:

        data = json.dumps({'image': imagedict})

    return HttpResponse(data, status=202)

@api_method('GET')

    #                       badRequest (400),

    #                       itemNotFound (404),

    #                       overLimit (413)

    image = get_image(image_id, request.user)

    imagedict = image_to_dict(image)

    if request.serialization == 'xml':

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

    else:

        data = json.dumps({'image': imagedict})

    return HttpResponse(data, status=200)

@api_method('DELETE')

    #                       unauthorized (401),

    #                       itemNotFound (404),

    #                       overLimit (413)

    image = get_image(image_id, request.user)

    image.delete()

    return HttpResponse(status=204)

    #                       itemNotFound (404),

    #                       badRequest (400),

    #                       overLimit (413)

    image = get_image(image_id, request.user)

    meta = get_image_meta(image, key)

    return render_meta(request, meta, status=200)

    #                       buildInProgress (409),

    #                       badMediaType(415),

    #                       overLimit (413),

    image = get_image(image_id, request.user)

    meta = get_image_meta(image, key)

    meta.delete()

        #caching of results

        response['Vary'] = self.auth_token

        return response

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       overLimit (413)

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

    if since:

        user_networks = Network.objects.filter(owner=request.user, updated__gte=since)

        if not user_networks:

            return HttpResponse(status=304)

    else:

        user_networks = Network.objects.filter(owner=request.user)

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

    if request.serialization == 'xml':

        data = render_to_string('list_networks.xml', {'networks': networks, 'detail': detail})

    else:

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

    return HttpResponse(data, status=200)

@api_method('POST')

    #                       badMediaType(415),

    #                       badRequest (400),

    #                       overLimit (413)

    req = get_request_dict(request)

    try:

        d = req['network']

        name = d['name']

    except (KeyError, ValueError):

        raise BadRequest('Malformed request.')

    network = Network.objects.create(name=name, owner=request.user)

    networkdict = network_to_dict(network)

    return render_network(request, networkdict, status=202)

    #                       badRequest (400),

    #                       itemNotFound (404),

    #                       overLimit (413)

    net = get_network(network_id, request.user)

    netdict = network_to_dict(net)

    return render_network(request, netdict)

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       overLimit (413)

    req = get_request_dict(request)

    try:

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       overLimit (413)

    net = get_network(network_id, request.user)

    net.delete()

    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 network_actions[key](request, net, req[key])

        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()

{% spaceless %}

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

<flavors xmlns="http://docs.openstack.org/compute/api/v1.1" xmlns:atom="http://www.w3.org/2005/Atom">

  <flavor id="{{ flavor.id}}" name="{{ flavor.name }}"{% if detail %} ram="{{ flavor.ram }}" cpu="{{ flavor.cpu }}" disk="{{ flavor.disk }}"{% endif %}>

  </flavor>

  {% endfor %}

        {% for key, val in server.metadata.values.items %}<meta key="{{ key }}">{{ val }}</meta>{% endfor %}

    </metadata>

    {% endif %}

    <addresses>

        {% for network in server.addresses.values %}

        <network id="{{ network.id }}">

    <uri>http://ocean.grnet.gr/</uri>

  </author>

  <link rel="self" href="http://ocean.grnet.gr/"/>

  <entry>

    <id>http://servers.api.openstack.org/{{ version.id }}/</id>

    <title type="text">Version {{ version.id }}</title>

    {% for link in version.links %}

      <link rel="{{ link.rel }}" {% if link.type %}type="{{ link.type }}" {% endif %}href="{{ link.href }}"/>

    {% endfor %}

  </entry>

</feed>

{% endspaceless %}

    <uri>http://ocean.grnet.gr/</uri>

  </author>

  <link rel="self" href="http://ocean.grnet.gr/"/>

  {% for version in versions %}

  <entry>

    <id>http://servers.api.openstack.org/{{ version.id }}/</id>

    def test_api_version(self):

        """Check API version."""

        response = self.client.get('/api/v1.1/')

        self.assertEqual(response.status_code, 200)

        api_version = json.loads(response.content)['version']

    def test_server_list(self):

        """Test if the expected list of servers is returned."""

        response = self.client.get('/api/v1.1/servers')

        vms_from_api = json.loads(response.content)['servers']['values']

        vms_from_db = VirtualMachine.objects.filter(deleted=False)

    def test_server_details(self):

        """Test if the expected server is returned."""

        response = self.client.get('/api/v1.1/servers/%d' % self.test_server_id)

        vm_from_api = json.loads(response.content)['server']

        vm_from_db = VirtualMachine.objects.get(id=self.test_server_id)

    def test_servers_details(self):

        """Test if the servers details are returned."""

        response = self.client.get('/api/v1.1/servers/detail')

        # Make sure both DB and API responses are sorted by id,

    def test_wrong_server(self):

        """Test 404 response if server does not exist."""

        response = self.client.get('/api/v1.1/servers/%d' % self.test_wrong_server_id)

        self.assertEqual(response.status_code, 404)

    def test_create_server_empty(self):

        """Test if the create server call returns a 400 badRequest if

           no attributes are specified."""

        response = self.client.post('/api/v1.1/servers', {})

        self.assertEqual(response.status_code, 400)

    def test_create_server(self):

        """Test if the create server call returns the expected response

           if a valid request has been speficied."""

        request = {

                    "server": {

                        "name": "new-server-test",

    def test_server_polling(self):

        """Test if the server polling works as expected."""

        response = self.client.get('/api/v1.1/servers/detail')

        vms_from_api_initial = json.loads(response.content)['servers']['values']

        ts = mktime(parsedate(response['Date']))

                        "personality": []

                    }

        }

        path = '/api/v1.1/servers'

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

        self.assertEqual(response.status_code, 202)

    def test_reboot_server(self):

        """Test if the specified server is rebooted."""

        request = {'reboot': {'type': 'HARD'}}

        path = '/api/v1.1/servers/%d/action' % self.test_server_id

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

    def test_shutdown_server(self):

        """Test if the specified server is shutdown."""

        request = {'shutdown': {}}

        path = '/api/v1.1/servers/%d/action' % self.test_server_id

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

    def test_start_server(self):

        """Test if the specified server is started."""

        request = {'start': {}}

        path = '/api/v1.1/servers/%d/action' % self.test_server_id

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

    def test_flavor_list(self):

        """Test if the expected list of flavors is returned by."""

        response = self.client.get('/api/v1.1/flavors')

        flavors_from_api = json.loads(response.content)['flavors']['values']

        flavors_from_db = Flavor.objects.all()

    def test_flavors_details(self):

        """Test if the flavors details are returned."""

        response = self.client.get('/api/v1.1/flavors/detail')

        flavors_from_db = Flavor.objects.all()

        flavors_from_api = json.loads(response.content)['flavors']['values']

    def test_flavor_details(self):

        """Test if the expected flavor is returned."""

        response = self.client.get('/api/v1.1/flavors/%d' % self.test_flavor_id)

        flavor_from_api = json.loads(response.content)['flavor']

        flavor_from_db = Flavor.objects.get(id=self.test_flavor_id)

    def test_wrong_flavor(self):

        """Test 404 result when requesting a flavor that does not exist."""

        response = self.client.get('/api/v1.1/flavors/%d' % self.test_wrong_flavor_id)

        self.assertTrue(response.status_code in [404, 503])

    def test_image_list(self):

        """Test if the expected list of images is returned by the API."""

        response = self.client.get('/api/v1.1/images')

        images_from_api = json.loads(response.content)['images']['values']

        images_from_db = Image.objects.all()

    def test_wrong_image(self):

        """Test 404 result if a non existent image is requested."""

        response = self.client.get('/api/v1.1/images/%d' % self.test_wrong_image_id)

        self.assertEqual(response.status_code, 404)

    def test_server_metadata(self):

        """Test server's metadata (add, edit)."""

        key = 'name'

        request = {'meta': {key: 'a fancy name'}}

        path = '/api/v1.1/servers/%d/meta/%s' % (self.test_server_id, key)

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

        self.assertEqual(response.status_code, 201)

        self.callable = callable

        self.args = args

        self.kwargs = kwargs

    def __enter__(self):

        self.value = self.callable(*self.args, **self.kwargs)

        return self.value

    def __exit__(self, type, value, tb):

        assert self.value == self.callable(*self.args, **self.kwargs)

    SERVER_METADATA = 0

    IMAGE_METADATA = 0

    NETWORKS = 0

    def setUp(self):

        self.client = AaiClient()

        create_users(self.USERS)

        create_servers(self.SERVERS)

        create_server_metadata(self.SERVER_METADATA)

        create_networks(self.NETWORKS)

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

        self.assertEqual(response.status_code, status_code)

        fault = json.loads(response.content)

        self.assertEqual(fault.keys(), [name])

    def assertBadRequest(self, response):

        self.assertFault(response, 400, 'badRequest')

    def assertItemNotFound(self, response):

        self.assertFault(response, 404, 'itemNotFound')

    def list_images(self, detail=False):

        path = '/api/v1.1/images'

        if detail:

        self.assertEqual(reply.keys(), ['images'])

        self.assertEqual(reply['images'].keys(), ['values'])

        return reply['images']['values']

    def list_metadata(self, path):

        response = self.client.get(path)

        self.assertTrue(response.status_code in (200, 203))

        self.assertEqual(reply.keys(), ['metadata'])

        self.assertEqual(reply['metadata'].keys(), ['values'])

        return reply['metadata']['values']

    def list_server_metadata(self, server_id):

        path = '/api/v1.1/servers/%d/meta' % server_id

        return self.list_metadata(path)

    def list_image_metadata(self, image_id):

        path = '/api/v1.1/images/%d/meta' % image_id

        return self.list_metadata(path)

    def update_metadata(self, path, metadata):

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

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

        reply = json.loads(response.content)

        self.assertEqual(reply.keys(), ['metadata'])

        return reply['metadata']

    def update_server_metadata(self, server_id, metadata):

        path = '/api/v1.1/servers/%d/meta' % server_id

        return self.update_metadata(path, metadata)

    def update_image_metadata(self, image_id, metadata):

        path = '/api/v1.1/images/%d/meta' % image_id

        return self.update_metadata(path, metadata)

    def create_server_meta(self, server_id, meta):

        key = meta.keys()[0]

        path = '/api/v1.1/servers/%d/meta/%s' % (server_id, key)

        self.assertEqual(reply.keys(), ['meta'])

        response_meta = reply['meta']

        self.assertEqual(response_meta, meta)

    def get_all_server_metadata(self):

        metadata = defaultdict(dict)

        for m in VirtualMachineMetadata.objects.all():

            metadata[m.vm.id][m.meta_key] = m.meta_value

        return metadata

    def get_all_image_metadata(self):

        metadata = defaultdict(dict)

        for m in ImageMetadata.objects.all():

            metadata[m.image.id][m.meta_key] = m.meta_value

        return metadata

    def list_networks(self, detail=False):

        path = '/api/v1.1/networks'

        if detail:

        self.assertEqual(reply.keys(), ['networks'])

        self.assertEqual(reply['networks'].keys(), ['values'])

        return reply['networks']['values']

    def create_network(self, name):

        path = '/api/v1.1/networks'

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

        reply = json.loads(response.content)

        self.assertEqual(reply.keys(), ['network'])

        return reply

    def get_network_details(self, network_id):

        path = '/api/v1.1/networks/%d' % network_id

        response = self.client.get(path)

        reply = json.loads(response.content)

        self.assertEqual(reply.keys(), ['network'])

        return reply['network']

    def update_network_name(self, network_id, new_name):

        path = '/api/v1.1/networks/%d' % network_id

        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):

        path = '/api/v1.1/networks/%d' % network_id

        response = self.client.delete(path)

        self.assertEqual(response.status_code, 204)

    def add_to_network(self, network_id, server_id):

        path = '/api/v1.1/networks/%d/action' % network_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):

        path = '/api/v1.1/networks/%d/action' % network_id

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

def popdict(l, **kwargs):

    """Pops a dict from list `l` based on the predicates given as `kwargs`."""

    for i in range(len(l)):

        item = l[i]

        match = True

class ListImages(BaseTestCase):

    IMAGES = 10

    def test_list_images(self):

        images = self.list_images()

        keys = set(['id', 'name'])

            self.assertEqual(image['id'], img.id)

            self.assertEqual(image['name'], img.name)

        self.assertEqual(images, [])

    def test_list_images_detail(self):

        images = self.list_images(detail=True)

        keys = set(['id', 'name', 'updated', 'created', 'status', 'progress'])

class ListServerMetadata(BaseTestCase):

    SERVERS = 5

    SERVER_METADATA = 100

    def test_list_metadata(self):

        with AssertInvariant(self.get_all_server_metadata) as metadata:

            for vm in VirtualMachine.objects.all():

                response_metadata = self.list_server_metadata(vm.id)

                self.assertEqual(response_metadata, metadata[vm.id])

    def test_invalid_server(self):

        with AssertInvariant(self.get_all_server_metadata):

            response = self.client.get('/api/v1.1/servers/0/meta')

class UpdateServerMetadata(BaseTestCase):

    SERVER_METADATA = 10

    def test_update_metadata(self):

        metadata = self.get_all_server_metadata()

        server_id = choice(metadata.keys())

        self.assertEqual(response_metadata, new_metadata)

        metadata[server_id].update(new_metadata)

        self.assertEqual(metadata, self.get_all_server_metadata())

    def test_does_not_create(self):

        with AssertInvariant(self.get_all_server_metadata) as metadata:

            server_id = choice(metadata.keys())

            new_metadata = {'Foo': 'Bar'}

            response_metadata = self.update_server_metadata(server_id, new_metadata)

            self.assertEqual(response_metadata, {})

    def test_invalid_data(self):

        with AssertInvariant(self.get_all_server_metadata) as metadata:

            server_id = choice(metadata.keys())

            path = '/api/v1.1/servers/%d/meta' % server_id

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

            self.assertBadRequest(response)

    def test_invalid_server(self):

        with AssertInvariant(self.get_all_server_metadata):

            path = '/api/v1.1/servers/0/meta'

class GetServerMetadataItem(BaseTestCase):

    SERVERS = 5

    SERVER_METADATA = 100

    def test_get_metadata_item(self):

        with AssertInvariant(self.get_all_server_metadata) as metadata:

            server_id = choice(metadata.keys())

            self.assertTrue(response.status_code in (200, 203))

            reply = json.loads(response.content)

            self.assertEqual(reply['meta'], {key: metadata[server_id][key]})

    def test_invalid_key(self):

        with AssertInvariant(self.get_all_server_metadata) as metadata:

            server_id = choice(metadata.keys())

            response = self.client.get('/api/v1.1/servers/%d/meta/foo' % server_id)

            self.assertItemNotFound(response)

    def test_invalid_server(self):

        with AssertInvariant(self.get_all_server_metadata):

            response = self.client.get('/api/v1.1/servers/0/meta/foo')

class CreateServerMetadataItem(BaseTestCase):

    SERVER_METADATA = 10

    def test_create_metadata(self):

        metadata = self.get_all_server_metadata()

        server_id = choice(metadata.keys())

        self.create_server_meta(server_id, meta)

        metadata[server_id].update(meta)

        self.assertEqual(metadata, self.get_all_server_metadata())

    def test_update_metadata(self):

        metadata = self.get_all_server_metadata()

        server_id = choice(metadata.keys())

        self.create_server_meta(server_id, meta)

        metadata[server_id].update(meta)

        self.assertEqual(metadata, self.get_all_server_metadata())

    def test_invalid_server(self):

        with AssertInvariant(self.get_all_server_metadata):

            path = '/api/v1.1/servers/0/meta/foo'

            data = json.dumps({'meta': {'foo': 'bar'}})

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

            self.assertItemNotFound(response)

    def test_invalid_key(self):

        with AssertInvariant(self.get_all_server_metadata) as metadata:

            server_id = choice(metadata.keys())

            data = json.dumps({'meta': {'foo': 'bar'}})

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

            self.assertBadRequest(response)

    def test_invalid_data(self):

        with AssertInvariant(self.get_all_server_metadata) as metadata:

            server_id = choice(metadata.keys())

class DeleteServerMetadataItem(BaseTestCase):

    SERVER_METADATA = 10

    def test_delete_metadata(self):

        metadata = self.get_all_server_metadata()

        server_id = choice(metadata.keys())

        self.assertEqual(response.status_code, 204)

        metadata[server_id].pop(key)

        self.assertEqual(metadata, self.get_all_server_metadata())

    def test_invalid_server(self):

        with AssertInvariant(self.get_all_server_metadata):

            response = self.client.delete('/api/v1.1/servers/9/meta/Key1')

            self.assertItemNotFound(response)

    def test_invalid_key(self):

        with AssertInvariant(self.get_all_server_metadata) as metadata:

            server_id = choice(metadata.keys())