Synnefo

#

# Copyright (c) 2010 Greek Research and Technology Network

#

from socket import getfqdn

from django.conf import settings

from django.http import HttpResponse

from django.template.loader import render_to_string

from django.utils import simplejson as json

from synnefo.api.faults import BadRequest, ResizeNotAllowed, ServiceUnavailable

from synnefo.api.util import random_password

from synnefo.util.rapi import GanetiRapiClient

from synnefo.util.vapclient import request_forwarding as request_vnc_forwarding

from synnefo.logic import backend

from synnefo.logic.utils import get_rsapi_state

server_actions = {}

rapi = GanetiRapiClient(*settings.GANETI_CLUSTER_INFO)

def server_action(name):

    '''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

    return decorator

@server_action('console')

def get_console(request, vm, args):

    """Arrange for an OOB console of the specified type

    This method arranges for an OOB console of the specified type.

    Only consoles of type "vnc" are supported for now.

    It uses a running instance of vncauthproxy to setup proper

    VNC forwarding with a random password, then returns the necessary

    VNC connection info to the caller.

    JSON Request: {

        "console": {

            "type": "vnc"

        }

    }

    JSON Reply: {

        "vnc": {

            "host": "fqdn_here",

            "port": a_port_here,

            "password": "a_password_here"

        }

    }

    """

    # Normal Response Code: 200

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       overLimit (413)

    try:

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

        if console_type != 'vnc':

            raise BadRequest(message="type can only be 'vnc'")

    except KeyError:

        raise BadRequest()

    # Use RAPI to get VNC console information for this instance

    if get_rsapi_state(vm) != 'ACTIVE':

        raise BadRequest(message="Server not in ACTIVE state")

    if settings.TEST:

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

    else:

        console_data = rapi.GetInstanceConsole(vm.backend_id)

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

        raise ServiceUnavailable()

    # Let vncauthproxy decide on the source port.

    # The alternative: static allocation, e.g.

    # sport = console_data['port'] - 1000

    sport = 0

    daddr = console_data['host']

    dport = console_data['port']

    passwd = random_password()

    try:

        if settings.TEST:

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

        else:

            fwd = request_vnc_forwarding(sport, daddr, dport, passwd)

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

            raise ServiceUnavailable()

        vnc = { 'host': getfqdn(), 'port': fwd['source_port'], 'password': passwd }

    except Exception:

        raise ServiceUnavailable("Could not allocate VNC console port")

    # Format to be reviewed by [verigak], FIXME

    if request.serialization == 'xml':

        mimetype = 'application/xml'

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

    else:

        mimetype = 'application/json'

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

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

@server_action('changePassword')

def change_password(request, vm, args):

    # Normal Response Code: 202

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       overLimit (413)

    try:

        adminPass = args['adminPass']

    except KeyError:

        raise BadRequest()

    raise ServiceUnavailable()

@server_action('reboot')

def reboot(request, vm, args):

    # Normal Response Code: 202

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       overLimit (413)

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

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

        raise BadRequest()

    backend.start_action(vm, 'REBOOT')

    rapi.RebootInstance(vm.backend_id, reboot_type.lower())

    return HttpResponse(status=202)

@server_action('start')

def start(request, vm, args):

    # Normal Response Code: 202

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404)

    backend.start_action(vm, 'START')

    rapi.StartupInstance(vm.backend_id)

    return HttpResponse(status=202)

@server_action('shutdown')

def shutdown(request, vm, args):

    # Normal Response Code: 202

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404)

    backend.start_action(vm, 'STOP')

    rapi.ShutdownInstance(vm.backend_id)

    return HttpResponse(status=202)

@server_action('rebuild')

def rebuild(request, vm, args):

    # Normal Response Code: 202

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413)

    raise ServiceUnavailable()

@server_action('resize')

def resize(request, vm, args):

    # Normal Response Code: 202

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413),

    #                       resizeNotAllowed (403)

    raise ResizeNotAllowed()

@server_action('confirmResize')

def confirm_resize(request, vm, args):

    # Normal Response Code: 204

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413),

    #                       resizeNotAllowed (403)

    raise ResizeNotAllowed()

@server_action('revertResize')

def revert_resize(request, vm, args):

    # Normal Response Code: 202

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

    #                       serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       badMediaType(415),

    #                       itemNotFound (404),

    #                       buildInProgress (409),

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413),

    #                       resizeNotAllowed (403)

    raise ResizeNotAllowed()