def test_update(self):
old_pool = test_base.FakePool('TCP', 'LEAST_CONNECTIONS', None, True)
pool = test_base.FakePool('TCP', 'ROUND_ROBIN', None, True)
self.a.pool.update(None, old_pool, pool)
self.print_mocks()
self.a.last_client.slb.service_group.create(
pool.id,
lb_method=self.a.last_client.slb.service_group.ROUND_ROBIN,
protocol=self.a.last_client.slb.service_group.TCP)
def test_update(self):
pers1 = None
pers2 = None
old_pool = test_base.FakePool('TCP', 'LEAST_CONNECTIONS', pers1, True)
pool = test_base.FakePool('TCP', 'ROUND_ROBIN', pers2, True)
self.a.pool.update(None, pool, old_pool)
self.print_mocks()
self.a.last_client.slb.service_group.update.assert_called_with(
pool.id,
axapi_args={"service_group": {}},
lb_method=mock.ANY,
protocol=mock.ANY)
def test_delete(self):
members = [[], [test_base.FakeMember()]]
hms = [None, test_base.FakeHM('PING')]
persistences = [None, 'SOURCE_IP', 'HTTP_COOKIE']
listeners = [False, True]
for m in members:
for hm in hms:
for pers in persistences:
for lst in listeners:
self.a.reset_mocks()
pool = test_base.FakePool('TCP', 'ROUND_ROBIN',
pers, lst,
members=m,
hm=hm)
self.a.pool.delete(None, pool)
self.print_mocks()
(self.a.last_client.slb.service_group.delete.
assert_called_with(pool.id))
if pers == 'SOURCE_IP':
(self.a.last_client.slb.template.
src_ip_persistence.delete.
assert_called_with(pool.id))
elif pers == 'HTTP_COOKIE':
(self.a.last_client.slb.template.
cookie_persistence.delete.
assert_called_with(pool.id))
def _test_create_ipinip(self, api_ver="3.0", ip_in_ip=False):
ipinip_expected = None
expected_tuple = axapi_mappings.ipinip_dictionary.get(api_ver)
saw_exception = False
for k, v in self.a.config.get_devices().items():
v['ipinip'] = ip_in_ip
v['api_version'] = api_ver
if expected_tuple is not None:
key, transform = expected_tuple
else:
key = None
transform = None
if ip_in_ip and key and transform:
ipinip_format = "'{0}': {1}"
ipinip_expected = ipinip_format.format(key, transform(ip_in_ip))
p = 'TCP'
lb = test_base.FakeLoadBalancer()
pool = test_base.FakePool(p, 'ROUND_ROBIN', None)
m = test_base.FakeListener(p, 2222, pool=pool, loadbalancer=lb)
self.a.listener.create(None, m)
self.print_mocks()
if not saw_exception:
s = str(self.a.last_client.mock_calls)
self.assertIn("vport.create", s)
if ipinip_expected is not None:
self.assertIn(ipinip_expected, s)
def test_create(self):
methods = {
'ROUND_ROBIN':
self.a.last_client.slb.service_group.ROUND_ROBIN,
'LEAST_CONNECTIONS':
self.a.last_client.slb.service_group.LEAST_CONNECTION,
'SOURCE_IP':
self.a.last_client.slb.service_group.WEIGHTED_LEAST_CONNECTION,
}
protocols = {
'TCP': self.a.last_client.slb.service_group.TCP,
'UDP': self.a.last_client.slb.service_group.UDP,
}
persistences = [None, 'SOURCE_IP', 'HTTP_COOKIE', 'APP_COOKIE']
listeners = [False, True]
for p in protocols.keys():
for m in methods.keys():
for pers in persistences:
for listener in listeners:
self.a.reset_mocks()
saw_exception = False
pool = test_base.FakePool(p, m, pers, listener)
try:
self.a.pool.create(None, pool)
except a10_ex.UnsupportedFeature as e:
if pers == 'APP_COOKIE':
saw_exception = True
else:
raise e
self.print_mocks()
# (self.a.last_client.slb.service_group.create.
# assert_called_with(
# pool.id,
# axapi_args={"service_group": {}},
# lb_method=methods(m),
# protocol=protocols(p)))
if not saw_exception:
n = str(self.a.last_client.mock_calls).index(
'slb.service_group.create')
self.assertTrue(n >= 0)
if pers == 'SOURCE_IP':
(self.a.last_client.slb.template.
src_ip_persistence.create.
assert_called_with(pool.id))
elif pers == 'HTTP_COOKIE':
(self.a.last_client.slb.template.
cookie_persistence.create.
assert_called_with(pool.id))
elif pers == 'APP_COOKIE':
(self.a.last_client.slb.template.
cookie_persistence.create.
assert_called_with(pool.id))
def test_create(self):
admin_states = [True, False]
persistences = [None, 'SOURCE_IP', 'HTTP_COOKIE', 'APP_COOKIE']
protocols = ['TCP', 'UDP', 'HTTP', 'HTTPS']
lb = test_base.FakeLoadBalancer()
for a in admin_states:
for pers in persistences:
for p in protocols:
self.a.reset_mocks()
pool = test_base.FakePool(p, 'ROUND_ROBIN', pers)
m = test_base.FakeListener(p,
2222,
pool=pool,
loadbalancer=lb)
pool.listener = m
saw_exception = False
try:
self.a.listener.create(None, m)
except a10_ex.UnsupportedFeature as e:
if pers == 'APP_COOKIE':
saw_exception = True
else:
raise e
self.print_mocks()
if not saw_exception:
s = str(self.a.last_client.mock_calls)
self.assertTrue('vport.create' in s)
self.assertTrue('fake-lb-id-001' in s)
self.assertTrue('fake-listen-id-001' in s)
self.assertTrue('port=2222' in s)
test_prot = p
if p in ('HTTPS', constants.PROTOCOL_TERMINATED_HTTPS):
test_prot = 'TCP'
self.assertTrue(test_prot in s)
if pers == 'SOURCE_IP':
self.assertTrue('s_pers_name=None' not in s)
pass
elif pers == 'HTTP_COOKIE':
self.assertTrue('s_pers=HTTP_COOKIE')
self.assertTrue('c_pers_name=None' not in s)
pass
elif pers == 'APP_COOKIE':
self.assertTrue('s_pers=APP_COOKIE')
self.assertTrue('c_pers_name=None' not in s)
pass
else:
self.assertTrue('c_pers_name=None' in s)
self.assertTrue('s_pers_name=None' in s)
def test_dissociate_calls_service_group_update(self):
fake_pool = test_base.FakePool()
fake_hm = test_base.FakeHM()
fake_hm["id"] = "id1"
fake_hm["pools"] = []
fake_hm["pools"].append(fake_pool)
fake_hm['tenant_id'] = "tenv1"
self.a.hm.dissociate(self.a.last_client, None, fake_hm, fake_pool.id)
self.a.last_client.slb.service_group.update.assert_called(
fake_pool.id, health_monitor="", health_check_disable=True)
def test_dissociate_calls_hm_delete(self):
fake_pool = test_base.FakePool()
fake_hm = test_base.FakeHM()
fake_pool["health_monitor_status"] = [{"monitor_id": fake_hm.id}]
fake_hm["id"] = "id1"
fake_hm["pools"] = []
fake_hm["pools"].append(fake_pool)
fake_hm['tenant_id'] = "tenv1"
self.a.hm.dissociate(self.a.last_client, None, fake_hm, fake_pool.id)
self.a.last_client.hm.service_group.delete.assert_called(
self.a.hm._meta_name(fake_hm))
def test_delete(self):
expected = test_base.FakePool()
fakehm = test_base.FakeHM()
fakehm['tenant_id'] = 'tenv1'
fakehm['id'] = 'fedcba'
fakehm.pools.append(expected)
self.a.hm.openstack_driver.plugin.get_pool.return_value = expected
self.a.hm.openstack_driver._hm_binding_count.return_value = 1
self.a.hm.delete(None, fakehm, 'p01')
self.a.last_client.slb.hm.delete.assert_called_with(fakehm["id"])
def test_barbican_client_not_null(self, certmgr):
"""This tests that the barbican_client dependency is always there."""
handler = self.a.listener
handler.barbican_client = None
pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS,
constants.LB_METHOD_ROUND_ROBIN, None)
lb = test_base.FakeLoadBalancer()
m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS,
2222,
pool=pool,
loadbalancer=lb)
pool.listener = m
handler.create(None, m)
self.assertTrue(handler.barbican_client is not None)
def _test_create_ipinip(self, ip_in_ip=False):
for k, v in self.a.config.devices.items():
v['ipinip'] = ip_in_ip
p = 'TCP'
lb = test_base.FakeLoadBalancer()
pool = test_base.FakePool(p, 'ROUND_ROBIN', None)
m = test_base.FakeListener(p, 2222, pool=pool,
loadbalancer=lb)
self.a.listener.create(None, m)
self.print_mocks()
s = str(self.a.last_client.mock_calls)
self.assertEqual(ip_in_ip, "ipinip" in s)
def test_delete(self):
pool = test_base.FakePool('HTTP', 'ROUND_ROBIN', None)
lb = test_base.FakeLoadBalancer()
m = test_base.FakeListener('HTTP', 2222, pool=pool, loadbalancer=lb)
pool.listener = m
self.a.listener.delete(None, m)
s = str(self.a.last_client.mock_calls)
self.assertTrue('vport.delete' in s)
self.assertTrue('fake-lb-id-001' in s)
self.assertTrue('fake-listen-id-001' in s)
self.assertTrue('port=2222' in s)
self.assertTrue('HTTP' in s)
def _tls_container_shared(self):
certmgr = FakeCertManager()
certmgr.certificate = "CERTDATA"
certmgr.private_key = "PRIVATEKEY"
certmgr.private_key_passphrase = "SECRETPASSWORD"
handler = self.a.listener
handler.barbican_client = certmgr
pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS,
constants.LB_METHOD_ROUND_ROBIN, None)
lb = test_base.FakeLoadBalancer()
m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS,
2222,
pool=pool,
loadbalancer=lb)
return (certmgr, m, pool, handler)
def test_create_with_listeners(self):
pool = test_base.FakePool('HTTP', 'ROUND_ROBIN', None)
m = test_base.FakeLoadBalancer()
for x in [1, 2, 3]:
z = test_base.FakeListener('TCP', 2222+x, pool=pool,
loadbalancer=m)
m.listeners.append(z)
self.a.lb.create(None, m)
s = str(self.a.last_client.mock_calls)
self.assertTrue('call.slb.virtual_server.create' in s)
self.assertTrue('fake-lb-id-001' in s)
self.assertTrue('5.5.5.5' in s)
self.assertTrue('UP' in s)
self.assertTrue('vport.create' in s)
for x in [1, 2, 3]:
self.assertTrue(str(2222+x) in s)
def _test_create_autosnat(self, api_ver=None, autosnat=None):
saw_exception = False
"""
Due to how the config is pulled in, we can't override the config
version here and just expect it to work.
"""
for k, v in self.a.config.devices.items():
v['api_version'] = api_ver
v['autosnat'] = autosnat
# self.a.device_info["api_version"] = api_ver
# self.a.device_info["autosnat"] = autosnat
p = 'TCP'
lb = test_base.FakeLoadBalancer()
pool = test_base.FakePool(p, 'ROUND_ROBIN', None)
m = test_base.FakeListener(p, 2222, pool=pool,
loadbalancer=lb)
auto_expected = None
expected_tuple = a10_common.auto_dictionary.get(api_ver, None)
if expected_tuple is not None:
key = expected_tuple[0]
transform = expected_tuple[1]
else:
key = None
transform = None
if autosnat and key is not None and transform is not None:
auto_format = "'{0}': {1}"
auto_expected = auto_format.format(key, transform(autosnat))
try:
self.a.listener.create(None, m)
except Exception as e:
saw_exception = True
raise e
if not saw_exception:
s = str(self.a.last_client.mock_calls)
self.assertTrue('vport.create' in s)
if auto_expected is not None:
self.assertTrue(auto_expected in s)
def test_create_protocol_terminated_https(self):
pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS,
constants.LB_METHOD_ROUND_ROBIN, None)
lb = test_base.FakeLoadBalancer()
m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS,
2222,
pool=pool,
loadbalancer=lb)
m.default_tls_container_id = "CONTAINERID"
pool.listener = m
certmgr = FakeCertManager()
self.a.barbican_client = certmgr
self.a.listener.create(None, m)
s = str(self.a.last_client.mock_calls)
self.assertTrue('HTTPS' in s)
def test_delete_updates_pool_health_monitor(self):
expected = test_base.FakePool()
fakehm = test_base.FakeHM()
fakehm['tenant_id'] = 'tenv1'
fakehm['id'] = 'fedcba'
fakehm['pools'] = []
fakehm['pools'].append(expected)
self.a.hm.openstack_driver._pool_get_hm.return_value = fakehm
self.a.hm.openstack_driver.plugin.get_pool.return_value = expected
self.a.hm.openstack_driver._hm_binding_count.return_value = 1
pool_name = self.a.hm._pool_name(None, 'p01')
self.a.hm.delete(None, fakehm, 'p01')
self.a.last_client.slb.service_group.update.assert_called_with(
pool_name, health_monitor='', health_check_disable=True)
def test_delete(self):
pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS,
constants.LB_METHOD_ROUND_ROBIN, None)
lb = test_base.FakeLoadBalancer()
m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS,
2222,
pool=pool,
loadbalancer=lb)
pool.listener = m
self.a.listener.delete(None, m)
self.print_mocks()
s = str(self.a.last_client.mock_calls)
LOG.debug("DELETE RESULT %s" % s)
self.assertTrue('vport.delete' in s)
self.assertTrue('fake-lb-id-001' in s)
self.assertTrue('fake-listen-id-001' in s)
self.assertTrue('port=2222' in s)
self.assertTrue('HTTPS' in s)
def test_update(self):
pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS,
constants.LB_METHOD_ROUND_ROBIN, None)
lb = test_base.FakeLoadBalancer()
m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS,
2222,
pool=pool,
loadbalancer=lb)
certmgr = FakeCertManager()
self.a.barbican_client = certmgr
# self.a.listener.set_certmgr(certmgr)
pool.listener = m
self.a.listener.update(None, m, m)
self.print_mocks()
s = str(self.a.last_client.mock_calls)
self.assertTrue('vport.update' in s)
self.assertTrue('fake-lb-id-001' in s)
self.assertTrue('fake-listen-id-001' in s)
self.assertTrue('port=2222' in s)
self.assertTrue('HTTPS' in s)
def _test_stats(self):
pool = test_base.FakePool('TCP', 'ROUND_ROBIN', None, False)
actual = self.a.pool.stats(None, pool)
return pool, actual
