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')
m_handler._l7_router_listeners = obj_lbaas.LBaaSListener(
id='00EE9E11-91C2-41CF-8FD4-7970579E1234',
project_id='TEST_PROJECT',
name='http_listenr',
protocol='http',
port=80)
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()
def test_create_listener(self):
lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
cls = d_lbaasv2.LBaaSv2Driver
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
listener = obj_lbaas.LBaaSListener(
name='TEST_NAME',
project_id='TEST_PROJECT',
protocol='TCP',
port=1234,
loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
listener_id = 'A57B7771-6050-4CA8-A63C-443493EC98AB'
req = {
'listener': {
'name': listener.name,
'project_id': listener.project_id,
'loadbalancer_id': listener.loadbalancer_id,
'protocol': listener.protocol,
'protocol_port': listener.port
}
}
resp = {'listener': {'id': listener_id}}
lbaas.create_listener.return_value = resp
ret = cls._create_listener(m_driver, listener)
lbaas.create_listener.assert_called_once_with(req)
for attr in listener.obj_fields:
self.assertEqual(getattr(listener, attr), getattr(ret, attr))
self.assertEqual(listener_id, ret.id)
def ensure_listener(self,
loadbalancer,
protocol,
port,
service_type='ClusterIP'):
name = "%s:%s:%s" % (loadbalancer.name, protocol, port)
listener = obj_lbaas.LBaaSListener(name=name,
project_id=loadbalancer.project_id,
loadbalancer_id=loadbalancer.id,
protocol=protocol,
port=port)
try:
result = self._ensure_provisioned(loadbalancer, listener,
self._create_listener,
self._find_listener,
_LB_STS_POLL_SLOW_INTERVAL)
except o_exc.BadRequestException:
LOG.info(
"Listener creation failed, most probably because "
"protocol %(prot)s is not supported", {'prot': protocol})
return None
self._ensure_security_group_rules(loadbalancer, result, service_type)
return result
def test_find_listener(self):
neutron = self.useFixture(k_fix.MockNeutronClient()).client
cls = d_lbaasv2.LBaaSv2Driver
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
listener = obj_lbaas.LBaaSListener(
name='TEST_NAME',
project_id='TEST_PROJECT',
protocol='TCP',
port=1234,
loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
listener_id = 'A57B7771-6050-4CA8-A63C-443493EC98AB'
resp = {'listeners': [{'id': listener_id}]}
neutron.list_listeners.return_value = resp
ret = cls._find_listener(m_driver, listener)
neutron.list_listeners.assert_called_once_with(
name=listener.name,
project_id=listener.project_id,
tenant_id=listener.project_id,
loadbalancer_id=listener.loadbalancer_id,
protocol=listener.protocol,
protocol_port=listener.port)
for attr in listener.obj_fields:
self.assertEqual(getattr(listener, attr), getattr(ret, attr))
self.assertEqual(listener_id, ret.id)
def ensure_listener(self,
loadbalancer,
protocol,
port,
service_type='ClusterIP'):
name = "%s:%s:%s" % (loadbalancer.name, protocol, port)
listener = obj_lbaas.LBaaSListener(name=name,
project_id=loadbalancer.project_id,
loadbalancer_id=loadbalancer.id,
protocol=protocol,
port=port)
try:
result = self._ensure_provisioned(loadbalancer, listener,
self._create_listener,
self._find_listener,
_LB_STS_POLL_SLOW_INTERVAL)
except os_exc.SDKException:
LOG.exception(
"Listener creation failed, most probably because "
"protocol %(prot)s is not supported", {'prot': protocol})
return None
if CONF.octavia_defaults.sg_mode == 'create':
self._create_lb_security_group_rule(loadbalancer, result)
return result
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 ensure_listener(self, endpoints, loadbalancer, protocol, port):
name = "%s:%s:%s" % (loadbalancer.name, protocol, port)
return obj_lbaas.LBaaSListener(name=name,
project_id=loadbalancer.project_id,
loadbalancer_id=loadbalancer.id,
protocol=protocol,
port=port,
id=uuidutils.generate_uuid())
def ensure_listener(self, endpoints, loadbalancer, protocol, port):
if protocol not in _SUPPORTED_LISTENER_PROT:
return None
name = "%s:%s:%s" % (loadbalancer.name, protocol, port)
return obj_lbaas.LBaaSListener(name=name,
project_id=loadbalancer.project_id,
loadbalancer_id=loadbalancer.id,
protocol=protocol,
port=port,
id=uuidutils.generate_uuid())
def ensure_listener(self, endpoints, loadbalancer, protocol, port):
name = "%(namespace)s/%(name)s" % endpoints['metadata']
name += ":%s:%s" % (protocol, port)
listener = obj_lbaas.LBaaSListener(name=name,
project_id=loadbalancer.project_id,
loadbalancer_id=loadbalancer.id,
protocol=protocol,
port=port)
return self._ensure_provisioned(loadbalancer, listener,
self._create_listener,
self._find_listener)
def ensure_listener(self, loadbalancer, protocol, port,
service_type='ClusterIP'):
if protocol not in _SUPPORTED_LISTENER_PROT:
return None
name = "%s:%s:%s" % (loadbalancer.name, protocol, port)
return obj_lbaas.LBaaSListener(name=name,
project_id=loadbalancer.project_id,
loadbalancer_id=loadbalancer.id,
protocol=protocol,
port=port,
id=str(uuid.uuid4()))
def ensure_listener(self,
loadbalancer,
protocol,
port,
service_type='ClusterIP'):
# NOTE(yboaron): Since retrieving Octavia capabilities/version is not
# supported via the OpenstackSdk, the list of allowed listener's
# protocols will be defined statically.
# Kuryr still need to handle the case in which listener's protocol
# (e.g: UDP) is not supported by Octavia.
provider = loadbalancer.provider or 'amphora'
try:
if protocol not in _PROVIDER_SUPPORTED_LISTENER_PROT[provider]:
LOG.info(
"Protocol: %(prot)s: is not supported by "
"%(provider)s", {
'prot': protocol,
'provider': provider
})
return None
except KeyError:
LOG.info(
"Provider %(provider)s doesnt exist in "
"_PROVIDER_SUPPORTED_LISTENER_PROT", {'provider': provider})
return None
name = "%s:%s:%s" % (loadbalancer.name, protocol, port)
listener = obj_lbaas.LBaaSListener(name=name,
project_id=loadbalancer.project_id,
loadbalancer_id=loadbalancer.id,
protocol=protocol,
port=port)
try:
result = self._ensure_provisioned(loadbalancer, listener,
self._create_listener,
self._find_listener,
_LB_STS_POLL_SLOW_INTERVAL)
except n_exc.BadRequest:
LOG.info(
"Listener creation failed, most probably because "
"protocol %(prot)s is not supported", {'prot': protocol})
return None
self._ensure_security_group_rules(loadbalancer, result, service_type)
return result
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 ensure_listener(self, loadbalancer, protocol, port):
if protocol not in _SUPPORTED_LISTENER_PROT:
LOG.info("Protocol: %(prot)s: is not supported by LBaaSV2",
{'prot': protocol})
return None
name = "%s:%s:%s" % (loadbalancer.name, protocol, port)
listener = obj_lbaas.LBaaSListener(name=name,
project_id=loadbalancer.project_id,
loadbalancer_id=loadbalancer.id,
protocol=protocol,
port=port)
result = self._ensure_provisioned(loadbalancer, listener,
self._create_listener,
self._find_listener)
self._ensure_security_group_rules(loadbalancer, result)
return result
def test_find_listener_not_found(self):
lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
cls = d_lbaasv2.LBaaSv2Driver
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
listener = obj_lbaas.LBaaSListener(
name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP',
port=1234, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
resp = iter([])
lbaas.listeners.return_value = resp
ret = cls._find_listener(m_driver, listener)
lbaas.listeners.assert_called_once_with(
name=listener.name,
project_id=listener.project_id,
load_balancer_id=listener.loadbalancer_id,
protocol=listener.protocol,
protocol_port=listener.port)
self.assertIsNone(ret)
