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 Network

from logging import getLogger

from synnefo import quotas

log = getLogger(__name__)

def demux(request):

    if request.method == 'GET':

        #return HttpResponse("in network get")

        return list_networks(request)

    elif request.method == 'POST':

        return create_network(request)

        #return HttpResponse("in network post")

    else:

        return api.api_method_not_allowed(request)

def network_demux(request, offset):

    if request.method == 'GET':

        return get_network(request, offset)

        #return HttpResponse("in network det get")

    elif request.method == 'DELETE':

        return delete_network(request, offset)

        #return HttpResponse("in network det delete")

    elif request.method == 'PUT':

        return update_network(request, offset)

        #return HttpResponse("in network det put")

    else:

        return api.api_method_not_allowed(request)

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

def list_networks(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_network(request):

    '''

    This operation does not require a rest body. If specified, the body might

    include one or more of the following attributes:

    name: a string specifying a symbolic name for the network, which is not

        required to be unique;

    admin_state_up: a bool value specifying the administrative status of

        the network;

    2 more attirbutes for administrative users (not supported)

    '''

    try:

        user_id = request.user_uniq

        if request.raw_post_data:

            req = utils.get_request_dict(request)

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

            try:

                d = req['network']

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

                msg = "Can not create network of type '%s'"

                raise api.faults.Forbidden(msg % flavor)

            # Get and validate flavor. Flavors are still exposed

            #as 'type' in the API.

        else:

            name = ""

            flavor = "MAC_FILTERED"   # this is the default FIX ME

        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:

            msg = "Failed to allocate resources for network of type: %s"

            log.error(msg, 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

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

def get_network(request, network_id):

    log.debug('get_network_details %s', network_id)

    net = get_network_fromdb(network_id, request.user_uniq)

    #needs discussion

    if net.deleted:

        raise api.faults.BadRequest("Network has been deleted.")

    else:

        netdict = network_to_dict(net)

        return render_network(request, netdict)

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

@transaction.commit_on_success

def delete_network(request, network_id):

    log.info('delete_network %s', network_id)

    net = get_network_fromdb(network_id, request.user_uniq, for_update=True)

    log.info(net.name)

    if net.public:

        raise api.faults.Forbidden('Can not delete the public network.')

    if net.deleted:

        raise api.faults.BadRequest("Network has been deleted.")

    if net.machines.all():  # Nics attached on network

        #raise api.faults.NetworkInUse('Machines are connected to network.')

        return HttpResponse("Network in use", status=409)

    net.action = 'DESTROY'

    net.save()

    '''

    skip the backend part...

    backend_networks = net.backend_networks.exclude(operstate="DELETED")

    for bnet in backend_networks:

        backend.delete_network(net, bnet.backend)

    if not backend_networks:

        backend.update_network_state(net)

    '''

    #the following has to leave when fix the backend thing

    net.deleted = True

    net.save()

    return HttpResponse(status=204)

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

def update_network(request, network_id):

    '''

    You can update only name and admin_state_up

    '''

    net = get_network_fromdb(network_id, request.user_uniq, for_update=True)

    info = utils.get_request_dict(request)

    updatable = set(["name", "admin_state_up"])

    try:

        new_vals = info["network"]

    except Keyerror:

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

    for key, val in new_vals.iteritems():

        if key in updatable:

            setattr(net, key, val)

        else:

            raise api.faults.BadRequest("Wrong field update")

    net.save()

    netdict = network_to_dict(net)

    return render_network(request, netdict, 200)

def network_to_dict(network):

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

    d['links'] = util.network_to_links(network.id)

    d['user_id'] = network.userid

    d['tenant_id'] = network.userid

    d['type'] = network.flavor

    d['updated'] = utils.isoformat(network.updated)

    d['created'] = utils.isoformat(network.created)

    d['status'] = network.state

    d['public'] = network.public

    d['admin_state_up'] = "true"

    subnet_cidr = [s.id for s in network.subnet_set.all()]

    d['subnets'] = subnet_cidr

    return d

def render_network(request, networkdict, status=200):

    if request.serialization == 'xml':

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

    else:

        data = json.dumps({'network': networkdict})

    return HttpResponse(data, status=status)

def get_network_fromdb(network_id, user_id, for_update=False):

    """

    Return a Network instance or raise ItemNotFound.

    This is the same as util.get_network

    """

    try:

        network_id = int(network_id)

        objects = Network.objects

        if for_update:

            objects = objects.select_for_update()

        return objects.get(Q(userid=user_id) | Q(public=True), id=network_id)

    except (ValueError, Network.DoesNotExist):

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