def test_create_loadbalancer_provider_mismatch(self): cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) lbaas = self.useFixture(k_fix.MockLBaaSClient()).client loadbalancer = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', security_groups=[], provider='amphora') loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' req = { 'name': loadbalancer.name, 'project_id': loadbalancer.project_id, 'vip_address': str(loadbalancer.ip), 'vip_subnet_id': loadbalancer.subnet_id, 'provider': loadbalancer.provider, } resp = o_lb.LoadBalancer(id=loadbalancer_id, provider='haproxy') lbaas.create_load_balancer.return_value = resp m_driver._get_vip_port.return_value = munch.Munch( {'id': mock.sentinel.port_id}) ret = cls._create_loadbalancer(m_driver, loadbalancer) lbaas.create_load_balancer.assert_called_once_with(**req) self.assertIsNone(ret)
def test_create_loadbalancer(self): neutron = self.useFixture(k_fix.MockNeutronClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' req = { 'loadbalancer': { 'name': loadbalancer.name, 'project_id': loadbalancer.project_id, 'tenant_id': loadbalancer.project_id, 'vip_address': str(loadbalancer.ip), 'vip_subnet_id': loadbalancer.subnet_id } } resp = {'loadbalancer': {'id': loadbalancer_id}} neutron.create_loadbalancer.return_value = resp ret = cls._create_loadbalancer(m_driver, loadbalancer) neutron.create_loadbalancer.assert_called_once_with(req) for attr in loadbalancer.obj_fields: self.assertEqual(getattr(loadbalancer, attr), getattr(ret, attr)) self.assertEqual(loadbalancer_id, ret.id)
def test_find_loadbalancer_error(self): lbaas = self.useFixture(k_fix.MockLBaaSClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' resp = iter([ o_lb.LoadBalancer(id=loadbalancer_id, provider='haproxy', provisioning_status='ERROR') ]) lbaas.load_balancers.return_value = resp m_driver._get_vip_port.return_value = munch.Munch( {'id': mock.sentinel.port_id}) ret = cls._find_loadbalancer(m_driver, loadbalancer) lbaas.load_balancers.assert_called_once_with( name=loadbalancer.name, project_id=loadbalancer.project_id, vip_address=str(loadbalancer.ip), vip_subnet_id=loadbalancer.subnet_id) self.assertIsNone(ret) m_driver.release_loadbalancer.assert_called_once()
def ensure_loadbalancer(self, name, project_id, subnet_id, ip, security_groups_ids=None, service_type=None, provider=None): request = obj_lbaas.LBaaSLoadBalancer( name=name, project_id=project_id, subnet_id=subnet_id, ip=ip, security_groups=security_groups_ids, provider=provider) response = self._ensure(request, self._create_loadbalancer, self._find_loadbalancer) if not response: # NOTE(ivc): load balancer was present before 'create', but got # deleted externally between 'create' and 'find' # NOTE(ltomasbo): or it is in ERROR status, so we deleted and # trigger the retry raise k_exc.ResourceNotReady(request) return response
def _test_ensure_listener(self): cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) expected_resp = mock.sentinel.expected_resp name = 'TEST_NAME' project_id = 'TEST_PROJECT' subnet_id = 'D3FA400A-F543-4B91-9CD3-047AF0CE42D1' ip = '1.2.3.4' loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' protocol = 'TCP' provider = 'amphora' port = 1234 loadbalancer = obj_lbaas.LBaaSLoadBalancer( id=loadbalancer_id, name=name, project_id=project_id, subnet_id=subnet_id, ip=ip, provider=provider) # TODO(ivc): handle security groups m_driver._ensure_provisioned.return_value = expected_resp resp = cls.ensure_listener(m_driver, loadbalancer, protocol, port) m_driver._ensure_provisioned.assert_called_once_with( loadbalancer, mock.ANY, m_driver._create_listener, m_driver._find_listener, d_lbaasv2._LB_STS_POLL_SLOW_INTERVAL) listener = m_driver._ensure_provisioned.call_args[0][1] self.assertEqual("%s:%s:%s" % (loadbalancer.name, protocol, port), listener.name) self.assertEqual(project_id, listener.project_id) self.assertEqual(loadbalancer_id, listener.loadbalancer_id) self.assertEqual(protocol, listener.protocol) self.assertEqual(port, listener.port) self.assertEqual(expected_resp, resp)
def test_ensure_pool(self): cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) expected_resp = mock.sentinel.expected_resp endpoints = mock.sentinel.endpoints loadbalancer = obj_lbaas.LBaaSLoadBalancer( id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C', project_id='TEST_PROJECT') listener = obj_lbaas.LBaaSListener( id='A57B7771-6050-4CA8-A63C-443493EC98AB', name='TEST_LISTENER_NAME', protocol='TCP') m_driver._ensure_provisioned.return_value = expected_resp resp = cls.ensure_pool(m_driver, endpoints, loadbalancer, listener) m_driver._ensure_provisioned.assert_called_once_with( loadbalancer, mock.ANY, m_driver._create_pool, m_driver._find_pool) pool = m_driver._ensure_provisioned.call_args[0][1] self.assertEqual(listener.name, pool.name) self.assertEqual(loadbalancer.project_id, pool.project_id) self.assertEqual(listener.id, pool.listener_id) self.assertEqual(listener.protocol, pool.protocol) self.assertEqual(expected_resp, resp)
def test_create_loadbalancer_provider_defined(self): lbaas = self.useFixture(k_fix.MockLBaaSClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', security_groups=[], provider='amphora') loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' req = {'loadbalancer': { 'name': loadbalancer.name, 'project_id': loadbalancer.project_id, 'vip_address': str(loadbalancer.ip), 'vip_subnet_id': loadbalancer.subnet_id, 'provider': loadbalancer.provider, }} resp = {'loadbalancer': {'id': loadbalancer_id, 'provider': 'amphora'}} lbaas.create_loadbalancer.return_value = resp m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id} ret = cls._create_loadbalancer(m_driver, loadbalancer) lbaas.create_loadbalancer.assert_called_once_with(req) for attr in loadbalancer.obj_fields: self.assertEqual(getattr(loadbalancer, attr), getattr(ret, attr)) self.assertEqual(loadbalancer_id, ret.id)
def test_find_loadbalancer(self): lbaas = self.useFixture(k_fix.MockLBaaSClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', provider='haproxy', security_groups=[]) loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' resp = {'loadbalancers': [{'id': loadbalancer_id, 'provider': 'haproxy', 'provisioning_status': 'ACTIVE'}]} lbaas.list_loadbalancers.return_value = resp m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id} ret = cls._find_loadbalancer(m_driver, loadbalancer) lbaas.list_loadbalancers.assert_called_once_with( name=loadbalancer.name, project_id=loadbalancer.project_id, vip_address=str(loadbalancer.ip), vip_subnet_id=loadbalancer.subnet_id) for attr in loadbalancer.obj_fields: self.assertEqual(getattr(loadbalancer, attr), getattr(ret, attr)) self.assertEqual(loadbalancer_id, ret.id) m_driver.release_loadbalancer.assert_not_called()
def test_ensure_member(self): cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) expected_resp = mock.sentinel.expected_resp loadbalancer = obj_lbaas.LBaaSLoadBalancer( id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C', project_id='TEST_PROJECT') pool = obj_lbaas.LBaaSPool(project_id='TEST_PROJECT', id='D4F35594-27EB-4F4C-930C-31DD40F53B77') subnet_id = 'D3FA400A-F543-4B91-9CD3-047AF0CE42D1' ip = '1.2.3.4' port = 1234 namespace = 'TEST_NAMESPACE' name = 'TEST_NAME' target_ref = {'namespace': namespace, 'name': name} m_driver._ensure_provisioned.return_value = expected_resp resp = cls.ensure_member(m_driver, loadbalancer, pool, subnet_id, ip, port, target_ref['namespace'], target_ref['name']) m_driver._ensure_provisioned.assert_called_once_with( loadbalancer, mock.ANY, m_driver._create_member, m_driver._find_member) member = m_driver._ensure_provisioned.call_args[0][1] self.assertEqual("%s/%s:%s" % (namespace, name, port), member.name) self.assertEqual(pool.project_id, member.project_id) self.assertEqual(pool.id, member.pool_id) self.assertEqual(subnet_id, member.subnet_id) self.assertEqual(ip, str(member.ip)) self.assertEqual(port, member.port) self.assertEqual(expected_resp, resp)
def test_ensure_loadbalancer(self): neutron = self.useFixture(k_fix.MockNeutronClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) expected_resp = obj_lbaas.LBaaSLoadBalancer( provider='octavia', port_id='D3FA400A-F543-4B91-9CD3-047AF0CE42E2', security_groups=[]) project_id = 'TEST_PROJECT' subnet_id = 'D3FA400A-F543-4B91-9CD3-047AF0CE42D1' ip = '1.2.3.4' sg_ids = ['foo', 'bar'] lb_name = 'just_a_name' m_driver._ensure.return_value = expected_resp neutron.update_port = mock.Mock() resp = cls.ensure_loadbalancer(m_driver, lb_name, project_id, subnet_id, ip, sg_ids, 'ClusterIP') m_driver._ensure.assert_called_once_with(mock.ANY, m_driver._create_loadbalancer, m_driver._find_loadbalancer) req = m_driver._ensure.call_args[0][0] self.assertEqual(lb_name, req.name) self.assertEqual(project_id, req.project_id) self.assertEqual(subnet_id, req.subnet_id) self.assertEqual(ip, str(req.ip)) self.assertEqual(expected_resp, resp) neutron.update_port.assert_not_called()
def test_find_member(self): lbaas = self.useFixture(k_fix.MockLBaaSClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer = obj_lbaas.LBaaSLoadBalancer() member = { 'name': 'TEST_NAME', 'project_id': 'TEST_PROJECT', 'pool_id': 'D4F35594-27EB-4F4C-930C-31DD40F53B77', 'subnet_id': 'D3FA400A-F543-4B91-9CD3-047AF0CE42D1', 'ip': '1.2.3.4', 'port': 1234 } member_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F' resp = iter([o_mem.Member(id=member_id, name='TEST_NAME')]) lbaas.members.return_value = resp ret = cls._find_member(m_driver, member, loadbalancer) lbaas.members.assert_called_once_with(member['pool_id'], project_id=member['project_id'], subnet_id=member['subnet_id'], address=member['ip'], protocol_port=member['port']) # the member dict is copied, so the id is added to the return obj member['id'] = member_id self.assertEqual(member, ret) self.assertEqual(member_id, ret['id'])
def test_find_loadbalancer_not_found(self): lbaas = self.useFixture(k_fix.MockLBaaSClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') loadbalancer = { 'name': 'TEST_NAME', 'project_id': 'TEST_PROJECT', 'subnet_id': 'D3FA400A-F543-4B91-9CD3-047AF0CE42D1', 'ip': '1.2.3.4', 'provider': None } resp = iter([]) lbaas.load_balancers.return_value = resp ret = cls._find_loadbalancer(m_driver, loadbalancer) lbaas.load_balancers.assert_called_once_with( name=loadbalancer['name'], project_id=loadbalancer['project_id'], vip_address=str(loadbalancer['ip']), vip_subnet_id=loadbalancer['subnet_id'], provider=None) self.assertIsNone(ret) m_driver.release_loadbalancer.assert_not_called()
def ensure_loadbalancer(self, name, project_id, subnet_id, ip, security_groups_ids, service_type): return obj_lbaas.LBaaSLoadBalancer(name=name, project_id=project_id, subnet_id=subnet_id, ip=ip, id=uuidutils.generate_uuid())
def ensure_loadbalancer(self, name, project_id, subnet_id, ip, security_groups_ids, service_type, provider=None): return obj_lbaas.LBaaSLoadBalancer(name=name, project_id=project_id, subnet_id=subnet_id, ip=ip, id=str(uuid.uuid4()), provider=provider)
def ensure_loadbalancer(self, endpoints, project_id, subnet_id, ip, security_groups_ids): name = str(ip) return obj_lbaas.LBaaSLoadBalancer(name=name, project_id=project_id, subnet_id=subnet_id, ip=ip, id=uuidutils.generate_uuid())
def _cleanup_leftover_lbaas(self): lbaas_client = clients.get_loadbalancer_client() services = [] try: services = driver_utils.get_services().get('items') except k_exc.K8sClientException: LOG.debug("Skipping cleanup of leftover lbaas. " "Error retriving Kubernetes services") return services_cluster_ip = { service['spec']['clusterIP']: service for service in services if service['spec'].get('clusterIP') } services_without_selector = set( service['spec']['clusterIP'] for service in services if (service['spec'].get('clusterIP') and not service['spec'].get('selector'))) lbaas_spec = {} self._drv_lbaas.add_tags('loadbalancer', lbaas_spec) loadbalancers = lbaas_client.load_balancers(**lbaas_spec) for loadbalancer in loadbalancers: if loadbalancer.vip_address not in services_cluster_ip.keys(): lb_obj = obj_lbaas.LBaaSLoadBalancer(**loadbalancer) eventlet.spawn(self._ensure_release_lbaas, lb_obj) else: # check if the provider is the right one if (loadbalancer.vip_address not in services_without_selector and self._lb_provider and self._lb_provider != loadbalancer.provider): LOG.debug("Removing loadbalancer with old provider: %s", loadbalancer) lb_obj = obj_lbaas.LBaaSLoadBalancer(**loadbalancer) eventlet.spawn( self._ensure_release_lbaas, lb_obj, services_cluster_ip[loadbalancer.vip_address]) # NOTE(ltomasbo): give some extra time in between lbs # recreation actions time.sleep(1)
def test_sync_path_l7_rule(self): m_handler = mock.Mock(spec=h_route.OcpRouteHandler) m_handler._l7_router = obj_lbaas.LBaaSLoadBalancer( id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C', project_id='TEST_PROJECT') m_handler._drv_lbaas = mock.Mock(spec=drv_base.LBaaSDriver) l7_policy = obj_lbaas.LBaaSL7Policy( id='00EE9E11-91C2-41CF-8FD4-7970579E6666', name='myname', listener_id='00EE9E11-91C2-41CF-8FD4-7970579E5C45', redirect_pool_id='00EE9E11-91C2-41CF-8FD4-7970579E5C46', project_id='00EE9E11-91C2-41CF-8FD4-7970579E5C46') route_state = obj_route.RouteState(l7_policy=l7_policy) route = { 'metadata': { 'namespace': 'namespace', 'name': 'name' }, 'spec': { 'host': 'new.www.test.com', 'path': '/nice_path', 'to': { 'name': 'target_service' } } } route_spec = obj_route.RouteSpec(host='www.test.com', path=None, to_service='target_service') ret_p_l7_rule = obj_lbaas.LBaaSL7Rule( id='55559E11-91C2-41CF-8FD4-7970579E5C44', compare_type=OCP_ROUTE_PATH_COMP_TYPE, l7policy_id='55559E11-91C2-41CF-8FD4-7970579E5C45', type='PATH', value='/nice_path') m_handler._drv_lbaas.ensure_l7_rule.return_value = ret_p_l7_rule h_route.OcpRouteHandler._sync_path_l7_rule(m_handler, route, route_spec, route_state) self.assertEqual(route_state.p_l7_rule, ret_p_l7_rule) m_handler._drv_lbaas.ensure_l7_rule.assert_called_once_with( m_handler._l7_router, route_state.l7_policy, OCP_ROUTE_PATH_COMP_TYPE, 'PATH', route['spec']['path'])
def get_lb_by_uuid(self, lb_uuid): lbaas = clients.get_loadbalancer_client() try: response = lbaas.get_load_balancer(lb_uuid) except o_exc.ResourceNotFound: LOG.debug("Couldn't find loadbalancer with uuid=%s", lb_uuid) return None return obj_lbaas.LBaaSLoadBalancer(id=response['id'], port_id=response['vip_port_id'], name=response['name'], project_id=response['project_id'], subnet_id=response['vip_subnet_id'], ip=response['vip_address'], security_groups=None, provider=response['provider'])
def get_lb_by_uuid(self, lb_uuid): lbaas = clients.get_loadbalancer_client() response = lbaas.show_loadbalancer(lb_uuid) try: return obj_lbaas.LBaaSLoadBalancer( id=response['loadbalancer']['id'], port_id=response['loadbalancer']['vip_port_id'], name=response['loadbalancer']['name'], project_id=response['loadbalancer']['project_id'], subnet_id=response['loadbalancer']['vip_subnet_id'], ip=response['loadbalancer']['vip_address'], security_groups=None, provider=response['loadbalancer']['provider']) except (KeyError, IndexError): LOG.debug("Couldn't find loadbalancer with uuid=%s", lb_uuid) return None
def ensure_loadbalancer(self, endpoints, project_id, subnet_id, ip, security_groups_ids): name = "%(namespace)s/%(name)s" % endpoints['metadata'] request = obj_lbaas.LBaaSLoadBalancer(name=name, project_id=project_id, subnet_id=subnet_id, ip=ip) response = self._ensure(request, self._create_loadbalancer, self._find_loadbalancer) if not response: # NOTE(ivc): load balancer was present before 'create', but got # deleted externally between 'create' and 'find' raise k_exc.ResourceNotReady(request) # TODO(ivc): handle security groups return response
def get_lb_by_uuid(self, lb_uuid): lbaas = clients.get_loadbalancer_client() try: response = lbaas.get_load_balancer(lb_uuid) except os_exc.NotFoundException: LOG.debug("Couldn't find loadbalancer with uuid=%s", lb_uuid) return None return obj_lbaas.LBaaSLoadBalancer( id=response.id, port_id=response.vip_port_id, name=response.name, project_id=response.project_id, subnet_id=response.vip_subnet_id, ip=response.vip_address, security_groups=None, provider=response.provider)
def test_sync_path_l7_rule_edit_usecase(self): m_handler = mock.Mock(spec=h_route.OcpRouteHandler) m_handler._l7_router = obj_lbaas.LBaaSLoadBalancer( id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C', project_id='TEST_PROJECT') m_handler._drv_lbaas = mock.Mock(spec=drv_base.LBaaSDriver) old_p_l7_rule = obj_lbaas.LBaaSL7Rule( id='00EE9E11-91C2-41CF-8FD4-7970579E5C44', compare_type=OCP_ROUTE_PATH_COMP_TYPE, l7policy_id='00EE9E11-91C2-41CF-8FD4-7970579E5C45', type='PATH', value='/cur_path') route_state = obj_route.RouteState(p_l7_rule=old_p_l7_rule) route = { 'metadata': { 'namespace': 'namespace', 'name': 'name' }, 'spec': { 'host': 'new.www.test.com', 'path': '/new_path', 'to': { 'name': 'target_service' } } } route_spec = obj_route.RouteSpec(host='www.test.com', path=old_p_l7_rule.value, to_service='target_service') ret_p_l7_rule = obj_lbaas.LBaaSL7Rule( id='00EE9E11-91C2-41CF-8FD4-7970579E5C44', compare_type=OCP_ROUTE_PATH_COMP_TYPE, l7policy_id='00EE9E11-91C2-41CF-8FD4-7970579E5C45', type='PATH', value=route['spec']['path']) m_handler._drv_lbaas.update_l7_rule.return_value = True h_route.OcpRouteHandler._sync_path_l7_rule(m_handler, route, route_spec, route_state) self.assertEqual(route_state.p_l7_rule.value, ret_p_l7_rule.value) m_handler._drv_lbaas.update_l7_rule.assert_called_once_with( old_p_l7_rule, route['spec']['path'])
def test_sync_path_l7_rule(self): m_handler = mock.Mock(spec=h_route.OcpRouteHandler) m_handler._l7_router = obj_lbaas.LBaaSLoadBalancer( id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C', project_id='TEST_PROJECT') m_handler._drv_l7_router = mock.Mock( spec=d_l7_rtr.LBaaSv2L7RouterDriver) old_p_l7_rule = obj_route.RouteL7Rule( id='00EE9E11-91C2-41CF-8FD4-7970579E5C44', compare_type='EQUAL_TO', l7policy_id='00EE9E11-91C2-41CF-8FD4-7970579E5C45', type='PATH', value='/nice_path/') route_state = obj_route.RouteState(p_l7_rule=old_p_l7_rule) route = { 'metadata': { 'namespace': 'namespace', 'name': 'name' }, 'spec': { 'host': 'new.www.test.com', 'path': 'mypath', 'to': { 'name': 'target_service' } } } route_spec = obj_route.RouteSpec(host='www.test.com', path='mypath', to_service='target_service') ret_p_l7_rule = obj_route.RouteL7Rule( id='55559E11-91C2-41CF-8FD4-7970579E5C44', compare_type='EQUAL_TO', l7policy_id='55559E11-91C2-41CF-8FD4-7970579E5C45', type='PATH', value='/nice_path/') m_handler._drv_l7_router.ensure_l7_rule.return_value = ret_p_l7_rule h_route.OcpRouteHandler._sync_path_l7_rule(m_handler, route, route_spec, route_state) self.assertEqual(route_state.p_l7_rule, old_p_l7_rule)
def test_sync_l7_policy(self): m_handler = mock.Mock(spec=h_route.OcpRouteHandler) m_handler._l7_router = obj_lbaas.LBaaSLoadBalancer( id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C', project_id='TEST_PROJECT') m_handler._drv_l7_router = mock.Mock( spec=d_l7_rtr.LBaaSv2L7RouterDriver) listener = obj_lbaas.LBaaSListener( id='123443545', name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', port=80, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') m_handler._l7_router_listeners = {'80': listener} l7_policy = obj_route.RouteL7Policy( id='00EE9E11-91C2-41CF-8FD4-7970579E5C44', name='myname', listener_id='00EE9E11-91C2-41CF-8FD4-7970579E5C45', redirect_pool_id='00EE9E11-91C2-41CF-8FD4-7970579E5C46', project_id='00EE9E11-91C2-41CF-8FD4-7970579E5C46') route_state = obj_route.RouteState() m_handler._drv_l7_router.ensure_l7_policy.return_value = l7_policy route = { 'metadata': { 'namespace': 'namespace', 'name': 'name' }, 'spec': { 'host': 'www.test.com', 'path': 'mypath', 'to': { 'name': 'target_service' } } } route_spec = obj_route.RouteSpec(host='www.test.com1', path='mypath', to_service='target_service') h_route.OcpRouteHandler._sync_l7_policy(m_handler, route, route_spec, route_state) self.assertEqual(route_state.l7_policy, l7_policy)
def test_find_loadbalancer_not_found(self): lbaas = self.useFixture(k_fix.MockLBaaSClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') resp = {'loadbalancers': []} lbaas.list_loadbalancers.return_value = resp ret = cls._find_loadbalancer(m_driver, loadbalancer) lbaas.list_loadbalancers.assert_called_once_with( name=loadbalancer.name, project_id=loadbalancer.project_id, vip_address=str(loadbalancer.ip), vip_subnet_id=loadbalancer.subnet_id) self.assertIsNone(ret) m_driver.release_loadbalancer.assert_not_called()
def _cleanup_leftover_lbaas(self): lbaas_client = clients.get_loadbalancer_client() services = [] try: services = driver_utils.get_services().get('items') except k_exc.K8sClientException: LOG.debug("Skipping cleanup of leftover lbaas. " "Error retriving Kubernetes services") return services_cluster_ip = set(service['spec']['clusterIP'] for service in services if service['spec'].get('clusterIP')) lbaas_spec = {} self._drv_lbaas.add_tags('loadbalancer', lbaas_spec) loadbalancers = lbaas_client.load_balancers(**lbaas_spec) for loadbalancer in loadbalancers: if loadbalancer.vip_address not in services_cluster_ip: lb_obj = obj_lbaas.LBaaSLoadBalancer(**loadbalancer) eventlet.spawn(self._ensure_release_lbaas, lb_obj)
def test_ensure_listener_bad_request_exception(self): cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) name = 'TEST_NAME' project_id = 'TEST_PROJECT' subnet_id = 'D3FA400A-F543-4B91-9CD3-047AF0CE42D1' ip = '1.2.3.4' loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' port = 1234 protocol = 'TCP' provider = 'amphora' loadbalancer = obj_lbaas.LBaaSLoadBalancer( id=loadbalancer_id, name=name, project_id=project_id, subnet_id=subnet_id, ip=ip, provider=provider) m_driver._ensure_provisioned.side_effect = os_exc.BadRequestException resp = cls.ensure_listener(m_driver, loadbalancer, protocol, port) self.assertIsNone(resp)
def test_get_lb_by_uuid(self): lbaas = self.useFixture(k_fix.MockLBaaSClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' loadbalancer_vip = '1.2.3.4' loadbalancer_vip_port_id = '00EE9E11-91C2-41CF-8FD4-7970579EFFFF' loadbalancer_project_id = '00EE9E11-91C2-41CF-8FD4-7970579EAAAA' loadbalancer_name = 'MyName' loadbalancer_subnet_id = '00EE9E11-91C2-41CF-8FD4-7970579EBBBB' loadbalancer_provider = 'haproxy' expected_lb = obj_lbaas.LBaaSLoadBalancer( id=loadbalancer_id, port_id=loadbalancer_vip_port_id, name=loadbalancer_name, project_id=loadbalancer_project_id, subnet_id=loadbalancer_subnet_id, ip=loadbalancer_vip, security_groups=None, provider=loadbalancer_provider) resp = { 'loadbalancer': { 'id': loadbalancer_id, 'vip_port_id': loadbalancer_vip_port_id, 'name': loadbalancer_name, 'project_id': loadbalancer_project_id, 'vip_subnet_id': loadbalancer_subnet_id, 'vip_address': loadbalancer_vip, 'provider': loadbalancer_provider } } lbaas.show_loadbalancer.return_value = resp ret = cls.get_lb_by_uuid(m_driver, loadbalancer_id) lbaas.show_loadbalancer.assert_called_once() for attr in expected_lb.obj_fields: self.assertEqual(getattr(expected_lb, attr), getattr(ret, attr)) self.assertEqual(loadbalancer_id, ret.id)
def test_ingress_ctrlr_router_enabled_k8s(self, m_cfg, m_get_lbaas_drv): m_cfg.kubernetes.enabled_handlers = ['ingresslb'] m_cfg.ingress.l7_router_uuid = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' l7_router = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', security_groups=[], id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') m_driver = mock.Mock() m_driver.get_lb_by_uuid.return_value = l7_router m_get_lbaas_drv.return_value = m_driver ing_ctrl = ingress_ctl.IngressCtrlr.get_instance() ing_ctrl.start_operation() self.assertIsNotNone(ing_ctrl) self.assertEqual(ing_ctrl._status, 'ACTIVE')
def test_on_present_no_change(self): route_event = mock.sentinel.route_event route_spec = mock.sentinel.route_spec m_handler = mock.Mock(spec=h_route.OcpRouteHandler) m_handler._get_route_spec.return_value = route_spec m_handler._should_ignore.return_value = True m_handler._l7_router = obj_lbaas.LBaaSLoadBalancer( id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C', project_id='TEST_PROJECT') h_route.OcpRouteHandler.on_present(m_handler, route_event) m_handler._get_route_spec.assert_called_once_with(route_event) m_handler._sync_router_pool.assert_not_called() m_handler._sync_l7_policy.assert_not_called() m_handler._sync_host_l7_rule.assert_not_called() m_handler._sync_path_l7_rule.assert_not_called() m_handler._set_route_state.assert_not_called() m_handler._set_route_spec.assert_not_called() m_handler._send_route_notification_to_ep.assert_not_called()