octavia.controller.worker.v2.tasks package

Submodules

octavia.controller.worker.v2.tasks.amphora_driver_tasks module

class AmpListenersUpdate(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to update the listeners on one amphora.

execute(loadbalancer, 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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class AmpRetry(attempts=1, name=None, provides=None, requires=None, auto_extract=True, rebind=None, revert_all=False)[source]

Bases: taskflow.retry.Times

on_failure(history, *args, **kwargs)[source]

Makes a decision about the future.

This method will typically use information about prior failures (if this historical failure information is not available or was not persisted the provided history will be empty).

Returns a retry constant (one of):

  • RETRY: when the controlling flow must be reverted and restarted again (for example with new parameters).

  • REVERT: when this controlling flow must be completely reverted and the parent flow (if any) should make a decision about further flow execution.

  • REVERT_ALL: when this controlling flow and the parent flow (if any) must be reverted and marked as a FAILURE.

class AmphoraCertUpload(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Upload a certificate to the amphora.

execute(amphora, server_pem)[source]

Execute cert_update_amphora routine.

class AmphoraComputeConnectivityWait(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to wait for the compute instance to be up.

execute(amphora, raise_retry_exception=False)[source]

Execute get_info routine for an amphora until it responds.

class AmphoraConfigUpdate(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to push a new amphora agent configuration to the amphroa.

execute(amphora, flavor)[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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class AmphoraFinalize(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to finalize the amphora before any listeners are configured.

execute(amphora)[source]

Execute finalize_amphora routine.

revert(result, amphora, *args, **kwargs)[source]

Handle a failed amphora finalize.

class AmphoraGetDiagnostics(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to get diagnostics on the amphora and the loadbalancers.

execute(amphora)[source]

Execute get_diagnostic routine for an amphora.

class AmphoraGetInfo(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to get information on an amphora.

execute(amphora)[source]

Execute get_info routine for an amphora.

class AmphoraPostNetworkPlug(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to notify the amphora post network plug.

execute(amphora, ports)[source]

Execute post_network_plug routine.

revert(result, amphora, *args, **kwargs)[source]

Handle a failed post network plug.

class AmphoraPostVIPPlug(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to notify the amphora post VIP plug.

execute(amphora, loadbalancer, amphorae_network_config)[source]

Execute post_vip_routine.

revert(result, amphora, loadbalancer, *args, **kwargs)[source]

Handle a failed amphora vip plug notification.

class AmphoraUpdateVRRPInterface(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to get and update the VRRP interface device name from amphora.

execute(loadbalancer)[source]

Execute post_vip_routine.

revert(result, loadbalancer, *args, **kwargs)[source]

Handle a failed amphora vip plug notification.

class AmphoraVRRPStart(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class AmphoraVRRPStop(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class AmphoraVRRPUpdate(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to update the VRRP configuration of the loadbalancer amphorae.

execute(loadbalancer, amphorae_network_config)[source]

Execute update_vrrp_conf.

class AmphoraePostNetworkPlug(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to notify the amphorae post network plug.

execute(loadbalancer, added_ports)[source]

Execute post_network_plug routine.

revert(result, loadbalancer, added_ports, *args, **kwargs)[source]

Handle a failed post network plug.

class AmphoraePostVIPPlug(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to notify the amphorae post VIP plug.

execute(loadbalancer, amphorae_network_config)[source]

Execute post_vip_plug across the amphorae.

revert(result, loadbalancer, *args, **kwargs)[source]

Handle a failed amphora vip plug notification.

class BaseAmphoraTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to load drivers common to the tasks.

class ListenerDelete(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to delete the listener on the vip.

execute(listener)[source]

Execute listener delete routines for an amphora.

revert(listener, *args, **kwargs)[source]

Handle a failed listener delete.

class ListenersStart(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to start all listeners on the vip.

execute(loadbalancer, amphora=None)[source]

Execute listener start routines for listeners on an amphora.

revert(loadbalancer, *args, **kwargs)[source]

Handle failed listeners starts.

class ListenersUpdate(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to update amphora with all specified listeners’ configurations.

execute(loadbalancer_id)[source]

Execute updates per listener for an amphora.

revert(loadbalancer_id, *args, **kwargs)[source]

Handle failed listeners updates.

octavia.controller.worker.v2.tasks.cert_task module

class BaseCertTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to load drivers common to the tasks.

class GenerateServerPEMTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

octavia.controller.worker.v2.tasks.compute_tasks module

class BaseComputeTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to load drivers common to the tasks.

class CertComputeCreate(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.compute_tasks.ComputeCreate

execute(amphora_id, server_pem, build_type_priority=40, server_group_id=None, ports=None, flavor=None, availability_zone=None)[source]

Create an amphora

Parameters

availability_zone – availability zone metadata dictionary

Returns

an amphora

class ComputeActiveWait(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.compute_tasks.BaseComputeTask

Wait for the compute driver to mark the amphora active.

execute(compute_id, amphora_id, availability_zone)[source]

Wait for the compute driver to mark the amphora active

Parameters
  • compute_id – virtual machine UUID

  • amphora_id – id of the amphora object

  • availability_zone – availability zone metadata dictionary

Raises

Generic exception if the amphora is not active

Returns

An amphora object

class ComputeCreate(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.compute_tasks.BaseComputeTask

Create the compute instance for a new amphora.

execute(amphora_id, config_drive_files=None, build_type_priority=40, server_group_id=None, ports=None, flavor=None, availability_zone=None)[source]

Create an amphora

Parameters

availability_zone – availability zone metadata dictionary

Returns

an amphora

revert(result, amphora_id, *args, **kwargs)[source]

This method will revert the creation of the

amphora. So it will just delete it in this flow

class ComputeDelete(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class DeleteAmphoraeOnLoadBalancer(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class NovaServerGroupCreate(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.compute_tasks.BaseComputeTask

execute(loadbalancer_id)[source]

Create a server group by nova client api

Parameters
  • loadbalancer_id – will be used for server group’s name

  • policy – will used for server group’s policy

Raises

Generic exception if the server group is not created

Returns

server group’s id

revert(result, *args, **kwargs)[source]

This method will revert the creation of the

Parameters

result – here it refers to server group id

class NovaServerGroupDelete(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

octavia.controller.worker.v2.tasks.database_tasks module

class AssociateFailoverAmphoraWithLBID(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Associate failover amphora with loadbalancer in the database.

execute(amphora_id, loadbalancer_id)[source]

Associate failover amphora with loadbalancer in the database.

Parameters
  • amphora_id – Id of an amphora to update

  • loadbalancer_id – Id of a load balancer to be associated with a given amphora.

Returns

None

revert(amphora_id, *args, **kwargs)[source]

Remove amphora-load balancer association.

Parameters

amphora_id – Id of an amphora that couldn’t be associated with a load balancer.

Returns

None

class BaseDatabaseTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to load drivers common to the tasks.

class CountPoolChildrenForQuota(**kwargs)[source]

Bases: octavia.controller.worker.v2.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.

execute(pool_id)[source]

Count the pool child resources for quota management

Parameters

pool_id – pool_id of pool object to count children on

Returns

None

class CreateAmphoraInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Task to create an initial amphora in the Database.

execute(*args, loadbalancer_id=None, **kwargs)[source]

Creates an pending create amphora record in the database.

Returns

The created amphora object

revert(result, *args, **kwargs)[source]

Revert by storing the amphora in error state in the DB

In a future version we might change the status to DELETED if deleting the amphora was successful

Parameters

result – Id of created amphora.

Returns

None

class CreateVRRPGroupForLB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Create a VRRP group for a load balancer.

execute(loadbalancer)[source]

Create a VRRP group for a load balancer.

Parameters

loadbalancer – Load balancer for which a VRRP group should be created

Returns

Updated load balancer

class DecrementHealthMonitorQuota(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Decrements the health monitor quota for a project.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(project_id)[source]

Decrements the health monitor quota.

Parameters

project_id – The project_id to decrement the quota on.

Returns

None

revert(project_id, result, *args, **kwargs)[source]

Re-apply the quota

Parameters

project_id – The project_id to decrement the quota on.

Returns

None

class DecrementL7policyQuota(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Decrements the l7policy quota for a project.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7policy)[source]

Decrements the l7policy quota.

Parameters

l7policy – The l7policy to decrement the quota on.

Returns

None

revert(l7policy, result, *args, **kwargs)[source]

Re-apply the quota

Parameters

l7policy – The l7policy to decrement the quota on.

Returns

None

class DecrementL7ruleQuota(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Decrements the l7rule quota for a project.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7rule)[source]

Decrements the l7rule quota.

Parameters

l7rule – The l7rule to decrement the quota on.

Returns

None

revert(l7rule, result, *args, **kwargs)[source]

Re-apply the quota

Parameters

l7rule – The l7rule to decrement the quota on.

Returns

None

class DecrementListenerQuota(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Decrements the listener quota for a project.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(project_id)[source]

Decrements the listener quota.

Parameters

project_id – The project_id to decrement the quota on.

Returns

None

revert(project_id, result, *args, **kwargs)[source]

Re-apply the quota

Parameters

project_id – The project_id to decrement the quota on.

Returns

None

class DecrementLoadBalancerQuota(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Decrements the load balancer quota for a project.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(project_id)[source]

Decrements the load balancer quota.

Parameters

project_id – Project id where quota should be reduced

Returns

None

revert(project_id, result, *args, **kwargs)[source]

Re-apply the quota

Parameters

project_id – The project id to decrement the quota on.

Returns

None

class DecrementMemberQuota(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Decrements the member quota for a project.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(project_id)[source]

Decrements the member quota.

Parameters

member – The member to decrement the quota on.

Returns

None

revert(project_id, result, *args, **kwargs)[source]

Re-apply the quota

Parameters

member – The member to decrement the quota on.

Returns

None

class DecrementPoolQuota(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Decrements the pool quota for a project.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(project_id, pool_child_count)[source]

Decrements the pool quota.

Parameters

project_id – project_id where the pool to decrement the quota on

Returns

None

revert(project_id, pool_child_count, result, *args, **kwargs)[source]

Re-apply the quota

Parameters

project_id – The id of project to decrement the quota on

Returns

None

class DeleteHealthMonitorInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Delete the health monitor in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(health_mon)[source]

Delete the health monitor in DB

Parameters

health_mon – The health monitor which should be deleted

Returns

None

revert(health_mon, *args, **kwargs)[source]

Mark the health monitor ERROR since the mark active couldn’t happen

Parameters

health_mon – The health monitor which couldn’t be deleted

Returns

None

class DeleteHealthMonitorInDBByPool(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.DeleteHealthMonitorInDB

Delete the health monitor in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(pool_id)[source]

Delete the health monitor in the DB.

Parameters

pool_id – ID of pool which health monitor should be deleted.

Returns

None

revert(pool_id, *args, **kwargs)[source]

Mark the health monitor ERROR since the mark active couldn’t happen

Parameters

pool_id – ID of pool which health monitor couldn’t be deleted

Returns

None

class DeleteL7PolicyInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Delete the L7 policy in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7policy)[source]

Delete the l7policy in DB

Parameters

l7policy – The l7policy to be deleted

Returns

None

revert(l7policy, *args, **kwargs)[source]

Mark the l7policy ERROR since the delete couldn’t happen

Parameters

l7policy – L7 policy that failed to get deleted

Returns

None

class DeleteL7RuleInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Delete the L7 rule in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7rule)[source]

Delete the l7rule in DB

Parameters

l7rule – The l7rule to be deleted

Returns

None

revert(l7rule, *args, **kwargs)[source]

Mark the l7rule ERROR since the delete couldn’t happen

Parameters

l7rule – L7 rule that failed to get deleted

Returns

None

class DeleteListenerInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Delete the listener in the DB.

execute(listener)[source]

Delete the listener in DB

Parameters

listener – The listener to delete

Returns

None

revert(listener, *args, **kwargs)[source]

Mark the listener ERROR since the listener didn’t delete

Parameters

listener – Listener that failed to get deleted

Returns

None

class DeleteMemberInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Delete the member in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(member)[source]

Delete the member in the DB

Parameters

member – The member to be deleted

Returns

None

revert(member, *args, **kwargs)[source]

Mark the member ERROR since the delete couldn’t happen

Parameters

member – Member that failed to get deleted

Returns

None

class DeletePoolInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Delete the pool in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(pool_id)[source]

Delete the pool in DB

Parameters

pool_id – The pool_id to be deleted

Returns

None

revert(pool_id, *args, **kwargs)[source]

Mark the pool ERROR since the delete couldn’t happen

Parameters

pool_id – pool_id that failed to get deleted

Returns

None

class DisableAmphoraHealthMonitoring(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Disable amphora health monitoring.

This disables amphora health monitoring by removing it from the amphora_health table.

execute(amphora)[source]

Disable health monitoring for an amphora

Parameters

amphora – The amphora to disable health monitoring for

Returns

None

class DisableLBAmphoraeHealthMonitoring(**kwargs)[source]

Bases: octavia.controller.worker.v2.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.

execute(loadbalancer)[source]

Disable health monitoring for amphora on a load balancer

Parameters

loadbalancer – The load balancer to disable health monitoring on

Returns

None

class GetAmphoraDetails(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Task to retrieve amphora network details.

execute(amphora)[source]

Retrieve amphora network details.

Parameters

amphora – Amphora which network details are required

Returns

Amphora data dict

class GetAmphoraeFromLoadbalancer(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Task to pull the listeners from a loadbalancer.

execute(loadbalancer)[source]

Pull the amphorae from a loadbalancer.

Parameters

loadbalancer – Load balancer which listeners are required

Returns

A list of Listener objects

class GetListenersFromLoadbalancer(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Task to pull the listeners from a loadbalancer.

execute(loadbalancer)[source]

Pull the listeners from a loadbalancer.

Parameters

loadbalancer – Load balancer which listeners are required

Returns

A list of Listener objects

class GetVipFromLoadbalancer(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Task to pull the vip from a loadbalancer.

execute(loadbalancer)[source]

Pull the vip from a loadbalancer.

Parameters

loadbalancer – Load balancer which VIP is required

Returns

VIP associated with a given load balancer

class MapLoadbalancerToAmphora(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Maps and assigns a load balancer to an amphora in the database.

execute(loadbalancer_id, server_group_id=None, flavor=None, availability_zone=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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class MarkAmphoraAllocatedInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.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

execute(amphora, loadbalancer_id)[source]

Mark amphora as allocated to a load balancer in DB.

Parameters
  • amphora – Amphora to be updated.

  • loadbalancer_id – Id of a load balancer to which an amphora should be allocated.

Returns

None

revert(result, amphora, loadbalancer_id, *args, **kwargs)[source]

Mark the amphora as broken and ready to be cleaned up.

Parameters
  • result – Execute task result

  • amphora – Amphora that was updated.

  • loadbalancer_id – Id of a load balancer to which an amphora failed to be allocated.

Returns

None

class MarkAmphoraBackupInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks._MarkAmphoraRoleAndPriorityInDB

Alter the amphora role to: Backup.

execute(amphora)[source]

Mark amphora as BACKUP in db.

Parameters

amphora – Amphora to update role.

Returns

None

revert(result, amphora, *args, **kwargs)[source]

Removes amphora role association.

Parameters

amphora – Amphora to update role.

Returns

None

class MarkAmphoraBootingInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the amphora as booting in the database.

execute(amphora_id, compute_id)[source]

Mark amphora booting in DB.

Parameters
  • amphora_id – Id of the amphora to update

  • compute_id – Id of a compute on which an amphora resides

Returns

None

revert(result, amphora_id, compute_id, *args, **kwargs)[source]

Mark the amphora as broken and ready to be cleaned up.

Parameters
  • result – Execute task result

  • amphora_id – Id of the amphora that failed to update

  • compute_id – Id of a compute on which an amphora resides

Returns

None

class MarkAmphoraDeletedInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the amphora deleted in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(amphora)[source]

Mark the amphora as deleted in DB.

Parameters

amphora – Amphora to be updated.

Returns

None

revert(amphora, *args, **kwargs)[source]

Mark the amphora as broken and ready to be cleaned up.

Parameters

amphora – Amphora that was updated.

Returns

None

class MarkAmphoraHealthBusy(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark amphora health monitoring busy.

This prevents amphora failover by marking the amphora busy in the amphora_health table.

execute(amphora)[source]

Mark amphora health monitoring busy

Parameters

amphora – The amphora to mark amphora health busy

Returns

None

class MarkAmphoraMasterInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks._MarkAmphoraRoleAndPriorityInDB

Alter the amphora role to: MASTER.

execute(amphora)[source]

Mark amphora as MASTER in db.

Parameters

amphora – Amphora to update role.

Returns

None

revert(result, amphora, *args, **kwargs)[source]

Removes amphora role association.

Parameters

amphora – Amphora to update role.

Returns

None

class MarkAmphoraPendingDeleteInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the amphora pending delete in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(amphora)[source]

Mark the amphora as pending delete in DB.

Parameters

amphora – Amphora to be updated.

Returns

None

revert(amphora, *args, **kwargs)[source]

Mark the amphora as broken and ready to be cleaned up.

Parameters

amphora – Amphora that was updated.

Returns

None

class MarkAmphoraPendingUpdateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the amphora pending update in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(amphora)[source]

Mark the amphora as pending update in DB.

Parameters

amphora – Amphora to be updated.

Returns

None

revert(amphora, *args, **kwargs)[source]

Mark the amphora as broken and ready to be cleaned up.

Parameters

amphora – Amphora that was updated.

Returns

None

class MarkAmphoraReadyInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.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

execute(amphora)[source]

Mark amphora as ready in DB.

Parameters

amphora – Amphora to be updated.

Returns

None

revert(amphora, *args, **kwargs)[source]

Mark the amphora as broken and ready to be cleaned up.

Parameters

amphora – Amphora that was updated.

Returns

None

class MarkAmphoraStandAloneInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks._MarkAmphoraRoleAndPriorityInDB

Alter the amphora role to: Standalone.

execute(amphora)[source]

Mark amphora as STANDALONE in db.

Parameters

amphora – Amphora to update role.

Returns

None

revert(result, amphora, *args, **kwargs)[source]

Removes amphora role association.

Parameters

amphora – Amphora to update role.

Returns

None

class MarkHealthMonitorActiveInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the health monitor ACTIVE in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(health_mon)[source]

Mark the health monitor ACTIVE in DB.

Parameters

health_mon – Health Monitor object to be updated

Returns

None

revert(health_mon, *args, **kwargs)[source]

Mark the health monitor as broken

Parameters

health_mon – Health Monitor object that failed to update

Returns

None

class MarkHealthMonitorPendingCreateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.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

execute(health_mon)[source]

Mark the health monitor as pending create in DB.

Parameters

health_mon – Health Monitor object to be updated

Returns

None

revert(health_mon, *args, **kwargs)[source]

Mark the health monitor as broken

Parameters

health_mon – Health Monitor object that failed to update

Returns

None

class MarkHealthMonitorPendingDeleteInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.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

execute(health_mon)[source]

Mark the health monitor as pending delete in DB.

Parameters

health_mon – Health Monitor object to be updated

Returns

None

revert(health_mon, *args, **kwargs)[source]

Mark the health monitor as broken

Parameters

health_mon – Health Monitor object that failed to update

Returns

None

class MarkHealthMonitorPendingUpdateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.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

execute(health_mon)[source]

Mark the health monitor as pending update in DB.

Parameters

health_mon – Health Monitor object to be updated

Returns

None

revert(health_mon, *args, **kwargs)[source]

Mark the health monitor as broken

Parameters

health_mon – Health Monitor object that failed to update

Returns

None

class MarkL7PolicyActiveInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the l7policy ACTIVE in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7policy)[source]

Mark the l7policy ACTIVE in DB.

Parameters

l7policy – L7Policy object to be updated

Returns

None

revert(l7policy, *args, **kwargs)[source]

Mark the l7policy as broken

Parameters

l7policy – L7Policy object that failed to update

Returns

None

class MarkL7PolicyPendingCreateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the l7policy pending create in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7policy)[source]

Mark the l7policy as pending create in DB.

Parameters

l7policy – L7Policy object to be updated

Returns

None

revert(l7policy, *args, **kwargs)[source]

Mark the l7policy as broken

Parameters

l7policy – L7Policy object that failed to update

Returns

None

class MarkL7PolicyPendingDeleteInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the l7policy pending delete in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7policy)[source]

Mark the l7policy as pending delete in DB.

Parameters

l7policy – L7Policy object to be updated

Returns

None

revert(l7policy, *args, **kwargs)[source]

Mark the l7policy as broken

Parameters

l7policy – L7Policy object that failed to update

Returns

None

class MarkL7PolicyPendingUpdateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the l7policy pending update in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7policy)[source]

Mark the l7policy as pending update in DB.

Parameters

l7policy – L7Policy object to be updated

Returns

None

revert(l7policy, *args, **kwargs)[source]

Mark the l7policy as broken

Parameters

l7policy – L7Policy object that failed to update

Returns

None

class MarkL7RuleActiveInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the l7rule ACTIVE in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7rule)[source]

Mark the l7rule ACTIVE in DB.

Parameters

l7rule – L7Rule object to be updated

Returns

None

revert(l7rule, *args, **kwargs)[source]

Mark the l7rule as broken

Parameters

l7rule – L7Rule object that failed to update

Returns

None

class MarkL7RulePendingCreateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the l7rule pending create in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7rule)[source]

Mark the l7rule as pending create in DB.

Parameters

l7rule – L7Rule object to be updated

Returns

None

revert(l7rule, *args, **kwargs)[source]

Mark the l7rule as broken

Parameters

l7rule – L7Rule object that failed to update

Returns

None

class MarkL7RulePendingDeleteInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the l7rule pending delete in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7rule)[source]

Mark the l7rule as pending delete in DB.

Parameters

l7rule – L7Rule object to be updated

Returns

None

revert(l7rule, *args, **kwargs)[source]

Mark the l7rule as broken

Parameters

l7rule – L7Rule object that failed to update

Returns

None

class MarkL7RulePendingUpdateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the l7rule pending update in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7rule)[source]

Mark the l7rule as pending update in DB.

Parameters

l7rule – L7Rule object to be updated

Returns

None

revert(l7rule, *args, **kwargs)[source]

Mark the l7rule as broken

Parameters

l7rule – L7Rule object that failed to update

Returns

None

class MarkLBActiveInDB(mark_subobjects=False, **kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the load balancer active in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(loadbalancer)[source]

Mark the load balancer as active in DB.

This also marks ACTIVE all sub-objects of the load balancer if self.mark_subobjects is True.

Parameters

loadbalancer – Load balancer object to be updated

Returns

None

revert(loadbalancer, *args, **kwargs)[source]

Mark the load balancer as broken and ready to be cleaned up.

This also puts all sub-objects of the load balancer to ERROR state if self.mark_subobjects is True

Parameters

loadbalancer – Load balancer object that failed to update

Returns

None

class MarkLBActiveInDBByListener(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the load balancer active in the DB using a listener dict.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(listener)[source]

Mark the load balancer as active in DB.

Parameters

listener – Listener dictionary

Returns

None

revert(listener, *args, **kwargs)[source]

Mark the load balancer as broken and ready to be cleaned up.

This also puts all sub-objects of the load balancer to ERROR state if self.mark_subobjects is True

Parameters

listener – Listener dictionary

Returns

None

class MarkLBAmphoraeDeletedInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Task to mark a list of amphora deleted in the Database.

execute(loadbalancer)[source]

Update load balancer’s amphorae statuses to DELETED in the database.

Parameters

loadbalancer – The load balancer which amphorae should be marked DELETED.

Returns

None

class MarkLBAmphoraeHealthBusy(**kwargs)[source]

Bases: octavia.controller.worker.v2.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.

execute(loadbalancer)[source]

Marks amphorae health busy for each amphora on a load balancer

Parameters

loadbalancer – The load balancer to mark amphorae health busy

Returns

None

class MarkLBAndListenersActiveInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.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

execute(loadbalancer_id, listeners)[source]

Mark the load balancer and listeners as active in DB.

Parameters
  • loadbalancer_id – The load balancer ID to be updated

  • listeners – Listener objects to be updated

Returns

None

revert(loadbalancer_id, listeners, *args, **kwargs)[source]

Mark the load balancer and listeners as broken.

Parameters
  • loadbalancer_id – The load balancer ID to be updated

  • listeners – Listener objects that failed to update

Returns

None

class MarkLBDeletedInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the load balancer deleted in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(loadbalancer)[source]

Mark the load balancer as deleted in DB.

Parameters

loadbalancer – Load balancer object to be updated

Returns

None

revert(loadbalancer, *args, **kwargs)[source]

Mark the load balancer as broken and ready to be cleaned up.

Parameters

loadbalancer – Load balancer object that failed to update

Returns

None

class MarkLBPendingDeleteInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.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

execute(loadbalancer)[source]

Mark the load balancer as pending delete in DB.

Parameters

loadbalancer – Load balancer object to be updated

Returns

None

revert(loadbalancer, *args, **kwargs)[source]

Mark the load balancer as broken and ready to be cleaned up.

Parameters

loadbalancer – Load balancer object that failed to update

Returns

None

class MarkListenerDeletedInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the listener deleted in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(listener)[source]

Mark the listener as deleted in DB

Parameters

listener – The listener to be marked deleted

Returns

None

revert(listener, *args, **kwargs)[source]

Mark the listener ERROR since the delete couldn’t happen

Parameters

listener – The listener that couldn’t be updated

Returns

None

class MarkListenerPendingDeleteInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the listener pending delete in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(listener)[source]

Mark the listener as pending delete in DB.

Parameters

listener – The listener to be updated

Returns

None

revert(listener, *args, **kwargs)[source]

Mark the listener as broken and ready to be cleaned up.

Parameters

listener – The listener that couldn’t be updated

Returns

None

class MarkMemberActiveInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the member ACTIVE in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(member)[source]

Mark the member ACTIVE in DB.

Parameters

member – Member object to be updated

Returns

None

revert(member, *args, **kwargs)[source]

Mark the member as broken

Parameters

member – Member object that failed to update

Returns

None

class MarkMemberPendingCreateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the member pending create in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(member)[source]

Mark the member as pending create in DB.

Parameters

member – Member object to be updated

Returns

None

revert(member, *args, **kwargs)[source]

Mark the member as broken

Parameters

member – Member object that failed to update

Returns

None

class MarkMemberPendingDeleteInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the member pending delete in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(member)[source]

Mark the member as pending delete in DB.

Parameters

member – Member object to be updated

Returns

None

revert(member, *args, **kwargs)[source]

Mark the member as broken

Parameters

member – Member object that failed to update

Returns

None

class MarkMemberPendingUpdateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the member pending update in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(member)[source]

Mark the member as pending update in DB.

Parameters

member – Member object to be updated

Returns

None

revert(member, *args, **kwargs)[source]

Mark the member as broken

Parameters

member – Member object that failed to update

Returns

None

class MarkPoolActiveInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the pool ACTIVE in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(pool_id)[source]

Mark the pool ACTIVE in DB.

Parameters

pool_id – pool_id to be updated

Returns

None

revert(pool_id, *args, **kwargs)[source]

Mark the pool as broken

Parameters

pool_id – pool_id that failed to update

Returns

None

class MarkPoolPendingCreateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the pool pending create in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(pool_id)[source]

Mark the pool as pending create in DB.

Parameters

pool_id – pool_id of pool object to be updated

Returns

None

revert(pool_id, *args, **kwargs)[source]

Mark the pool as broken

Parameters

pool_id – pool_id of pool object that failed to update

Returns

None

class MarkPoolPendingDeleteInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the pool pending delete in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(pool_id)[source]

Mark the pool as pending delete in DB.

Parameters

pool_id – pool_id of pool object to be updated

Returns

None

revert(pool_id, *args, **kwargs)[source]

Mark the pool as broken

Parameters

pool_id – pool_id of pool object that failed to update

Returns

None

class MarkPoolPendingUpdateInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Mark the pool pending update in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(pool_id)[source]

Mark the pool as pending update in DB.

Parameters

pool_id – pool_id of pool object to be updated

Returns

None

revert(pool_id, *args, **kwargs)[source]

Mark the pool as broken

Parameters

pool_id – pool_id of pool object that failed to update

Returns

None

class ReloadAmphora(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Get an amphora object from the database.

execute(amphora)[source]

Get an amphora object from the database.

Parameters

amphora_id – The amphora ID to lookup

Returns

The amphora object

class ReloadLoadBalancer(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Get an load balancer object from the database.

execute(loadbalancer_id, *args, **kwargs)[source]

Get an load balancer object from the database.

Parameters

loadbalancer_id – The load balancer ID to lookup

Returns

The load balancer object

class UpdateAmpFailoverDetails(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update amphora failover details in the database.

execute(amphora, amp_data)[source]

Update amphora failover details in the database.

Parameters
  • amphora – The amphora to update

  • amp_data – data_models.Amphora object with update data

Returns

None

class UpdateAmphoraCertBusyToFalse(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the amphora cert_busy flag to be false.

execute(amphora_id)[source]

Update the amphora cert_busy flag to be false.

Parameters

amphora – Amphora to be updated.

Returns

None

class UpdateAmphoraComputeId(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Associate amphora with a compute in DB.

execute(amphora_id, compute_id)[source]

Associate amphora with a compute in DB.

Parameters
  • amphora_id – Id of the amphora to update

  • compute_id – Id of a compute on which an amphora resides

Returns

None

class UpdateAmphoraDBCertExpiration(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the amphora expiration date with new cert file date.

execute(amphora_id, server_pem)[source]

Update the amphora expiration date with new cert file date.

Parameters
  • amphora_id – Id of the amphora to update

  • server_pem – Certificate in PEM format

Returns

None

class UpdateAmphoraInfo(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update amphora with compute instance details.

execute(amphora_id, compute_obj)[source]

Update amphora with compute instance details.

Parameters
  • amphora_id – Id of the amphora to update

  • compute_obj – Compute on which an amphora resides

Returns

Updated amphora object

class UpdateAmphoraVIPData(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update amphorae VIP data.

execute(amp_data)[source]

Update amphorae VIP data.

Parameters

amps_data – Amphorae update dicts.

Returns

None

class UpdateAmphoraeVIPData(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update amphorae VIP data.

execute(amps_data)[source]

Update amphorae VIP data.

Parameters

amps_data – Amphorae update dicts.

Returns

None

class UpdateHealthMonInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the health monitor in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(health_mon, update_dict)[source]

Update the health monitor in the DB

Parameters
  • health_mon – The health monitor to be updated

  • update_dict – The dictionary of updates to apply

Returns

None

revert(health_mon, *args, **kwargs)[source]

Mark the health monitor ERROR since the update couldn’t happen

Parameters

health_mon – The health monitor that couldn’t be updated

Returns

None

class UpdateL7PolicyInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the L7 policy in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7policy, update_dict)[source]

Update the L7 policy in the DB

Parameters
  • l7policy – The L7 policy to be updated

  • update_dict – The dictionary of updates to apply

Returns

None

revert(l7policy, *args, **kwargs)[source]

Mark the l7policy ERROR since the update couldn’t happen

Parameters

l7policy – L7 policy that couldn’t be updated

Returns

None

class UpdateL7RuleInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the L7 rule in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(l7rule, update_dict)[source]

Update the L7 rule in the DB

Parameters
  • l7rule – The L7 rule to be updated

  • update_dict – The dictionary of updates to apply

Returns

None

revert(l7rule, *args, **kwargs)[source]

Mark the L7 rule ERROR since the update couldn’t happen

Parameters

l7rule – L7 rule that couldn’t be updated

Returns

None

class UpdateLBServerGroupInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • loadbalancer_id – Id of a load balancer to update

  • server_group_id – Id of a server group to associate with the load balancer

Returns

None

revert(loadbalancer_id, server_group_id, *args, **kwargs)[source]

Remove server group information from a load balancer in DB.

Parameters
  • loadbalancer_id – Id of a load balancer that failed to update

  • server_group_id – Id of a server group that couldn’t be associated with the load balancer

Returns

None

class UpdateListenerInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the listener in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(listener, update_dict)[source]

Update the listener in the DB

Parameters
  • listener – The listener to be updated

  • update_dict – The dictionary of updates to apply

Returns

None

revert(listener, *args, **kwargs)[source]

Mark the listener ERROR since the update couldn’t happen

Parameters

listener – The listener that couldn’t be updated

Returns

None

class UpdateLoadbalancerInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the loadbalancer in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(loadbalancer, update_dict)[source]

Update the loadbalancer in the DB

Parameters
  • loadbalancer – The load balancer to be updated

  • update_dict – The dictionary of updates to apply

Returns

None

revert(loadbalancer, *args, **kwargs)[source]

Mark the loadbalancer ERROR since the update couldn’t happen

Parameters

loadbalancer – The load balancer that couldn’t be updated

Returns

None

class UpdateMemberInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the member in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(member, update_dict)[source]

Update the member in the DB

Parameters
  • member – The member to be updated

  • update_dict – The dictionary of updates to apply

Returns

None

revert(member, *args, **kwargs)[source]

Mark the member ERROR since the update couldn’t happen

Parameters

member – The member that couldn’t be updated

Returns

None

class UpdatePoolInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update the pool in the DB.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(pool_id, update_dict)[source]

Update the pool in the DB

Parameters
  • pool_id – The pool_id to be updated

  • update_dict – The dictionary of updates to apply

Returns

None

revert(pool_id, *args, **kwargs)[source]

Mark the pool ERROR since the update couldn’t happen

Parameters

pool_id – The pool_id that couldn’t be updated

Returns

None

class UpdatePoolMembersOperatingStatusInDB(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Updates the members of a pool operating status.

Since sqlalchemy will likely retry by itself always revert if it fails

execute(pool_id, operating_status)[source]

Update the members of a pool operating status in DB.

Parameters
  • pool_id – pool_id of pool object to be updated

  • operating_status – Operating status to set

Returns

None

class UpdateVIPAfterAllocation(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.database_tasks.BaseDatabaseTask

Update a VIP associated with a given load balancer.

execute(loadbalancer_id, vip)[source]

Update a VIP associated with a given load balancer.

Parameters
  • loadbalancer_id – Id of a load balancer which VIP should be updated.

  • vip – data_models.Vip object with update data.

Returns

The load balancer object.

octavia.controller.worker.v2.tasks.lifecycle_tasks module

class AmphoraIDToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class AmphoraToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class BaseLifecycleTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to instansiate common classes.

class HealthMonitorToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class L7PolicyToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.lifecycle_tasks.BaseLifecycleTask

Task to set a l7policy to ERROR on revert.

execute(l7policy, listeners, 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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

revert(l7policy, listeners, 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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class L7RuleToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.lifecycle_tasks.BaseLifecycleTask

Task to set a l7rule to ERROR on revert.

execute(l7rule, l7policy_id, listeners, 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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

revert(l7rule, l7policy_id, listeners, 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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class ListenerToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class ListenersToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.lifecycle_tasks.BaseLifecycleTask

Task to set a listener to ERROR on revert.

execute(listeners)[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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

revert(listeners, *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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class LoadBalancerIDToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class LoadBalancerToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class MemberToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.lifecycle_tasks.BaseLifecycleTask

Task to set a member to ERROR on revert.

execute(member, listeners, loadbalancer, pool_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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

revert(member, listeners, loadbalancer, pool_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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class MembersToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.lifecycle_tasks.BaseLifecycleTask

Task to set members to ERROR on revert.

execute(members, listeners, loadbalancer, pool_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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

revert(members, listeners, loadbalancer, pool_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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class PoolToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.lifecycle_tasks.BaseLifecycleTask

Task to set a pool to ERROR on revert.

execute(pool_id, 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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

revert(pool_id, 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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

octavia.controller.worker.v2.tasks.network_tasks module

class AllocateVIP(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to allocate a VIP.

execute(loadbalancer)[source]

Allocate a vip to the loadbalancer.

revert(result, loadbalancer, *args, **kwargs)[source]

Handle a failure to allocate vip.

class ApplyQos(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Apply Quality of Services to the VIP

execute(loadbalancer, amps_data=None, update_dict=None)[source]

Apply qos policy on the vrrp ports which are related with vip.

revert(result, loadbalancer, amps_data=None, update_dict=None, *args, **kwargs)[source]

Handle a failure to apply QoS to VIP

class ApplyQosAmphora(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Apply Quality of Services to the VIP

execute(loadbalancer, amp_data=None, update_dict=None)[source]

Apply qos policy on the vrrp ports which are related with vip.

revert(result, loadbalancer, amp_data=None, update_dict=None, *args, **kwargs)[source]

Handle a failure to apply QoS to VIP

class BaseNetworkTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to load drivers common to the tasks.

property network_driver
class CalculateAmphoraDelta(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

default_provides = 'delta'
execute(loadbalancer, amphora, availability_zone)[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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class CalculateDelta(**kwargs)[source]

Bases: octavia.controller.worker.v2.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'
execute(loadbalancer, availability_zone)[source]

Compute which NICs need to be plugged

for the amphora to become operational.

Parameters
  • loadbalancer – the loadbalancer to calculate deltas for all amphorae

  • availability_zone – availability zone metadata dict

Returns

dict of octavia.network.data_models.Delta keyed off amphora id

class DeallocateVIP(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to deallocate a VIP.

execute(loadbalancer)[source]

Deallocate a VIP.

class FailoverPreparationForAmphora(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class GetAmphoraNetworkConfigs(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to retrieve amphora network details.

execute(loadbalancer, amphora=None)[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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class GetAmphoraeNetworkConfigs(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class GetMemberPorts(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class GetPlumbedNetworks(**kwargs)[source]

Bases: octavia.controller.worker.v2.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'
execute(amphora)[source]

Get plumbed networks for the amphora.

class GetSubnetFromVIP(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to plumb a VIP.

execute(loadbalancer)[source]

Plumb a vip to an amphora.

class HandleNetworkDelta(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to plug and unplug networks

Plug or unplug networks based on delta

execute(amphora, delta)[source]

Handle network plugging based off deltas.

revert(result, amphora, delta, *args, **kwargs)[source]

Handle a network plug or unplug failures.

class HandleNetworkDeltas(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to plug and unplug networks

Loop through the deltas and plug or unplug networks based on delta

execute(deltas)[source]

Handle network plugging based off deltas.

revert(result, deltas, *args, **kwargs)[source]

Handle a network plug or unplug failures.

class PlugNetworks(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to plug the networks.

This uses the delta to add all missing networks/nics

execute(amphora, delta)[source]

Update the amphora networks for the delta.

revert(amphora, delta, *args, **kwargs)[source]

Handle a failed network plug by removing all nics added.

class PlugPorts(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class PlugVIP(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to plumb a VIP.

execute(loadbalancer)[source]

Plumb a vip to an amphora.

revert(result, loadbalancer, *args, **kwargs)[source]

Handle a failure to plumb a vip.

class PlugVIPAmpphora(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to plumb a VIP.

execute(loadbalancer, amphora, subnet)[source]

Plumb a vip to an amphora.

revert(result, loadbalancer, amphora, subnet, *args, **kwargs)[source]

Handle a failure to plumb a vip.

class PlugVIPPort(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

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
  • args – positional arguments that the atom required to execute.

  • kwargs – any keyword arguments that the atom required to execute; the special key 'result' will contain the execute() result (if any) and the **kwargs key 'flow_failures' will contain any failure information.

class RetrievePortIDsOnAmphoraExceptLBNetwork(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class UnPlugNetworks(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to unplug the networks

Loop over all nics and unplug them based on delta

execute(amphora, delta)[source]

Unplug the networks.

class UnplugVIP(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to unplug the vip.

execute(loadbalancer)[source]

Unplug the vip.

class UpdateVIP(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to update a VIP.

execute(listeners)[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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class UpdateVIPForDelete(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to update a VIP for listener delete flows.

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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

class UpdateVIPSecurityGroup(**kwargs)[source]

Bases: octavia.controller.worker.v2.tasks.network_tasks.BaseNetworkTask

Task to setup SG for LB.

execute(loadbalancer)[source]

Task to setup SG for LB.

class WaitForPortDetach(**kwargs)[source]

Bases: octavia.controller.worker.v2.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
  • args – positional arguments that atom requires to execute.

  • kwargs – any keyword arguments that atom requires to execute.

Module contents