octavia.controller.worker.tasks package

octavia.controller.worker.tasks package

Submodules

octavia.controller.worker.tasks.amphora_driver_tasks module

class AmphoraCertUpload(**kwargs)[source]

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

Upload a certificate to the amphora.

execute(amphora, server_pem)[source]

Execute cert_update_amphora routine.

class AmphoraFinalize(**kwargs)[source]

Bases: octavia.controller.worker.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.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.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.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.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.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.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to start keepalived of all amphorae of a LB.

execute(loadbalancer)[source]
class AmphoraVRRPStop(**kwargs)[source]

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

Task to stop keepalived of all amphorae of a LB.

execute(loadbalancer)[source]
class AmphoraVRRPUpdate(**kwargs)[source]

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

Task to update the VRRP configuration of the loadbalancer amphorae.

execute(loadbalancer)[source]

Execute update_vrrp_conf.

class AmphoraePostNetworkPlug(**kwargs)[source]

Bases: octavia.controller.worker.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.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.tasks.amphora_driver_tasks.BaseAmphoraTask

Task to delete the listener on the vip.

execute(loadbalancer, listener)[source]

Execute listener delete routines for an amphora.

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

Handle a failed listener delete.

class ListenerStart(**kwargs)[source]

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

Task to start the listener on the vip.

execute(loadbalancer, listener)[source]

Execute listener start routines for an amphora.

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

Handle a failed listener start.

class ListenerStop(**kwargs)[source]

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

Task to stop the listener on the vip.

execute(loadbalancer, listener)[source]

Execute listener stop routines for an amphora.

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

Handle a failed listener stop.

class ListenersStart(**kwargs)[source]

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

Task to start all listeners on the vip.

execute(loadbalancer, listeners)[source]

Execute listener start routines for listeners on an amphora.

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

Handle failed listeners starts.

class ListenersUpdate(**kwargs)[source]

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

Task to update amphora with all specified listeners’ configurations.

execute(loadbalancer, listeners)[source]

Execute updates per listener for an amphora.

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

Handle failed listeners updates.

octavia.controller.worker.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.tasks.cert_task.BaseCertTask

Create the server certs for the agent comm

Use the amphora_id for the CN

execute(amphora_id)[source]

octavia.controller.worker.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.tasks.compute_tasks.ComputeCreate

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

Create an amphora

Returns:an amphora
class ComputeCreate(**kwargs)[source]

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

Create the compute instance for a new amphora.

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

Create an amphora

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.tasks.compute_tasks.BaseComputeTask

execute(amphora)[source]
class ComputeWait(**kwargs)[source]

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

Wait for the compute driver to mark the amphora active.

execute(compute_id, amphora_id)[source]

Wait for the compute driver to mark the amphora active

Raises:Generic exception if the amphora is not active
Returns:An amphora object
class DeleteAmphoraeOnLoadBalancer(**kwargs)[source]

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

Delete the amphorae on a load balancer.

Iterate through amphorae, deleting them

execute(loadbalancer)[source]
class NovaServerGroupCreate(**kwargs)[source]

Bases: octavia.controller.worker.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.tasks.compute_tasks.BaseComputeTask

execute(server_group_id)[source]

octavia.controller.worker.tasks.controller_tasks module

class BaseControllerTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to load drivers common to the tasks.

class DeleteLoadBalancersOnAmp(**kwargs)[source]

Bases: octavia.controller.worker.tasks.controller_tasks.BaseControllerTask

Delete the load balancers on an amphora.

execute(amphora)[source]

Deletes the load balancers on an amphora.

Iterate across the load balancers on an amphora and call back into the controller worker to delete the load balancers.

Parameters:amphora – The amphora to delete the load balancers from

octavia.controller.worker.tasks.database_tasks module

class AssociateFailoverAmphoraWithLBID(**kwargs)[source]

Bases: octavia.controller.worker.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.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)[source]

Count the pool child resources for quota management

Parameters:pool – The pool to count children on
Returns:None
class CreateAmphoraInDB(**kwargs)[source]

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

Task to create an initial amphora in the Database.

execute(*args, **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.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.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(health_mon)[source]

Decrements the health monitor quota.

Parameters:health_mon – The health monitor to decrement the quota on.
Returns:None
revert(health_mon, result, *args, **kwargs)[source]

Re-apply the quota

Parameters:health_mon – The health monitor to decrement the quota on.
Returns:None
class DecrementListenerQuota(**kwargs)[source]

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

Decrements the listener quota for a project.

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

execute(listener)[source]

Decrements the listener quota.

Parameters:listener – The listener to decrement the quota on.
Returns:None
revert(listener, result, *args, **kwargs)[source]

Re-apply the quota

Parameters:listener – The listener to decrement the quota on.
Returns:None
class DecrementLoadBalancerQuota(**kwargs)[source]

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

Decrements the load balancer quota for a project.

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

execute(loadbalancer)[source]

Decrements the load balancer quota.

Parameters:loadbalancer – The load balancer to decrement the quota on.
Returns:None
revert(loadbalancer, result, *args, **kwargs)[source]

Re-apply the quota

Parameters:loadbalancer – The load balancer to decrement the quota on.
Returns:None
class DecrementMemberQuota(**kwargs)[source]

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

Decrements the member quota for a project.

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

execute(member)[source]

Decrements the member quota.

Parameters:member – The member to decrement the quota on.
Returns:None
revert(member, 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.tasks.database_tasks.BaseDatabaseTask

Decrements the pool quota for a project.

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

execute(pool, pool_child_count)[source]

Decrements the pool quota.

Parameters:pool – The pool to decrement the quota on
Returns:None
revert(pool, 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.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.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)[source]

Delete the health monitor in the DB.

Parameters:pool – A pool which health monitor should be deleted.
Returns:None
revert(pool, *args, **kwargs)[source]

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

Parameters:pool – A pool which health monitor couldn’t be deleted
Returns:None
class DeleteL7PolicyInDB(**kwargs)[source]

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

Delete the L7 policy in the DB.

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

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.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.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.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.tasks.database_tasks.BaseDatabaseTask

Delete the pool in the DB.

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

execute(pool)[source]

Delete the pool in DB

Parameters:pool – The pool to be deleted
Returns:None
revert(pool, *args, **kwargs)[source]

Mark the pool ERROR since the delete couldn’t happen

Parameters:pool – Pool that failed to get deleted
Returns:None
class DisableAmphoraHealthMonitoring(**kwargs)[source]

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

Disable amphora health monitoring.

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

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.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.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:data_models.Amphora object
class GetListenersFromLoadbalancer(**kwargs)[source]

Bases: octavia.controller.worker.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.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.tasks.database_tasks.BaseDatabaseTask

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

execute(loadbalancer_id)[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]
class MarkAmphoraAllocatedInDB(**kwargs)[source]

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

Will mark an amphora as allocated to a load balancer in the database.

Assume sqlalchemy made sure the DB got retried sufficiently - so just abort

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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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 MarkLBAmphoraeDeletedInDB(**kwargs)[source]

Bases: octavia.controller.worker.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.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.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, listeners)[source]

Mark the load balancer and listeners as active in DB.

Parameters:
  • loadbalancer – Load balancer object to be updated
  • listeners – Listener objects to be updated
Returns:

None

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

Mark the load balancer and listeners as broken.

Parameters:
  • loadbalancer – Load balancer object that failed to update
  • listeners – Listener objects that failed to update
Returns:

None

class MarkLBDeletedInDB(**kwargs)[source]

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

Mark the load balancer deleted in the DB.

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

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.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 MarkListenerActiveInDB(**kwargs)[source]

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

Mark the listener active in the DB.

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

execute(listener)[source]

Mark the listener as active in DB

Parameters:listener – The listener to be marked active
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 MarkListenerDeletedInDB(**kwargs)[source]

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

Mark the listener deleted in the DB.

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

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.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.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.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.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.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.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)[source]

Mark the pool ACTIVE in DB.

Parameters:pool – Pool object to be updated
Returns:None
revert(pool, *args, **kwargs)[source]

Mark the pool as broken

Parameters:pool – Pool object that failed to update
Returns:None
class MarkPoolPendingCreateInDB(**kwargs)[source]

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

Mark the pool pending create in the DB.

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

execute(pool)[source]

Mark the pool as pending create in DB.

Parameters:pool – Pool object to be updated
Returns:None
revert(pool, *args, **kwargs)[source]

Mark the pool as broken

Parameters:pool – Pool object that failed to update
Returns:None
class MarkPoolPendingDeleteInDB(**kwargs)[source]

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

Mark the pool pending delete in the DB.

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

execute(pool)[source]

Mark the pool as pending delete in DB.

Parameters:pool – Pool object to be updated
Returns:None
revert(pool, *args, **kwargs)[source]

Mark the pool as broken

Parameters:pool – Pool object that failed to update
Returns:None
class MarkPoolPendingUpdateInDB(**kwargs)[source]

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

Mark the pool pending update in the DB.

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

execute(pool)[source]

Mark the pool as pending update in DB.

Parameters:pool – Pool object to be updated
Returns:None
revert(pool, *args, **kwargs)[source]

Mark the pool as broken

Parameters:pool – Pool object that failed to update
Returns:None
class ReloadAmphora(**kwargs)[source]

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

Get an amphora object from the database.

execute(amphora_id)[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.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 TestLBStatusSetPendingInDB(**kwargs)[source]

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

Test the LB’s status to get a lock, and set it to PENDING_UPDATE

execute(loadbalancer_id)[source]
revert(loadbalancer_id, *args, **kwargs)[source]
class UpdateAmpFailoverDetails(**kwargs)[source]

Bases: octavia.controller.worker.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.tasks.database_tasks.BaseDatabaseTask

Update the amphora cert_busy flag to be false.

execute(amphora)[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.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.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.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.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.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.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.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.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.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.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.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.tasks.database_tasks.BaseDatabaseTask

Update the pool in the DB.

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

execute(pool, update_dict)[source]

Update the pool in the DB

Parameters:
  • pool – The pool to be updated
  • update_dict – The dictionary of updates to apply
Returns:

None

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

Mark the pool ERROR since the update couldn’t happen

Parameters:pool – The pool that couldn’t be updated
Returns:None
class UpdateVIPAfterAllocation(**kwargs)[source]

Bases: octavia.controller.worker.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.tasks.lifecycle_tasks module

class AmphoraIDToErrorOnRevertTask(**kwargs)[source]

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

Task to checkpoint Amphora lifecycle milestones.

execute(amphora_id)[source]
revert(amphora_id, *args, **kwargs)[source]
class AmphoraToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.tasks.lifecycle_tasks.AmphoraIDToErrorOnRevertTask

Task to checkpoint Amphora lifecycle milestones.

execute(amphora)[source]
revert(amphora, *args, **kwargs)[source]
class BaseLifecycleTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to instansiate common classes.

class HealthMonitorToErrorOnRevertTask(**kwargs)[source]

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

Task to set a member to ERROR on revert.

execute(health_mon, listeners, loadbalancer)[source]
revert(health_mon, listeners, loadbalancer, *args, **kwargs)[source]
class L7PolicyToErrorOnRevertTask(**kwargs)[source]

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

Task to set a l7policy to ERROR on revert.

execute(l7policy, listeners, loadbalancer)[source]
revert(l7policy, listeners, loadbalancer, *args, **kwargs)[source]
class L7RuleToErrorOnRevertTask(**kwargs)[source]

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

Task to set a l7rule to ERROR on revert.

execute(l7rule, listeners, loadbalancer)[source]
revert(l7rule, listeners, loadbalancer, *args, **kwargs)[source]
class ListenerToErrorOnRevertTask(**kwargs)[source]

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

Task to set a listener to ERROR on revert.

execute(listener)[source]
revert(listener, *args, **kwargs)[source]
class ListenersToErrorOnRevertTask(**kwargs)[source]

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

Task to set listeners to ERROR on revert.

execute(listeners, loadbalancer)[source]
revert(listeners, loadbalancer, *args, **kwargs)[source]
class LoadBalancerIDToErrorOnRevertTask(**kwargs)[source]

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

Task to set the load balancer to ERROR on revert.

execute(loadbalancer_id)[source]
revert(loadbalancer_id, *args, **kwargs)[source]
class LoadBalancerToErrorOnRevertTask(**kwargs)[source]

Bases: octavia.controller.worker.tasks.lifecycle_tasks.LoadBalancerIDToErrorOnRevertTask

Task to set the load balancer to ERROR on revert.

execute(loadbalancer)[source]
revert(loadbalancer, *args, **kwargs)[source]
class MemberToErrorOnRevertTask(**kwargs)[source]

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

Task to set a member to ERROR on revert.

execute(member, listeners, loadbalancer, pool)[source]
revert(member, listeners, loadbalancer, pool, *args, **kwargs)[source]
class PoolToErrorOnRevertTask(**kwargs)[source]

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

Task to set a pool to ERROR on revert.

execute(pool, listeners, loadbalancer)[source]
revert(pool, listeners, loadbalancer, *args, **kwargs)[source]

octavia.controller.worker.tasks.model_tasks module

class DeleteModelObject(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)[source]

Bases: taskflow.task.Task

Task to delete an object in a model.

execute(object)[source]
class UpdateAttributes(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)[source]

Bases: taskflow.task.Task

Task to update an object for changes.

execute(object, update_dict)[source]

octavia.controller.worker.tasks.network_tasks module

class AllocateVIP(**kwargs)[source]

Bases: octavia.controller.worker.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 BaseNetworkTask(**kwargs)[source]

Bases: taskflow.task.Task

Base task to load drivers common to the tasks.

class CalculateAmphoraDelta(**kwargs)[source]

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

default_provides = 'delta'
execute(loadbalancer, amphora)[source]
class CalculateDelta(**kwargs)[source]

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

Task to calculate the delta between

the nics on the amphora and the ones we need. Returns a list for plumbing them.

default_provides = 'deltas'
execute(loadbalancer)[source]

Compute which NICs need to be plugged

for the amphora to become operational.

Parameters:loadbalancer – the loadbalancer to calculate deltas for all amphorae
Returns:dict of octavia.network.data_models.Delta keyed off amphora id
class DeallocateVIP(**kwargs)[source]

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

Task to deallocate a VIP.

execute(loadbalancer)[source]

Deallocate a VIP.

class FailoverPreparationForAmphora(**kwargs)[source]

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

Task to prepare an amphora for failover.

execute(amphora)[source]
class GetAmphoraeNetworkConfigs(**kwargs)[source]

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

Task to retrieve amphorae network details.

execute(loadbalancer)[source]
class GetMemberPorts(**kwargs)[source]

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

execute(loadbalancer, amphora)[source]
class GetPlumbedNetworks(**kwargs)[source]

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

Task to figure out the NICS on an amphora.

This will likely move into the amphora driver :returns: Array of networks

default_provides = 'nics'
execute(amphora)[source]

Get plumbed networks for the amphora.

class HandleNetworkDeltas(**kwargs)[source]

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

Task to plug and unplug networks

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

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.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.tasks.network_tasks.BaseNetworkTask

Task to plug neutron ports into a compute instance.

execute(amphora, ports)[source]
class PlugVIP(**kwargs)[source]

Bases: octavia.controller.worker.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 PlugVIPPort(**kwargs)[source]

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

Task to plug a VIP into a compute instance.

execute(amphora, amphorae_network_config)[source]
revert(result, amphora, amphorae_network_config, *args, **kwargs)[source]
class RetrievePortIDsOnAmphoraExceptLBNetwork(**kwargs)[source]

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

Task retrieving all the port ids on an amphora, except lb network.

execute(amphora)[source]
class UnPlugNetworks(**kwargs)[source]

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

Task to unplug the networks

Loop over all nics and unplug them based on delta

execute(amphora, delta)[source]

Unplug the networks.

class UnplugVIP(**kwargs)[source]

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

Task to unplug the vip.

execute(loadbalancer)[source]

Unplug the vip.

class UpdateVIP(**kwargs)[source]

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

Task to update a VIP.

execute(loadbalancer)[source]
class WaitForPortDetach(**kwargs)[source]

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

Task to wait for the neutron ports to detach from an amphora.

execute(amphora)[source]

Module contents

Creative Commons Attribution 3.0 License

Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.