def test_get_network_list_returns_eos_compatible_data(self):
tenant = u'test-1'
segm_type = 'vlan'
network_id = u'123'
network2_id = u'1234'
vlan_id = 123
vlan2_id = 1234
expected_eos_net_list = {
network_id: {
u'networkId': network_id,
u'segmentationTypeId': vlan_id,
u'segmentationType': segm_type
},
network2_id: {
u'networkId': network2_id,
u'segmentationTypeId': vlan2_id,
u'segmentationType': segm_type
}
}
db_lib.remember_network(tenant, network_id, vlan_id)
db_lib.remember_network(tenant, network2_id, vlan2_id)
net_list = db_lib.get_networks(tenant)
self.assertNotEqual(net_list != expected_eos_net_list,
('%s != %s' % (net_list, expected_eos_net_list)))
def test_network_is_removed(self):
tenant_id = 'test'
network_id = '123'
db_lib.remember_network(tenant_id, network_id, '123')
db_lib.forget_network(tenant_id, network_id)
net_provisioned = db_lib.is_network_provisioned(tenant_id, network_id)
self.assertFalse(net_provisioned, 'The network should be deleted')
def test_network_is_remembered(self):
tenant_id = 'test'
network_id = '123'
segmentation_id = 456
db_lib.remember_network(tenant_id, network_id, segmentation_id)
net_provisioned = db_lib.is_network_provisioned(tenant_id, network_id)
self.assertTrue(net_provisioned, 'Network must be provisioned')
def test_network_is_removed(self):
tenant_id = 'test'
network_id = '123'
db_lib.remember_network(tenant_id, network_id, '123')
db_lib.forget_network(tenant_id, network_id)
net_provisioned = db_lib.is_network_provisioned(tenant_id, network_id)
self.assertFalse(net_provisioned, 'The network should be deleted')
def test_network_is_remembered(self):
tenant_id = 'test'
network_id = '123'
segmentation_id = 456
db_lib.remember_network(tenant_id, network_id, segmentation_id)
net_provisioned = db_lib.is_network_provisioned(tenant_id,
network_id)
self.assertTrue(net_provisioned, 'Network must be provisioned')
def test_remembers_multiple_networks(self):
tenant_id = 'test'
expected_num_nets = 100
nets = ['id%s' % n for n in range(expected_num_nets)]
for net_id in nets:
db_lib.remember_network(tenant_id, net_id, 123)
num_nets_provisioned = db_lib.num_nets_provisioned(tenant_id)
self.assertEqual(expected_num_nets, num_nets_provisioned,
'There should be %d nets, not %d' %
(expected_num_nets, num_nets_provisioned))
def test_remembers_multiple_networks(self):
tenant_id = 'test'
expected_num_nets = 100
nets = ['id%s' % n for n in range(expected_num_nets)]
for net_id in nets:
db_lib.remember_network(tenant_id, net_id, 123)
num_nets_provisioned = db_lib.num_nets_provisioned(tenant_id)
self.assertEqual(expected_num_nets, num_nets_provisioned,
'There should be %d nets, not %d' %
(expected_num_nets, num_nets_provisioned))
def create_network_precommit(self, context):
"""Remember the tenant, and network information."""
network = context.current
segments = context.network_segments
network_id = network['id']
tenant_id = network['tenant_id']
segmentation_id = segments[0]['segmentation_id']
with self.eos_sync_lock:
db_lib.remember_tenant(tenant_id)
db_lib.remember_network(tenant_id, network_id, segmentation_id)
def create_network_precommit(self, context):
"""Remember the tenant, and network information."""
network = context.current
segments = context.network_segments
network_id = network['id']
tenant_id = network['tenant_id']
segmentation_id = segments[0]['segmentation_id']
with self.eos_sync_lock:
db_lib.remember_tenant(tenant_id)
db_lib.remember_network(tenant_id,
network_id,
segmentation_id)
def test_cleanup_on_start(self):
"""Ensures that the driver cleans up the arista database on startup."""
ndb = db_lib.NeutronNets()
# Create some networks in neutron db
n1_context = self._get_network_context('t1', 'n1', 10)
ndb.create_network(n1_context, {'network': n1_context.current})
n2_context = self._get_network_context('t2', 'n2', 20)
ndb.create_network(n2_context, {'network': n2_context.current})
n3_context = self._get_network_context('', 'ha-network', 100)
ndb.create_network(n3_context, {'network': n3_context.current})
# Create some networks in Arista db
db_lib.remember_network('t1', 'n1', 10)
db_lib.remember_network('t2', 'n2', 20)
db_lib.remember_network('admin', 'ha-network', 100)
db_lib.remember_network('t3', 'n3', 30)
# Initialize the driver which should clean up the extra networks
self.drv.initialize()
adb_networks = db_lib.get_networks(tenant_id='any')
# 'n3' should now be deleted from the Arista DB
assert(set(('n1', 'n2', 'ha-network')) == set(adb_networks.keys()))
def test_removes_all_networks(self):
tenant_id = 'test'
num_nets = 100
old_nets = db_lib.num_nets_provisioned(tenant_id)
nets = ['id_%s' % n for n in range(num_nets)]
for net_id in nets:
db_lib.remember_network(tenant_id, net_id, 123)
for net_id in nets:
db_lib.forget_network(tenant_id, net_id)
num_nets_provisioned = db_lib.num_nets_provisioned(tenant_id)
expected = old_nets
self.assertEqual(
expected, num_nets_provisioned, 'There should be %d nets, not %d' %
(expected, num_nets_provisioned))
def test_removes_all_networks(self):
tenant_id = 'test'
num_nets = 100
old_nets = db_lib.num_nets_provisioned(tenant_id)
nets = ['id_%s' % n for n in range(num_nets)]
for net_id in nets:
db_lib.remember_network(tenant_id, net_id, 123)
for net_id in nets:
db_lib.forget_network(tenant_id, net_id)
num_nets_provisioned = db_lib.num_nets_provisioned(tenant_id)
expected = old_nets
self.assertEqual(expected, num_nets_provisioned,
'There should be %d nets, not %d' %
(expected, num_nets_provisioned))
def create_network_precommit(self, context):
"""Remember the tenant, and network information."""
network = context.current
segments = context.network_segments
if segments[0][driver_api.NETWORK_TYPE] != p_const.TYPE_VLAN:
# If network type is not VLAN, do nothing
return
network_id = network["id"]
tenant_id = network["tenant_id"]
if not tenant_id:
tenant_id = context._plugin_context.tenant_id
segmentation_id = segments[0]["segmentation_id"]
with self.eos_sync_lock:
db_lib.remember_tenant(tenant_id)
db_lib.remember_network(tenant_id, network_id, segmentation_id)
def create_network_precommit(self, context):
"""Remember the tenant, and network information."""
network = context.current
segments = context.network_segments
if segments[0][driver_api.NETWORK_TYPE] != p_const.TYPE_VLAN:
# If network type is not VLAN, do nothing
return
network_id = network['id']
tenant_id = network['tenant_id'] or INTERNAL_TENANT_ID
segmentation_id = segments[0]['segmentation_id']
with self.eos_sync_lock:
db_lib.remember_tenant(tenant_id)
db_lib.remember_network(tenant_id,
network_id,
segmentation_id)
def create_network_precommit(self, context):
"""Remember the tenant, and network information."""
network = context.current
segments = context.network_segments
if segments[0][driver_api.NETWORK_TYPE] != p_const.TYPE_VLAN:
# If network type is not VLAN, do nothing
return
network_id = network['id']
tenant_id = network['tenant_id']
if not tenant_id:
tenant_id = context._plugin_context.tenant_id
segmentation_id = segments[0]['segmentation_id']
with self.eos_sync_lock:
db_lib.remember_tenant(tenant_id)
db_lib.remember_network(tenant_id, network_id, segmentation_id)
def test_synchronize_required(self):
"""Tests whether synchronize() sends the right commands.
This test verifies a scenario when the sync is required.
"""
region_updated_time = {
'regionName': 'RegionOne',
'regionTimestamp': '12345'
}
self.rpc.get_region_updated_time.return_value = region_updated_time
self.sync_service._region_updated_time = {
'regionName': 'RegionOne',
'regionTimestamp': '0',
}
tenant_id = 'tenant-1'
network_id = 'net-1'
segmentation_id = 42
db_lib.remember_tenant(tenant_id)
db_lib.remember_network(tenant_id, network_id, segmentation_id)
self.rpc.get_tenants.return_value = {}
self.rpc.sync_start.return_value = True
self.rpc.sync_end.return_value = True
self.sync_service.do_synchronize()
expected_calls = [
mock.call.get_region_updated_time(),
mock.call.sync_start(),
mock.call.register_with_eos(sync=True),
mock.call.get_tenants(),
mock.call.create_network_bulk(
tenant_id,
[{'network_id': network_id,
'segmentation_id': segmentation_id,
'network_name': '',
'shared': False}],
sync=True),
mock.call.sync_end(),
mock.call.get_region_updated_time()
]
assert self.rpc.mock_calls == expected_calls
db_lib.forget_network(tenant_id, network_id)
db_lib.forget_tenant(tenant_id)
def test_get_network_list_returns_eos_compatible_data(self):
tenant = u'test-1'
segm_type = 'vlan'
network_id = u'123'
network2_id = u'1234'
vlan_id = 123
vlan2_id = 1234
expected_eos_net_list = {network_id: {u'networkId': network_id,
u'segmentationTypeId': vlan_id,
u'segmentationType': segm_type},
network2_id: {u'networkId': network2_id,
u'segmentationTypeId': vlan2_id,
u'segmentationType': segm_type}}
db_lib.remember_network(tenant, network_id, vlan_id)
db_lib.remember_network(tenant, network2_id, vlan2_id)
net_list = db_lib.get_networks(tenant)
self.assertNotEqual(net_list != expected_eos_net_list, ('%s != %s' %
(net_list, expected_eos_net_list)))
def test_synchronize_one_network(self):
"""Test to ensure that only the required resources are sent to EOS."""
# Store two tenants in a db and a single tenant in EOS.
# The sync should send details of the second tenant to EOS
tenant_1_id = 'tenant-1'
tenant_1_net_1_id = 'ten-1-net-1'
tenant_1_net_1_seg_id = 11
db_lib.remember_tenant(tenant_1_id)
db_lib.remember_network(tenant_1_id, tenant_1_net_1_id,
tenant_1_net_1_seg_id)
tenant_2_id = 'tenant-2'
tenant_2_net_1_id = 'ten-2-net-1'
tenant_2_net_1_seg_id = 21
db_lib.remember_tenant(tenant_2_id)
db_lib.remember_network(tenant_2_id, tenant_2_net_1_id,
tenant_2_net_1_seg_id)
self.rpc.get_tenants.return_value = {
tenant_1_id: {
'tenantVmInstances': {},
'tenantNetworks': {
tenant_1_net_1_id: {
'networkId': tenant_1_net_1_id,
'shared': False,
'networkName': 'Net1',
'segmenationType': 'vlan',
'segmentationTypeId': tenant_1_net_1_seg_id,
}
}
}
}
self.sync_service.do_synchronize()
expected_calls = [
mock.call.get_region_updated_time(),
mock.call._run_openstack_cmds(['sync start']),
mock.call.register_with_eos(),
mock.call.get_tenants(),
mock.call.create_network_bulk(tenant_2_id, [{
'network_id': tenant_2_net_1_id,
'segmentation_id': tenant_2_net_1_seg_id,
'network_name': '',
'shared': False
}]),
mock.call._run_openstack_cmds(['sync end']),
mock.call.get_region_updated_time()
]
self.assertTrue(
self.rpc.mock_calls == expected_calls, "Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
))
db_lib.forget_network(tenant_1_id, tenant_1_net_1_id)
db_lib.forget_network(tenant_2_id, tenant_2_net_1_id)
db_lib.forget_tenant(tenant_1_id)
db_lib.forget_tenant(tenant_2_id)
def test_synchronize_all_networks(self):
"""Test to ensure that only the required resources are sent to EOS."""
# Store two tenants in a db and none on EOS.
# The sync should send details of all tenants to EOS
tenant_1_id = u'tenant-1'
tenant_1_net_1_id = u'ten-1-net-1'
tenant_1_net_1_seg_id = 11
db_lib.remember_tenant(tenant_1_id)
db_lib.remember_network(tenant_1_id, tenant_1_net_1_id,
tenant_1_net_1_seg_id)
tenant_2_id = u'tenant-2'
tenant_2_net_1_id = u'ten-2-net-1'
tenant_2_net_1_seg_id = 21
db_lib.remember_tenant(tenant_2_id)
db_lib.remember_network(tenant_2_id, tenant_2_net_1_id,
tenant_2_net_1_seg_id)
self.rpc.get_tenants.return_value = {}
self.sync_service.do_synchronize()
expected_calls = [
mock.call.get_region_updated_time(),
mock.call._run_openstack_cmds(['sync start']),
mock.call.register_with_eos(),
mock.call.get_tenants(),
mock.call.create_network_bulk(
tenant_1_id,
[{'network_id': tenant_1_net_1_id,
'segmentation_id': tenant_1_net_1_seg_id,
'network_name': '',
'shared': False}]),
mock.call.create_network_bulk(
tenant_2_id,
[{'network_id': tenant_2_net_1_id,
'segmentation_id': tenant_2_net_1_seg_id,
'network_name': '',
'shared': False}]),
mock.call._run_openstack_cmds(['sync end']),
mock.call.get_region_updated_time()
]
# The create_network_bulk() can be called in different order. So split
# it up. The first part checks if the initial set of methods are
# invoked.
self.assertTrue(self.rpc.mock_calls[:4] == expected_calls[:4],
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
)
)
# Check if tenant 1 networks are created. It must be one of the two
# methods.
self.assertTrue(self.rpc.mock_calls[4] in expected_calls[4:6],
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
)
)
# Check if tenant 2 networks are created. It must be one of the two
# methods.
self.assertTrue(self.rpc.mock_calls[5] in expected_calls[4:6],
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
)
)
# Check if the sync end methods are invoked.
self.assertTrue(self.rpc.mock_calls[6:8] == expected_calls[6:8],
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
)
)
db_lib.forget_network(tenant_1_id, tenant_1_net_1_id)
db_lib.forget_network(tenant_2_id, tenant_2_net_1_id)
db_lib.forget_tenant(tenant_1_id)
db_lib.forget_tenant(tenant_2_id)
def test_synchronize_one_network(self):
"""Test to ensure that only the required resources are sent to EOS."""
# Store two tenants in a db and a single tenant in EOS.
# The sync should send details of the second tenant to EOS
tenant_1_id = 'tenant-1'
tenant_1_net_1_id = 'ten-1-net-1'
tenant_1_net_1_seg_id = 11
db_lib.remember_tenant(tenant_1_id)
db_lib.remember_network(tenant_1_id, tenant_1_net_1_id,
tenant_1_net_1_seg_id)
tenant_2_id = 'tenant-2'
tenant_2_net_1_id = 'ten-2-net-1'
tenant_2_net_1_seg_id = 21
db_lib.remember_tenant(tenant_2_id)
db_lib.remember_network(tenant_2_id, tenant_2_net_1_id,
tenant_2_net_1_seg_id)
self.rpc.get_tenants.return_value = {
tenant_1_id: {
'tenantVmInstances': {},
'tenantNetworks': {
tenant_1_net_1_id: {
'networkId': tenant_1_net_1_id,
'shared': False,
'networkName': 'Net1',
'segmenationType': 'vlan',
'segmentationTypeId': tenant_1_net_1_seg_id,
}
}
}
}
self.sync_service.do_synchronize()
expected_calls = [
mock.call.get_region_updated_time(),
mock.call._run_openstack_cmds(['sync start']),
mock.call.register_with_eos(),
mock.call.get_tenants(),
mock.call.create_network_bulk(
tenant_2_id,
[{'network_id': tenant_2_net_1_id,
'segmentation_id': tenant_2_net_1_seg_id,
'network_name': '',
'shared': False}]),
mock.call._run_openstack_cmds(['sync end']),
mock.call.get_region_updated_time()
]
self.assertTrue(self.rpc.mock_calls == expected_calls,
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
)
)
db_lib.forget_network(tenant_1_id, tenant_1_net_1_id)
db_lib.forget_network(tenant_2_id, tenant_2_net_1_id)
db_lib.forget_tenant(tenant_1_id)
db_lib.forget_tenant(tenant_2_id)
def test_synchronize_all_networks(self):
"""Test to ensure that only the required resources are sent to EOS."""
# Store two tenants in a db and none on EOS.
# The sync should send details of all tenants to EOS
tenant_1_id = u'tenant-1'
tenant_1_net_1_id = u'ten-1-net-1'
tenant_1_net_1_seg_id = 11
db_lib.remember_tenant(tenant_1_id)
db_lib.remember_network(tenant_1_id, tenant_1_net_1_id,
tenant_1_net_1_seg_id)
tenant_2_id = u'tenant-2'
tenant_2_net_1_id = u'ten-2-net-1'
tenant_2_net_1_seg_id = 21
db_lib.remember_tenant(tenant_2_id)
db_lib.remember_network(tenant_2_id, tenant_2_net_1_id,
tenant_2_net_1_seg_id)
self.rpc.get_tenants.return_value = {}
self.sync_service.do_synchronize()
expected_calls = [
mock.call.get_region_updated_time(),
mock.call._run_openstack_cmds(['sync start']),
mock.call.register_with_eos(),
mock.call.get_tenants(),
mock.call.create_network_bulk(tenant_1_id, [{
'network_id': tenant_1_net_1_id,
'segmentation_id': tenant_1_net_1_seg_id,
'network_name': '',
'shared': False
}]),
mock.call.create_network_bulk(tenant_2_id, [{
'network_id': tenant_2_net_1_id,
'segmentation_id': tenant_2_net_1_seg_id,
'network_name': '',
'shared': False
}]),
mock.call._run_openstack_cmds(['sync end']),
mock.call.get_region_updated_time()
]
# The create_network_bulk() can be called in different order. So split
# it up. The first part checks if the initial set of methods are
# invoked.
self.assertTrue(
self.rpc.mock_calls[:4] == expected_calls[:4],
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
))
# Check if tenant 1 networks are created. It must be one of the two
# methods.
self.assertTrue(
self.rpc.mock_calls[4] in expected_calls[4:6],
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
))
# Check if tenant 2 networks are created. It must be one of the two
# methods.
self.assertTrue(
self.rpc.mock_calls[5] in expected_calls[4:6],
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
))
# Check if the sync end methods are invoked.
self.assertTrue(
self.rpc.mock_calls[6:8] == expected_calls[6:8],
"Seen: %s\nExpected: %s" % (
self.rpc.mock_calls,
expected_calls,
))
db_lib.forget_network(tenant_1_id, tenant_1_net_1_id)
db_lib.forget_network(tenant_2_id, tenant_2_net_1_id)
db_lib.forget_tenant(tenant_1_id)
db_lib.forget_tenant(tenant_2_id)