Synnefo

from synnefo.db.models import Subnet

    allocation_pools = subnet.get('allocation_pools', None)

    if allocation_pools is not None:

        pool = parse_ip_pools(allocation_pools)

        allocation_pools = string_to_ipaddr(pool)

    # If no gateway is specified, send an empty string, because None is used

    # if the user wants no gateway at all

    gateway = subnet.get('gateway_ip', "")

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

    potential_gateway = str(ipaddr.IPNetwork(cidr).network + 1)

        gateway = potential_gateway

    allocation_pools = subnet.ip_pools.all()

    pools = list()

    if allocation_pools:

        for pool in allocation_pools:

            cidr = ipaddr.IPNetwork(pool.base)

            start = str(cidr.network + pool.offset)

            end = str(cidr.network + pool.offset + pool.size - 1)

            pools.append({"start": start, "end": end})

    dictionary = dict({'id': str(subnet.id),

                       'network_id': str(subnet.network.id),

                       'name': subnet.name if subnet.name is not None else "",

                       'tenant_id': subnet.network.userid,

                       'user_id': subnet.network.userid,

                       'gateway_ip': subnet.gateway,

                       'ip_version': subnet.ipversion,

                       'cidr': subnet.cidr,

                       'enable_dhcp': subnet.dhcp,

                       'dns_nameservers': dns,

                       'host_routes': hosts,

                       'allocation_pools': pools if pools is not None else []})

        dictionary['enable_slaac'] = subnet.dhcp

    dictionary['links'] = util.subnet_to_links(subnet.id)

    return dictionary

def string_to_ipaddr(pools):

    """Convert [["192.168.42.1", "192.168.42.15"],

                ["192.168.42.30", "192.168.42.60"]]

                [[IPv4Address('192.168.42.1'), IPv4Address('192.168.42.15')],

                [IPv4Address('192.168.42.30'), IPv4Address('192.168.42.60')]]

    and sort the output

    pool_list = [(map(lambda ip_str: ipaddr.IPAddress(ip_str), pool))

                 for pool in pools]

    pool_list.sort()

    return pool_list

def check_name_length(name):

    """Check if the length of a name is within acceptable value"""

    if len(str(name)) > Subnet.SUBNET_NAME_LENGTH:

        raise api.faults.BadRequest("Subnet name too long")

    return name

def get_subnet_fromdb(subnet_id, user_id, for_update=False):

    """Return a Subnet instance or raise ItemNotFound.

    This is the same as util.get_network

    """

    try:

        subnet_id = int(subnet_id)

        if for_update:

            return Subnet.objects.select_for_update().get(id=subnet_id,

                                                          network__userid=

                                                          user_id)

        return Subnet.objects.get(id=subnet_id, network__userid=user_id)

    except (ValueError, Subnet.DoesNotExist):

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

def parse_ip_pools(pools):

    """Convert [{'start': '192.168.42.1', 'end': '192.168.42.15'},

             {'start': '192.168.42.30', 'end': '192.168.42.60'}]

    to

            [["192.168.42.1", "192.168.42.15"],

             ["192.168.42.30", "192.168.42.60"]]

    """

    pool_list = list()

    for pool in pools:

        parse = [pool["start"], pool["end"]]

        pool_list.append(parse)

    return pool_list