def test_remove(self, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
bn = mfactory.BackendNetworkFactory(operstate='ACTIVE')
for old_state in ['success', 'canceled', 'error']:
for flavor in Network.FLAVORS.keys():
bn.operstate = old_state
bn.save()
net = bn.network
net.state = 'ACTIVE'
net.flavor = flavor
if flavor == 'PHYSICAL_VLAN':
net.link = allocate_resource('bridge')
if flavor == 'MAC_FILTERED':
net.mac_prefix = allocate_resource('mac_prefix')
net.save()
msg = self.create_msg(operation='OP_NETWORK_REMOVE',
network=net.backend_id,
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
self.assertFalse(BackendNetwork.objects.filter(id=bn.id)
.exists())
db_net = Network.objects.get(id=net.id)
self.assertEqual(db_net.state, 'DELETED', flavor)
self.assertTrue(db_net.deleted)
if flavor == 'PHYSICAL_VLAN':
pool = BridgePoolTable.get_pool()
self.assertTrue(pool.is_available(net.link))
if flavor == 'MAC_FILTERED':
pool = MacPrefixPoolTable.get_pool()
self.assertTrue(pool.is_available(net.mac_prefix))
def test_ips(self, client):
network = mfactory.NetworkFactory(subnet='10.0.0.0/24')
bn = mfactory.BackendNetworkFactory(network=network)
msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',
network=network.backend_id,
cluster=bn.backend.clustername,
status='success',
add_reserved_ips=['10.0.0.10', '10.0.0.20'],
remove_reserved_ips=[])
update_network(client, msg)
client.basic_ack.assert_called_once()
pool = network.get_pool()
self.assertTrue(pool.is_reserved('10.0.0.10'))
self.assertTrue(pool.is_reserved('10.0.0.20'))
pool.save()
# Release them
msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',
network=network.backend_id,
cluster=bn.backend.clustername,
add_reserved_ips=[],
remove_reserved_ips=['10.0.0.10', '10.0.0.20'])
update_network(client, msg)
client.basic_ack.assert_called_once()
pool = network.get_pool()
self.assertFalse(pool.is_reserved('10.0.0.10'))
self.assertFalse(pool.is_reserved('10.0.0.20'))
def test_error_opcode(self, rapi, client):
# Mock getting network, because code will lookup if network exists
# in backend
rapi().GetNetwork.return_value = {}
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
network = mfactory.NetworkFactory()
mfactory.BackendNetworkFactory(network=network,
operstate="ACTIVE")
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE",
network=network)
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
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_error_opcode(self, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE")
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
client.basic_ack.assert_called_once()
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
def test_ips(self, client):
network = mfactory.NetworkFactory(subnet='10.0.0.0/24')
bn = mfactory.BackendNetworkFactory(network=network)
msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',
network=network.backend_id,
cluster=bn.backend.clustername,
status='success',
add_reserved_ips=['10.0.0.10', '10.0.0.20'],
remove_reserved_ips=[])
update_network(client, msg)
client.basic_ack.assert_called_once()
pool = network.get_pool()
self.assertTrue(pool.is_reserved('10.0.0.10'))
self.assertTrue(pool.is_reserved('10.0.0.20'))
pool.save()
# Release them
msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',
network=network.backend_id,
cluster=bn.backend.clustername,
add_reserved_ips=[],
remove_reserved_ips=['10.0.0.10', '10.0.0.20'])
update_network(client, msg)
client.basic_ack.assert_called_once()
pool = network.get_pool()
self.assertFalse(pool.is_reserved('10.0.0.10'))
self.assertFalse(pool.is_reserved('10.0.0.20'))
def test_create(self, client):
back_network = mfactory.BackendNetworkFactory(operstate='PENDING')
net = back_network.network
net.state = 'ACTIVE'
net.save()
back1 = back_network.backend
back_network2 = mfactory.BackendNetworkFactory(operstate='PENDING',
network=net)
back2 = back_network2.backend
# Message from first backend network
msg = self.create_msg(operation='OP_NETWORK_CONNECT',
network=net.backend_id,
cluster=back1.clustername)
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
back_net = BackendNetwork.objects.get(id=back_network.id)
self.assertEqual(back_net.operstate, 'ACTIVE')
db_net = Network.objects.get(id=net.id)
self.assertEqual(db_net.state, 'ACTIVE')
# msg from second backend network
msg = self.create_msg(operation='OP_NETWORK_CONNECT',
network=net.backend_id,
cluster=back2.clustername)
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
db_net = Network.objects.get(id=net.id)
self.assertEqual(db_net.state, 'ACTIVE')
back_net = BackendNetwork.objects.get(id=back_network.id)
self.assertEqual(back_net.operstate, 'ACTIVE')
def test_error_opcode(self, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE")
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
client.basic_ack.assert_called_once()
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
def test_remove(self, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
bn = mfactory.BackendNetworkFactory(operstate='ACTIVE')
for old_state in ['success', 'canceled', 'error']:
for flavor in Network.FLAVORS.keys():
bn.operstate = old_state
bn.save()
net = bn.network
net.state = 'ACTIVE'
net.flavor = flavor
if flavor == 'PHYSICAL_VLAN':
net.link = allocate_resource('bridge')
if flavor == 'MAC_FILTERED':
net.mac_prefix = allocate_resource('mac_prefix')
net.save()
msg = self.create_msg(operation='OP_NETWORK_REMOVE',
network=net.backend_id,
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
self.assertFalse(BackendNetwork.objects.filter(id=bn.id)
.exists())
db_net = Network.objects.get(id=net.id)
self.assertEqual(db_net.state, 'DELETED', flavor)
self.assertTrue(db_net.deleted)
if flavor == 'PHYSICAL_VLAN':
pool = BridgePoolTable.get_pool()
self.assertTrue(pool.is_available(net.link))
if flavor == 'MAC_FILTERED':
pool = MacPrefixPoolTable.get_pool()
self.assertTrue(pool.is_available(net.mac_prefix))
def test_error_opcode(self, rapi, client):
# Mock getting network, because code will lookup if network exists
# in backend
rapi().GetNetwork.return_value = {}
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
network = mfactory.NetworkFactory()
mfactory.BackendNetworkFactory(network=network,
operstate="ACTIVE")
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE",
network=network)
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
def test_create(self, client):
back_network = mfactory.BackendNetworkFactory(operstate='PENDING')
net = back_network.network
net.state = 'ACTIVE'
net.save()
back1 = back_network.backend
back_network2 = mfactory.BackendNetworkFactory(operstate='PENDING',
network=net)
back2 = back_network2.backend
# Message from first backend network
msg = self.create_msg(operation='OP_NETWORK_CONNECT',
network=net.backend_id,
cluster=back1.clustername)
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
back_net = BackendNetwork.objects.get(id=back_network.id)
self.assertEqual(back_net.operstate, 'ACTIVE')
db_net = Network.objects.get(id=net.id)
self.assertEqual(db_net.state, 'ACTIVE')
# msg from second backend network
msg = self.create_msg(operation='OP_NETWORK_CONNECT',
network=net.backend_id,
cluster=back2.clustername)
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
db_net = Network.objects.get(id=net.id)
self.assertEqual(db_net.state, 'ACTIVE')
back_net = BackendNetwork.objects.get(id=back_network.id)
self.assertEqual(back_net.operstate, 'ACTIVE')
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)
#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'))
def test_create_offline_backend(self, client):
"""Test network creation when a backend is offline"""
net = mfactory.NetworkFactory(state='ACTIVE')
bn1 = mfactory.BackendNetworkFactory(network=net)
mfactory.BackendNetworkFactory(network=net, backend__offline=True)
msg = self.create_msg(operation='OP_NETWORK_CONNECT',
network=net.backend_id,
cluster=bn1.backend.clustername)
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
new_net = Network.objects.get(id=net.id)
self.assertEqual(new_net.state, 'ACTIVE')
def test_create_offline_backend(self, client):
"""Test network creation when a backend is offline"""
net = mfactory.NetworkFactory(state='ACTIVE')
bn1 = mfactory.BackendNetworkFactory(network=net)
mfactory.BackendNetworkFactory(network=net,
backend__offline=True)
msg = self.create_msg(operation='OP_NETWORK_CONNECT',
network=net.backend_id,
cluster=bn1.backend.clustername)
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
new_net = Network.objects.get(id=net.id)
self.assertEqual(new_net.state, 'ACTIVE')
def test_disconnect(self, client):
bn1 = mfactory.BackendNetworkFactory(operstate='ACTIVE')
net1 = bn1.network
net1.state = "ACTIVE"
net1.state = 'ACTIVE'
net1.save()
bn2 = mfactory.BackendNetworkFactory(operstate='ACTIVE', network=net1)
msg = self.create_msg(operation='OP_NETWORK_DISCONNECT',
network=net1.backend_id,
cluster=bn2.backend.clustername)
update_network(client, msg)
client.basic_ack.assert_called_once()
self.assertEqual(Network.objects.get(id=net1.id).state, 'ACTIVE')
self.assertEqual(
BackendNetwork.objects.get(id=bn2.id).operstate, 'PENDING')
def test_disconnect(self, client):
bn1 = mfactory.BackendNetworkFactory(operstate='ACTIVE')
net1 = bn1.network
net1.state = "ACTIVE"
net1.state = 'ACTIVE'
net1.save()
bn2 = mfactory.BackendNetworkFactory(operstate='ACTIVE',
network=net1)
msg = self.create_msg(operation='OP_NETWORK_DISCONNECT',
network=net1.backend_id,
cluster=bn2.backend.clustername)
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
self.assertEqual(Network.objects.get(id=net1.id).state, 'ACTIVE')
self.assertEqual(BackendNetwork.objects.get(id=bn2.id).operstate,
'PENDING')
def test_remove_error(self, rapi, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
bn = mfactory.BackendNetworkFactory(operstate='ACTIVE')
network = bn.network
msg = self.create_msg(operation='OP_NETWORK_REMOVE',
network=network.backend_id,
status="error",
cluster=bn.backend.clustername)
rapi().GetNetwork.return_value = {}
update_network(client, msg)
bn = BackendNetwork.objects.get(id=bn.id)
self.assertNotEqual(bn.operstate, "DELETED")
rapi().GetNetwork.side_effect = GanetiApiError(msg="foo", code=404)
with mocked_quotaholder():
update_network(client, msg)
self.assertFalse(BackendNetwork.objects.filter(id=bn.id) .exists())
def test_remove_error(self, rapi, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
bn = mfactory.BackendNetworkFactory(operstate='ACTIVE')
network = bn.network
msg = self.create_msg(operation='OP_NETWORK_REMOVE',
network=network.backend_id,
status="error",
cluster=bn.backend.clustername)
rapi().GetNetwork.return_value = {}
update_network(client, msg)
bn = BackendNetwork.objects.get(id=bn.id)
self.assertNotEqual(bn.operstate, "DELETED")
rapi().GetNetwork.side_effect = GanetiApiError(msg="foo", code=404)
with mocked_quotaholder():
update_network(client, msg)
self.assertFalse(BackendNetwork.objects.filter(id=bn.id) .exists())
def test_remove_offline_backend(self, client):
"""Test network removing when a backend is offline"""
mfactory.BridgePoolTableFactory()
net = mfactory.NetworkFactory(flavor='PHYSICAL_VLAN',
state='ACTIVE',
link='prv12')
bn1 = mfactory.BackendNetworkFactory(network=net)
mfactory.BackendNetworkFactory(network=net,
operstate="ACTIVE",
backend__offline=True)
msg = self.create_msg(operation='OP_NETWORK_REMOVE',
network=net.backend_id,
cluster=bn1.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
new_net = Network.objects.get(id=net.id)
self.assertEqual(new_net.state, 'ACTIVE')
self.assertFalse(new_net.deleted)
def test_remove_offline_backend(self, client):
"""Test network removing when a backend is offline"""
mfactory.BridgePoolTableFactory()
net = mfactory.NetworkFactory(flavor='PHYSICAL_VLAN',
state='ACTIVE',
link='prv12')
bn1 = mfactory.BackendNetworkFactory(network=net)
mfactory.BackendNetworkFactory(network=net,
operstate="ACTIVE",
backend__offline=True)
msg = self.create_msg(operation='OP_NETWORK_REMOVE',
network=net.backend_id,
cluster=bn1.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
new_net = Network.objects.get(id=net.id)
self.assertEqual(new_net.state, 'ACTIVE')
self.assertFalse(new_net.deleted)
def test_unhandled_exception(self, client):
update_network(client, {})
client.basic_reject.assert_called_once()
def test_missing_attribute(self, client):
update_network(client, json.dumps({'body': {}}))
client.basic_nack.assert_called_once()
def test_unhandled_exception(self, client):
update_network(client, {})
client.basic_reject.assert_called_once()
def test_wrong_type(self, client):
msg = self.create_msg(type="WRONG_TYPE")
update_network(client, msg)
client.basic_ack.assert_called_once()
def test_missing_attribute(self, client):
update_network(client, json.dumps({'body': {}}))
self.assertTrue(client.basic_reject.called)
def test_missing_attribute(self, client):
update_network(client, json.dumps({'body': {}}))
client.basic_nack.assert_called_once()
def test_missing_network(self, client):
msg = self.create_msg(operation='OP_NETWORK_CREATE',
network='foo')
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
def test_wrong_type(self, client):
msg = self.create_msg(type="WRONG_TYPE")
update_network(client, msg)
self.assertTrue(client.basic_nack.called)
def test_wrong_type(self, client):
msg = self.create_msg(type="WRONG_TYPE")
update_network(client, msg)
client.basic_ack.assert_called_once()
def test_missing_attribute(self, client):
update_network(client, json.dumps({'body': {}}))
self.assertTrue(client.basic_reject.called)
def test_wrong_type(self, client):
msg = self.create_msg(type="WRONG_TYPE")
update_network(client, msg)
self.assertTrue(client.basic_nack.called)
def test_missing_network(self, client):
msg = self.create_msg(operation='OP_NETWORK_CREATE',
network='foo')
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
