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()
