AmpListenersUpdate
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to update the listeners on one amphora.
execute
(listeners, amphora_index, amphorae, timeout_dict=())[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
AmphoraCertUpload
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Upload a certificate to the amphora.
AmphoraComputeConnectivityWait
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
“Task to wait for the compute instance to be up.
AmphoraFinalize
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to finalize the amphora before any listeners are configured.
AmphoraGetDiagnostics
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to get diagnostics on the amphora and the loadbalancers.
AmphoraGetInfo
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to get information on an amphora.
AmphoraPostNetworkPlug
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to notify the amphora post network plug.
AmphoraPostVIPPlug
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to notify the amphora post VIP plug.
AmphoraUpdateVRRPInterface
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to get and update the VRRP interface device name from amphora.
AmphoraVRRPStart
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to start keepalived of all amphorae of a LB.
execute
(loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
AmphoraVRRPStop
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to stop keepalived of all amphorae of a LB.
execute
(loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
AmphoraVRRPUpdate
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to update the VRRP configuration of the loadbalancer amphorae.
AmphoraePostNetworkPlug
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to notify the amphorae post network plug.
AmphoraePostVIPPlug
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to notify the amphorae post VIP plug.
BaseAmphoraTask
(**kwargs)[source]¶Bases: taskflow.task.Task
Base task to load drivers common to the tasks.
ListenerDelete
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to delete the listener on the vip.
ListenerStart
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to start the listener on the vip.
ListenerStop
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to stop the listener on the vip.
ListenersStart
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to start all listeners on the vip.
ListenersUpdate
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.amphora_driver_tasks.BaseAmphoraTask
Task to update amphora with all specified listeners’ configurations.
BaseCertTask
(**kwargs)[source]¶Bases: taskflow.task.Task
Base task to load drivers common to the tasks.
GenerateServerPEMTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.cert_task.BaseCertTask
Create the server certs for the agent comm
Use the amphora_id for the CN
execute
(amphora_id)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
BaseComputeTask
(**kwargs)[source]¶Bases: taskflow.task.Task
Base task to load drivers common to the tasks.
CertComputeCreate
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.compute_tasks.ComputeCreate
ComputeActiveWait
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.compute_tasks.BaseComputeTask
Wait for the compute driver to mark the amphora active.
ComputeCreate
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.compute_tasks.BaseComputeTask
Create the compute instance for a new amphora.
ComputeDelete
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.compute_tasks.BaseComputeTask
execute
(amphora)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
DeleteAmphoraeOnLoadBalancer
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.compute_tasks.BaseComputeTask
Delete the amphorae on a load balancer.
Iterate through amphorae, deleting them
execute
(loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
NovaServerGroupCreate
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.compute_tasks.BaseComputeTask
NovaServerGroupDelete
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.compute_tasks.BaseComputeTask
execute
(server_group_id)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
AssociateFailoverAmphoraWithLBID
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Associate failover amphora with loadbalancer in the database.
BaseDatabaseTask
(**kwargs)[source]¶Bases: taskflow.task.Task
Base task to load drivers common to the tasks.
CountPoolChildrenForQuota
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Counts the pool child resources for quota management.
Since the children of pools are cleaned up by the sqlalchemy cascade delete settings, we need to collect the quota counts for the child objects early.
CreateAmphoraInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Task to create an initial amphora in the Database.
CreateVRRPGroupForLB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Create a VRRP group for a load balancer.
DecrementHealthMonitorQuota
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Decrements the health monitor quota for a project.
Since sqlalchemy will likely retry by itself always revert if it fails
DecrementListenerQuota
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Decrements the listener quota for a project.
Since sqlalchemy will likely retry by itself always revert if it fails
DecrementLoadBalancerQuota
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Decrements the load balancer quota for a project.
Since sqlalchemy will likely retry by itself always revert if it fails
DecrementMemberQuota
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Decrements the member quota for a project.
Since sqlalchemy will likely retry by itself always revert if it fails
DecrementPoolQuota
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Decrements the pool quota for a project.
Since sqlalchemy will likely retry by itself always revert if it fails
DeleteHealthMonitorInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Delete the health monitor in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
DeleteHealthMonitorInDBByPool
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.DeleteHealthMonitorInDB
Delete the health monitor in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
DeleteL7PolicyInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Delete the L7 policy in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
DeleteL7RuleInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Delete the L7 rule in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
DeleteListenerInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Delete the listener in the DB.
DeleteMemberInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Delete the member in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
DeletePoolInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Delete the pool in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
DisableAmphoraHealthMonitoring
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Disable amphora health monitoring.
This disables amphora health monitoring by removing it from the amphora_health table.
DisableLBAmphoraeHealthMonitoring
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Disable health monitoring on the LB amphorae.
This disables amphora health monitoring by removing it from the amphora_health table for each amphora on a load balancer.
GetAmphoraDetails
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Task to retrieve amphora network details.
GetAmphoraeFromLoadbalancer
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Task to pull the listeners from a loadbalancer.
GetListenersFromLoadbalancer
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Task to pull the listeners from a loadbalancer.
GetVipFromLoadbalancer
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Task to pull the vip from a loadbalancer.
MapLoadbalancerToAmphora
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Maps and assigns a load balancer to an amphora in the database.
execute
(loadbalancer_id, server_group_id=None)[source]¶Allocates an Amphora for the load balancer in the database.
Parameters: | loadbalancer_id – The load balancer id to map to an amphora |
---|---|
Returns: | Amphora ID if one was allocated, None if it was unable to allocate an Amphora |
revert
(result, loadbalancer_id, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
MarkAmphoraAllocatedInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Will mark an amphora as allocated to a load balancer in the database.
Assume sqlalchemy made sure the DB got retried sufficiently - so just abort
MarkAmphoraBackupInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks._MarkAmphoraRoleAndPriorityInDB
Alter the amphora role to: Backup.
MarkAmphoraBootingInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the amphora as booting in the database.
MarkAmphoraDeletedInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the amphora deleted in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkAmphoraHealthBusy
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark amphora health monitoring busy.
This prevents amphora failover by marking the amphora busy in the amphora_health table.
MarkAmphoraMasterInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks._MarkAmphoraRoleAndPriorityInDB
Alter the amphora role to: MASTER.
MarkAmphoraPendingDeleteInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the amphora pending delete in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkAmphoraPendingUpdateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the amphora pending update in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkAmphoraReadyInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
This task will mark an amphora as ready in the database.
Assume sqlalchemy made sure the DB got retried sufficiently - so just abort
MarkAmphoraStandAloneInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks._MarkAmphoraRoleAndPriorityInDB
Alter the amphora role to: Standalone.
MarkHealthMonitorActiveInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the health monitor ACTIVE in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkHealthMonitorPendingCreateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the health monitor pending create in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkHealthMonitorPendingDeleteInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the health monitor pending delete in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkHealthMonitorPendingUpdateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the health monitor pending update in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkL7PolicyActiveInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the l7policy ACTIVE in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkL7PolicyPendingCreateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the l7policy pending create in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkL7PolicyPendingDeleteInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the l7policy pending delete in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkL7PolicyPendingUpdateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the l7policy pending update in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkL7RuleActiveInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the l7rule ACTIVE in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkL7RulePendingCreateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the l7rule pending create in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkL7RulePendingDeleteInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the l7rule pending delete in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkL7RulePendingUpdateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the l7rule pending update in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkLBActiveInDB
(mark_subobjects=False, **kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the load balancer active in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkLBAmphoraeDeletedInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Task to mark a list of amphora deleted in the Database.
MarkLBAmphoraeHealthBusy
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark amphorae health monitoring busy for the LB.
This prevents amphorae failover by marking each amphora of a given load balancer busy in the amphora_health table.
MarkLBAndListenersActiveInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the load balancer and specified listeners active in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkLBDeletedInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the load balancer deleted in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkLBPendingDeleteInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the load balancer pending delete in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkListenerActiveInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the listener active in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkListenerDeletedInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the listener deleted in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkListenerPendingDeleteInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the listener pending delete in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkMemberActiveInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the member ACTIVE in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkMemberPendingCreateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the member pending create in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkMemberPendingDeleteInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the member pending delete in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkMemberPendingUpdateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the member pending update in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkPoolActiveInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the pool ACTIVE in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkPoolPendingCreateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the pool pending create in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkPoolPendingDeleteInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the pool pending delete in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
MarkPoolPendingUpdateInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Mark the pool pending update in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
ReloadAmphora
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Get an amphora object from the database.
ReloadLoadBalancer
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Get an load balancer object from the database.
UpdateAmpFailoverDetails
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update amphora failover details in the database.
UpdateAmphoraCertBusyToFalse
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the amphora cert_busy flag to be false.
UpdateAmphoraComputeId
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Associate amphora with a compute in DB.
UpdateAmphoraDBCertExpiration
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the amphora expiration date with new cert file date.
UpdateAmphoraInfo
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update amphora with compute instance details.
UpdateAmphoraVIPData
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update amphorae VIP data.
UpdateHealthMonInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the health monitor in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
UpdateL7PolicyInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the L7 policy in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
UpdateL7RuleInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the L7 rule in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
UpdateLBServerGroupInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the server group id info for load balancer in DB.
execute
(loadbalancer_id, server_group_id)[source]¶Update the server group id info for load balancer in DB.
Parameters: |
|
---|---|
Returns: | None |
revert
(loadbalancer_id, server_group_id, *args, **kwargs)[source]¶Remove server group information from a load balancer in DB.
Parameters: |
|
---|---|
Returns: | None |
UpdateListenerInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the listener in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
UpdateLoadbalancerInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the loadbalancer in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
UpdateMemberInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the member in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
UpdatePoolInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update the pool in the DB.
Since sqlalchemy will likely retry by itself always revert if it fails
UpdatePoolMembersOperatingStatusInDB
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Updates the members of a pool operating status.
Since sqlalchemy will likely retry by itself always revert if it fails
UpdateVIPAfterAllocation
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.database_tasks.BaseDatabaseTask
Update a VIP associated with a given load balancer.
AmphoraIDToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to checkpoint Amphora lifecycle milestones.
execute
(amphora_id)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(amphora_id, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
AmphoraToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.AmphoraIDToErrorOnRevertTask
Task to checkpoint Amphora lifecycle milestones.
execute
(amphora)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(amphora, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
BaseLifecycleTask
(**kwargs)[source]¶Bases: taskflow.task.Task
Base task to instansiate common classes.
HealthMonitorToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set a member to ERROR on revert.
execute
(health_mon, listeners, loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(health_mon, listeners, loadbalancer, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
L7PolicyToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set a l7policy to ERROR on revert.
execute
(l7policy, listeners, loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(l7policy, listeners, loadbalancer, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
L7RuleToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set a l7rule to ERROR on revert.
execute
(l7rule, listeners, loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(l7rule, listeners, loadbalancer, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
ListenerToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set a listener to ERROR on revert.
execute
(listener)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(listener, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
ListenersToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set listeners to ERROR on revert.
execute
(listeners, loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(listeners, loadbalancer, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
LoadBalancerIDToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set the load balancer to ERROR on revert.
execute
(loadbalancer_id)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(loadbalancer_id, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
LoadBalancerToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.LoadBalancerIDToErrorOnRevertTask
Task to set the load balancer to ERROR on revert.
execute
(loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(loadbalancer, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
MemberToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set a member to ERROR on revert.
execute
(member, listeners, loadbalancer, pool)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(member, listeners, loadbalancer, pool, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
MembersToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set members to ERROR on revert.
execute
(members, listeners, loadbalancer, pool)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(members, listeners, loadbalancer, pool, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
PoolToErrorOnRevertTask
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.lifecycle_tasks.BaseLifecycleTask
Task to set a pool to ERROR on revert.
execute
(pool, listeners, loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(pool, listeners, loadbalancer, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
DeleteModelObject
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)[source]¶Bases: taskflow.task.Task
Task to delete an object in a model.
execute
(object)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
UpdateAttributes
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)[source]¶Bases: taskflow.task.Task
Task to update an object for changes.
execute
(object, update_dict)[source]¶Update an object and its associated resources.
Parameters: |
|
---|---|
Returns: | None |
AllocateVIP
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to allocate a VIP.
ApplyQos
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Apply Quality of Services to the VIP
BaseNetworkTask
(**kwargs)[source]¶Bases: taskflow.task.Task
Base task to load drivers common to the tasks.
network_driver
¶CalculateAmphoraDelta
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
default_provides
= 'delta'¶execute
(loadbalancer, amphora)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
CalculateDelta
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to calculate the delta between
the nics on the amphora and the ones we need. Returns a list for plumbing them.
default_provides
= 'deltas'¶DeallocateVIP
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to deallocate a VIP.
FailoverPreparationForAmphora
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to prepare an amphora for failover.
execute
(amphora)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
GetAmphoraeNetworkConfigs
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to retrieve amphorae network details.
execute
(loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
GetMemberPorts
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
execute
(loadbalancer, amphora)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
GetPlumbedNetworks
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to figure out the NICS on an amphora.
This will likely move into the amphora driver :returns: Array of networks
default_provides
= 'nics'¶HandleNetworkDelta
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to plug and unplug networks
Plug or unplug networks based on delta
HandleNetworkDeltas
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to plug and unplug networks
Loop through the deltas and plug or unplug networks based on delta
PlugNetworks
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to plug the networks.
This uses the delta to add all missing networks/nics
PlugPorts
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to plug neutron ports into a compute instance.
execute
(amphora, ports)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
PlugVIP
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to plumb a VIP.
PlugVIPPort
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to plug a VIP into a compute instance.
execute
(amphora, amphorae_network_config)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, amphora, amphorae_network_config, *args, **kwargs)[source]¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
RetrievePortIDsOnAmphoraExceptLBNetwork
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task retrieving all the port ids on an amphora, except lb network.
execute
(amphora)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
UnPlugNetworks
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to unplug the networks
Loop over all nics and unplug them based on delta
UnplugVIP
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to unplug the vip.
UpdateVIP
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to update a VIP.
execute
(loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
UpdateVIPForDelete
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to update a VIP for listener delete flows.
execute
(loadbalancer)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
WaitForPortDetach
(**kwargs)[source]¶Bases: octavia.controller.worker.tasks.network_tasks.BaseNetworkTask
Task to wait for the neutron ports to detach from an amphora.
execute
(amphora)[source]¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.