Synnefo

from synnefo.db.models import (Network, Backend, BackendNetwork,

                               pooled_rapi_client)

from synnefo.logic import networks

from synnefo.logic.backend import create_network, delete_network

HELP_MSG = """Modify a network.

This management command will only modify the state of the network in Cyclades

DB. The state of the network in the Ganeti backends will remain unchanged. You

should manually modify the network in all the backends, to synchronize the

state of DB and Ganeti.

The only exception is add_reserved_ips and remove_reserved_ips options, which

modify the IP pool in the Ganeti backends.

"""

    help = HELP_MSG

    output_transaction = True

            help="Set network's name"),

            help="Set the userid of the network owner"),

        make_option(

            '--subnet',

            dest='subnet',

            help="Set network's subnet"),

        make_option(

            '--gateway',

            dest='gateway',

            help="Set network's gateway"),

        make_option(

            '--subnet6',

            dest='subnet6',

            help="Set network's IPv6 subnet"),

            '--gateway6',

            dest='gateway6',

            help="Set network's IPv6 gateway"),

        make_option(

            '--dhcp',

            dest='dhcp',

            help="Set if network will use nfdhcp"),

        make_option(

            '--state',

            dest='state',

            metavar='STATE',

            help="Set network's state"),

        make_option(

            '--link',

            dest='link',

            help="Set the connectivity link"),

            '--mac-prefix',

            dest="mac_prefix",

            help="Set the MAC prefix"),

            "--drained",

            dest="drained",

            metavar="True|False",

            choices=["True", "False"],

            help="Set as drained to exclude for IP allocation."

                 " Only used for public networks."),

        make_option(

            help="Create a public network to a Ganeti backend."),

            help="Remove a public network from a Ganeti backend."),

        make_option(

            "--floating-ip-pool",

            dest="floating_ip_pool",

            metavar="True|False",

            choices=["True", "False"],

            help="Convert network to a floating IP pool. During this"

                 " conversation the network will be created to all"

                 " available Ganeti backends."),

        # Validate subnet

        subnet = options["subnet"] or network.subnet

        gateway = options["gateway"] or network.gateway

        subnet6 = options["subnet6"] or network.subnet6

        gateway6 = options["gateway6"] or network.gateway6

        networks.validate_network_params(subnet, gateway, subnet6, gateway6)

        # Validate state

        state = options.get('state')

        if state:

            allowed = [x[0] for x in Network.OPER_STATES]

            if state not in allowed:

                msg = "Invalid state, must be one of %s" % ', '.join(allowed)

                raise CommandError(msg)

            options["floating_ip_pool"] = floating_ip_pool

        if floating_ip_pool is False and network.floating_ip_pool is True:

            if network.floating_ips.filter(deleted=False).exists():

                msg = ("Can not make network a non floating IP pool. There are"

                       " still reserved floating IPs.")

                raise CommandError(msg)

        elif floating_ip_pool is True:

            existing =\

                network.backend_networks.filter(operstate="ACTIVE")\

                                        .values_list("backend", flat=True)

            for backend in Backend.objects.filter(offline=False)\

                                          .exclude(id__in=existing):

                check_link_availability(backend, network)

        dhcp = options.get("dhcp")

        if dhcp:

            options["dhcp"] = parse_bool(dhcp)

        drained = options.get("drained")

        if drained:

            options["drained"] = parse_bool(drained)

        fields = ('name', 'userid', 'subnet', 'gateway', 'subnet6', 'gateway6',

                  'dhcp', 'state', 'link', 'mac_prefix', 'drained',

                  'floating_ip_pool')

        for field in fields:

            value = options.get(field, None)

            if value is not None:

                network.__setattr__(field, value)

        network.save()

            for bnetwork in network.backend_networks.all():

        if floating_ip_pool is True:

            for backend in Backend.objects.filter(offline=False):

                try:

                    bnet = network.backend_networks.get(backend=backend)

                except BackendNetwork.DoesNotExist:

                    bnet = network.create_backend_network(backend=backend)

                if bnet.operstate != "ACTIVE":

                    create_network(network, backend, connect=True)

                    msg = "Sent job to create network '%s' in backend '%s'\n"

                    self.stdout.write(msg % (network, backend))

            create_network(network, backend, connect=True)

            delete_network(network, backend, disconnect=True)

def check_link_availability(backend, network):

    """Check if network link is available in backend."""

    with pooled_rapi_client(backend) as c:

        ganeti_networks = c.GetNetworks(bulk=True)

    name = network.backend_id

    mode = network.mode

    link = network.link

    for gnet in ganeti_networks:

        if (gnet["name"] != name and

            reduce(lambda x, y: x or y,

                   ["(%s, %s)" % (mode, link) in gnet["group_list"]],

                   False)):

           # Ganeti >= 2.7

           #(mode, link) in [(m, l) for (_, m, l) in gnet["group_list"]]):

            msg = "Can not create network '%s' in backend '%s'. Link '%s'" \

                  " is already used by network '%s" % \

                  (network, backend, link, gnet["name"])

            raise CommandError(msg)