def test_create_with_vip_network_picks_subnet_ipv4(self): network_id = uuidutils.generate_uuid() subnet1 = network_models.Subnet(id=uuidutils.generate_uuid(), network_id=network_id, ip_version=6) subnet2 = network_models.Subnet(id=uuidutils.generate_uuid(), network_id=network_id, ip_version=4) network = network_models.Network(id=network_id, subnets=[subnet1.id, subnet2.id]) vip = {'network_id': network.id} lb_json = {'vip': vip, 'project_id': self.project_id} with mock.patch( "octavia.network.drivers.noop_driver.driver.NoopManager" ".get_network") as mock_get_network, mock.patch( "octavia.network.drivers.noop_driver.driver.NoopManager" ".get_subnet") as mock_get_subnet: mock_get_network.return_value = network mock_get_subnet.side_effect = [subnet1, subnet2] response = self.post(self.LBS_PATH, lb_json) api_lb = response.json self._assert_request_matches_response(lb_json, api_lb) self.assertEqual(subnet2.id, api_lb.get('vip', {}).get('subnet_id')) self.assertEqual(network_id, api_lb.get('vip', {}).get('network_id'))
def execute(self, amphora, loadbalancer, amphorae_network_config): """Execute post_vip_routine.""" db_amp = self.amphora_repo.get(db_apis.get_session(), id=amphora.get(constants.ID)) db_lb = self.loadbalancer_repo.get( db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID]) vrrp_port = data_models.Port( **amphorae_network_config[ amphora.get(constants.ID)][constants.VRRP_PORT]) # Required for noop-case vip_arg = amphorae_network_config[amphora.get( constants.ID)][constants.VIP_SUBNET] if vip_arg: host_routes = vip_arg.get('host_routes') if host_routes: vip_arg['host_routes'] = [ data_models.HostRoute(**hr) for hr in host_routes ] vip_subnet = data_models.Subnet(**vip_arg) else: vip_subnet = data_models.Subnet() self.amphora_driver.post_vip_plug( db_amp, db_lb, amphorae_network_config, vrrp_port=vrrp_port, vip_subnet=vip_subnet) LOG.debug("Notified amphora of vip plug")
def test_subnet_exists_with_valid_subnet(self): subnet_id = uuidutils.generate_uuid() subnet = network_models.Subnet(id=subnet_id) with mock.patch( 'octavia.common.utils.get_network_driver') as net_mock: net_mock.return_value.get_subnet.return_value = subnet self.assertEqual(validate.subnet_exists(subnet_id), subnet)
def test_create_with_vip_full(self): subnet = network_models.Subnet(id=uuidutils.generate_uuid()) network = network_models.Network(id=uuidutils.generate_uuid(), subnets=[subnet]) port = network_models.Port(id=uuidutils.generate_uuid(), network_id=network.id) lb_json = { 'name': 'test1', 'description': 'test1_desc', 'vip_address': '10.0.0.1', 'vip_subnet_id': subnet.id, 'vip_network_id': network.id, 'vip_port_id': port.id, 'admin_state_up': False, 'project_id': self.project_id} body = self._build_body(lb_json) with mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_network") as mock_get_network, \ mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_port") as mock_get_port: mock_get_network.return_value = network mock_get_port.return_value = port response = self.post(self.LBS_PATH, body) api_lb = response.json.get(self.root_tag) self._assert_request_matches_response(lb_json, api_lb) self.assertEqual('10.0.0.1', api_lb.get('vip_address')) self.assertEqual(subnet.id, api_lb.get('vip_subnet_id')) self.assertEqual(network.id, api_lb.get('vip_network_id')) self.assertEqual(port.id, api_lb.get('vip_port_id'))
def test_create_with_vip_full(self): subnet = network_models.Subnet(id=uuidutils.generate_uuid()) network = network_models.Network(id=uuidutils.generate_uuid(), subnets=[subnet]) port = network_models.Port(id=uuidutils.generate_uuid(), network_id=network.id) vip = { 'ip_address': '10.0.0.1', 'subnet_id': subnet.id, 'network_id': network.id, 'port_id': port.id } lb_json = { 'name': 'test1', 'description': 'test1_desc', 'vip': vip, 'enabled': False, 'project_id': self.project_id } with mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_network") as mock_get_network, \ mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_port") as mock_get_port: mock_get_network.return_value = network mock_get_port.return_value = port response = self.post(self.LBS_PATH, lb_json) api_lb = response.json self._assert_request_matches_response(lb_json, api_lb) self.assertEqual(vip, api_lb.get('vip'))
def setUp(self): super(TestNoopAmphoraLoadBalancerDriver, self).setUp() self.driver = driver.NoopAmphoraLoadBalancerDriver() self.listener = data_models.Listener() self.listener.id = uuidutils.generate_uuid() self.listener.protocol_port = 80 self.vip = data_models.Vip() self.vip.ip_address = "10.0.0.1" self.amphora = data_models.Amphora() self.amphora.id = self.FAKE_UUID_1 self.load_balancer = data_models.LoadBalancer( id=FAKE_UUID_1, amphorae=[self.amphora], vip=self.vip, listeners=[self.listener]) self.listener.load_balancer = self.load_balancer self.network = network_models.Network(id=self.FAKE_UUID_1) self.port = network_models.Port(id=uuidutils.generate_uuid()) self.amphorae_net_configs = { self.amphora.id: network_models.AmphoraNetworkConfig( amphora=self.amphora, vip_subnet=network_models.Subnet(id=self.FAKE_UUID_1)) } self.pem_file = 'test_pem_file' self.agent_config = 'test agent config' self.timeout_dict = { constants.REQ_CONN_TIMEOUT: 1, constants.REQ_READ_TIMEOUT: 2, constants.CONN_MAX_RETRIES: 3, constants.CONN_RETRY_INTERVAL: 4 }
def test_get(self): project_id = uuidutils.generate_uuid() subnet = network_models.Subnet(id=uuidutils.generate_uuid()) network = network_models.Network(id=uuidutils.generate_uuid(), subnets=[subnet]) port = network_models.Port(id=uuidutils.generate_uuid(), network_id=network.id) with mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_network") as mock_get_network, \ mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_port") as mock_get_port: mock_get_network.return_value = network mock_get_port.return_value = port lb = self.create_load_balancer(subnet.id, vip_address='10.0.0.1', vip_network_id=network.id, vip_port_id=port.id, name='lb1', project_id=project_id, description='desc1', admin_state_up=False) lb_dict = lb.get(self.root_tag) response = self.get( self.LB_PATH.format( lb_id=lb_dict.get('id'))).json.get(self.root_tag) self.assertEqual('lb1', response.get('name')) self.assertEqual(project_id, response.get('project_id')) self.assertEqual('desc1', response.get('description')) self.assertFalse(response.get('admin_state_up')) self.assertEqual('10.0.0.1', response.get('vip_address')) self.assertEqual(subnet.id, response.get('vip_subnet_id')) self.assertEqual(network.id, response.get('vip_network_id')) self.assertEqual(port.id, response.get('vip_port_id'))
def test_get(self): subnet = network_models.Subnet(id=uuidutils.generate_uuid()) network = network_models.Network(id=uuidutils.generate_uuid(), subnets=[subnet]) port = network_models.Port(id=uuidutils.generate_uuid(), network_id=network.id) vip = { 'ip_address': '10.0.0.1', 'subnet_id': subnet.id, 'network_id': network.id, 'port_id': port.id } with mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_network") as mock_get_network, \ mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_port") as mock_get_port: mock_get_network.return_value = network mock_get_port.return_value = port lb = self.create_load_balancer(vip, name='lb1', description='test1_desc', enabled=False) response = self.get(self.LB_PATH.format(lb_id=lb.get('id'))) self.assertEqual('lb1', response.json.get('name')) self.assertEqual('test1_desc', response.json.get('description')) self.assertFalse(response.json.get('enabled')) self.assertEqual(vip, response.json.get('vip'))
def execute(self, amphora, ports): """Execute post_network_plug routine.""" db_amp = self.amphora_repo.get(db_apis.get_session(), id=amphora[constants.ID]) for port in ports: net = data_models.Network(**port.pop(constants.NETWORK)) ips = port.pop(constants.FIXED_IPS) fixed_ips = [] for ip in ips: subnet_arg = ip.pop(constants.SUBNET) host_routes = subnet_arg.get('host_routes') if host_routes: subnet_arg['host_routes'] = [ data_models.HostRoute(**hr) for hr in host_routes ] fixed_ips.append(data_models.FixedIP( subnet=data_models.Subnet(**subnet_arg), **ip)) self.amphora_driver.post_network_plug( db_amp, data_models.Port(network=net, fixed_ips=fixed_ips, **port)) LOG.debug("post_network_plug called on compute instance " "%(compute_id)s for port %(port_id)s", {"compute_id": amphora[constants.COMPUTE_ID], "port_id": port[constants.ID]})
def test_post_network_plug_with_host_routes(self): SUBNET_ID = 'SUBNET_ID' FIXED_IP1 = '192.0.2.2' FIXED_IP2 = '192.0.2.3' SUBNET_CIDR = '192.0.2.0/24' DEST1 = '198.51.100.0/24' DEST2 = '203.0.113.0/24' NEXTHOP = '192.0.2.1' host_routes = [ network_models.HostRoute(destination=DEST1, nexthop=NEXTHOP), network_models.HostRoute(destination=DEST2, nexthop=NEXTHOP) ] subnet = network_models.Subnet(id=SUBNET_ID, cidr=SUBNET_CIDR, ip_version=4, host_routes=host_routes) fixed_ips = [ network_models.FixedIP(subnet_id=subnet.id, ip_address=FIXED_IP1, subnet=subnet), network_models.FixedIP(subnet_id=subnet.id, ip_address=FIXED_IP2, subnet=subnet) ] port = network_models.Port(mac_address=FAKE_MAC_ADDRESS, fixed_ips=fixed_ips, network=self.network) self.driver.post_network_plug(self.amp, port) expected_fixed_ips = [{ 'ip_address': FIXED_IP1, 'subnet_cidr': SUBNET_CIDR, 'host_routes': [{ 'destination': DEST1, 'nexthop': NEXTHOP }, { 'destination': DEST2, 'nexthop': NEXTHOP }] }, { 'ip_address': FIXED_IP2, 'subnet_cidr': SUBNET_CIDR, 'host_routes': [{ 'destination': DEST1, 'nexthop': NEXTHOP }, { 'destination': DEST2, 'nexthop': NEXTHOP }] }] self.driver.client.plug_network.assert_called_once_with( self.amp, dict(mac_address=FAKE_MAC_ADDRESS, fixed_ips=expected_fixed_ips, mtu=FAKE_MTU))
def convert_subnet_dict_to_model(subnet_dict): subnet = subnet_dict.get('subnet', subnet_dict) return network_models.Subnet(id=subnet.get('id'), name=subnet.get('name'), network_id=subnet.get('network_id'), project_id=subnet.get('tenant_id'), gateway_ip=subnet.get('gateway_ip'), cidr=subnet.get('cidr'), ip_version=subnet.get('ip_version') )
def test_post_vip_plug(self, exec_command): amps = [data_models.Amphora(id=MOCK_AMP_ID, compute_id=MOCK_COMPUTE_ID, lb_network_ip=MOCK_IP_ADDRESS)] vip = data_models.Vip(ip_address=MOCK_IP_ADDRESS) lb = data_models.LoadBalancer(amphorae=amps, vip=vip) vip_subnet = network_models.Subnet(id=MOCK_SUBNET_ID, gateway_ip=MOCK_IP_ADDRESS, cidr=MOCK_CIDR) vip_port = network_models.Port(id=MOCK_PORT_ID, device_id=MOCK_COMPUTE_ID) amphorae_net_config = {amps[0].id: network_models.AmphoraNetworkConfig( amphora=amps[0], vip_subnet=vip_subnet, vip_port=vip_port, vrrp_port=self.port )} iface = 'eth1' exec_command.return_value = ('{0}: '.format(iface), '') self.driver.post_vip_plug(lb, amphorae_net_config) grep_call = mock.call( ssh_driver.CMD_GREP_LINK_BY_MAC.format(mac_address='123')) dhclient_call = mock.call(ssh_driver.CMD_DHCLIENT.format(iface), run_as_root=True) add_ip_call = mock.call(ssh_driver.CMD_ADD_IP_ADDR.format( MOCK_IP_ADDRESS, iface), run_as_root=True) show_ip_call = mock.call(ssh_driver.CMD_SHOW_IP_ADDR.format(iface)) create_vip_table_call = mock.call( ssh_driver.CMD_CREATE_VIP_ROUTE_TABLE.format( ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) add_route_call = mock.call( ssh_driver.CMD_ADD_ROUTE_TO_TABLE.format( MOCK_CIDR, iface, ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) add_default_route_call = mock.call( ssh_driver.CMD_ADD_DEFAULT_ROUTE_TO_TABLE.format( MOCK_IP_ADDRESS, iface, ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) add_rule_from_call = mock.call( ssh_driver.CMD_ADD_RULE_FROM_NET_TO_TABLE.format( MOCK_CIDR, ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) add_rule_to_call = mock.call( ssh_driver.CMD_ADD_RULE_TO_NET_TO_TABLE.format( MOCK_CIDR, ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) exec_command.assert_has_calls([grep_call, dhclient_call, add_ip_call, show_ip_call, create_vip_table_call, add_route_call, add_default_route_call, add_rule_from_call, add_rule_to_call]) self.assertEqual(9, exec_command.call_count)
def test_amphora_post_vip_plug( self, mock_lb_get, mock_loadbalancer_repo_update, mock_driver, mock_generate_uuid, mock_log, mock_get_session, mock_listener_repo_get, mock_listener_repo_update, mock_amphora_repo_get, mock_amphora_repo_update): amphorae_net_config_mock = mock.MagicMock() mock_amphora_repo_get.return_value = _db_amphora_mock mock_lb_get.return_value = _db_load_balancer_mock amphora_post_vip_plug_obj = amphora_driver_tasks.AmphoraPostVIPPlug() amphora_post_vip_plug_obj.execute(_amphora_mock, _LB_mock, amphorae_net_config_mock) vip_subnet = network_data_models.Subnet( **amphorae_net_config_mock[AMP_ID]['vip_subnet']) vrrp_port = network_data_models.Port( **amphorae_net_config_mock[AMP_ID]['vrrp_port']) mock_driver.post_vip_plug.assert_called_once_with( _db_amphora_mock, _db_load_balancer_mock, amphorae_net_config_mock, vip_subnet=vip_subnet, vrrp_port=vrrp_port) # Test revert amp = amphora_post_vip_plug_obj.revert(None, _amphora_mock, _LB_mock) repo.AmphoraRepository.update.assert_called_once_with( _session_mock, id=AMP_ID, status=constants.ERROR) repo.LoadBalancerRepository.update.assert_called_once_with( _session_mock, id=LB_ID, provisioning_status=constants.ERROR) self.assertIsNone(amp) # Test revert with repo exceptions repo.AmphoraRepository.update.reset_mock() repo.LoadBalancerRepository.update.reset_mock() mock_amphora_repo_update.side_effect = Exception('fail') mock_loadbalancer_repo_update.side_effect = Exception('fail') amp = amphora_post_vip_plug_obj.revert(None, _amphora_mock, _LB_mock) repo.AmphoraRepository.update.assert_called_once_with( _session_mock, id=AMP_ID, status=constants.ERROR) repo.LoadBalancerRepository.update.assert_called_once_with( _session_mock, id=LB_ID, provisioning_status=constants.ERROR) self.assertIsNone(amp) # Test revert when this task failed repo.AmphoraRepository.update.reset_mock() amp = amphora_post_vip_plug_obj.revert( failure.Failure.from_exception(Exception('boom')), _amphora_mock, None) repo.AmphoraRepository.update.assert_not_called()
def test_create_with_vip_subnet_fills_network(self): subnet = network_models.Subnet(id=uuidutils.generate_uuid(), network_id=uuidutils.generate_uuid()) lb_json = {'vip_subnet_id': subnet.id, 'project_id': self.project_id} body = self._build_body(lb_json) with mock.patch("octavia.network.drivers.noop_driver.driver" ".NoopManager.get_subnet") as mock_get_subnet: mock_get_subnet.return_value = subnet response = self.post(self.LBS_PATH, body) api_lb = response.json.get(self.root_tag) self._assert_request_matches_response(lb_json, api_lb) self.assertEqual(subnet.id, api_lb.get('vip_subnet_id')) self.assertEqual(subnet.network_id, api_lb.get('vip_network_id'))
def convert_subnet_dict_to_model(subnet_dict): subnet = subnet_dict.get('subnet', subnet_dict) subnet_hrs = subnet.get('host_routes', []) host_routes = [network_models.HostRoute(nexthop=hr.get('nexthop'), destination=hr.get('destination')) for hr in subnet_hrs] return network_models.Subnet(id=subnet.get('id'), name=subnet.get('name'), network_id=subnet.get('network_id'), project_id=subnet.get('tenant_id'), gateway_ip=subnet.get('gateway_ip'), cidr=subnet.get('cidr'), ip_version=subnet.get('ip_version'), host_routes=host_routes )
def execute(self, amphora, loadbalancer, amphorae_network_config): """Execute post_vip_routine.""" db_amp = self.amphora_repo.get(db_apis.get_session(), id=amphora.get(constants.ID)) db_lb = self.loadbalancer_repo.get( db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID]) vrrp_port = data_models.Port(**amphorae_network_config[amphora.get( constants.ID)][constants.VRRP_PORT]) vip_subnet = data_models.Subnet(**amphorae_network_config[amphora.get( constants.ID)][constants.VIP_SUBNET]) self.amphora_driver.post_vip_plug(db_amp, db_lb, amphorae_network_config, vrrp_port=vrrp_port, vip_subnet=vip_subnet) LOG.debug("Notified amphora of vip plug")
def setUp(self): super(TestNoopAmphoraLoadBalancerDriver, self).setUp() self.driver = driver.NoopAmphoraLoadBalancerDriver() self.listener = data_models.Listener() self.listener.protocol_port = 80 self.vip = data_models.Vip() self.vip.ip_address = "10.0.0.1" self.amphora = data_models.Amphora() self.amphora.id = self.FAKE_UUID_1 self.load_balancer = data_models.LoadBalancer( id=FAKE_UUID_1, amphorae=[self.amphora], vip=self.vip, listeners=[self.listener]) self.network = network_models.Network(id=self.FAKE_UUID_1) self.port = network_models.Port(id=uuidutils.generate_uuid()) self.amphorae_net_configs = { self.amphora.id: network_models.AmphoraNetworkConfig( amphora=self.amphora, vip_subnet=network_models.Subnet(id=self.FAKE_UUID_1)) }
def get_subnet_by_name(self, subnet_name): LOG.debug("Subnet %s no-op, get_subnet_by_name subnet_name %s", self.__class__.__name__, subnet_name) self.networkconfigconfig[subnet_name] = (subnet_name, 'get_subnet_by_name') return network_models.Subnet(id=uuidutils.generate_uuid())
def get_subnet(self, subnet_id): LOG.debug("Subnet %s no-op, get_subnet subnet_id %s", self.__class__.__name__, subnet_id) self.networkconfigconfig[subnet_id] = (subnet_id, 'get_subnet') return network_models.Subnet(id=uuidutils.generate_uuid())
def test_calculate_delta(self, mock_get_session, mock_get_lb, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_lb.return_value = self.db_load_balancer_mock self.db_amphora_mock.to_dict.return_value = { constants.ID: AMPHORA_ID, constants.COMPUTE_ID: COMPUTE_ID, constants.VRRP_PORT_ID: PORT_ID} mock_get_net_driver.return_value = mock_driver mock_driver.get_plugged_networks.return_value = [ data_models.Interface(network_id='netid')] mock_driver.get_port.return_value = data_models.Port( network_id='netid') EMPTY = {} empty_deltas = {self.db_amphora_mock.id: data_models.Delta( amphora_id=AMPHORA_ID, compute_id=COMPUTE_ID, add_nics=[], delete_nics=[]).to_dict(recurse=True)} calc_delta = network_tasks.CalculateDelta() self.assertEqual(EMPTY, calc_delta.execute(self.load_balancer_mock, {})) # Test with one amp and no pools, nothing plugged # Delta should be empty mock_driver.reset_mock() self.db_amphora_mock.load_balancer = self.db_load_balancer_mock self.db_load_balancer_mock.amphorae = [self.db_amphora_mock] self.db_load_balancer_mock.pools = [] self.assertEqual(empty_deltas, calc_delta.execute(self.load_balancer_mock, {})) mock_driver.get_plugged_networks.assert_called_once_with(COMPUTE_ID) # Pool mock should be configured explicitly for each test pool_mock = mock.MagicMock() self.db_load_balancer_mock.pools = [pool_mock] # Test with one amp and one pool but no members, nothing plugged # Delta should be empty pool_mock.members = [] self.assertEqual(empty_deltas, calc_delta.execute(self.load_balancer_mock, {})) # Test with one amp and one pool and one member, nothing plugged # Delta should be one additional subnet to plug mock_driver.reset_mock() member_mock = mock.MagicMock() member_mock.subnet_id = 1 pool_mock.members = [member_mock] mock_driver.get_subnet.return_value = data_models.Subnet(id=2, network_id=3) ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[ data_models.Interface(network_id=3)], delete_nics=[]).to_dict(recurse=True) self.assertEqual({self.db_amphora_mock.id: ndm}, calc_delta.execute(self.load_balancer_mock, {})) vrrp_port_call = mock.call(PORT_ID) mock_driver.get_port.assert_has_calls([vrrp_port_call]) self.assertEqual(1, mock_driver.get_port.call_count) member_subnet_call = mock.call(member_mock.subnet_id) mock_driver.get_subnet.assert_has_calls([member_subnet_call]) self.assertEqual(1, mock_driver.get_subnet.call_count) # Test with one amp and one pool and one member, already plugged # Delta should be empty mock_driver.reset_mock() member_mock = mock.MagicMock() member_mock.subnet_id = 1 pool_mock.members = [member_mock] mock_driver.get_plugged_networks.return_value = [ data_models.Interface(network_id=3), data_models.Interface(network_id='netid')] self.assertEqual(empty_deltas, calc_delta.execute(self.load_balancer_mock, {})) # Test with one amp and one pool and one member, wrong network plugged # Delta should be one network to add and one to remove mock_driver.reset_mock() member_mock = mock.MagicMock() member_mock.subnet_id = 1 pool_mock.members = [member_mock] mock_driver.get_plugged_networks.return_value = [ data_models.Interface(network_id=2), data_models.Interface(network_id='netid')] ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[ data_models.Interface(network_id=3)], delete_nics=[ data_models.Interface(network_id=2)] ).to_dict(recurse=True) self.assertEqual({self.db_amphora_mock.id: ndm}, calc_delta.execute(self.load_balancer_mock, {})) # Test with one amp and one pool and no members, one network plugged # Delta should be one network to remove mock_driver.reset_mock() pool_mock.members = [] mock_driver.get_plugged_networks.return_value = [ data_models.Interface(network_id=2), data_models.Interface(network_id='netid') ] ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[], delete_nics=[ data_models.Interface(network_id=2)] ).to_dict(recurse=True) self.assertEqual({self.db_amphora_mock.id: ndm}, calc_delta.execute(self.load_balancer_mock, {}))
def setUp(self): super(TestHaproxyAmphoraLoadBalancerDriverTest, self).setUp() DEST1 = '198.51.100.0/24' DEST2 = '203.0.113.0/24' NEXTHOP = '192.0.2.1' self.driver = driver.HaproxyAmphoraLoadBalancerDriver() self.driver.cert_manager = mock.MagicMock() self.driver.cert_parser = mock.MagicMock() self.driver.client = mock.MagicMock() self.driver.jinja = mock.MagicMock() self.driver.udp_jinja = mock.MagicMock() # Build sample Listener and VIP configs self.sl = sample_configs.sample_listener_tuple(tls=True, sni=True) self.sl_udp = sample_configs.sample_listener_tuple( proto=constants.PROTOCOL_UDP, persistence_type=constants.SESSION_PERSISTENCE_SOURCE_IP, persistence_timeout=33, persistence_granularity='255.255.0.0', monitor_proto=constants.HEALTH_MONITOR_UDP_CONNECT) self.amp = self.sl.load_balancer.amphorae[0] self.sv = sample_configs.sample_vip_tuple() self.lb = self.sl.load_balancer self.fixed_ip = mock.MagicMock() self.fixed_ip.ip_address = '198.51.100.5' self.fixed_ip.subnet.cidr = '198.51.100.0/24' self.network = network_models.Network(mtu=FAKE_MTU) self.port = network_models.Port(mac_address=FAKE_MAC_ADDRESS, fixed_ips=[self.fixed_ip], network=self.network) self.host_routes = [ network_models.HostRoute(destination=DEST1, nexthop=NEXTHOP), network_models.HostRoute(destination=DEST2, nexthop=NEXTHOP) ] host_routes_data = [{ 'destination': DEST1, 'nexthop': NEXTHOP }, { 'destination': DEST2, 'nexthop': NEXTHOP }] self.subnet_info = { 'subnet_cidr': FAKE_CIDR, 'gateway': FAKE_GATEWAY, 'mac_address': FAKE_MAC_ADDRESS, 'vrrp_ip': self.amp.vrrp_ip, 'mtu': FAKE_MTU, 'host_routes': host_routes_data } self.subnet = network_models.Subnet(gateway_ip='10.10.10.1', host_routes=self.host_routes, cidr='10.10.10.0/24') self.timeout_dict = { constants.REQ_CONN_TIMEOUT: 1, constants.REQ_READ_TIMEOUT: 2, constants.CONN_MAX_RETRIES: 3, constants.CONN_RETRY_INTERVAL: 4 }
def test_calculate_delta(self, mock_driver): EMPTY = {} empty_deltas = { self.amphora_mock.id: data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=[]) } def _interface(network_id): return [data_models.Interface(network_id=network_id)] net = network_tasks.CalculateDelta() self.assertEqual(EMPTY, net.execute(self.load_balancer_mock)) self.amphora_mock.load_balancer = self.load_balancer_mock self.load_balancer_mock.amphorae = [self.amphora_mock] self.load_balancer_mock.listeners = None self.assertEqual({self.amphora_mock.id: None}, net.execute(self.load_balancer_mock)) listener_mock = mock.MagicMock() self.load_balancer_mock.listeners = [listener_mock] listener_mock.default_pool = None self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) mock_driver.get_plugged_networks.assert_called_once_with(COMPUTE_ID) pool_mock = mock.MagicMock() listener_mock.default_pool = pool_mock pool_mock.members = None self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) member_mock = mock.MagicMock() pool_mock.members = [member_mock] member_mock.subnet_id = 1 mock_driver.get_subnet.reset_mock() mock_driver.get_subnet.return_value = data_models.Subnet(id=2, network_id=3) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(2), delete_nics=[]) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock)) vip_subnet_call = mock.call(self.vip_mock.subnet_id) member_subnet_call = mock.call(member_mock.subnet_id) mock_driver.get_subnet.assert_has_calls( [vip_subnet_call, member_subnet_call]) self.assertEqual(2, mock_driver.get_subnet.call_count) mock_driver.get_plugged_networks.return_value = _interface(2) self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) mock_driver.get_plugged_networks.return_value = _interface(3) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(2), delete_nics=_interface(3)) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock)) pool_mock.members = [] mock_driver.get_plugged_networks.return_value = _interface(2) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=_interface(2)) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock))
import mock from oslo_config import cfg from oslo_config import fixture as oslo_fixture from octavia.common import data_models as o_data_models from octavia.network import data_models as o_net_data_models from a10_octavia.common import config_options from a10_octavia.common import data_models from a10_octavia.controller.worker.tasks import a10_network_tasks from a10_octavia.tests.common import a10constants from a10_octavia.tests.unit import base MEMBER = o_data_models.Member(subnet_id=a10constants.MOCK_SUBNET_ID) VTHUNDER = data_models.VThunder() SUBNET = o_net_data_models.Subnet() PORT = o_net_data_models.Port() VRID = data_models.VRID() VRID_VALUE = 0 SUBNET_1 = o_net_data_models.Subnet(id=a10constants.MOCK_SUBNET_ID) VRID_1 = data_models.VRID(id=1, subnet_id=a10constants.MOCK_SUBNET_ID) NAT_POOL = data_models.NATPool(port_id=a10constants.MOCK_PORT_ID) NAT_FLAVOR = { "pool_name": "p1", "start_address": "1.1.1.1", "end_address": "1.1.1.2" } HW_THUNDER = data_models.HardwareThunder( project_id=a10constants.MOCK_PROJECT_ID, device_name="rack_thunder_1", undercloud=True,
from oslo_config import cfg from oslo_config import fixture as oslo_fixture from octavia.common import data_models as o_data_models from octavia.network import data_models as o_net_data_models from a10_octavia.common import config_options from a10_octavia.common import data_models from a10_octavia.common import exceptions from a10_octavia.controller.worker.tasks import a10_network_tasks from a10_octavia.tests.common import a10constants from a10_octavia.tests.unit import base MEMBER = o_data_models.Member() VTHUNDER = data_models.VThunder() SUBNET = o_net_data_models.Subnet() PORT = o_net_data_models.Port() VRID = data_models.VRID() VRID_VALUE = 0 class MockIP(object): def __init__(self, ip_address): self.ip_address = ip_address class TestNetworkTasks(base.BaseTaskTestCase): def setUp(self): super(TestNetworkTasks, self).setUp() imp.reload(a10_network_tasks) patcher = mock.patch(
def test_calculate_delta(self, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_net_driver.return_value = mock_driver EMPTY = {} empty_deltas = {self.amphora_mock.id: data_models.Delta( amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=[])} def _interface(network_id): return [data_models.Interface(network_id=network_id)] net = network_tasks.CalculateDelta() self.assertEqual(EMPTY, net.execute(self.load_balancer_mock)) self.amphora_mock.load_balancer = self.load_balancer_mock self.load_balancer_mock.amphorae = [self.amphora_mock] self.load_balancer_mock.pools = [] self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) mock_driver.get_plugged_networks.assert_called_once_with(COMPUTE_ID) pool_mock = mock.MagicMock() self.load_balancer_mock.pools = [pool_mock] pool_mock.members = [] self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) member_mock = mock.MagicMock() pool_mock.members = [member_mock] member_mock.subnet_id = 1 mock_driver.get_subnet.reset_mock() mock_driver.get_subnet.return_value = data_models.Subnet(id=2, network_id=3) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(2), delete_nics=[]) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock)) vrrp_port_call = mock.call(self.amphora_mock.vrrp_port_id) mock_driver.get_port.assert_has_calls([vrrp_port_call]) # For some reason we call calculate_delta three times? self.assertEqual(3, mock_driver.get_port.call_count) member_subnet_call = mock.call(member_mock.subnet_id) mock_driver.get_subnet.assert_has_calls([member_subnet_call]) self.assertEqual(1, mock_driver.get_subnet.call_count) mock_driver.get_plugged_networks.return_value = _interface(2) self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) mock_driver.get_plugged_networks.return_value = _interface(3) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(2), delete_nics=_interface(3)) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock)) pool_mock.members = [] mock_driver.get_plugged_networks.return_value = _interface(2) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=_interface(2)) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock))
POOL = o_data_models.Pool(id=a10constants.MOCK_POOL_ID, load_balancer=LB) HM = o_data_models.HealthMonitor(id=a10constants, pool=POOL) MEMBER_1 = o_data_models.Member(id=uuidutils.generate_uuid(), project_id=a10constants.MOCK_PROJECT_ID, subnet_id=a10constants.MOCK_SUBNET_ID, pool=POOL) MEMBER_2 = o_data_models.Member(id=uuidutils.generate_uuid(), project_id=a10constants.MOCK_PROJECT_ID, subnet_id=a10constants.MOCK_SUBNET_ID_2, pool=POOL) FLAVOR_PROFILE = o_data_models.FlavorProfile( id=a10constants.MOCK_FLAVOR_PROF_ID, flavor_data={}) FLAVOR = o_data_models.Flavor( id=a10constants.MOCK_FLAVOR_ID, flavor_profile_id=a10constants.MOCK_FLAVOR_PROF_ID) SUBNET = n_data_models.Subnet(id=uuidutils.generate_uuid()) NAT_POOL = data_models.NATPool(id=uuidutils.generate_uuid(), port_id=a10constants.MOCK_PORT_ID) class TestA10DatabaseTasks(base.BaseTaskTestCase): def setUp(self): super(TestA10DatabaseTasks, self).setUp() imp.reload(task) self.vrid_repo = mock.Mock() self.nat_pool_repo = mock.Mock() self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF)) self.conf.register_opts(config_options.A10_GLOBAL_OPTS, group=a10constants.A10_GLOBAL_CONF_SECTION) self.conf.register_opts( config_options.A10_HARDWARE_THUNDER_OPTS,
from octavia.network import data_models as n_data_models from octavia.tests.common import constants as t_constants from acos_client import errors as acos_errors from a10_octavia.common import config_options from a10_octavia.common import data_models as a10_data_models from a10_octavia.common import exceptions as a10_ex from a10_octavia.controller.worker.tasks import glm_tasks as task from a10_octavia.tests.common import a10constants from a10_octavia.tests.unit import base VTHUNDER = a10_data_models.VThunder(id=a10constants.MOCK_VTHUNDER_ID) AMPHORA = o_data_models.Amphora(id=t_constants.MOCK_AMP_ID1) DNS_SUBNET = n_data_models.Subnet(id=a10constants.MOCK_SUBNET_ID) DNS_NETWORK = n_data_models.Network(id=a10constants.MOCK_NETWORK_ID, subnets=[DNS_SUBNET.id]) PRIMARY_DNS = '1.3.3.7' SECONDARY_DNS = '1.0.0.7' PROXY_HOST = '10.10.10.10' PROXY_PORT = 1111 PROXY_USERNAME = '******' PROXY_PASSWORD = True PROXY_PASSWORD_VALUE = 'password' class TestGLMTasks(base.BaseTaskTestCase): def setUp(self): super(TestGLMTasks, self).setUp()