Synnefo

# Copyright 2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.conf.urls.defaults import patterns

from django.db import transaction

from django.http import HttpResponse

from django.utils import simplejson as json

from snf_django.lib import api

from snf_django.lib.api import faults, utils

from synnefo.api import util

from synnefo import quotas

from synnefo.db.models import Network, FloatingIP

from logging import getLogger

log = getLogger(__name__)

ips_urlpatterns = patterns(

    'synnefo.api.floating_ips',

    (r'^(?:/|.json|.xml)?$', 'demux'),

    (r'^/(\w+)(?:.json|.xml)?$', 'floating_ip_demux'),

)

pools_urlpatterns = patterns(

    "synnefo.api.floating_ips",

    (r'^(?:/|.json|.xml)?$', 'list_floating_ip_pools'),

)

def demux(request):

    if request.method == 'GET':

        return list_floating_ips(request)

    elif request.method == 'POST':

        return allocate_floating_ip(request)

    else:

        return api.method_not_allowed(request)

def floating_ip_demux(request, floating_ip_id):

    if request.method == 'GET':

        return get_floating_ip(request, floating_ip_id)

    elif request.method == 'DELETE':

        return release_floating_ip(request, floating_ip_id)

    else:

        return api.method_not_allowed(request)

def ip_to_dict(floating_ip):

    machine_id = floating_ip.machine_id

    return {"fixed_ip": None,

            "id": str(floating_ip.id),

            "instance_id": str(machine_id) if machine_id else None,

            "ip": floating_ip.ipv4,

            "pool": str(floating_ip.network_id)}

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

                serializations=["json"])

def list_floating_ips(request):

    """Return user reserved floating IPs"""

    log.debug("list_floating_ips")

    userid = request.user_uniq

    floating_ips = FloatingIP.objects.filter(userid=userid).order_by("id")

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

    floating_ips = map(ip_to_dict, floating_ips)

    request.serialization = "json"

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

    return HttpResponse(data, status=200)

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

                serializations=["json"])

def get_floating_ip(request, floating_ip_id):

    """Return information for a floating IP."""

    userid = request.user_uniq

    try:

        floating_ip = FloatingIP.objects.get(id=floating_ip_id,

                                             deleted=False,

                                             userid=userid)

    except FloatingIP.DoesNotExist:

        raise faults.ItemNotFound("Floating IP '%s' does not exist" %

                                  floating_ip_id)

    request.serialization = "json"

    data = json.dumps({"floating_ip": ip_to_dict(floating_ip)})

    return HttpResponse(data, status=200)

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

                serializations=["json"])

@transaction.commit_manually

def allocate_floating_ip(request):

    """Allocate a floating IP."""

    req = utils.get_request_dict(request)

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

    userid = request.user_uniq

    pool = req.get("pool", None)

    address = req.get("address", None)

    machine = None

    net_objects = Network.objects.select_for_update()\

                                 .filter(public=True, floating_ip_pool=True,

                                         deleted=False)

    try:

        if pool is None:

            # User did not specified a pool. Choose a random public IP

            network, address = util.get_free_ip(net_objects)

        else:

            try:

                network_id = int(pool)

            except ValueError:

                raise faults.BadRequest("Invalid pool ID.")

            network = next((n for n in net_objects if n.id == network_id),

                           None)

            if network is None:

                raise faults.ItemNotFound("Pool '%s' does not exist." % pool)

            if address is None:

                # User did not specified an IP address. Choose a random one

                # Gets X-Lock on IP pool

                address = util.get_network_free_address(network)

            else:

                # User specified an IP address. Check that it is not a used

                # floating IP

                if FloatingIP.objects.filter(network=network,

                                             deleted=False,

                                             ipv4=address).exists():

                    msg = "Floating IP '%s' is reserved" % address

                    raise faults.Conflict(msg)

                pool = network.get_pool()  # Gets X-Lock

                # Check address belongs to pool

                if not pool.contains(address):

                    raise faults.BadRequest("Invalid address")

                if pool.is_available(address):

                    pool.reserve(address)

                    pool.save()

                # If address is not available, check that it belongs to the

                # same user

                elif not network.nics.filter(ipv4=address,

                                             machine__userid=userid).exists():

                        msg = "Address '%s' is already in use" % address

                        raise faults.Conflict(msg)

        floating_ip = FloatingIP.objects.create(ipv4=address, network=network,

                                                userid=userid, machine=machine)

        quotas.issue_and_accept_commission(floating_ip)

    except:

        transaction.rollback()

        raise

    else:

        transaction.commit()

    log.info("User '%s' allocated floating IP '%s", userid, floating_ip)

    request.serialization = "json"

    data = json.dumps({"floating_ip": ip_to_dict(floating_ip)})

    return HttpResponse(data, status=200)

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

                serializations=["json"])

@transaction.commit_on_success

def release_floating_ip(request, floating_ip_id):

    """Release a floating IP."""

    userid = request.user_uniq

    log.info("release_floating_ip '%s'. User '%s'.", floating_ip_id, userid)

    try:

        floating_ip = FloatingIP.objects.select_for_update()\

                                        .get(id=floating_ip_id,

                                             deleted=False,

                                             userid=userid)

    except FloatingIP.DoesNotExist:

        raise faults.ItemNotFound("Floating IP '%s' does not exist" %

                                  floating_ip_id)

    # Since we have got an exlusively lock in floating IP, and since

    # to remove a floating IP you need the same lock, the in_use() query

    # is safe

    if floating_ip.in_use():

        msg = "Floating IP '%s' is used" % floating_ip.id

        raise faults.Conflict(message=msg)

    try:

        floating_ip.network.release_address(floating_ip.ipv4)

        floating_ip.deleted = True

        quotas.issue_and_accept_commission(floating_ip, delete=True)

    except:

        transaction.rollback()

        raise

    else:

        floating_ip.delete()

        transaction.commit()

    log.info("User '%s' released IP '%s", userid, floating_ip)

    return HttpResponse(status=204)

def network_to_pool(network):

    pool = network.get_pool(with_lock=False)

    return {"name": str(network.id),

            "size": pool.pool_size,

            "free": pool.count_available()}

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

                serializations=["json"])

def list_floating_ip_pools(request):

    networks = Network.objects.filter(public=True, floating_ip_pool=True)

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

    pools = map(network_to_pool, networks)

    request.serialization = "json"

    data = json.dumps({"floating_ip_pools": pools})

    request.serialization = "json"

    return HttpResponse(data, status=200)