Synnefo

from django.template.loader import render_to_string

from django.utils import simplejson as json

from synnefo.api import util

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

    return HttpResponse(data, status=200)

def get_flavor_details(request, flavor_id):

    # Normal Response Codes: 200, 203

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

from logging import getLogger

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

from synnefo.api import util

urlpatterns = patterns(

    'synnefo.api.images',

    elif request.method == 'POST':

        return create_image(request)

    else:

def image_demux(request, image_id):

    elif request.method == 'DELETE':

        return delete_image(request, image_id)

    else:

def metadata_demux(request, image_id):

    elif request.method == 'POST':

        return update_metadata(request, image_id)

    else:

def metadata_item_demux(request, image_id, key):

    elif request.method == 'DELETE':

        return delete_metadata_item(request, image_id, key)

    else:

def image_to_dict(image, detail=True):

    d = dict(id=image['id'], name=image['name'])

    if detail:

        d['status'] = 'DELETED' if image['deleted_at'] else 'ACTIVE'

        d['progress'] = 100 if image['status'] == 'available' else 0

        if image['properties']:

    return d

def list_images(request, detail=False):

    # Normal Response Codes: 200, 203

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

    log.debug('list_images detail=%s', detail)

    with image_backend(request.user_uniq) as backend:

        if since:

            images = []

            for image in backend.iter():

                if updated >= since:

                    images.append(image)

            if not images:

    return HttpResponse(data, status=200)

def create_image(request):

    # Normal Response Code: 202

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

    raise faults.NotImplemented('Not supported.')

def get_image_details(request, image_id):

    # Normal Response Codes: 200, 203

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

    return HttpResponse(data, status=200)

def delete_image(request, image_id):

    # Normal Response Code: 204

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

    return HttpResponse(status=204)

def list_metadata(request, image_id):

    # Normal Response Codes: 200, 203

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

    return util.render_metadata(request, metadata, use_values=True, status=200)

def update_metadata(request, image_id):

    # Normal Response Code: 201

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

    #                       badMediaType(415),

    #                       overLimit (413)

    log.info('update_image_metadata %s %s', image_id, req)

    image = util.get_image(image_id, request.user_uniq)

    try:

    return util.render_metadata(request, properties, status=201)

def get_metadata_item(request, image_id, key):

    # Normal Response Codes: 200, 203

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

    return util.render_meta(request, {key: val}, status=200)

def create_metadata_item(request, image_id, key):

    # Normal Response Code: 201

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

    #                       badMediaType(415),

    #                       overLimit (413)

    log.info('create_image_metadata_item %s %s %s', image_id, key, req)

    try:

        metadict = req['meta']

    return util.render_meta(request, {key: val}, status=201)

def delete_metadata_item(request, image_id, key):

    # Normal Response Code: 204

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

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.conf import settings

from django.db import transaction

from django.http import HttpResponse

from django.template.loader import render_to_string

from django.utils import simplejson as json

from synnefo.api import util

from synnefo.api.actions import network_actions

from synnefo import quotas

from synnefo.db.models import Network

from synnefo.db.pools import EmptyPool

from synnefo.logic import backend

urlpatterns = patterns(

    'synnefo.api.networks',

    elif request.method == 'POST':

        return create_network(request)

    else:

def network_demux(request, network_id):

    elif request.method == 'DELETE':

        return delete_network(request, network_id)

    else:

def network_to_dict(network, user_id, detail=True):

        d['gateway6'] = network.gateway6

        d['dhcp'] = network.dhcp

        d['type'] = network.flavor

        d['status'] = network.state

        d['public'] = network.public

    return HttpResponse(data, status=status)

def list_networks(request, detail=False):

    # Normal Response Codes: 200, 203

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

    #                       overLimit (413)

    log.debug('list_networks detail=%s', detail)

    user_networks = Network.objects.filter(Q(userid=request.user_uniq) |

                                           Q(public=True))

    return HttpResponse(data, status=200)

@quotas.uses_commission

@transaction.commit_manually

def create_network(serials, request):

    #                       overLimit (413)

    try:

        log.info('create_network %s', req)

        user_id = request.user_uniq

    return response

def get_network_details(request, network_id):

    # Normal Response Codes: 200, 203

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

    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)

    log.info('update_network_name %s', network_id)

    try:

    return HttpResponse(status=204)

@transaction.commit_on_success

def delete_network(request, network_id):

    # Normal Response Code: 204

    return HttpResponse(status=204)

def network_action(request, network_id):

    log.debug('network_action %s %s', network_id, req)

    if len(req) != 1:

        raise faults.BadRequest('Malformed request.')

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django import dispatch

from django.conf import settings

from django.conf.urls.defaults import patterns

from django.template.loader import render_to_string

from django.utils import simplejson as json

from synnefo.api import util

from synnefo.api.actions import server_actions

from synnefo.db.models import (VirtualMachine, VirtualMachineMetadata,

                               NetworkInterface)

from synnefo.logic.backend import create_instance, delete_instance

server_created = dispatch.Signal(providing_args=["created_vm_params"])

from logging import getLogger

urlpatterns = patterns(

    'synnefo.api.servers',

    elif request.method == 'POST':

        return create_server(request)

    else:

def server_demux(request, server_id):

    elif request.method == 'DELETE':

        return delete_server(request, server_id)

    else:

def metadata_demux(request, server_id):

    elif request.method == 'POST':

        return update_metadata(request, server_id)

    else:

def metadata_item_demux(request, server_id, key):

    elif request.method == 'DELETE':

        return delete_metadata_item(request, server_id, key)

    else:

def nic_to_dict(nic):

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

            else vm.buildpercentage

        d['hostId'] = vm.hostid

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

        d['imageRef'] = vm.imageid

        d['suspended'] = vm.suspended

        # format source date if set

        formatted_source_date = None

        if diagnostic.source_date:

        entry = {

            'source': diagnostic.source,

            'message': diagnostic.message,

            'details': diagnostic.details,

            'level': diagnostic.level,

    return HttpResponse(json.dumps(diagnostics_dict), status=status)

def get_server_diagnostics(request, server_id):

    """

    Virtual machine diagnostics api view.

    return render_diagnostics(request, diagnostics)

def list_servers(request, detail=False):

    # Normal Response Codes: 200, 203

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

    log.debug('list_servers detail=%s', detail)

    user_vms = VirtualMachine.objects.filter(userid=request.user_uniq)

    if since:

        user_vms = user_vms.filter(updated__gte=since)

    return HttpResponse(data, status=200)

# Use manual transactions. Backend and IP pool allocations need exclusive

# access (SELECT..FOR UPDATE). Running create_server with commit_on_success

# would result in backends and public networks to be locked until the job is

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413)

    try:

        log.info('create_server %s', req)

        user_id = request.user_uniq

    return respsone

def get_server_details(request, server_id):

    # Normal Response Codes: 200, 203

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

    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)

    log.info('update_server_name %s %s', server_id, req)

    try:

    return HttpResponse(status=204)

@transaction.commit_on_success

def delete_server(request, server_id):

    # Normal Response Codes: 204

ARBITRARY_ACTIONS = ['console', 'firewallProfile']

def server_action(request, server_id):

    log.debug('server_action %s %s', server_id, req)

    if len(req) != 1:

    vm.save()

def list_addresses(request, server_id):

    # Normal Response Codes: 200, 203

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

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

    return HttpResponse(data, status=200)

def list_metadata(request, server_id):

    # Normal Response Codes: 200, 203

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

    return util.render_metadata(request, metadata, use_values=True, status=200)

def update_metadata(request, server_id):

    # Normal Response Code: 201

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

    #                       badMediaType(415),

    #                       overLimit (413)

    log.info('update_server_metadata %s %s', server_id, req)

    vm = util.get_vm(server_id, request.user_uniq, non_suspended=True)

    try:

    return util.render_metadata(request, vm_meta, status=201)

def get_metadata_item(request, server_id, key):

    # Normal Response Codes: 200, 203

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

    return util.render_meta(request, d, status=200)

@transaction.commit_on_success

def create_metadata_item(request, server_id, key):

    # Normal Response Code: 201

    #                       badMediaType(415),

    #                       overLimit (413)

    log.info('create_server_metadata_item %s %s %s', server_id, key, req)

    vm = util.get_vm(server_id, request.user_uniq, non_suspended=True)

    try:

    return util.render_meta(request, d, status=201)

@transaction.commit_on_success

def delete_metadata_item(request, server_id, key):

    # Normal Response Code: 204

    return HttpResponse(status=204)

def server_stats(request, server_id):

    # Normal Response Codes: 200

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

    def wrapper(self, backend):

        result = func(self, backend)

        if backend.called is True:

        return result

    return wrapper

class ImageAPITest(BaseAPITest):

    @assert_backend_closed

    def test_create_image(self, mimage):

        mimage.return_value._delete.assert_not_called('42')

class ImageMetadataAPITest(BaseAPITest):

    def setUp(self):

        self.image = {'id': 42,

        response = self.get('/api/v1.1/images/42/meta/not_found', 'user')

        self.assertItemNotFound(response)

    def test_delete_metadata_item(self, backend):

        backend.return_value.get_image.return_value = self.image

    @assert_backend_closed

    def test_create_metadata_item(self, backend):

        backend.return_value.get_image.return_value = self.image

    @assert_backend_closed

    def test_create_metadata_malformed_1(self, backend):

        backend.return_value.get_image.return_value = self.image

    @assert_backend_closed

    def test_create_metadata_malformed_2(self, backend):

        backend.return_value.get_image.return_value = self.image

    @assert_backend_closed

    def test_create_metadata_malformed_3(self, backend):

        backend.return_value.get_image.return_value = self.image

    @assert_backend_closed

    def test_create_metadata_malformed_4(self, backend):

        backend.return_value.get_image.return_value = self.image

    @assert_backend_closed

    def test_update_metadata_item(self, backend):

        backend.return_value.get_image.return_value = self.image

    @assert_backend_closed

    def test_update_metadata_malformed(self, backend):

        backend.return_value.get_image.return_value = self.image

        .... make api calls ....

    """

class BaseAPITest(TestCase):

from django.conf.urls.defaults import include, patterns

from synnefo.api import servers, flavors, images, networks

from synnefo.api.versions import versions_list, version_details

from synnefo.db.pools import EmptyPool

from synnefo.lib.astakos import get_user

from synnefo.settings import MAX_CIDR_BLOCK

def get_image(image_id, user_id):

    """Return an Image instance or raise ItemNotFound."""

        image = backend.get_image(image_id)

        if not image:

            raise faults.ItemNotFound('Image not found.')

        return image

def get_image_dict(image_id, user_id):

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from logging import getLogger

from django.conf import settings

from django.template.loader import render_to_string

from django.utils import simplejson as json

log = getLogger('synnefo.api')

VERSIONS = [VERSION_1_1]

MEDIA_TYPES = [

]

DESCRIBED_BY = [

]

def versions_list(request):

    # Normal Response Codes: 200, 203

    # Error Response Codes: 400, 413, 500, 503

    if request.serialization == 'xml':

        data = render_to_string('versions_list.xml', {'versions': VERSIONS})

    else:

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

    return HttpResponse(data)

def version_details(request, api_version):

    # Normal Response Codes: 200, 203

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

    if request.serialization == 'xml':

        version['media_types'] = MEDIA_TYPES

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

    else:

        version['media-types'] = MEDIA_TYPES

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