def get_rack_vthunder_create_listener_flow(self, project_id):
"""Create a flow to create a rack listener"""
create_listener_flow = linear_flow.Flow(constants.CREATE_LISTENER_FLOW)
create_listener_flow.add(lifecycle_tasks.ListenerToErrorOnRevertTask(
requires=[constants.LISTENER]))
create_listener_flow.add(a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_listener_flow.add(self.handle_ssl_cert_flow(flow_type='create'))
create_listener_flow.add(a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LISTENER},
provides=constants.FLAVOR_DATA))
create_listener_flow.add(nat_pool_tasks.NatPoolCreate(
requires=(constants.LOADBALANCER,
a10constants.VTHUNDER, constants.FLAVOR_DATA)))
create_listener_flow.add(virtual_port_tasks.ListenerCreate(
requires=[constants.LOADBALANCER, constants.LISTENER,
a10constants.VTHUNDER, constants.FLAVOR_DATA]))
create_listener_flow.add(a10_database_tasks.
MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER,
constants.LISTENER]))
create_listener_flow.add(vthunder_tasks.WriteMemory(
requires=a10constants.VTHUNDER))
create_listener_flow.add(a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return create_listener_flow
def get_update_listener_flow(self, topology):
"""Flow to update a listener"""
update_listener_flow = linear_flow.Flow(constants.UPDATE_LISTENER_FLOW)
update_listener_flow.add(lifecycle_tasks.ListenerToErrorOnRevertTask(
requires=[constants.LISTENER]))
update_listener_flow.add(vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
update_listener_flow.add(a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
update_listener_flow.add(vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_MASTER_VTHUNDER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
update_listener_flow.add(self.handle_ssl_cert_flow(flow_type='update'))
update_listener_flow.add(a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LISTENER},
provides=constants.FLAVOR_DATA))
update_listener_flow.add(virtual_port_tasks.ListenerUpdate(
requires=[constants.LOADBALANCER, constants.LISTENER,
a10constants.VTHUNDER, constants.FLAVOR_DATA, constants.UPDATE_DICT]))
update_listener_flow.add(database_tasks.UpdateListenerInDB(
requires=[constants.LISTENER, constants.UPDATE_DICT]))
update_listener_flow.add(a10_database_tasks.
MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER,
constants.LISTENER]))
update_listener_flow.add(vthunder_tasks.WriteMemory(
requires=a10constants.VTHUNDER))
update_listener_flow.add(a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return update_listener_flow
def get_create_pool_flow(self):
"""Create a flow to create a pool
:returns: The flow for creating a pool
"""
create_pool_flow = linear_flow.Flow(constants.CREATE_POOL_FLOW)
create_pool_flow.add(lifecycle_tasks.PoolToErrorOnRevertTask(
requires=[constants.POOL,
constants.LISTENERS,
constants.LOADBALANCER]))
create_pool_flow.add(database_tasks.MarkPoolPendingCreateInDB(
requires=constants.POOL))
create_pool_flow.add(a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_pool_flow.add(a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.POOL},
provides=constants.FLAVOR))
create_pool = service_group_tasks.PoolCreate(
requires=[constants.POOL, a10constants.VTHUNDER, constants.FLAVOR],
provides=constants.POOL)
create_pool_flow.add(*self._get_sess_pers_subflow(create_pool))
create_pool_flow.add(virtual_port_tasks.ListenerUpdateForPool(
requires=[constants.LOADBALANCER, constants.LISTENER, a10constants.VTHUNDER]))
create_pool_flow.add(database_tasks.MarkPoolActiveInDB(
requires=constants.POOL))
create_pool_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
create_pool_flow.add(vthunder_tasks.WriteMemory(
requires=a10constants.VTHUNDER))
create_pool_flow.add(a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return create_pool_flow
def test_GetFlavorData_format_flavor_multi_val(self):
expected = {
"service_group": {
"name_expressions": [{
"regex": "sg1",
"json": {
"health_check_disable": 1
}
}],
"strict_select":
0
}
}
name_expr = {
"name-expressions": [{
"regex": "sg1",
"json": {
"health-check-disable": 1
}
}]
}
flavor = {"service-group": {"strict-select": 0}}
flavor['service-group'].update(name_expr)
flavor_task = task.GetFlavorData()
formated_flavor = flavor_task._format_keys(flavor)
self.assertEqual(formated_flavor, expected)
def get_create_health_monitor_flow(self, topology):
"""Create a flow to create a health monitor
:returns: The flow for creating a health monitor
"""
create_hm_flow = linear_flow.Flow(constants.CREATE_HEALTH_MONITOR_FLOW)
create_hm_flow.add(
lifecycle_tasks.HealthMonitorToErrorOnRevertTask(requires=[
constants.HEALTH_MON, constants.LISTENERS,
constants.LOADBALANCER
]))
create_hm_flow.add(
vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
create_hm_flow.add(
database_tasks.MarkHealthMonitorPendingCreateInDB(
requires=constants.HEALTH_MON))
create_hm_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
create_hm_flow.add(
vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_MASTER_VTHUNDER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
create_hm_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
create_hm_flow.add(
health_monitor_tasks.CreateAndAssociateHealthMonitor(requires=[
constants.LISTENERS, constants.HEALTH_MON,
a10constants.VTHUNDER, constants.FLAVOR
]))
create_hm_flow.add(
database_tasks.MarkHealthMonitorActiveInDB(
requires=constants.HEALTH_MON))
create_hm_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
create_hm_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
create_hm_flow.add(
vthunder_tasks.WriteMemory(
name=a10constants.WRITE_MEM_FOR_LOCAL_PARTITION,
requires=(a10constants.VTHUNDER)))
create_hm_flow.add(
vthunder_tasks.WriteMemory(
name=a10constants.WRITE_MEM_FOR_SHARED_PARTITION,
requires=(a10constants.VTHUNDER,
a10constants.WRITE_MEM_SHARED_PART)))
create_hm_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=(a10constants.VTHUNDER)))
return create_hm_flow
def get_delete_pool_rack_flow(self, members, health_mon, store):
"""Create a flow to delete a pool rack
:returns: The flow for deleting a pool
"""
delete_pool_flow = linear_flow.Flow(constants.DELETE_POOL_FLOW)
delete_pool_flow.add(lifecycle_tasks.PoolToErrorOnRevertTask(
requires=[constants.POOL,
constants.LISTENERS,
constants.LOADBALANCER]))
delete_pool_flow.add(database_tasks.MarkPoolPendingDeleteInDB(
requires=constants.POOL))
delete_pool_flow.add(database_tasks.CountPoolChildrenForQuota(
requires=constants.POOL, provides=constants.POOL_CHILD_COUNT))
delete_pool_flow.add(model_tasks.DeleteModelObject(
rebind={constants.OBJECT: constants.POOL}))
# Get VThunder details from database
delete_pool_flow.add(a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_pool_flow.add(virtual_port_tasks.ListenerUpdateForPool(
requires=[constants.LOADBALANCER, constants.LISTENER, a10constants.VTHUNDER]))
delete_pool_flow.add(persist_tasks.DeleteSessionPersistence(
requires=[a10constants.VTHUNDER, constants.POOL]))
delete_pool_flow.add(vthunder_tasks.SetupDeviceNetworkMap(
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
# Device Flavor
delete_pool_flow.add(a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
delete_pool_flow.add(vthunder_tasks.GetVthunderConfByFlavor(
requires=(constants.LOADBALANCER, a10constants.VTHUNDER_CONFIG,
a10constants.DEVICE_CONFIG_DICT),
rebind={constants.FLAVOR_DATA: constants.FLAVOR},
provides=(a10constants.VTHUNDER_CONFIG, a10constants.USE_DEVICE_FLAVOR)))
delete_pool_flow.add(a10_network_tasks.GetPoolsOnThunder(
requires=[a10constants.VTHUNDER, a10constants.USE_DEVICE_FLAVOR],
provides=a10constants.POOLS))
# Delete pool children
delete_pool_flow.add(self._get_delete_health_monitor_vthunder_subflow(health_mon))
delete_pool_flow.add(self._get_delete_member_vthunder_subflow(members, store))
delete_pool_flow.add(service_group_tasks.PoolDelete(
requires=[constants.POOL, a10constants.VTHUNDER]))
delete_pool_flow.add(database_tasks.DeletePoolInDB(
requires=constants.POOL))
delete_pool_flow.add(database_tasks.DecrementPoolQuota(
requires=[constants.POOL, constants.POOL_CHILD_COUNT]))
delete_pool_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
delete_pool_flow.add(vthunder_tasks.WriteMemory(
requires=a10constants.VTHUNDER))
delete_pool_flow.add(a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return delete_pool_flow
def get_update_pool_flow(self, topology):
"""Create a flow to update a pool
:returns: The flow for updating a pool
"""
update_pool_flow = linear_flow.Flow(constants.UPDATE_POOL_FLOW)
update_pool_flow.add(
lifecycle_tasks.PoolToErrorOnRevertTask(requires=[
constants.POOL, constants.LISTENERS, constants.LOADBALANCER
]))
update_pool_flow.add(
vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
update_pool_flow.add(
database_tasks.MarkPoolPendingUpdateInDB(requires=constants.POOL))
update_pool_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
update_pool_flow.add(
vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_MASTER_VTHUNDER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
update_pool_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.POOL},
provides=constants.FLAVOR))
update_pool = service_group_tasks.PoolUpdate(requires=[
constants.POOL, a10constants.VTHUNDER, constants.UPDATE_DICT,
constants.FLAVOR
],
provides=constants.POOL)
update_pool_flow.add(*self._get_sess_pers_subflow(update_pool))
update_pool_flow.add(
virtual_port_tasks.ListenerUpdateForPool(requires=[
constants.LOADBALANCER, constants.LISTENER,
a10constants.VTHUNDER
]))
update_pool_flow.add(
database_tasks.UpdatePoolInDB(
requires=[constants.POOL, constants.UPDATE_DICT]))
update_pool_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
update_pool_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
update_pool_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
update_pool_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return update_pool_flow
def get_rack_vthunder_create_member_flow(self):
"""Create a flow to create a rack vthunder member
:returns: The flow for creating a rack vthunder member
"""
create_member_flow = linear_flow.Flow(constants.CREATE_MEMBER_FLOW)
create_member_flow.add(
lifecycle_tasks.MemberToErrorOnRevertTask(requires=[
constants.MEMBER, constants.LISTENERS, constants.LOADBALANCER,
constants.POOL
]))
create_member_flow.add(
database_tasks.MarkMemberPendingCreateInDB(
requires=constants.MEMBER))
create_member_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_member_flow.add(
vthunder_tasks.SetupDeviceNetworkMap(
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
create_member_flow.add(self.handle_vrid_for_member_subflow())
if CONF.a10_global.network_type == 'vlan':
create_member_flow.add(
vthunder_tasks.TagInterfaceForMember(
requires=[constants.MEMBER, a10constants.VTHUNDER]))
create_member_flow.add(
a10_database_tasks.CountMembersWithIP(
requires=constants.MEMBER,
provides=a10constants.MEMBER_COUNT_IP))
create_member_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
create_member_flow.add(self.get_create_member_snat_pool_subflow())
create_member_flow.add(
server_tasks.MemberCreate(requires=(constants.MEMBER,
a10constants.VTHUNDER,
constants.POOL,
a10constants.MEMBER_COUNT_IP,
constants.FLAVOR)))
create_member_flow.add(
database_tasks.MarkMemberActiveInDB(requires=constants.MEMBER))
create_member_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
create_member_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=(constants.LOADBALANCER, constants.LISTENERS)))
create_member_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
create_member_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return create_member_flow
def get_update_member_flow(self, topology):
"""Flow to update a member
:returns: The flow for updating a member
"""
update_member_flow = linear_flow.Flow(constants.UPDATE_MEMBER_FLOW)
update_member_flow.add(
lifecycle_tasks.MemberToErrorOnRevertTask(requires=[
constants.MEMBER, constants.LISTENERS, constants.LOADBALANCER,
constants.POOL
]))
update_member_flow.add(
vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
update_member_flow.add(
database_tasks.MarkMemberPendingUpdateInDB(
requires=constants.MEMBER))
update_member_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
update_member_flow.add(
vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_MASTER_VTHUNDER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
update_member_flow.add(self.handle_vrid_for_member_subflow())
update_member_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
update_member_flow.add(
server_tasks.MemberUpdate(requires=(constants.MEMBER,
a10constants.VTHUNDER,
constants.POOL,
constants.FLAVOR,
constants.UPDATE_DICT)))
update_member_flow.add(
database_tasks.UpdateMemberInDB(
requires=[constants.MEMBER, constants.UPDATE_DICT]))
update_member_flow.add(
database_tasks.MarkMemberActiveInDB(requires=constants.MEMBER))
update_member_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
update_member_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
update_member_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
update_member_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return update_member_flow
def get_create_rack_vthunder_load_balancer_flow(self,
vthunder_conf,
topology,
listeners=None):
"""Flow to create rack load balancer"""
f_name = constants.CREATE_LOADBALANCER_FLOW
lb_create_flow = linear_flow.Flow(f_name)
lb_create_flow.add(
lifecycle_tasks.LoadBalancerIDToErrorOnRevertTask(
requires=constants.LOADBALANCER_ID))
lb_create_flow.add(
database_tasks.ReloadLoadBalancer(
requires=constants.LOADBALANCER_ID,
provides=constants.LOADBALANCER))
lb_create_flow.add(
a10_database_tasks.CheckExistingProjectToThunderMappedEntries(
inject={a10constants.VTHUNDER_CONFIG: vthunder_conf},
requires=(constants.LOADBALANCER,
a10constants.VTHUNDER_CONFIG),
provides=a10constants.VTHUNDER_CONFIG))
lb_create_flow.add(
a10_database_tasks.CheckExistingThunderToProjectMappedEntries(
requires=(constants.LOADBALANCER,
a10constants.VTHUNDER_CONFIG)))
lb_create_flow.add(
self.vthunder_flows.get_rack_vthunder_for_lb_subflow(
vthunder_conf=a10constants.VTHUNDER_CONFIG,
prefix=constants.ROLE_STANDALONE,
role=constants.ROLE_STANDALONE))
post_amp_prefix = constants.POST_LB_AMP_ASSOCIATION_SUBFLOW
lb_create_flow.add(
self.get_post_lb_rack_vthunder_association_flow(
post_amp_prefix, topology, mark_active=(not listeners)))
lb_create_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR_DATA))
lb_create_flow.add(
nat_pool_tasks.NatPoolCreate(requires=(constants.LOADBALANCER,
a10constants.VTHUNDER,
constants.FLAVOR_DATA)))
lb_create_flow.add(
virtual_server_tasks.CreateVirtualServerTask(
requires=(constants.LOADBALANCER, a10constants.VTHUNDER,
constants.FLAVOR_DATA),
provides=a10constants.STATUS))
lb_create_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
lb_create_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return lb_create_flow
def get_update_load_balancer_flow(self):
"""Flow to update load balancer."""
update_LB_flow = linear_flow.Flow(constants.UPDATE_LOADBALANCER_FLOW)
update_LB_flow.add(
lifecycle_tasks.LoadBalancerToErrorOnRevertTask(
requires=constants.LOADBALANCER))
update_LB_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
update_LB_flow.add(
a10_database_tasks.MarkVThunderStatusInDB(
requires=a10constants.VTHUNDER,
inject={"status": constants.PENDING_UPDATE}))
update_LB_flow.add(
vthunder_tasks.SetupDeviceNetworkMap(
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
update_LB_flow.add(
network_tasks.ApplyQos(requires=(constants.LOADBALANCER,
constants.UPDATE_DICT)))
# update_LB_flow.add(amphora_driver_tasks.ListenersUpdate(
# requires=[constants.LOADBALANCER, constants.LISTENERS]))
# post_create_lb_flow.add(handle_vrid_for_loadbalancer_subflow())
update_LB_flow.add(self.handle_vrid_for_loadbalancer_subflow())
update_LB_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR_DATA))
update_LB_flow.add(
virtual_server_tasks.UpdateVirtualServerTask(
requires=(constants.LOADBALANCER, a10constants.VTHUNDER,
constants.FLAVOR_DATA)))
update_LB_flow.add(
database_tasks.UpdateLoadbalancerInDB(
requires=[constants.LOADBALANCER, constants.UPDATE_DICT]))
if CONF.a10_global.network_type == 'vlan':
update_LB_flow.add(
vthunder_tasks.TagInterfaceForLB(
requires=[constants.LOADBALANCER, a10constants.VTHUNDER]))
update_LB_flow.add(
database_tasks.MarkLBActiveInDB(requires=constants.LOADBALANCER))
update_LB_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
update_LB_flow.add(
a10_database_tasks.MarkVThunderStatusInDB(
name="pending_update_to_active",
requires=a10constants.VTHUNDER,
inject={"status": constants.ACTIVE}))
update_LB_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return update_LB_flow
def get_rack_vthunder_update_member_flow(self):
"""Flow to update a member in Thunder devices
:returns: The flow for updating a member
"""
update_member_flow = linear_flow.Flow(constants.UPDATE_MEMBER_FLOW)
update_member_flow.add(
lifecycle_tasks.MemberToErrorOnRevertTask(requires=[
constants.MEMBER, constants.LISTENERS, constants.LOADBALANCER,
constants.POOL
]))
update_member_flow.add(
database_tasks.MarkMemberPendingUpdateInDB(
requires=constants.MEMBER))
update_member_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
update_member_flow.add(
vthunder_tasks.SetupDeviceNetworkMap(
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
# Handle VRID settings
update_member_flow.add(self.handle_vrid_for_member_subflow())
update_member_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
update_member_flow.add(
server_tasks.MemberUpdate(requires=(constants.MEMBER,
a10constants.VTHUNDER,
constants.POOL,
constants.FLAVOR)))
update_member_flow.add(
database_tasks.UpdateMemberInDB(
requires=[constants.MEMBER, constants.UPDATE_DICT]))
if CONF.a10_global.network_type == 'vlan':
update_member_flow.add(
vthunder_tasks.TagInterfaceForMember(
requires=[constants.MEMBER, a10constants.VTHUNDER]))
update_member_flow.add(
database_tasks.MarkMemberActiveInDB(requires=constants.MEMBER))
update_member_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
update_member_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
update_member_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
update_member_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return update_member_flow
def get_delete_member_flow(self):
"""Flow to delete a member on VThunder
:returns: The flow for deleting a member
"""
delete_member_flow = linear_flow.Flow(constants.DELETE_MEMBER_FLOW)
delete_member_flow.add(
lifecycle_tasks.MemberToErrorOnRevertTask(requires=[
constants.MEMBER, constants.LISTENERS, constants.LOADBALANCER,
constants.POOL
]))
delete_member_flow.add(
database_tasks.MarkMemberPendingDeleteInDB(
requires=constants.MEMBER))
delete_member_flow.add(
model_tasks.DeleteModelObject(
rebind={constants.OBJECT: constants.MEMBER}))
delete_member_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_member_flow.add(
a10_database_tasks.CountMembersWithIP(
requires=constants.MEMBER,
provides=a10constants.MEMBER_COUNT_IP))
delete_member_flow.add(
a10_database_tasks.CountMembersWithIPPortProtocol(
requires=(constants.MEMBER, constants.POOL),
provides=a10constants.MEMBER_COUNT_IP_PORT_PROTOCOL))
delete_member_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
delete_member_flow.add(
server_tasks.MemberDelete(
requires=(constants.MEMBER, a10constants.VTHUNDER,
constants.POOL, a10constants.MEMBER_COUNT_IP,
a10constants.MEMBER_COUNT_IP_PORT_PROTOCOL)))
delete_member_flow.add(
database_tasks.DeleteMemberInDB(requires=constants.MEMBER))
delete_member_flow.add(
database_tasks.DecrementMemberQuota(requires=constants.MEMBER))
delete_member_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
delete_member_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
delete_member_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
delete_member_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return delete_member_flow
def test_GetFlavorData_execute_with_default_flavor_id(self):
flavor_task = task.GetFlavorData()
flavor = copy.deepcopy(FLAVOR)
flavor_prof = copy.deepcopy(FLAVOR_PROFILE)
flavor_prof.flavor_data = "{}"
flavor_task.flavor_repo = mock.Mock()
flavor_task.flavor_repo.get.return_value = flavor
self.conf.config(group=a10constants.A10_GLOBAL_OPTS,
default_flavor_id=flavor)
flavor_task.flavor_profile_repo = mock.Mock()
flavor_task.flavor_profile_repo.get.return_value = flavor_prof
ret_val = flavor_task.execute(LB2)
self.assertEqual(ret_val, {})
def get_update_health_monitor_flow(self):
"""Create a flow to update a health monitor
:returns: The flow for updating a health monitor
"""
update_hm_flow = linear_flow.Flow(constants.UPDATE_HEALTH_MONITOR_FLOW)
update_hm_flow.add(
lifecycle_tasks.HealthMonitorToErrorOnRevertTask(requires=[
constants.HEALTH_MON, constants.LISTENERS,
constants.LOADBALANCER
]))
update_hm_flow.add(
database_tasks.MarkHealthMonitorPendingUpdateInDB(
requires=constants.HEALTH_MON))
update_hm_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
update_hm_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
update_hm_flow.add(
health_monitor_tasks.UpdateHealthMonitor(requires=[
constants.LISTENERS, constants.HEALTH_MON,
a10constants.VTHUNDER, constants.UPDATE_DICT, constants.FLAVOR
]))
update_hm_flow.add(
database_tasks.UpdateHealthMonInDB(
requires=[constants.HEALTH_MON, constants.UPDATE_DICT]))
update_hm_flow.add(
database_tasks.MarkHealthMonitorActiveInDB(
requires=constants.HEALTH_MON))
update_hm_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
update_hm_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
update_hm_flow.add(
vthunder_tasks.WriteMemory(
name=a10constants.WRITE_MEM_FOR_LOCAL_PARTITION,
requires=(a10constants.VTHUNDER)))
update_hm_flow.add(
vthunder_tasks.WriteMemory(
name=a10constants.WRITE_MEM_FOR_SHARED_PARTITION,
requires=(a10constants.VTHUNDER,
a10constants.WRITE_MEM_SHARED_PART)))
update_hm_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=(a10constants.VTHUNDER)))
return update_hm_flow
def test_GetFlavorData_execute_return_flavor(self):
flavor_task = task.GetFlavorData()
flavor_task._flavor_search = mock.Mock(
return_value=a10constants.MOCK_FLAVOR_ID)
flavor_task._format_keys = mock.Mock()
flavor_task._format_keys.return_value = {}
flavor_task.flavor_repo = mock.Mock()
flavor_task.flavor_repo.get.return_value = FLAVOR
flavor_prof = copy.deepcopy(FLAVOR_PROFILE)
flavor_prof.flavor_data = "{}"
flavor_task.flavor_profile_repo = mock.Mock()
flavor_task.flavor_profile_repo.get.return_value = flavor_prof
ret_val = flavor_task.execute(LB)
self.assertEqual(ret_val, {})
def test_GetFlavorData_execute_no_flavor_or_profile(self):
flavor_task = task.GetFlavorData()
flavor_task.flavor_repo = mock.Mock()
flavor_task.flavor_repo.get.return_value = None
flavor_task._flavor_search = mock.Mock(
return_value=a10constants.MOCK_FLAVOR_ID)
ret_val = flavor_task.execute(LB)
self.assertEqual(ret_val, None)
flavor_task.flavor_repo.reset_mock()
flavor_task.flavor_repo = mock.Mock()
flavor = copy.deepcopy(FLAVOR)
flavor.flavor_profile_id = None
flavor_task.flavor_repo.get.return_value = flavor
ret_val = flavor_task.execute(LB)
self.assertEqual(ret_val, None)
def get_create_load_balancer_flow(self, topology, listeners=None):
"""Flow to create a load balancer"""
f_name = constants.CREATE_LOADBALANCER_FLOW
lb_create_flow = linear_flow.Flow(f_name)
lb_create_flow.add(
lifecycle_tasks.LoadBalancerIDToErrorOnRevertTask(
requires=constants.LOADBALANCER_ID))
# Attaching vThunder to LB in database
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
lb_create_flow.add(*self._create_active_standby_topology())
LOG.info("TOPOLOGY ===" + str(topology))
elif topology == constants.TOPOLOGY_SINGLE:
lb_create_flow.add(*self._create_single_topology())
LOG.info("TOPOLOGY ===" + str(topology))
else:
LOG.error("Unknown topology: %s. Unable to build load balancer.",
topology)
raise exceptions.InvalidTopology(topology=topology)
# IMP: Now creating vThunder config here
post_amp_prefix = constants.POST_LB_AMP_ASSOCIATION_SUBFLOW
lb_create_flow.add(
self.get_post_lb_vthunder_association_flow(
post_amp_prefix, topology, mark_active=(not listeners)))
lb_create_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR_DATA))
lb_create_flow.add(
nat_pool_tasks.NatPoolCreate(requires=(constants.LOADBALANCER,
a10constants.VTHUNDER,
constants.FLAVOR_DATA)))
lb_create_flow.add(
virtual_server_tasks.CreateVirtualServerTask(
requires=(constants.LOADBALANCER, a10constants.VTHUNDER,
constants.FLAVOR_DATA)))
lb_create_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
lb_create_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return lb_create_flow
def test_GetFlavorData_format_flavor_list_keys(self):
expected = {
"service_group": {
"name_expressions": [{
"regex": "sg1",
"json": {
"health_check_disable": 1
}
}]
}
}
name_expr = {
"name-expressions": [{
"regex": "sg1",
"json": {
"health-check-disable": 1
}
}]
}
flavor = {"service-group": name_expr}
flavor_task = task.GetFlavorData()
formated_flavor = flavor_task._format_keys(flavor)
self.assertEqual(formated_flavor, expected)
def test_GetFlavorData_execute_no_flavor_id(self, mock_utils):
mock_utils.attribute_search.return_value = None
flavor_task = task.GetFlavorData()
ret_val = flavor_task.execute(LB)
self.assertEqual(ret_val, None)
def get_delete_member_flow(self):
"""Flow to delete a member on VThunder
:returns: The flow for deleting a member
"""
delete_member_flow = linear_flow.Flow(constants.DELETE_MEMBER_FLOW)
delete_member_flow.add(
lifecycle_tasks.MemberToErrorOnRevertTask(requires=[
constants.MEMBER, constants.LISTENERS, constants.LOADBALANCER,
constants.POOL
]))
delete_member_flow.add(
database_tasks.MarkMemberPendingDeleteInDB(
requires=constants.MEMBER))
delete_member_flow.add(
model_tasks.DeleteModelObject(
rebind={constants.OBJECT: constants.MEMBER}))
delete_member_flow.add(
database_tasks.GetAmphoraeFromLoadbalancer(
requires=constants.LOADBALANCER, provides=constants.AMPHORA))
delete_member_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_member_flow.add(
a10_database_tasks.CountMembersWithIP(
requires=constants.MEMBER,
provides=a10constants.MEMBER_COUNT_IP))
delete_member_flow.add(
a10_database_tasks.CountMembersWithIPPortProtocol(
requires=(constants.MEMBER, constants.POOL),
provides=a10constants.MEMBER_COUNT_IP_PORT_PROTOCOL))
delete_member_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
delete_member_flow.add(
database_tasks.DeleteMemberInDB(requires=constants.MEMBER))
delete_member_flow.add(
a10_database_tasks.GetLoadBalancerListByProjectID(
requires=a10constants.VTHUNDER,
provides=a10constants.LOADBALANCERS_LIST))
delete_member_flow.add(
a10_network_tasks.CalculateDelta(
requires=(constants.LOADBALANCER,
a10constants.LOADBALANCERS_LIST),
provides=constants.DELTAS))
delete_member_flow.add(
a10_network_tasks.HandleNetworkDeltas(
requires=constants.DELTAS, provides=constants.ADDED_PORTS))
delete_member_flow.add(
vthunder_tasks.AmphoraePostNetworkUnplug(
requires=(constants.LOADBALANCER, constants.ADDED_PORTS,
a10constants.VTHUNDER)))
delete_member_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
delete_member_flow.add(
server_tasks.MemberFindNatPool(requires=[
constants.MEMBER, a10constants.VTHUNDER, constants.POOL,
constants.FLAVOR
],
provides=a10constants.NAT_FLAVOR))
delete_member_flow.add(
a10_database_tasks.GetNatPoolEntry(
requires=[constants.MEMBER, a10constants.NAT_FLAVOR],
provides=a10constants.NAT_POOL))
delete_member_flow.add(
a10_network_tasks.ReleaseSubnetAddressForMember(requires=[
constants.MEMBER, a10constants.NAT_FLAVOR,
a10constants.NAT_POOL
]))
delete_member_flow.add(
a10_database_tasks.DeleteNatPoolEntry(
requires=a10constants.NAT_POOL))
delete_member_flow.add(
server_tasks.MemberDelete(
requires=(constants.MEMBER, a10constants.VTHUNDER,
constants.POOL, a10constants.MEMBER_COUNT_IP,
a10constants.MEMBER_COUNT_IP_PORT_PROTOCOL)))
delete_member_flow.add(self.get_delete_member_vrid_subflow())
delete_member_flow.add(
database_tasks.DecrementMemberQuota(requires=constants.MEMBER))
delete_member_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
delete_member_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
delete_member_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
delete_member_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return delete_member_flow
def get_rack_vthunder_delete_member_flow(self):
"""Flow to delete a member in Thunder devices
:returns: The flow for deleting a member
"""
delete_member_flow = linear_flow.Flow(constants.DELETE_MEMBER_FLOW)
delete_member_flow.add(
lifecycle_tasks.MemberToErrorOnRevertTask(requires=[
constants.MEMBER, constants.LISTENERS, constants.LOADBALANCER,
constants.POOL
]))
delete_member_flow.add(
database_tasks.MarkMemberPendingDeleteInDB(
requires=constants.MEMBER))
delete_member_flow.add(
model_tasks.DeleteModelObject(
rebind={constants.OBJECT: constants.MEMBER}))
delete_member_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_member_flow.add(
vthunder_tasks.SetupDeviceNetworkMap(
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
delete_member_flow.add(
a10_database_tasks.CountMembersWithIP(
requires=constants.MEMBER,
provides=a10constants.MEMBER_COUNT_IP))
delete_member_flow.add(
a10_database_tasks.CountMembersWithIPPortProtocol(
requires=(constants.MEMBER, constants.POOL),
provides=a10constants.MEMBER_COUNT_IP_PORT_PROTOCOL))
delete_member_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
delete_member_flow.add(
server_tasks.MemberFindNatPool(requires=[
constants.MEMBER, a10constants.VTHUNDER, constants.POOL,
constants.FLAVOR
],
provides=a10constants.NAT_FLAVOR))
delete_member_flow.add(
a10_database_tasks.GetNatPoolEntry(
requires=[constants.MEMBER, a10constants.NAT_FLAVOR],
provides=a10constants.NAT_POOL))
delete_member_flow.add(
a10_network_tasks.ReleaseSubnetAddressForMember(requires=[
constants.MEMBER, a10constants.NAT_FLAVOR,
a10constants.NAT_POOL
]))
delete_member_flow.add(
a10_database_tasks.DeleteNatPoolEntry(
requires=a10constants.NAT_POOL))
delete_member_flow.add(
server_tasks.MemberDelete(
requires=(constants.MEMBER, a10constants.VTHUNDER,
constants.POOL, a10constants.MEMBER_COUNT_IP,
a10constants.MEMBER_COUNT_IP_PORT_PROTOCOL)))
if CONF.a10_global.network_type == 'vlan':
delete_member_flow.add(
vthunder_tasks.DeleteInterfaceTagIfNotInUseForMember(
requires=[constants.MEMBER, a10constants.VTHUNDER]))
# Handle VRID setting
delete_member_flow.add(self.get_delete_member_vrid_subflow())
delete_member_flow.add(
database_tasks.DeleteMemberInDB(requires=constants.MEMBER))
delete_member_flow.add(
database_tasks.DecrementMemberQuota(requires=constants.MEMBER))
delete_member_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
delete_member_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
delete_member_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
delete_member_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return delete_member_flow
def test_GetFlavorData_format_flavor_keys(self):
expected = {"virtual_server": {"arp_disable": 1}}
flavor = {"virtual-server": {"arp-disable": 1}}
flavor_task = task.GetFlavorData()
formated_flavor = flavor_task._format_keys(flavor)
self.assertEqual(formated_flavor, expected)
def get_create_member_flow(self, topology):
"""Create a flow to create a member
:returns: The flow for creating a member
"""
create_member_flow = linear_flow.Flow(constants.CREATE_MEMBER_FLOW)
create_member_flow.add(
lifecycle_tasks.MemberToErrorOnRevertTask(requires=[
constants.MEMBER, constants.LISTENERS, constants.LOADBALANCER,
constants.POOL
]))
create_member_flow.add(
database_tasks.MarkMemberPendingCreateInDB(
requires=constants.MEMBER))
create_member_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_member_flow.add(
a10_database_tasks.GetLoadBalancerListByProjectID(
requires=a10constants.VTHUNDER,
provides=a10constants.LOADBALANCERS_LIST))
create_member_flow.add(
database_tasks.GetAmphoraeFromLoadbalancer(
requires=constants.LOADBALANCER, provides=constants.AMPHORA))
create_member_flow.add(
a10_network_tasks.CalculateDelta(
requires=(constants.LOADBALANCER,
a10constants.LOADBALANCERS_LIST),
provides=constants.DELTAS))
create_member_flow.add(
a10_network_tasks.HandleNetworkDeltas(
requires=constants.DELTAS, provides=constants.ADDED_PORTS))
# managing interface additions here
create_member_flow.add(
vthunder_tasks.AmphoraePostMemberNetworkPlug(
requires=(constants.LOADBALANCER, constants.ADDED_PORTS,
a10constants.VTHUNDER)))
create_member_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
create_member_flow.add(
vthunder_tasks.EnableInterfaceForMembers(requires=[
constants.ADDED_PORTS, constants.LOADBALANCER,
a10constants.VTHUNDER
]))
create_member_flow.add(self.handle_vrid_for_member_subflow())
# configure member flow for HA
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
create_member_flow.add(
a10_database_tasks.GetBackupVThunderByLoadBalancer(
name="get_backup_vThunder",
requires=constants.LOADBALANCER,
provides=a10constants.BACKUP_VTHUNDER))
create_member_flow.add(
vthunder_tasks.AmphoraePostMemberNetworkPlug(
name="backup_amphora_network_plug",
requires=[constants.ADDED_PORTS, constants.LOADBALANCER],
rebind={
a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER
}))
create_member_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name="backup_compute_conn_wait",
requires=constants.AMPHORA,
rebind={
a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER
}))
create_member_flow.add(
vthunder_tasks.EnableInterfaceForMembers(
name="backup_enable_interface",
requires=[constants.ADDED_PORTS, constants.LOADBALANCER],
rebind={
a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER
}))
create_member_flow.add(
a10_database_tasks.CountMembersWithIP(
requires=constants.MEMBER,
provides=a10constants.MEMBER_COUNT_IP))
create_member_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
create_member_flow.add(self.get_create_member_snat_pool_subflow())
create_member_flow.add(
server_tasks.MemberCreate(requires=(constants.MEMBER,
a10constants.VTHUNDER,
constants.POOL,
a10constants.MEMBER_COUNT_IP,
constants.FLAVOR)))
create_member_flow.add(
database_tasks.MarkMemberActiveInDB(requires=constants.MEMBER))
create_member_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
create_member_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=(constants.LOADBALANCER, constants.LISTENERS)))
create_member_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
create_member_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return create_member_flow
def get_delete_member_vthunder_internal_subflow(self,
member_id,
pool=constants.POOL):
delete_member_thunder_subflow = linear_flow.Flow(
a10constants.DELETE_MEMBER_VTHUNDER_INTERNAL_SUBFLOW)
delete_member_thunder_subflow.add(
vthunder_tasks.SetupDeviceNetworkMap(
name='setup_device_network_map_' + member_id,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
delete_member_thunder_subflow.add(
a10_database_tasks.CountMembersWithIPPortProtocol(
name='count_members_ip_port_' + member_id,
requires=(constants.MEMBER, constants.POOL),
provides=a10constants.MEMBER_COUNT_IP_PORT_PROTOCOL,
rebind={
constants.MEMBER: member_id,
constants.POOL: pool
}))
delete_member_thunder_subflow.add(
a10_database_tasks.PoolCountforIP(
name='pool_count_for_ip_' + member_id,
requires=constants.MEMBER,
provides=a10constants.POOL_COUNT_IP,
rebind={constants.MEMBER: member_id}))
# NAT pools database and pools clean up for flavor
delete_member_thunder_subflow.add(
a10_database_tasks.GetFlavorData(
name='get_flavor_data_' + member_id,
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR))
delete_member_thunder_subflow.add(
server_tasks.MemberFindNatPool(
name='member_find_nat_pool_' + member_id,
requires=[
constants.MEMBER, a10constants.VTHUNDER, constants.POOL,
constants.FLAVOR
],
provides=a10constants.NAT_FLAVOR,
rebind={
constants.MEMBER: member_id,
constants.POOL: pool
}))
delete_member_thunder_subflow.add(
a10_database_tasks.GetNatPoolEntry(
name='get_nat_pool_db_entry_' + member_id,
requires=[constants.MEMBER, a10constants.NAT_FLAVOR],
provides=a10constants.NAT_POOL,
rebind={constants.MEMBER: member_id}))
delete_member_thunder_subflow.add(
a10_network_tasks.ReleaseSubnetAddressForMember(
name='release_subnet_address_for_member_' + member_id,
requires=[
constants.MEMBER, a10constants.NAT_FLAVOR,
a10constants.NAT_POOL
],
rebind={constants.MEMBER: member_id}))
delete_member_thunder_subflow.add(
a10_database_tasks.DeleteNatPoolEntry(
name='delete_nat_pool_entry_' + member_id,
requires=a10constants.NAT_POOL))
delete_member_thunder_subflow.add(
server_tasks.MemberDeletePool(
name='delete_thunder_member_pool_' + member_id,
requires=(constants.MEMBER, a10constants.VTHUNDER,
constants.POOL, a10constants.POOL_COUNT_IP,
a10constants.MEMBER_COUNT_IP_PORT_PROTOCOL),
rebind={
constants.MEMBER: member_id,
constants.POOL: pool
}))
if CONF.a10_global.network_type == 'vlan':
delete_member_thunder_subflow.add(
vthunder_tasks.DeleteInterfaceTagIfNotInUseForMember(
name='delete_unused_interface_tag_in_member_' + member_id,
requires=[constants.MEMBER, a10constants.VTHUNDER],
rebind={constants.MEMBER: member_id}))
return delete_member_thunder_subflow
def test_GetFlavorData_execute_no_flavor_id(self):
flavor_task = task.GetFlavorData()
flavor_task._flavor_search = mock.Mock(return_value=None)
ret_val = flavor_task.execute(LB)
self.assertEqual(ret_val, None)
def test_flavor_search_health_monitor_find_flavor(self):
flavor_task = task.GetFlavorData()
found_id = flavor_task._flavor_search(HM)
self.assertEqual(found_id, a10constants.MOCK_FLAVOR_ID)
def test_flavor_search_member_find_flavor(self):
flavor_task = task.GetFlavorData()
found_id = flavor_task._flavor_search(MEMBER_1)
self.assertEqual(found_id, a10constants.MOCK_FLAVOR_ID)
def test_flavor_search_pool_find_flavor(self):
flavor_task = task.GetFlavorData()
found_id = flavor_task._flavor_search(POOL)
self.assertEqual(found_id, a10constants.MOCK_FLAVOR_ID)
def test_flavor_search_loadbalancer_find_flavor(self):
flavor_task = task.GetFlavorData()
found_id = flavor_task._flavor_search(LB)
self.assertEqual(found_id, a10constants.MOCK_FLAVOR_ID)
