openstack
/
kuryr-kubernetes
Code Issues Proposed changes

Merge "Switch Octavia API calls to openstacksdk"

This commit is contained in:
Zuul 2019-03-18 11:25:24 +00:00 committed by Gerrit Code Review
parent 38f1198e82 b90ca1b9b9
commit 21a0a2673c
9 changed files with 290 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
kuryr_kubernetes/clients.py
View File

@ -16,23 +16,27 @@
import os import os
from kuryr.lib import utils from kuryr.lib import utils
from openstack import connection
from kuryr_kubernetes import config from kuryr_kubernetes import config
from kuryr_kubernetes import k8s_client from kuryr_kubernetes import k8s_client
from neutronclient import client as n_client
_clients = {} _clients = {}
_NEUTRON_CLIENT = 'neutron-client' _NEUTRON_CLIENT = 'neutron-client'
_LB_CLIENT = 'load-balancer-client'
_KUBERNETES_CLIENT = 'kubernetes-client' _KUBERNETES_CLIENT = 'kubernetes-client'
_OPENSTACKSDK = 'openstacksdk'
def get_neutron_client(): def get_neutron_client():
return _clients[_NEUTRON_CLIENT] return _clients[_NEUTRON_CLIENT]
def get_openstacksdk():
return _clients[_OPENSTACKSDK]
def get_loadbalancer_client(): def get_loadbalancer_client():
return _clients[_LB_CLIENT] return get_openstacksdk().load_balancer
def get_kubernetes_client(): def get_kubernetes_client():
@ -41,34 +45,14 @@ def get_kubernetes_client():
def setup_clients(): def setup_clients():
setup_neutron_client() setup_neutron_client()
setup_loadbalancer_client()
setup_kubernetes_client() setup_kubernetes_client()
setup_openstacksdk()
def setup_neutron_client(): def setup_neutron_client():
_clients[_NEUTRON_CLIENT] = utils.get_neutron_client() _clients[_NEUTRON_CLIENT] = utils.get_neutron_client()
def setup_loadbalancer_client():
neutron_client = get_neutron_client()
if any(ext['alias'] == 'lbaasv2' for
ext in neutron_client.list_extensions()['extensions']):
_clients[_LB_CLIENT] = neutron_client
neutron_client.cascading_capable = False
else:
# Since Octavia is lbaasv2 API compatible (A superset of it) we'll just
# wire an extra neutron client instance to point to it
lbaas_client = utils.get_neutron_client()
conf_group = utils.kuryr_config.neutron_group.name
auth_plugin = utils.get_auth_plugin(conf_group)
octo_httpclient = n_client.construct_http_client(
session=utils.get_keystone_session(conf_group, auth_plugin),
service_type='load-balancer')
lbaas_client.httpclient = octo_httpclient
_clients[_LB_CLIENT] = lbaas_client
lbaas_client.cascading_capable = True
def setup_kubernetes_client(): def setup_kubernetes_client():
if config.CONF.kubernetes.api_root: if config.CONF.kubernetes.api_root:
api_root = config.CONF.kubernetes.api_root api_root = config.CONF.kubernetes.api_root
@ -79,3 +63,10 @@ def setup_kubernetes_client():
port = os.environ['KUBERNETES_SERVICE_PORT_HTTPS'] port = os.environ['KUBERNETES_SERVICE_PORT_HTTPS']
api_root = "https://%s:%s" % (host, port) api_root = "https://%s:%s" % (host, port)
_clients[_KUBERNETES_CLIENT] = k8s_client.K8sClient(api_root) _clients[_KUBERNETES_CLIENT] = k8s_client.K8sClient(api_root)
def setup_openstacksdk():
auth_plugin = utils.get_auth_plugin('neutron')
session = utils.get_keystone_session('neutron', auth_plugin)
conn = connection.Connection(session=session)
_clients[_OPENSTACKSDK] = conn

264
kuryr_kubernetes/controller/drivers/lbaasv2.py
View File

@ -14,14 +14,12 @@
# under the License. # under the License.
import random import random
import six
import sys
import time import time
import traceback
import requests import requests
from neutronclient.common import exceptions as n_exc from neutronclient.common import exceptions as n_exc
from openstack import exceptions as o_exc
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from oslo_utils import timeutils from oslo_utils import timeutils
@ -53,11 +51,6 @@ _LB_STS_POLL_SLOW_INTERVAL = 3
class LBaaSv2Driver(base.LBaaSDriver): class LBaaSv2Driver(base.LBaaSDriver):
"""LBaaSv2Driver implements LBaaSDriver for Neutron LBaaSv2 API.""" """LBaaSv2Driver implements LBaaSDriver for Neutron LBaaSv2 API."""
@property
def cascading_capable(self):
lbaas = clients.get_loadbalancer_client()
return lbaas.cascading_capable
def get_service_loadbalancer_name(self, namespace, svc_name): def get_service_loadbalancer_name(self, namespace, svc_name):
return "%s/%s" % (namespace, svc_name) return "%s/%s" % (namespace, svc_name)
@ -84,17 +77,12 @@ class LBaaSv2Driver(base.LBaaSDriver):
def release_loadbalancer(self, loadbalancer): def release_loadbalancer(self, loadbalancer):
neutron = clients.get_neutron_client() neutron = clients.get_neutron_client()
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
if lbaas.cascading_capable: self._release(
self._release( loadbalancer,
loadbalancer, loadbalancer,
loadbalancer, lbaas.delete_load_balancer,
lbaas.delete, loadbalancer.id,
lbaas.lbaas_loadbalancer_path % loadbalancer.id, cascade=True)
params={'cascade': True})
else:
self._release(loadbalancer, loadbalancer,
lbaas.delete_loadbalancer, loadbalancer.id)
sg_id = self._find_listeners_sg(loadbalancer) sg_id = self._find_listeners_sg(loadbalancer)
if sg_id: if sg_id:
@ -394,7 +382,7 @@ class LBaaSv2Driver(base.LBaaSDriver):
result = self._ensure_provisioned( result = self._ensure_provisioned(
loadbalancer, listener, self._create_listener, loadbalancer, listener, self._create_listener,
self._find_listener, _LB_STS_POLL_SLOW_INTERVAL) self._find_listener, _LB_STS_POLL_SLOW_INTERVAL)
except n_exc.BadRequest: except o_exc.BadRequestException:
LOG.info("Listener creation failed, most probably because " LOG.info("Listener creation failed, most probably because "
"protocol %(prot)s is not supported", {'prot': protocol}) "protocol %(prot)s is not supported", {'prot': protocol})
return None return None
@ -449,9 +437,7 @@ class LBaaSv2Driver(base.LBaaSDriver):
def release_pool(self, loadbalancer, pool): def release_pool(self, loadbalancer, pool):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
self._release(loadbalancer, pool, self._release(loadbalancer, pool, lbaas.delete_pool, pool.id)
lbaas.delete_lbaas_pool,
pool.id)
def ensure_member(self, loadbalancer, pool, def ensure_member(self, loadbalancer, pool,
subnet_id, ip, port, target_ref_namespace, subnet_id, ip, port, target_ref_namespace,
@ -480,9 +466,8 @@ class LBaaSv2Driver(base.LBaaSDriver):
def release_member(self, loadbalancer, member): def release_member(self, loadbalancer, member):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
self._release(loadbalancer, member, self._release(loadbalancer, member, lbaas.delete_member, member.id,
lbaas.delete_lbaas_member, member.pool_id)
member.id, member.pool_id)
def _get_vip_port(self, loadbalancer): def _get_vip_port(self, loadbalancer):
neutron = clients.get_neutron_client() neutron = clients.get_neutron_client()
@ -502,71 +487,73 @@ class LBaaSv2Driver(base.LBaaSDriver):
def _create_loadbalancer(self, loadbalancer): def _create_loadbalancer(self, loadbalancer):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
request = {'loadbalancer': { request = {
'name': loadbalancer.name, 'name': loadbalancer.name,
'project_id': loadbalancer.project_id, 'project_id': loadbalancer.project_id,
'vip_address': str(loadbalancer.ip), 'vip_address': str(loadbalancer.ip),
'vip_subnet_id': loadbalancer.subnet_id}} 'vip_subnet_id': loadbalancer.subnet_id,
}
if loadbalancer.provider is not None: if loadbalancer.provider is not None:
request['loadbalancer']['provider'] = loadbalancer.provider request['provider'] = loadbalancer.provider
response = lbaas.create_loadbalancer(request) response = lbaas.create_load_balancer(**request)
loadbalancer.id = response['loadbalancer']['id'] loadbalancer.id = response['id']
loadbalancer.port_id = self._get_vip_port(loadbalancer).get("id") loadbalancer.port_id = self._get_vip_port(loadbalancer).get("id")
if (loadbalancer.provider is not None and if (loadbalancer.provider is not None and
loadbalancer.provider != response['loadbalancer']['provider']): loadbalancer.provider != response['provider']):
LOG.error("Request provider(%s) != Response provider(%s)", LOG.error("Request provider(%s) != Response provider(%s)",
loadbalancer.provider, loadbalancer.provider,
response['loadbalancer']['provider']) response['provider'])
return None return None
loadbalancer.provider = response['loadbalancer']['provider'] loadbalancer.provider = response['provider']
return loadbalancer return loadbalancer
def _find_loadbalancer(self, loadbalancer): def _find_loadbalancer(self, loadbalancer):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.list_loadbalancers( response = lbaas.load_balancers(
name=loadbalancer.name, name=loadbalancer.name,
project_id=loadbalancer.project_id, project_id=loadbalancer.project_id,
vip_address=str(loadbalancer.ip), vip_address=str(loadbalancer.ip),
vip_subnet_id=loadbalancer.subnet_id) vip_subnet_id=loadbalancer.subnet_id)
try: try:
loadbalancer.id = response['loadbalancers'][0]['id'] os_lb = next(response) # openstacksdk returns a generator
loadbalancer.id = os_lb['id']
loadbalancer.port_id = self._get_vip_port(loadbalancer).get("id") loadbalancer.port_id = self._get_vip_port(loadbalancer).get("id")
loadbalancer.provider = response['loadbalancers'][0]['provider'] loadbalancer.provider = os_lb['provider']
if (response['loadbalancers'][0]['provisioning_status'] == if os_lb['provisioning_status'] == 'ERROR':
'ERROR'):
self.release_loadbalancer(loadbalancer) self.release_loadbalancer(loadbalancer)
return None return None
except (KeyError, IndexError): except (KeyError, StopIteration):
return None return None
return loadbalancer return loadbalancer
def _create_listener(self, listener): def _create_listener(self, listener):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.create_listener({'listener': { response = lbaas.create_listener(
'name': listener.name, name=listener.name,
'project_id': listener.project_id, project_id=listener.project_id,
'loadbalancer_id': listener.loadbalancer_id, load_balancer_id=listener.loadbalancer_id,
'protocol': listener.protocol, protocol=listener.protocol,
'protocol_port': listener.port}}) protocol_port=listener.port)
listener.id = response['listener']['id'] listener.id = response['id']
return listener return listener
def _find_listener(self, listener): def _find_listener(self, listener):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.list_listeners( response = lbaas.listeners(
name=listener.name, name=listener.name,
project_id=listener.project_id, project_id=listener.project_id,
loadbalancer_id=listener.loadbalancer_id, load_balancer_id=listener.loadbalancer_id,
protocol=listener.protocol, protocol=listener.protocol,
protocol_port=listener.port) protocol_port=listener.port)
try: try:
listener.id = response['listeners'][0]['id'] os_listener = next(response)
except (KeyError, IndexError): listener.id = os_listener['id']
except (KeyError, StopIteration):
return None return None
return listener return listener
@ -575,49 +562,19 @@ class LBaaSv2Driver(base.LBaaSDriver):
# TODO(ivc): make lb_algorithm configurable # TODO(ivc): make lb_algorithm configurable
lb_algorithm = 'ROUND_ROBIN' lb_algorithm = 'ROUND_ROBIN'
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
try: response = lbaas.create_pool(
response = lbaas.create_lbaas_pool({'pool': { name=pool.name,
'name': pool.name, project_id=pool.project_id,
'project_id': pool.project_id, listener_id=pool.listener_id,
'listener_id': pool.listener_id,
'loadbalancer_id': pool.loadbalancer_id,
'protocol': pool.protocol,
'lb_algorithm': lb_algorithm}})
pool.id = response['pool']['id']
return pool
except n_exc.StateInvalidClient:
(type_, value, tb) = sys.exc_info()
try:
self._cleanup_bogus_pool(lbaas, pool, lb_algorithm)
except Exception:
LOG.error('Pool creation traceback: %s',
traceback.format_exception(type_, value, tb))
raise
else:
six.reraise(type_, value, tb)
def _cleanup_bogus_pool(self, lbaas, pool, lb_algorithm):
# REVISIT(ivc): LBaaSv2 creates pool object despite raising an
# exception. The created pool is not bound to listener, but
# it is bound to loadbalancer and will cause an error on
# 'release_loadbalancer'.
pools = lbaas.list_lbaas_pools(
name=pool.name, project_id=pool.project_id,
loadbalancer_id=pool.loadbalancer_id, loadbalancer_id=pool.loadbalancer_id,
protocol=pool.protocol, lb_algorithm=lb_algorithm) protocol=pool.protocol,
bogus_pool_ids = [p['id'] for p in pools.get('pools') lb_algorithm=lb_algorithm)
if not p['listeners'] and pool.name == p['name']] pool.id = response['id']
for pool_id in bogus_pool_ids: return pool
try:
LOG.debug("Removing bogus pool %(id)s %(pool)s", {
'id': pool_id, 'pool': pool})
lbaas.delete_lbaas_pool(pool_id)
except (n_exc.NotFound, n_exc.StateInvalidClient):
pass
def _find_pool(self, pool, by_listener=True): def _find_pool(self, pool, by_listener=True):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.list_lbaas_pools( response = lbaas.pools(
name=pool.name, name=pool.name,
project_id=pool.project_id, project_id=pool.project_id,
loadbalancer_id=pool.loadbalancer_id, loadbalancer_id=pool.loadbalancer_id,
@ -625,12 +582,10 @@ class LBaaSv2Driver(base.LBaaSDriver):
try: try:
if by_listener: if by_listener:
pools = [p for p in response['pools'] pools = [p for p in response if pool.listener_id
if pool.listener_id
in {l['id'] for l in p['listeners']}] in {l['id'] for l in p['listeners']}]
else: else:
pools = [p for p in response['pools'] pools = [p for p in response if pool.name == p['name']]
if pool.name == p['name']]
pool.id = pools[0]['id'] pool.id = pools[0]['id']
except (KeyError, IndexError): except (KeyError, IndexError):
@ -642,18 +597,19 @@ class LBaaSv2Driver(base.LBaaSDriver):
def _create_member(self, member): def _create_member(self, member):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.create_lbaas_member(member.pool_id, {'member': { response = lbaas.create_member(
'name': member.name, member.pool_id,
'project_id': member.project_id, name=member.name,
'subnet_id': member.subnet_id, project_id=member.project_id,
'address': str(member.ip), subnet_id=member.subnet_id,
'protocol_port': member.port}}) address=str(member.ip),
member.id = response['member']['id'] protocol_port=member.port)
member.id = response['id']
return member return member
def _find_member(self, member): def _find_member(self, member):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.list_lbaas_members( response = lbaas.members(
member.pool_id, member.pool_id,
name=member.name, name=member.name,
project_id=member.project_id, project_id=member.project_id,
@ -662,8 +618,8 @@ class LBaaSv2Driver(base.LBaaSDriver):
protocol_port=member.port) protocol_port=member.port)
try: try:
member.id = response['members'][0]['id'] member.id = next(response)['id']
except (KeyError, IndexError): except (KeyError, StopIteration):
return None return None
return member return member
@ -673,7 +629,9 @@ class LBaaSv2Driver(base.LBaaSDriver):
try: try:
result = create(obj) result = create(obj)
LOG.debug("Created %(obj)s", {'obj': result}) LOG.debug("Created %(obj)s", {'obj': result})
except (n_exc.Conflict, n_exc.InternalServerError): except o_exc.HttpException as e:
if e.status_code not in (409, 500):
raise
result = find(obj) result = find(obj)
if result: if result:
LOG.debug("Found %(obj)s", {'obj': result}) LOG.debug("Found %(obj)s", {'obj': result})
@ -688,7 +646,7 @@ class LBaaSv2Driver(base.LBaaSDriver):
result = self._ensure(obj, create, find) result = self._ensure(obj, create, find)
if result: if result:
return result return result
except n_exc.StateInvalidClient: except o_exc.BadRequestException:
continue continue
raise k_exc.ResourceNotReady(obj) raise k_exc.ResourceNotReady(obj)
@ -699,9 +657,9 @@ class LBaaSv2Driver(base.LBaaSDriver):
try: try:
delete(*args, **kwargs) delete(*args, **kwargs)
return return
except (n_exc.Conflict, n_exc.StateInvalidClient): except (o_exc.ConflictException, o_exc.BadRequestException):
self._wait_for_provisioning(loadbalancer, remaining) self._wait_for_provisioning(loadbalancer, remaining)
except n_exc.NotFound: except o_exc.ResourceNotFound:
return return
raise k_exc.ResourceNotReady(obj) raise k_exc.ResourceNotReady(obj)
@ -711,8 +669,8 @@ class LBaaSv2Driver(base.LBaaSDriver):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
for remaining in self._provisioning_timer(timeout, interval): for remaining in self._provisioning_timer(timeout, interval):
response = lbaas.show_loadbalancer(loadbalancer.id) response = lbaas.get_load_balancer(loadbalancer.id)
status = response['loadbalancer']['provisioning_status'] status = response['provisioning_status']
if status == 'ACTIVE': if status == 'ACTIVE':
LOG.debug("Provisioning complete for %(lb)s", { LOG.debug("Provisioning complete for %(lb)s", {
'lb': loadbalancer}) 'lb': loadbalancer})
@ -731,8 +689,8 @@ class LBaaSv2Driver(base.LBaaSDriver):
for remaining in self._provisioning_timer(timeout, interval): for remaining in self._provisioning_timer(timeout, interval):
try: try:
lbaas.show_loadbalancer(loadbalancer.id) lbaas.get_load_balancer(loadbalancer.id)
except n_exc.NotFound: except o_exc.ResourceNotFound:
return return
def _provisioning_timer(self, timeout, def _provisioning_timer(self, timeout,
@ -777,20 +735,21 @@ class LBaaSv2Driver(base.LBaaSDriver):
def get_lb_by_uuid(self, lb_uuid): def get_lb_by_uuid(self, lb_uuid):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.show_loadbalancer(lb_uuid)
try: try:
return obj_lbaas.LBaaSLoadBalancer( response = lbaas.get_load_balancer(lb_uuid)
id=response['loadbalancer']['id'], except o_exc.ResourceNotFound:
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) LOG.debug("Couldn't find loadbalancer with uuid=%s", lb_uuid)
return None 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_pool_by_name(self, pool_name, project_id): def get_pool_by_name(self, pool_name, project_id):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
@ -799,9 +758,8 @@ class LBaaSv2Driver(base.LBaaSDriver):
# get_loadbalancer_pool_name function, which means that pool's name # get_loadbalancer_pool_name function, which means that pool's name
# is unique # is unique
pools_list = lbaas.list_lbaas_pools( pools = lbaas.pools(project_id=project_id)
project_id=project_id) for entry in pools:
for entry in pools_list['pools']:
if not entry: if not entry:
continue continue
if entry['name'] == pool_name: if entry['name'] == pool_name:
@ -830,30 +788,30 @@ class LBaaSv2Driver(base.LBaaSDriver):
def release_l7_policy(self, loadbalancer, l7_policy): def release_l7_policy(self, loadbalancer, l7_policy):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
self._release( self._release(
loadbalancer, l7_policy, lbaas.delete_lbaas_l7policy, loadbalancer, l7_policy, lbaas.delete_l7_policy,
l7_policy.id) l7_policy.id)
def _create_l7_policy(self, l7_policy): def _create_l7_policy(self, l7_policy):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.create_lbaas_l7policy({'l7policy': { response = lbaas.create_l7_policy(
'action': _L7_POLICY_ACT_REDIRECT_TO_POOL, action=_L7_POLICY_ACT_REDIRECT_TO_POOL,
'listener_id': l7_policy.listener_id, listener_id=l7_policy.listener_id,
'name': l7_policy.name, name=l7_policy.name,
'project_id': l7_policy.project_id, project_id=l7_policy.project_id,
'redirect_pool_id': l7_policy.redirect_pool_id}}) redirect_pool_id=l7_policy.redirect_pool_id)
l7_policy.id = response['l7policy']['id'] l7_policy.id = response['id']
return l7_policy return l7_policy
def _find_l7_policy(self, l7_policy): def _find_l7_policy(self, l7_policy):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.list_lbaas_l7policies( response = lbaas.l7_policies(
name=l7_policy.name, name=l7_policy.name,
project_id=l7_policy.project_id, project_id=l7_policy.project_id,
redirect_pool_id=l7_policy.redirect_pool_id, redirect_pool_id=l7_policy.redirect_pool_id,
listener_id=l7_policy.listener_id) listener_id=l7_policy.listener_id)
try: try:
l7_policy.id = response['l7policies'][0]['id'] l7_policy.id = next(response)['id']
except (KeyError, IndexError): except (KeyError, StopIteration):
return None return None
return l7_policy return l7_policy
@ -869,49 +827,47 @@ class LBaaSv2Driver(base.LBaaSDriver):
def _create_l7_rule(self, l7_rule): def _create_l7_rule(self, l7_rule):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.create_lbaas_l7rule( response = lbaas.create_l7_rule(
l7_rule.l7policy_id, l7_rule.l7policy_id,
{'rule': {'compare_type': l7_rule.compare_type, compare_type=l7_rule.compare_type,
'type': l7_rule.type, type=l7_rule.type,
'value': l7_rule.value}}) value=l7_rule.value)
l7_rule.id = response['rule']['id'] l7_rule.id = response['id']
return l7_rule return l7_rule
def _find_l7_rule(self, l7_rule): def _find_l7_rule(self, l7_rule):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
response = lbaas.list_lbaas_l7rules( response = lbaas.l7_rules(
l7_rule.l7policy_id, l7_rule.l7policy_id,
type=l7_rule.type, type=l7_rule.type,
value=l7_rule.value, value=l7_rule.value,
compare_type=l7_rule.compare_type) compare_type=l7_rule.compare_type)
try: try:
l7_rule.id = response['rules'][0]['id'] l7_rule.id = next(response)['id']
except (KeyError, IndexError): except (KeyError, StopIteration):
return None return None
return l7_rule return l7_rule
def release_l7_rule(self, loadbalancer, l7_rule): def release_l7_rule(self, loadbalancer, l7_rule):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
self._release( self._release(
loadbalancer, l7_rule, lbaas.delete_lbaas_l7rule, loadbalancer, l7_rule, lbaas.delete_l7_rule,
l7_rule.id, l7_rule.l7policy_id) l7_rule.id, l7_rule.l7policy_id)
def update_l7_rule(self, l7_rule, new_value): def update_l7_rule(self, l7_rule, new_value):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
try: try:
lbaas.update_lbaas_l7rule( lbaas.update_l7_rule(
l7_rule.id, l7_rule.l7policy_id, l7_rule.id, l7_rule.l7policy_id,
{'rule': {'value': new_value}}) value=new_value)
except o_exc.SDKException:
except n_exc.NeutronClientException:
LOG.exception("Failed to update l7_rule- id=%s ", l7_rule.id) LOG.exception("Failed to update l7_rule- id=%s ", l7_rule.id)
raise raise
def is_pool_used_by_other_l7policies(self, l7policy, pool): def is_pool_used_by_other_l7policies(self, l7policy, pool):
lbaas = clients.get_loadbalancer_client() lbaas = clients.get_loadbalancer_client()
l7policy_list = lbaas.list_lbaas_l7policies( l7policy_list = lbaas.l7_policies(project_id=l7policy.project_id)
project_id=l7policy.project_id) for entry in l7policy_list:
for entry in l7policy_list['l7policies']:
if not entry: if not entry:
continue continue
if (entry['redirect_pool_id'] == pool.id and if (entry['redirect_pool_id'] == pool.id and

15
kuryr_kubernetes/controller/handlers/lbaas.py
View File

@ -250,16 +250,11 @@ class LoadBalancerHandler(k8s_base.ResourceEventHandler):
if not lbaas_state: if not lbaas_state:
return return
# NOTE(ivc): deleting pool deletes its members # NOTE(ivc): deleting pool deletes its members
if self._drv_lbaas.cascading_capable: self._drv_lbaas.release_loadbalancer(
self._drv_lbaas.release_loadbalancer( loadbalancer=lbaas_state.loadbalancer)
loadbalancer=lbaas_state.loadbalancer) if lbaas_state.service_pub_ip_info:
if lbaas_state.service_pub_ip_info: self._drv_service_pub_ip.release_pub_ip(
self._drv_service_pub_ip.release_pub_ip( lbaas_state.service_pub_ip_info)
lbaas_state.service_pub_ip_info)
else:
lbaas_state.members = []
self._sync_lbaas_members(endpoints, lbaas_state,
obj_lbaas.LBaaSServiceSpec())
def _should_ignore(self, endpoints, lbaas_spec): def _should_ignore(self, endpoints, lbaas_spec):
return not(lbaas_spec and return not(lbaas_spec and

307
kuryr_kubernetes/tests/unit/controller/drivers/test_lbaasv2.py
View File

@ -16,6 +16,7 @@
import mock import mock
from neutronclient.common import exceptions as n_exc from neutronclient.common import exceptions as n_exc
from openstack import exceptions as o_exc
from kuryr_kubernetes.controller.drivers import lbaasv2 as d_lbaasv2 from kuryr_kubernetes.controller.drivers import lbaasv2 as d_lbaasv2
from kuryr_kubernetes import exceptions as k_exc from kuryr_kubernetes import exceptions as k_exc
@ -68,24 +69,9 @@ class TestLBaaSv2Driver(test_base.TestCase):
m_driver, name, project_id, subnet_id, ip, m_driver, name, project_id, subnet_id, ip,
sg_ids, 'ClusterIP') sg_ids, 'ClusterIP')
def test_release_loadbalancer(self):
self.useFixture(k_fix.MockNeutronClient()).client
lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
lbaas.cascading_capable = False
cls = d_lbaasv2.LBaaSv2Driver
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
loadbalancer = mock.Mock()
cls.release_loadbalancer(m_driver, loadbalancer)
m_driver._release.assert_called_once_with(loadbalancer, loadbalancer,
lbaas.delete_loadbalancer,
loadbalancer.id)
def test_cascade_release_loadbalancer(self): def test_cascade_release_loadbalancer(self):
self.useFixture(k_fix.MockNeutronClient()).client self.useFixture(k_fix.MockNeutronClient()).client
lbaas = self.useFixture(k_fix.MockLBaaSClient()).client lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
lbaas.cascading_capable = True
lbaas.lbaas_loadbalancer_path = "boo %s" lbaas.lbaas_loadbalancer_path = "boo %s"
cls = d_lbaasv2.LBaaSv2Driver cls = d_lbaasv2.LBaaSv2Driver
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
@ -94,9 +80,8 @@ class TestLBaaSv2Driver(test_base.TestCase):
cls.release_loadbalancer(m_driver, loadbalancer) cls.release_loadbalancer(m_driver, loadbalancer)
m_driver._release.assert_called_once_with( m_driver._release.assert_called_once_with(
loadbalancer, loadbalancer, lbaas.delete, loadbalancer, loadbalancer, lbaas.delete_load_balancer,
lbaas.lbaas_loadbalancer_path % loadbalancer.id, loadbalancer.id, cascade=True)
params={'cascade': True})
def _test_ensure_listener(self): def _test_ensure_listener(self):
cls = d_lbaasv2.LBaaSv2Driver cls = d_lbaasv2.LBaaSv2Driver
@ -146,7 +131,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
loadbalancer = obj_lbaas.LBaaSLoadBalancer( loadbalancer = obj_lbaas.LBaaSLoadBalancer(
id=loadbalancer_id, name=name, project_id=project_id, id=loadbalancer_id, name=name, project_id=project_id,
subnet_id=subnet_id, ip=ip, provider=provider) subnet_id=subnet_id, ip=ip, provider=provider)
m_driver._ensure_provisioned.side_effect = n_exc.BadRequest m_driver._ensure_provisioned.side_effect = o_exc.BadRequestException
resp = cls.ensure_listener(m_driver, loadbalancer, resp = cls.ensure_listener(m_driver, loadbalancer,
protocol, port) protocol, port)
@ -205,7 +190,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
cls.release_pool(m_driver, loadbalancer, pool) cls.release_pool(m_driver, loadbalancer, pool)
m_driver._release.assert_called_once_with(loadbalancer, pool, m_driver._release.assert_called_once_with(loadbalancer, pool,
lbaas.delete_lbaas_pool, lbaas.delete_pool,
pool.id) pool.id)
def test_ensure_member(self): def test_ensure_member(self):
@ -251,7 +236,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
cls.release_member(m_driver, loadbalancer, member) cls.release_member(m_driver, loadbalancer, member)
m_driver._release.assert_called_once_with(loadbalancer, member, m_driver._release.assert_called_once_with(loadbalancer, member,
lbaas.delete_lbaas_member, lbaas.delete_member,
member.id, member.pool_id) member.id, member.pool_id)
def test_create_loadbalancer(self): def test_create_loadbalancer(self):
@ -263,18 +248,18 @@ class TestLBaaSv2Driver(test_base.TestCase):
subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1',
security_groups=[]) security_groups=[])
loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C'
req = {'loadbalancer': { req = {
'name': loadbalancer.name, 'name': loadbalancer.name,
'project_id': loadbalancer.project_id, 'project_id': loadbalancer.project_id,
'vip_address': str(loadbalancer.ip), 'vip_address': str(loadbalancer.ip),
'vip_subnet_id': loadbalancer.subnet_id, 'vip_subnet_id': loadbalancer.subnet_id,
}} }
resp = {'loadbalancer': {'id': loadbalancer_id, 'provider': 'haproxy'}} resp = {'id': loadbalancer_id, 'provider': 'haproxy'}
lbaas.create_loadbalancer.return_value = resp lbaas.create_load_balancer.return_value = resp
m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id} m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id}
ret = cls._create_loadbalancer(m_driver, loadbalancer) ret = cls._create_loadbalancer(m_driver, loadbalancer)
lbaas.create_loadbalancer.assert_called_once_with(req) lbaas.create_load_balancer.assert_called_once_with(**req)
for attr in loadbalancer.obj_fields: for attr in loadbalancer.obj_fields:
self.assertEqual(getattr(loadbalancer, attr), self.assertEqual(getattr(loadbalancer, attr),
getattr(ret, attr)) getattr(ret, attr))
@ -290,19 +275,19 @@ class TestLBaaSv2Driver(test_base.TestCase):
security_groups=[], security_groups=[],
provider='amphora') provider='amphora')
loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C'
req = {'loadbalancer': { req = {
'name': loadbalancer.name, 'name': loadbalancer.name,
'project_id': loadbalancer.project_id, 'project_id': loadbalancer.project_id,
'vip_address': str(loadbalancer.ip), 'vip_address': str(loadbalancer.ip),
'vip_subnet_id': loadbalancer.subnet_id, 'vip_subnet_id': loadbalancer.subnet_id,
'provider': loadbalancer.provider, 'provider': loadbalancer.provider,
}} }
resp = {'loadbalancer': {'id': loadbalancer_id, 'provider': 'amphora'}} resp = {'id': loadbalancer_id, 'provider': 'amphora'}
lbaas.create_loadbalancer.return_value = resp lbaas.create_load_balancer.return_value = resp
m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id} m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id}
ret = cls._create_loadbalancer(m_driver, loadbalancer) ret = cls._create_loadbalancer(m_driver, loadbalancer)
lbaas.create_loadbalancer.assert_called_once_with(req) lbaas.create_load_balancer.assert_called_once_with(**req)
for attr in loadbalancer.obj_fields: for attr in loadbalancer.obj_fields:
self.assertEqual(getattr(loadbalancer, attr), self.assertEqual(getattr(loadbalancer, attr),
getattr(ret, attr)) getattr(ret, attr))
@ -318,19 +303,19 @@ class TestLBaaSv2Driver(test_base.TestCase):
security_groups=[], security_groups=[],
provider='amphora') provider='amphora')
loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C'
req = {'loadbalancer': { req = {
'name': loadbalancer.name, 'name': loadbalancer.name,
'project_id': loadbalancer.project_id, 'project_id': loadbalancer.project_id,
'vip_address': str(loadbalancer.ip), 'vip_address': str(loadbalancer.ip),
'vip_subnet_id': loadbalancer.subnet_id, 'vip_subnet_id': loadbalancer.subnet_id,
'provider': loadbalancer.provider, 'provider': loadbalancer.provider,
}} }
resp = {'loadbalancer': {'id': loadbalancer_id, 'provider': 'haproxy'}} resp = {'id': loadbalancer_id, 'provider': 'haproxy'}
lbaas.create_loadbalancer.return_value = resp lbaas.create_load_balancer.return_value = resp
m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id} m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id}
ret = cls._create_loadbalancer(m_driver, loadbalancer) ret = cls._create_loadbalancer(m_driver, loadbalancer)
lbaas.create_loadbalancer.assert_called_once_with(req) lbaas.create_load_balancer.assert_called_once_with(**req)
self.assertIsNone(ret) self.assertIsNone(ret)
def test_find_loadbalancer(self): def test_find_loadbalancer(self):
@ -342,14 +327,14 @@ class TestLBaaSv2Driver(test_base.TestCase):
subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1',
provider='haproxy', security_groups=[]) provider='haproxy', security_groups=[])
loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C'
resp = {'loadbalancers': [{'id': loadbalancer_id, resp = iter([{'id': loadbalancer_id,
'provider': 'haproxy', 'provider': 'haproxy',
'provisioning_status': 'ACTIVE'}]} 'provisioning_status': 'ACTIVE'}])
lbaas.list_loadbalancers.return_value = resp lbaas.load_balancers.return_value = resp
m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id} m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id}
ret = cls._find_loadbalancer(m_driver, loadbalancer) ret = cls._find_loadbalancer(m_driver, loadbalancer)
lbaas.list_loadbalancers.assert_called_once_with( lbaas.load_balancers.assert_called_once_with(
name=loadbalancer.name, name=loadbalancer.name,
project_id=loadbalancer.project_id, project_id=loadbalancer.project_id,
vip_address=str(loadbalancer.ip), vip_address=str(loadbalancer.ip),
@ -367,11 +352,11 @@ class TestLBaaSv2Driver(test_base.TestCase):
loadbalancer = obj_lbaas.LBaaSLoadBalancer( loadbalancer = obj_lbaas.LBaaSLoadBalancer(
name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4',
subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1')
resp = {'loadbalancers': []} resp = iter([])
lbaas.list_loadbalancers.return_value = resp lbaas.load_balancers.return_value = resp
ret = cls._find_loadbalancer(m_driver, loadbalancer) ret = cls._find_loadbalancer(m_driver, loadbalancer)
lbaas.list_loadbalancers.assert_called_once_with( lbaas.load_balancers.assert_called_once_with(
name=loadbalancer.name, name=loadbalancer.name,
project_id=loadbalancer.project_id, project_id=loadbalancer.project_id,
vip_address=str(loadbalancer.ip), vip_address=str(loadbalancer.ip),
@ -387,14 +372,14 @@ class TestLBaaSv2Driver(test_base.TestCase):
name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4',
subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1')
loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C'
resp = {'loadbalancers': [{'id': loadbalancer_id, resp = iter([{'id': loadbalancer_id,
'provider': 'haproxy', 'provider': 'haproxy',
'provisioning_status': 'ERROR'}]} 'provisioning_status': 'ERROR'}])
lbaas.list_loadbalancers.return_value = resp lbaas.load_balancers.return_value = resp
m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id} m_driver._get_vip_port.return_value = {'id': mock.sentinel.port_id}
ret = cls._find_loadbalancer(m_driver, loadbalancer) ret = cls._find_loadbalancer(m_driver, loadbalancer)
lbaas.list_loadbalancers.assert_called_once_with( lbaas.load_balancers.assert_called_once_with(
name=loadbalancer.name, name=loadbalancer.name,
project_id=loadbalancer.project_id, project_id=loadbalancer.project_id,
vip_address=str(loadbalancer.ip), vip_address=str(loadbalancer.ip),
@ -410,17 +395,17 @@ class TestLBaaSv2Driver(test_base.TestCase):
name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP',
port=1234, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') port=1234, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
listener_id = 'A57B7771-6050-4CA8-A63C-443493EC98AB' listener_id = 'A57B7771-6050-4CA8-A63C-443493EC98AB'
req = {'listener': { req = {
'name': listener.name, 'name': listener.name,
'project_id': listener.project_id, 'project_id': listener.project_id,
'loadbalancer_id': listener.loadbalancer_id, 'load_balancer_id': listener.loadbalancer_id,
'protocol': listener.protocol, 'protocol': listener.protocol,
'protocol_port': listener.port}} 'protocol_port': listener.port}
resp = {'listener': {'id': listener_id}} resp = {'id': listener_id}
lbaas.create_listener.return_value = resp lbaas.create_listener.return_value = resp
ret = cls._create_listener(m_driver, listener) ret = cls._create_listener(m_driver, listener)
lbaas.create_listener.assert_called_once_with(req) lbaas.create_listener.assert_called_once_with(**req)
for attr in listener.obj_fields: for attr in listener.obj_fields:
self.assertEqual(getattr(listener, attr), self.assertEqual(getattr(listener, attr),
getattr(ret, attr)) getattr(ret, attr))
@ -434,14 +419,13 @@ class TestLBaaSv2Driver(test_base.TestCase):
name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP',
port=1234, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') port=1234, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
listener_id = 'A57B7771-6050-4CA8-A63C-443493EC98AB' listener_id = 'A57B7771-6050-4CA8-A63C-443493EC98AB'
resp = {'listeners': [{'id': listener_id}]} lbaas.listeners.return_value = iter([{'id': listener_id}])
lbaas.list_listeners.return_value = resp
ret = cls._find_listener(m_driver, listener) ret = cls._find_listener(m_driver, listener)
lbaas.list_listeners.assert_called_once_with( lbaas.listeners.assert_called_once_with(
name=listener.name, name=listener.name,
project_id=listener.project_id, project_id=listener.project_id,
loadbalancer_id=listener.loadbalancer_id, load_balancer_id=listener.loadbalancer_id,
protocol=listener.protocol, protocol=listener.protocol,
protocol_port=listener.port) protocol_port=listener.port)
for attr in listener.obj_fields: for attr in listener.obj_fields:
@ -456,14 +440,14 @@ class TestLBaaSv2Driver(test_base.TestCase):
listener = obj_lbaas.LBaaSListener( listener = obj_lbaas.LBaaSListener(
name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP',
port=1234, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') port=1234, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
resp = {'listeners': []} resp = iter([])
lbaas.list_listeners.return_value = resp lbaas.listeners.return_value = resp
ret = cls._find_listener(m_driver, listener) ret = cls._find_listener(m_driver, listener)
lbaas.list_listeners.assert_called_once_with( lbaas.listeners.assert_called_once_with(
name=listener.name, name=listener.name,
project_id=listener.project_id, project_id=listener.project_id,
loadbalancer_id=listener.loadbalancer_id, load_balancer_id=listener.loadbalancer_id,
protocol=listener.protocol, protocol=listener.protocol,
protocol_port=listener.port) protocol_port=listener.port)
self.assertIsNone(ret) self.assertIsNone(ret)
@ -478,18 +462,18 @@ class TestLBaaSv2Driver(test_base.TestCase):
listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB', listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB',
loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
pool_id = 'D4F35594-27EB-4F4C-930C-31DD40F53B77' pool_id = 'D4F35594-27EB-4F4C-930C-31DD40F53B77'
req = {'pool': { req = {
'name': pool.name, 'name': pool.name,
'project_id': pool.project_id, 'project_id': pool.project_id,
'listener_id': pool.listener_id, 'listener_id': pool.listener_id,
'loadbalancer_id': pool.loadbalancer_id, 'loadbalancer_id': pool.loadbalancer_id,
'protocol': pool.protocol, 'protocol': pool.protocol,
'lb_algorithm': lb_algorithm}} 'lb_algorithm': lb_algorithm}
resp = {'pool': {'id': pool_id}} resp = {'id': pool_id}
lbaas.create_lbaas_pool.return_value = resp lbaas.create_pool.return_value = resp
ret = cls._create_pool(m_driver, pool) ret = cls._create_pool(m_driver, pool)
lbaas.create_lbaas_pool.assert_called_once_with(req) lbaas.create_pool.assert_called_once_with(**req)
for attr in pool.obj_fields: for attr in pool.obj_fields:
self.assertEqual(getattr(pool, attr), self.assertEqual(getattr(pool, attr),
getattr(ret, attr)) getattr(ret, attr))
@ -504,24 +488,18 @@ class TestLBaaSv2Driver(test_base.TestCase):
name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP',
listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB', listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB',
loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
req = {'pool': { req = {
'name': pool.name, 'name': pool.name,
'project_id': pool.project_id, 'project_id': pool.project_id,
'listener_id': pool.listener_id, 'listener_id': pool.listener_id,
'loadbalancer_id': pool.loadbalancer_id, 'loadbalancer_id': pool.loadbalancer_id,
'protocol': pool.protocol, 'protocol': pool.protocol,
'lb_algorithm': lb_algorithm}} 'lb_algorithm': lb_algorithm}
lbaas.create_lbaas_pool.side_effect = n_exc.StateInvalidClient lbaas.create_pool.side_effect = n_exc.StateInvalidClient
self.assertRaises(n_exc.StateInvalidClient, cls._create_pool, m_driver, self.assertRaises(n_exc.StateInvalidClient, cls._create_pool, m_driver,
pool) pool)
lbaas.create_lbaas_pool.assert_called_once_with(req) lbaas.create_pool.assert_called_once_with(**req)
m_driver._cleanup_bogus_pool.assert_called_once_with(lbaas, pool,
lb_algorithm)
def test_cleanup_bogus_pool(self):
# TODO(ivc): add unit test or get rid of _cleanup_bogus_pool
self.skipTest("not implemented")
def test_find_pool_by_listener(self): def test_find_pool_by_listener(self):
lbaas = self.useFixture(k_fix.MockLBaaSClient()).client lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
@ -532,12 +510,12 @@ class TestLBaaSv2Driver(test_base.TestCase):
listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB', listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB',
loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
pool_id = 'D4F35594-27EB-4F4C-930C-31DD40F53B77' pool_id = 'D4F35594-27EB-4F4C-930C-31DD40F53B77'
resp = {'pools': [{'id': pool_id, resp = [{'id': pool_id,
'listeners': [{'id': pool.listener_id}]}]} 'listeners': [{'id': pool.listener_id}]}]
lbaas.list_lbaas_pools.return_value = resp lbaas.pools.return_value = resp
ret = cls._find_pool(m_driver, pool) ret = cls._find_pool(m_driver, pool)
lbaas.list_lbaas_pools.assert_called_once_with( lbaas.pools.assert_called_once_with(
name=pool.name, name=pool.name,
project_id=pool.project_id, project_id=pool.project_id,
loadbalancer_id=pool.loadbalancer_id, loadbalancer_id=pool.loadbalancer_id,
@ -555,11 +533,11 @@ class TestLBaaSv2Driver(test_base.TestCase):
name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP',
listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB', listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB',
loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
resp = {'pools': []} resp = []
lbaas.list_lbaas_pools.return_value = resp lbaas.pools.return_value = resp
ret = cls._find_pool(m_driver, pool) ret = cls._find_pool(m_driver, pool)
lbaas.list_lbaas_pools.assert_called_once_with( lbaas.pools.assert_called_once_with(
name=pool.name, name=pool.name,
project_id=pool.project_id, project_id=pool.project_id,
loadbalancer_id=pool.loadbalancer_id, loadbalancer_id=pool.loadbalancer_id,
@ -575,18 +553,18 @@ class TestLBaaSv2Driver(test_base.TestCase):
port=1234, subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', port=1234, subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1',
pool_id='D4F35594-27EB-4F4C-930C-31DD40F53B77') pool_id='D4F35594-27EB-4F4C-930C-31DD40F53B77')
member_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F' member_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F'
req = {'member': { req = {
'name': member.name, 'name': member.name,
'project_id': member.project_id, 'project_id': member.project_id,
'subnet_id': member.subnet_id, 'subnet_id': member.subnet_id,
'address': str(member.ip), 'address': str(member.ip),
'protocol_port': member.port}} 'protocol_port': member.port}
resp = {'member': {'id': member_id}} resp = {'id': member_id}
lbaas.create_lbaas_member.return_value = resp lbaas.create_member.return_value = resp
ret = cls._create_member(m_driver, member) ret = cls._create_member(m_driver, member)
lbaas.create_lbaas_member.assert_called_once_with( lbaas.create_member.assert_called_once_with(
member.pool_id, req) member.pool_id, **req)
for attr in member.obj_fields: for attr in member.obj_fields:
self.assertEqual(getattr(member, attr), self.assertEqual(getattr(member, attr),
getattr(ret, attr)) getattr(ret, attr))
@ -601,11 +579,11 @@ class TestLBaaSv2Driver(test_base.TestCase):
port=1234, subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', port=1234, subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1',
pool_id='D4F35594-27EB-4F4C-930C-31DD40F53B77') pool_id='D4F35594-27EB-4F4C-930C-31DD40F53B77')
member_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F' member_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F'
resp = {'members': [{'id': member_id}]} resp = iter([{'id': member_id}])
lbaas.list_lbaas_members.return_value = resp lbaas.members.return_value = resp
ret = cls._find_member(m_driver, member) ret = cls._find_member(m_driver, member)
lbaas.list_lbaas_members.assert_called_once_with( lbaas.members.assert_called_once_with(
member.pool_id, member.pool_id,
name=member.name, name=member.name,
project_id=member.project_id, project_id=member.project_id,
@ -625,11 +603,11 @@ class TestLBaaSv2Driver(test_base.TestCase):
name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4',
port=1234, subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', port=1234, subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1',
pool_id='D4F35594-27EB-4F4C-930C-31DD40F53B77') pool_id='D4F35594-27EB-4F4C-930C-31DD40F53B77')
resp = {'members': []} resp = iter([])
lbaas.list_lbaas_members.return_value = resp lbaas.members.return_value = resp
ret = cls._find_member(m_driver, member) ret = cls._find_member(m_driver, member)
lbaas.list_lbaas_members.assert_called_once_with( lbaas.members.assert_called_once_with(
member.pool_id, member.pool_id,
name=member.name, name=member.name,
project_id=member.project_id, project_id=member.project_id,
@ -667,10 +645,12 @@ class TestLBaaSv2Driver(test_base.TestCase):
self.assertEqual(expected_result, ret) self.assertEqual(expected_result, ret)
def test_ensure_with_conflict(self): def test_ensure_with_conflict(self):
self._verify_ensure_with_exception(n_exc.Conflict) self._verify_ensure_with_exception(
o_exc.ConflictException(http_status=409))
def test_ensure_with_internalservererror(self): def test_ensure_with_internalservererror(self):
self._verify_ensure_with_exception(n_exc.InternalServerError) self._verify_ensure_with_exception(
o_exc.HttpException(http_status=500))
def test_request(self): def test_request(self):
cls = d_lbaasv2.LBaaSv2Driver cls = d_lbaasv2.LBaaSv2Driver
@ -682,7 +662,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
expected_result = mock.sentinel.expected_result expected_result = mock.sentinel.expected_result
timer = [mock.sentinel.t0, mock.sentinel.t1] timer = [mock.sentinel.t0, mock.sentinel.t1]
m_driver._provisioning_timer.return_value = timer m_driver._provisioning_timer.return_value = timer
m_driver._ensure.side_effect = [n_exc.StateInvalidClient, m_driver._ensure.side_effect = [o_exc.BadRequestException,
expected_result] expected_result]
ret = cls._ensure_provisioned(m_driver, loadbalancer, obj, create, ret = cls._ensure_provisioned(m_driver, loadbalancer, obj, create,
@ -738,7 +718,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
m_delete = mock.Mock() m_delete = mock.Mock()
timer = [mock.sentinel.t0, mock.sentinel.t1] timer = [mock.sentinel.t0, mock.sentinel.t1]
m_driver._provisioning_timer.return_value = timer m_driver._provisioning_timer.return_value = timer
m_delete.side_effect = [n_exc.StateInvalidClient, None] m_delete.side_effect = [o_exc.BadRequestException, None]
cls._release(m_driver, loadbalancer, obj, m_delete) cls._release(m_driver, loadbalancer, obj, m_delete)
@ -754,7 +734,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
m_delete = mock.Mock() m_delete = mock.Mock()
timer = [mock.sentinel.t0, mock.sentinel.t1] timer = [mock.sentinel.t0, mock.sentinel.t1]
m_driver._provisioning_timer.return_value = timer m_driver._provisioning_timer.return_value = timer
m_delete.side_effect = n_exc.NotFound m_delete.side_effect = o_exc.NotFoundException
cls._release(m_driver, loadbalancer, obj, m_delete) cls._release(m_driver, loadbalancer, obj, m_delete)
@ -769,7 +749,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
m_delete = mock.Mock() m_delete = mock.Mock()
timer = [mock.sentinel.t0, mock.sentinel.t1] timer = [mock.sentinel.t0, mock.sentinel.t1]
m_driver._provisioning_timer.return_value = timer m_driver._provisioning_timer.return_value = timer
m_delete.side_effect = n_exc.StateInvalidClient m_delete.side_effect = o_exc.ConflictException
self.assertRaises(k_exc.ResourceNotReady, cls._release, m_driver, self.assertRaises(k_exc.ResourceNotReady, cls._release, m_driver,
loadbalancer, obj, m_delete) loadbalancer, obj, m_delete)
@ -787,12 +767,12 @@ class TestLBaaSv2Driver(test_base.TestCase):
timeout = mock.sentinel.timeout timeout = mock.sentinel.timeout
timer = [mock.sentinel.t0, mock.sentinel.t1] timer = [mock.sentinel.t0, mock.sentinel.t1]
m_driver._provisioning_timer.return_value = timer m_driver._provisioning_timer.return_value = timer
resp = {'loadbalancer': {'provisioning_status': 'ACTIVE'}} resp = {'provisioning_status': 'ACTIVE'}
lbaas.show_loadbalancer.return_value = resp lbaas.get_load_balancer.return_value = resp
cls._wait_for_provisioning(m_driver, loadbalancer, timeout) cls._wait_for_provisioning(m_driver, loadbalancer, timeout)
lbaas.show_loadbalancer.assert_called_once_with(loadbalancer.id) lbaas.get_load_balancer.assert_called_once_with(loadbalancer.id)
def test_wait_for_provisioning_not_ready(self): def test_wait_for_provisioning_not_ready(self):
lbaas = self.useFixture(k_fix.MockLBaaSClient()).client lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
@ -802,13 +782,13 @@ class TestLBaaSv2Driver(test_base.TestCase):
timeout = mock.sentinel.timeout timeout = mock.sentinel.timeout
timer = [mock.sentinel.t0, mock.sentinel.t1] timer = [mock.sentinel.t0, mock.sentinel.t1]
m_driver._provisioning_timer.return_value = timer m_driver._provisioning_timer.return_value = timer
resp = {'loadbalancer': {'provisioning_status': 'NOT_ACTIVE'}} resp = {'provisioning_status': 'NOT_ACTIVE'}
lbaas.show_loadbalancer.return_value = resp lbaas.get_load_balancer.return_value = resp
self.assertRaises(k_exc.ResourceNotReady, cls._wait_for_provisioning, self.assertRaises(k_exc.ResourceNotReady, cls._wait_for_provisioning,
m_driver, loadbalancer, timeout) m_driver, loadbalancer, timeout)
self.assertEqual(len(timer), lbaas.show_loadbalancer.call_count) self.assertEqual(len(timer), lbaas.get_load_balancer.call_count)
def test_provisioning_timer(self): def test_provisioning_timer(self):
# REVISIT(ivc): add test if _provisioning_timer is to stay # REVISIT(ivc): add test if _provisioning_timer is to stay
@ -820,7 +800,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
pools = {'name': 'KUKU', 'id': 'a2a62ea7-e3bf-40df-8c09-aa0c29876a6b'} pools = {'name': 'KUKU', 'id': 'a2a62ea7-e3bf-40df-8c09-aa0c29876a6b'}
lbaas.list_lbaas_pools.return_value = {'pools': [pools]} lbaas.pools.return_value = [pools]
pool_name = 'NOT_KUKU' pool_name = 'NOT_KUKU'
project_id = 'TEST_PROJECT' project_id = 'TEST_PROJECT'
@ -859,25 +839,23 @@ class TestLBaaSv2Driver(test_base.TestCase):
protocol=pool_protocol, protocol=pool_protocol,
id=pool_id) id=pool_id)
resp = {"pools": [ resp = [{
{ "protocol": pool_protocol,
"protocol": pool_protocol, "loadbalancers": [
"loadbalancers": [ {
{ "id": pool_lb_id
"id": pool_lb_id }
} ],
], "listeners": resp_listeners,
"listeners": resp_listeners, "project_id": pool_project_id,
"project_id": pool_project_id, "id": pool_id,
"id": pool_id, "name": pool_name
"name": pool_name }]
}
]}
lbaas.list_lbaas_pools.return_value = resp lbaas.pools.return_value = resp
pool = cls.get_pool_by_name(m_driver, pool_name, pool_project_id) pool = cls.get_pool_by_name(m_driver, pool_name, pool_project_id)
lbaas.list_lbaas_pools.assert_called_once() lbaas.pools.assert_called_once()
for attr in expected_result.obj_fields: for attr in expected_result.obj_fields:
self.assertEqual(getattr(expected_result, attr), self.assertEqual(getattr(expected_result, attr),
getattr(pool, attr)) getattr(pool, attr))
@ -887,7 +865,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
cls = d_lbaasv2.LBaaSv2Driver cls = d_lbaasv2.LBaaSv2Driver
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
pools = {} pools = {}
lbaas.list_lbaas_pools.return_value = {'pools': [pools]} lbaas.pools.return_value = [pools]
pool_name = 'NOT_KUKU' pool_name = 'NOT_KUKU'
project_id = 'TEST_PROJECT' project_id = 'TEST_PROJECT'
@ -913,18 +891,18 @@ class TestLBaaSv2Driver(test_base.TestCase):
subnet_id=loadbalancer_subnet_id, ip=loadbalancer_vip, subnet_id=loadbalancer_subnet_id, ip=loadbalancer_vip,
security_groups=None, provider=loadbalancer_provider) security_groups=None, provider=loadbalancer_provider)
resp = {'loadbalancer': {'id': loadbalancer_id, resp = {'id': loadbalancer_id,
'vip_port_id': loadbalancer_vip_port_id, 'vip_port_id': loadbalancer_vip_port_id,
'name': loadbalancer_name, 'name': loadbalancer_name,
'project_id': loadbalancer_project_id, 'project_id': loadbalancer_project_id,
'vip_subnet_id': loadbalancer_subnet_id, 'vip_subnet_id': loadbalancer_subnet_id,
'vip_address': loadbalancer_vip, 'vip_address': loadbalancer_vip,
'provider': loadbalancer_provider}} 'provider': loadbalancer_provider}
lbaas.show_loadbalancer.return_value = resp lbaas.get_load_balancer.return_value = resp
ret = cls.get_lb_by_uuid(m_driver, loadbalancer_id) ret = cls.get_lb_by_uuid(m_driver, loadbalancer_id)
lbaas.show_loadbalancer.assert_called_once() lbaas.get_load_balancer.assert_called_once()
for attr in expected_lb.obj_fields: for attr in expected_lb.obj_fields:
self.assertEqual(getattr(expected_lb, attr), self.assertEqual(getattr(expected_lb, attr),
getattr(ret, attr)) getattr(ret, attr))
@ -936,13 +914,13 @@ class TestLBaaSv2Driver(test_base.TestCase):
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
resp = {'loadbalancer': {}} resp = {'loadbalancer': {}}
lbaas.show_loadbalancer.return_value = resp lbaas.get_load_balancer.return_value = resp
requested_uuid = '00EE9E11-91C2-41CF-8FD4-7970579EFFFF' requested_uuid = '00EE9E11-91C2-41CF-8FD4-7970579EFFFF'
lbaas.show_loadbalancer.return_value = resp lbaas.get_load_balancer.side_effect = o_exc.ResourceNotFound
ret = cls.get_lb_by_uuid(m_driver, requested_uuid) ret = cls.get_lb_by_uuid(m_driver, requested_uuid)
lbaas.show_loadbalancer.assert_called_once() lbaas.get_load_balancer.assert_called_once()
self.assertIsNone(ret) self.assertIsNone(ret)
def test_ensure_l7policy(self): def test_ensure_l7policy(self):
@ -987,7 +965,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
cls.release_l7_policy(m_driver, loadbalancer, l7_policy) cls.release_l7_policy(m_driver, loadbalancer, l7_policy)
m_driver._release.assert_called_once_with( m_driver._release.assert_called_once_with(
loadbalancer, l7_policy, lbaas.delete_lbaas_l7policy, loadbalancer, l7_policy, lbaas.delete_l7_policy,
l7_policy.id) l7_policy.id)
def test_create_l7policy(self): def test_create_l7policy(self):
@ -1002,17 +980,17 @@ class TestLBaaSv2Driver(test_base.TestCase):
redirect_pool_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') redirect_pool_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1')
l7policy_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F' l7policy_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F'
req = {'l7policy': { req = {
'action': 'REDIRECT_TO_POOL', 'action': 'REDIRECT_TO_POOL',
'listener_id': l7_policy.listener_id, 'listener_id': l7_policy.listener_id,
'name': l7_policy.name, 'name': l7_policy.name,
'project_id': l7_policy.project_id, 'project_id': l7_policy.project_id,
'redirect_pool_id': l7_policy.redirect_pool_id}} 'redirect_pool_id': l7_policy.redirect_pool_id}
resp = {'l7policy': {'id': l7policy_id}} resp = {'id': l7policy_id}
lbaas.create_lbaas_l7policy.return_value = resp lbaas.create_l7_policy.return_value = resp
ret = cls._create_l7_policy(m_driver, l7_policy) ret = cls._create_l7_policy(m_driver, l7_policy)
lbaas.create_lbaas_l7policy.assert_called_once_with(req) lbaas.create_l7_policy.assert_called_once_with(**req)
for attr in l7_policy.obj_fields: for attr in l7_policy.obj_fields:
self.assertEqual(getattr(l7_policy, attr), self.assertEqual(getattr(l7_policy, attr),
getattr(ret, attr)) getattr(ret, attr))
@ -1030,11 +1008,11 @@ class TestLBaaSv2Driver(test_base.TestCase):
l7policy_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F' l7policy_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F'
resp = {'l7policies': [{'id': l7policy_id}]} resp = iter([{'id': l7policy_id}])
lbaas.list_lbaas_l7policies.return_value = resp lbaas.l7_policies.return_value = resp
ret = cls._find_l7_policy(m_driver, l7_policy) ret = cls._find_l7_policy(m_driver, l7_policy)
lbaas.list_lbaas_l7policies.assert_called_once_with( lbaas.l7_policies.assert_called_once_with(
name=l7_policy.name, name=l7_policy.name,
project_id=l7_policy.project_id, project_id=l7_policy.project_id,
redirect_pool_id=l7_policy.redirect_pool_id, redirect_pool_id=l7_policy.redirect_pool_id,
@ -1054,11 +1032,11 @@ class TestLBaaSv2Driver(test_base.TestCase):
listener_id='D4F35594-27EB-4F4C-930C-31DD40F53B77', listener_id='D4F35594-27EB-4F4C-930C-31DD40F53B77',
redirect_pool_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') redirect_pool_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1')
resp = {'l7policies': []} resp = iter([])
lbaas.list_lbaas_l7policies.return_value = resp lbaas.l7_policies.return_value = resp
ret = cls._find_l7_policy(m_driver, l7_policy) ret = cls._find_l7_policy(m_driver, l7_policy)
lbaas.list_lbaas_l7policies.assert_called_once_with( lbaas.l7_policies.assert_called_once_with(
name=l7_policy.name, name=l7_policy.name,
project_id=l7_policy.project_id, project_id=l7_policy.project_id,
redirect_pool_id=l7_policy.redirect_pool_id, redirect_pool_id=l7_policy.redirect_pool_id,
@ -1104,7 +1082,7 @@ class TestLBaaSv2Driver(test_base.TestCase):
cls.release_l7_rule(m_driver, loadbalancer, l7_rule) cls.release_l7_rule(m_driver, loadbalancer, l7_rule)
m_driver._release.assert_called_once_with( m_driver._release.assert_called_once_with(
loadbalancer, l7_rule, lbaas.delete_lbaas_l7rule, loadbalancer, l7_rule, lbaas.delete_l7_rule,
l7_rule.id, l7_rule.l7policy_id) l7_rule.id, l7_rule.l7policy_id)
def test_create_l7_rule(self): def test_create_l7_rule(self):
@ -1120,17 +1098,16 @@ class TestLBaaSv2Driver(test_base.TestCase):
l7_rule_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F' l7_rule_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F'
req = {'rule': { req = {'compare_type': l7_rule.compare_type,
'compare_type': l7_rule.compare_type, 'type': l7_rule.type,
'type': l7_rule.type, 'value': l7_rule.value}
'value': l7_rule.value}}
resp = {'rule': {'id': l7_rule_id}} resp = {'id': l7_rule_id}
lbaas.create_lbaas_l7rule.return_value = resp lbaas.create_l7_rule.return_value = resp
ret = cls._create_l7_rule(m_driver, l7_rule) ret = cls._create_l7_rule(m_driver, l7_rule)
lbaas.create_lbaas_l7rule.assert_called_once_with( lbaas.create_l7_rule.assert_called_once_with(l7_rule.l7policy_id,
l7_rule.l7policy_id, req) **req)
for attr in l7_rule.obj_fields: for attr in l7_rule.obj_fields:
self.assertEqual(getattr(l7_rule, attr), self.assertEqual(getattr(l7_rule, attr),
getattr(ret, attr)) getattr(ret, attr))
@ -1147,11 +1124,11 @@ class TestLBaaSv2Driver(test_base.TestCase):
value='www.test.com') value='www.test.com')
l7_rule_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F' l7_rule_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F'
resp = {'rules': [{'id': l7_rule_id}]} resp = iter([{'id': l7_rule_id}])
lbaas.list_lbaas_l7rules.return_value = resp lbaas.l7_rules.return_value = resp
ret = cls._find_l7_rule(m_driver, l7_rule) ret = cls._find_l7_rule(m_driver, l7_rule)
lbaas.list_lbaas_l7rules.assert_called_once_with( lbaas.l7_rules.assert_called_once_with(
l7_rule.l7policy_id, l7_rule.l7policy_id,
type=l7_rule.type, type=l7_rule.type,
value=l7_rule.value, value=l7_rule.value,
@ -1172,11 +1149,11 @@ class TestLBaaSv2Driver(test_base.TestCase):
type='HOST_NAME', type='HOST_NAME',
value='www.test.com') value='www.test.com')
resp = {'rules': []} resp = iter([])
lbaas.list_lbaas_l7rules.return_value = resp lbaas.l7_rules.return_value = resp
ret = cls._find_l7_rule(m_driver, l7_rule) ret = cls._find_l7_rule(m_driver, l7_rule)
lbaas.list_lbaas_l7rules.assert_called_once_with( lbaas.l7_rules.assert_called_once_with(
l7_rule.l7policy_id, l7_rule.l7policy_id,
type=l7_rule.type, type=l7_rule.type,
value=l7_rule.value, value=l7_rule.value,

20
kuryr_kubernetes/tests/unit/controller/handlers/test_lbaas.py
View File

@ -608,25 +608,6 @@ class TestLoadBalancerHandler(test_base.TestCase):
m_handler.on_deleted.assert_called_once_with( m_handler.on_deleted.assert_called_once_with(
endpoints, lbaas_state) endpoints, lbaas_state)
@mock.patch('kuryr_kubernetes.objects.lbaas'
'.LBaaSServiceSpec')
def test_on_deleted(self, m_svc_spec_ctor):
endpoints = mock.sentinel.endpoints
empty_spec = mock.sentinel.empty_spec
lbaas_state = mock.sentinel.lbaas_state
m_svc_spec_ctor.return_value = empty_spec
m_handler = mock.Mock(spec=h_lbaas.LoadBalancerHandler)
m_handler._get_lbaas_state.return_value = lbaas_state
m_handler._drv_lbaas = mock.Mock()
m_handler._drv_lbaas.cascading_capable = False
h_lbaas.LoadBalancerHandler.on_deleted(m_handler, endpoints)
m_handler._get_lbaas_state.assert_called_once_with(endpoints)
m_handler._sync_lbaas_members.assert_called_once_with(
endpoints, lbaas_state, empty_spec)
@mock.patch('kuryr_kubernetes.objects.lbaas' @mock.patch('kuryr_kubernetes.objects.lbaas'
'.LBaaSServiceSpec') '.LBaaSServiceSpec')
def test_on_cascade_deleted_lb_service(self, m_svc_spec_ctor): def test_on_cascade_deleted_lb_service(self, m_svc_spec_ctor):
@ -641,7 +622,6 @@ class TestLoadBalancerHandler(test_base.TestCase):
m_handler._get_lbaas_state.return_value = lbaas_state m_handler._get_lbaas_state.return_value = lbaas_state
m_handler._drv_lbaas = mock.Mock() m_handler._drv_lbaas = mock.Mock()
m_handler._drv_service_pub_ip = mock.Mock() m_handler._drv_service_pub_ip = mock.Mock()
m_handler._drv_lbaas.cascading_capable = True
h_lbaas.LoadBalancerHandler.on_deleted(m_handler, endpoints) h_lbaas.LoadBalancerHandler.on_deleted(m_handler, endpoints)

11
kuryr_kubernetes/tests/unit/controller/handlers/test_vif.py
View File

@ -89,21 +89,25 @@ class TestVIFHandler(test_base.TestCase):
@mock.patch.object(drivers.PodSecurityGroupsDriver, 'get_instance') @mock.patch.object(drivers.PodSecurityGroupsDriver, 'get_instance')
@mock.patch.object(drivers.PodSubnetsDriver, 'get_instance') @mock.patch.object(drivers.PodSubnetsDriver, 'get_instance')
@mock.patch.object(drivers.PodProjectDriver, 'get_instance') @mock.patch.object(drivers.PodProjectDriver, 'get_instance')
def test_init(self, m_get_project_driver, m_get_subnets_driver, @mock.patch.object(drivers.LBaaSDriver, 'get_instance')
m_get_sg_driver, m_get_vif_driver, m_get_vif_pool_driver, def test_init(self, m_get_lbaas_driver, m_get_project_driver,
m_set_vifs_driver, m_get_multi_vif_drivers): m_get_subnets_driver, m_get_sg_driver, m_get_vif_driver,
m_get_vif_pool_driver, m_set_vifs_driver,
m_get_multi_vif_drivers):
project_driver = mock.sentinel.project_driver project_driver = mock.sentinel.project_driver
subnets_driver = mock.sentinel.subnets_driver subnets_driver = mock.sentinel.subnets_driver
sg_driver = mock.sentinel.sg_driver sg_driver = mock.sentinel.sg_driver
vif_driver = mock.sentinel.vif_driver vif_driver = mock.sentinel.vif_driver
vif_pool_driver = mock.Mock(spec=drivers.VIFPoolDriver) vif_pool_driver = mock.Mock(spec=drivers.VIFPoolDriver)
multi_vif_drivers = [mock.MagicMock(spec=drivers.MultiVIFDriver)] multi_vif_drivers = [mock.MagicMock(spec=drivers.MultiVIFDriver)]
lbaas_driver = mock.sentinel.lbaas_driver
m_get_project_driver.return_value = project_driver m_get_project_driver.return_value = project_driver
m_get_subnets_driver.return_value = subnets_driver m_get_subnets_driver.return_value = subnets_driver
m_get_sg_driver.return_value = sg_driver m_get_sg_driver.return_value = sg_driver
m_get_vif_driver.return_value = vif_driver m_get_vif_driver.return_value = vif_driver
m_get_vif_pool_driver.return_value = vif_pool_driver m_get_vif_pool_driver.return_value = vif_pool_driver
m_get_multi_vif_drivers.return_value = multi_vif_drivers m_get_multi_vif_drivers.return_value = multi_vif_drivers
m_get_lbaas_driver.return_value = lbaas_driver
handler = h_vif.VIFHandler() handler = h_vif.VIFHandler()
@ -112,6 +116,7 @@ class TestVIFHandler(test_base.TestCase):
self.assertEqual(sg_driver, handler._drv_sg) self.assertEqual(sg_driver, handler._drv_sg)
self.assertEqual(vif_pool_driver, handler._drv_vif_pool) self.assertEqual(vif_pool_driver, handler._drv_vif_pool)
self.assertEqual(multi_vif_drivers, handler._drv_multi_vif) self.assertEqual(multi_vif_drivers, handler._drv_multi_vif)
self.assertEqual(lbaas_driver, handler._drv_lbaas)
def test_is_pending_node(self): def test_is_pending_node(self):
self.assertTrue(h_vif.VIFHandler._is_pending_node(self._pod)) self.assertTrue(h_vif.VIFHandler._is_pending_node(self._pod))

48
kuryr_kubernetes/tests/unit/test_clients.py
View File

@ -21,60 +21,28 @@ from kuryr_kubernetes.tests import base as test_base
class TestK8sClient(test_base.TestCase): class TestK8sClient(test_base.TestCase):
@mock.patch('openstack.connection.Connection')
@mock.patch('kuryr_kubernetes.config.CONF') @mock.patch('kuryr_kubernetes.config.CONF')
@mock.patch('kuryr_kubernetes.k8s_client.K8sClient') @mock.patch('kuryr_kubernetes.k8s_client.K8sClient')
@mock.patch('kuryr.lib.utils.get_neutron_client') @mock.patch('kuryr.lib.utils.get_neutron_client')
def test_setup_clients_lbaasv2(self, m_neutron, m_k8s, m_cfg): def test_setup_clients(self, m_neutron, m_k8s, m_cfg, m_openstack):
k8s_api_root = 'http://127.0.0.1:1234' k8s_api_root = 'http://127.0.0.1:1234'
neutron_mock = mock.Mock() neutron_mock = mock.Mock()
openstacksdk_mock = mock.Mock()
openstacksdk_mock.load_balancer = mock.Mock()
k8s_dummy = object() k8s_dummy = object()
neutron_mock.list_extensions.return_value = {
'extensions': [
{'alias': 'lbaasv2',
'description': 'Provides Load Balancing',
'links': [],
'name': 'Load Balancing v2',
'updated': '2017-11-28T09:00:00-00:00'}]}
m_cfg.kubernetes.api_root = k8s_api_root m_cfg.kubernetes.api_root = k8s_api_root
m_neutron.return_value = neutron_mock m_neutron.return_value = neutron_mock
m_k8s.return_value = k8s_dummy m_k8s.return_value = k8s_dummy
m_openstack.return_value = openstacksdk_mock
clients.setup_clients() clients.setup_clients()
m_k8s.assert_called_with(k8s_api_root) m_k8s.assert_called_with(k8s_api_root)
self.assertIs(k8s_dummy, clients.get_kubernetes_client()) self.assertIs(k8s_dummy, clients.get_kubernetes_client())
self.assertIs(neutron_mock, clients.get_neutron_client()) self.assertIs(neutron_mock, clients.get_neutron_client())
self.assertIs(neutron_mock, clients.get_loadbalancer_client()) self.assertIs(openstacksdk_mock, clients.get_openstacksdk())
self.assertIs(openstacksdk_mock.load_balancer,
@mock.patch('neutronclient.client.construct_http_client') clients.get_loadbalancer_client())
@mock.patch('kuryr.lib.utils.get_auth_plugin')
@mock.patch('kuryr_kubernetes.config.CONF')
@mock.patch('kuryr_kubernetes.k8s_client.K8sClient')
@mock.patch('kuryr.lib.utils.get_neutron_client')
def test_setup_clients_octavia(self, m_neutron, m_k8s, m_cfg,
m_auth_plugin, m_construct_http_client):
k8s_api_root = 'http://127.0.0.1:1234'
neutron_mock = mock.Mock()
k8s_dummy = object()
neutron_mock.list_extensions.return_value = {
'extensions': []}
octavia_httpclient = mock.sentinel.octavia_httpclient
m_construct_http_client.return_value = octavia_httpclient
m_auth_plugin.return_value = mock.sentinel.auth_plugin
m_cfg.kubernetes.api_root = k8s_api_root
m_neutron.return_value = neutron_mock
m_k8s.return_value = k8s_dummy
clients.setup_clients()
m_k8s.assert_called_with(k8s_api_root)
self.assertIs(k8s_dummy, clients.get_kubernetes_client())
self.assertIs(neutron_mock, clients.get_neutron_client())
self.assertIs(octavia_httpclient,
clients.get_loadbalancer_client().httpclient)

2
lower-constraints.txt
View File

@ -55,7 +55,7 @@ netaddr==0.7.19
netifaces==0.10.6 netifaces==0.10.6
neutron-lib==1.13.0 neutron-lib==1.13.0
openstackdocstheme==1.18.1 openstackdocstheme==1.18.1
openstacksdk==0.12.0 openstacksdk==0.13.0
os-client-config==1.29.0 os-client-config==1.29.0
os-service-types==1.2.0 os-service-types==1.2.0
os-testr==1.0.0 os-testr==1.0.0

1
requirements.txt
View File

@ -8,6 +8,7 @@ kuryr-lib>=0.5.0 # Apache-2.0
pbr!=2.1.0,>=2.0.0 # Apache-2.0 pbr!=2.1.0,>=2.0.0 # Apache-2.0
requests>=2.14.2 # Apache-2.0 requests>=2.14.2 # Apache-2.0
eventlet!=0.18.3,!=0.20.1,!=0.21.0,>=0.18.2 # MIT eventlet!=0.18.3,!=0.20.1,!=0.21.0,>=0.18.2 # MIT
openstacksdk>=0.13.0 # Apache-2.0
oslo.cache>=1.26.0 # Apache-2.0 oslo.cache>=1.26.0 # Apache-2.0
oslo.config>=5.2.0 # Apache-2.0 oslo.config>=5.2.0 # Apache-2.0
oslo.log>=3.36.0 # Apache-2.0 oslo.log>=3.36.0 # Apache-2.0