def test_process_router_2_rids_1_vrf(self): driver = self._mock_driver_and_hosting_device(self.routing_helper) router1, ports = self.prepare_router_data() ri1 = svc_helper.RouterInfo(router1['id'], router=router1) # Router #2 is like #1, except with some different IDs router2 = copy.deepcopy(router1) router2['id'] = _uuid() ri2 = svc_helper.RouterInfo(router2['id'], router=router2) h_info1 = create_hosting_info() h_info2 = copy.deepcopy(h_info1) ri1.router['hosting_info'] = h_info1 ri2.router['hosting_info'] = h_info2 driver._get_vrf_name = mock.Mock( return_value=ri1.router['hosting_info']['vrf_id']) self.routing_helper._process_router(ri1) vrf = ri1.router['hosting_info']['vrf_id'] driver._get_vrf_name.assert_called_with(ri1) driver._do_create_vrf.assert_called_with(vrf) self.assertEqual(1, len(self.routing_helper._router_ids_by_vrf)) self.assertEqual(1, len(self.routing_helper._router_ids_by_vrf[vrf])) driver._get_vrf_name.reset_mock() driver._do_create_vrf.reset_mock() self.routing_helper._process_router(ri2) driver._get_vrf_name.assert_called_with(ri2) driver._do_create_vrf.assert_not_called() self.assertEqual(1, len(self.routing_helper._router_ids_by_vrf)) self.assertEqual(2, len(self.routing_helper._router_ids_by_vrf[vrf])) del ri1.router['gw_port'] driver._get_vrf_name.reset_mock() self.routing_helper._process_router(ri1) driver._get_vrf_name.assert_called_with(ri1) driver._remove_vrf.assert_not_called() self.assertEqual(1, len(self.routing_helper._router_ids_by_vrf)) self.assertEqual(1, len(self.routing_helper._router_ids_by_vrf[vrf])) del ri2.router['gw_port'] driver._get_vrf_name.reset_mock() driver._remove_vrf.reset_mock() self.routing_helper._process_router(ri2) driver._get_vrf_name.assert_called_with(ri2) driver._remove_vrf.assert_called_with(ri2) self.assertEqual({}, self.routing_helper._router_ids_by_vrf)
def test_process_router_throw_no_ip_address_on_subnet_error(self): router, ports = prepare_router_data() # change subnet_id to something that does not exist router['gw_port']['subnets'][0]['id'] = 'fake_uuid' ri = routing_svc_helper.RouterInfo(router['id'], router) self.assertRaises(routing_svc_helper.IPAddressMissingException, self.routing_helper._process_router, ri)
def test_process_router_internal_network_removed_unexpected_error(self): router, ports = prepare_router_data() ri = routing_svc_helper.RouterInfo(router['id'], router=router) # add an internal port self.routing_helper._process_router(ri) # raise RuntimeError to simulate that an unexpected exception occurrs self.routing_helper._internal_network_removed.side_effect = mock.Mock( side_effect=RuntimeError) router[l3_constants.INTERFACE_KEY][0]['admin_state_up'] = False # The above port is set to down state, remove it. self.assertRaises(RuntimeError, self.routing_helper._process_router, ri) self.assertIn(router[l3_constants.INTERFACE_KEY][0], ri.internal_ports) # The unexpected exception has been fixed manually self.routing_helper._internal_network_removed.side_effect = None # Failure will cause a retry next time, # We were able to add the port to ri.internal_ports self.routing_helper._process_router(ri) # We were able to remove the port from ri.internal_ports self.assertNotIn(router[l3_constants.INTERFACE_KEY][0], ri.internal_ports)
def test_router_info_create_with_router(self): router_id = _uuid() ri = routing_svc_helper.RouterInfo(router_id, self.router) self.assertTrue(ri.router_name().endswith(router_id)) self.assertEqual(ri.router, self.router) self.assertEqual(ri._router, self.router) self.assertTrue(ri.snat_enabled) self.assertIsNone(ri.ex_gw_port)
def test_process_router_throw_session_close(self): class SessionCloseError(Exception): pass self.routing_helper._internal_network_added.side_effect = ( SessionCloseError("Simulate SessionCloseError")) router, ports = prepare_router_data() ri = routing_svc_helper.RouterInfo(router['id'], router) self.assertRaises(SessionCloseError, self.routing_helper._process_router, ri)
def test_process_router_throw_config_error(self): snip_name = 'CREATE_SUBINTERFACE' e_type = 'Fake error' e_tag = 'Fake error tag' params = {'snippet': snip_name, 'type': e_type, 'tag': e_tag} self.routing_helper._internal_network_added.side_effect = ( cfg_exceptions.CSR1kvConfigException(**params)) router, ports = prepare_router_data() ri = routing_svc_helper.RouterInfo(router['id'], router) self.assertRaises(cfg_exceptions.CSR1kvConfigException, self.routing_helper._process_router, ri)
def setUp(self): super(TestCSR1kvRouting, self).setUp() device_params = {'management_ip_address': 'fake_ip', 'protocol_port': 22, 'credentials': {"username": "******", "password": "******"}, 'timeout': None } self.driver = csr_driver.CSR1kvRoutingDriver( **device_params) self.mock_conn = mock.MagicMock() self.driver._csr_conn = self.mock_conn self.driver._check_response = mock.MagicMock(return_value=True) self.vrf = ('nrouter-' + FAKE_ID)[:csr_driver.CSR1kvRoutingDriver. DEV_NAME_LEN] self.driver._get_vrfs = mock.Mock(return_value=[self.vrf]) self.ex_gw_ip = '20.0.0.30' self.ex_gw_cidr = '20.0.0.30/24' self.ex_gw_vlan = 1000 self.ex_gw_gateway_ip = '20.0.0.1' self.ex_gw_port = {'id': _uuid(), 'network_id': _uuid(), 'fixed_ips': [{'ip_address': self.ex_gw_ip, 'subnet_id': _uuid()}], 'subnets': [{'cidr': self.ex_gw_cidr, 'gateway_ip': self.ex_gw_gateway_ip}], 'ip_cidr': self.ex_gw_cidr, 'mac_address': 'ca:fe:de:ad:be:ef', 'hosting_info': {'segmentation_id': self.ex_gw_vlan, 'hosting_port_name': 't2_p:0'}} self.vlan_no = 500 self.gw_ip_cidr = '10.0.0.1/16' self.gw_ip = '10.0.0.1' self.hosting_port = 't1_p:0' self.port = {'id': PORT_ID, 'ip_cidr': self.gw_ip_cidr, 'fixed_ips': [{'ip_address': self.gw_ip}], 'hosting_info': {'segmentation_id': self.vlan_no, 'hosting_port_name': self.hosting_port}} int_ports = [self.port] self.router = { 'id': FAKE_ID, l3_constants.INTERFACE_KEY: int_ports, 'enable_snat': True, 'routes': [], 'gw_port': self.ex_gw_port} self.ri = routing_svc_helper.RouterInfo(FAKE_ID, self.router) self.ri.internal_ports = int_ports
def _create_test_routers(self, is_user_visible=True): self.router, ports = self.prepare_router_data( is_user_visible=is_user_visible) self.ri = routing_svc_helper.RouterInfo(self.router['id'], self.router) self.ha_priority = self.router[ha.DETAILS][ha.PRIORITY] self.vrf = ('nrouter-' + self.router['id'])[:DEV_NAME_LEN] # router port on external network, i.e., gateway port self.ext_gw_port = self.router['gw_port'] self.ext_gw_port['ip_info'] = { 'subnet_id': self.ext_gw_port['subnets'][0]['id'], 'is_primary': True, 'ip_cidr': self.ext_gw_port['subnets'][0]['cidr'] } self.ext_phy_infc = ( self.ext_gw_port['hosting_info']['physical_interface']) self.vlan_ext = self.ext_gw_port['hosting_info']['segmentation_id'] self.ext_gw_upstream_ip = self.ext_gw_port['subnets'][0]['gateway_ip'] self.ext_gw_ip = self.ext_gw_port['fixed_ips'][0]['ip_address'] self.ext_gw_ip_cidr = self.ext_gw_port['subnets'][0]['cidr'] self.ext_gw_ip_mask = str( netaddr.IPNetwork(self.ext_gw_ip_cidr).netmask) port_ha_info = self.ext_gw_port['ha_info'] self.ext_gw_ha_group = port_ha_info['group'] # router port on internal network self.int_port = ports[0] self.int_port['ip_info'] = { 'subnet_id': self.int_port['subnets'][0]['id'], 'is_primary': True, 'ip_cidr': self.int_port['subnets'][0]['cidr'] } self.int_port['change_details'] = { 'new_ports': [self.int_port], 'current_ports': [self.int_port], 'old_ports': [], 'former_ports': [] } self.int_phy_infc = self.int_port['hosting_info']['physical_interface'] self.vlan_int = self.int_port['hosting_info']['segmentation_id'] self.int_gw_ip = self.int_port['fixed_ips'][0]['ip_address'] self.int_gw_ip_cidr = self.int_port['subnets'][0]['cidr'] self.int_gw_ip_mask = str( netaddr.IPNetwork(self.int_gw_ip_cidr).netmask) port_ha_info = self.int_port['ha_info'] self.int_gw_ip_vip = ( port_ha_info['ha_port']['fixed_ips'][0]['ip_address']) self.int_gw_ha_group = port_ha_info['group'] self.floating_ip = '19.4.0.6' self.fixed_ip = '35.4.0.20'
def test_process_router_throw_session_close(self): # snip_name = 'CREATE_SUBINTERFACE' # e_type = 'Fake error' # e_tag = 'Fake error tag' # confstr = 'Fake conf str' # params = {'snippet': snip_name, 'type': e_type, 'tag': e_tag, # 'confstr': confstr, 'dev_id': 'FAKE_ID', 'ip': 'FAKE_IP'} params = {'in_buf': ''} self.routing_helper._internal_network_added.side_effect = ( ncc_errors.SessionCloseError(**params)) router, ports = prepare_router_data() ri = routing_svc_helper.RouterInfo(router['id'], router) self.assertRaises(ncc_errors.SessionCloseError, self.routing_helper._process_router, ri)
def test_routing_table_update(self): router = self.router fake_route1 = {'destination': '135.207.0.0/16', 'nexthop': '1.2.3.4'} fake_route2 = { 'destination': '135.207.111.111/32', 'nexthop': '1.2.3.4' } # First we set the routes to fake_route1 and see if the # driver.routes_updated was called with 'replace'(==add or replace) # and fake_route1 router['routes'] = [fake_route1] ri = routing_svc_helper.RouterInfo(router['id'], router) self.routing_helper._process_router(ri) self.driver.routes_updated.assert_called_with(ri, 'replace', fake_route1) # Now we replace fake_route1 with fake_route2. This should cause driver # to be invoked to delete fake_route1 and 'replace'(==add or replace) self.driver.reset_mock() router['routes'] = [fake_route2] ri.router = router self.routing_helper._process_router(ri) self.driver.routes_updated.assert_called_with(ri, 'delete', fake_route1) self.driver.routes_updated.assert_any_call(ri, 'replace', fake_route2) # Now we add back fake_route1 as a new route, this should cause driver # to be invoked to 'replace'(==add or replace) fake_route1 self.driver.reset_mock() router['routes'] = [fake_route2, fake_route1] ri.router = router self.routing_helper._process_router(ri) self.driver.routes_updated.assert_any_call(ri, 'replace', fake_route1) # Now we delete all routes. This should cause driver # to be invoked to delete fake_route1 and fake-route2 self.driver.reset_mock() router['routes'] = [] ri.router = router self.routing_helper._process_router(ri) self.driver.routes_updated.assert_any_call(ri, 'delete', fake_route2) self.driver.routes_updated.assert_any_call(ri, 'delete', fake_route1)
def test_process_router_internal_network_added_unexpected_error(self): router, ports = prepare_router_data() ri = routing_svc_helper.RouterInfo(router['id'], router=router) # raise RuntimeError to simulate that an unexpected exception occurrs self.routing_helper._internal_network_added.side_effect = RuntimeError self.assertRaises(RuntimeError, self.routing_helper._process_router, ri) self.assertNotIn(router[l3_constants.INTERFACE_KEY][0], ri.internal_ports) # The unexpected exception has been fixed manually self.routing_helper._internal_network_added.side_effect = None # Failure will cause a retry next time, then were able to add the # port to ri.internal_ports self.routing_helper._process_router(ri) self.assertIn(router[l3_constants.INTERFACE_KEY][0], ri.internal_ports)
def _test_process_global_msn_router(self, num_ext_subnets=3): def _verify_ip_info(the_mock): self.assertEqual(num_ext_subnets, len(the_mock.ip_infos)) self.assertTrue(the_mock.ip_infos[0]['is_primary']) self.assertEqual('35.4.0.4/24', the_mock.ip_infos[0]['ip_cidr']) for i in range(1, num_ext_subnets): self.assertFalse(the_mock.ip_infos[i]['is_primary']) self.assertEqual('35.4.%s.4/24' % i, the_mock.ip_infos[i]['ip_cidr']) # need these helpers to verify that ip_info is correct def _int_nw_added(ri, port, ex_gw_port): self.assertIsNone(ex_gw_port) self.routing_helper._internal_network_added.ip_infos.append( copy.deepcopy(port['ip_info'])) router, ports = prepare_router_data(num_subnets=num_ext_subnets, is_global=True) # Setup mock for call to process floating ips self.routing_helper._process_router_floating_ips = mock.Mock() ri = routing_svc_helper.RouterInfo(router['id'], router=router) self.routing_helper._internal_network_added.ip_infos = [] self.routing_helper._internal_network_added.side_effect = _int_nw_added # Process with initial values self.routing_helper._process_router(ri) self.assertFalse( self.routing_helper._process_router_floating_ips.called) self.assertFalse(self.routing_helper._external_gateway_added.called) _verify_ip_info(self.routing_helper._internal_network_added) self._reset_mocks() # now no ports so state is torn down del router[bc.constants.INTERFACE_KEY] # Update router_info object ri.router = router # Process router and verify that internal and external network removed # were called and floating_ips_process was called self.routing_helper._process_router(ri) self.assertFalse( self.routing_helper._process_router_floating_ips.called) self.assertFalse(self.routing_helper._external_gateway_added.called) self.assertFalse(self.routing_helper._external_gateway_removed.called) self.assertFalse(self.routing_helper._internal_network_added.called) self.routing_helper._internal_network_removed.assert_called_once_with( ri, ports[0], None)
def test_process_router_internal_network_added_raises_HAMissingError(self): router, ports = prepare_router_data() router[ha.ENABLED] = True ri = routing_svc_helper.RouterInfo(router['id'], router=router) # raise RuntimeError to simulate that a HAParamsMissingException params = {'r_id': FAKE_ID, 'p_id': FAKE_ID, 'port': ports[0]} self.routing_helper._internal_network_added.side_effect = ( cfg_exceptions.HAParamsMissingException(**params)) self.routing_helper._process_router(ri) self.assertIn(ri.router_id, self.routing_helper.updated_routers) self.assertNotIn(router[l3_constants.INTERFACE_KEY][0], ri.internal_ports) # The unexpected exception has been fixed manually self.routing_helper._internal_network_added.side_effect = None # Failure will cause a retry next time, then were able to add the # port to ri.internal_ports self.routing_helper._process_router(ri) self.assertIn(router[l3_constants.INTERFACE_KEY][0], ri.internal_ports)
def _process_routers_floatingips(self, action='add'): router, port = prepare_router_data() driver = self._mock_driver_and_hosting_device(self.routing_helper) ex_gw_port = router['gw_port'] floating_ip_address = '19.4.4.10' fixed_ip_address = '35.4.1.10' fixed_ip_address_2 = '35.4.1.15' port_id = 'fake_port_id' floating_ip = { 'fixed_ip_address': fixed_ip_address, 'floating_ip_address': floating_ip_address, 'id': 'floating_ip_id', 'port_id': port_id, 'status': 'ACTIVE', } router[l3_constants.FLOATINGIP_KEY] = [floating_ip] ri = routing_svc_helper.RouterInfo(router['id'], router=router) # Default add action self.routing_helper._process_router_floating_ips(ri, ex_gw_port) driver.floating_ip_added.assert_called_with(ri, ex_gw_port, floating_ip_address, fixed_ip_address) if action == 'remove': router[l3_constants.FLOATINGIP_KEY] = [] self.routing_helper._process_router_floating_ips(ri, ex_gw_port) driver.floating_ip_removed.assert_called_with( ri, ri.ex_gw_port, floating_ip_address, fixed_ip_address) if action == 'remap': driver.reset_mock() floating_ip_2 = copy.deepcopy(floating_ip) floating_ip_2['fixed_ip_address'] = fixed_ip_address_2 ri.router[l3_constants.FLOATINGIP_KEY] = [floating_ip_2] self.routing_helper._process_router_floating_ips(ri, ex_gw_port) driver.floating_ip_added.assert_called_with( ri, ex_gw_port, floating_ip_address, fixed_ip_address_2) driver.floating_ip_removed.assert_called_with( ri, ri.ex_gw_port, floating_ip_address, fixed_ip_address)
def _create_test_global_routers(self, num_ext_subnets=1, subnet_index=0): # global router and its ports self.global_router, gl_ports = self.prepare_router_data( is_global=True, num_ext_subnets=num_ext_subnets) self.ha_priority = self.global_router[ha.DETAILS][ha.PRIORITY] self.ri_global = routing_svc_helper.RouterInfo( self.global_router['id'], self.global_router) self.gl_port = gl_ports[0] self.gl_port['ip_info'] = { 'subnet_id': self.gl_port['subnets'][0]['id'], 'is_primary': True, 'ip_cidr': self.gl_port['subnets'][0]['cidr'] } self.ext_phy_infc = self.gl_port['hosting_info']['physical_interface'] self.vlan_ext = self.gl_port['hosting_info']['segmentation_id'] self.gl_port_ip = self.gl_port['fixed_ips'][subnet_index]['ip_address'] self.gl_port_ip_cidr = self.gl_port['subnets'][subnet_index]['cidr'] self.gl_port_ip_mask = str( netaddr.IPNetwork(self.gl_port_ip_cidr).netmask) port_ha_info = self.gl_port['ha_info'] self.gl_port_vip = ( port_ha_info['ha_port']['fixed_ips'][subnet_index]['ip_address']) self.gl_port_ha_group = port_ha_info['group']
def _test_process_router_throw_multiple_ipv4_subnets_error(self): router, ports = prepare_router_data(num_subnets=2, is_global=True) # make router a regular one which triggers the error condition router[routerrole.ROUTER_ROLE_ATTR] = None ri = routing_svc_helper.RouterInfo(router['id'], router) return ri, router
def test_process_router(self): router, ports = prepare_router_data() #Setup mock for call to proceess floating ips self.routing_helper._process_router_floating_ips = mock.Mock() fake_floatingips1 = { 'floatingips': [{ 'id': _uuid(), 'floating_ip_address': '8.8.8.8', 'fixed_ip_address': '7.7.7.7', 'port_id': _uuid() }] } ri = routing_svc_helper.RouterInfo(router['id'], router=router) # Process with initial values self.routing_helper._process_router(ri) ex_gw_port = ri.router.get('gw_port') # Assert that process_floating_ips, internal_network & external network # added were all called with the right params self.routing_helper._process_router_floating_ips.assert_called_with( ri, ex_gw_port) self.routing_helper._internal_network_added.assert_called_with( ri, ports[0], ex_gw_port) self.routing_helper._external_gateway_added.assert_called_with( ri, ex_gw_port) self._reset_mocks() # remap floating IP to a new fixed ip fake_floatingips2 = copy.deepcopy(fake_floatingips1) fake_floatingips2['floatingips'][0]['fixed_ip_address'] = '7.7.7.8' router[l3_constants.FLOATINGIP_KEY] = fake_floatingips2['floatingips'] # Process again and check that this time only the process_floating_ips # was only called. self.routing_helper._process_router(ri) ex_gw_port = ri.router.get('gw_port') self.routing_helper._process_router_floating_ips.assert_called_with( ri, ex_gw_port) self.assertFalse(self.routing_helper._internal_network_added.called) self.assertFalse(self.routing_helper._external_gateway_added.called) self._reset_mocks() # remove just the floating ips del router[l3_constants.FLOATINGIP_KEY] # Process again and check that this time also only the # process_floating_ips and external_network remove was called self.routing_helper._process_router(ri) ex_gw_port = ri.router.get('gw_port') self.routing_helper._process_router_floating_ips.assert_called_with( ri, ex_gw_port) self.assertFalse(self.routing_helper._internal_network_added.called) self.assertFalse(self.routing_helper._external_gateway_added.called) self._reset_mocks() # now no ports so state is torn down del router[l3_constants.INTERFACE_KEY] del router['gw_port'] # Update router_info object ri.router = router # Keep a copy of the ex_gw_port before its gone after processing. ex_gw_port = ri.ex_gw_port # Process router and verify that internal and external network removed # were called and floating_ips_process was called self.routing_helper._process_router(ri) self.assertFalse( self.routing_helper._process_router_floating_ips.called) self.assertFalse(self.routing_helper._external_gateway_added.called) self.assertTrue(self.routing_helper._internal_network_removed.called) self.assertTrue(self.routing_helper._external_gateway_removed.called) self.routing_helper._internal_network_removed.assert_called_with( ri, ports[0], ex_gw_port) self.routing_helper._external_gateway_removed.assert_called_with( ri, ex_gw_port)
def test_process_router_2_rids_2_vrfs_2_networks(self): driver = _mock_driver_and_hosting_device(self.routing_helper) self._set_driver_port_mocks(driver) router1, ports = self.prepare_router_data() ri1 = svc_helper.RouterInfo(router1['id'], router=router1) # Router #2 is like #1, except with different IDs and host info router2 = copy.deepcopy(router1) router2['id'] = _uuid() ri2 = svc_helper.RouterInfo(router2['id'], router=router2) h_info1 = create_hosting_info() h_info2 = create_hosting_info(net_name=TEST_NET2, vlan=TEST_VLAN2, gw_ip=TEST_GW_IP2, cidr=TEST_CIDR2) ri1.router['hosting_info'] = h_info1 ri2.router['hosting_info'] = h_info2 ex_gw_port1 = ri1.router.get('gw_port') ex_gw_port2 = ri2.router.get('gw_port') ex_gw_port1['hosting_info'] = h_info1 ex_gw_port2['hosting_info'] = h_info2 vrf1 = ri1.router['hosting_info']['vrf_id'] vrf2 = ri2.router['hosting_info']['vrf_id'] network_name1 = h_info1['network_name'] network_name2 = h_info2['network_name'] driver._get_vrf_name = mock.Mock(return_value=vrf1) self.routing_helper._process_router(ri1) driver.internal_network_added.assert_called_with(ri1, ports[0]) driver.enable_internal_network_NAT.assert_called_with( ri1, ports[0], ex_gw_port1) v_n_r_dict = self.routing_helper._router_ids_by_vrf_and_ext_net self.assertEqual(1, len(v_n_r_dict)) self.assertEqual(1, len(v_n_r_dict[vrf1])) self.assertEqual(1, len(v_n_r_dict[vrf1][network_name1])) driver.internal_network_added.reset_mock() driver.enable_internal_network_NAT.reset_mock() driver._get_vrf_name = mock.Mock(return_value=vrf2) self.routing_helper._process_router(ri2) # remove change_details as they are recursive and prevent comparison del ports[0]['change_details'] del ri2.internal_ports[0]['change_details'] driver.internal_network_added.assert_called_with(ri2, ports[0]) driver.enable_internal_network_NAT.assert_called_with( ri2, ports[0], ex_gw_port2) self.assertEqual(2, len(v_n_r_dict)) self.assertEqual(1, len(v_n_r_dict[vrf1])) self.assertEqual(1, len(v_n_r_dict[vrf2])) self.assertEqual(1, len(v_n_r_dict[vrf1][network_name1])) self.assertEqual(1, len(v_n_r_dict[vrf2][network_name2])) del ri1.router[bc.constants.INTERFACE_KEY] driver._get_vrf_name = mock.Mock(return_value=vrf1) self.routing_helper._process_router(ri1) driver.internal_network_removed.assert_called_with(ri1, ports[0], itfc_deleted=True) driver.disable_internal_network_NAT.assert_called_with( ri1, ports[0], ex_gw_port1, itfc_deleted=True) self.assertEqual(1, len(v_n_r_dict)) self.assertEqual(1, len(v_n_r_dict[vrf2])) self.assertFalse(v_n_r_dict.get(vrf1)) self.assertEqual(1, len(v_n_r_dict[vrf2][network_name2])) driver.internal_network_removed.reset_mock() driver.disable_internal_network_NAT.reset_mock() del ri2.router[bc.constants.INTERFACE_KEY] driver._get_vrf_name = mock.Mock(return_value=vrf2) self.routing_helper._process_router(ri2) # remove change_details as they are recursive and prevent comparison del ports[0]['change_details'] del driver.internal_network_removed.call_args[0][1]['change_details'] driver.internal_network_removed.assert_called_with(ri2, ports[0], itfc_deleted=True) driver.disable_internal_network_NAT.assert_called_with( ri2, ports[0], ex_gw_port2, itfc_deleted=True) self.assertEqual({}, v_n_r_dict)
def test_router_info_create(self): router_id = _uuid() fake_router = {} ri = routing_svc_helper.RouterInfo(router_id, fake_router) self.assertTrue(ri.router_name().endswith(router_id))
def setUp(self): super(ASR1kRoutingDriver, self).setUp() cfg.CONF.set_override('enable_multi_region', False, 'multi_region') device_params = { 'management_ip_address': 'fake_ip', 'protocol_port': 22, 'credentials': { "user_name": "stack", "password": "******" }, 'timeout': None, 'id': '0000-1', 'device_id': 'ASR-1' } self.driver = driver.ASR1kRoutingDriver(**device_params) self.driver._ncc_connection = mock.MagicMock() self.driver._check_response = mock.MagicMock(return_value=True) self.driver._check_acl = mock.MagicMock(return_value=False) self.vrf = ('nrouter-' + FAKE_ID)[:iosxe_driver.IosXeRoutingDriver.DEV_NAME_LEN] self.driver._get_vrfs = mock.Mock(return_value=[self.vrf]) self.ex_gw_ip = '20.0.0.31' # VIP is same as gw_ip for user visible router self.ex_gw_ip_vip = self.ex_gw_ip self.ex_gw_prefixlen = 24 self.ex_gw_cidr = '20.0.0.30/24' self.ex_gw_ip_mask = '255.255.255.0' self.ex_gw_ha_group = 1500 self.ex_gw_ha_info = { 'group': self.ex_gw_ha_group, 'ha_port': { 'fixed_ips': [{ 'ip_address': self.ex_gw_ip_vip, 'prefixlen': self.ex_gw_prefixlen }] } } self.ex_gw_gateway_ip = '20.0.0.1' self.vlan_ext = 317 self.phy_infc = 'GigabitEthernet0/0/0' self.ex_gw_port = { 'id': _uuid(), 'network_id': _uuid(), 'fixed_ips': [{ 'ip_address': self.ex_gw_ip, 'prefixlen': self.ex_gw_prefixlen, 'subnet_id': _uuid() }], 'subnets': [{ 'cidr': self.ex_gw_cidr, 'gateway_ip': self.ex_gw_gateway_ip }], 'device_owner': l3_constants.DEVICE_OWNER_ROUTER_GW, 'mac_address': 'ca:fe:de:ad:be:ef', 'admin_state_up': True, 'hosting_info': { 'physical_interface': self.phy_infc, 'segmentation_id': self.vlan_ext }, HA_INFO: self.ex_gw_ha_info } self.vlan_int = 314 self.hosting_info = { 'physical_interface': self.phy_infc, 'segmentation_id': self.vlan_ext } self.gw_ip_cidr = '10.0.3.0/24' self.gw_prefixlen = 24 self.gw_ip = '10.0.3.3' self.gw_ip_vip = '10.0.3.1' self.gw_ip_mask = '255.255.255.0' self.gw_ha_group = 1621 self.gw_ha_info = { 'group': self.gw_ha_group, 'ha_port': { 'fixed_ips': [{ 'ip_address': self.gw_ip_vip, 'prefixlen': self.gw_prefixlen }] } } self.port = { 'id': PORT_ID, 'ip_cidr': self.gw_ip_cidr, 'fixed_ips': [{ 'ip_address': self.gw_ip }], 'subnets': [{ 'cidr': self.gw_ip_cidr, 'gateway_ip': self.gw_ip }], 'hosting_info': { 'physical_interface': self.phy_infc, 'segmentation_id': self.vlan_int }, HA_INFO: self.gw_ha_info } int_ports = [self.port] self.floating_ip = '20.0.0.35' self.fixed_ip = '10.0.3.5' self.ha_priority = 10 self.cisco_ha_details = { 'priority': self.ha_priority, 'redundancy_level': 1, 'redundancy_routers': [{ 'id': _uuid(), 'priority': 20, 'state': 'STANDBY' }], 'state': 'ACTIVE', 'type': 'HSRP' } self.router = { 'id': FAKE_ID, l3_constants.INTERFACE_KEY: int_ports, 'enable_snat': True, 'admin_state_up': True, 'routes': [], routerrole.ROUTER_ROLE_ATTR: 'Logical', ha.ENABLED: True, ha.DETAILS: self.cisco_ha_details, 'gw_port': self.ex_gw_port } self.ri = routing_svc_helper.RouterInfo(FAKE_ID, self.router) self.ri.internal_ports = int_ports # Global router self.global_router = copy.deepcopy(self.router) self.global_router[routerrole.ROUTER_ROLE_ATTR] = ( cisco_constants.ROUTER_ROLE_GLOBAL) self.cisco_ha_details_global = { 'priority': self.ha_priority, 'redundancy_level': 2, 'redundancy_routers': [{ 'priority': 10, 'state': 'STANDBY', 'id': FAKE_ID }, { 'id': _uuid(), 'priority': 20, 'state': 'STANDBY' }], 'state': 'ACTIVE', 'type': 'HSRP' } self.global_router[ha.DETAILS] = self.cisco_ha_details_global self.global_router['gw_port'][HA_INFO]['ha_port']['fixed_ips'][0][ 'ip_address'] = self.ex_gw_ip_vip self.ri_global = routing_svc_helper.RouterInfo(FAKE_ID, self.global_router) self.ri_global.internal_ports = int_ports
def test_router_info_create_snat_disabled(self): router_id = _uuid() self.router['enable_snat'] = False ri = routing_svc_helper.RouterInfo(router_id, self.router) self.assertFalse(ri.snat_enabled)
def test_process_router_2_rids_2_vrfs_1_network(self): driver = _mock_driver_and_hosting_device(self.routing_helper) self._set_driver_port_mocks(driver) router1, ports = helper.prepare_router_data() ri1 = svc_helper.RouterInfo(router1['id'], router=router1) # Router #2 is like #1, except with some different IDs router2 = copy.deepcopy(router1) router2['id'] = _uuid() ri2 = svc_helper.RouterInfo(router2['id'], router=router2) h_info1 = create_hosting_info() h_info2 = copy.deepcopy(h_info1) h_info2['vrf_id'] = _uuid() ri1.router['hosting_info'] = h_info1 ri2.router['hosting_info'] = h_info2 ex_gw_port1 = ri1.router.get('gw_port') ex_gw_port2 = ri2.router.get('gw_port') ex_gw_port1['hosting_info'] = h_info1 ex_gw_port2['hosting_info'] = h_info2 vrf1 = ri1.router['hosting_info']['vrf_id'] vrf2 = ri2.router['hosting_info']['vrf_id'] driver._get_vrf_name = mock.Mock(return_value=vrf1) self.routing_helper._process_router(ri1) driver.internal_network_added.assert_called_with( ri1, ports[0]) driver.enable_internal_network_NAT.assert_called_with( ri1, ports[0], ex_gw_port1) v_n_r_dict = self.routing_helper._router_ids_by_vrf_and_ext_net network_name = h_info1['network_name'] self.assertEqual(1, len(v_n_r_dict)) self.assertEqual(1, len(v_n_r_dict[vrf1])) self.assertEqual(1, len(v_n_r_dict[vrf1][network_name])) driver.internal_network_added.reset_mock() driver.enable_internal_network_NAT.reset_mock() driver._get_vrf_name = mock.Mock(return_value=vrf2) self.routing_helper._process_router(ri2) driver.internal_network_added.assert_called_with( ri2, ports[0]) driver.enable_internal_network_NAT.assert_called_with( ri2, ports[0], ex_gw_port2) network_name = h_info1['network_name'] self.assertEqual(2, len(v_n_r_dict)) self.assertEqual(1, len(v_n_r_dict[vrf1])) self.assertEqual(1, len(v_n_r_dict[vrf2])) self.assertEqual(1, len(v_n_r_dict[vrf1][network_name])) self.assertEqual(1, len(v_n_r_dict[vrf2][network_name])) del ri1.router[bc.constants.INTERFACE_KEY] driver._get_vrf_name = mock.Mock(return_value=vrf1) self.routing_helper._process_router(ri1) driver.internal_network_removed.assert_called_with( ri1, ports[0], itfc_deleted=True) driver.disable_internal_network_NAT.assert_called_with( ri1, ports[0], ex_gw_port1, itfc_deleted=True) self.assertEqual(1, len(v_n_r_dict)) self.assertFalse(v_n_r_dict.get(vrf1)) self.assertEqual(1, len(v_n_r_dict[vrf2])) self.assertEqual(1, len(v_n_r_dict[vrf2][network_name])) driver.internal_network_removed.reset_mock() driver.disable_internal_network_NAT.reset_mock() del ri2.router[bc.constants.INTERFACE_KEY] driver._get_vrf_name = mock.Mock(return_value=vrf2) self.routing_helper._process_router(ri2) driver.internal_network_removed.assert_called_with( ri2, ports[0], itfc_deleted=True) driver.disable_internal_network_NAT.assert_called_with( ri2, ports[0], ex_gw_port2, itfc_deleted=True) self.assertEqual({}, v_n_r_dict)
def _test_process_msn_router(self, num_ext_subnets=3, test_admin_state=True): def _verify_ip_info(the_mock): self.assertEqual(num_ext_subnets, len(the_mock.ip_infos)) self.assertTrue(the_mock.ip_infos[0]['is_primary']) self.assertEqual('19.4.0.4/28', the_mock.ip_infos[0]['ip_cidr']) for i in range(1, num_ext_subnets): self.assertFalse(the_mock.ip_infos[i]['is_primary']) self.assertEqual('19.4.%s.4/27' % i, the_mock.ip_infos[i]['ip_cidr']) # need these helpers to verify that ip_info is correct def _ext_gw_added(ri, ex_gw_port): self.routing_helper._external_gateway_added.ip_infos.append( copy.deepcopy(ex_gw_port['ip_info'])) def _ext_gw_removed(ri, ex_gw_port): self.routing_helper._external_gateway_removed.ip_infos.append( copy.deepcopy(ex_gw_port['ip_info'])) router, ports = prepare_router_data(num_subnets=num_ext_subnets) # Setup mock for call to process floating ips self.routing_helper._process_router_floating_ips = mock.Mock() fake_floatingips1 = { 'floatingips': [{ 'id': _uuid(), 'floating_ip_address': '8.8.8.8', 'fixed_ip_address': '7.7.7.7', 'port_id': _uuid() }] } ri = routing_svc_helper.RouterInfo(router['id'], router=router) self.routing_helper._external_gateway_added.ip_infos = [] self.routing_helper._external_gateway_added.side_effect = _ext_gw_added # Process with initial values self.routing_helper._process_router(ri) ex_gw_port = ri.router.get('gw_port') # Assert that process_floating_ips, internal_network & external network # added were all called with the right params (self.routing_helper._process_router_floating_ips. assert_called_once_with(ri, ex_gw_port)) self.routing_helper._internal_network_added.assert_called_once_with( ri, ports[0], ex_gw_port) _verify_ip_info(self.routing_helper._external_gateway_added) self._reset_mocks() # remap floating IP to a new fixed ip fake_floatingips2 = copy.deepcopy(fake_floatingips1) fake_floatingips2['floatingips'][0]['fixed_ip_address'] = '7.7.7.8' router[bc.constants.FLOATINGIP_KEY] = fake_floatingips2['floatingips'] # Process again and check that this time only the process_floating_ips # was only called. self.routing_helper._process_router(ri) ex_gw_port = ri.router.get('gw_port') (self.routing_helper._process_router_floating_ips. assert_called_once_with(ri, ex_gw_port)) self.assertFalse(self.routing_helper._internal_network_added.called) self.assertFalse(self.routing_helper._external_gateway_added.called) self._reset_mocks() # remove just the floating ips del router[bc.constants.FLOATINGIP_KEY] # Process again and check that this time also only the # process_floating_ips and external_network remove was called self.routing_helper._process_router(ri) ex_gw_port = ri.router.get('gw_port') (self.routing_helper._process_router_floating_ips. assert_called_once_with(ri, ex_gw_port)) self.assertFalse(self.routing_helper._internal_network_added.called) self.assertFalse(self.routing_helper._external_gateway_added.called) self._reset_mocks() if test_admin_state: self._test_router_admin_port_state(router, ri, ex_gw_port) # now no ports so state is torn down del router[bc.constants.INTERFACE_KEY] del router['gw_port'] # Update router_info object ri.router = router # Keep a copy of the ex_gw_port before its gone after processing. ex_gw_port = ri.ex_gw_port self.routing_helper._external_gateway_removed.ip_infos = [] self.routing_helper._external_gateway_removed.side_effect = ( _ext_gw_removed) # Process router and verify that internal and external network removed # were called and floating_ips_process was called self.routing_helper._process_router(ri) self.assertFalse( self.routing_helper._process_router_floating_ips.called) self.assertFalse(self.routing_helper._external_gateway_added.called) self.routing_helper._internal_network_removed.assert_called_once_with( ri, ports[0], ex_gw_port) _verify_ip_info(self.routing_helper._external_gateway_removed)