def get_delete_health_monitor_flow(self, topology):
"""Create a flow to delete a health monitor
:returns: The flow for deleting a health monitor
"""
delete_hm_flow = linear_flow.Flow(constants.DELETE_HEALTH_MONITOR_FLOW)
delete_hm_flow.add(
lifecycle_tasks.HealthMonitorToErrorOnRevertTask(requires=[
constants.HEALTH_MON, constants.LISTENERS,
constants.LOADBALANCER
]))
delete_hm_flow.add(
vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
delete_hm_flow.add(
database_tasks.MarkHealthMonitorPendingDeleteInDB(
requires=constants.HEALTH_MON))
delete_hm_flow.add(
model_tasks.DeleteModelObject(
rebind={constants.OBJECT: constants.HEALTH_MON}))
delete_hm_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
delete_hm_flow.add(
vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_MASTER_VTHUNDER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
delete_hm_flow.add(self.get_delete_health_monitor_vthunder_subflow())
delete_hm_flow.add(
database_tasks.DeleteHealthMonitorInDB(
requires=constants.HEALTH_MON))
delete_hm_flow.add(
database_tasks.DecrementHealthMonitorQuota(
requires=constants.HEALTH_MON))
delete_hm_flow.add(
database_tasks.UpdatePoolMembersOperatingStatusInDB(
requires=constants.POOL,
inject={constants.OPERATING_STATUS: constants.NO_MONITOR}))
delete_hm_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
delete_hm_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
delete_hm_flow.add(
vthunder_tasks.WriteMemory(
name=a10constants.WRITE_MEM_FOR_LOCAL_PARTITION,
requires=(a10constants.VTHUNDER)))
delete_hm_flow.add(
vthunder_tasks.WriteMemory(
name=a10constants.WRITE_MEM_FOR_SHARED_PARTITION,
requires=(a10constants.VTHUNDER,
a10constants.WRITE_MEM_SHARED_PART)))
delete_hm_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=(a10constants.VTHUNDER)))
return delete_hm_flow
def get_create_l7rule_flow(self):
"""Create a flow to create an L7 rule
:returns: The flow for creating an L7 rule
"""
create_l7rule_flow = linear_flow.Flow(constants.CREATE_L7RULE_FLOW)
create_l7rule_flow.add(
lifecycle_tasks.L7RuleToErrorOnRevertTask(requires=[
constants.L7RULE, constants.LISTENERS, constants.LOADBALANCER
]))
create_l7rule_flow.add(
database_tasks.MarkL7RulePendingCreateInDB(
requires=constants.L7RULE))
create_l7rule_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_l7rule_flow.add(
l7rule_tasks.CreateL7Rule(requires=[
constants.L7RULE, constants.LISTENERS, a10constants.VTHUNDER
]))
create_l7rule_flow.add(
database_tasks.MarkL7RuleActiveInDB(requires=constants.L7RULE))
create_l7rule_flow.add(
database_tasks.MarkL7PolicyActiveInDB(requires=constants.L7POLICY))
create_l7rule_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
create_l7rule_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
create_l7rule_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return create_l7rule_flow
def get_delete_pool_flow(self):
"""Create a flow to delete a pool
: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.ListenersUpdate(
requires=[constants.LOADBALANCER, constants.LISTENERS, a10constants.VTHUNDER]))
delete_pool_flow.add(persist_tasks.DeleteSessionPersistence(
requires=[a10constants.VTHUNDER, constants.POOL]))
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]))
return delete_pool_flow
def get_update_pool_flow(self):
"""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(database_tasks.MarkPoolPendingUpdateInDB(
requires=constants.POOL))
update_pool_flow.add(a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
update_pool = service_group_tasks.PoolUpdate(
requires=[constants.POOL, a10constants.VTHUNDER, constants.UPDATE_DICT],
provides=constants.POOL)
update_pool_flow.add(*self._get_sess_pers_subflow(update_pool))
update_pool_flow.add(virtual_port_tasks.ListenersUpdate(
requires=[constants.LOADBALANCER, constants.LISTENERS, 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]))
return update_pool_flow
def get_delete_l7rule_flow(self):
"""Create a flow to delete an L7 rule
:returns: The flow for deleting an L7 rule
"""
delete_l7rule_flow = linear_flow.Flow(constants.DELETE_L7RULE_FLOW)
delete_l7rule_flow.add(
lifecycle_tasks.L7RuleToErrorOnRevertTask(requires=[
constants.L7RULE, constants.LISTENERS, constants.LOADBALANCER
]))
delete_l7rule_flow.add(
database_tasks.MarkL7RulePendingDeleteInDB(
requires=constants.L7RULE))
delete_l7rule_flow.add(
model_tasks.DeleteModelObject(
rebind={constants.OBJECT: constants.L7RULE}))
delete_l7rule_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_l7rule_flow.add(
l7rule_tasks.DeleteL7Rule(requires=[
constants.L7RULE, constants.LISTENERS, a10constants.VTHUNDER
]))
delete_l7rule_flow.add(
database_tasks.DeleteL7RuleInDB(requires=constants.L7RULE))
delete_l7rule_flow.add(
database_tasks.MarkL7PolicyActiveInDB(requires=constants.L7POLICY))
delete_l7rule_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
delete_l7rule_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
return delete_l7rule_flow
def get_update_listener_flow(self):
"""Create a flow to update a listener
:returns: The flow for updating a listener
"""
update_listener_flow = linear_flow.Flow(constants.UPDATE_LISTENER_FLOW)
update_listener_flow.add(
lifecycle_tasks.ListenersToErrorOnRevertTask(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
update_listener_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
update_listener_flow.add(
virtual_port_tasks.ListenersUpdate(requires=[
constants.LOADBALANCER, constants.LISTENERS,
a10constants.VTHUNDER
]))
update_listener_flow.add(
database_tasks.UpdateListenerInDB(
requires=[constants.LISTENER, constants.UPDATE_DICT]))
update_listener_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
return update_listener_flow
def get_rack_vthunder_for_lb_subflow(self,
vthunder_conf,
prefix,
role=constants.ROLE_STANDALONE):
""" reload the loadbalancer and make entry in database"""
sf_name = prefix + '-' + constants.GET_AMPHORA_FOR_LB_SUBFLOW
amp_for_lb_flow = linear_flow.Flow(sf_name)
amp_for_lb_flow.add(
database_tasks.ReloadLoadBalancer(
name=sf_name + '-' + 'reload_loadbalancer',
requires=constants.LOADBALANCER_ID,
provides=constants.LOADBALANCER))
amp_for_lb_flow.add(
a10_database_tasks.CreateRackVthunderEntry(
name=sf_name + '-' + 'create_rack_vThunder_entry_in_database',
inject={a10constants.VTHUNDER_CONFIG: vthunder_conf},
requires=(constants.LOADBALANCER,
a10constants.VTHUNDER_CONFIG)))
amp_for_lb_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
amp_for_lb_flow.add(
vthunder_tasks.HandleACOSPartitionChange(
name=sf_name + '-' + a10constants.CHANGE_PARTITION,
requires=a10constants.VTHUNDER))
return amp_for_lb_flow
def get_vrrp_subflow(self, prefix):
sf_name = prefix + '-' + constants.GET_VRRP_SUBFLOW
vrrp_subflow = linear_flow.Flow(sf_name)
# TODO(omkartelee01) Need HA variables here
vrrp_subflow.add(a10_database_tasks.GetVThunderByLoadBalancer(
name=sf_name + '-' + a10constants.GET_LOADBALANCER_FROM_DB,
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
vrrp_subflow.add(a10_database_tasks.GetBackupVThunderByLoadBalancer(
name=sf_name + '-' + a10constants.GET_BACKUP_LOADBALANCER_FROM_DB,
requires=(constants.LOADBALANCER, a10constants.VTHUNDER),
provides=a10constants.BACKUP_VTHUNDER))
# Make sure devices are ready
vrrp_subflow.add(vthunder_tasks.VThunderComputeConnectivityWait(
name=sf_name + '-' + a10constants.WAIT_FOR_MASTER_SYNC + '-for-thunder',
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
vrrp_subflow.add(vthunder_tasks.VThunderComputeConnectivityWait(
name=sf_name + '-' + a10constants.WAIT_FOR_BACKUP_SYNC + '-for-thunder',
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER},
requires=(constants.AMPHORA)))
# VRRP Configuration
vrrp_subflow.add(a10_database_tasks.AddProjectSetIdDB(
name=sf_name + '-' + a10constants.ADD_VRRP_SET_ID_INDB,
requires=constants.LOADBALANCER,
provides=a10constants.SET_ID))
vrrp_subflow.add(vthunder_tasks.ConfigureVRRPMaster(
name=sf_name + '-' + a10constants.CONFIGURE_VRRP_FOR_MASTER_VTHUNDER,
requires=(a10constants.VTHUNDER, a10constants.SET_ID)))
vrrp_subflow.add(vthunder_tasks.ConfigureVRRPBackup(
name=sf_name + '-' + a10constants.CONFIGURE_VRRP_FOR_BACKUP_VTHUNDER,
requires=(a10constants.VTHUNDER, a10constants.SET_ID),
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER}))
vrrp_subflow.add(self._get_vrrp_status_subflow(sf_name))
return vrrp_subflow
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(amphora_driver_tasks.ListenersUpdate(
# requires=[constants.LOADBALANCER, constants.LISTENERS]))
# Get VThunder details from database
create_pool_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_pool_flow.add(
handler_service_group.PoolCreate(
requires=[constants.POOL, a10constants.VTHUNDER]))
create_pool_flow.add(
handler_virtual_port.ListenersUpdate(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
create_pool_flow.add(
database_tasks.MarkPoolActiveInDB(requires=constants.POOL))
create_pool_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
return create_pool_flow
def get_update_member_flow(self):
"""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(
database_tasks.MarkMemberPendingUpdateInDB(
requires=constants.MEMBER))
update_member_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
update_member_flow.add(
server_tasks.MemberUpdate(requires=(constants.MEMBER,
a10constants.VTHUNDER)))
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))
return update_member_flow
def get_delete_listener_flow(self):
"""Create a flow to delete a listener
:returns: The flow for deleting a listener
"""
delete_listener_flow = linear_flow.Flow(constants.DELETE_LISTENER_FLOW)
delete_listener_flow.add(lifecycle_tasks.ListenerToErrorOnRevertTask(
requires=constants.LISTENER))
# update delete flow task here
# Get VThunder details from database
delete_listener_flow.add(a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_listener_flow.add(handler_virtual_port.ListenerDelete(
requires=[constants.LOADBALANCER, constants.LISTENER, a10constants.VTHUNDER]))
delete_listener_flow.add(network_tasks.UpdateVIPForDelete(
requires=constants.LOADBALANCER))
delete_listener_flow.add(database_tasks.DeleteListenerInDB(
requires=constants.LISTENER))
delete_listener_flow.add(database_tasks.DecrementListenerQuota(
requires=constants.LISTENER))
delete_listener_flow.add(database_tasks.MarkLBActiveInDB(
requires=constants.LOADBALANCER))
return delete_listener_flow
def get_delete_listener_flow(self, topology):
"""Flow to delete a listener"""
delete_listener_flow = linear_flow.Flow(constants.DELETE_LISTENER_FLOW)
delete_listener_flow.add(lifecycle_tasks.ListenerToErrorOnRevertTask(
requires=constants.LISTENER))
delete_listener_flow.add(vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
delete_listener_flow.add(a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
delete_listener_flow.add(vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_MASTER_VTHUNDER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
delete_listener_flow.add(self.handle_ssl_cert_flow(flow_type='delete'))
delete_listener_flow.add(virtual_port_tasks.ListenerDelete(
requires=[constants.LOADBALANCER, constants.LISTENER, a10constants.VTHUNDER]))
delete_listener_flow.add(network_tasks.UpdateVIPForDelete(
requires=constants.LOADBALANCER))
delete_listener_flow.add(database_tasks.DeleteListenerInDB(
requires=constants.LISTENER))
delete_listener_flow.add(database_tasks.DecrementListenerQuota(
requires=constants.LISTENER))
delete_listener_flow.add(database_tasks.MarkLBActiveInDB(
requires=constants.LOADBALANCER))
delete_listener_flow.add(vthunder_tasks.WriteMemory(
requires=a10constants.VTHUNDER))
delete_listener_flow.add(a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return delete_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_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_delete_l7policy_flow(self):
"""Create a flow to delete an L7 policy
:returns: The flow for deleting an L7 policy
"""
delete_l7policy_flow = linear_flow.Flow(constants.DELETE_L7POLICY_FLOW)
delete_l7policy_flow.add(
lifecycle_tasks.L7PolicyToErrorOnRevertTask(requires=[
constants.L7POLICY, constants.LISTENERS, constants.LOADBALANCER
]))
delete_l7policy_flow.add(
database_tasks.MarkL7PolicyPendingDeleteInDB(
requires=constants.L7POLICY))
delete_l7policy_flow.add(
model_tasks.DeleteModelObject(
rebind={constants.OBJECT: constants.L7POLICY}))
#delete_l7policy_flow.add(amphora_driver_tasks.ListenersUpdate(
# requires=[constants.LOADBALANCER, constants.LISTENERS]))
delete_l7policy_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_l7policy_flow.add(
handler_l7policy.DeleteL7Policy(
requires=[constants.L7POLICY, a10constants.VTHUNDER]))
delete_l7policy_flow.add(
database_tasks.DeleteL7PolicyInDB(requires=constants.L7POLICY))
delete_l7policy_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
return delete_l7policy_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 = service_group_tasks.PoolCreate(
requires=[constants.POOL, a10constants.VTHUNDER],
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))
return create_pool_flow
def get_create_health_monitor_flow(self):
"""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(
database_tasks.MarkHealthMonitorPendingCreateInDB(
requires=constants.HEALTH_MON))
# create_hm_flow.add(amphora_driver_tasks.ListenersUpdate(
# requires=[constants.LOADBALANCER, constants.LISTENERS]))
create_hm_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_hm_flow.add(
handler_health_monitor.CreateAndAssociateHealthMonitor(
requires=[constants.HEALTH_MON, a10constants.VTHUNDER]))
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]))
return create_hm_flow
def get_create_l7policy_flow(self):
"""Create a flow to create an L7 policy
:returns: The flow for creating an L7 policy
"""
create_l7policy_flow = linear_flow.Flow(constants.CREATE_L7POLICY_FLOW)
create_l7policy_flow.add(
lifecycle_tasks.L7PolicyToErrorOnRevertTask(requires=[
constants.L7POLICY, constants.LISTENERS, constants.LOADBALANCER
]))
create_l7policy_flow.add(
database_tasks.MarkL7PolicyPendingCreateInDB(
requires=constants.L7POLICY))
#create_l7policy_flow.add(amphora_driver_tasks.ListenersUpdate(
# requires=[constants.LOADBALANCER, constants.LISTENERS]))
create_l7policy_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_l7policy_flow.add(
handler_l7policy.CreateL7Policy(requires=[
constants.L7POLICY, constants.LISTENERS, a10constants.VTHUNDER
]))
create_l7policy_flow.add(
database_tasks.MarkL7PolicyActiveInDB(requires=constants.L7POLICY))
create_l7policy_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
return create_l7policy_flow
def get_vrrp_subflow(self, prefix):
sf_name = prefix + '-' + constants.GET_VRRP_SUBFLOW
vrrp_subflow = linear_flow.Flow(sf_name)
# TODO(omkartelee01) Need HA variables here
vrrp_subflow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
name=sf_name + '-' + a10constants.GET_LOADBALANCER_FROM_DB,
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
vrrp_subflow.add(
a10_database_tasks.GetBackupVThunderByLoadBalancer(
name=sf_name + '-' +
a10constants.GET_BACKUP_LOADBALANCER_FROM_DB,
requires=constants.LOADBALANCER,
provides=a10constants.BACKUP_VTHUNDER))
# VRRP Configuration
vrrp_subflow.add(
vthunder_tasks.ConfigureVRRPMaster(
name=sf_name + '-' +
a10constants.CONFIGURE_VRRP_FOR_MASTER_VTHUNDER,
requires=(a10constants.VTHUNDER)))
vrrp_subflow.add(
vthunder_tasks.ConfigureVRRPBackup(
name=sf_name + '-' +
a10constants.CONFIGURE_VRRP_FOR_BACKUP_VTHUNDER,
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER}))
vrrp_subflow.add(self._get_vrrp_status_subflow(sf_name))
return vrrp_subflow
def get_delete_rack_listener_flow(self):
"""Flow to delete a rack listener """
delete_listener_flow = linear_flow.Flow(constants.DELETE_LISTENER_FLOW)
delete_listener_flow.add(
lifecycle_tasks.ListenerToErrorOnRevertTask(
requires=constants.LISTENER))
delete_listener_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_listener_flow.add(self.handle_ssl_cert_flow(flow_type='delete'))
delete_listener_flow.add(
virtual_port_tasks.ListenerDelete(requires=[
constants.LOADBALANCER, constants.LISTENER,
a10constants.VTHUNDER
]))
delete_listener_flow.add(
database_tasks.DeleteListenerInDB(requires=constants.LISTENER))
delete_listener_flow.add(
database_tasks.DecrementListenerQuota(requires=constants.LISTENER))
delete_listener_flow.add(
database_tasks.MarkLBActiveInDB(requires=constants.LOADBALANCER))
delete_listener_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
delete_listener_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
requires=a10constants.VTHUNDER))
return delete_listener_flow
def get_update_load_balancer_flow(self):
"""Creates a flow to update a load balancer.
:returns: The flow for update a 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(
name="set load balancer status PENDING_UPDATE",
requires=a10constants.VTHUNDER,
inject={"status": constants.PENDING_UPDATE}))
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]))
update_LB_flow.add(
virtual_server_tasks.UpdateVirtualServerTask(
requires=(constants.LOADBALANCER, a10constants.VTHUNDER)))
update_LB_flow.add(
database_tasks.UpdateLoadbalancerInDB(
requires=[constants.LOADBALANCER, constants.UPDATE_DICT]))
update_LB_flow.add(
database_tasks.MarkLBActiveInDB(requires=constants.LOADBALANCER))
return update_LB_flow
def get_create_listener_flow(self):
"""Flow to create a 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(
virtual_port_tasks.ListenerCreate(requires=[
constants.LOADBALANCER, constants.LISTENER,
a10constants.VTHUNDER
]))
create_listener_flow.add(
a10_network_tasks.UpdateVIP(requires=constants.LOADBALANCER))
create_listener_flow.add(
a10_database_tasks.MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENER]))
create_listener_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
return create_listener_flow
def get_rack_vthunder_create_listener_flow(self, project_id):
"""Create a flow to create a rack listener
:returns: The flow for creating a rack listener
"""
create_listener_flow = linear_flow.Flow(constants.CREATE_LISTENER_FLOW)
create_listener_flow.add(
lifecycle_tasks.ListenersToErrorOnRevertTask(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
create_listener_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_listener_flow.add(
virtual_port_tasks.ListenersCreate(requires=[
constants.LOADBALANCER, constants.LISTENERS,
a10constants.VTHUNDER
]))
if project_id is None:
create_listener_flow.add(
network_tasks.UpdateVIP(requires=constants.LOADBALANCER))
create_listener_flow.add(
database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
return create_listener_flow
def get_update_l7policy_flow(self):
"""Create a flow to update an L7 policy
:returns: The flow for updating an L7 policy
"""
update_l7policy_flow = linear_flow.Flow(constants.UPDATE_L7POLICY_FLOW)
update_l7policy_flow.add(lifecycle_tasks.L7PolicyToErrorOnRevertTask(
requires=[constants.L7POLICY,
constants.LISTENERS,
constants.LOADBALANCER]))
update_l7policy_flow.add(database_tasks.MarkL7PolicyPendingUpdateInDB(
requires=constants.L7POLICY))
update_l7policy_flow.add(a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
update_l7policy_flow.add(
l7policy_tasks.UpdateL7Policy(
requires=[
constants.L7POLICY,
constants.LISTENERS,
a10constants.VTHUNDER,
constants.UPDATE_DICT]))
update_l7policy_flow.add(database_tasks.UpdateL7PolicyInDB(
requires=[constants.L7POLICY, constants.UPDATE_DICT]))
update_l7policy_flow.add(database_tasks.MarkL7PolicyActiveInDB(
requires=constants.L7POLICY))
update_l7policy_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENERS]))
update_l7policy_flow.add(vthunder_tasks.WriteMemory(
requires=a10constants.VTHUNDER))
return update_l7policy_flow
def test_get_vthunder_by_loadbalancer(self):
self.conf.config(group=a10constants.A10_GLOBAL_CONF_SECTION,
use_parent_partition=True)
mock_get_vthunder = task.GetVThunderByLoadBalancer()
mock_get_vthunder.vthunder_repo = mock.MagicMock()
mock_get_vthunder.vthunder_repo.get_vthunder_from_lb.return_value = None
vthunder = mock_get_vthunder.execute(LB)
self.assertEqual(vthunder, None)
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_delete_load_balancer_flow(self, lb, deleteCompute):
"""Creates a flow to delete a load balancer.
:returns: The flow for deleting a load balancer
"""
store = {}
delete_LB_flow = linear_flow.Flow(constants.DELETE_LOADBALANCER_FLOW)
delete_LB_flow.add(
lifecycle_tasks.LoadBalancerToErrorOnRevertTask(
requires=constants.LOADBALANCER))
delete_LB_flow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
delete_LB_flow.add(
a10_database_tasks.MarkVThunderStatusInDB(
name="set load balancer status PENDING_DELETE",
requires=a10constants.VTHUNDER,
inject={"status": constants.PENDING_DELETE}))
delete_LB_flow.add(
compute_tasks.NovaServerGroupDelete(
requires=constants.SERVER_GROUP_ID))
delete_LB_flow.add(
database_tasks.MarkLBAmphoraeHealthBusy(
requires=constants.LOADBALANCER))
delete_LB_flow.add(
virtual_server_tasks.DeleteVirtualServerTask(
requires=(constants.LOADBALANCER, a10constants.VTHUNDER)))
# delete_LB_flow.add(listeners_delete)
# delete_LB_flow.add(network_tasks.UnplugVIP(
# requires=constants.LOADBALANCER))
# delete_LB_flow.add(network_tasks.DeallocateVIP(
# requires=constants.LOADBALANCER))
if deleteCompute:
delete_LB_flow.add(
compute_tasks.DeleteAmphoraeOnLoadBalancer(
requires=constants.LOADBALANCER))
delete_LB_flow.add(
a10_database_tasks.MarkVThunderStatusInDB(
name="DELETED",
requires=a10constants.VTHUNDER,
inject={"status": constants.DELETED}))
delete_LB_flow.add(
database_tasks.MarkLBAmphoraeDeletedInDB(
requires=constants.LOADBALANCER))
delete_LB_flow.add(
database_tasks.DisableLBAmphoraeHealthMonitoring(
requires=constants.LOADBALANCER))
delete_LB_flow.add(
database_tasks.MarkLBDeletedInDB(requires=constants.LOADBALANCER))
delete_LB_flow.add(
database_tasks.DecrementLoadBalancerQuota(
requires=constants.LOADBALANCER))
return (delete_LB_flow, store)
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(
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))
return delete_member_flow
