def get_create_vthunder_flow(self):
"""Flow to create a spare amphora."""
create_vthunder_flow = linear_flow.Flow(constants.CREATE_AMPHORA_FLOW)
sf_name = a10constants.SPARE_VTHUNDER_CREATE
create_vthunder_flow.add(
database_tasks.CreateAmphoraInDB(name=sf_name + '-' +
constants.CREATE_AMPHORA_INDB,
provides=constants.AMPHORA_ID))
create_vthunder_flow.add(
compute_tasks.ComputeCreate(name=sf_name + '-' +
constants.COMPUTE_CREATE,
requires=(
constants.AMPHORA_ID,
constants.BUILD_TYPE_PRIORITY,
),
provides=constants.COMPUTE_ID))
create_vthunder_flow.add(
database_tasks.UpdateAmphoraComputeId(
name=sf_name + '-' + constants.UPDATE_AMPHORA_COMPUTEID,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
create_vthunder_flow.add(
database_tasks.MarkAmphoraBootingInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_BOOTING_INDB,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
create_vthunder_flow.add(
compute_tasks.ComputeActiveWait(
name=sf_name + '-' + constants.COMPUTE_WAIT,
requires=(constants.COMPUTE_ID, constants.AMPHORA_ID),
provides=constants.COMPUTE_OBJ))
create_vthunder_flow.add(
database_tasks.UpdateAmphoraInfo(
name=sf_name + '-' + constants.UPDATE_AMPHORA_INFO,
requires=(constants.AMPHORA_ID, constants.COMPUTE_OBJ),
provides=constants.AMPHORA))
create_vthunder_flow.add(
a10_database_tasks.CreateSpareVThunderEntry(
requires=(constants.AMPHORA), provides=a10constants.VTHUNDER))
create_vthunder_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=sf_name + '-' + constants.AMP_COMPUTE_CONNECTIVITY_WAIT,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
return create_vthunder_flow
def _get_create_amp_for_lb_subflow(self, prefix, role):
"""Flow to create a new vThunder for lb."""
sf_name = prefix + '-' + constants.CREATE_AMP_FOR_LB_SUBFLOW
create_amp_for_lb_subflow = linear_flow.Flow(sf_name)
create_amp_for_lb_subflow.add(
database_tasks.CreateAmphoraInDB(name=sf_name + '-' +
constants.CREATE_AMPHORA_INDB,
provides=constants.AMPHORA_ID))
# VIP subnet integration at bootup
create_amp_for_lb_subflow.add(
database_tasks.ReloadLoadBalancer(
name=sf_name + '-' + constants.RELOADLOAD_BALANCER,
requires=constants.LOADBALANCER_ID,
provides=constants.LOADBALANCER))
require_server_group_id_condition = (
role in (constants.ROLE_BACKUP, constants.ROLE_MASTER)
and CONF.a10_nova.enable_anti_affinity)
if require_server_group_id_condition:
create_amp_for_lb_subflow.add(
compute_tasks.ComputeCreate(
name=sf_name + '-' + constants.COMPUTE_CREATE,
requires=(constants.AMPHORA_ID,
constants.BUILD_TYPE_PRIORITY,
constants.SERVER_GROUP_ID,
constants.LOADBALANCER),
provides=constants.COMPUTE_ID))
else:
create_amp_for_lb_subflow.add(
compute_tasks.ComputeCreate(
name=sf_name + '-' + constants.COMPUTE_CREATE,
requires=(constants.AMPHORA_ID,
constants.BUILD_TYPE_PRIORITY,
constants.LOADBALANCER),
provides=constants.COMPUTE_ID))
create_amp_for_lb_subflow.add(
database_tasks.UpdateAmphoraComputeId(
name=sf_name + '-' + constants.UPDATE_AMPHORA_COMPUTEID,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraBootingInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_BOOTING_INDB,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
create_amp_for_lb_subflow.add(
compute_tasks.ComputeActiveWait(
name=sf_name + '-' + constants.COMPUTE_WAIT,
requires=(constants.COMPUTE_ID, constants.AMPHORA_ID),
provides=constants.COMPUTE_OBJ))
create_amp_for_lb_subflow.add(
database_tasks.UpdateAmphoraInfo(
name=sf_name + '-' + constants.UPDATE_AMPHORA_INFO,
requires=(constants.AMPHORA_ID, constants.COMPUTE_OBJ),
provides=constants.AMPHORA))
# create vThunder entry in custom DB
create_amp_for_lb_subflow.add(
a10_database_tasks.CreateVThunderEntry(
name=sf_name + '-' + a10constants.CREATE_VTHUNDER_ENTRY,
requires=(constants.AMPHORA, constants.LOADBALANCER),
inject={
a10constants.ROLE: role,
a10constants.STATUS: constants.PENDING_CREATE
}))
# Get VThunder details from database
create_amp_for_lb_subflow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
name=sf_name + '-' + a10constants.VTHUNDER_BY_LB,
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
create_amp_for_lb_subflow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=sf_name + '-' +
a10constants.WAIT_FOR_VTHUNDER_CONNECTIVITY,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraAllocatedInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_ALLOCATED_INDB,
requires=(constants.AMPHORA, constants.LOADBALANCER_ID)))
create_amp_for_lb_subflow.add(
database_tasks.ReloadAmphora(name=sf_name + '-' +
constants.RELOAD_AMPHORA,
requires=constants.AMPHORA_ID,
provides=constants.AMPHORA))
create_amp_for_lb_subflow.add(
a10_network_tasks.GetLBResourceSubnet(
name=sf_name + '-' + a10constants.GET_LB_RESOURCE,
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.SUBNET))
create_amp_for_lb_subflow.add(
vthunder_tasks.AllowL2DSR(
name=sf_name + '-' + a10constants.ALLOW_L2DSR,
requires=(constants.SUBNET, constants.AMPHORA)))
if role == constants.ROLE_MASTER:
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraMasterInDB(
name=sf_name + '-' + constants.MARK_AMP_MASTER_INDB,
requires=constants.AMPHORA))
elif role == constants.ROLE_BACKUP:
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraBackupInDB(
name=sf_name + '-' + constants.MARK_AMP_BACKUP_INDB,
requires=constants.AMPHORA))
elif role == constants.ROLE_STANDALONE:
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraStandAloneInDB(
name=sf_name + '-' + constants.MARK_AMP_STANDALONE_INDB,
requires=constants.AMPHORA))
return create_amp_for_lb_subflow
def get_delete_pool_flow(self, members, health_mon, store, topology):
"""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(
vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
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))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
delete_pool_flow.add(
vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_MASTER_VTHUNDER,
requires=a10constants.VTHUNDER,
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 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))
# Interface delete.
delete_pool_flow.add(
a10_database_tasks.GetLoadBalancerListByProjectID(
requires=a10constants.VTHUNDER,
provides=a10constants.LOADBALANCERS_LIST))
delete_pool_flow.add(
a10_database_tasks.GetMemberListByProjectID(
requires=a10constants.VTHUNDER,
provides=a10constants.MEMBER_LIST))
delete_pool_flow.add(
a10_network_tasks.CalculateDelta(
requires=(constants.LOADBALANCER,
a10constants.LOADBALANCERS_LIST,
a10constants.MEMBER_LIST),
provides=constants.DELTAS))
delete_pool_flow.add(
a10_network_tasks.HandleNetworkDeltas(
requires=constants.DELTAS, provides=constants.ADDED_PORTS))
delete_pool_flow.add(
vthunder_tasks.AmphoraePostNetworkUnplug(
requires=(constants.LOADBALANCER, constants.ADDED_PORTS,
a10constants.VTHUNDER)))
delete_pool_flow.add(
database_tasks.GetAmphoraeFromLoadbalancer(
requires=constants.LOADBALANCER_ID,
provides=constants.AMPHORA))
delete_pool_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
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_create_vthunder_flow(self):
"""Flow to create a spare amphora."""
create_vthunder_flow = linear_flow.Flow(constants.CREATE_AMPHORA_FLOW)
sf_name = a10constants.SPARE_VTHUNDER_CREATE
create_vthunder_flow.add(
database_tasks.CreateAmphoraInDB(name=sf_name + '-' +
constants.CREATE_AMPHORA_INDB,
provides=constants.AMPHORA_ID))
create_vthunder_flow.add(
compute_tasks.ComputeCreate(name=sf_name + '-' +
constants.COMPUTE_CREATE,
requires=(
constants.AMPHORA_ID,
constants.BUILD_TYPE_PRIORITY,
),
provides=constants.COMPUTE_ID))
create_vthunder_flow.add(
database_tasks.UpdateAmphoraComputeId(
name=sf_name + '-' + constants.UPDATE_AMPHORA_COMPUTEID,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
create_vthunder_flow.add(
database_tasks.MarkAmphoraBootingInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_BOOTING_INDB,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
create_vthunder_flow.add(
compute_tasks.ComputeActiveWait(
name=sf_name + '-' + constants.COMPUTE_WAIT,
requires=(constants.COMPUTE_ID, constants.AMPHORA_ID),
provides=constants.COMPUTE_OBJ))
create_vthunder_flow.add(
database_tasks.UpdateAmphoraInfo(
name=sf_name + '-' + constants.UPDATE_AMPHORA_INFO,
requires=(constants.AMPHORA_ID, constants.COMPUTE_OBJ),
provides=constants.AMPHORA))
create_vthunder_flow.add(
a10_database_tasks.CreateSpareVThunderEntry(
requires=(constants.AMPHORA), provides=a10constants.VTHUNDER))
create_vthunder_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=sf_name + '-' + constants.AMP_COMPUTE_CONNECTIVITY_WAIT,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
create_vthunder_flow.add(
vthunder_tasks.EnableInterfaceOnSpare(
name=sf_name + '-' + a10constants.ENABLE_VTHUNDER_INTERFACE,
requires=(a10constants.VTHUNDER)))
create_vthunder_flow.add(
vthunder_tasks.UpdateAcosVersionInVthunderEntry(
name=sf_name + '-' +
a10constants.UPDATE_ACOS_VERSION_IN_VTHUNDER_ENTRY,
requires=(a10constants.VTHUNDER)))
create_vthunder_flow.add(
database_tasks.MarkAmphoraReadyInDB(
name=sf_name + '-' + a10constants.MARK_AMPHORA_READY_INDB,
requires=(constants.AMPHORA)))
create_vthunder_flow.add(
self.get_glm_license_subflow(
prefix=a10constants.SPARE_VTHUNDER_CREATE,
role=a10constants.SPARE_VTHUNDER))
create_vthunder_flow.add(
vthunder_tasks.CreateHealthMonitorOnVThunder(
name=sf_name + '-' +
a10constants.CREATE_HEALTH_MONITOR_ON_SPARE,
requires=(a10constants.VTHUNDER)))
create_vthunder_flow.add(
a10_database_tasks.MarkVThunderStatusInDB(
requires=(a10constants.VTHUNDER),
inject={"status": a10constants.READY}))
return create_vthunder_flow
def _get_vthunder_for_amphora_subflow(self, prefix, role):
"""Subflow to create lb in existing vThunder."""
sf_name = prefix + '-' + a10constants.LB_TO_VTHUNDER_SUBFLOW
vthunder_for_amphora_subflow = linear_flow.Flow(sf_name)
vthunder_for_amphora_subflow.add(
database_tasks.CreateAmphoraInDB(name=sf_name + '-' +
constants.CREATE_AMPHORA_INDB,
provides=constants.AMPHORA_ID))
vthunder_for_amphora_subflow.add(
a10_database_tasks.ValidateComputeForProject(
name=sf_name + '-' + a10constants.VALIDATE_COMPUTE_FOR_PROJECT,
requires=constants.LOADBALANCER,
inject={"role": role},
provides=constants.COMPUTE_ID))
# if no compute, use spare vThunder and prepare network for spare vThunder
vthunder_for_amphora_subflow.add(
a10_database_tasks.GetSpareComputeForProject(
name=sf_name + '-' +
a10constants.GET_SPARE_COMPUTE_FOR_PROJECT,
requires=constants.COMPUTE_ID,
provides=(constants.COMPUTE_ID, a10constants.SPARE_VTHUNDER)))
vthunder_for_amphora_subflow.add(
a10_network_tasks.PlugVipNetworkOnSpare(
name=sf_name + '-' + a10constants.PLUG_VIP_NETWORK_ON_SPARE,
requires=(a10constants.SPARE_VTHUNDER, constants.LOADBALANCER),
provides=a10constants.ADDED_NETWORK))
vthunder_for_amphora_subflow.add(
vthunder_tasks.SparePostNetworkPlug(
name=sf_name + '-' + a10constants.POST_SPARE_PLUG_NETWORK,
rebind={a10constants.VTHUNDER: a10constants.SPARE_VTHUNDER},
requires=(a10constants.ADDED_NETWORK)))
vthunder_for_amphora_subflow.add(
a10_database_tasks.GetVThunderAmphora(
name=sf_name + '-' + a10constants.GET_VTHUNDER_AMPHORA,
rebind={a10constants.VTHUNDER: a10constants.SPARE_VTHUNDER},
provides=constants.AMPHORA))
vthunder_for_amphora_subflow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=sf_name + '-' + constants.AMP_COMPUTE_CONNECTIVITY_WAIT,
rebind={a10constants.VTHUNDER: a10constants.SPARE_VTHUNDER},
requires=(constants.AMPHORA)))
vthunder_for_amphora_subflow.add(
vthunder_tasks.EnableInterfaceOnSpare(
name=sf_name + '-' + a10constants.ENABLE_VTHUNDER_INTERFACE,
rebind={a10constants.VTHUNDER: a10constants.SPARE_VTHUNDER},
requires=(a10constants.ADDED_NETWORK)))
vthunder_for_amphora_subflow.add(
database_tasks.UpdateAmphoraComputeId(
name=sf_name + '-' + constants.UPDATE_AMPHORA_COMPUTEID,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
vthunder_for_amphora_subflow.add(
compute_tasks.ComputeActiveWait(
name=sf_name + '-' + constants.COMPUTE_WAIT,
requires=(constants.COMPUTE_ID, constants.AMPHORA_ID),
provides=constants.COMPUTE_OBJ))
vthunder_for_amphora_subflow.add(
database_tasks.UpdateAmphoraInfo(
name=sf_name + '-' + constants.UPDATE_AMPHORA_INFO,
requires=(constants.AMPHORA_ID, constants.COMPUTE_OBJ),
provides=constants.AMPHORA))
# create vThunder entry in custom DB
vthunder_for_amphora_subflow.add(
a10_database_tasks.CreateVThunderEntry(
name=sf_name + '-' + a10constants.CREATE_VTHUNDER_ENTRY,
requires=(constants.AMPHORA, constants.LOADBALANCER),
inject={
"role": role,
"status": constants.PENDING_CREATE
}))
# Get VThunder details from database
vthunder_for_amphora_subflow.add(
a10_database_tasks.GetVThunderByLoadBalancer(
name=sf_name + '-' + a10constants.VTHUNDER_BY_LB,
requires=constants.LOADBALANCER,
provides=a10constants.VTHUNDER))
vthunder_for_amphora_subflow.add(
database_tasks.ReloadLoadBalancer(
name=sf_name + '-' + a10constants.RELOADLOAD_BALANCER,
requires=constants.LOADBALANCER_ID,
provides=constants.LOADBALANCER))
vthunder_for_amphora_subflow.add(
a10_network_tasks.GetLBResourceSubnet(
name=sf_name + '-' + a10constants.GET_LB_RESOURCE,
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.SUBNET))
vthunder_for_amphora_subflow.add(
a10_database_tasks.GetChildProjectsOfParentPartition(
name=sf_name + '-' + a10constants.GET_PROJECT_COUNT,
requires=[a10constants.VTHUNDER],
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=a10constants.PARTITION_PROJECT_LIST))
vthunder_for_amphora_subflow.add(
a10_database_tasks.CountLoadbalancersInProjectBySubnet(
name=sf_name + '-' + a10constants.GET_LB_COUNT_SUBNET,
requires=[
constants.SUBNET, a10constants.PARTITION_PROJECT_LIST
],
provides=a10constants.LB_COUNT_SUBNET))
vthunder_for_amphora_subflow.add(
a10_network_tasks.AllocateVIP(
name=sf_name + '-' + a10constants.ALLOCATE_VIP,
requires=[
constants.LOADBALANCER, a10constants.LB_COUNT_SUBNET
],
provides=constants.VIP))
vthunder_for_amphora_subflow.add(
database_tasks.UpdateVIPAfterAllocation(
name=sf_name + '-' + a10constants.UPDATE_VIP_AFTER_ALLOCATION,
requires=(constants.LOADBALANCER_ID, constants.VIP),
provides=constants.LOADBALANCER))
vthunder_for_amphora_subflow.add(
database_tasks.MarkAmphoraAllocatedInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_ALLOCATED_INDB,
requires=(constants.AMPHORA, constants.LOADBALANCER_ID)))
vthunder_for_amphora_subflow.add(
database_tasks.ReloadAmphora(name=sf_name + '-' +
constants.RELOAD_AMPHORA,
requires=constants.AMPHORA_ID,
provides=constants.AMPHORA))
if role == constants.ROLE_MASTER:
vthunder_for_amphora_subflow.add(
database_tasks.MarkAmphoraMasterInDB(
name=sf_name + '-' + constants.MARK_AMP_MASTER_INDB,
requires=constants.AMPHORA))
vthunder_for_amphora_subflow.add(
vthunder_tasks.UpdateAcosVersionInVthunderEntry(
name=sf_name + '-' +
a10constants.UPDATE_ACOS_VERSION_FOR_BACKUP_VTHUNDER,
requires=(a10constants.VTHUNDER)))
elif role == constants.ROLE_BACKUP:
vthunder_for_amphora_subflow.add(
database_tasks.MarkAmphoraBackupInDB(
name=sf_name + '-' + constants.MARK_AMP_BACKUP_INDB,
requires=constants.AMPHORA))
vthunder_for_amphora_subflow.add(
a10_database_tasks.GetBackupVThunderByLoadBalancer(
name=sf_name + '-' + a10constants.BACKUP_VTHUNDER,
requires=constants.LOADBALANCER,
provides=a10constants.BACKUP_VTHUNDER))
vthunder_for_amphora_subflow.add(
vthunder_tasks.UpdateAcosVersionInVthunderEntry(
name=sf_name + '-' +
a10constants.UPDATE_ACOS_VERSION_FOR_BACKUP_VTHUNDER,
rebind={
a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER
}))
elif role == constants.ROLE_STANDALONE:
vthunder_for_amphora_subflow.add(
database_tasks.MarkAmphoraStandAloneInDB(
name=sf_name + '-' + constants.MARK_AMP_STANDALONE_INDB,
requires=constants.AMPHORA))
vthunder_for_amphora_subflow.add(
vthunder_tasks.UpdateAcosVersionInVthunderEntry(
name=sf_name + '-' +
a10constants.UPDATE_ACOS_VERSION_FOR_BACKUP_VTHUNDER,
requires=(a10constants.VTHUNDER)))
# If spare vThunder is used, remove spare vThunder the database
vthunder_for_amphora_subflow.add(
a10_database_tasks.DeleteStaleSpareVThunder(
name=sf_name + '-' + a10constants.DELETE_STALE_SPARE_VTHUNDER,
requires=(a10constants.SPARE_VTHUNDER)))
return vthunder_for_amphora_subflow
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_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_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(vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
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
if topology == constants.TOPOLOGY_SINGLE:
create_member_flow.add(
vthunder_tasks.AmphoraePostMemberNetworkPlug(
requires=(
constants.LOADBALANCER,
constants.ADDED_PORTS,
a10constants.VTHUNDER)))
create_member_flow.add(vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.VTHUNDER_CONNECTIVITY_WAIT,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
create_member_flow.add(
vthunder_tasks.EnableInterfaceForMembers(
requires=[
constants.ADDED_PORTS,
constants.LOADBALANCER,
a10constants.VTHUNDER]))
# 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, a10constants.VTHUNDER),
provides=a10constants.BACKUP_VTHUNDER))
create_member_flow.add(vthunder_tasks.VThunderComputeConnectivityWait(
name="backup_compute_conn_wait_before_probe_device",
requires=constants.AMPHORA,
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER}))
create_member_flow.add(vthunder_tasks.VCSSyncWait(
name="vcs_sync_wait_before_probe_device",
requires=a10constants.VTHUNDER))
create_member_flow.add(
vthunder_tasks.AmphoraePostMemberNetworkPlug(
requires=(
constants.LOADBALANCER,
constants.ADDED_PORTS,
a10constants.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=a10constants.MASTER_CONNECTIVITY_WAIT,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
create_member_flow.add(vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.BACKUP_CONNECTIVITY_WAIT,
requires=constants.AMPHORA,
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER}))
create_member_flow.add(vthunder_tasks.VCSSyncWait(
name="backup-plug-wait-vcs-ready",
requires=a10constants.VTHUNDER))
create_member_flow.add(vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_MASTER_VTHUNDER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
create_member_flow.add(a10_database_tasks.GetBackupVThunderByLoadBalancer(
name="get_backup_vThunder_after_get_master",
requires=(constants.LOADBALANCER, a10constants.VTHUNDER),
provides=a10constants.BACKUP_VTHUNDER))
create_member_flow.add(
vthunder_tasks.EnableInterfaceForMembers(
name=a10constants.ENABLE_MASTER_VTHUNDER_INTERFACE,
requires=[
constants.ADDED_PORTS,
constants.LOADBALANCER,
a10constants.VTHUNDER]))
create_member_flow.add(vthunder_tasks.AmphoraePostMemberNetworkPlug(
name="amphorae-post-member-network-plug-for-master",
requires=(constants.LOADBALANCER, constants.ADDED_PORTS,
a10constants.VTHUNDER)))
create_member_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.CONNECTIVITY_WAIT_FOR_MASTER_VTHUNDER,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
create_member_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.CONNECTIVITY_WAIT_FOR_BACKUP_VTHUNDER,
rebind={
a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER},
requires=constants.AMPHORA))
create_member_flow.add(vthunder_tasks.VCSSyncWait(
name="member_enable_interface_vcs_sync_wait",
requires=a10constants.VTHUNDER))
create_member_flow.add(vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_VTHUNDER_MASTER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
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())
create_member_flow.add(a10_database_tasks.CountMembersWithIP(
requires=constants.MEMBER, provides=a10constants.MEMBER_COUNT_IP
))
create_member_flow.add(vthunder_tasks.AllowLoadbalancerForwardWithAnySource(
name=a10constants.ALLOW_NO_SNAT,
requires=(constants.MEMBER, constants.AMPHORA)))
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_flow(self, topology):
"""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(vthunder_tasks.VthunderInstanceBusy(
requires=a10constants.COMPUTE_BUSY))
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(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(
name=a10constants.VTHUNDER_CONNECTIVITY_WAIT,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
delete_member_flow.add(
a10_database_tasks.GetBackupVThunderByLoadBalancer(
name=a10constants.GET_BACKUP_VTHUNDER_BY_LB,
requires=(constants.LOADBALANCER, a10constants.VTHUNDER),
provides=a10constants.BACKUP_VTHUNDER))
delete_member_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.BACKUP_CONNECTIVITY_WAIT + "-before-unplug",
requires=constants.AMPHORA,
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER}))
delete_member_flow.add(
vthunder_tasks.AmphoraePostNetworkUnplug(
name=a10constants.AMPHORA_POST_NETWORK_UNPLUG_FOR_BACKUP_VTHUNDER,
requires=(constants.LOADBALANCER, constants.ADDED_PORTS),
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER}))
delete_member_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.BACKUP_CONNECTIVITY_WAIT,
requires=constants.AMPHORA,
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER}))
delete_member_flow.add(vthunder_tasks.VCSSyncWait(
name='member-unplug-' + a10constants.VCS_SYNC_WAIT,
requires=a10constants.VTHUNDER))
delete_member_flow.add(vthunder_tasks.GetMasterVThunder(
name=a10constants.GET_VTHUNDER_MASTER,
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
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.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 get_new_lb_networking_subflow(self, topology):
"""Subflow to setup networking for amphora"""
new_LB_net_subflow = linear_flow.Flow(
constants.LOADBALANCER_NETWORKING_SUBFLOW)
new_LB_net_subflow.add(
a10_network_tasks.PlugVIP(requires=constants.LOADBALANCER,
provides=constants.AMPS_DATA))
new_LB_net_subflow.add(
a10_network_tasks.ApplyQos(requires=(constants.LOADBALANCER,
constants.AMPS_DATA,
constants.UPDATE_DICT)))
new_LB_net_subflow.add(
database_tasks.UpdateAmphoraeVIPData(requires=constants.AMPS_DATA))
new_LB_net_subflow.add(
database_tasks.ReloadLoadBalancer(
name=constants.RELOAD_LB_AFTER_PLUG_VIP,
requires=constants.LOADBALANCER_ID,
provides=constants.LOADBALANCER))
new_LB_net_subflow.add(
a10_network_tasks.GetAmphoraeNetworkConfigs(
requires=constants.LOADBALANCER,
provides=constants.AMPHORAE_NETWORK_CONFIG))
new_LB_net_subflow.add(
database_tasks.GetAmphoraeFromLoadbalancer(
requires=constants.LOADBALANCER, provides=constants.AMPHORA))
new_LB_net_subflow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.MASTER_CONNECTIVITY_WAIT,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
new_LB_net_subflow.add(
vthunder_tasks.EnableInterface(requires=a10constants.VTHUNDER))
new_LB_net_subflow.add(
a10_database_tasks.MarkVThunderStatusInDB(
name=a10constants.MARK_VTHUNDER_MASTER_ACTIVE_IN_DB,
requires=a10constants.VTHUNDER,
inject={a10constants.STATUS: constants.ACTIVE}))
if topology == constants.TOPOLOGY_ACTIVE_STANDBY:
new_LB_net_subflow.add(
vthunder_tasks.CreateHealthMonitorOnVThunder(
name=a10constants.CREATE_HEALTH_MONITOR_ON_VTHUNDER_MASTER,
requires=a10constants.VTHUNDER))
new_LB_net_subflow.add(
a10_database_tasks.GetBackupVThunderByLoadBalancer(
name=a10constants.GET_BACKUP_VTHUNDER_BY_LB,
requires=constants.LOADBALANCER,
provides=a10constants.BACKUP_VTHUNDER))
new_LB_net_subflow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.BACKUP_CONNECTIVITY_WAIT,
rebind={
a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER
},
requires=constants.AMPHORA))
new_LB_net_subflow.add(
vthunder_tasks.EnableInterface(
name=a10constants.BACKUP_ENABLE_INTERFACE,
rebind={
a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER
}))
new_LB_net_subflow.add(
a10_database_tasks.MarkVThunderStatusInDB(
name=a10constants.MARK_VTHUNDER_BACKUP_ACTIVE_IN_DB,
rebind={
a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER
},
inject={a10constants.STATUS: constants.ACTIVE}))
return new_LB_net_subflow
def get_delete_load_balancer_flow(self, lb, deleteCompute, cascade):
"""Flow to delete 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(
requires=a10constants.VTHUNDER,
inject={"status": constants.PENDING_DELETE}))
delete_LB_flow.add(
vthunder_tasks.SetupDeviceNetworkMap(
requires=a10constants.VTHUNDER,
provides=a10constants.VTHUNDER))
delete_LB_flow.add(
compute_tasks.NovaServerGroupDelete(
requires=constants.SERVER_GROUP_ID))
delete_LB_flow.add(
database_tasks.MarkLBAmphoraeHealthBusy(
requires=constants.LOADBALANCER))
if cascade:
(pools_listeners_delete,
store) = self._get_cascade_delete_pools_listeners_flow(lb)
delete_LB_flow.add(pools_listeners_delete)
delete_LB_flow.add(
a10_database_tasks.GetFlavorData(
rebind={a10constants.LB_RESOURCE: constants.LOADBALANCER},
provides=constants.FLAVOR_DATA))
delete_LB_flow.add(
a10_database_tasks.CountLoadbalancersWithFlavor(
requires=(constants.LOADBALANCER, a10constants.VTHUNDER),
provides=a10constants.LB_COUNT))
delete_LB_flow.add(self.get_delete_lb_vrid_subflow())
if CONF.a10_global.network_type == 'vlan':
delete_LB_flow.add(
vthunder_tasks.DeleteInterfaceTagIfNotInUseForLB(
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(
database_tasks.GetAmphoraeFromLoadbalancer(
requires=constants.LOADBALANCER, provides=constants.AMPHORA))
delete_LB_flow.add(
a10_database_tasks.GetLoadBalancerListByProjectID(
requires=a10constants.VTHUNDER,
provides=a10constants.LOADBALANCERS_LIST))
if not deleteCompute:
delete_LB_flow.add(
a10_network_tasks.CalculateDelta(
requires=(constants.LOADBALANCER,
a10constants.LOADBALANCERS_LIST),
provides=constants.DELTAS))
delete_LB_flow.add(
a10_network_tasks.HandleNetworkDeltas(
requires=constants.DELTAS, provides=constants.ADDED_PORTS))
delete_LB_flow.add(
vthunder_tasks.AmphoraePostNetworkUnplug(
name=a10constants.AMPHORA_POST_NETWORK_UNPLUG,
requires=(constants.LOADBALANCER, constants.ADDED_PORTS,
a10constants.VTHUNDER)))
delete_LB_flow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=a10constants.VTHUNDER_CONNECTIVITY_WAIT,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
delete_LB_flow.add(
virtual_server_tasks.DeleteVirtualServerTask(
requires=(constants.LOADBALANCER, a10constants.VTHUNDER)))
delete_LB_flow.add(
nat_pool_tasks.NatPoolDelete(requires=(constants.LOADBALANCER,
a10constants.VTHUNDER,
a10constants.LB_COUNT,
constants.FLAVOR_DATA)))
if deleteCompute:
delete_LB_flow.add(
compute_tasks.DeleteAmphoraeOnLoadBalancer(
requires=constants.LOADBALANCER))
delete_LB_flow.add(
a10_database_tasks.MarkVThunderStatusInDB(
name=a10constants.MARK_VTHUNDER_MASTER_DELETED_IN_DB,
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))
if not deleteCompute:
delete_LB_flow.add(
vthunder_tasks.WriteMemory(requires=a10constants.VTHUNDER))
delete_LB_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
name=a10constants.SET_THUNDER_UPDATE_AT,
requires=a10constants.VTHUNDER))
delete_LB_flow.add(
a10_database_tasks.GetBackupVThunderByLoadBalancer(
requires=constants.LOADBALANCER,
provides=a10constants.BACKUP_VTHUNDER))
delete_LB_flow.add(
a10_database_tasks.MarkVThunderStatusInDB(
name=a10constants.MARK_VTHUNDER_BACKUP_DELETED_IN_DB,
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER},
inject={"status": constants.DELETED}))
delete_LB_flow.add(
a10_database_tasks.SetThunderUpdatedAt(
name=a10constants.SET_THUNDER_BACKUP_UPDATE_AT,
rebind={a10constants.VTHUNDER: a10constants.BACKUP_VTHUNDER}))
return (delete_LB_flow, store)
def _get_create_amp_for_lb_subflow(self, prefix, role):
"""Create a new amphora for lb."""
sf_name = prefix + '-' + constants.CREATE_AMP_FOR_LB_SUBFLOW
create_amp_for_lb_subflow = linear_flow.Flow(sf_name)
create_amp_for_lb_subflow.add(
database_tasks.CreateAmphoraInDB(name=sf_name + '-' +
constants.CREATE_AMPHORA_INDB,
provides=constants.AMPHORA_ID))
require_server_group_id_condition = (
role in (constants.ROLE_BACKUP, constants.ROLE_MASTER)
and CONF.nova.enable_anti_affinity)
if False:
create_amp_for_lb_subflow.add(
cert_task.GenerateServerPEMTask(name=sf_name + '-' +
constants.GENERATE_SERVER_PEM,
provides=constants.SERVER_PEM))
create_amp_for_lb_subflow.add(
database_tasks.UpdateAmphoraDBCertExpiration(
name=sf_name + '-' + constants.UPDATE_CERT_EXPIRATION,
requires=(constants.AMPHORA_ID, constants.SERVER_PEM)))
if require_server_group_id_condition:
create_amp_for_lb_subflow.add(
compute_tasks.CertComputeCreate(
name=sf_name + '-' + constants.CERT_COMPUTE_CREATE,
requires=(
constants.AMPHORA_ID,
constants.SERVER_PEM,
constants.BUILD_TYPE_PRIORITY,
constants.SERVER_GROUP_ID,
),
provides=constants.COMPUTE_ID))
else:
create_amp_for_lb_subflow.add(
compute_tasks.CertComputeCreate(
name=sf_name + '-' + constants.CERT_COMPUTE_CREATE,
requires=(
constants.AMPHORA_ID,
constants.SERVER_PEM,
constants.BUILD_TYPE_PRIORITY,
),
provides=constants.COMPUTE_ID))
else:
if require_server_group_id_condition:
create_amp_for_lb_subflow.add(
compute_tasks.ComputeCreate(
name=sf_name + '-' + constants.COMPUTE_CREATE,
requires=(
constants.AMPHORA_ID,
constants.BUILD_TYPE_PRIORITY,
constants.SERVER_GROUP_ID,
),
provides=constants.COMPUTE_ID))
else:
create_amp_for_lb_subflow.add(
compute_tasks.ComputeCreate(
name=sf_name + '-' + constants.COMPUTE_CREATE,
requires=(
constants.AMPHORA_ID,
constants.BUILD_TYPE_PRIORITY,
),
provides=constants.COMPUTE_ID))
create_amp_for_lb_subflow.add(
database_tasks.UpdateAmphoraComputeId(
name=sf_name + '-' + constants.UPDATE_AMPHORA_COMPUTEID,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraBootingInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_BOOTING_INDB,
requires=(constants.AMPHORA_ID, constants.COMPUTE_ID)))
create_amp_for_lb_subflow.add(
compute_tasks.ComputeActiveWait(
name=sf_name + '-' + constants.COMPUTE_WAIT,
requires=(constants.COMPUTE_ID, constants.AMPHORA_ID),
provides=constants.COMPUTE_OBJ))
create_amp_for_lb_subflow.add(
database_tasks.UpdateAmphoraInfo(
name=sf_name + '-' + constants.UPDATE_AMPHORA_INFO,
requires=(constants.AMPHORA_ID, constants.COMPUTE_OBJ),
provides=constants.AMPHORA))
# create vThunder entry in custom DB
create_amp_for_lb_subflow.add(
database_tasks.ReloadLoadBalancer(
name=sf_name + '-' + 'reload_loadbalancer',
requires=constants.LOADBALANCER_ID,
provides=constants.LOADBALANCER))
create_amp_for_lb_subflow.add(
a10_database_tasks.CreteVthunderEntry(
name=sf_name + '-' + 'create_vThunder_entry_in_database',
requires=(constants.AMPHORA, constants.LOADBALANCER)))
# Get VThunder details from database
create_amp_for_lb_subflow.add(
a10_database_tasks.GetVThunderByLoadBalancerID(
requires=constants.LOADBALANCER_ID,
provides=a10constants.VTHUNDER))
create_amp_for_lb_subflow.add(
vthunder_tasks.VThunderComputeConnectivityWait(
name=sf_name + '-' + constants.AMP_COMPUTE_CONNECTIVITY_WAIT,
requires=(a10constants.VTHUNDER, constants.AMPHORA)))
#create_amp_for_lb_subflow.add(amphora_driver_tasks.AmphoraFinalize(
# name=sf_name + '-' + constants.AMPHORA_FINALIZE,
# requires=constants.AMPHORA))
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraAllocatedInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_ALLOCATED_INDB,
requires=(constants.AMPHORA, constants.LOADBALANCER_ID)))
create_amp_for_lb_subflow.add(
database_tasks.ReloadAmphora(name=sf_name + '-' +
constants.RELOAD_AMPHORA,
requires=constants.AMPHORA_ID,
provides=constants.AMPHORA))
if role == constants.ROLE_MASTER:
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraMasterInDB(
name=sf_name + '-' + constants.MARK_AMP_MASTER_INDB,
requires=constants.AMPHORA))
elif role == constants.ROLE_BACKUP:
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraBackupInDB(
name=sf_name + '-' + constants.MARK_AMP_BACKUP_INDB,
requires=constants.AMPHORA))
elif role == constants.ROLE_STANDALONE:
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraStandAloneInDB(
name=sf_name + '-' + constants.MARK_AMP_STANDALONE_INDB,
requires=constants.AMPHORA))
return create_amp_for_lb_subflow
