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

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

        elif offset2 == "remove_router_interface":

            #return HttpResponse("remove interface")

            return remove_interface(request, offset22)

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

    metadata = server.get('metadata', {})

    assert isinstance(metadata, dict)

    image_id = server['imageRef']

    flavor_id = server['flavorRef']

    personality = server.get('personality', [])

    assert isinstance(personality, list)

    private_networks = server.get("networks", [])

    assert isinstance(private_networks, list)

    floating_ips = server.get("floating_ips", [])

    assert isinstance(floating_ips, list)

    # Verify that personalities are well-formed

    util.verify_personality(personality)

    # Get image information

    image = util.get_image_dict(image_id, user_id)

    # Get flavor (ensure it is active)

    flavor = util.get_flavor(flavor_id, include_deleted=False)

    # Generate password

    password = util.random_password()

    vm = servers.create(user_id,

                        name,

                        #password,

                        #flavor,

                        #image,

                        #metadata=metadata,

                        #personality=personality,

                        #private_networks=private_networks,

                        #floating_ips=floating_ips

                        )

    server = router_to_dict(vm, detail=True)

    server['status'] = 'BUILD'

    server['adminPass'] = password

    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)

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

    router_info = utils.get_request_dict(request)

    subnet = False

    try:

        subnet_id = router_info["subnet_id"]

        subnet = True

        subnet_obj = subnet_views.get_subnet_fromdb(subnet_id,

                                        request.user_unique)

    except KeyError:

        pass

    try:

        port_id = router_info['port_id']

        if subnet:

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

        try:

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

        except (ValueError, models.NetworkInteraface.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 = models.NetworkInteface(machine=router,

                                    subnet=subnet_obj,

                                    network=subnet_obj.network

                                    ipv4=subnet.gateway

                                    )

        nic.save()

        port_id = nic.id

    else:

        #connect the nic

        nic_obj.machine = router

        nic_obj.save()

        subnet_id = nic.subnet.id

    res = {"port_id":port_db.id,

            "subnet_id":subnet_db.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)

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

    info = utils.get_request_dict(request)

    subnet = False

    try:

        subnet_id = info["subnet_id"]

        subnet = True

        subnet_db = subnet_views.get_subnet_fromdb(subnet_id,

                                request.user_unique)

    except KeyError:

        pass

    port = False

    try:

        port_id = info['port_id']

        port = True

        try:

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

        except (ValueError, models.NetworkInteraface.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 is subnet_db:

            return HttpResponse(status=409)

    if subnet:

        #get the port

        if not port_db:

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

    elif port:

        #get the subnet

        if not subnet_db:

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