Synnefo

        pool.put(address)

        pool.save()

    class InvalidBackendIdError(Exception):

        def __init__(self, value):

            self.value = value

    dns_nameservers = fields.SeparatedValuesField('DNS Nameservers', null=True)

    def __unicode__(self):

    def get_pool(self, locked=True):

        if self.ipversion == 6:

    @property

    def ipv4_address(self):

class SecurityGroup(models.Model):

                                 models.Network.FLAVORS[a.flavor]['tags'])

    public = False

    deleted = False

class DeletedNetwork(NetworkFactory):

    size = 0

    FACTORY_FOR = models.Subnet

    network = factory.SubFactory(NetworkFactory, state="ACTIVE")

    name = factory.LazyAttribute(lambda self: random_string(30))

    dhcp = True

    dns_nameservers = []

    host_routes = []

    pool = factory.RelatedFactory(IPPoolTableFactory, 'subnet')

    ipversion = 6

    cidr = "2001:648:2ffc:1112::/64"

    gateway = None

class IPv4AddressFactory(factory.DjangoModelFactory):

    FACTORY_FOR = models.IPAddress

    network = factory.SubFactory(NetworkFactory)

    address =\

        factory.LazyAttributeSequence(lambda self, n: self.subnet.cidr[:-4] +

                                      '{0}'.format(int(n) + 2))

from datetime import datetime, timedelta

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

                               BackendNetwork, BACKEND_STATUSES,

                               pooled_rapi_client, VirtualMachineDiagnostic,

from synnefo.logic import utils

from synnefo import quotas

from synnefo.api.util import release_resource

# stale and removed from DB.

BUILDING_NIC_TIMEOUT = timedelta(seconds=180)

UNKNOWN_NIC_PREFIX = "unknown-"

                      " valid name." % ganeti_nic

                log.error(msg)

                continue

        elif not nics_are_equal(db_nic, ganeti_nic):

            # Special case where the IPv4 address has changed, because you

            # need to release the old IPv4 address and reserve the new one

                release_nic_address(db_nic)

            # Dummy update the network, to work with 'changed-since'

            db_nic.network.save()

        # Get the new nic info

        mac = gnic.get('mac')

        ipv4 = gnic.get('ip')

        firewall = gnic.get('firewall')

        firewall_profile = _reverse_tags.get(firewall)

            'index': index,

            'network': network,

            'mac': mac,

            'firewall_profile': firewall_profile,

            'state': 'ACTIVE'}

    """

        else:

@transaction.commit_on_success

    subnet6 = None

    gateway = None

    gateway6 = None

                tags.append('nfdhcpd')

    if network.public:

        conflicts_check = True

    nic = {'name': nic.backend_uuid,

           'network': network.backend_id,

    log.debug("Adding NIC %s to VM %s", nic, vm)

from snf_django.lib.api import faults

from synnefo.api import util

from synnefo import quotas

from synnefo.db.utils import validate_mac

from synnefo.db.pools import EmptyPool

from synnefo.logic import backend as backend_mod

    network = Network.objects.create(

        name=name,

        userid=user_id,

        flavor=flavor,

        mode=mode,

        link=link,

        action='CREATE',

        state='ACTIVE')

    # 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!

def format_db_nic(nic):

def format_gnt_nic(nic):

    nic_name, nic = nic

#

        raise faults.BuildInProgress('Network not active yet')

    address = None

    nic = NetworkInterface.objects.create(machine=vm, network=network,

                                          state="BUILDING")

    log.info("Connecting VM %s to Network %s. NIC: %s", vm, network, nic)

    return backend.connect_to_network(vm, nic)

from .utils_tests import *

from .rapi_pool_tests import *

from .reconciliation import *

    def test_remove(self, client):

        vm = mfactory.VirtualMachineFactory()

        # Also create a NIC

        msg = self.create_msg(operation='OP_INSTANCE_REMOVE',

                              instance=vm.backend_vm_id)

        with mocked_quotaholder():

        self.assertTrue(db_vm.deleted)

        # Check that nics are deleted

        self.assertFalse(db_vm.nics.all())

        vm2 = mfactory.VirtualMachineFactory()

        pool = network.get_pool()

        pool.save()

        msg = self.create_msg(operation='OP_INSTANCE_REMOVE',

                              instance=vm2.backend_vm_id)

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

        self.assertEqual(db_vm.operstate, 'DESTROYED')

        self.assertTrue(db_vm.deleted)

        pool = network.get_pool()

        # Test that floating ips are not released

    @patch("synnefo.logic.rapi_pool.GanetiRapiClient")

    def test_remove_error(self, rapi, client):

        for status in ["success", "error"]:

            msg = self.create_msg(operation='OP_INSTANCE_SET_PARAMS',

                                  instance=vm.backend_vm_id,

                                  status=status)

            client.reset_mock()

            with mocked_quotaholder():

        vm.operstate = "STOPPED"

        vm.save()

        for status in ["queued", "waiting", "running"]:

            msg = self.create_msg(operation='OP_INSTANCE_SET_PARAMS',

                                  instance=vm.backend_vm_id,

                                  status=status)

            client.reset_mock()

            update_db(client, msg)

        vm.save()

        f2 = mfactory.FlavorFactory(cpu=8, ram=2048, disk_template="drbd",

                                    disk=1024)

        msg = self.create_msg(operation='OP_INSTANCE_SET_PARAMS',

                              instance=vm.backend_vm_id,

                              status="success")

        client.reset_mock()

        with mocked_quotaholder():

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

        self.assertEqual(db_vm.operstate, "STOPPED")

        self.assertEqual(db_vm.flavor, f2)

        msg = self.create_msg(operation='OP_INSTANCE_SET_PARAMS',

                              instance=vm.backend_vm_id,

                              status="success")

        client.reset_mock()

        with mocked_quotaholder():

    def test_no_nics(self, client):

        vm = mfactory.VirtualMachineFactory(operstate='ERROR')

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

                              instance=vm.backend_vm_id)

        update_db(client, msg)

        self.assertTrue(client.basic_ack.called)

    def test_empty_nic(self, client):

        vm = mfactory.VirtualMachineFactory(operstate='ERROR')

        for public in [True, False]:

                                  instance=vm.backend_vm_id)

            update_db(client, msg)

            self.assertTrue(client.basic_ack.called)

            nics = db_vm.nics.all()

            self.assertEqual(len(nics), 1)

            self.assertEqual(nics[0].index, 0)

            self.assertEqual(nics[0].mac, None)

            if public:

                self.assertEqual(nics[0].firewall_profile,

    def test_full_nic(self, client):

        vm = mfactory.VirtualMachineFactory(operstate='ERROR')

        pool = net.get_pool()

        self.assertTrue(pool.is_available('10.0.0.22'))

        pool.save()

                              instance=vm.backend_vm_id)

        update_db(client, msg)

        self.assertTrue(client.basic_ack.called)

        nics = db_vm.nics.all()

        self.assertEqual(len(nics), 1)

        self.assertEqual(nics[0].index, 0)

        self.assertEqual(nics[0].mac, 'aa:bb:cc:00:11:22')

        pool = net.get_pool()

        self.assertFalse(pool.is_available('10.0.0.22'))

                self.assertEqual(bn.network.state, db_bnet.network.state)

    def test_ips(self, client):

        bn = mfactory.BackendNetworkFactory(network=network)

        msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',

                              network=network.backend_id,

                              cluster=bn.backend.clustername,

                              status='success',

        update_network(client, msg)

        self.assertTrue(client.basic_ack.called)

        pool = network.get_pool()

        self.assertTrue(pool.is_reserved('10.0.0.10'))

        self.assertTrue(pool.is_reserved('10.0.0.20'))

        pool.save()

        msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',

                              network=network.backend_id,

                              cluster=bn.backend.clustername,

        update_network(client, msg)

        pool = network.get_pool()

@patch('synnefo.lib.amqp.AMQPClient')

        kwargs["dhcp"] = False

        with mocked_quotaholder():

            net = networks.create(**kwargs)

        self.assertEqual(net.public, True)

        self.assertEqual(net.flavor, "CUSTOM")

        self.assertEqual(net.action, "CREATE")

        self.assertEqual(net.state, "ACTIVE")

        self.assertEqual(net.name, "test")

        kwargs["gateway6"] = "2001:648:2ffc:1112::1"

        with mocked_quotaholder():

            net = networks.create(**kwargs)

        self.assertRaises(Exception, net.get_pool)

        self.assertEqual(vm1.operstate, "STARTED")

    def test_unsynced_nics(self, mrapi):

        vm1 = mfactory.VirtualMachineFactory(backend=self.backend,

                                             deleted=False,

                                             operstate="STOPPED")

        mrapi().GetInstances.return_value =\

            [{"name": vm1.backend_vm_id,

             "beparams": {"maxmem": 2048,

        self.assertEqual(vm1.operstate, "STARTED")

        nic = vm1.nics.all()[0]

        self.assertEqual(nic.network, network2)

        self.assertEqual(nic.mac, "aa:00:bb:cc:dd:ee")

            fix=True)

    def test_parted_network(self, mrapi):

        mrapi().GetNetworks.return_value = []

        # Test nothing if Ganeti returns nothing

        self.assertEqual(net1.backend_networks.count(), 0)

                                             "group_list": [["default",

                                                             "bridged",

                                                             "prv0"]],

                                             "map": "....",

                                             "external_reservations": ""}]

        self.reconciler.reconcile_networks()

        self.assertFalse(net1.backend_networks

                             .filter(backend=self.backend).exists())

        # Test creation if network is a floating IP pool

        mrapi().GetNetworks.return_value = []

        self.assertEqual(net2.backend_networks.count(), 0)

        self.reconciler.reconcile_networks()

    def test_stale_network(self, mrapi):

        # Test that stale network will be deleted from DB, if network action is

        # destroy

        bn1 = mfactory.BackendNetworkFactory(network=net1,

                                             backend=self.backend,

                                             operstate="ACTIVE")

        self.assertEqual(bn1.operstate, "DELETED")

        self.assertTrue(net1.deleted)

        # But not if action is not DESTROY

        mfactory.BackendNetworkFactory(network=net2, backend=self.backend)

        self.assertFalse(net2.deleted)

        self.reconciler.reconcile_networks()

        self.assertFalse(net2.deleted)

    def test_missing_network(self, mrapi):

        mfactory.BackendNetworkFactory(network=net2, backend=self.backend)

        mrapi().GetNetworks.return_value = []

        self.reconciler.reconcile_networks()

    #    pass

    def test_unsynced_networks(self, mrapi):

        bn = mfactory.BackendNetworkFactory(network=net, backend=self.backend,

                                            operstate="PENDING")

        mrapi().GetNetworks.return_value = [{"name": net.backend_id,

                                             "group_list": [],

                                             "map": "....",

                                             "external_reservations": ""}]

        self.assertEqual(bn.operstate, "PENDING")

        self.assertEqual(bn.operstate, "ACTIVE")

    def test_orphan_networks(self, mrapi):

        mrapi().GetNetworks.return_value = [{"name": net.backend_id,

                                             "group_list": [],

                                             "map": "....",

                                             "external_reservations": ""}]

        self.reconciler.reconcile_networks()

        self.assertRaises(faults.ServiceUnavailable, servers.create, **kwargs)

        self.assertEqual(models.VirtualMachine.objects.count(), 0)

        # error in nics

        req = deepcopy(kwargs)

        self.assertEqual(vm.task, "BUILD")

        # test connect in IPv6 only network

        mfactory.BackendNetworkFactory(network=net)

        with override_settings(settings,

                               DEFAULT_INSTANCE_NETWORKS=[str(net.id)]):

                vm = servers.create(**kwargs)

        nics = vm.nics.all()

        self.assertEqual(len(nics), 1)

        args, kwargs = mrapi().CreateInstance.call_args

        ganeti_nic = kwargs["nics"][0]

        self.assertEqual(ganeti_nic["ip"], None)

class ServerTest(TransactionTestCase):

    def test_connect_network(self, mrapi):

        # Common connect

        vm = mfactory.VirtualMachineFactory(operstate="STARTED")

        mfactory.BackendNetworkFactory(network=net, backend=vm.backend)

        mrapi().ModifyInstance.return_value = 42

        self.assertEqual(nics[2]["ip"], "192.168.2.2")

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

        vm = mfactory.VirtualMachineFactory(operstate="STARTED")

        mfactory.BackendNetworkFactory(network=net, backend=vm.backend)

        servers.connect(vm, net)

        pool = net.get_pool(locked=False)

        # Test connect to IPv6 only network

        vm = mfactory.VirtualMachineFactory(operstate="STARTED")

        mfactory.BackendNetworkFactory(network=net, backend=vm.backend)

        servers.connect(vm, net)

        args, kwargs = mrapi().ModifyInstance.call_args