Synnefo

from django.http import HttpResponse

from django.utils import simplejson as json

from django.db import transaction

from django.db.models import Q

from synnefo.db.pools import EmptyPool

from synnefo.db.utils import validate_mac

from django.conf import settings

from snf_django.lib import api

from snf_django.lib.api import utils

from synnefo.logic import backend

from django.template.loader import render_to_string

from synnefo.api import util

from synnefo.db.models import VirtualMachine

import models

import subnet_views

from logging import getLogger

import network_views as nv

#from synnefo.logic import servers

log = getLogger(__name__)

def demux(request):

    if request.method == 'GET':

        #return HttpResponse("list routers")

        return list_routers(request)

    elif request.method == 'POST':

        return create_router(request)

        #return HttpResponse("create router")

    else:

        return api.api_method_not_allowed(request)

def router_demux(request, offset):

    if request.method == 'GET':

        #return HttpResponse("get single router")

        return get_router(request,  offset)

    elif request.method == 'DELETE':

        #return HttpResponse("delete router")

        return delete_router(request, offset)

    elif request.method == 'PUT':

        #return HttpResponse("put router")

        return update_router(request, offset)

    else:

        return api.api_method_not_allowed(request)

def rinterface_demux(request, offset1, offset2):

    if request.method == 'PUT':

        if offset2 == "add_router_interface":

            #return HttpResponse("add interface")

            return add_interface(request, offset1)

        elif offset2 == "remove_router_interface":

            #return HttpResponse("remove interface")

            return remove_interface(request, offset1)

    else:

        return api.api_method_not_allowed(request)

@api.api_method(http_method='GET', user_required=True, logger=log)

def list_routers(request):

    log.debug('list_routers')

    user_routers = VirtualMachine.objects.filter(userid=request.user_uniq,

                                                 router=True)

    user_routers = utils.filter_modified_since(request, objects=user_routers)

    routers = [router_to_dict(router)

               for router in user_routers.order_by('id')]

    if request.serialization == 'xml':

        data = render_to_string('list_routers.xml', {

            'routers': routers})

    else:

        data = json.dumps({"routers": routers})

    return HttpResponse(data, status=200)

@api.api_method(http_method='POST', user_required=True, logger=log)

@transaction.commit_manually

def create_router(request):

    user_id = request.user_uniq

    req = utils.get_request_dict(request)

    try:

        server = req['router']

        name = server['name']

    except (KeyError, AssertionError):

        raise api.faults.BadRequest("Malformed request")

    try:

        netid = server[external_gateway_info]["network_id"]

        net = nv.get_network_fromdb(netid, request.user_uniq)

    except (KeyError, AssertionError):

        pass

    '''

    vm = servers.create(user_id,

                        name,

                        #password,

                        #flavor,

                        #image,

                        #metadata=metadata,

                        #personality=personality,

                        #private_networks=private_networks,

                        #floating_ips=floating_ips

                        )

    '''

    try:

        net

        mock_connect(vm, net)

    except NameError:

        pass

        #mock_connect(vm, random_public_net)

    server = router_to_dict(vm, detail=True)

    response = render_router(request, server, status=202)

    return response

@api.api_method(http_method='GET', user_required=True, logger=log)

def get_router(request, router_id):

    log.debug('get_router_details %s', router_id)

    router = util.get_vm(router_id, request.user_uniq)

    router_dict = router_to_dict(router)

    return render_router(request, router_dict)

@api.api_method(http_method='DELETE', user_required=True, logger=log)

@transaction.commit_on_success

def delete_router(request, router_id):

    log.debug('delete router  %s', router_id)

    router = util.get_vm(router_id, request.user_uniq)

    if router.neutron_networks.filter(public=False):

        return HttpResponse("There are internal interfaces on the router",

                            status=409)

    #servers.destroy(router)

    router.deleted = True

    router.save()

    return HttpResponse(status=204)

@api.api_method(http_method='PUT', user_required=True, logger=log)

def update_router(request, router_id):

    log.debug('update router %s', router_id)

    router = util.get_vm(router_id, request.user_uniq)

    req = utils.get_request_dict(request)

    try:

        server = req['router']

    except (KeyError, AssertionError):

        raise api.faults.BadRequest("Malformed request")

    try:

        name = server['name']

        router.name = name

    except KeyError:

        pass

    try:

        net = server['external_gateway_info']['network_id']

        #find the new network

        new_net = nv.get_network_fromdb(net, request.user_uniq)

        #disconnect from the old net

        external_net = router.neutron_networks.filter(public=True)

        if external_net:

            #servers.disconnect(router, external_net[0])

            mock_disconnect(router, external_net[0])

        #connect to the new net

        #servers.connect(router, new_net)

        mock_connect(router, new_net)

    except KeyError:

        pass

    router.save()

    routerdict = router_to_dict(router)

    return render_router(request, routerdict, 200)

@api.api_method(http_method='PUT', user_required=True, logger=log)

def add_interface(request, router_id):

    log.debug('add interface to router %s', router_id)

    info = utils.get_request_dict(request)

    router = util.get_vm(router_id, request.user_uniq)

    subnet = False

    try:

        subnet_id = info["subnet_id"]

        subnet = True

        subnet_obj = subnet_views.get_subnet_fromdb(subnet_id,

                                                    request.user_uniq)

    except KeyError:

        pass

    try:

        port_id = info['port_id']

        if subnet:

            raise api.faults.BadRequest("Both subnet and port provided")

        try:

            nic_obj = models.NetworkInterface.objects.get(id=port_id)

        except (ValueError, models.NetworkInterface.DoesNotExist):

            raise api.faults.ItemNotFound('Port not found')

        if not nic_obj.ipv4:

            raise api.faults.BadRequest("No ip-address")

        if nic_obj.machine:

            return HttpResponse(status=409)

    except KeyError:

        if not subnet:

            raise api.faults.BadRequest("Malformed request")

    if subnet:

        #create nic with the subnet and add to the vm

        nic_obj = models.NetworkInterface(machine=router,

                                          subnet=subnet_obj,

                                          network=subnet_obj.network,

                                          ipv4=subnet_obj.gateway)

        nic_obj.save()

    else:

        #connect the nic

        nic_obj.machine = router

        nic_obj.save()

    #FIX ME : do backend connection

    res = {"port_id": nic_obj.id,

           "subnet_id": nic_obj.subnet.id}

    data = json.dumps(res)

    return HttpResponse(data, status=200)

@api.api_method(http_method='PUT', user_required=True, logger=log)

def remove_interface(request, router_id):

    log.debug('remove interface from router %s', router_id)

    info = utils.get_request_dict(request)

    router = util.get_vm(router_id, request.user_uniq)

    subnet = False

    try:

        subnet_id = info["subnet_id"]

        subnet = True

        subnet_db = subnet_views.get_subnet_fromdb(subnet_id,

                                                   request.user_uniq)

    except KeyError:

        pass

    port = False

    try:

        port_id = info['port_id']

        port = True

        try:

            port_db = models.NetworkInterface.objects.get(id=port_id)

        except (ValueError, models.NetworkInterface.DoesNotExist):

            raise api.faults.ItemNotFound('Port not found')

    except KeyError:

        pass

    if (port and subnet):

        #validate port-subnet combination else return 409

        #subnet must be the first of the port

        if not (port_db.subnet.id == subnet_db.id):

            return HttpResponse(status=409)

    if subnet:

        #get the port

        try:

            port_db

        except NameError:

            try:

                port_db = subnet_db.neutron_nics.get(machine=router)

            except (ValueError, models.NetworkInterface.DoesNotExist):

                raise api.faults.ItemNotFound('Port not found')

    elif port:

        #get the subnet

        try:

            subnet_db

        except NameError:

            subnet_db = port_db.subnet

    else:

        raise api.faults.BadRequest("Malformed request")

    res = {"id": str(router.id),

           "tenant_id": request.user_uniq,

           "port_id": port_db.id,

           "subnet_id": subnet_db.id}

    port_db.delete()  # need to add backend stuff

    data = json.dumps(res)

    return HttpResponse(data, status=200)

# util functions

def router_to_dict(router):

    d = {'id': str(router.id), 'name': router.name}

    d['user_id'] = router.userid

    d['tenant_id'] = router.userid

    d['admin_state_up'] = True

    external_net = router.neutron_networks.filter(public=True)

    if external_net:

        external_net = external_net[0]

        d['external_gateway_info'] = {'network_id': external_net.id}

    else:

        d['external_gateway_info'] = None

    return d

def render_router(request, routerdict, status=200):

    if request.serialization == 'xml':

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

    else:

        data = json.dumps({'router': routerdict})

    return HttpResponse(data, status=status)

# mock functions

def mock_disconnect(router, net):

    nic = models.NetworkInterface.objects.get(network=net, machine=router)

    nic.delete()

def mock_connect(router, net):

    nic = models.NetworkInterface(network=net, machine=router)

    nic.save()