Refactor LB policy for driver calls
This patch moves the driver calls up to the policy base class from the LB policy. Change-Id: I66b50d25d47b43a1f636b8a17c86abbf252b19d6
This commit is contained in:
tengqm
parent
717b4be536
commit
5fbc05e9a4
|
|
@ -29,8 +29,8 @@ class LoadBalancerDriver(base.DriverBase):
|
|||
"""Load-balancing driver based on Neutron LBaaS V2 service."""
|
||||
|
||||
def __init__(self, params):
|
||||
self.lb_status_timeout = params.pop('lb_status_timeout')
|
||||
super(LoadBalancerDriver, self).__init__(params)
|
||||
self.lb_status_timeout = 600
|
||||
self._nc = None
|
||||
|
||||
def nc(self):
|
||||
|
|
|
|||
|
|
@ -113,6 +113,8 @@ class Policy(object):
|
|||
self.singleton = True
|
||||
self._novaclient = None
|
||||
self._keystoneclient = None
|
||||
self._networkclient = None
|
||||
self._lbaasclient = None
|
||||
|
||||
@classmethod
|
||||
def _from_object(cls, policy):
|
||||
|
|
@ -276,6 +278,35 @@ class Policy(object):
|
|||
self._novaclient = driver.SenlinDriver().compute(params)
|
||||
return self._novaclient
|
||||
|
||||
def network(self, user, project):
|
||||
"""Construct network client based on user and project.
|
||||
|
||||
:param user: The ID of the requesting user.
|
||||
:param project: The ID of the requesting project.
|
||||
:returns: A reference to the network client.
|
||||
"""
|
||||
if self._networkclient is not None:
|
||||
return self._networkclient
|
||||
|
||||
params = self._build_conn_params(user, project)
|
||||
self._networkclient = driver.SenlinDriver().network(params)
|
||||
return self._networkclient
|
||||
|
||||
def lbaas(self, user, project):
|
||||
"""Construct LB service client based on user and project.
|
||||
|
||||
:param user: The ID of the requesting user.
|
||||
:param project: The ID of the requesting project.
|
||||
:returns: A reference to the LB service client.
|
||||
"""
|
||||
if self._lbaasclient is not None:
|
||||
return self._lbaasclient
|
||||
|
||||
params = self._build_conn_params(user, project)
|
||||
|
||||
self._lbaasclient = driver.SenlinDriver().loadbalancing(params)
|
||||
return self._lbaasclient
|
||||
|
||||
def attach(self, cluster):
|
||||
'''Method to be invoked before policy is attached to a cluster.
|
||||
|
||||
|
|
|
|||
|
|
@ -24,11 +24,9 @@ from oslo_log import log as logging
|
|||
from senlin.common import constraints
|
||||
from senlin.common import consts
|
||||
from senlin.common import exception as exc
|
||||
from senlin.common.i18n import _
|
||||
from senlin.common.i18n import _LW
|
||||
from senlin.common.i18n import _, _LW
|
||||
from senlin.common import scaleutils
|
||||
from senlin.common import schema
|
||||
from senlin.drivers import base as driver_base
|
||||
from senlin.engine import cluster_policy
|
||||
from senlin.engine import node as nm
|
||||
from senlin.objects import cluster as co
|
||||
|
|
@ -282,8 +280,7 @@ class LoadBalancingPolicy(base.Policy):
|
|||
if not validate_props:
|
||||
return True
|
||||
|
||||
params = self._build_conn_params(context.user, context.project)
|
||||
nc = driver_base.SenlinDriver().network(params)
|
||||
nc = self.network(context.user, context.project)
|
||||
|
||||
# validate pool subnet
|
||||
name_or_id = self.pool_spec.get(self.POOL_SUBNET)
|
||||
|
|
@ -317,9 +314,8 @@ class LoadBalancingPolicy(base.Policy):
|
|||
nodes = nm.Node.load_all(oslo_context.get_current(),
|
||||
cluster_id=cluster.id)
|
||||
|
||||
params = self._build_conn_params(cluster.user, cluster.project)
|
||||
params['lb_status_timeout'] = self.lb_status_timeout
|
||||
lb_driver = driver_base.SenlinDriver().loadbalancing(params)
|
||||
lb_driver = self.lbaas(cluster.user, cluster.project)
|
||||
lb_driver.lb_status_timeout = self.lb_status_timeout
|
||||
|
||||
res, data = lb_driver.lb_create(self.vip_spec, self.pool_spec,
|
||||
self.hm_spec)
|
||||
|
|
@ -361,9 +357,8 @@ class LoadBalancingPolicy(base.Policy):
|
|||
contains a error message.
|
||||
"""
|
||||
reason = _('LB resources deletion succeeded.')
|
||||
params = self._build_conn_params(cluster.user, cluster.project)
|
||||
params['lb_status_timeout'] = self.lb_status_timeout
|
||||
lb_driver = driver_base.SenlinDriver().loadbalancing(params)
|
||||
lb_driver = self.lbaas(cluster.user, cluster.project)
|
||||
lb_driver.lb_status_timeout = self.lb_status_timeout
|
||||
|
||||
cp = cluster_policy.ClusterPolicy.load(oslo_context.get_current(),
|
||||
cluster.id, self.id)
|
||||
|
|
@ -454,9 +449,8 @@ class LoadBalancingPolicy(base.Policy):
|
|||
return
|
||||
|
||||
db_cluster = co.Cluster.get(action.context, cluster_id)
|
||||
params = self._build_conn_params(db_cluster.user, db_cluster.project)
|
||||
params['lb_status_timeout'] = self.lb_status_timeout
|
||||
lb_driver = driver_base.SenlinDriver().loadbalancing(params)
|
||||
lb_driver = self.lbaas(db_cluster.user, db_cluster.project)
|
||||
lb_driver.lb_status_timeout = self.lb_status_timeout
|
||||
cp = cluster_policy.ClusterPolicy.load(action.context, cluster_id,
|
||||
self.id)
|
||||
policy_data = self._extract_policy_data(cp.data)
|
||||
|
|
@ -492,7 +486,6 @@ class LoadBalancingPolicy(base.Policy):
|
|||
:param action: The action object that triggered this operation.
|
||||
:returns: Nothing.
|
||||
"""
|
||||
|
||||
# TODO(Yanyanhu): Need special handling for cross-az scenario
|
||||
# which is supported by Neutron lbaas.
|
||||
if action.action == consts.NODE_CREATE:
|
||||
|
|
@ -504,9 +497,8 @@ class LoadBalancingPolicy(base.Policy):
|
|||
return
|
||||
|
||||
db_cluster = co.Cluster.get(action.context, cluster_id)
|
||||
params = self._build_conn_params(db_cluster.user, db_cluster.project)
|
||||
params['lb_status_timeout'] = self.lb_status_timeout
|
||||
lb_driver = driver_base.SenlinDriver().loadbalancing(params)
|
||||
lb_driver = self.lbaas(db_cluster.user, db_cluster.project)
|
||||
lb_driver.lb_status_timeout = self.lb_status_timeout
|
||||
cp = cluster_policy.ClusterPolicy.load(action.context, cluster_id,
|
||||
self.id)
|
||||
policy_data = self._extract_policy_data(cp.data)
|
||||
|
|
|
|||
|
|
@ -29,8 +29,8 @@ class TestNeutronLBaaSDriver(base.SenlinTestCase):
|
|||
super(TestNeutronLBaaSDriver, self).setUp()
|
||||
self.context = utils.dummy_context()
|
||||
self.conn_params = self.context.to_dict()
|
||||
self.conn_params['lb_status_timeout'] = 10
|
||||
self.lb_driver = lbaas.LoadBalancerDriver(self.conn_params)
|
||||
self.lb_driver.lb_status_timeout = 10
|
||||
self.patchobject(neutron_v2, 'NeutronClient')
|
||||
self.nc = self.lb_driver.nc()
|
||||
|
||||
|
|
@ -105,20 +105,20 @@ class TestNeutronLBaaSDriver(base.SenlinTestCase):
|
|||
lb_id = 'LB_ID'
|
||||
self.nc.loadbalancer_get.return_value = None
|
||||
|
||||
res = self.lb_driver._wait_for_lb_ready(lb_id,
|
||||
ignore_not_found=True)
|
||||
res = self.lb_driver._wait_for_lb_ready(lb_id, ignore_not_found=True)
|
||||
|
||||
self.assertTrue(res)
|
||||
|
||||
@mock.patch.object(eventlet, 'sleep')
|
||||
def test_wait_for_lb_ready_timeout(self, mock_sleep):
|
||||
lb_id = 'LB_ID'
|
||||
lb_obj = mock.Mock()
|
||||
lb_obj.id = lb_id
|
||||
lb_obj = mock.Mock(id=lb_id)
|
||||
self.nc.loadbalancer_get.return_value = lb_obj
|
||||
|
||||
lb_obj.provisioning_status = 'PENDING_UPDATE'
|
||||
lb_obj.operating_status = 'OFFLINE'
|
||||
|
||||
res = self.lb_driver._wait_for_lb_ready(lb_id)
|
||||
|
||||
self.assertFalse(res)
|
||||
mock_sleep.assert_called_once_with(10)
|
||||
|
||||
|
|
|
|||
|
|
@ -73,8 +73,6 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
self.patchobject(driver_base, 'SenlinDriver', return_value=self.sd)
|
||||
self.lb_driver = mock.Mock()
|
||||
self.net_driver = mock.Mock()
|
||||
self.sd.loadbalancing.return_value = self.lb_driver
|
||||
self.sd.network.return_value = self.net_driver
|
||||
|
||||
@mock.patch.object(lb_policy.LoadBalancingPolicy, 'validate')
|
||||
def test_init(self, mock_validate):
|
||||
|
|
@ -132,7 +130,7 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
self.assertIsNone(policy.lb)
|
||||
|
||||
@mock.patch.object(policy_base.Policy, 'validate')
|
||||
def test_validate(self, mock_validate):
|
||||
def test_validate_shallow(self, mock_validate):
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
ctx = mock.Mock()
|
||||
|
||||
|
|
@ -141,32 +139,26 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
self.assertTrue(res)
|
||||
mock_validate.assert_called_with(ctx, False)
|
||||
|
||||
@mock.patch.object(policy_base.Policy, '_build_conn_params')
|
||||
@mock.patch.object(policy_base.Policy, 'validate')
|
||||
def test_validate_pool_subnet_notfound(self, mock_validate, mock_params):
|
||||
def test_validate_pool_subnet_notfound(self, mock_validate):
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._networkclient = self.net_driver
|
||||
ctx = mock.Mock(user='user1', project='project1')
|
||||
x_params = mock.Mock()
|
||||
mock_params.return_value = x_params
|
||||
self.net_driver.subnet_get = mock.Mock(
|
||||
side_effect=exc.InternalError(code='404', message='not found'))
|
||||
|
||||
ex = self.assertRaises(exc.InvalidSpec, policy.validate, ctx, True)
|
||||
|
||||
mock_validate.assert_called_with(ctx, True)
|
||||
mock_params.assert_called_once_with('user1', 'project1')
|
||||
self.sd.network.assert_called_once_with(x_params)
|
||||
self.net_driver.subnet_get.assert_called_once_with('internal-subnet')
|
||||
self.assertEqual("The specified subnet 'internal-subnet' could not "
|
||||
"be found.", six.text_type(ex))
|
||||
|
||||
@mock.patch.object(policy_base.Policy, '_build_conn_params')
|
||||
@mock.patch.object(policy_base.Policy, 'validate')
|
||||
def test_validate_vip_subnet_notfound(self, mock_validate, mock_params):
|
||||
def test_validate_vip_subnet_notfound(self, mock_validate):
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._networkclient = self.net_driver
|
||||
ctx = mock.Mock(user='user1', project='project1')
|
||||
x_params = mock.Mock()
|
||||
mock_params.return_value = x_params
|
||||
self.net_driver.subnet_get = mock.Mock(
|
||||
side_effect=[
|
||||
mock.Mock(), # for the internal (pool) one
|
||||
|
|
@ -177,8 +169,6 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
ex = self.assertRaises(exc.InvalidSpec, policy.validate, ctx, True)
|
||||
|
||||
mock_validate.assert_called_with(ctx, True)
|
||||
mock_params.assert_called_once_with('user1', 'project1')
|
||||
self.sd.network.assert_called_once_with(x_params)
|
||||
self.net_driver.subnet_get.assert_has_calls([
|
||||
mock.call('internal-subnet'), mock.call('external-subnet')
|
||||
])
|
||||
|
|
@ -188,11 +178,8 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
@mock.patch.object(lb_policy.LoadBalancingPolicy, '_build_policy_data')
|
||||
@mock.patch.object(node_mod.Node, 'load_all')
|
||||
@mock.patch.object(policy_base.Policy, 'attach')
|
||||
@mock.patch.object(lb_policy.LoadBalancingPolicy, '_build_conn_params')
|
||||
def test_attach_succeeded(self, m_conn, m_attach, m_load, m_build):
|
||||
cluster = mock.Mock()
|
||||
cluster.data = {}
|
||||
cluster.id = 'CLUSTER_ID'
|
||||
def test_attach_succeeded(self, m_attach, m_load, m_build):
|
||||
cluster = mock.Mock(id='CLUSTER_ID', data={})
|
||||
node1 = mock.Mock()
|
||||
node2 = mock.Mock()
|
||||
m_attach.return_value = (True, None)
|
||||
|
|
@ -203,13 +190,15 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
'vip_address': '192.168.1.100',
|
||||
'pool': 'POOL_ID'
|
||||
}
|
||||
self.lb_driver.lb_create.return_value = (True, data)
|
||||
self.lb_driver.member_add.side_effect = ['MEMBER1_ID', 'MEMBER2_ID']
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy.id = 'FAKE_ID'
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
self.lb_driver.lb_create.return_value = (True, data)
|
||||
self.lb_driver.member_add.side_effect = ['MEMBER1_ID', 'MEMBER2_ID']
|
||||
res, data = policy.attach(cluster)
|
||||
|
||||
self.assertTrue(res)
|
||||
self.assertEqual('policy_data', data)
|
||||
self.lb_driver.lb_create.assert_called_once_with(policy.vip_spec,
|
||||
|
|
@ -232,34 +221,32 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
|
||||
@mock.patch.object(policy_base.Policy, 'attach')
|
||||
def test_attach_failed_base_return_false(self, mock_attach):
|
||||
|
||||
cluster = mock.Mock()
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
# Base policy attaching return False
|
||||
mock_attach.return_value = (False, 'data')
|
||||
|
||||
res, data = policy.attach(cluster)
|
||||
|
||||
self.assertFalse(res)
|
||||
self.assertEqual('data', data)
|
||||
|
||||
@mock.patch.object(lb_policy.LoadBalancingPolicy, '_build_conn_params')
|
||||
@mock.patch.object(node_mod.Node, 'load_all')
|
||||
@mock.patch.object(policy_base.Policy, 'attach')
|
||||
def test_attach_failed_lb_creation_error(self, m_attach, m_load, m_conn):
|
||||
def test_attach_failed_lb_creation_error(self, m_attach, m_load):
|
||||
cluster = mock.Mock()
|
||||
m_attach.return_value = (True, None)
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
# lb_driver.lb_create return False
|
||||
self.lb_driver.lb_create.return_value = (False, 'error')
|
||||
res = policy.attach(cluster)
|
||||
self.assertEqual((False, 'error'), res)
|
||||
|
||||
@mock.patch.object(lb_policy.LoadBalancingPolicy, '_build_conn_params')
|
||||
@mock.patch.object(node_mod.Node, 'load_all')
|
||||
@mock.patch.object(policy_base.Policy, 'attach')
|
||||
def test_attach_failed_member_add(self, mock_attach, mock_load, m_conn):
|
||||
def test_attach_failed_member_add(self, mock_attach, mock_load):
|
||||
cluster = mock.Mock()
|
||||
mock_attach.return_value = (True, None)
|
||||
mock_load.return_value = ['node1', 'node2']
|
||||
|
|
@ -268,35 +255,33 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
'vip_address': '192.168.1.100',
|
||||
'pool': 'POOL_ID'
|
||||
}
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
policy._lbaasclient = self.lb_driver
|
||||
# lb_driver.member_add return None
|
||||
self.lb_driver.lb_create.return_value = (True, lb_data)
|
||||
self.lb_driver.member_add.return_value = None
|
||||
|
||||
res = policy.attach(cluster)
|
||||
|
||||
self.assertEqual((False, 'Failed in adding node into lb pool'), res)
|
||||
self.lb_driver.lb_delete.assert_called_once_with(**lb_data)
|
||||
|
||||
def test_get_delete_candidates_for_node_delete(self):
|
||||
action = mock.Mock()
|
||||
action.data = {}
|
||||
action.action = consts.NODE_DELETE
|
||||
action.node = mock.Mock(id='NODE_ID')
|
||||
action.inputs = {}
|
||||
|
||||
action = mock.Mock(action=consts.NODE_DELETE, inputs={}, data={},
|
||||
node=mock.Mock(id='NODE_ID'))
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
res = policy._get_delete_candidates('CLUSTERID', action)
|
||||
|
||||
self.assertEqual(['NODE_ID'], res)
|
||||
|
||||
def test_get_delete_candidates_no_deletion_data_del_nodes(self):
|
||||
action = mock.Mock()
|
||||
action.data = {}
|
||||
action.action = consts.CLUSTER_DEL_NODES
|
||||
action.inputs = {'candidates': ['node1', 'node2']}
|
||||
|
||||
action = mock.Mock(action=consts.CLUSTER_DEL_NODES, data={},
|
||||
inputs={'candidates': ['node1', 'node2']})
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
res = policy._get_delete_candidates('CLUSTERID', action)
|
||||
|
||||
self.assertEqual(['node1', 'node2'], res)
|
||||
|
||||
@mock.patch.object(no.Node, 'get_all_by_cluster')
|
||||
|
|
@ -304,19 +289,16 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
def test_get_delete_candidates_no_deletion_data_scale_in(self,
|
||||
m_nodes_random,
|
||||
m_node_get):
|
||||
|
||||
action = mock.Mock()
|
||||
self.context = utils.dummy_context()
|
||||
action.data = {}
|
||||
action.action = consts.CLUSTER_SCALE_IN
|
||||
action = mock.Mock(action=consts.CLUSTER_SCALE_IN, data={})
|
||||
m_node_get.return_value = ['node1', 'node2', 'node3']
|
||||
m_nodes_random.return_value = ['node1', 'node3']
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
res = policy._get_delete_candidates('CLUSTERID', action)
|
||||
|
||||
m_node_get.assert_called_once_with(action.context, 'CLUSTERID')
|
||||
m_nodes_random.assert_called_once_with(['node1', 'node2', 'node3'], 1)
|
||||
|
||||
self.assertEqual(['node1', 'node3'], res)
|
||||
|
||||
@mock.patch.object(no.Node, 'get_all_by_cluster')
|
||||
|
|
@ -331,23 +313,21 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
def _parse_param(action, cluster):
|
||||
action.data = {'deletion': {'count': 2}}
|
||||
|
||||
action = mock.Mock()
|
||||
self.context = utils.dummy_context()
|
||||
action.data = {}
|
||||
action.action = consts.CLUSTER_RESIZE
|
||||
action = mock.Mock(action=consts.CLUSTER_RESIZE, data={})
|
||||
m_parse_param.side_effect = _parse_param
|
||||
m_node_get.return_value = ['node1', 'node2', 'node3']
|
||||
m_cluster_get.return_value = 'cluster1'
|
||||
m_nodes_random.return_value = ['node1', 'node3']
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
res = policy._get_delete_candidates('CLUSTERID', action)
|
||||
m_cluster_get.assert_called_once_with(action.context,
|
||||
'CLUSTERID')
|
||||
|
||||
m_cluster_get.assert_called_once_with(action.context, 'CLUSTERID')
|
||||
m_parse_param.assert_called_once_with(action, 'cluster1')
|
||||
m_node_get.assert_called_once_with(action.context, 'CLUSTERID')
|
||||
m_nodes_random.assert_called_once_with(['node1', 'node2', 'node3'], 2)
|
||||
|
||||
self.assertEqual(['node1', 'node3'], res)
|
||||
|
||||
@mock.patch.object(no.Node, 'get_all_by_cluster')
|
||||
|
|
@ -355,14 +335,15 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
def test_get_delete_candidates_deletion_no_candidates(self,
|
||||
m_nodes_random,
|
||||
m_node_get):
|
||||
action = mock.Mock()
|
||||
self.context = utils.dummy_context()
|
||||
action.data = {'deletion': {'count': 1}}
|
||||
action = mock.Mock(data={'deletion': {'count': 1}})
|
||||
m_node_get.return_value = ['node1', 'node2', 'node3']
|
||||
m_nodes_random.return_value = ['node2']
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
res = policy._get_delete_candidates('CLUSTERID', action)
|
||||
|
||||
m_node_get.assert_called_once_with(action.context, 'CLUSTERID')
|
||||
m_nodes_random.assert_called_once_with(['node1', 'node2', 'node3'], 1)
|
||||
|
||||
|
|
@ -371,14 +352,12 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
action.data)
|
||||
|
||||
def test_get_delete_candidates_deletion_count_is_zero(self):
|
||||
action = mock.Mock()
|
||||
self.context = utils.dummy_context()
|
||||
# count is 0 by default
|
||||
action.data = {'deletion': {'number': 3}}
|
||||
|
||||
action = mock.Mock(data={'deletion': {'number': 3}})
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
res = policy._get_delete_candidates('CLUSTERID', action)
|
||||
|
||||
self.assertEqual([], res)
|
||||
|
||||
@mock.patch.object(no.Node, 'get_all_by_cluster')
|
||||
|
|
@ -386,27 +365,25 @@ class TestLoadBalancingPolicy(base.SenlinTestCase):
|
|||
def test_get_delete_candidates_deletion_count_over_size(self,
|
||||
m_nodes_random,
|
||||
m_node_get):
|
||||
action = mock.Mock()
|
||||
self.context = utils.dummy_context()
|
||||
action.data = {'deletion': {'count': 4}}
|
||||
action = mock.Mock(data={'deletion': {'count': 4}})
|
||||
m_node_get.return_value = ['node1', 'node2', 'node3']
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
policy._get_delete_candidates('CLUSTERID', action)
|
||||
|
||||
m_node_get.assert_called_once_with(action.context, 'CLUSTERID')
|
||||
m_nodes_random.assert_called_once_with(['node1', 'node2', 'node3'], 3)
|
||||
|
||||
def test_get_delete_candidates_deletion_with_candidates(self):
|
||||
action = mock.Mock()
|
||||
self.context = utils.dummy_context()
|
||||
action.data = {'deletion': {'count': 1, 'candidates': ['node3']}}
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
res = policy._get_delete_candidates('CLUSTERID', action)
|
||||
self.assertEqual(['node3'], res)
|
||||
|
||||
|
||||
@mock.patch.object(lb_policy.LoadBalancingPolicy, '_build_conn_params')
|
||||
@mock.patch.object(cluster_policy.ClusterPolicy, 'load')
|
||||
@mock.patch.object(lb_policy.LoadBalancingPolicy, '_extract_policy_data')
|
||||
class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
||||
|
|
@ -450,24 +427,21 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
}
|
||||
}
|
||||
}
|
||||
sd = mock.Mock()
|
||||
self.patchobject(driver_base, 'SenlinDriver', return_value=sd)
|
||||
self.lb_driver = mock.Mock()
|
||||
sd.loadbalancing.return_value = self.lb_driver
|
||||
self.patchobject(oslo_context, 'get_current')
|
||||
|
||||
def test_detach_no_policy_data(self, m_extract, m_load, m_conn):
|
||||
def test_detach_no_policy_data(self, m_extract, m_load):
|
||||
cluster = mock.Mock()
|
||||
m_extract.return_value = None
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
res, data = policy.detach(cluster)
|
||||
|
||||
self.assertTrue(res)
|
||||
self.assertEqual('LB resources deletion succeeded.', data)
|
||||
|
||||
def test_detach_succeeded(self, m_extract, m_load, m_conn):
|
||||
cluster = mock.Mock()
|
||||
cluster.id = 'CLUSTER_ID'
|
||||
def test_detach_succeeded(self, m_extract, m_load):
|
||||
cp = mock.Mock()
|
||||
policy_data = {
|
||||
'loadbalancer': 'LB_ID',
|
||||
|
|
@ -486,13 +460,18 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
m_extract.return_value = policy_data
|
||||
self.lb_driver.lb_delete.return_value = (True, 'lb_delete succeeded.')
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
cluster.data = {
|
||||
'loadbalancers': {
|
||||
policy.id: {'vip_address': '192.168.1.100'}
|
||||
}
|
||||
}
|
||||
policy._lbaasclient = self.lb_driver
|
||||
cluster = mock.Mock(
|
||||
id='CLUSTER_ID',
|
||||
data={
|
||||
'loadbalancers': {
|
||||
policy.id: {'vip_address': '192.168.1.100'}
|
||||
|
||||
}
|
||||
})
|
||||
|
||||
res, data = policy.detach(cluster)
|
||||
|
||||
self.assertTrue(res)
|
||||
self.assertEqual('lb_delete succeeded.', data)
|
||||
m_load.assert_called_once_with(mock.ANY, cluster.id, policy.id)
|
||||
|
|
@ -500,36 +479,38 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
self.lb_driver.lb_delete.assert_called_once_with(**policy_data)
|
||||
self.assertEqual({}, cluster.data)
|
||||
|
||||
def test_detach_failed_lb_delete(self, m_extract, m_load, m_conn):
|
||||
def test_detach_failed_lb_delete(self, m_extract, m_load):
|
||||
cluster = mock.Mock()
|
||||
self.lb_driver.lb_delete.return_value = (False, 'lb_delete failed.')
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
res, data = policy.detach(cluster)
|
||||
|
||||
self.assertFalse(res)
|
||||
self.assertEqual('lb_delete failed.', data)
|
||||
|
||||
def test_post_op_no_nodes(self, m_extract, m_load, m_conn):
|
||||
action = mock.Mock()
|
||||
action.data = {}
|
||||
def test_post_op_no_nodes(self, m_extract, m_load):
|
||||
action = mock.Mock(data={})
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
|
||||
res = policy.post_op('FAKE_ID', action)
|
||||
|
||||
self.assertIsNone(res)
|
||||
|
||||
@mock.patch.object(node_mod.Node, 'load')
|
||||
@mock.patch.object(co.Cluster, 'get')
|
||||
def test_post_op_node_create(self, m_cluster_get, m_node_load, m_extract,
|
||||
m_load, m_conn):
|
||||
m_load):
|
||||
ctx = mock.Mock()
|
||||
cid = 'CLUSTER_ID'
|
||||
cluster = mock.Mock(user='user1', project='project1')
|
||||
m_cluster_get.return_value = cluster
|
||||
node_obj = mock.Mock(data={})
|
||||
action = mock.Mock(data={}, context=ctx, action=consts.NODE_CREATE)
|
||||
action.node = mock.Mock(id='NODE_ID')
|
||||
action = mock.Mock(data={}, context=ctx, action=consts.NODE_CREATE,
|
||||
node=mock.Mock(id='NODE_ID'))
|
||||
cp = mock.Mock()
|
||||
policy_data = {
|
||||
'loadbalancer': 'LB_ID',
|
||||
|
|
@ -544,12 +525,13 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
}
|
||||
}
|
||||
cp.data = cp_data
|
||||
self.lb_driver.member_add.side_effect = ['MEMBER_ID']
|
||||
m_node_load.side_effect = [node_obj]
|
||||
m_load.return_value = cp
|
||||
m_extract.return_value = policy_data
|
||||
|
||||
self.lb_driver.member_add.side_effect = ['MEMBER_ID']
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
# do it
|
||||
res = policy.post_op(cid, action)
|
||||
|
|
@ -557,7 +539,6 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
# assertion
|
||||
self.assertIsNone(res)
|
||||
m_cluster_get.assert_called_once_with(ctx, 'CLUSTER_ID')
|
||||
m_conn.assert_called_once_with('user1', 'project1')
|
||||
m_load.assert_called_once_with(ctx, cid, policy.id)
|
||||
m_extract.assert_called_once_with(cp_data)
|
||||
m_node_load.assert_called_once_with(ctx, node_id='NODE_ID')
|
||||
|
|
@ -569,7 +550,7 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
@mock.patch.object(node_mod.Node, 'load')
|
||||
@mock.patch.object(co.Cluster, 'get')
|
||||
def test_post_op_add_nodes(self, m_cluster_get, m_node_load, m_extract,
|
||||
m_load, m_conn):
|
||||
m_load):
|
||||
cid = 'CLUSTER_ID'
|
||||
cluster = mock.Mock(user='user1', project='project1')
|
||||
m_cluster_get.return_value = cluster
|
||||
|
|
@ -601,6 +582,7 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
m_load.return_value = cp
|
||||
m_extract.return_value = policy_data
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
# do it
|
||||
res = policy.post_op(cid, action)
|
||||
|
|
@ -608,7 +590,6 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
# assertions
|
||||
self.assertIsNone(res)
|
||||
m_cluster_get.assert_called_once_with('action_context', 'CLUSTER_ID')
|
||||
m_conn.assert_called_once_with('user1', 'project1')
|
||||
m_load.assert_called_once_with('action_context', cid, policy.id)
|
||||
m_extract.assert_called_once_with(cp_data)
|
||||
calls_node_load = [
|
||||
|
|
@ -629,16 +610,15 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
@mock.patch.object(node_mod.Node, 'load')
|
||||
@mock.patch.object(co.Cluster, 'get')
|
||||
def test_post_op_add_nodes_in_pool(self, m_cluster_get, m_node_load,
|
||||
m_extract, m_load, m_conn):
|
||||
m_extract, m_load):
|
||||
cluster_id = 'CLUSTER_ID'
|
||||
node1 = mock.Mock()
|
||||
node2 = mock.Mock()
|
||||
node1.data = {'lb_member': 'MEMBER1_ID'}
|
||||
node2.data = {}
|
||||
action = mock.Mock()
|
||||
action.data = {'creation': {'nodes': ['NODE1_ID', 'NODE2_ID']}}
|
||||
action.context = 'action_context'
|
||||
action.action = consts.CLUSTER_RESIZE
|
||||
node1 = mock.Mock(data={'lb_member': 'MEMBER1_ID'})
|
||||
node2 = mock.Mock(data={})
|
||||
action = mock.Mock(
|
||||
action=consts.CLUSTER_RESIZE,
|
||||
context='action_context',
|
||||
data={'creation': {'nodes': ['NODE1_ID', 'NODE2_ID']}}
|
||||
)
|
||||
policy_data = {
|
||||
'loadbalancer': 'LB_ID',
|
||||
'listener': 'LISTENER_ID',
|
||||
|
|
@ -648,9 +628,11 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
self.lb_driver.member_add.side_effect = ['MEMBER2_ID']
|
||||
m_node_load.side_effect = [node1, node2]
|
||||
m_extract.return_value = policy_data
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
res = policy.post_op(cluster_id, action)
|
||||
|
||||
self.assertIsNone(res)
|
||||
self.lb_driver.member_add.assert_called_once_with(
|
||||
node2, 'LB_ID', 'POOL_ID', 80, 'test-subnet')
|
||||
|
|
@ -658,7 +640,7 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
@mock.patch.object(node_mod.Node, 'load')
|
||||
@mock.patch.object(co.Cluster, 'get')
|
||||
def test_post_op_add_nodes_failed(self, m_cluster_get, m_node_load,
|
||||
m_extract, m_load, m_conn):
|
||||
m_extract, m_load):
|
||||
cluster_id = 'CLUSTER_ID'
|
||||
node1 = mock.Mock(data={})
|
||||
action = mock.Mock(data={'creation': {'nodes': ['NODE1_ID']}},
|
||||
|
|
@ -673,6 +655,7 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
'healthmonitor': 'HM_ID'
|
||||
}
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
res = policy.post_op(cluster_id, action)
|
||||
|
||||
|
|
@ -686,7 +669,7 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
@mock.patch.object(node_mod.Node, 'load')
|
||||
@mock.patch.object(co.Cluster, 'get')
|
||||
def test_pre_op_del_nodes_ok(self, m_cluster_get, m_node_load, m_extract,
|
||||
m_load, m_conn):
|
||||
m_load):
|
||||
cluster_id = 'CLUSTER_ID'
|
||||
cluster = mock.Mock(user='user1', project='project1')
|
||||
m_cluster_get.return_value = cluster
|
||||
|
|
@ -717,14 +700,13 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
m_node_load.side_effect = [node1, node2]
|
||||
m_load.return_value = cp
|
||||
m_extract.return_value = policy_data
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
res = policy.pre_op(cluster_id, action)
|
||||
|
||||
self.assertIsNone(res)
|
||||
m_cluster_get.assert_called_once_with('action_context', 'CLUSTER_ID')
|
||||
m_conn.assert_called_once_with('user1', 'project1')
|
||||
m_load.assert_called_once_with('action_context', cluster_id, policy.id)
|
||||
m_extract.assert_called_once_with(cp_data)
|
||||
calls_node_load = [
|
||||
|
|
@ -745,16 +727,14 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
@mock.patch.object(node_mod.Node, 'load')
|
||||
@mock.patch.object(co.Cluster, 'get')
|
||||
def test_pre_op_del_nodes_not_in_pool(self, m_cluster_get, m_node_load,
|
||||
m_extract, m_load, m_conn):
|
||||
m_extract, m_load):
|
||||
cluster_id = 'CLUSTER_ID'
|
||||
node1 = mock.Mock()
|
||||
node2 = mock.Mock()
|
||||
node1.data = {}
|
||||
node2.data = {'lb_member': 'MEMBER2_ID'}
|
||||
action = mock.Mock()
|
||||
action.data = {'deletion': {'candidates': ['NODE1_ID', 'NODE2_ID']}}
|
||||
action.context = 'action_context'
|
||||
action.action = consts.CLUSTER_RESIZE
|
||||
node1 = mock.Mock(data={})
|
||||
node2 = mock.Mock(data={'lb_member': 'MEMBER2_ID'})
|
||||
action = mock.Mock(
|
||||
action=consts.CLUSTER_RESIZE,
|
||||
context='action_context',
|
||||
data={'deletion': {'candidates': ['NODE1_ID', 'NODE2_ID']}})
|
||||
self.lb_driver.member_remove.return_value = True
|
||||
m_node_load.side_effect = [node1, node2]
|
||||
m_extract.return_value = {
|
||||
|
|
@ -763,9 +743,11 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
'pool': 'POOL_ID',
|
||||
'healthmonitor': 'HM_ID'
|
||||
}
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
res = policy.pre_op(cluster_id, action)
|
||||
|
||||
self.assertIsNone(res)
|
||||
self.lb_driver.member_remove.assert_called_once_with(
|
||||
'LB_ID', 'POOL_ID', 'MEMBER2_ID')
|
||||
|
|
@ -773,15 +755,14 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
@mock.patch.object(node_mod.Node, 'load')
|
||||
@mock.patch.object(co.Cluster, 'get')
|
||||
def test_pre_op_del_nodes_failed(self, m_cluster_get, m_node_load,
|
||||
m_extract, m_load, m_conn):
|
||||
m_extract, m_load):
|
||||
cluster_id = 'CLUSTER_ID'
|
||||
node1 = mock.Mock()
|
||||
node1.data = {'lb_member': 'MEMBER1_ID'}
|
||||
action = mock.Mock()
|
||||
action.data = {}
|
||||
action.data = {'deletion': {'candidates': ['NODE1_ID']}}
|
||||
action.context = 'action_context'
|
||||
action.action = consts.CLUSTER_RESIZE
|
||||
action = mock.Mock(
|
||||
action=consts.CLUSTER_RESIZE,
|
||||
context='action_context',
|
||||
data={'deletion': {'candidates': ['NODE1_ID']}})
|
||||
self.lb_driver.member_remove.return_value = False
|
||||
m_node_load.side_effect = [node1]
|
||||
m_extract.return_value = {
|
||||
|
|
@ -790,8 +771,8 @@ class TestLoadBalancingPolicyOperations(base.SenlinTestCase):
|
|||
'pool': 'POOL_ID',
|
||||
'healthmonitor': 'HM_ID'
|
||||
}
|
||||
|
||||
policy = lb_policy.LoadBalancingPolicy('test-policy', self.spec)
|
||||
policy._lbaasclient = self.lb_driver
|
||||
|
||||
res = policy.pre_op(cluster_id, action)
|
||||
|
||||
|
|
|
|||
|
|
@ -351,32 +351,6 @@ class TestPolicyBase(base.SenlinTestCase):
|
|||
res = policy._extract_policy_data(policy_data)
|
||||
self.assertIsNone(res)
|
||||
|
||||
@mock.patch.object(pb.Policy, '_build_conn_params')
|
||||
@mock.patch("senlin.drivers.base.SenlinDriver")
|
||||
def test_nova(self, mock_driver, mock_params):
|
||||
policy = self._create_policy('test-policy')
|
||||
fake_params = mock.Mock()
|
||||
mock_params.return_value = fake_params
|
||||
x_driver = mock.Mock()
|
||||
mock_driver.return_value = x_driver
|
||||
|
||||
result = policy.nova('user1', 'project1')
|
||||
|
||||
x_nova = x_driver.compute.return_value
|
||||
self.assertEqual(x_nova, result)
|
||||
self.assertEqual(x_nova, policy._novaclient)
|
||||
mock_params.assert_called_once_with('user1', 'project1')
|
||||
x_driver.compute.assert_called_once_with(fake_params)
|
||||
|
||||
def test_nova_already_initialized(self):
|
||||
policy = self._create_policy('test-policy')
|
||||
x_nova = mock.Mock()
|
||||
policy._novaclient = x_nova
|
||||
|
||||
result = policy.nova('foo', 'bar')
|
||||
|
||||
self.assertEqual(x_nova, result)
|
||||
|
||||
@mock.patch.object(pb.Policy, '_build_conn_params')
|
||||
@mock.patch('senlin.drivers.base.SenlinDriver')
|
||||
def test_keystone(self, mock_sd, mock_params):
|
||||
|
|
@ -405,6 +379,84 @@ class TestPolicyBase(base.SenlinTestCase):
|
|||
|
||||
self.assertEqual(x_keystone, result)
|
||||
|
||||
@mock.patch.object(pb.Policy, '_build_conn_params')
|
||||
@mock.patch("senlin.drivers.base.SenlinDriver")
|
||||
def test_nova(self, mock_driver, mock_params):
|
||||
policy = self._create_policy('test-policy')
|
||||
fake_params = mock.Mock()
|
||||
mock_params.return_value = fake_params
|
||||
x_driver = mock.Mock()
|
||||
mock_driver.return_value = x_driver
|
||||
|
||||
result = policy.nova('user1', 'project1')
|
||||
|
||||
x_nova = x_driver.compute.return_value
|
||||
self.assertEqual(x_nova, result)
|
||||
self.assertEqual(x_nova, policy._novaclient)
|
||||
mock_params.assert_called_once_with('user1', 'project1')
|
||||
x_driver.compute.assert_called_once_with(fake_params)
|
||||
|
||||
def test_nova_already_initialized(self):
|
||||
policy = self._create_policy('test-policy')
|
||||
x_nova = mock.Mock()
|
||||
policy._novaclient = x_nova
|
||||
|
||||
result = policy.nova('foo', 'bar')
|
||||
|
||||
self.assertEqual(x_nova, result)
|
||||
|
||||
@mock.patch.object(pb.Policy, '_build_conn_params')
|
||||
@mock.patch("senlin.drivers.base.SenlinDriver")
|
||||
def test_network(self, mock_driver, mock_params):
|
||||
policy = self._create_policy('test-policy')
|
||||
fake_params = mock.Mock()
|
||||
mock_params.return_value = fake_params
|
||||
x_driver = mock.Mock()
|
||||
mock_driver.return_value = x_driver
|
||||
|
||||
result = policy.network('user1', 'project1')
|
||||
|
||||
x_network = x_driver.network.return_value
|
||||
self.assertEqual(x_network, result)
|
||||
self.assertEqual(x_network, policy._networkclient)
|
||||
mock_params.assert_called_once_with('user1', 'project1')
|
||||
x_driver.network.assert_called_once_with(fake_params)
|
||||
|
||||
def test_network_already_initialized(self):
|
||||
policy = self._create_policy('test-policy')
|
||||
x_network = mock.Mock()
|
||||
policy._networkclient = x_network
|
||||
|
||||
result = policy.network('foo', 'bar')
|
||||
|
||||
self.assertEqual(x_network, result)
|
||||
|
||||
@mock.patch.object(pb.Policy, '_build_conn_params')
|
||||
@mock.patch("senlin.drivers.base.SenlinDriver")
|
||||
def test_lbaas(self, mock_driver, mock_params):
|
||||
policy = self._create_policy('test-policy')
|
||||
fake_params = mock.Mock()
|
||||
mock_params.return_value = fake_params
|
||||
x_driver = mock.Mock()
|
||||
mock_driver.return_value = x_driver
|
||||
|
||||
result = policy.lbaas('user1', 'project1')
|
||||
|
||||
x_lbaas = x_driver.loadbalancing.return_value
|
||||
self.assertEqual(x_lbaas, result)
|
||||
self.assertEqual(x_lbaas, policy._lbaasclient)
|
||||
mock_params.assert_called_once_with('user1', 'project1')
|
||||
x_driver.loadbalancing.assert_called_once_with(fake_params)
|
||||
|
||||
def test_lbaas_already_initialized(self):
|
||||
policy = self._create_policy('test-policy')
|
||||
x_lbaas = mock.Mock()
|
||||
policy._lbaasclient = x_lbaas
|
||||
|
||||
result = policy.lbaas('foo', 'bar')
|
||||
|
||||
self.assertEqual(x_lbaas, result)
|
||||
|
||||
def test_default_need_check(self):
|
||||
action = mock.Mock()
|
||||
action.action = consts.CLUSTER_SCALE_IN
|
||||
|
|
|
|||
Loading…
Reference in New Issue