Synnefo

#

# Copyright (c) 2010 Greek Research and Technology Network

#

def camelCase(s):

    return s[0].lower() + s[1:]

class Fault(BaseException):

    def __init__(self, message='', details='', name=''):

        BaseException.__init__(self, message, details, name)

        self.message = message

        self.details = details

        self.name = name or camelCase(self.__class__.__name__)

class BadRequest(Fault):

    code = 400

class Unauthorized(Fault):

    code = 401

class ItemNotFound(Fault):

    code = 404

[

    {

        "model": "db.Image",

        "pk": 1,

        "fields": {

            "name": "Debian Unstable",

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

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

            "state": "ACTIVE",

            "description": "Debian Sid, full installation",

            "size": 4096

        }

    },

    {

        "model": "db.Image",

        "pk": 2,

        "fields": {

            "name": "Red Hat Enterprise Linux",

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

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

            "state": "ACTIVE",

            "description": "Red Hat Enterprise Linux, full installation",

            "size": 2048

        }

    },

    {

        "model": "db.Image",

        "pk": 3,

        "fields": {

            "name": "Ubuntu 10.10",

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

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

            "state": "ACTIVE",

            "description": "Ubuntu 10.10, full installation",

            "size": 8192

        }

    },

    {

        "model": "db.Flavor",

        "pk": 1,

        "fields": {

            "cpu": 1,

            "ram": 1024,

            "disk": 20 

        }

    },

    {

        "model": "db.Flavor",

        "pk": 2,

        "fields": {

            "cpu": 1,

            "ram": 1024,

            "disk": 40 

        }

    },

    {

        "model": "db.Flavor",

        "pk": 3,

        "fields": {

            "cpu": 1,

            "ram": 1024,

            "disk": 80 

        }

    }

]

#

# Copyright (c) 2010 Greek Research and Technology Network

#

from synnefo.api.errors import *

from synnefo.api.util import *

from synnefo.db.models import *

from synnefo.util.rapi import GanetiRapiClient

from django.conf.urls.defaults import *

from django.http import HttpResponse

from django.template.loader import render_to_string

from logging import getLogger

import json

log = getLogger('synnefo.api.servers')

rapi = GanetiRapiClient(*settings.GANETI_CLUSTER_INFO)

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

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

    (r'^/detail(?:.json|.xml)?$', 'list_servers', {'detail': True}),

    (r'^/(\d+)(?:.json|.xml)?$', 'server_demux'),

)

def demux(request):

    if request.method == 'GET':

        return list_servers(request)

    elif request.method == 'POST':

        return create_server(request)

    else:

        return HttpResponse(status=404)

def server_demux(request, server_id):

    if request.method == 'GET':

        return get_server_details(request, server_id)

    elif request.method == 'PUT':

        return update_server_name(request, server_id)

    elif request.method == 'DELETE':

        return delete_server(request, server_id)

    else:

        return HttpResponse(status=404)

def server_dict(vm, detail=False):

    d = dict(id=vm.id, name=vm.name)

    if detail:

        d['status'] = vm.rsapi_state

        d['progress'] = 100 if vm.rsapi_state == 'ACTIVE' else 0

        d['hostId'] = vm.hostid

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

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

        d['flavorId'] = vm.flavor.id            # XXX Should use flavorRef instead?

        d['imageId'] = vm.sourceimage.id        # XXX Should use imageRef instead?

        d['description'] = vm.description       # XXX Not in OpenStack docs

        vm_meta = vm.virtualmachinemetadata_set.all()

        metadata = dict((meta.meta_key, meta.meta_value) for meta in vm_meta)

        if metadata:

            d['metadata'] = dict(values=metadata)

        public_addrs = [dict(version=4, addr=vm.ipfour), dict(version=6, addr=vm.ipsix)]

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

        d['addresses']['values'].append({'id': 'public', 'values': public_addrs})

    return d

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

    if request.type == 'xml':

        mimetype = 'application/xml'

        data = render_to_string('server.xml', dict(server=server, is_root=True))

    else:

        mimetype = 'application/json'

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

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

@api_method

def list_servers(request, detail=False):

    # Normal Response Codes: 200, 203

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       overLimit (413)

    owner = get_user()

    vms = VirtualMachine.objects.filter(owner=owner, deleted=False)

    servers = [server_dict(vm, detail) for vm in vms]

    if request.type == 'xml':

        mimetype = 'application/xml'

        data = render_to_string('list_servers.xml', dict(servers=servers, detail=detail))

    else:

        mimetype = 'application/json'

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

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

@api_method

def create_server(request):

    # Normal Response Code: 202

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       badRequest (400),

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413)

    req = get_request_dict(request)

    try:

        server = req['server']

        name = server['name']

        sourceimage = Image.objects.get(id=server['imageId'])

        flavor = Flavor.objects.get(id=server['flavorId'])

    except KeyError:

        raise BadRequest

    except Image.DoesNotExist:

        raise ItemNotFound

    except Flavor.DoesNotExist:

        raise ItemNotFound

    vm = VirtualMachine.objects.create(

        name=name,

        owner=get_user(),

        sourceimage=sourceimage,

        ipfour='0.0.0.0',

        ipsix='::1',

        flavor=flavor)

    if request.META.get('SERVER_NAME', None) == 'testserver':

        name = 'test-server'

        dry_run = True

    else:

        name = vm.backend_id

        dry_run = False

    jobId = rapi.CreateInstance(

        mode='create',

        name=name,

        disk_template='plain',

        disks=[{"size": 2000}],         #FIXME: Always ask for a 2GB disk for now

        nics=[{}],

        os='debootstrap+default',       #TODO: select OS from imageId

        ip_check=False,

        nam_check=False,

        pnode=rapi.GetNodes()[0],       #TODO: verify if this is necessary

        dry_run=dry_run,

        beparams=dict(auto_balance=True, vcpus=flavor.cpu, memory=flavor.ram))

    vm.save()

    log.info('created vm with %s cpus, %s ram and %s storage' % (flavor.cpu, flavor.ram, flavor.disk))

    server = server_dict(vm, detail=True)

    server['status'] = 'BUILD'

    server['adminPass'] = random_password()

    return render_server(server, request, status=202)

@api_method

def get_server_details(request, server_id):

    try:

        vm = VirtualMachine.objects.get(id=int(server_id))

    except VirtualMachine.DoesNotExist:

        raise NotFound

    server = server_dict(vm, detail=True)

    return render_server(server, request)

@api_method

def update_server_name(request, server_id):    

    req = get_request_dict(request)

    try:

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

        vm = VirtualMachine.objects.get(id=int(server_id))

    except KeyError:

        raise BadRequest

    except VirtualMachine.DoesNotExist:

        raise NotFound

    vm.name = name

    vm.save()

    return HttpResponse(status=204)

@api_method

def delete_server(request, server_id):

    try:

        vm = VirtualMachine.objects.get(id=int(server_id))

    except VirtualMachine.DoesNotExist:

        raise NotFound

    vm.start_action('DESTROY')

    rapi.DeleteInstance(vm.backend_id)

    vm.state = 'DESTROYED'

    vm.save()

    return HttpResponse(status=204)

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

<{{ fault.name }} xmlns="http://docs.openstack.org/compute/api/v1.1" code="{{ fault.code }}">

  <message>{{ fault.message }}</message>

  <details>{{ fault.details }}</details>

</{{ fault.name }}>

{% spaceless %}

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

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

{% for server in servers %}

{% if detail %}

{% include "server.xml" %}

{% else %}

<server id="{{ server.id }}" name="{{ server.name }}"></server>

{% endif %}

{% endfor %}

</servers>

{% endspaceless %}

{% spaceless %}

{% if is_root %}

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

<server xmlns="http://docs.openstack.org/compute/api/v1.1" xmlns:atom="http://www.w3.org/2005/Atom"{% else %}<server{% endif %}

    {% if server.adminPass %}adminPass="{{ server.adminPass }}"{% endif %}

    created="{{ server.created }}"

    description="{{ server.description }}"

    flavorId="{{ server.flavorId }}"

    hostId="{{ server.hostId }}"

    id="{{ server.id }}"

    imageId="{{ server.imageId }}"

    name="{{ server.name }}"

    progress="{{ server.progress }}"

    status="{{ server.status }}"

    updated="{{ server.updated}}">

    {% if server.metadata.values %}

    <metadata>

        {% 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 }}">

            {% for ip in network.values %}

            <ip version="{{ ip.version }}" addr="{{ ip.addr }}"/>

            {% endfor %}

        </network>

        {% endfor %}

    </addresses>

</server>

{% endspaceless %}

from synnefo.api.tests_redux import APIReduxTestCase

#

# Copyright (c) 2010 Greek Research and Technology Network

#

from django.test import TestCase

from django.test.client import Client

import json

API = 'v1.1redux'

class APIReduxTestCase(TestCase):

    fixtures = [ 'api_redux_test_data' ]

    def setUp(self):

        self.client = Client()

        self.server_id = 0

    def create_server_name(self):

        self.server_id += 1

        return 'server%d' % self.server_id

    def test_create_server_json(self):

        TEMPLATE = '''

        {

            "server" : {

                "name" : "%(name)s",

                "flavorId" : "%(flavorId)s",

                "imageId" : "%(imageId)s"

            }

        }

        '''

        def new_server(imageId=1, flavorId=1):

            name = self.create_server_name()

            return name, TEMPLATE % dict(name=name, imageId=imageId, flavorId=flavorId)

        def verify_response(response, name):

            assert response.status_code == 202

            reply =  json.loads(response.content)

            server = reply['server']

            assert server['name'] == name

            assert server['imageId'] == 1

            assert server['flavorId'] == 1

            assert server['status'] == 'BUILD'

            assert server['adminPass']

            assert server['addresses']

        def verify_error(response, code, name):

            assert response.status_code == code

            reply =  json.loads(response.content)

            assert name in reply

            assert reply[name]['code'] == code

        name, data = new_server()

        url = '/api/%s/servers' % API

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

        verify_response(response, name)

        name, data = new_server()

        url = '/api/%s/servers.json' % API

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

        verify_response(response, name)

        name, data = new_server()

        url = '/api/%s/servers.json' % API

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

                                    HTTP_ACCEPT='application/xml')

        verify_response(response, name)

        name, data = new_server(imageId=0)

        url = '/api/%s/servers' % API

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

        verify_error(response, 404, 'itemNotFound')

        name, data = new_server(flavorId=0)

        url = '/api/%s/servers' % API

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

        verify_error(response, 404, 'itemNotFound')

        url = '/api/%s/servers' % API

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

        verify_error(response, 400, 'badRequest')

# The OpenStack Compute API v1.1 (REDUX)

v11redux_patterns = patterns('',

    (r'^servers', include('synnefo.api.servers')),

    (r'^.+', notFound), # catch-all

)

    url(r'^v1.1redux/', include(v11redux_patterns)),

#

# Copyright (c) 2010 Greek Research and Technology Network

#

from synnefo.api.errors import *

from synnefo.db.models import *

from django.http import HttpResponse

from django.template.loader import render_to_string

from functools import wraps

from logging import getLogger

from random import choice

from string import ascii_letters, digits

from traceback import format_exc

from xml.etree import ElementTree

from xml.parsers.expat import ExpatError

import json

log = getLogger('synnefo.api')

def tag_name(e):

    ns, sep, name = e.tag.partition('}')

    return name if sep else e.tag

def xml_to_dict(s):

    def _xml_to_dict(e):

        root = {}

        d = root[tag_name(e)] = dict(e.items())

        for child in e.getchildren():

            d.update(_xml_to_dict(child))

        return root

    return _xml_to_dict(ElementTree.fromstring(s.strip()))

def get_user():

    # XXX Placeholder function, everything belongs to a single SynnefoUser for now

    try:

        return SynnefoUser.objects.all()[0]

    except IndexError:

        raise Unauthorized

def get_request_dict(request):

    data = request.raw_post_data

    if request.type == 'xml':

        try:

            return xml_to_dict(data)

        except ExpatError:

            raise BadRequest

    else:

        try:

            return json.loads(data)

        except ValueError:

            raise BadRequest

def random_password(length=8):

    pool = ascii_letters + digits

    return ''.join(choice(pool) for i in range(length))

def render_fault(fault, request):

    if settings.DEBUG or request.META.get('SERVER_NAME', None) == 'testserver':

        fault.details = format_exc(fault)

    if request.type == 'xml':

        mimetype = 'application/xml'

        data = render_to_string('fault.xml', dict(fault=fault))

    else:

        mimetype = 'application/json'

        d = {fault.name: {'code': fault.code, 'message': fault.message, 'details': fault.details}}

        data = json.dumps(d)

    return HttpResponse(data, mimetype=mimetype, status=fault.code)    

def api_method(func):

    @wraps(func)

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

        try:

            if request.path.endswith('.json'):

                type = 'json'

            elif request.path.endswith('.xml'):

                type = 'xml'

            elif request.META.get('HTTP_ACCEPT', None) == 'application/xml':

                type = 'xml'

            else:

                type = 'json'

            request.type = type

            return func(request, *args, **kwargs)

        except Fault, fault:

            return render_fault(fault, request)

        except Exception, e:

            log.exception('Unexpected error: %s' % e)

            return HttpResponse(status=500)

    return wrapper