def main(): """Useful to run this from the command line so we can see the input and output of the translation when debugging. """ mock_factory = mox.Mox() neutron_client = mock_factory.CreateMock( neutronclient.v2_0.client.Client) neutron_client.list_networks().InAnyOrder(1).AndReturn(network1) neutron_client.list_ports().InAnyOrder(1).AndReturn(port_response) neutron_client.list_routers().InAnyOrder(1).AndReturn(router_response) neutron_client.list_security_groups().InAnyOrder(1).AndReturn( security_group_response) neutron_client.list_networks().InAnyOrder(2).AndReturn(network2) neutron_client.list_ports().InAnyOrder(2).AndReturn(port_response) neutron_client.list_routers().InAnyOrder(2).AndReturn(router_response) neutron_client.list_security_groups().InAnyOrder(2).AndReturn( security_group_response) mock_factory.ReplayAll() args = helper.datasource_openstack_args() args['poll_time'] = 0 args['client'] = neutron_client driver = NeutronDriver(name="testneutron", args=args) driver.update_from_datasource() print "Original api data" print str(driver.raw_state) print "Resulting state" print str(driver.state) driver.update_from_datasource() print "Original api data" print str(driver.raw_state) print "Resulting state" print str(driver.state)
def setUp(self): self.neutron_client = mock.MagicMock() self.network = network_response self.ports = port_response self.neutron_client.list_networks.return_value = self.network self.neutron_client.list_ports.return_value = self.ports self.driver = NeutronDriver(poll_time=0)
def setUp(self): super(TestNeutronDriver, self).setUp() self.neutron_client = mock.MagicMock() self.neutron_client.list_networks.return_value = network_response self.neutron_client.list_ports.return_value = port_response self.neutron_client.list_routers.return_value = router_response self.neutron_client.list_security_groups.return_value = \ security_group_response args = helper.datasource_openstack_args() args['poll_time'] = 0 self.driver = NeutronDriver(args=args)
def create_network_group(tablename): """Return rule of the form TABLENAME(x) :- neutron:network(..., x, ...) """ network_key_to_index = NeutronDriver.get_column_map( NeutronDriver.NETWORKS) network_id_index = network_key_to_index['id'] network_max_index = max(network_key_to_index.values()) net_args = ['x' + str(i) for i in xrange(0, network_max_index + 1)] formula = compile.parse1( '{}({}) :- neutron:networks({})'.format( tablename, 'x' + str(network_id_index), ",".join(net_args))) return formula
def create_network_group(tablename, full_neutron_tablename=None): if full_neutron_tablename is None: full_neutron_tablename = 'neutron:networks' network_key_to_index = NeutronDriver.network_key_position_map() network_id_index = network_key_to_index['id'] network_max_index = max(network_key_to_index.values()) network_args = ['x' + str(i) for i in xrange(0, network_max_index + 1)] formula = compile.parse1( '{}({}) :- {}({})'.format( tablename, 'x' + str(network_id_index), full_neutron_tablename, ",".join(network_args))) return formula
def create_networkXnetwork_group(tablename): network_key_to_index = NeutronDriver.get_column_map( NeutronDriver.NETWORKS) network_id_index = network_key_to_index['id'] network_max_index = max(network_key_to_index.values()) net1_args = ['x' + str(i) for i in xrange(0, network_max_index + 1)] net2_args = ['y' + str(i) for i in xrange(0, network_max_index + 1)] formula = compile.parse1( '{}({},{}) :- neutron:networks({}), neutron2:networks({})'.format( tablename, 'x' + str(network_id_index), 'y' + str(network_id_index), ",".join(net1_args), ",".join(net2_args))) return formula
def setUp(self): """Setup polling tests.""" super(TestDataSourceDriver, self).setUp() cage = d6cage.d6Cage() # so that we exit once test finishes; all other threads are forced # to be daemons cage.daemon = True cage.start() # Create mock of Neutron client so we can control data mock_factory = mox.Mox() neutron_client = mock_factory.CreateMock( neutronclient.v2_0.client.Client) neutron_client.list_networks().InAnyOrder(1).AndReturn(network1) neutron_client.list_ports().InAnyOrder(1).AndReturn(port_response) neutron_client.list_routers().InAnyOrder(1).AndReturn(router_response) neutron_client.list_security_groups().InAnyOrder(1).AndReturn( security_group_response) neutron_client.list_networks().InAnyOrder(2).AndReturn(network2) neutron_client.list_ports().InAnyOrder(2).AndReturn(port_response) neutron_client.list_routers().InAnyOrder(2).AndReturn(router_response) neutron_client.list_security_groups().InAnyOrder(2).AndReturn( security_group_response) mock_factory.ReplayAll() # Create modules (without auto-polling) cage.loadModule("NeutronDriver", helper.data_module_path("neutron_driver.py")) cage.loadModule("PolicyDriver", helper.policy_module_path()) cage.createservice(name="policy", moduleName="PolicyDriver", args={'d6cage': cage, 'rootdir': helper.data_module_path('')}) args = helper.datasource_openstack_args() args['poll_time'] = 0 args['client'] = neutron_client cage.createservice(name="neutron", moduleName="NeutronDriver", args=args) policy = cage.service_object('policy') policy.debug_mode() # insert rule into policy to make testing easier. # (Some of the IDs are auto-generated each time we convert) policy.insert(create_network_group('p')) # create some garbage data network_key_to_index = NeutronDriver.get_column_map( NeutronDriver.NETWORKS) network_max_index = max(network_key_to_index.values()) args1 = ['1'] * (network_max_index + 1) args2 = ['2'] * (network_max_index + 1) args1 = ",".join(args1) args2 = ",".join(args2) fake_networks = [ 'neutron:networks({})'.format(args1), 'neutron:networks({})'.format(args2)] # answer to query above for network1 datalog1 = \ ('p("240ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("340ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("440ff9df-df35-43ae-9df5-27fae87f2492")') # answer to query above for network2 datalog2 = \ ('p("240ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("640ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("540ff9df-df35-43ae-9df5-27fae87f2492")') # return value self.info = {} self.info['cage'] = cage self.info['datalog1'] = datalog1 self.info['datalog2'] = datalog2 self.info['fake_networks'] = fake_networks
class TestNeutronDriver(base.TestCase): def setUp(self): super(TestNeutronDriver, self).setUp() self.neutron_client = mock.MagicMock() self.neutron_client.list_networks.return_value = network_response self.neutron_client.list_ports.return_value = port_response self.neutron_client.list_routers.return_value = router_response self.neutron_client.list_security_groups.return_value = \ security_group_response args = helper.datasource_openstack_args() args['poll_time'] = 0 self.driver = NeutronDriver(args=args) def test_list_networks(self): """Test conversion of complex network objects to tables.""" network_list = self.neutron_client.list_networks() self.driver._translate_networks(network_list) network_tuples = self.driver.state[self.driver.NETWORKS] network_subnet_tuples = self.driver.state[ self.driver.NETWORKS_SUBNETS] # size of networks/subnets self.assertIsNotNone(network_tuples) self.assertEquals(1, len(network_tuples)) self.assertEquals(1, len(network_subnet_tuples)) # properties of first network key_to_index = self.driver.get_column_map( self.driver.NETWORKS) network_tuple = network_tuples.pop() subnet_tuple_guid = network_tuple[key_to_index['subnets']] name = network_tuple[key_to_index['name']] status = network_tuple[key_to_index['status']] provider_physical_network = \ network_tuple[key_to_index['provider:physical_network']] admin_state_up = network_tuple[key_to_index['admin_state_up']] tenant_id = network_tuple[key_to_index['tenant_id']] provider_network_type = \ network_tuple[key_to_index['provider:network_type']] router_external = network_tuple[key_to_index['router:external']] shared = network_tuple[key_to_index['shared']] id = network_tuple[key_to_index['id']] provider_segmentation_id = \ network_tuple[key_to_index['provider:segmentation_id']] # properties of first subnet network_subnet_tuple = network_subnet_tuples.pop() guid_key = network_subnet_tuple[0] guid_value = network_subnet_tuple[1] # tests for network/subnet self.assertEquals('ACTIVE', status) self.assertIsNotNone(subnet_tuple_guid) self.assertEqual(guid_key, subnet_tuple_guid) self.assertEqual('4cef03d0-1d02-40bb-8c99-2f442aac6ab0', guid_value) self.assertEquals('test-network', name) self.assertEquals('None', provider_physical_network) self.assertEquals('True', admin_state_up) self.assertEquals('570fe78a1dc54cffa053bd802984ede2', tenant_id) self.assertEquals('gre', provider_network_type) self.assertEquals('False', router_external) self.assertEquals('False', shared) self.assertEquals('240ff9df-df35-43ae-9df5-27fae87f2492', id) self.assertEquals(4, provider_segmentation_id) def test_list_ports(self): """Test conversion of complex port objects to tuples.""" # setup self.driver._translate_ports(self.neutron_client.list_ports()) d = self.driver.get_column_map(self.driver.PORTS) # number of ports ports = self.driver.state[self.driver.PORTS] self.assertIsNotNone(ports) self.assertEquals(1, len(ports)) # simple properties of a port port = ports.pop() self.assertEqual('ACTIVE', port[d['status']]) self.assertEqual('havana', port[d['binding:host_id']]) self.assertEqual('', port[d['name']]) self.assertEqual('True', port[d['admin_state_up']]) self.assertEqual('240ff9df-df35-43ae-9df5-27fae87f2492', port[d['network_id']]) self.assertEqual('570fe78a1dc54cffa053bd802984ede2', port[d['tenant_id']]) self.assertEqual('ovs', port[d['binding:vif_type']]) self.assertEqual('network:router_interface', port[d['device_owner']]) self.assertEqual('fa:16:3e:ab:90:df', port[d['mac_address']]) self.assertEqual('0a2ce569-85a8-45ec-abb3-0d4b34ff69ba', port[d['id']]) self.assertEqual('864e4acf-bf8e-4664-8cf7-ad5daa95681e', port[d['device_id']]) # complex property: allowed_address_pairs # TODO(thinrichs): add representative allowed_address_pairs address_pairs = self.driver.state[ self.driver.PORTS_ADDR_PAIRS] self.assertEqual(0, len(address_pairs)) # complex property: extra_dhcp_opts # TODO(thinrichs): add representative port_extra_dhcp_opts dhcp_opts = self.driver.state[ self.driver.PORTS_EXTRA_DHCP_OPTS] self.assertEqual(0, len(dhcp_opts)) # complex property: binding:capabilities binding_caps = self.driver.state[ self.driver.PORTS_BINDING_CAPABILITIES] cap_id = port[d['binding:capabilities']] self.assertEqual(1, len(binding_caps)) self.assertEqual((cap_id, 'port_filter', 'True'), binding_caps.pop()) # complex property: security_groups sec_grps = self.driver.state[self.driver.PORTS_SECURITY_GROUPS] self.assertEqual(2, len(sec_grps)) security_grp_grp = port[d['security_groups']] security_grp1 = '15ea0516-11ec-46e9-9e8e-7d1b6e3d7523' security_grp2 = '25ea0516-11ec-46e9-9e8e-7d1b6e3d7523' security_data = set([(security_grp_grp, security_grp1), (security_grp_grp, security_grp2)]) self.assertEqual(security_data, set(sec_grps)) # complex property: fixed_ips # Need to show we have the following # port(..., <fixed_ips>, ...) # fixed_ips_groups(<fixed_ips>, <fip1>) # fixed_ips_groups(<fixed_ips>, <fip2>) # fixedips(<fip1>, "subnet_id", "4cef03d0-1d02-40bb-8c99-2f442aac6ab0") # fixedips(<fip1>, "ip_address", "90.0.0.1") # fixedips(<fip2>, "subnet_id", "5cef03d0-1d02-40bb-8c99-2f442aac6ab0") # fixedips(<fip2>, "ip_address", "100.0.0.1") # TODO(thinrichs): use functionality of policy-engine # to make this test simpler to understand/write fixed_ip_groups = self.driver.state[ self.driver.PORTS_FIXED_IPS_GROUPS] fixed_ips = self.driver.state[self.driver.PORTS_FIXED_IPS] fixed_ip_grp = port[d['fixed_ips']] # ensure groups of IPs are correct self.assertEqual(2, len(fixed_ip_groups)) groups = set([x[0] for x in fixed_ip_groups]) self.assertEqual(set([fixed_ip_grp]), groups) # ensure the IDs for fixed_ips are the right ones fixed_ips_from_grp = [x[1] for x in fixed_ip_groups] fixed_ips_from_ips = [x[0] for x in fixed_ips] self.assertEqual(set(fixed_ips_from_grp), set(fixed_ips_from_ips)) # ensure actual fixed_ips are right self.assertEqual(4, len(fixed_ips)) ips = [x for x in fixed_ips if x[1] == 'ip_address'] subnets = [x for x in fixed_ips if x[1] == 'subnet_id'] if ips[0][0] == subnets[0][0]: ip0 = ips[0][2] subnet0 = subnets[0][2] ip1 = ips[1][2] subnet1 = subnets[1][2] else: ip0 = ips[0][2] subnet0 = subnets[1][2] ip1 = ips[1][2] subnet1 = subnets[0][2] if ip0 == "90.0.0.1": self.assertEqual("4cef03d0-1d02-40bb-8c99-2f442aac6ab0", subnet0) self.assertEqual("90.0.0.1", ip0) self.assertEqual("5cef03d0-1d02-40bb-8c99-2f442aac6ab0", subnet1) self.assertEqual("100.0.0.1", ip1) else: self.assertEqual("4cef03d0-1d02-40bb-8c99-2f442aac6ab0", subnet1) self.assertEqual("90.0.0.1", ip1) self.assertEqual("5cef03d0-1d02-40bb-8c99-2f442aac6ab0", subnet0) self.assertEqual("100.0.0.1", ip0) def test_list_routers(self): self.driver._translate_routers(self.neutron_client.list_routers()) d = self.driver.get_column_map(self.driver.ROUTERS) # number of routers routers = self.driver.state[self.driver.ROUTERS] self.assertIsNotNone(routers) self.assertEquals(1, len(routers)) # simple properties of a router router = routers.pop() self.assertEqual('ACTIVE', router[d['status']]) self.assertEqual('router1', router[d['name']]) self.assertEqual('True', router[d['admin_state_up']]) self.assertEqual('abb53cc6636848218f46d01f22bf1060', router[d['tenant_id']]) self.assertEqual('4598c424-d608-4366-9beb-139adbd7cff5', router[d['id']]) # external gateway info gateway_info = self.driver.state[ self.driver.ROUTERS_EXTERNAL_GATEWAYS] gateway_id = router[d['external_gateway_info']] self.assertEqual(2, len(gateway_info)) row1 = (gateway_id, 'network_id', 'a821b8d3-af1f-4d79-9b8e-3da9674338ae') row2 = (gateway_id, 'enable_snat', 'True') self.assertEqual(set([row1, row2]), gateway_info) def test_list_security_groups(self): self.driver._translate_security_groups( self.neutron_client.list_security_groups()) d = self.driver.get_column_map(self.driver.SECURITY_GROUPS) # number of security groups sec_grps = self.driver.state[self.driver.SECURITY_GROUPS] self.assertIsNotNone(sec_grps) self.assertEquals(1, len(sec_grps)) # simple properties sec_grp = sec_grps.pop() self.assertEqual('abb53cc6636848218f46d01f22bf1060', sec_grp[d['tenant_id']]) self.assertEqual('default', sec_grp[d['name']]) self.assertEqual('default', sec_grp[d['description']]) self.assertEqual('9f3860a5-87b1-499c-bf93-5ca3ef247517', sec_grp[d['id']])
class TestNeutronDriver(unittest.TestCase): def setUp(self): self.neutron_client = mock.MagicMock() self.network = network_response self.ports = port_response self.neutron_client.list_networks.return_value = self.network self.neutron_client.list_ports.return_value = self.ports self.driver = NeutronDriver(poll_time=0) def test_list_networks(self): """Test conversion of complex network objects to tables.""" network_list = self.neutron_client.list_networks() network_tuple_list = \ self.driver._get_tuple_list(network_list, self.driver.NEUTRON_NETWORKS) network_tuple = network_tuple_list[0] network_subnet_tuples = self.driver.network_subnet self.assertIsNotNone(network_tuple_list) self.assertEquals(1, len(network_tuple_list)) self.assertEquals(1, len(network_subnet_tuples)) key_to_index = self.driver.network_key_position_map() logging.info("key_to_index: " + str(key_to_index)) logging.info("network: " + str(network_tuple)) subnet_tuple_guid = network_tuple[key_to_index['subnets']] guid_key = network_subnet_tuples[0][0] guid_value = network_subnet_tuples[0][1] name = network_tuple[key_to_index['name']] status = network_tuple[key_to_index['status']] provider_physical_network = \ network_tuple[key_to_index['provider:physical_network']] admin_state_up = network_tuple[key_to_index['admin_state_up']] tenant_id = network_tuple[key_to_index['tenant_id']] provider_network_type = \ network_tuple[key_to_index['provider:network_type']] router_external = network_tuple[key_to_index['router:external']] shared = network_tuple[key_to_index['shared']] id = network_tuple[key_to_index['id']] provider_segmentation_id = \ network_tuple[key_to_index['provider:segmentation_id']] self.assertEquals('ACTIVE', status) self.assertIsNotNone(subnet_tuple_guid) self.assertEqual(guid_key, subnet_tuple_guid) self.assertEqual('4cef03d0-1d02-40bb-8c99-2f442aac6ab0', guid_value) self.assertEquals('test-network', name) self.assertEquals('None', provider_physical_network) self.assertEquals('True', admin_state_up) self.assertEquals('570fe78a1dc54cffa053bd802984ede2', tenant_id) self.assertEquals('gre', provider_network_type) self.assertEquals('False', router_external) self.assertEquals('False', shared) self.assertEquals('240ff9df-df35-43ae-9df5-27fae87f2492', id) self.assertEquals(4, provider_segmentation_id) def test_list_ports(self): """Test conversion of complex port objects to tuples.""" port_list = self.neutron_client.list_ports() port_tuple_list = \ self.driver._get_tuple_list(port_list, self.driver.NEUTRON_PORTS) self.port_address_pairs = self.driver.port_address_pairs self.port_security_groups = self.driver.port_security_groups self.port_binding_capabilities = self.driver.port_binding_capabilities self.port_extra_dhcp_opts = self.driver.port_extra_dhcp_opts self.port_fixed_ips = self.driver.port_fixed_ips self.assertIsNotNone(port_tuple_list) self.assertEquals(1, len(port_tuple_list)) # Input # [{"status": "ACTIVE",'+ # '"binding:host_id": "havana", "name": "",' + # '"allowed_address_pairs": [],'+ # '"admin_state_up": True, ' + # '"network_id": "240ff9df-df35-43ae-9df5-27fae87f2492",'+ # '"tenant_id": "570fe78a1dc54cffa053bd802984ede2", # "extra_dhcp_opts": [],'+ # '"binding:vif_type": "ovs",' + # '"device_owner": "network:router_interface",'+ # '"binding:capabilities": {"port_filter": True},' + # '"mac_address": "fa:16:3e:ab:90:df",'+ # '"fixed_ips": [{"subnet_id": # "4cef03d0-1d02-40bb-8c99-2f442aac6ab0",' + # '"ip_address":"90.0.0.1"}],'+ # '"id": "0a2ce569-85a8-45ec-abb3-0d4b34ff69ba", # "security_groups": [],'+ # '"device_id": "864e4acf-bf8e-4664-8cf7-ad5daa95681e"}]}') # Output # [('ACTIVE', 'havana', '', '90a579ea-ea45-11e3-a085-000c292422e8', # 'True', # '240ff9df-df35-43ae-9df5-27fae87f2492', # '570fe78a1dc54cffa053bd802984ede2', # '90a5b5a4-ea45-11e3-a085-000c292422e8', 'ovs', # 'network:router_interface', # '90a5f564-ea45-11e3-a085-000c292422e8', 'fa:16:3e:ab:90:df', # '90a63222-ea45-11e3-a085-000c292422e8', # '0a2ce569-85a8-45ec-abb3-0d4b34ff69ba', # '90a6397a-ea45-11e3-a085-000c292422e8', # '864e4acf-bf8e-4664-8cf7-ad5daa95681e')] status = port_tuple_list[0][0] binding_host_id = port_tuple_list[0][1] name = port_tuple_list[0][2] guid_allowed_address_pairs = port_tuple_list[0][3] guid_allowed_address_pairs_expected = self.port_address_pairs[0] admin_state_up = port_tuple_list[0][4] network_id = port_tuple_list[0][5] tenant_id = port_tuple_list[0][6] guid_extra_dhcp_opts = port_tuple_list[0][7] guid_extra_dhcp_opts_expected = self.port_extra_dhcp_opts[0][0] extra_dhcp_opts_value_actual = self.port_extra_dhcp_opts[0][1] binding_vif_type = port_tuple_list[0][8] device_owner = port_tuple_list[0][9] guid_binding_capabilities = port_tuple_list[0][10] guid_binding_capabilities_expected = \ self.port_binding_capabilities[0][0] binding_capabilities_key_actual = self.port_binding_capabilities[0][1] binding_capabilities_value_actual = \ self.port_binding_capabilities[0][2] mac_address = port_tuple_list[0][11] guid_fixed_ips = port_tuple_list[0][12] guid_fixed_ips_expected = self.port_fixed_ips[0][0] fixed_ips_key_one = self.port_fixed_ips[0][1] fixed_ips_value_one = self.port_fixed_ips[0][2] fixed_ips_key_two = self.port_fixed_ips[1][1] fixed_ips_value_two = self.port_fixed_ips[1][2] id = port_tuple_list[0][13] guid_security_groups = port_tuple_list[0][14] guid_security_groups_expected = self.port_security_groups[0][0] security_groups_value = self.port_security_groups[0][1] device_id = port_tuple_list[0][15] self.assertEqual('ACTIVE', status) self.assertEqual('havana', binding_host_id) self.assertEqual('', name) self.assertEqual(guid_allowed_address_pairs_expected[0], guid_allowed_address_pairs) self.assertEqual(1, len(self.port_address_pairs)) self.assertEqual('', self.port_address_pairs[0][1]) self.assertEqual('True', admin_state_up) self.assertEqual('240ff9df-df35-43ae-9df5-27fae87f2492', network_id) self.assertEqual('570fe78a1dc54cffa053bd802984ede2', tenant_id) self.assertEqual(guid_extra_dhcp_opts_expected, guid_extra_dhcp_opts) self.assertEqual(1, len(self.port_extra_dhcp_opts)) self.assertEqual('', extra_dhcp_opts_value_actual) self.assertEqual(guid_binding_capabilities_expected, guid_binding_capabilities) self.assertEqual(1, len(self.port_binding_capabilities)) self.assertEqual('port_filter', binding_capabilities_key_actual) self.assertEqual('True', binding_capabilities_value_actual) self.assertEqual('ovs', binding_vif_type) self.assertEqual('network:router_interface', device_owner) # '"fixed_ips": [{"subnet_id": # "4cef03d0-1d02-40bb-8c99-2f442aac6ab0",' + # '"ip_address":"90.0.0.1"}],'+ self.assertEqual(guid_fixed_ips_expected, guid_fixed_ips) self.assertEqual(2, len(self.port_fixed_ips)) self.assertEqual('subnet_id', fixed_ips_key_one) self.assertEqual('4cef03d0-1d02-40bb-8c99-2f442aac6ab0', fixed_ips_value_one) self.assertEqual('ip_address', fixed_ips_key_two) self.assertEqual('90.0.0.1', fixed_ips_value_two) self.assertEqual('fa:16:3e:ab:90:df', mac_address) self.assertEqual('0a2ce569-85a8-45ec-abb3-0d4b34ff69ba', id) self.assertEqual(guid_security_groups_expected, guid_security_groups) self.assertEqual(1, len(self.port_security_groups)) self.assertEqual('', security_groups_value) self.assertEqual('864e4acf-bf8e-4664-8cf7-ad5daa95681e', device_id) #### Tests for DataSourceDriver # Note: these tests are really testing the functionality of the class # DataSourceDriver, but it's useful to use an actual subclass so # we can test the functionality end-to-end. We use Neutron for # that subclass. Leaving it in this file so that it is clear # that when the Neutron driver changes, these tests may need # to change as well. Tried to minimize the number of changes # necessary. def setup_polling(self, debug_mode=False): """Setup polling tests.""" cage = congress.dse.d6cage.d6Cage() # so that we exit once test finishes; all other threads are forced # to be daemons cage.daemon = True cage.start() # Create mock of Neutron client so we can control data mock_factory = mox.Mox() neutron_client = mock_factory.CreateMock( neutronclient.v2_0.client.Client) neutron_client.list_networks().InAnyOrder(1).AndReturn(network1) neutron_client.list_ports().InAnyOrder(1).AndReturn(port_response) neutron_client.list_networks().InAnyOrder(2).AndReturn(network2) neutron_client.list_ports().InAnyOrder(2).AndReturn(port_response) mock_factory.ReplayAll() # Create modules (without auto-polling) cage.loadModule("NeutronDriver", helper.data_module_path("neutron_driver.py")) cage.loadModule("PolicyDriver", helper.policy_module_path()) cage.createservice(name="policy", moduleName="PolicyDriver") cage.createservice(name="neutron", moduleName="NeutronDriver", args={'poll_time': 0, 'client': neutron_client}) policy = cage.service_object('policy') # Make it so that we get detailed info from policy engine if debug_mode: policy.debug_mode() # insert rule into policy to make testing easier. # (Some of the IDs are auto-generated each time we convert) policy.insert(create_network_group('p')) # create some garbage data network_key_to_index = NeutronDriver.network_key_position_map() network_max_index = max(network_key_to_index.values()) args1 = ['1'] * (network_max_index + 1) args2 = ['2'] * (network_max_index + 1) args1 = ",".join(args1) args2 = ",".join(args2) fake_networks = [ 'neutron:networks({})'.format(args1), 'neutron:networks({})'.format(args2)] # answer to query above for network1 datalog1 = \ ('p("240ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("340ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("440ff9df-df35-43ae-9df5-27fae87f2492")') # answer to query above for network2 datalog2 = \ ('p("240ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("640ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("540ff9df-df35-43ae-9df5-27fae87f2492")') # return value d = {} d['cage'] = cage d['datalog1'] = datalog1 d['datalog2'] = datalog2 d['fake_networks'] = fake_networks return d def test_subscribe_poll(self): """Test subscribing before polling. The common case.""" info = self.setup_polling() cage = info['cage'] policy = cage.service_object('policy') neutron = cage.service_object('neutron') datalog1 = info['datalog1'] datalog2 = info['datalog2'] # subscribe policy.subscribe('neutron', 'networks', callback=policy.receive_data) helper.pause() # so that subscription messages are processed # poll 1 neutron.poll() helper.pause() # so that data updates are processed e = helper.db_equal(policy.select('p(x)'), datalog1) self.assertTrue(e, 'Neutron insertion 1') # poll 2 neutron.poll() helper.pause() e = helper.db_equal(policy.select('p(x)'), datalog2) self.assertTrue(e, 'Neutron insertion 2') def test_policy_initialization(self): """Test subscribing before polling. The common case.""" info = self.setup_polling() cage = info['cage'] policy = cage.service_object('policy') neutron = cage.service_object('neutron') datalog1 = info['datalog1'] fake_networks = info['fake_networks'] # add garbage to policy for formula in fake_networks: logging.debug("Inserting fake_network: " + str(formula)) policy.insert(formula) # subscribe policy.subscribe('neutron', 'networks', callback=policy.receive_data) helper.pause() # so that subscription messages are processed # poll 1 neutron.poll() helper.pause() # so that data updates are processed e = helper.db_equal(policy.select('p(x)'), datalog1) self.assertTrue(e, 'Neutron insertion 1') def test_poll_subscribe(self): """Test polling before subscribing.""" info = self.setup_polling() cage = info['cage'] policy = cage.service_object('policy') neutron = cage.service_object('neutron') datalog1 = info['datalog1'] datalog2 = info['datalog2'] fake_networks = info['fake_networks'] # add garbage to policy for formula in fake_networks: logging.debug("Inserting fake_network: " + str(formula)) policy.insert(formula) # poll 1 and then subscribe; should still see first result neutron.poll() helper.pause() # so that data is sent policy.subscribe('neutron', 'networks', callback=policy.receive_data) helper.pause() # so that data updates are processed e = helper.db_equal(policy.select('p(x)'), datalog1) self.assertTrue(e, 'Neutron insertion 1') # poll 2 neutron.poll() helper.pause() e = helper.db_equal(policy.select('p(x)'), datalog2) self.assertTrue(e, 'Neutron insertion 2') def test_double_poll_subscribe(self): """Test double polling before subscribing.""" info = self.setup_polling() cage = info['cage'] policy = cage.service_object('policy') neutron = cage.service_object('neutron') datalog2 = info['datalog2'] # poll twice and then subscribe: should see 2nd result neutron.poll() helper.pause() neutron.poll() helper.pause() policy.subscribe('neutron', 'networks', callback=policy.receive_data) helper.pause() # so that messages are processed e = helper.db_equal(policy.select('p(x)'), datalog2) self.assertTrue(e, 'Neutron insertion 2') def test_policy_recovery(self): """Test policy crashing and recovering (sort of).""" info = self.setup_polling() cage = info['cage'] policy = cage.service_object('policy') neutron = cage.service_object('neutron') datalog1 = info['datalog1'] # get initial data policy.subscribe('neutron', 'networks', callback=policy.receive_data) helper.pause() neutron.poll() helper.pause() e = helper.db_equal(policy.select('p(x)'), datalog1) self.assertTrue(e, 'Neutron insertion 1') # clear out policy's neutron:networks data (to simulate crashing) policy.initialize(['neutron:networks'], []) # subscribe again (without unsubscribing) policy.subscribe('neutron', 'networks', callback=policy.receive_data) helper.pause() # should get same data e = helper.db_equal(policy.select('p(x)'), datalog1) self.assertTrue(e, 'Neutron insertion 1')
def setup_polling(self, debug_mode=False): """Setup polling tests.""" cage = congress.dse.d6cage.d6Cage() # so that we exit once test finishes; all other threads are forced # to be daemons cage.daemon = True cage.start() # Create mock of Neutron client so we can control data mock_factory = mox.Mox() neutron_client = mock_factory.CreateMock( neutronclient.v2_0.client.Client) neutron_client.list_networks().InAnyOrder(1).AndReturn(network1) neutron_client.list_ports().InAnyOrder(1).AndReturn(port_response) neutron_client.list_networks().InAnyOrder(2).AndReturn(network2) neutron_client.list_ports().InAnyOrder(2).AndReturn(port_response) mock_factory.ReplayAll() # Create modules (without auto-polling) cage.loadModule("NeutronDriver", helper.data_module_path("neutron_driver.py")) cage.loadModule("PolicyDriver", helper.policy_module_path()) cage.createservice(name="policy", moduleName="PolicyDriver") cage.createservice(name="neutron", moduleName="NeutronDriver", args={'poll_time': 0, 'client': neutron_client}) policy = cage.service_object('policy') # Make it so that we get detailed info from policy engine if debug_mode: policy.debug_mode() # insert rule into policy to make testing easier. # (Some of the IDs are auto-generated each time we convert) policy.insert(create_network_group('p')) # create some garbage data network_key_to_index = NeutronDriver.network_key_position_map() network_max_index = max(network_key_to_index.values()) args1 = ['1'] * (network_max_index + 1) args2 = ['2'] * (network_max_index + 1) args1 = ",".join(args1) args2 = ",".join(args2) fake_networks = [ 'neutron:networks({})'.format(args1), 'neutron:networks({})'.format(args2)] # answer to query above for network1 datalog1 = \ ('p("240ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("340ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("440ff9df-df35-43ae-9df5-27fae87f2492")') # answer to query above for network2 datalog2 = \ ('p("240ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("640ff9df-df35-43ae-9df5-27fae87f2492") ' 'p("540ff9df-df35-43ae-9df5-27fae87f2492")') # return value d = {} d['cage'] = cage d['datalog1'] = datalog1 d['datalog2'] = datalog2 d['fake_networks'] = fake_networks return d