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_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, 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 setUp(self):
self.mac_prefixes = mfactory.MacPrefixPoolTableFactory()
self.bridges = mfactory.BridgePoolTableFactory(base="link")
self.user = '******'
self.net1 = mfactory.NetworkFactory(userid=self.user)
self.vm1 = mfactory.VirtualMachineFactory(userid=self.user)
self.nic1 = mfactory.NetworkInterfaceFactory(network=self.net1,
machine=self.vm1)
self.nic2 = mfactory.NetworkInterfaceFactory(network=self.net1,
machine=self.vm1)
self.net2 = mfactory.NetworkFactory(userid=self.user)
self.nic3 = mfactory.NetworkInterfaceFactory(network=self.net2)
super(NetworkAPITest, self).setUp()
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_create(self):
request = {
"network": {
"name": u"Funky Network\u2602",
"type": "MAC_FILTERED"
}
}
response = self.post(NETWORKS_URL, params=json.dumps(request))
code = response.status_code
self.assertEqual(code, 503) # No MAC prefix pool
dbmf.MacPrefixPoolTableFactory()
response = self.post(NETWORKS_URL, params=json.dumps(request))
code = response.status_code
self.assertEqual(code, 201)
res = json.loads(response.content)
self.assertEqual(res["network"]["name"], u"Funky Network\u2602")
# TEST QUOTAS!!!
name, args, kwargs =\
self.mocked_quotaholder.issue_one_commission.mock_calls[0]
commission_resources = args[1]
self.assertEqual(commission_resources,
{("user", "cyclades.network.private"): 1})
name, args, kwargs =\
self.mocked_quotaholder.resolve_commissions.mock_calls[0]
serial = QuotaHolderSerial.objects.order_by("-serial")[0]
accepted_serials = args[0]
rejected_serials = args[1]
self.assertEqual(accepted_serials, [serial.serial])
self.assertEqual(rejected_serials, [])
# test no name
request["network"].pop("name")
response = self.post(NETWORKS_URL, params=json.dumps(request))
code = response.status_code
self.assertEqual(code, 201)
res = json.loads(response.content)
self.assertEqual(res["network"]["name"], "")
def test_create(self):
kwargs = {
"name": "test",
"userid": "user",
"flavor": "CUSTOM",
}
# wrong flavor
kw = copy(kwargs)
kw["flavor"] = "UNKNOWN"
self.assertRaises(faults.BadRequest, networks.create, **kw)
# Test create objet
kwargs["public"] = True
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")
self.assertEqual(net.userid, "user")
# Test for each for flavor type
# MAC_FILTERED
kwargs["flavor"] = "MAC_FILTERED"
# Test exception if no rules exists
self.assertRaises(faults.ServiceUnavailable, networks.create, **kwargs)
mfactory.MacPrefixPoolTableFactory(base="aa:bb:0")
with mocked_quotaholder():
net = networks.create(**kwargs)
self.assertEqual(net.mode, "bridged")
self.assertEqual(net.mac_prefix, "aa:bb:1")
self.assertEqual(net.link, settings.DEFAULT_MAC_FILTERED_BRIDGE)
self.assertEqual(net.backend_tag, ["private-filtered"])
pool = MacPrefixPoolTable.get_pool()
self.assertFalse(pool.is_available("aa:bb:1"))
# PHYSICAL_VLAN
kwargs["flavor"] = "PHYSICAL_VLAN"
# Test exception if no rules exists
self.assertRaises(faults.ServiceUnavailable, networks.create, **kwargs)
mfactory.BridgePoolTableFactory(base="prv")
with mocked_quotaholder():
net = networks.create(**kwargs)
self.assertEqual(net.mode, "bridged")
self.assertEqual(net.mac_prefix, settings.DEFAULT_MAC_PREFIX)
self.assertEqual(net.link, "prv1")
self.assertEqual(net.backend_tag, ["physical-vlan"])
pool = BridgePoolTable.get_pool()
self.assertFalse(pool.is_available(net.link))
# IP_LESS_ROUTED
kwargs["flavor"] = "IP_LESS_ROUTED"
with mocked_quotaholder():
net = networks.create(**kwargs)
self.assertEqual(net.mode, "routed")
self.assertEqual(net.mac_prefix, settings.DEFAULT_MAC_PREFIX)
self.assertEqual(net.link, "%slink-%d" % (settings.BACKEND_PREFIX_ID,
net.id))
self.assertEqual(net.backend_tag, ["ip-less-routed"])
# CUSTOM
kwargs["flavor"] = "CUSTOM"
with mocked_quotaholder():
net = networks.create(**kwargs)
self.assertEqual(net.mode, "bridged")
self.assertEqual(net.mac_prefix, settings.DEFAULT_MAC_PREFIX)
self.assertEqual(net.link, settings.DEFAULT_BRIDGE)
self.assertEqual(net.backend_tag, [])