def test_get_parent_project_not_exists(self, mock_key_client,
mock_get_session):
client_mock = mock.Mock()
client_mock.projects.get.return_value = FakeProject()
mock_key_client.return_value = client_mock
self.assertIsNone(
utils.get_parent_project(a10constants.MOCK_CHILD_PROJECT_ID))
def test_get_parent_project_exists(self, mock_key_client, mock_get_session):
client_mock = mock.Mock()
client_mock.projects.get.return_value = FakeProject(
parent_id=a10constants.MOCK_PARENT_PROJECT_ID)
mock_key_client.return_value = client_mock
self.assertEqual(utils.get_parent_project(a10constants.MOCK_CHILD_PROJECT_ID),
a10constants.MOCK_PARENT_PROJECT_ID)
def execute(self, loadbalancer, vthunder_config, use_device_flavor=False):
if use_device_flavor:
return
hierarchical_mt = vthunder_config.hierarchical_multitenancy
if hierarchical_mt == 'enable' and CONF.a10_global.use_parent_partition:
return
vthunder_ids = self.vthunder_repo.get_vthunders_by_ip_address(
db_apis.get_session(), ip_address=vthunder_config.ip_address)
for vthunder_id in vthunder_ids:
vthunder = self.vthunder_repo.get(db_apis.get_session(),
id=vthunder_id)
if vthunder is None:
return
existing_ip_addr_partition = '{}:{}'.format(
vthunder.ip_address, vthunder.partition_name)
config_ip_addr_partition = '{}:{}'.format(
vthunder_config.ip_address, vthunder_config.partition_name)
if existing_ip_addr_partition == config_ip_addr_partition:
if loadbalancer.project_id not in (vthunder.project_id,
utils.get_parent_project(
vthunder.project_id)):
raise exceptions.ProjectInUseByExistingThunderError(
config_ip_addr_partition, vthunder.project_id,
loadbalancer.project_id)
def create_member(self, member_id):
"""Creates a pool member.
:param member_id: ID of the member to create
:returns: None
:raises NoSuitablePool: Unable to find the node pool
"""
member = self._member_repo.get(db_apis.get_session(), id=member_id)
if not member:
LOG.warning(
'Failed to fetch %s %s from DB. Retrying for up to '
'60 seconds.', 'member', member_id)
raise db_exceptions.NoResultFound
pool = member.pool
listeners = pool.listeners
load_balancer = pool.load_balancer
topology = CONF.a10_controller_worker.loadbalancer_topology
parent_project_list = utils.get_parent_project_list()
member_parent_proj = utils.get_parent_project(member.project_id)
if (member.project_id in parent_project_list or
(member_parent_proj and member_parent_proj in parent_project_list)
or member.project_id in CONF.hardware_thunder.devices):
create_member_tf = self._taskflow_load(
self._member_flows.get_rack_vthunder_create_member_flow(),
store={
constants.MEMBER: member,
constants.LISTENERS: listeners,
constants.LOADBALANCER: load_balancer,
constants.POOL: pool
})
else:
create_member_tf = self._taskflow_load(
self._member_flows.get_create_member_flow(topology=topology),
store={
constants.MEMBER: member,
constants.LISTENERS: listeners,
constants.LOADBALANCER: load_balancer,
constants.POOL: pool
})
with tf_logging.DynamicLoggingListener(create_member_tf, log=LOG):
create_member_tf.run()
def execute(self, loadbalancer):
loadbalancer_id = loadbalancer.id
vthunder = self.vthunder_repo.get_vthunder_from_lb(
db_apis.get_session(), loadbalancer_id)
if vthunder is None:
return None
if (vthunder.undercloud and vthunder.hierarchical_multitenancy
and CONF.a10_global.use_parent_partition):
parent_project_id = utils.get_parent_project(vthunder.project_id)
if parent_project_id:
vthunder.partition_name = parent_project_id[:14]
elif CONF.a10_global.use_parent_partition and not vthunder.hierarchical_multitenancy:
LOG.warning(
"Hierarchical multitenancy is disabled, use_parent_partition "
"configuration will not be applied for loadbalancer: %s",
loadbalancer.id)
return vthunder
def _get_server_name(axapi_client, member):
server_name = '{}_{}'.format(member.project_id[:5],
member.ip_address.replace('.', '_'))
try:
server_name = axapi_client.slb.server.get(server_name)
except (acos_errors.NotFound):
# Backwards compatability with a10-neutron-lbaas
if CONF.a10_global.use_parent_partition:
try:
parent_project_id = a10_utils.get_parent_project(
member.project_id)
server_name = '_{}_{}_neutron'.format(
parent_project_id[:5], member.ip_address.replace('.', '_'))
server_name = axapi_client.slb.server.get(server_name)
except (acos_errors.NotFound):
server_name = '_{}_{}_neutron'.format(
member.project_id[:5], member.ip_address.replace('.', '_'))
server_name = axapi_client.slb.server.get(server_name)
else:
server_name = axapi_client.slb.server.get('_{}_{}'.format(
server_name, 'neutron'))
return server_name['server']['name']
def execute(self, loadbalancer, vthunder_config):
hierarchical_mt = vthunder_config.hierarchical_multitenancy
if hierarchical_mt == 'enable':
vthunder_config.partition_name = loadbalancer.project_id[:14]
if CONF.a10_global.use_parent_partition:
parent_project_id = utils.get_parent_project(
vthunder_config.project_id)
if parent_project_id:
if parent_project_id != 'default':
vthunder_config.partition_name = parent_project_id[:14]
else:
LOG.error(
"The parent project for project %s does not exist. ",
vthunder_config.project_id)
raise exceptions.ParentProjectNotFound(
vthunder_config.project_id)
else:
LOG.warning(
"Hierarchical multitenancy is disabled, use_parent_partition "
"configuration will not be applied for loadbalancer: %s",
loadbalancer.id)
vthunder_ids = self.vthunder_repo.get_vthunders_by_project_id(
db_apis.get_session(),
project_id=loadbalancer.project_id)
for vthunder_id in vthunder_ids:
vthunder = self.vthunder_repo.get(
db_apis.get_session(),
id=vthunder_id)
if vthunder is None:
return
existing_ip_addr_partition = '{}:{}'.format(
vthunder.ip_address, vthunder.partition_name)
config_ip_addr_partition = '{}:{}'.format(
vthunder_config.ip_address, vthunder_config.partition_name)
if existing_ip_addr_partition != config_ip_addr_partition:
raise exceptions.ThunderInUseByExistingProjectError(
config_ip_addr_partition, existing_ip_addr_partition, loadbalancer.project_id)
return vthunder_config
def execute(self, loadbalancer, vthunder_config):
hierarchical_mt = vthunder_config.hierarchical_multitenancy
if hierarchical_mt == 'enable':
vthunder_config.partition_name = loadbalancer.project_id[:14]
if CONF.a10_global.use_parent_partition:
parent_project_id = utils.get_parent_project(
vthunder_config.project_id)
if parent_project_id:
if parent_project_id != 'default':
vthunder_config.partition_name = parent_project_id[:14]
else:
LOG.error(
"The parent project for project %s does not exist. ",
vthunder_config.project_id)
raise exceptions.ParentProjectNotFound(
vthunder_config.project_id)
else:
LOG.warning(
"Hierarchical multitenancy is disabled, use_parent_partition "
"configuration will not be applied for loadbalancer: %s",
loadbalancer.id)
return vthunder_config
def create_listener(self, listener_id):
"""Function to create listener for A10 provider"""
listener = self._listener_repo.get(db_apis.get_session(),
id=listener_id)
if not listener:
LOG.warning(
'Failed to fetch %s %s from DB. Retrying for up to '
'60 seconds.', 'listener', listener_id)
raise db_exceptions.NoResultFound
load_balancer = listener.load_balancer
parent_project_list = utils.get_parent_project_list()
listener_parent_proj = utils.get_parent_project(listener.project_id)
if (listener.project_id in parent_project_list
or (listener_parent_proj
and listener_parent_proj in parent_project_list)
or listener.project_id in CONF.hardware_thunder.devices):
create_listener_tf = self._taskflow_load(
self._listener_flows.get_rack_vthunder_create_listener_flow(
listener.project_id),
store={
constants.LOADBALANCER: load_balancer,
constants.LISTENER: listener
})
else:
create_listener_tf = self._taskflow_load(
self._listener_flows.get_create_listener_flow(),
store={
constants.LOADBALANCER: load_balancer,
constants.LISTENER: listener
})
with tf_logging.DynamicLoggingListener(create_listener_tf, log=LOG):
create_listener_tf.run()
