Synnefo

# vim: ts=4 sts=4 et ai sw=4 fileencoding=utf-8

#

# Copyright © 2010 Greek Research and Technology Network

import simplejson as json

from django.conf import settings

from django.http import HttpResponse

from piston.handler import BaseHandler, AnonymousBaseHandler

from synnefo.api.faults import fault, noContent, accepted, created

from synnefo.api.helpers import instance_to_server, paginator

from synnefo.util.rapi import GanetiRapiClient, GanetiApiError, CertificateError

from synnefo.db.models import *

from time import sleep

import random

import string

import logging

log = logging.getLogger('synnefo.api.handlers')

try:

    rapi = GanetiRapiClient(*settings.GANETI_CLUSTER_INFO)

    rapi.GetVersion()

except Exception, e:

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

    raise fault.serviceUnavailable

#If we can't connect to the rapi successfully, don't do anything

backend_prefix_id = settings.BACKEND_PREFIX_ID

VERSIONS = [

    {

        "status": "CURRENT",

        "id": "v1.0",

        "docURL" : "http://docs.rackspacecloud.com/servers/api/v1.0/cs-devguide-20110112.pdf",

        "wadl" : "http://docs.rackspacecloud.com/servers/api/v1.0/application.wadl"

    },

    {

        "status": "CURRENT",

        "id": "v1.0grnet1",

        "docURL" : "None yet",

        "wad1" : "None yet"

    }

]

#read is called on GET requests

#create is called on POST, and creates new objects

#update is called on PUT, and should update an existing product

#delete is called on DELETE, and should delete an existing object

class VersionHandler(AnonymousBaseHandler):

    allowed_methods = ('GET',)

    def read(self, request, number=None):

        try:

            if number is None:

                versions = map(lambda v: {

                            "status": v["status"],

                            "id": v["id"],

                        }, VERSIONS)

                return { "versions": versions }

            else:

                for version in VERSIONS:

                    if version["id"] == number:

                        return { "version": version }

                raise fault.itemNotFound

        except Exception, e:

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

            raise fault.serviceUnavailable

class ServerHandler(BaseHandler):

    """Handler responsible for the Servers

     handles the listing of Virtual Machines, Creates and Destroys VM's

     @HTTP methods: POST, DELETE, PUT, GET

     @Parameters: POST data with the create data (cpu, ram, etc)

     @Responses: HTTP 202 if successfully call rapi, itemNotFound, serviceUnavailable otherwise

    """

    allowed_methods = ('GET', 'POST', 'PUT', 'DELETE')

    def read(self, request, id=None):

        from time import sleep

        sleep(0.5)

        #TODO: delete the sleep once the mock objects are removed

        if id is None:

            return self.read_all(request)

        elif id == "detail":

            return self.read_all(request, detail=True)

        else:

            return self.read_one(request, id)

    def read_one(self, request, id):

        try:

            server = VirtualMachine.objects.get(id=id)

            server = {'status': server.rsapi_state, 

                     'flavorId': server.flavor.id, 

                     'name': server.name, 

                     'description': server.description, 

                     'id': server.id, 

                     'imageId': server.sourceimage.id, 

                     'hostId': server.hostid, 

                     'progress': server.rsapi_state == 'ACTIVE' and 100 or 0, 

                     #'metadata': {'Server_Label': server.description },

                     'metadata':[{'meta': { 'key': {metadata.meta_key: metadata.meta_value}}} for metadata in server.virtualmachinemetadata_set.all()],                                    

                     'addresses': {'public': { 'ip': {'addr': server.ipfour}, 'ip6': {'addr': server.ipsix}},'private': ''},      

                    }

            return { "server": server } 

        except VirtualMachine.DoesNotExist:

            raise fault.itemNotFound

        except VirtualMachine.MultipleObjectsReturned:

            raise fault.serviceUnavailable

        except Exception, e:

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

            raise fault.serviceUnavailable

    @paginator

    def read_all(self, request, detail=False):

        try:

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

            #get all VM's for now, FIX it to take the user's VMs only yet. also don't get deleted VM's

            if not detail:

                return { "servers": [ { "id": s.id, "name": s.name } for s in virtual_servers ] }

            else:

                virtual_servers_list = [{'status': server.rsapi_state, 

                                         'flavorId': server.flavor.id, 

                                         'name': server.name, 

                                         'id': server.id, 

                                         'description': server.description, 

                                         'imageId': server.sourceimage.id, 

                                         'hostId': server.hostid, 

                                         'progress': server.rsapi_state == 'ACTIVE' and 100 or 0, 

                                         #'metadata': {'Server_Label': server.description },

                                         'metadata':[{'meta': { 'key': {metadata.meta_key: metadata.meta_value}}} for metadata in server.virtualmachinemetadata_set.all()],                                    

                                         'addresses': {'public': { 'ip': {'addr': server.ipfour}, 'ip6': {'addr': server.ipsix}},'private': ''},      

                                        } for server in virtual_servers]

                #pass some fake data regarding ip, since we don't have any such data            

                return { "servers":  virtual_servers_list }                

        except Exception, e:

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

            raise fault.serviceUnavailable

    def create(self, request):

        """ Parse RackSpace API create request to generate rapi create request

            TODO: auto generate and set password

        """

        # Check if we have all the necessary data in the JSON request       

        try:

            server = json.loads(request.raw_post_data)['server']

            name = server['name']

            flavorId = server['flavorId']

            flavor = Flavor.objects.get(id=flavorId)

            imageId = server['imageId']

            image = Image.objects.get(id=imageId)

            metadata = server['metadata']

            personality = server.get('personality', None)

        except Exception as e:

            log.error('Malformed create request: %s - %s' % (e, request.raw_post_data))    

            raise fault.badRequest

        # TODO: Proper Authn, Authz

        # Everything belongs to a single SynnefoUser for now.

        try:          

            owner = SynnefoUser.objects.all()[0]

        except Exception as e:

            log.error('Cannot find a single SynnefoUser in the DB: %s' % (e));

            raise fault.unauthorized

        # add the new VM to the local db

        try:

            vm = VirtualMachine.objects.create(sourceimage=image, ipfour='0.0.0.0', ipsix='::1', flavor=flavor, owner=owner)

        except Exception as e:

            log.error("Can't save vm: %s" % e)

            raise fault.serviceUnavailable

        try:

            vm.name = name

            #vm.description = descr

            vm.save()            

            jobId = rapi.CreateInstance(

                'create',

                request.META['SERVER_NAME'] == 'testserver' and 'test-server' or vm.backend_id,

                'plain',

                # disk field of Flavor object is in GB, value specified here is in MB

                # FIXME: Always ask for a 2GB disk, current LVM physical groups are too small:

                # [{"size": flavor.disk * 1000}],

                [{"size": 2000}],

                [{}],

                #TODO: select OS from imageId

                os='debootstrap+default',

                ip_check=False,

                name_check=False,

                #TODO: verify if this is necessary

                pnode = rapi.GetNodes()[0],

                # Dry run when called by unit tests

                dry_run = request.META['SERVER_NAME'] == 'testserver',

                beparams={

                            'auto_balance': True,

                            'vcpus': flavor.cpu,

                            'memory': flavor.ram,

                        },

                )

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

        except (GanetiApiError, CertificateError) as e:

            log.error('CreateInstance failed: %s' % e)

            vm.deleted = True

            vm.save()

            raise fault.serviceUnavailable

        except Exception as e:

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

            vm.deleted = True

            vm.save()

            raise fault.serviceUnavailable            

        ret = {'server': {

                'id' : vm.id,

                'name' : vm.name,

                "imageId" : imageId,

                "flavorId" : flavorId,

                "hostId" : vm.hostid,

                "progress" : 0,

                "status" : 'BUILD',

                "adminPass" : self.random_password(),

                "metadata" : {"My Server Name" : vm.description},

                "addresses" : {

                    "public" : [  ],

                    "private" : [  ],

                    },

                },

        }

        return HttpResponse(json.dumps(ret), mimetype="application/json", status=202)

    def random_password(self):

        "return random password"

        number_of_chars = 8

        possible_chars = string.ascii_uppercase + string.ascii_lowercase + string.digits

        return ''.join(random.choice(possible_chars) for x in range(number_of_chars))

    def update(self, request, id):

        """Sets and updates Virtual Machine Metadata. 

        """

        try:

            metadata_request = json.loads(request.raw_post_data)['metadata']

            metadata_key = metadata_request.get('metadata_key')

            metadata_value = metadata_request.get('metadata_value')

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

            #we only update virtual machine's name atm

            if metadata_key == 'name':

                vm.name = metadata_value

                vm.save()

                return accepted

        except VirtualMachine.DoesNotExist:

            raise fault.itemNotFound

        except VirtualMachine.MultipleObjectsReturned:

            raise fault.serviceUnavailable

        except Exception, e:

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

            raise fault.serviceUnavailable

        raise fault.itemNotFound

    def delete(self, request, id):

        try:

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

            #TODO: set the status to DESTROYED

            vm.start_action('DESTROY')

            rapi.DeleteInstance(vm.backend_id)

            return accepted        

        except VirtualMachine.DoesNotExist:

            raise fault.itemNotFound

        except VirtualMachine.MultipleObjectsReturned:

            raise fault.serviceUnavailable

        except GanetiApiError, CertificateError:

            raise fault.serviceUnavailable

        except Exception, e:

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

            raise fault.serviceUnavailable

class ServerAddressHandler(BaseHandler):

    allowed_methods = ('GET', 'PUT', 'DELETE')

    def read(self, request, id, type=None):

        """List IP addresses for a server"""

        if type is None:

            pass

        elif type == "private":

            pass

        elif type == "public":

            pass

        return {}

    def update(self, request, id, address):

        """Share an IP address to another in the group"""

        return accepted

    def delete(self, request, id, address):

        """Unshare an IP address"""

        return accepted

class ServerActionHandler(BaseHandler):

    """Handler responsible for Server Actions

     handles Reboot, Shutdown and Start actions. 

     @HTTP methods: POST, DELETE, PUT

     @Parameters: POST data with the action (reboot, shutdown, start)

     @Responses: HTTP 202 if successfully call rapi, itemNotFound, serviceUnavailable otherwise

    """

    allowed_methods = ('POST', 'DELETE',  'PUT')

    def create(self, request, id):

        """Reboot, Shutdown, Start virtual machine"""

        try:

            requested_action = json.loads(request.raw_post_data)

            reboot_request = requested_action.get('reboot', None)

            shutdown_request = requested_action.get('shutdown', None)

            start_request = requested_action.get('start', None)

            #action not implemented

            action = reboot_request and 'REBOOT' or shutdown_request and 'STOP' or start_request and 'START'

            if not action:

                raise fault.notImplemented 

            #test if we can get the vm

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

            vm.start_action(action)

            if reboot_request:

                rapi.RebootInstance(vm.backend_id)

            elif shutdown_request:

                rapi.ShutdownInstance(vm.backend_id)

            elif start_request:

                rapi.StartupInstance(vm.backend_id)

            return accepted

        except VirtualMachine.DoesNotExist:

            raise fault.itemNotFound

        except VirtualMachine.MultipleObjectsReturned:

            raise fault.serviceUnavailable

        except GanetiApiError, CertificateError:

            raise fault.serviceUnavailable

        except Exception, e:

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

            raise fault.serviceUnavailable

    def delete(self, request, id):

        """Delete an Instance"""

        return accepted

    def update(self, request, id):

        raise fault.itemNotFound

class ServerBackupHandler(BaseHandler):

    """ Backup Schedules are not implemented yet, return notImplemented """

    allowed_methods = ('GET', 'POST', 'DELETE')

    def read(self, request, id):

        raise fault.notImplemented

    def create(self, request, id):

        raise fault.notImplemented

    def delete(self, request, id):

        raise fault.notImplemented

class FlavorHandler(BaseHandler):

    """Handler responsible for Flavors

    """

    allowed_methods = ('GET',)

    def read(self, request, id=None):

        """

        List flavors or retrieve one

        Returns: OK

        Faults: cloudServersFault, serviceUnavailable, unauthorized,

                badRequest, itemNotFound

        """

        try:

            flavors = Flavor.objects.all()

            flavors = [ {'id': flavor.id, 'name': flavor.name, 'ram': flavor.ram, \

                     'disk': flavor.disk, 'cpu': flavor.cpu} for flavor in flavors]

            if id is None:

                simple = map(lambda v: {

                            "id": v['id'],

                            "name": v['name'],

                        }, flavors)

                return { "flavors": simple }

            elif id == "detail":

                return { "flavors": flavors }

            else:

                flavor = Flavor.objects.get(id=id)

                return { "flavor":  {

                    'id': flavor.id,

                    'name': flavor.name,

                    'ram': flavor.ram,

                    'disk': flavor.disk,  

                    'cpu': flavor.cpu,  

                   } }

        except Flavor.DoesNotExist:

            raise fault.itemNotFound

        except Flavor.MultipleObjectsReturned:

            raise fault.serviceUnavailable

        except Exception, e:

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

            raise fault.serviceUnavailable

class ImageHandler(BaseHandler):

    """Handler responsible for Images

     handles the listing, creation and delete of Images. 

     @HTTP methods: GET, POST

     @Parameters: POST data 

     @Responses: HTTP 202 if successfully create Image or get the Images list, itemNotFound, serviceUnavailable otherwise

    """

    allowed_methods = ('GET', 'POST')

    def read(self, request, id=None):

        """

        List images or retrieve one

        Returns: OK

        Faults: cloudServersFault, serviceUnavailable, unauthorized,

                badRequest, itemNotFound

        """

        try:

            images = Image.objects.all()

            images_list = [ {'created': image.created.isoformat(), 

                        'id': image.id,

                        'name': image.name,

                        'updated': image.updated.isoformat(),    

                        'description': image.description, 

                        'status': image.state, 

                        'progress': image.state == 'ACTIVE' and 100 or 0, 

                        'size': image.size, 

                        'serverId': image.sourcevm and image.sourcevm.id or ""

                       } for image in images]

            # Images info is stored in the DB. Ganeti is not aware of this

            if id == "detail":

                return { "images": images_list }

            elif id is None:

                return { "images": [ { "id": s['id'], "name": s['name'] } for s in images_list ] }

            else:        

                image = images.get(id=id)

                return { "image":  {'created': image.created.isoformat(), 

                    'id': image.id,

                    'name': image.name,

                    'updated': image.updated.isoformat(),    

                    'description': image.description, 

                    'status': image.state, 

                    'progress': image.state == 'ACTIVE' and 100 or 0, 

                    'size': image.size, 

                    'serverId': image.sourcevm and image.sourcevm.id or ""

                   } }

        except Image.DoesNotExist:

                    raise fault.itemNotFound

        except Image.MultipleObjectsReturned:

                    raise fault.serviceUnavailable

        except Exception, e:

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

                    raise fault.serviceUnavailable

    def create(self, request):

        """Create a new image"""

        return accepted

class SharedIPGroupHandler(BaseHandler):

    allowed_methods = ('GET', 'POST', 'DELETE')

    def read(self, request, id=None):

        """List Shared IP Groups"""

        if id is None:

            return {}

        elif id == "detail":

            return {}

        else:

            raise fault.itemNotFound

    def create(self, request, id):

        """Creates a new Shared IP Group"""

        return created

    def delete(self, request, id):

        """Deletes a Shared IP Group"""

        raise fault.itemNotFound

class VirtualMachineGroupHandler(BaseHandler):

    """Handler responsible for Virtual Machine Groups

     creates, lists, deletes virtual machine groups

     @HTTP methods: GET, POST, DELETE

     @Parameters: POST data 

     @Responses: HTTP 202 if successfully get the Groups list, itemNotFound, serviceUnavailable otherwise

    """

    allowed_methods = ('GET', 'POST', 'DELETE')

    def read(self, request, id=None):

        """List Groups"""

        try:

            vmgroups = VirtualMachineGroup.objects.all() 

            vmgroups_list = [ {'id': vmgroup.id, \

                  'name': vmgroup.name,  \

                   'server_id': [machine.id for machine in vmgroup.machines.all()] \

                   } for vmgroup in vmgroups]

            # Group info is stored in the DB. Ganeti is not aware of this

            if id == "detail":

                return { "groups": vmgroups_list }

            elif id is None:

                return { "groups": [ { "id": s['id'], "name": s['name'] } for s in vmgroups_list ] }

            else:

                vmgroup = vmgroups.get(id=id)

                return { "group":  {'id': vmgroup.id, \

                  'name': vmgroup.name,  \

                   'server_id': [machine.id for machine in vmgroup.machines.all()] \

                   } }

        except VirtualMachineGroup.DoesNotExist:

                    raise fault.itemNotFound

        except VirtualMachineGroup.MultipleObjectsReturned:

                    raise fault.serviceUnavailable

        except Exception, e:

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

                    raise fault.serviceUnavailable

    def create(self, request, id):

        """Creates a Group"""

        return created

    def delete(self, request, id):

        """Deletes a  Group"""

        raise fault.itemNotFound

class LimitHandler(BaseHandler):

    allowed_methods = ('GET',)

    # XXX: hookup with @throttle

    rate = [

        {

           "verb" : "POST",

           "URI" : "*",

           "regex" : ".*",

           "value" : 10,

           "remaining" : 2,

           "unit" : "MINUTE",

           "resetTime" : 1244425439

        },

        {

           "verb" : "POST",

           "URI" : "*/servers",

           "regex" : "^/servers",

           "value" : 25,

           "remaining" : 24,

           "unit" : "DAY",

           "resetTime" : 1244511839

        },

        {

           "verb" : "PUT",

           "URI" : "*",

           "regex" : ".*",

           "value" : 10,

           "remaining" : 2,

           "unit" : "MINUTE",

           "resetTime" : 1244425439

        },

        {

           "verb" : "GET",

           "URI" : "*",

           "regex" : ".*",

           "value" : 3,

           "remaining" : 3,

           "unit" : "MINUTE",

           "resetTime" : 1244425439

        },

        {

           "verb" : "DELETE",

           "URI" : "*",

           "regex" : ".*",

           "value" : 100,

           "remaining" : 100,

           "unit" : "MINUTE",

           "resetTime" : 1244425439

        }

    ]

    absolute = {

        "maxTotalRAMSize" : 51200,

        "maxIPGroups" : 50,

        "maxIPGroupMembers" : 25

    }

    def read(self, request):

        return { "limits": {

                "rate": self.rate,

                "absolute": self.absolute,

               }

            }

class DiskHandler(BaseHandler):

    allowed_methods = ('GET', 'POST', 'PUT', 'DELETE')

    def read(self, request, id=None):

        """List Disks"""

        if id is None:

            return self.read_all(request)

        elif id == "detail":

            return self.read_all(request, detail=True)

        else:

            return self.read_one(request, id)

    def read_one(self, request, id):

        """List one Disk with the specified id with all details"""

        # FIXME Get detailed info from the DB 

        # for the Disk with the specified id

        try:

            disk = Disk.objects.get(pk=id)

            disk_details = {

                "id" : disk.id, 

                "name" : disk.name, 

                "size" : disk.size,

                "created" : disk.created, 

                "serverId" : disk.vm.id

            }

            return { "disks" : disk_details }

        except:

            raise fault.itemNotFound

    @paginator

    def read_all(self, request, detail=False):

        """List all Disks. If -detail- is set list them with all details"""

        if not detail:

            disks = Disk.objects.filter(owner=SynnefoUser.objects.all()[0])

            return { "disks": [ { "id": disk.id, "name": disk.name } for disk in disks ] }

        else:

            disks = Disk.objects.filter(owner=SynnefoUser.objects.all()[0])

            disks_details = [ {

                "id" : disk.id, 

                "name" : disk.name,

                "size" : disk.size,

                "created" : disk.created, 

                "serverId" : disk.vm.id,

            } for disk in disks ]

            return { "disks":  disks_details }                

    def create(self, request):

        """Create a new Disk"""

        # FIXME Create a partial DB entry, 

        # then call the backend for actual creation

        pass

    def update(self, request, id):

        """Rename the Disk with the specified id"""

        # FIXME Change the Disk's name in the DB

        pass

    def delete(self, request, id):

        """Destroy the Disk with the specified id"""

        # Call the backend for actual destruction

        pass