def test_get_member_ports(self, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_net_driver.return_value = mock_driver def _interface(port_id): return [data_models.Interface(port_id=port_id)] net_task = network_tasks.GetMemberPorts() net_task.execute(self.load_balancer_mock, self.amphora_mock) mock_driver.get_port.assert_called_once_with(t_constants.MOCK_PORT_ID) mock_driver.get_plugged_networks.assert_called_once_with(COMPUTE_ID) mock_driver.reset_mock() net_task = network_tasks.GetMemberPorts() mock_driver.get_plugged_networks.return_value = _interface(1) mock_driver.get_port.side_effect = [ data_models.Port(network_id=NETWORK_ID), data_models.Port(network_id=NETWORK_ID)] net_task.execute(self.load_balancer_mock, self.amphora_mock) self.assertEqual(2, mock_driver.get_port.call_count) self.assertFalse(mock_driver.get_network.called) mock_driver.reset_mock() port_mock = mock.MagicMock() fixed_ip_mock = mock.MagicMock() fixed_ip_mock.subnet_id = 1 port_mock.fixed_ips = [fixed_ip_mock] net_task = network_tasks.GetMemberPorts() mock_driver.get_plugged_networks.return_value = _interface(1) mock_driver.get_port.side_effect = [ data_models.Port(network_id=NETWORK_ID), port_mock] ports = net_task.execute(self.load_balancer_mock, self.amphora_mock) mock_driver.get_subnet.assert_called_once_with(1) self.assertEqual([port_mock], ports)
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_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 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.timeout_dict = { constants.REQ_CONN_TIMEOUT: 1, constants.REQ_READ_TIMEOUT: 2, constants.CONN_MAX_RETRIES: 3, constants.CONN_RETRY_INTERVAL: 4 }
def get_port_by_net_id_device_id(self, network_id, device_id): LOG.debug( "Port %s no-op, get_port_by_net_id_device_id network_id %s" " device_id %s", self.__class__.__name__, network_id, device_id) self.networkconfigconfig[(network_id, device_id)] = ( network_id, device_id, 'get_port_by_net_id_device_id') return network_models.Port(id=uuidutils.generate_uuid())
def test_port_exists_with_valid_port(self): port_id = uuidutils.generate_uuid() port = network_models.Port(id=port_id) with mock.patch( 'octavia.common.utils.get_network_driver') as net_mock: net_mock.return_value.get_port.return_value = port self.assertEqual(validate.port_exists(port_id), port)
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 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 test_amphora_post_network_plug(self, 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): amphora_post_network_plug_obj = ( amphora_driver_tasks.AmphoraPostNetworkPlug()) mock_amphora_repo_get.return_value = _db_amphora_mock port_mock = { constants.NETWORK: mock.MagicMock(), constants.FIXED_IPS: [mock.MagicMock()], constants.ID: uuidutils.generate_uuid() } amphora_post_network_plug_obj.execute(_amphora_mock, [port_mock]) (mock_driver.post_network_plug.assert_called_once_with)( _db_amphora_mock, network_data_models.Port(**port_mock)) # Test revert amp = amphora_post_network_plug_obj.revert(None, _amphora_mock) repo.AmphoraRepository.update.assert_called_once_with( _session_mock, id=AMP_ID, status=constants.ERROR) self.assertIsNone(amp) # Test revert with exception repo.AmphoraRepository.update.reset_mock() mock_amphora_repo_update.side_effect = Exception('fail') amp = amphora_post_network_plug_obj.revert(None, _amphora_mock) repo.AmphoraRepository.update.assert_called_once_with( _session_mock, id=AMP_ID, status=constants.ERROR) self.assertIsNone(amp)
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 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_check_port_in_use(self): port_id = uuidutils.generate_uuid() device_id = uuidutils.generate_uuid() port = network_models.Port(id=port_id, device_id=device_id) with mock.patch('octavia.common.utils.get_network_driver') as net_mock: net_mock.return_value.get_port.device_id = port self.assertRaises(exceptions.ValidationException, validate.check_port_in_use, port)
def test_amphorae_post_network_plug( self, mock_lb_get, 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): mock_driver.get_network.return_value = _network_mock _db_amphora_mock.id = AMP_ID _db_amphora_mock.compute_id = COMPUTE_ID _db_load_balancer_mock.amphorae = [_db_amphora_mock] mock_lb_get.return_value = _db_load_balancer_mock mock_amphora_repo_get.return_value = _db_amphora_mock amphora_post_network_plug_obj = ( amphora_driver_tasks.AmphoraePostNetworkPlug()) port_mock = { constants.NETWORK: mock.MagicMock(), constants.FIXED_IPS: [mock.MagicMock()], constants.ID: uuidutils.generate_uuid() } _deltas_mock = {_db_amphora_mock.id: [port_mock]} amphora_post_network_plug_obj.execute(_LB_mock, _deltas_mock) (mock_driver.post_network_plug.assert_called_once_with( _db_amphora_mock, network_data_models.Port(**port_mock))) # Test with no ports to plug mock_driver.post_network_plug.reset_mock() _deltas_mock = {'0': [port_mock]} amphora_post_network_plug_obj.execute(_LB_mock, _deltas_mock) mock_driver.post_network_plug.assert_not_called() # Test revert amp = amphora_post_network_plug_obj.revert(None, _LB_mock, _deltas_mock) repo.AmphoraRepository.update.assert_called_once_with( _session_mock, id=AMP_ID, status=constants.ERROR) self.assertIsNone(amp) # Test revert with exception repo.AmphoraRepository.update.reset_mock() mock_amphora_repo_update.side_effect = Exception('fail') amp = amphora_post_network_plug_obj.revert(None, _LB_mock, _deltas_mock) repo.AmphoraRepository.update.assert_called_once_with( _session_mock, id=AMP_ID, status=constants.ERROR) self.assertIsNone(amp) # Test revert when this task failed repo.AmphoraRepository.update.reset_mock() amp = amphora_post_network_plug_obj.revert( failure.Failure.from_exception(Exception('boom')), _amphora_mock, None) repo.AmphoraRepository.update.assert_not_called()
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 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 setUp(self): super(TestHaproxyAmphoraLoadBalancerDriverTest, self).setUp() conf = oslo_fixture.Config(cfg.CONF) conf.config(group="haproxy_amphora", user_group="everyone") 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() # Build sample Listener and VIP configs self.sl = sample_configs.sample_listener_tuple(tls=True, sni=True) 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.timeout_dict = { constants.REQ_CONN_TIMEOUT: 1, constants.REQ_READ_TIMEOUT: 2, constants.CONN_MAX_RETRIES: 3, constants.CONN_RETRY_INTERVAL: 4 }
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 create_port(self, network_id, name=None, fixed_ips=(), secondary_ips=(), security_group_ids=(), admin_state_up=True, qos_policy_id=None): LOG.debug("Network %s no-op, create_port network_id %s", self.__class__.__name__, network_id) if not name: name = 'no-op-port' port_id = uuidutils.generate_uuid() project_id = uuidutils.generate_uuid() fixed_ip_obj_list = [] for fixed_ip in fixed_ips: if fixed_ip and not fixed_ip.get('ip_address'): fixed_ip_obj_list.append( network_models.FixedIP(subnet_id=fixed_ip.get('subnet_id'), ip_address='198.51.100.56')) else: fixed_ip_obj_list.append( network_models.FixedIP( subnet_id=fixed_ip.get('subnet_id'), ip_address=fixed_ip.get('ip_address'))) if not fixed_ip_obj_list: fixed_ip_obj_list = [ network_models.FixedIP(subnet_id=uuidutils.generate_uuid(), ip_address='198.51.100.56') ] self.networkconfigconfig[(network_id, 'create_port')] = (network_id, name, fixed_ip_obj_list, secondary_ips, security_group_ids, admin_state_up, qos_policy_id) return network_models.Port(id=port_id, name=name, device_id='no-op-device-id', device_owner='Octavia', mac_address='00:00:5E:00:53:05', network_id=network_id, status='UP', project_id=project_id, admin_state_up=admin_state_up, fixed_ips=fixed_ip_obj_list, qos_policy_id=qos_policy_id, security_group_ids=security_group_ids)
def setUp(self, mock_session): super(TestSshDriver, self).setUp() mock.MagicMock(keystone.get_session()) self.driver = ssh_driver.HaproxyManager() self.listener = sample_configs.sample_listener_tuple() self.vip = sample_configs.sample_vip_tuple() self.amphora = models.Amphora() self.amphora.id = self.FAKE_UUID_1 self.driver.cert_manager = mock.Mock( spec=cert_mgr.CertManager) self.driver.client = mock.Mock(spec=paramiko.SSHClient) self.driver.client.exec_command.return_value = ( mock.Mock(), mock.Mock(), mock.Mock()) self.driver.amp_config = mock.MagicMock() self.port = network_models.Port(mac_address='123')
def setUp(self): super(HaproxyAmphoraLoadBalancerDriverTest, self).setUp() 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() # Build sample Listener and VIP configs self.sl = sample_configs.sample_listener_tuple(tls=True, sni=True) self.amp = self.sl.load_balancer.amphorae[0] self.sv = sample_configs.sample_vip_tuple() self.lb = self.sl.load_balancer self.port = network_models.Port(mac_address='123')
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 convert_port_dict_to_model(port_dict): port = port_dict.get('port', port_dict) fixed_ips = [network_models.FixedIP(subnet_id=fixed_ip.get('subnet_id'), ip_address=fixed_ip.get('ip_address')) for fixed_ip in port.get('fixed_ips', [])] return network_models.Port( id=port.get('id'), name=port.get('name'), device_id=port.get('device_id'), device_owner=port.get('device_owner'), mac_address=port.get('mac_address'), network_id=port.get('network_id'), status=port.get('status'), project_id=port.get('tenant_id'), admin_state_up=port.get('admin_state_up'), fixed_ips=fixed_ips )
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() # Build sample Listener and VIP configs self.sl = sample_configs.sample_listener_tuple(tls=True, sni=True) 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 }
def convert_port_dict_to_model(port_dict): port = port_dict.get('port', port_dict) fixed_ips = [ network_models.FixedIP(subnet_id=fixed_ip.get('subnet_id'), ip_address=fixed_ip.get('ip_address')) for fixed_ip in port.get('fixed_ips', []) ] return network_models.Port(id=port.get(constants.ID), name=port.get(constants.NAME), device_id=port.get('device_id'), device_owner=port.get('device_owner'), mac_address=port.get('mac_address'), network_id=port.get('network_id'), status=port.get('status'), project_id=port.get(constants.TENANT_ID), admin_state_up=port.get('admin_state_up'), fixed_ips=fixed_ips, qos_policy_id=port.get('qos_policy_id'), security_group_ids=port.get( constants.SECURITY_GROUPS, []))
def test_post_network_plug(self): # Test dhcp path port = network_models.Port(mac_address=FAKE_MAC_ADDRESS, fixed_ips=[], network=self.network) self.driver.post_network_plug(self.amp, port) self.driver.client.plug_network.assert_called_once_with( self.amp, dict(mac_address=FAKE_MAC_ADDRESS, fixed_ips=[], mtu=FAKE_MTU)) self.driver.client.plug_network.reset_mock() # Test fixed IP path self.driver.post_network_plug(self.amp, self.port) self.driver.client.plug_network.assert_called_once_with( self.amp, dict(mac_address=FAKE_MAC_ADDRESS, fixed_ips=[dict(ip_address='198.51.100.5', subnet_cidr='198.51.100.0/24', host_routes=[])], mtu=FAKE_MTU))
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)) }
from a10_octavia.tests.common import a10constants from a10_octavia.tests.unit import base VTHUNDER = data_models.VThunder() HW_THUNDER = data_models.HardwareThunder( project_id=a10constants.MOCK_PROJECT_ID, device_name="rack_thunder_1", undercloud=True, username="******", password="******", ip_address="10.10.10.10", partition_name="shared") LB = o_data_models.LoadBalancer(id=a10constants.MOCK_LOAD_BALANCER_ID, flavor_id=a10constants.MOCK_FLAVOR_ID) FIXED_IP = n_data_models.FixedIP(ip_address='10.10.10.10') PORT = n_data_models.Port(id=uuidutils.generate_uuid(), fixed_ips=[FIXED_IP]) VRID = data_models.VRID(id=1, vrid=0, owner=a10constants.MOCK_PROJECT_ID, vrid_port_id=uuidutils.generate_uuid(), vrid_floating_ip='10.0.12.32') LISTENER = o_data_models.Listener(id=a10constants.MOCK_LISTENER_ID, load_balancer=LB) 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,
def get_port_by_name(self, port_name): LOG.debug("Port %s no-op, get_port_by_name port_name %s", self.__class__.__name__, port_name) self.networkconfigconfig[port_name] = (port_name, 'get_port_by_name') return network_models.Port(id=uuidutils.generate_uuid())
def get_port(self, port_id): LOG.debug("Port %s no-op, get_port port_id %s", self.__class__.__name__, port_id) self.networkconfigconfig[port_id] = (port_id, 'get_port') return network_models.Port(id=uuidutils.generate_uuid())