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 models import NetworkInterface

from logging import getLogger

log = getLogger(__name__)

def demux(request):

    if request.method == 'GET':

        return HttpResponse("list ports")

        #return list_ports(request)

    elif request.method == 'POST':

        #return create_port(request)

        return HttpResponse("create port")

    else:

        return api.api_method_not_allowed(request)

def port_demux(request,offset):

    if request.method == 'GET':

        return HttpResponse("get single port")

        #return get_port(request,offset)

    elif request.method == 'DELETE':

        return HttpResponse("delete port")

        #return delete_port(request,offset)

    elif request.method == 'PUT':

        return HttpResponse("put port")

        #return update_port(request,offset)

    else:

        return api.api_method_not_allowed(request)

"""

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

def list_ports(request):

    log.debug('list_networks')

    user_networks = Network.objects.filter(Q(userid=request.user_uniq) |

            Q(public=True))

    user_networks = user_networks.filter(deleted=False)

    networks = [network_to_dict(network)

                for network in user_networks.order_by('id')]

    if request.serialization == 'xml':

        data = render_to_string('list_networks.xml', {

            'networks': networks })

    else:

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

    return HttpResponse(data, status=200)

"""

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

@transaction.commit_manually

def create_port (request):

    '''

    '''

    try:

        user_id = request.user_uniq

        req = utils.get_request_dict(request)

        log.info('create_network %s', req)

        try:

             d = req['port']

             name = d['name']

        except KeyError:

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

        flavor = d.get("type", None)

        if flavor is None:

            #raise faults.BadRequest("Missing request parameter 'type'")

            # set default flavor

            #FIX ME!!!

            flavor="MAC_FILTERED"

            log.info("not found flavor")

        elif flavor not in Network.FLAVORS.keys():

            raise api.faults.BadRequest("Invalid network type '%s'" % flavor)

            log.info("found flavor 1")

        elif flavor not in settings.API_ENABLED_NETWORK_FLAVORS:

            log.info("found flavor2")

            raise api.faults.Forbidden("Can not create network of type '%s'" %flavor)

        # Get and validate flavor. Flavors are still exposed as 'type' in the

        # API.

        try:

            mode, link, mac_prefix, tags = util.values_from_flavor(flavor)

            validate_mac(mac_prefix + "0:00:00:00")

            network = Network.objects.create(

                name=name,

                userid=user_id,

                flavor=flavor,

                mode=mode,

                link=link,

                mac_prefix=mac_prefix,

                tags=tags,

                action='CREATE',

                state='ACTIVE')

        except EmptyPool:

            log.error("Failed to allocate resources for network of type: %s",

            flavor)

            raise api.faults.ServiceUnavailable("Failed to allocate network"

                " resources")

        # Issue commission to Quotaholder and accept it since at the end of

        # this transaction the Network object will be created in the DB.

        # Note: the following call does a commit!

        #quotas.issue_and_accept_commission(network)

        # COME BACK....

    except:

        transaction.rollback()

        log.info("roll")

        raise

    else:

        transaction.commit()

        log.info("commit")

    networkdict = network_to_dict(network)

    response = render_network(request, networkdict, status=201)

    return response