Synnefo

## CYCLADES_DEFAULT_SERVER_NETWORKS setting contains a list of networks to

## connect a newly created server to, *if the user has not* specified them

## explicitly in the POST /server API call.

## Each member of the list may be a network UUID, a tuple of network UUIDs,

## "SNF:ANY_PUBLIC_IPV4" [any public network with an IPv4 subnet defined],

## "SNF:ANY_PUBLIC_IPV6 [any public network with only an IPV6 subnet defined],

##  or "SNF:ANY_PUBLIC" [any public network].

##

## Access control and quota policy are enforced, just as if the user had

## specified the value of CYCLADES_DEFAULT_SERVER_NETWORKS in the content

## of the POST /call, after processing of "SNF:*" directives."

#CYCLADES_DEFAULT_SERVER_NETWORKS = ["SNF:ANY_PUBLIC"]

#

## This setting contains a list of networks which every new server

## will be forced to connect to, regardless of the contents of the POST

## /servers call, or the value of CYCLADES_DEFAULT_SERVER_NETWORKS.

## Its format is identical to that of CYCLADES_DEFAULT_SERVER_NETWORKS.

#

## WARNING: No access control or quota policy are enforced.

## The server will get all IPv4/IPv6 addresses needed to connect to the

## networks specified in CYCLADES_FORCED_SERVER_NETWORKS, regardless

## of the state of the floating IP pool of the user, and without

## allocating any floating IPs."

#CYCLADES_FORCED_SERVER_NETWORKS = ["SNF:ANY_PUBLIC_IPV6"]

        floating_ips = \

            map(lambda x: common.get_floating_ip_by_id(x, for_update=True),

                floating_ip_ids)

        floating_ips = map(lambda fp: {"uuid": fp.network_id,

                                       "fixed_ip": fp.address},

                           floating_ips)

                                networks=(floating_ips+ports+networks),

        networks = server.get("networks")

        if networks is not None:

            assert isinstance(networks, list)

        # Create dummy public IPv6 network

        sub6 = mfactory.IPv6SubnetFactory(network__public=True)

        self.net6 = sub6.network

        self.network_settings = {

            "CYCLADES_DEFAULT_SERVER_NETWORKS": [],

            "CYCLADES_FORCED_SERVER_NETWORKS": ["SNF:ANY_PUBLIC_IPV6"]

        }

        with override_settings(settings, **self.network_settings):

    def test_create_server_no_flavor(self, mrapi):

        request["server"]["flavorRef"] = 42

        with override_settings(settings, **self.network_settings):

            with mocked_quotaholder():

                response = self.mypost('servers', 'test_user',

                                       json.dumps(request), 'json')

        self.assertItemNotFound(response)

    def test_create_server_error(self, mrapi):

        """Test if the create server call returns the expected response

           if a valid request has been speficied."""

        mrapi().CreateInstance.side_effect = GanetiApiError("..ganeti is down")

        request = self.request

        with override_settings(settings, **self.network_settings):

            with mocked_quotaholder():

                response = self.mypost('servers', 'test_user',

                                       json.dumps(request), 'json')

        mrapi().CreateInstance.assert_called_once()

        vm = VirtualMachine.objects.get()

        # The VM has not been deleted

        self.assertFalse(vm.deleted)

        # but is in "ERROR" operstate

        self.assertEqual(vm.operstate, "ERROR")

    def test_create_network_info(self, mrapi):

        s1 = mfactory.IPv4SubnetFactory(network__userid="test")

        s2 = mfactory.IPv6SubnetFactory(network__userid="test")

        # and a public IPv6

        request["server"]["networks"] = [{"uuid": s1.network_id},

                                         {"uuid": s2.network_id}]

        with override_settings(settings, **self.network_settings):

                response = self.mypost('servers', "test",

        self.assertEqual(kwargs["nics"][0]["network"], self.net6.backend_id)

        self.assertEqual(kwargs["nics"][1]["network"], s1.network.backend_id)

        self.assertEqual(kwargs["nics"][2]["network"], s2.network.backend_id)

        # but fail if others user network

        s3 = mfactory.IPv6SubnetFactory(network__userid="test_other")

        request["server"]["networks"] = [{"uuid": s3.network_id}]

        response = self.mypost('servers', "test", json.dumps(request), 'json')

        self.assertEqual(response.status_code, 404)

        # User requested public networks

        # but no floating IP..

        s1 = mfactory.IPv4SubnetFactory(network__public=True)

        request["server"]["networks"] = [{"uuid": s1.network_id}]

        response = self.mypost('servers', "test", json.dumps(request), 'json')

        self.assertEqual(response.status_code, 409)

        # Add one floating IP

        fp1 = mfactory.IPv4AddressFactory(userid="test", subnet=s1,

                                          network=s1.network,

                                          floating_ip=True, nic=None)

        self.assertEqual(fp1.nic, None)

        request["server"]["networks"] = [{"uuid": s1.network_id,

                                          "fixed_ip": fp1.address}]

        with mocked_quotaholder():

            with override_settings(settings, **self.network_settings):

                response = self.mypost('servers', "test",

        server_id = json.loads(response.content)["server"]["id"]

        fp1 = IPAddress.objects.get(id=fp1.id)

        self.assertEqual(fp1.nic.machine_id, server_id)

        # check used floating IP

        response = self.mypost('servers', "test", json.dumps(request), 'json')

        self.assertEqual(response.status_code, 409)

        # Add more floating IP. but check auto-reserve

        fp2 = mfactory.IPv4AddressFactory(userid="test", subnet=s1,

                                          network=s1.network,

                                          floating_ip=True, nic=None)

        self.assertEqual(fp2.nic, None)

        request["server"]["networks"] = [{"uuid": s1.network_id}]

            with override_settings(settings, **self.network_settings):

                response = self.mypost('servers', "test",

                                       json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202)

        server_id = json.loads(response.content)["server"]["id"]

        fp2 = IPAddress.objects.get(id=fp2.id)

        self.assertEqual(fp2.nic.machine_id, server_id)

        name, args, kwargs = mrapi().CreateInstance.mock_calls[-1]

        self.assertEqual(len(kwargs["nics"]), 2)

        self.assertEqual(kwargs["nics"][0]["network"], self.net6.backend_id)

        self.assertEqual(kwargs["nics"][1]["network"], fp2.network.backend_id)

    def test_create_network_settings(self, mrapi):

        mrapi().CreateInstance.return_value = 12

        # User requested private networks

        # no public IPv4

        network_settings = {

            "CYCLADES_DEFAULT_SERVER_NETWORKS": [],

            "CYCLADES_FORCED_SERVER_NETWORKS": ["SNF:ANY_PUBLIC_IPV4"]

        }

        with override_settings(settings, **network_settings):

            response = self.mypost('servers', "test", json.dumps(self.request),

                                   'json')

        self.assertEqual(response.status_code, 503)

        # no public IPv4, IPv6 exists

        network_settings = {

            "CYCLADES_DEFAULT_SERVER_NETWORKS": [],

            "CYCLADES_FORCED_SERVER_NETWORKS": ["SNF:ANY_PUBLIC"]

        }

        with override_settings(settings, **network_settings):

            response = self.mypost('servers', "test", json.dumps(self.request),

                                   'json')

        server_id = json.loads(response.content)["server"]["id"]

        vm = VirtualMachine.objects.get(id=server_id)

        self.assertEqual(vm.nics.get().ipv4_address, None)

        # IPv4 exists

        mfactory.IPv4SubnetFactory(network__public=True,

                                   cidr="192.168.2.0/24",

                                   pool__offset=2,

                                   pool__size=1)

        with override_settings(settings, **network_settings):

            response = self.mypost('servers', "test", json.dumps(self.request),

                                   'json')

        self.assertEqual(response.status_code, 202)

        server_id = json.loads(response.content)["server"]["id"]

        vm = VirtualMachine.objects.get(id=server_id)

        self.assertEqual(vm.nics.get().ipv4_address, "192.168.2.2")

        # Fixed networks

        net1 = mfactory.NetworkFactory(userid="test")

        net2 = mfactory.NetworkFactory(userid="test")

        net3 = mfactory.NetworkFactory(userid="test")

        network_settings = {

            "CYCLADES_DEFAULT_SERVER_NETWORKS": [],

            "CYCLADES_FORCED_SERVER_NETWORKS": [net1.id, [net2.id, net3.id],

                                                (net3.id, net2.id)]

        }

        with override_settings(settings, **network_settings):

            response = self.mypost('servers', "test", json.dumps(self.request),

                                   'json')

        self.assertEqual(response.status_code, 202)

        server_id = json.loads(response.content)["server"]["id"]

        vm = VirtualMachine.objects.get(id=server_id)

        self.assertEqual(len(vm.nics.all()), 3)

    def test_create_server_with_port(self, mrapi):

        mrapi().CreateInstance.return_value = 42

        ip = mfactory.IPv4AddressFactory(nic__machine=None)

        port1 = ip.nic

        request = deepcopy(self.request)

        request["server"]["networks"] = [{"port": port1.id}]

        with override_settings(settings, **self.network_settings):

            with mocked_quotaholder():

                response = self.mypost("servers", port1.userid,

                                       json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202)

        vm_id = json.loads(response.content)["server"]["id"]

        port1 = NetworkInterface.objects.get(id=port1.id)

        self.assertEqual(port1.machine_id, vm_id)

        # 409 if already used

        with override_settings(settings, **self.network_settings):

            with mocked_quotaholder():

                response = self.mypost("servers", port1.userid,

                                       json.dumps(request), 'json')

        self.assertConflict(response)

        # Test permissions

        ip = mfactory.IPv4AddressFactory(userid="user1", nic__userid="user1")

        port2 = ip.nic

        request["server"]["networks"] = [{"port": port2.id}]

        with override_settings(settings, **self.network_settings):

            with mocked_quotaholder():

                response = self.mypost("servers", "user2",

                                       json.dumps(request), 'json')

        self.assertEqual(response.status_code, 404)

# CYCLADES_DEFAULT_SERVER_NETWORKS setting contains a list of networks to

# connect a newly created server to, *if the user has not* specified them

# explicitly in the POST /server API call.

# Each member of the list may be a network UUID, a tuple of network UUIDs,

# "SNF:ANY_PUBLIC_IPV4" [any public network with an IPv4 subnet defined],

# "SNF:ANY_PUBLIC_IPV6 [any public network with only an IPV6 subnet defined],

#  or "SNF:ANY_PUBLIC" [any public network].

#

# Access control and quota policy are enforced, just as if the user had

# specified the value of CYCLADES_DEFAULT_SERVER_NETWORKS in the content

# of the POST /call, after processing of "SNF:*" directives."

CYCLADES_DEFAULT_SERVER_NETWORKS = ["SNF:ANY_PUBLIC"]

# This setting contains a list of networks which every new server

# will be forced to connect to, regardless of the contents of the POST

# /servers call, or the value of CYCLADES_DEFAULT_SERVER_NETWORKS.

# Its format is identical to that of CYCLADES_DEFAULT_SERVER_NETWORKS.

# WARNING: No access control or quota policy are enforced.

# The server will get all IPv4/IPv6 addresses needed to connect to the

# networks specified in CYCLADES_FORCED_SERVER_NETWORKS, regardless

# of the state of the floating IP pool of the user, and without

# allocating any floating IPs."

CYCLADES_FORCED_SERVER_NETWORKS = ["SNF:ANY_PUBLIC_IPV6"]

def allocate_public_ip(userid, floating_ip=False, backend=None, networks=None):

    if networks is not None:

        ip_pool_rows = ip_pool_rows.filter(subnet__network__in=networks)

        raise faults.Conflict(exception_msg)

def get_free_floating_ip(userid, network=None):

    """Get one of the free available floating IPs of the user.

    Get one of the users floating IPs that is not connected to any port

    or server. If network is specified, the floating IP must be from

    that network.

    """

    floating_ips = IPAddress.objects\

                            .filter(userid=userid, deleted=False, nic=None)

    if network is not None:

        floating_ips = floating_ips.filter(network=network)

    for floating_ip in floating_ips:

        floating_ip = IPAddress.objects.select_for_update()\

                                       .get(id=floating_ip.id)

        if floating_ip.nic is None:

            return floating_ip

    msg = "Cannot allocate a floating IP for connecting new server to"

    if network is not None:

        msg += " network '%s'." % network.id

    else:

        msg += " a public network."

    msg += " Please create more floating IPs."

    raise faults.Conflict(msg)

                               VirtualMachineMetadata, IPAddressLog, Network)

           personality=[], networks=None, use_backend=None):

    # Create the ports for the server

    try:

        ports = create_instance_ports(userid, networks)

    except Exception as e:

        raise e

    # Associate the ports with the server

    for index, port in enumerate(ports):

        associate_port_with_machine(port, vm)

        port.index = index

        port.save()

    vm = create_server(vm, ports, flavor, image, personality, password)

    when the job completes successfully. Deleting port that is connected to

    a public network is allowed only if the port has an associated floating IP

    address.

    if port.network.public and not port.ips.filter(floating_ip=True,

                                                   deleted=False).exists():

        raise faults.Forbidden("Can not disconnect from public network.")

def create_instance_ports(user_id, networks=None):

    # First connect the instance to the networks defined by the admin

    forced_ports = create_ports_for_setting(user_id, category="admin")

    if networks is None:

        # If the user did not asked for any networks, connect instance to

        # default networks as defined by the admin

        ports = create_ports_for_setting(user_id, category="default")

    else:

        # Else just connect to the networks that the user defined

        ports = create_ports_for_request(user_id, networks)

    return forced_ports + ports

def create_ports_for_setting(user_id, category):

    if category == "admin":

        network_setting = settings.CYCLADES_FORCED_SERVER_NETWORKS

    elif category == "default":

        network_setting = settings.CYCLADES_DEFAULT_SERVER_NETWORKS

    else:

        raise ValueError("Unknown category: %s" % category)

    ports = []

    for network_ids in network_setting:

        # Treat even simple network IDs as group of networks with one network

        if type(network_ids) not in (list, tuple):

            network_ids = [network_ids]

        for network_id in network_ids:

            try:

                ports.append(_port_from_setting(user_id, network_id, category))

                break

            except faults.Conflict:

                # Try all network IDs in the network group

                pass

            # Diffrent exception for each category!

            if category == "admin":

                exception = faults.ServiceUnavailable

            else:

                exception = faults.Conflict

            raise exception("Cannot connect instance to any of the following"

                            " networks %s" % network_ids)

    return ports

def _port_from_setting(user_id, network_id, category):

    # TODO: Fix this..you need only IPv4 and only IPv6 network

    if network_id == "SNF:ANY_PUBLIC_IPV4":

        return create_public_ipv4_port(user_id, category=category)

    elif network_id == "SNF:ANY_PUBLIC_IPV6":

        return create_public_ipv6_port(user_id, category=category)

    elif network_id == "SNF:ANY_PUBLIC":

        try:

            return create_public_ipv4_port(user_id, category=category)

        except faults.Conflict:

            return create_public_ipv6_port(user_id, category=category)

    else:  # Case of network ID

        if category in ["user", "default"]:

            return _port_for_request(user_id, {"uuid": network_id})

        elif category == "admin":

            network = util.get_network(network_id, user_id, non_deleted=True)

            return _create_port(user_id, network)

        else:

            raise ValueError("Unknown category: %s" % category)

def create_public_ipv4_port(user_id, network=None, address=None,

                            category="user"):

    """Create a port in a public IPv4 network.

    Create a port in a public IPv4 network (that may also have an IPv6

    subnet). If the category is 'user' or 'default' this will try to use

    one of the users floating IPs. If the category is 'admin' will

    create a port to the public network (without floating IPs or quotas).

    """

    if category in ["user", "default"]:

        if address is None:

            ipaddress = ips.get_free_floating_ip(user_id, network)

        else:

            ipaddress = util.get_floating_ip_by_address(user_id, address,

                                                        for_update=True)

    elif category == "admin":

        if network is None:

            ipaddress = ips.allocate_public_ip(user_id)

        else:

            ipaddress = ips.allocate_ip(network, user_id)

    else:

        raise ValueError("Unknown category: %s" % category)

    if network is None:

        network = ipaddress.network

    return _create_port(user_id, network, use_ipaddress=ipaddress)

def create_public_ipv6_port(user_id, category=None):

    """Create a port in a public IPv6 only network."""

    networks = Network.objects.filter(public=True, deleted=False,

                                      drained=False, subnets__ipversion=6)\

                              .exclude(subnets__ipversion=4)

    if networks:

        return _create_port(user_id, networks[0])

    else:

        msg = "No available IPv6 only network!"

        log.error(msg)

        raise faults.Conflict(msg)

def create_ports_for_request(user_id, networks):

    """Create the server ports requested by the user.

    Create the ports for the new servers as requested in the 'networks'

    attribute. The networks attribute contains either a list of network IDs

    ('uuid') or a list of ports IDs ('port'). In case of network IDs, the user

    can also specify an IPv4 address ('fixed_ip'). In order to connect to a

    public network, the 'fixed_ip' attribute must contain the IPv4 address of a

    floating IP. If the network is public but the 'fixed_ip' attribute is not

    specified, the system will automatically reserve one of the users floating

    IPs.

    """

    return [_port_for_request(user_id, network) for network in networks]

def _port_for_request(user_id, network_dict):

    port_id = network_dict.get("port")

    network_id = network_dict.get("uuid")

    if port_id is not None:

        return util.get_port(port_id, user_id, for_update=True)

    elif network_id is not None:

        address = network_dict.get("fixed_ip")

        network = util.get_network(network_id, user_id, non_deleted=True)

        if network.public:

            if network.subnet4 is not None:

                if not "fixed_ip" in network_dict:

                    return create_public_ipv4_port(user_id, network)

                elif address is None:

                    msg = "Cannot connect to public network"

                    raise faults.BadRequest(msg % network.id)

                else:

                    return create_public_ipv4_port(user_id, network, address)

            else:

                raise faults.Forbidden("Cannot connect to IPv6 only public"

                                       " network %" % network.id)

        else:

            return _create_port(user_id, network, address=address)

    else:

        raise faults.BadRequest("Network 'uuid' or 'port' attribute"

                                " is required.")

        mfactory.IPv4SubnetFactory(network__public=True)

        mfactory.IPv6SubnetFactory(network__public=True)

        mfactory.BackendFactory()

        self.assertEqual(len(vm.nics.all()), 2)