def test_create_port_without_device(self):
net = dbmf.NetworkWithSubnetFactory(userid="test_user",
public=False,
subnet__cidr="192.168.2.0/24",
subnet__gateway=None,
subnet__pool__size=3,
subnet__pool__offset=1)
request = {
"port": {
"name": "port_with_address",
"network_id": str(net.id),
}
}
response = self.post(PORTS_URL,
params=json.dumps(request),
user="******")
self.assertEqual(response.status_code, 201)
new_port = json.loads(response.content)["port"]
self.assertEqual(new_port["device_id"], None)
# And with address
request["port"]["fixed_ips"] = [{"ip_address": "192.168.2.2"}]
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user="******")
self.assertEqual(response.status_code, 201)
new_port = json.loads(response.content)["port"]
self.assertEqual(new_port["device_id"], None)
self.assertEqual(new_port["fixed_ips"][0]["ip_address"], "192.168.2.2")
def test_ips(self, client):
network = mfactory.NetworkWithSubnetFactory(subnet__cidr='10.0.0.0/24',
subnet__gateway="10.0.0.1")
bn = mfactory.BackendNetworkFactory(network=network)
msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',
network=network.backend_id,
cluster=bn.backend.clustername,
status='success',
job_fields={"add_reserved_ips": ["10.0.0.10",
"10.0.0.20"]})
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
pool = network.get_ip_pools()[0]
self.assertTrue(pool.is_reserved('10.0.0.10'))
self.assertTrue(pool.is_reserved('10.0.0.20'))
pool.save()
# Check that they are not released
msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',
network=network.backend_id,
cluster=bn.backend.clustername,
job_fields={
"remove_reserved_ips": ["10.0.0.10",
"10.0.0.20"]})
update_network(client, msg)
pool = network.get_ip_pools()[0]
self.assertTrue(pool.is_reserved('10.0.0.10'))
self.assertTrue(pool.is_reserved('10.0.0.20'))
def test_reserve_no_pool(self):
# Network is not a floating IP pool
pool2 = mf.NetworkWithSubnetFactory(floating_ip_pool=False,
public=True,
subnet__cidr="192.168.2.0/24",
subnet__gateway="192.168.2.1")
request = {"floatingip": {'floating_network_id': pool2.id}}
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertConflict(response)
# Full network
net = mf.NetworkWithSubnetFactory(floating_ip_pool=True,
public=True,
subnet__cidr="192.168.2.0/31",
subnet__gateway="192.168.2.1",
subnet__pool__size=0)
request = {"floatingip": {'floating_network_id': net.id}}
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertConflict(response)
def test_reserve_ip(self):
net1 = mfact.NetworkWithSubnetFactory(subnet__cidr='192.168.2.0/24')
pool = net1.get_ip_pools()[0]
self.assertTrue(pool.is_available('192.168.2.12'))
net1.reserve_address('192.168.2.12')
pool = net1.get_ip_pools()[0]
self.assertFalse(pool.is_available('192.168.2.12'))
net1.release_address('192.168.2.12')
pool = net1.get_ip_pools()[0]
self.assertTrue(pool.is_available('192.168.2.12'))
def test_orphan_networks(self, mrapi):
net = mfactory.NetworkWithSubnetFactory(public=False,
action="CREATE",
deleted=True)
mrapi().GetNetworks.return_value = [{
"name": net.backend_id,
"group_list": [],
"network": net.subnet4.cidr,
"map": "....",
"external_reservations": ""
}]
self.reconciler.reconcile_networks()
mrapi().DeleteNetwork.assert_called_once_with(net.backend_id, [])
def test_stale_network(self, mrapi):
# Test that stale network will be deleted from DB, if network action is
# destroy
net1 = mfactory.NetworkWithSubnetFactory(public=False,
flavor="IP_LESS_ROUTED",
action="DESTROY",
deleted=False)
bn1 = mfactory.BackendNetworkFactory(network=net1,
backend=self.backend,
operstate="ACTIVE")
mrapi().GetNetworks.return_value = []
self.assertFalse(net1.deleted)
with mocked_quotaholder():
self.reconciler.reconcile_networks()
net1 = Network.objects.get(id=net1.id)
self.assertTrue(net1.deleted)
self.assertFalse(net1.backend_networks.filter(id=bn1.id).exists())
# But not if action is not DESTROY
net2 = mfactory.NetworkWithSubnetFactory(public=False, action="CREATE")
mfactory.BackendNetworkFactory(network=net2, backend=self.backend)
self.assertFalse(net2.deleted)
self.reconciler.reconcile_networks()
self.assertFalse(net2.deleted)
def test_unsynced_nics(self, mrapi):
network1 = mfactory.NetworkWithSubnetFactory(
subnet__cidr="10.0.0.0/24", subnet__gateway="10.0.0.2")
network2 = mfactory.NetworkWithSubnetFactory(
subnet__cidr="192.168.2.0/24", subnet__gateway="192.168.2.2")
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
operstate="STOPPED")
subnet = network1.subnets.get(ipversion=4)
ip = mfactory.IPv4AddressFactory(nic__machine=vm1,
network=network1,
subnet=subnet,
address="10.0.0.3")
nic = ip.nic
mrapi().GetInstances.return_value =\
[{"name": vm1.backend_vm_id,
"beparams": {"maxmem": 2048,
"minmem": 2048,
"vcpus": 4},
"oper_state": True,
"mtime": time(),
"disk.sizes": [],
"disk.names": [],
"disk.uuids": [],
"nic.names": [nic.backend_uuid],
"nic.ips": ["192.168.2.5"],
"nic.macs": ["aa:00:bb:cc:dd:ee"],
"nic.networks.names": [network2.backend_id],
"tags": []}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertEqual(vm1.operstate, "STARTED")
nic = vm1.nics.all()[0]
self.assertEqual(nic.network, network2)
self.assertEqual(nic.ipv4_address, "192.168.2.5")
self.assertEqual(nic.mac, "aa:00:bb:cc:dd:ee")
def test_unsynced_networks(self, mrapi):
net = mfactory.NetworkWithSubnetFactory(public=False,
state="PENDING",
action="CREATE",
deleted=False)
bn = mfactory.BackendNetworkFactory(network=net,
backend=self.backend,
operstate="PENDING")
mrapi().GetNetworks.return_value = [{
"name": net.backend_id,
"group_list": [],
"network": net.subnet4.cidr,
"map": "....",
"external_reservations": ""
}]
self.assertEqual(bn.operstate, "PENDING")
self.reconciler.reconcile_networks()
bn = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, "ACTIVE")
def test_create_port_with_address(self, mrapi):
"""Test creation if IP address is specified."""
mrapi().ModifyInstance.return_value = 42
vm = dbmf.VirtualMachineFactory()
net = dbmf.NetworkWithSubnetFactory(userid=vm.userid,
public=False,
subnet__cidr="192.168.2.0/24",
subnet__gateway=None,
subnet__pool__size=1,
subnet__pool__offset=1)
request = {
"port": {
"name": "port_with_address",
"network_id": str(net.id),
"device_id": str(vm.id),
"fixed_ips": [{
"ip_address": "192.168.2.1"
}]
}
}
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=vm.userid)
self.assertEqual(response.status_code, 201)
new_port_ip = json.loads(response.content)["port"]["fixed_ips"][0]
self.assertEqual(new_port_ip["ip_address"], "192.168.2.1")
# But 409 if address is already used
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=vm.userid)
self.assertConflict(response)
# And bad request if IPv6 address is specified
request["port"]["fixed_ips"][0]["ip_address"] = "babe::"
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=vm.userid)
self.assertBadRequest(response)
def test_parted_network(self, mrapi):
net1 = mfactory.NetworkWithSubnetFactory(public=False)
mrapi().GetNetworks.return_value = []
# Test nothing if Ganeti returns nothing
self.assertEqual(net1.backend_networks.count(), 0)
self.reconciler.reconcile_networks()
self.assertEqual(net1.backend_networks.count(), 0)
# Test creation if exists in Ganeti
self.assertEqual(net1.backend_networks.count(), 0)
mrapi().GetNetworks.return_value = [{
"name":
net1.backend_id,
"group_list": [["default", "bridged", "prv0", "1"]],
"network":
net1.subnet4.cidr,
"map":
"....",
"external_reservations":
""
}]
self.reconciler.reconcile_networks()
self.assertTrue(
net1.backend_networks.filter(backend=self.backend).exists())
def setUp(self):
self.pool = mf.NetworkWithSubnetFactory(floating_ip_pool=True,
public=True,
subnet__cidr="192.168.2.0/24",
subnet__gateway="192.168.2.1")
def setUp(self):
self.net = mfact.NetworkWithSubnetFactory()
def test_missing_network(self, mrapi):
net2 = mfactory.NetworkWithSubnetFactory(public=False, action="CREATE")
mfactory.BackendNetworkFactory(network=net2, backend=self.backend)
mrapi().GetNetworks.return_value = []
self.reconciler.reconcile_networks()
self.assertEqual(len(mrapi().CreateNetwork.mock_calls), 1)
