openstack
/
octavia
Code Issues Proposed changes

Transition amphora flows to dicts 

Fixed endpoints logs for listener, pool and member as well.

Rework _get_create_amp_for_lb_subflow due to issue with taskflow
decider and retry subflow.
Retry subflow was not ignored properly for spare amphorae case,
so _get_create_amp_for_lb_subflow has been split to
3 separate subflows each of them linked to graph flow.
This is work around and can be removed when proper mechanism
implemeneted in taskflow library. (added several todos about it).

Change-Id: Ibd114fa14123e6de6c5d6f260e32cf7f2b28805a
Story: 2005072
Task: 30814
This commit is contained in:
Ann Kamyshnikova 2019-07-03 16:59:19 +04:00
parent 1b6efa43f1
commit dad38f61f8
21 changed files with 968 additions and 613 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
octavia/amphorae/drivers/haproxy/rest_api_driver.py
View File

@ -378,10 +378,14 @@ class HaproxyAmphoraLoadBalancerDriver(
def finalize_amphora(self, amphora):
pass
def post_vip_plug(self, amphora, load_balancer, amphorae_network_config):
def post_vip_plug(self, amphora, load_balancer, amphorae_network_config,
vrrp_port=None, vip_subnet=None):
if amphora.status != consts.DELETED:
self._populate_amphora_api_version(amphora)
subnet = amphorae_network_config.get(amphora.id).vip_subnet
if vip_subnet is None:
subnet = amphorae_network_config.get(amphora.id).vip_subnet
else:
subnet = vip_subnet
# NOTE(blogan): using the vrrp port here because that
# is what the allowed address pairs network driver sets
# this particular port to. This does expose a bit of
@ -391,8 +395,12 @@ class HaproxyAmphoraLoadBalancerDriver(
# NOTE (johnsom): I am loading the vrrp_ip into the
# net_info structure here so that I don't break
# compatibility with old amphora agent versions.
port = amphorae_network_config.get(amphora.id).vrrp_port
if vrrp_port is None:
port = amphorae_network_config.get(amphora.id).vrrp_port
mtu = port.network.mtu
else:
port = vrrp_port
mtu = port.network['mtu']
LOG.debug("Post-VIP-Plugging with vrrp_ip %s vrrp_port %s",
amphora.vrrp_ip, port.id)
host_routes = [{'nexthop': hr.nexthop,
@ -402,7 +410,7 @@ class HaproxyAmphoraLoadBalancerDriver(
'gateway': subnet.gateway_ip,
'mac_address': port.mac_address,
'vrrp_ip': amphora.vrrp_ip,
'mtu': port.network.mtu,
'mtu': mtu,
'host_routes': host_routes}
try:
self.clients[amphora.api_version].plug_vip(

7
octavia/amphorae/drivers/keepalived/vrrp_rest_driver.py
View File

@ -47,7 +47,12 @@ class KeepalivedAmphoraDriverMixin(driver_base.VRRPDriverMixin):
self._populate_amphora_api_version(amp)
# Get the VIP subnet prefix for the amphora
vip_cidr = amphorae_network_config[amp.id].vip_subnet.cidr
# For amphorav2 amphorae_network_config will be list of dicts
try:
vip_cidr = amphorae_network_config[amp.id].vip_subnet.cidr
except AttributeError:
vip_cidr = amphorae_network_config[amp.id][
constants.VIP_SUBNET][constants.CIDR]
# Generate Keepalived configuration from loadbalancer object
config = templater.build_keepalived_config(

19
octavia/common/constants.py
View File

@ -293,6 +293,7 @@ SUPPORTED_TASKFLOW_ENGINE_TYPES = ['serial', 'parallel']
# Task/Flow constants
ACTIVE_CONNECTIONS = 'active_connections'
ADD_NICS = 'add_nics'
ADDED_PORTS = 'added_ports'
AMP_DATA = 'amp_data'
AMPHORA = 'amphora'
@ -305,7 +306,9 @@ AMPS_DATA = 'amps_data'
ANTI_AFFINITY = 'anti-affinity'
BYTES_IN = 'bytes_in'
BYTES_OUT = 'bytes_out'
CACHED_ZONE = 'cached_zone'
CA_TLS_CERTIFICATE_ID = 'ca_tls_certificate_id'
CIDR = 'cidr'
CLIENT_CA_TLS_CERTIFICATE_ID = 'client_ca_tls_certificate_id'
CLIENT_CRL_CONTAINER_ID = 'client_crl_container_id'
COMPUTE_ID = 'compute_id'
@ -316,6 +319,7 @@ CONN_RETRY_INTERVAL = 'conn_retry_interval'
CREATED_AT = 'created_at'
CRL_CONTAINER_ID = 'crl_container_id'
DEFAULT_TLS_CONTAINER_DATA = 'default_tls_container_data'
DELETE_NICS = 'delete_nics'
DELTA = 'delta'
DELTAS = 'deltas'
DESCRIPTION = 'description'
@ -324,13 +328,18 @@ FAILED_AMPHORA = 'failed_amphora'
FAILOVER_AMPHORA = 'failover_amphora'
FAILOVER_AMPHORA_ID = 'failover_amphora_id'
FIELDS = 'fields'
FIXED_IPS = 'fixed_ips'
FLAVOR_ID = 'flavor_id'
HA_IP = 'ha_ip'
HA_PORT_ID = 'ha_port_id'
HEALTH_MON = 'health_mon'
HEALTH_MONITOR = 'health_monitor'
HEALTH_MONITOR_ID = 'health_monitor_id'
HEALTH_MONITOR_UPDATES = 'health_monitor_updates'
ID = 'id'
IMAGE_ID = 'image_id'
IP_ADDRESS = 'ip_address'
LB_NETWORK_IP = 'lb_network_ip'
L7POLICY = 'l7policy'
L7POLICY_ID = 'l7policy_id'
L7POLICY_UPDATES = 'l7policy_updates'
@ -350,6 +359,7 @@ MEMBER_ID = 'member_id'
MEMBER_PORTS = 'member_ports'
MEMBER_UPDATES = 'member_updates'
NAME = 'name'
NETWORK = 'network'
NETWORK_ID = 'network_id'
NICS = 'nics'
OBJECT = 'object'
@ -371,11 +381,13 @@ REDIRECT_POOL = 'redirect_pool'
REQ_CONN_TIMEOUT = 'req_conn_timeout'
REQ_READ_TIMEOUT = 'req_read_timeout'
REQUEST_ERRORS = 'request_errors'
ROLE = 'role'
SERVER_GROUP_ID = 'server_group_id'
SERVER_PEM = 'server_pem'
SNI_CONTAINER_DATA = 'sni_container_data'
SNI_CONTAINERS = 'sni_containers'
SOFT_ANTI_AFFINITY = 'soft-anti-affinity'
STATUS = 'status'
SUBNET = 'subnet'
TAGS = 'tags'
TIMEOUT_DICT = 'timeout_dict'
@ -387,7 +399,13 @@ UPDATED_AT = 'updated_at'
UPDATE_DICT = 'update_dict'
VIP = 'vip'
VIP_NETWORK = 'vip_network'
VIP_SUBNET = 'vip_subnet'
VRRP_ID = 'vrrp_id'
VRRP_IP = 'vrrp_ip'
VRRP_GROUP = 'vrrp_group'
VRRP_PORT = 'vrrp_port'
VRRP_PORT_ID = 'vrrp_port_id'
VRRP_PRIORITY = 'vrrp_priority'
# Taskflow flow and task names
CERT_ROTATE_AMPHORA_FLOW = 'octavia-cert-rotate-amphora-flow'
@ -415,6 +433,7 @@ DELETE_POOL_FLOW = 'octavia-delete-pool-flow'
DELETE_L7POLICY_FLOW = 'octavia-delete-l7policy-flow'
DELETE_L7RULE_FLOW = 'octavia-delete-l7policy-flow'
FAILOVER_AMPHORA_FLOW = 'octavia-failover-amphora-flow'
FINALIZE_AMPHORA_FLOW = 'octavia-finalize-amphora-flow'
LOADBALANCER_NETWORKING_SUBFLOW = 'octavia-new-loadbalancer-net-subflow'
UPDATE_HEALTH_MONITOR_FLOW = 'octavia-update-health-monitor-flow'
UPDATE_LISTENER_FLOW = 'octavia-update-listener-flow'

23
octavia/controller/queue/v2/endpoints.py
View File

@ -63,28 +63,31 @@ class Endpoints(object):
self.worker.failover_amphora(amphora_id)
def create_listener(self, context, listener):
LOG.info('Creating listener \'%s\'...', listener.get(constants.ID))
LOG.info('Creating listener \'%s\'...',
listener[constants.LISTENER_ID])
self.worker.create_listener(listener)
def update_listener(self, context, original_listener, listener_updates):
LOG.info('Updating listener \'%s\'...', original_listener.get(
constants.ID))
LOG.info('Updating listener \'%s\'...',
original_listener[constants.LISTENER_ID])
self.worker.update_listener(original_listener, listener_updates)
def delete_listener(self, context, listener):
LOG.info('Deleting listener \'%s\'...', listener.get(constants.ID))
LOG.info('Deleting listener \'%s\'...',
listener[constants.LISTENER_ID])
self.worker.delete_listener(listener)
def create_pool(self, context, pool):
LOG.info('Creating pool \'%s\'...', pool.get(constants.ID))
LOG.info('Creating pool \'%s\'...', pool.get(constants.POOL_ID))
self.worker.create_pool(pool)
def update_pool(self, context, original_pool, pool_updates):
LOG.info('Updating pool \'%s\'...', original_pool.get(constants.ID))
LOG.info('Updating pool \'%s\'...',
original_pool.get(constants.POOL_ID))
self.worker.update_pool(original_pool, pool_updates)
def delete_pool(self, context, pool):
LOG.info('Deleting pool \'%s\'...', pool.get(constants.ID))
LOG.info('Deleting pool \'%s\'...', pool.get(constants.POOL_ID))
self.worker.delete_pool(pool)
def create_health_monitor(self, context, health_monitor_id):
@ -102,12 +105,12 @@ class Endpoints(object):
self.worker.delete_health_monitor(health_monitor_id)
def create_member(self, context, member):
LOG.info('Creating member \'%s\'...', member.get(constants.ID))
LOG.info('Creating member \'%s\'...', member.get(constants.MEMBER_ID))
self.worker.create_member(member)
def update_member(self, context, original_member, member_updates):
LOG.info('Updating member \'%s\'...', original_member.get(
constants.ID))
constants.MEMBER_ID))
self.worker.update_member(original_member, member_updates)
def batch_update_members(self, context, old_members, new_members,
@ -124,7 +127,7 @@ class Endpoints(object):
old_members, new_members, updated_members)
def delete_member(self, context, member):
LOG.info('Deleting member \'%s\'...', member.get(constants.ID))
LOG.info('Deleting member \'%s\'...', member.get(constants.MEMBER_ID))
self.worker.delete_member(member)
def create_l7policy(self, context, l7policy_id):

15
octavia/controller/worker/v2/controller_worker.py
View File

@ -121,9 +121,9 @@ class ControllerWorker(base_taskflow.BaseTaskFlowEngine):
"""
amphora = self._amphora_repo.get(db_apis.get_session(),
id=amphora_id)
delete_amp_tf = self._taskflow_load(self._amphora_flows.
get_delete_amphora_flow(),
store={constants.AMPHORA: amphora})
delete_amp_tf = self._taskflow_load(
self._amphora_flows.get_delete_amphora_flow(),
store={constants.AMPHORA: amphora.to_dict()})
with tf_logging.DynamicLoggingListener(delete_amp_tf,
log=LOG):
delete_amp_tf.run()
@ -833,8 +833,7 @@ class ControllerWorker(base_taskflow.BaseTaskFlowEngine):
:param priority: The create priority
:returns: None
"""
stored_params = {constants.FAILED_AMPHORA: amp,
stored_params = {constants.FAILED_AMPHORA: amp.to_dict(),
constants.LOADBALANCER_ID: amp.load_balancer_id,
constants.BUILD_TYPE_PRIORITY: priority, }
@ -993,8 +992,8 @@ class ControllerWorker(base_taskflow.BaseTaskFlowEngine):
certrotation_amphora_tf = self._taskflow_load(
self._amphora_flows.cert_rotate_amphora_flow(),
store={constants.AMPHORA: amp,
constants.AMPHORA_ID: amp.id})
store={constants.AMPHORA: amp.to_dict(),
constants.AMPHORA_ID: amphora_id})
with tf_logging.DynamicLoggingListener(certrotation_amphora_tf,
log=LOG):
@ -1022,7 +1021,7 @@ class ControllerWorker(base_taskflow.BaseTaskFlowEngine):
update_amphora_tf = self._taskflow_load(
self._amphora_flows.update_amphora_config_flow(),
store={constants.AMPHORA: amp,
store={constants.AMPHORA: amp.to_dict(),
constants.FLAVOR: flavor})
with tf_logging.DynamicLoggingListener(update_amphora_tf,

115
octavia/controller/worker/v2/flows/amphora_flows.py
View File

@ -30,10 +30,6 @@ CONF = cfg.CONF
class AmphoraFlows(object):
def __init__(self):
# for some reason only this has the values from the config file
self.REST_AMPHORA_DRIVER = (CONF.controller_worker.amphora_driver ==
'amphora_haproxy_rest_driver')
def get_create_amphora_flow(self):
"""Creates a flow to create an amphora.
@ -45,7 +41,8 @@ class AmphoraFlows(object):
provides=constants.AMPHORA_ID))
create_amphora_flow.add(lifecycle_tasks.AmphoraIDToErrorOnRevertTask(
requires=constants.AMPHORA_ID))
if self.REST_AMPHORA_DRIVER:
if (CONF.controller_worker.amphora_driver ==
'amphora_haproxy_rest_driver'):
create_amphora_flow.add(cert_task.GenerateServerPEMTask(
provides=constants.SERVER_PEM))
@ -79,7 +76,7 @@ class AmphoraFlows(object):
inject={'raise_retry_exception': True}))
create_amphora_flow.add(retry_subflow)
create_amphora_flow.add(database_tasks.ReloadAmphora(
requires=constants.AMPHORA_ID,
requires=constants.AMPHORA,
provides=constants.AMPHORA))
create_amphora_flow.add(amphora_driver_tasks.AmphoraFinalize(
requires=constants.AMPHORA))
@ -97,7 +94,7 @@ class AmphoraFlows(object):
post_map_amp_to_lb.add(database_tasks.ReloadAmphora(
name=sf_name + '-' + constants.RELOAD_AMPHORA,
requires=constants.AMPHORA_ID,
requires=constants.AMPHORA,
provides=constants.AMPHORA))
post_map_amp_to_lb.add(amphora_driver_tasks.AmphoraConfigUpdate(
@ -132,7 +129,8 @@ class AmphoraFlows(object):
role in (constants.ROLE_BACKUP, constants.ROLE_MASTER) and
CONF.nova.enable_anti_affinity)
if self.REST_AMPHORA_DRIVER:
if (CONF.controller_worker.amphora_driver ==
'amphora_haproxy_rest_driver'):
create_amp_for_lb_subflow.add(cert_task.GenerateServerPEMTask(
name=sf_name + '-' + constants.GENERATE_SERVER_PEM,
provides=constants.SERVER_PEM))
@ -202,40 +200,6 @@ class AmphoraFlows(object):
name=sf_name + '-' + constants.UPDATE_AMPHORA_INFO,
requires=(constants.AMPHORA_ID, constants.COMPUTE_OBJ),
provides=constants.AMPHORA))
retry_task = sf_name + '-' + constants.AMP_COMPUTE_CONNECTIVITY_WAIT
retry_subflow = linear_flow.Flow(
constants.CREATE_AMPHORA_RETRY_SUBFLOW,
retry=amphora_driver_tasks.AmpRetry())
retry_subflow.add(
amphora_driver_tasks.AmphoraComputeConnectivityWait(
name=retry_task, requires=constants.AMPHORA,
inject={'raise_retry_exception': True}))
create_amp_for_lb_subflow.add(retry_subflow)
create_amp_for_lb_subflow.add(amphora_driver_tasks.AmphoraFinalize(
name=sf_name + '-' + constants.AMPHORA_FINALIZE,
requires=constants.AMPHORA))
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraAllocatedInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_ALLOCATED_INDB,
requires=(constants.AMPHORA, constants.LOADBALANCER_ID)))
create_amp_for_lb_subflow.add(database_tasks.ReloadAmphora(
name=sf_name + '-' + constants.RELOAD_AMPHORA,
requires=constants.AMPHORA_ID,
provides=constants.AMPHORA))
if role == constants.ROLE_MASTER:
create_amp_for_lb_subflow.add(database_tasks.MarkAmphoraMasterInDB(
name=sf_name + '-' + constants.MARK_AMP_MASTER_INDB,
requires=constants.AMPHORA))
elif role == constants.ROLE_BACKUP:
create_amp_for_lb_subflow.add(database_tasks.MarkAmphoraBackupInDB(
name=sf_name + '-' + constants.MARK_AMP_BACKUP_INDB,
requires=constants.AMPHORA))
elif role == constants.ROLE_STANDALONE:
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraStandAloneInDB(
name=sf_name + '-' + constants.MARK_AMP_STANDALONE_INDB,
requires=constants.AMPHORA))
return create_amp_for_lb_subflow
@ -252,8 +216,49 @@ class AmphoraFlows(object):
:return: True if there is no spare amphora
"""
values = history.values()
return not values or list(values)[0] is None
return list(history.values())[0] is None
def _retry_flow(self, sf_name):
retry_task = sf_name + '-' + constants.AMP_COMPUTE_CONNECTIVITY_WAIT
retry_subflow = linear_flow.Flow(
sf_name + '-' + constants.CREATE_AMPHORA_RETRY_SUBFLOW,
retry=amphora_driver_tasks.AmpRetry())
retry_subflow.add(
amphora_driver_tasks.AmphoraComputeConnectivityWait(
name=retry_task, requires=constants.AMPHORA,
inject={'raise_retry_exception': True}))
return retry_subflow
def _finalize_flow(self, sf_name, role):
sf_name = sf_name + constants.FINALIZE_AMPHORA_FLOW
create_amp_for_lb_subflow = linear_flow.Flow(sf_name)
create_amp_for_lb_subflow.add(amphora_driver_tasks.AmphoraFinalize(
name=sf_name + '-' + constants.AMPHORA_FINALIZE,
requires=constants.AMPHORA))
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraAllocatedInDB(
name=sf_name + '-' + constants.MARK_AMPHORA_ALLOCATED_INDB,
requires=(constants.AMPHORA, constants.LOADBALANCER_ID)))
create_amp_for_lb_subflow.add(database_tasks.ReloadAmphora(
name=sf_name + '-' + constants.RELOAD_AMPHORA,
requires=constants.AMPHORA,
provides=constants.AMPHORA))
if role == constants.ROLE_MASTER:
create_amp_for_lb_subflow.add(database_tasks.MarkAmphoraMasterInDB(
name=sf_name + '-' + constants.MARK_AMP_MASTER_INDB,
requires=constants.AMPHORA))
elif role == constants.ROLE_BACKUP:
create_amp_for_lb_subflow.add(database_tasks.MarkAmphoraBackupInDB(
name=sf_name + '-' + constants.MARK_AMP_BACKUP_INDB,
requires=constants.AMPHORA))
elif role == constants.ROLE_STANDALONE:
create_amp_for_lb_subflow.add(
database_tasks.MarkAmphoraStandAloneInDB(
name=sf_name + '-' + constants.MARK_AMP_STANDALONE_INDB,
requires=constants.AMPHORA))
return create_amp_for_lb_subflow
def get_amphora_for_lb_subflow(
self, prefix, role=constants.ROLE_STANDALONE):
@ -272,16 +277,21 @@ class AmphoraFlows(object):
name=sf_name + '-' + constants.MAP_LOADBALANCER_TO_AMPHORA,
requires=(constants.LOADBALANCER_ID, constants.FLAVOR,
constants.AVAILABILITY_ZONE),
provides=constants.AMPHORA_ID)
provides=constants.AMPHORA)
# Define a subflow for if we successfully map an amphora
map_lb_to_amp = self._get_post_map_lb_subflow(prefix, role)
# Define a subflow for if we can't map an amphora
create_amp = self._get_create_amp_for_lb_subflow(prefix, role)
# TODO(ataraday): Have to split create flow due lack of functionality
# in taskflow: related https://bugs.launchpad.net/taskflow/+bug/1480907
retry_flow = self._retry_flow(sf_name)
finalize_flow = self._finalize_flow(sf_name, role)
# Add them to the graph flow
amp_for_lb_flow.add(allocate_and_associate_amp,
map_lb_to_amp, create_amp)
map_lb_to_amp, create_amp,
retry_flow, finalize_flow, resolve_requires=False)
# Setup the decider for the path if we can map an amphora
amp_for_lb_flow.link(allocate_and_associate_amp, map_lb_to_amp,
@ -291,6 +301,15 @@ class AmphoraFlows(object):
amp_for_lb_flow.link(allocate_and_associate_amp, create_amp,
decider=self._create_new_amp_for_lb_decider,
decider_depth='flow')
# TODO(ataraday): setup separate deciders as we need retry flow
# properly ignored
amp_for_lb_flow.link(create_amp, retry_flow,
decider=self._create_new_amp_for_lb_decider,
decider_depth='flow')
amp_for_lb_flow.link(retry_flow, finalize_flow,
decider=self._create_new_amp_for_lb_decider,
decider_depth='flow')
# Plug the network
# todo(xgerman): Rework failover flow
@ -320,7 +339,7 @@ class AmphoraFlows(object):
requires=constants.AMP_DATA))
flows.append(database_tasks.ReloadAmphora(
name=sf_name + '-' + constants.RELOAD_AMP_AFTER_PLUG_VIP,
requires=constants.AMPHORA_ID,
requires=constants.AMPHORA,
provides=constants.AMPHORA))
flows.append(database_tasks.ReloadLoadBalancer(
name=sf_name + '-' + constants.RELOAD_LB_AFTER_PLUG_VIP,
@ -444,7 +463,7 @@ class AmphoraFlows(object):
provides=constants.LOADBALANCER))
failover_amphora_flow.add(database_tasks.ReloadAmphora(
requires=constants.AMPHORA_ID,
requires=constants.AMPHORA,
provides=constants.AMPHORA))
# Prepare to reconnect the network interface(s)
@ -596,7 +615,7 @@ class AmphoraFlows(object):
# update the cert_busy flag to be false after rotation
rotated_amphora_flow.add(database_tasks.UpdateAmphoraCertBusyToFalse(
requires=constants.AMPHORA))
requires=constants.AMPHORA_ID))
return rotated_amphora_flow

87
octavia/controller/worker/v2/tasks/amphora_driver_tasks.py
View File

@ -29,6 +29,7 @@ from octavia.common import utils
from octavia.controller.worker import task_utils as task_utilities
from octavia.db import api as db_apis
from octavia.db import repositories as repo
from octavia.network import data_models
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
@ -78,10 +79,15 @@ class AmpListenersUpdate(BaseAmphoraTask):
# in a failover flow with both amps failing. Skip it and let
# health manager fix it.
try:
db_amphorae = []
for amp in amphorae:
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amp[constants.ID])
db_amphorae.append(db_amp)
self.amphora_driver.update_amphora_listeners(
loadbalancer, amphorae[amphora_index], timeout_dict)
loadbalancer, db_amphorae[amphora_index], timeout_dict)
except Exception as e:
amphora_id = amphorae[amphora_index].id
amphora_id = amphorae[amphora_index].get(constants.ID)
LOG.error('Failed to update listeners on amphora %s. Skipping '
'this amphora as it is failing to update due to: %s',
amphora_id, str(e))
@ -119,7 +125,12 @@ class ListenersStart(BaseAmphoraTask):
def execute(self, loadbalancer, amphora=None):
"""Execute listener start routines for listeners on an amphora."""
if loadbalancer.listeners:
self.amphora_driver.start(loadbalancer, amphora)
if amphora is not None:
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID])
else:
db_amp = amphora
self.amphora_driver.start(loadbalancer, db_amp)
LOG.debug("Started the listeners on the vip")
def revert(self, loadbalancer, *args, **kwargs):
@ -154,7 +165,9 @@ class AmphoraGetInfo(BaseAmphoraTask):
def execute(self, amphora):
"""Execute get_info routine for an amphora."""
self.amphora_driver.get_info(amphora)
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID])
self.amphora_driver.get_info(db_amp)
class AmphoraGetDiagnostics(BaseAmphoraTask):
@ -170,7 +183,9 @@ class AmphoraFinalize(BaseAmphoraTask):
def execute(self, amphora):
"""Execute finalize_amphora routine."""
self.amphora_driver.finalize_amphora(amphora)
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora.get(constants.ID))
self.amphora_driver.finalize_amphora(db_amp)
LOG.debug("Finalized the amphora.")
def revert(self, result, amphora, *args, **kwargs):
@ -178,7 +193,8 @@ class AmphoraFinalize(BaseAmphoraTask):
if isinstance(result, failure.Failure):
return
LOG.warning("Reverting amphora finalize.")
self.task_utils.mark_amphora_status_error(amphora.id)
self.task_utils.mark_amphora_status_error(
amphora.get(constants.ID))
class AmphoraPostNetworkPlug(BaseAmphoraTask):
@ -186,18 +202,30 @@ class AmphoraPostNetworkPlug(BaseAmphoraTask):
def execute(self, amphora, ports):
"""Execute post_network_plug routine."""
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID])
for port in ports:
self.amphora_driver.post_network_plug(amphora, port)
net = data_models.Network(**port.pop(constants.NETWORK))
ips = port.pop(constants.FIXED_IPS)
fixed_ips = [data_models.FixedIP(
subnet=data_models.Subnet(**ip.pop(constants.SUBNET)), **ip)
for ip in ips]
self.amphora_driver.post_network_plug(
db_amp, data_models.Port(network=net, fixed_ips=fixed_ips,
**port))
LOG.debug("post_network_plug called on compute instance "
"%(compute_id)s for port %(port_id)s",
{"compute_id": amphora.compute_id, "port_id": port.id})
{"compute_id": amphora[constants.COMPUTE_ID],
"port_id": port[constants.ID]})
def revert(self, result, amphora, *args, **kwargs):
"""Handle a failed post network plug."""
if isinstance(result, failure.Failure):
return
LOG.warning("Reverting post network plug.")
self.task_utils.mark_amphora_status_error(amphora.id)
self.task_utils.mark_amphora_status_error(amphora.get(constants.ID))
class AmphoraePostNetworkPlug(BaseAmphoraTask):
@ -208,7 +236,8 @@ class AmphoraePostNetworkPlug(BaseAmphoraTask):
amp_post_plug = AmphoraPostNetworkPlug()
for amphora in loadbalancer.amphorae:
if amphora.id in added_ports:
amp_post_plug.execute(amphora, added_ports[amphora.id])
amp_post_plug.execute(amphora.to_dict(),
added_ports[amphora.id])
def revert(self, result, loadbalancer, added_ports, *args, **kwargs):
"""Handle a failed post network plug."""
@ -227,8 +256,17 @@ class AmphoraPostVIPPlug(BaseAmphoraTask):
def execute(self, amphora, loadbalancer, amphorae_network_config):
"""Execute post_vip_routine."""
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora.get(constants.ID))
vrrp_port = data_models.Port(
**amphorae_network_config[
amphora.get(constants.ID)][constants.VRRP_PORT])
vip_subnet = data_models.Subnet(
**amphorae_network_config[
amphora.get(constants.ID)][constants.VIP_SUBNET])
self.amphora_driver.post_vip_plug(
amphora, loadbalancer, amphorae_network_config)
db_amp, loadbalancer, amphorae_network_config, vrrp_port=vrrp_port,
vip_subnet=vip_subnet)
LOG.debug("Notified amphora of vip plug")
def revert(self, result, amphora, loadbalancer, *args, **kwargs):
@ -236,7 +274,7 @@ class AmphoraPostVIPPlug(BaseAmphoraTask):
if isinstance(result, failure.Failure):
return
LOG.warning("Reverting post vip plug.")
self.task_utils.mark_amphora_status_error(amphora.id)
self.task_utils.mark_amphora_status_error(amphora.get(constants.ID))
self.task_utils.mark_loadbalancer_prov_status_error(loadbalancer.id)
@ -267,7 +305,10 @@ class AmphoraCertUpload(BaseAmphoraTask):
LOG.debug("Upload cert in amphora REST driver")
key = utils.get_six_compatible_server_certs_key_passphrase()
fer = fernet.Fernet(key)
self.amphora_driver.upload_cert_amp(amphora, fer.decrypt(server_pem))
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora.get(constants.ID))
self.amphora_driver.upload_cert_amp(
db_amp, fer.decrypt(server_pem.encode('utf-8')))
class AmphoraUpdateVRRPInterface(BaseAmphoraTask):
@ -357,16 +398,19 @@ class AmphoraComputeConnectivityWait(BaseAmphoraTask):
def execute(self, amphora, raise_retry_exception=False):
"""Execute get_info routine for an amphora until it responds."""
try:
db_amphora = self.amphora_repo.get(
db_apis.get_session(), id=amphora.get(constants.ID))
amp_info = self.amphora_driver.get_info(
amphora, raise_retry_exception=raise_retry_exception)
db_amphora, raise_retry_exception=raise_retry_exception)
LOG.debug('Successfuly connected to amphora %s: %s',
amphora.id, amp_info)
amphora.get(constants.ID), amp_info)
except driver_except.TimeOutException:
LOG.error("Amphora compute instance failed to become reachable. "
"This either means the compute driver failed to fully "
"boot the instance inside the timeout interval or the "
"instance is not reachable via the lb-mgmt-net.")
self.amphora_repo.update(db_apis.get_session(), amphora.id,
self.amphora_repo.update(db_apis.get_session(),
amphora.get(constants.ID),
status=constants.ERROR)
raise
@ -384,13 +428,16 @@ class AmphoraConfigUpdate(BaseAmphoraTask):
# Build the amphora agent config
agent_cfg_tmpl = agent_jinja_cfg.AgentJinjaTemplater()
agent_config = agent_cfg_tmpl.build_agent_config(amphora.id, topology)
agent_config = agent_cfg_tmpl.build_agent_config(
amphora.get(constants.ID), topology)
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID])
# Push the new configuration to the amphroa
try:
self.amphora_driver.update_amphora_agent_config(amphora,
self.amphora_driver.update_amphora_agent_config(db_amp,
agent_config)
except driver_except.AmpDriverNotImplementedError:
LOG.error('Amphora {} does not support agent configuration '
'update. Please update the amphora image for this '
'amphora. Skipping.'.format(amphora.id))
'amphora. Skipping.'.
format(amphora.get(constants.ID)))

4
octavia/controller/worker/v2/tasks/cert_task.py
View File

@ -48,4 +48,6 @@ class GenerateServerPEMTask(BaseCertTask):
key = utils.get_six_compatible_server_certs_key_passphrase()
fer = fernet.Fernet(key)
return fer.encrypt(cert.certificate + cert.private_key)
# storing in db requires conversion bytes to string
# (required for python3)
return fer.encrypt(cert.certificate + cert.private_key).decode('utf-8')

12
octavia/controller/worker/v2/tasks/compute_tasks.py
View File

@ -163,7 +163,8 @@ class CertComputeCreate(ComputeCreate):
key = utils.get_six_compatible_server_certs_key_passphrase()
fer = fernet.Fernet(key)
config_drive_files = {
'/etc/octavia/certs/server.pem': fer.decrypt(server_pem),
'/etc/octavia/certs/server.pem': fer.decrypt(
server_pem.encode("utf-8")),
'/etc/octavia/certs/client_ca.pem': ca}
return super(CertComputeCreate, self).execute(
amphora_id, config_drive_files=config_drive_files,
@ -191,13 +192,14 @@ class DeleteAmphoraeOnLoadBalancer(BaseComputeTask):
class ComputeDelete(BaseComputeTask):
def execute(self, amphora):
LOG.debug("Compute Delete execute for amphora with id %s", amphora.id)
LOG.debug("Compute Delete execute for amphora with id %s",
amphora.get(constants.ID))
try:
self.compute.delete(amphora.compute_id)
self.compute.delete(amphora[constants.COMPUTE_ID])
except Exception:
LOG.exception("Compute delete for amphora id: %s failed",
amphora.id)
amphora.get(constants.ID))
raise
@ -215,7 +217,7 @@ class ComputeActiveWait(BaseComputeTask):
if amp.status == constants.ACTIVE:
if CONF.haproxy_amphora.build_rate_limit != -1:
self.rate_limit.remove_from_build_req_queue(amphora_id)
return amp
return amp.to_dict()
if amp.status == constants.ERROR:
raise exceptions.ComputeBuildException(fault=fault)
time.sleep(CONF.controller_worker.amp_active_wait_sec)

202
octavia/controller/worker/v2/tasks/database_tasks.py
View File

@ -372,15 +372,17 @@ class DeleteL7RuleInDB(BaseDatabaseTask):
class ReloadAmphora(BaseDatabaseTask):
"""Get an amphora object from the database."""
def execute(self, amphora_id):
def execute(self, amphora):
"""Get an amphora object from the database.
:param amphora_id: The amphora ID to lookup
:returns: The amphora object
"""
LOG.debug("Get amphora from DB for amphora id: %s ", amphora_id)
return self.amphora_repo.get(db_apis.get_session(), id=amphora_id)
LOG.debug("Get amphora from DB for amphora id: %s ",
amphora[constants.ID])
return self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID]).to_dict()
class ReloadLoadBalancer(BaseDatabaseTask):
@ -427,12 +429,14 @@ class UpdateAmphoraeVIPData(BaseDatabaseTask):
:returns: None
"""
for amp_data in amps_data:
self.repos.amphora.update(db_apis.get_session(), amp_data.id,
vrrp_ip=amp_data.vrrp_ip,
ha_ip=amp_data.ha_ip,
vrrp_port_id=amp_data.vrrp_port_id,
ha_port_id=amp_data.ha_port_id,
vrrp_id=1)
self.repos.amphora.update(
db_apis.get_session(),
amp_data.get(constants.ID),
vrrp_ip=amp_data[constants.VRRP_IP],
ha_ip=amp_data[constants.HA_IP],
vrrp_port_id=amp_data[constants.VRRP_PORT_ID],
ha_port_id=amp_data[constants.HA_PORT_ID],
vrrp_id=1)
class UpdateAmphoraVIPData(BaseDatabaseTask):
@ -444,12 +448,14 @@ class UpdateAmphoraVIPData(BaseDatabaseTask):
:param amps_data: Amphorae update dicts.
:returns: None
"""
self.repos.amphora.update(db_apis.get_session(), amp_data.id,
vrrp_ip=amp_data.vrrp_ip,
ha_ip=amp_data.ha_ip,
vrrp_port_id=amp_data.vrrp_port_id,
ha_port_id=amp_data.ha_port_id,
vrrp_id=1)
self.repos.amphora.update(
db_apis.get_session(),
amp_data.get(constants.ID),
vrrp_ip=amp_data[constants.VRRP_IP],
ha_ip=amp_data[constants.HA_IP],
vrrp_port_id=amp_data[constants.VRRP_PORT_ID],
ha_port_id=amp_data[constants.HA_PORT_ID],
vrrp_id=1)
class UpdateAmpFailoverDetails(BaseDatabaseTask):
@ -463,12 +469,14 @@ class UpdateAmpFailoverDetails(BaseDatabaseTask):
:returns: None
"""
# role and vrrp_priority will be updated later.
self.repos.amphora.update(db_apis.get_session(), amphora.id,
vrrp_ip=amp_data.vrrp_ip,
ha_ip=amp_data.ha_ip,
vrrp_port_id=amp_data.vrrp_port_id,
ha_port_id=amp_data.ha_port_id,
vrrp_id=amp_data.vrrp_id)
self.repos.amphora.update(
db_apis.get_session(),
amphora.get(constants.ID),
vrrp_ip=amp_data[constants.VRRP_IP],
ha_ip=amp_data[constants.HA_IP],
vrrp_port_id=amp_data[constants.VRRP_PORT_ID],
ha_port_id=amp_data[constants.HA_PORT_ID],
vrrp_id=amp_data[constants.VRRP_ID])
class AssociateFailoverAmphoraWithLBID(BaseDatabaseTask):
@ -545,8 +553,9 @@ class MapLoadbalancerToAmphora(BaseDatabaseTask):
LOG.debug("Allocated Amphora with id %(amp)s for load balancer "
"with id %(lb)s", {'amp': amp.id, 'lb': loadbalancer_id})
return amp.id
# TODO(ataraday): return AMP here so refactored spit of create amp for
# loadbalancer flow can executed properly
return amp.to_dict()
def revert(self, result, loadbalancer_id, *args, **kwargs):
LOG.warning("Reverting Amphora allocation for the load "
@ -566,8 +575,9 @@ class _MarkAmphoraRoleAndPriorityInDB(BaseDatabaseTask):
:returns: None
"""
LOG.debug("Mark %(role)s in DB for amphora: %(amp)s",
{'role': amp_role, 'amp': amphora.id})
self.amphora_repo.update(db_apis.get_session(), amphora.id,
{constants.ROLE: amp_role, 'amp': amphora[constants.ID]})
self.amphora_repo.update(db_apis.get_session(),
amphora[constants.ID],
role=amp_role,
vrrp_priority=vrrp_priority)
@ -584,15 +594,17 @@ class _MarkAmphoraRoleAndPriorityInDB(BaseDatabaseTask):
return
LOG.warning("Reverting amphora role in DB for amp id %(amp)s",
{'amp': amphora.id})
{'amp': amphora[constants.ID]})
try:
self.amphora_repo.update(db_apis.get_session(), amphora.id,
self.amphora_repo.update(db_apis.get_session(),
amphora[constants.ID],
role=None,
vrrp_priority=None)
except Exception as e:
LOG.error("Failed to update amphora %(amp)s "
"role and vrrp_priority to None due to: "
"%(except)s", {'amp': amphora.id, 'except': e})
"%(except)s", {'amp': amphora[constants.ID],
'except': e})
class MarkAmphoraMasterInDB(_MarkAmphoraRoleAndPriorityInDB):
@ -677,15 +689,17 @@ class MarkAmphoraAllocatedInDB(BaseDatabaseTask):
LOG.info('Mark ALLOCATED in DB for amphora: %(amp)s with '
'compute id %(comp)s for load balancer: %(lb)s',
{
'amp': amphora.id,
'comp': amphora.compute_id,
'amp': amphora.get(constants.ID),
'comp': amphora[constants.COMPUTE_ID],
'lb': loadbalancer_id
})
self.amphora_repo.update(db_apis.get_session(), amphora.id,
status=constants.AMPHORA_ALLOCATED,
compute_id=amphora.compute_id,
lb_network_ip=amphora.lb_network_ip,
load_balancer_id=loadbalancer_id)
self.amphora_repo.update(
db_apis.get_session(),
amphora.get(constants.ID),
status=constants.AMPHORA_ALLOCATED,
compute_id=amphora[constants.COMPUTE_ID],
lb_network_ip=amphora[constants.LB_NETWORK_IP],
load_balancer_id=loadbalancer_id)
def revert(self, result, amphora, loadbalancer_id, *args, **kwargs):
"""Mark the amphora as broken and ready to be cleaned up.
@ -702,8 +716,10 @@ class MarkAmphoraAllocatedInDB(BaseDatabaseTask):
LOG.warning("Reverting mark amphora ready in DB for amp "
"id %(amp)s and compute id %(comp)s",
{'amp': amphora.id, 'comp': amphora.compute_id})
self.task_utils.mark_amphora_status_error(amphora.id)
{'amp': amphora.get(constants.ID),
'comp': amphora[constants.COMPUTE_ID]})
self.task_utils.mark_amphora_status_error(
amphora.get(constants.ID))
class MarkAmphoraBootingInDB(BaseDatabaseTask):
@ -718,7 +734,8 @@ class MarkAmphoraBootingInDB(BaseDatabaseTask):
"""
LOG.debug("Mark BOOTING in DB for amphora: %(amp)s with "
"compute id %(id)s", {'amp': amphora_id, 'id': compute_id})
"compute id %(id)s", {'amp': amphora_id,
constants.ID: compute_id})
self.amphora_repo.update(db_apis.get_session(), amphora_id,
status=constants.AMPHORA_BOOTING,
compute_id=compute_id)
@ -763,8 +780,10 @@ class MarkAmphoraDeletedInDB(BaseDatabaseTask):
LOG.debug("Mark DELETED in DB for amphora: %(amp)s with "
"compute id %(comp)s",
{'amp': amphora.id, 'comp': amphora.compute_id})
self.amphora_repo.update(db_apis.get_session(), amphora.id,
{'amp': amphora.get(constants.ID),
'comp': amphora[constants.COMPUTE_ID]})
self.amphora_repo.update(db_apis.get_session(),
amphora.get(constants.ID),
status=constants.DELETED)
def revert(self, amphora, *args, **kwargs):
@ -776,8 +795,10 @@ class MarkAmphoraDeletedInDB(BaseDatabaseTask):
LOG.warning("Reverting mark amphora deleted in DB "
"for amp id %(amp)s and compute id %(comp)s",
{'amp': amphora.id, 'comp': amphora.compute_id})
self.task_utils.mark_amphora_status_error(amphora.id)
{'amp': amphora.get(constants.ID),
'comp': amphora[constants.COMPUTE_ID]})
self.task_utils.mark_amphora_status_error(amphora.get(constants.ID))
class MarkAmphoraPendingDeleteInDB(BaseDatabaseTask):
@ -795,8 +816,10 @@ class MarkAmphoraPendingDeleteInDB(BaseDatabaseTask):
LOG.debug("Mark PENDING DELETE in DB for amphora: %(amp)s "
"with compute id %(id)s",
{'amp': amphora.id, 'id': amphora.compute_id})
self.amphora_repo.update(db_apis.get_session(), amphora.id,
{'amp': amphora.get(constants.ID),
'id': amphora[constants.COMPUTE_ID]})
self.amphora_repo.update(db_apis.get_session(),
amphora.get(constants.ID),
status=constants.PENDING_DELETE)
def revert(self, amphora, *args, **kwargs):
@ -808,8 +831,9 @@ class MarkAmphoraPendingDeleteInDB(BaseDatabaseTask):
LOG.warning("Reverting mark amphora pending delete in DB "
"for amp id %(amp)s and compute id %(comp)s",
{'amp': amphora.id, 'comp': amphora.compute_id})
self.task_utils.mark_amphora_status_error(amphora.id)
{'amp': amphora.get(constants.ID),
'comp': amphora[constants.COMPUTE_ID]})
self.task_utils.mark_amphora_status_error(amphora.get(constants.ID))
class MarkAmphoraPendingUpdateInDB(BaseDatabaseTask):
@ -827,8 +851,10 @@ class MarkAmphoraPendingUpdateInDB(BaseDatabaseTask):
LOG.debug("Mark PENDING UPDATE in DB for amphora: %(amp)s "
"with compute id %(id)s",
{'amp': amphora.id, 'id': amphora.compute_id})
self.amphora_repo.update(db_apis.get_session(), amphora.id,
{'amp': amphora.get(constants.ID),
'id': amphora[constants.COMPUTE_ID]})
self.amphora_repo.update(db_apis.get_session(),
amphora.get(constants.ID),
status=constants.PENDING_UPDATE)
def revert(self, amphora, *args, **kwargs):
@ -840,8 +866,9 @@ class MarkAmphoraPendingUpdateInDB(BaseDatabaseTask):
LOG.warning("Reverting mark amphora pending update in DB "
"for amp id %(amp)s and compute id %(comp)s",
{'amp': amphora.id, 'comp': amphora.compute_id})
self.task_utils.mark_amphora_status_error(amphora.id)
{'amp': amphora.get(constants.ID),
'comp': amphora[constants.COMPUTE_ID]})
self.task_utils.mark_amphora_status_error(amphora.get(constants.ID))
class MarkAmphoraReadyInDB(BaseDatabaseTask):
@ -860,11 +887,14 @@ class MarkAmphoraReadyInDB(BaseDatabaseTask):
LOG.info("Mark READY in DB for amphora: %(amp)s with compute "
"id %(comp)s",
{"amp": amphora.id, "comp": amphora.compute_id})
self.amphora_repo.update(db_apis.get_session(), amphora.id,
status=constants.AMPHORA_READY,
compute_id=amphora.compute_id,
lb_network_ip=amphora.lb_network_ip)
{"amp": amphora.get(constants.ID),
"comp": amphora[constants.COMPUTE_ID]})
self.amphora_repo.update(
db_apis.get_session(),
amphora.get(constants.ID),
status=constants.AMPHORA_READY,
compute_id=amphora[constants.COMPUTE_ID],
lb_network_ip=amphora[constants.LB_NETWORK_IP])
def revert(self, amphora, *args, **kwargs):
"""Mark the amphora as broken and ready to be cleaned up.
@ -875,16 +905,20 @@ class MarkAmphoraReadyInDB(BaseDatabaseTask):
LOG.warning("Reverting mark amphora ready in DB for amp "
"id %(amp)s and compute id %(comp)s",
{'amp': amphora.id, 'comp': amphora.compute_id})
{'amp': amphora.get(constants.ID),
'comp': amphora[constants.COMPUTE_ID]})
try:
self.amphora_repo.update(db_apis.get_session(), amphora.id,
status=constants.ERROR,
compute_id=amphora.compute_id,
lb_network_ip=amphora.lb_network_ip)
self.amphora_repo.update(
db_apis.get_session(),
amphora.get(constants.ID),
status=constants.ERROR,
compute_id=amphora[constants.COMPUTE_ID],
lb_network_ip=amphora[constants.LB_NETWORK_IP])
except Exception as e:
LOG.error("Failed to update amphora %(amp)s "
"status to ERROR due to: "
"%(except)s", {'amp': amphora.id, 'except': e})
"%(except)s", {'amp': amphora.get(constants.ID),
'except': e})
class UpdateAmphoraComputeId(BaseDatabaseTask):
@ -914,11 +948,12 @@ class UpdateAmphoraInfo(BaseDatabaseTask):
"""
self.amphora_repo.update(
db_apis.get_session(), amphora_id,
lb_network_ip=compute_obj.lb_network_ip,
cached_zone=compute_obj.cached_zone,
image_id=compute_obj.image_id,
compute_flavor=compute_obj.compute_flavor)
return self.amphora_repo.get(db_apis.get_session(), id=amphora_id)
lb_network_ip=compute_obj[constants.LB_NETWORK_IP],
cached_zone=compute_obj[constants.CACHED_ZONE],
image_id=compute_obj[constants.IMAGE_ID],
compute_flavor=compute_obj[constants.COMPUTE_FLAVOR])
return self.amphora_repo.get(db_apis.get_session(),
id=amphora_id).to_dict()
class UpdateAmphoraDBCertExpiration(BaseDatabaseTask):
@ -937,7 +972,7 @@ class UpdateAmphoraDBCertExpiration(BaseDatabaseTask):
key = utils.get_six_compatible_server_certs_key_passphrase()
fer = fernet.Fernet(key)
cert_expiration = cert_parser.get_cert_expiration(
fer.decrypt(server_pem))
fer.decrypt(server_pem.encode("utf-8")))
LOG.debug("Certificate expiration date is %s ", cert_expiration)
self.amphora_repo.update(db_apis.get_session(), amphora_id,
cert_expiration=cert_expiration)
@ -946,7 +981,7 @@ class UpdateAmphoraDBCertExpiration(BaseDatabaseTask):
class UpdateAmphoraCertBusyToFalse(BaseDatabaseTask):
"""Update the amphora cert_busy flag to be false."""
def execute(self, amphora):
def execute(self, amphora_id):
"""Update the amphora cert_busy flag to be false.
:param amphora: Amphora to be updated.
@ -954,8 +989,8 @@ class UpdateAmphoraCertBusyToFalse(BaseDatabaseTask):
"""
LOG.debug("Update cert_busy flag of amphora id %s to False",
amphora.id)
self.amphora_repo.update(db_apis.get_session(), amphora.id,
amphora_id)
self.amphora_repo.update(db_apis.get_session(), amphora_id,
cert_busy=False)
@ -1584,16 +1619,19 @@ class GetAmphoraDetails(BaseDatabaseTask):
"""Retrieve amphora network details.
:param amphora: Amphora which network details are required
:returns: data_models.Amphora object
:returns: Amphora data dict
"""
return data_models.Amphora(id=amphora.id,
vrrp_ip=amphora.vrrp_ip,
ha_ip=amphora.ha_ip,
vrrp_port_id=amphora.vrrp_port_id,
ha_port_id=amphora.ha_port_id,
role=amphora.role,
vrrp_id=amphora.vrrp_id,
vrrp_priority=amphora.vrrp_priority)
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora.get(constants.ID))
amphora.update({
constants.VRRP_IP: db_amp.vrrp_ip,
constants.HA_IP: db_amp.ha_ip,
constants.HA_PORT_ID: db_amp.ha_port_id,
constants.ROLE: db_amp.role,
constants.VRRP_ID: db_amp.vrrp_id,
constants.VRRP_PRIORITY: db_amp.vrrp_priority
})
return amphora
class GetAmphoraeFromLoadbalancer(BaseDatabaseTask):
@ -1611,7 +1649,7 @@ class GetAmphoraeFromLoadbalancer(BaseDatabaseTask):
show_deleted=False)
if a is None:
continue
amphorae.append(a)
amphorae.append(a.to_dict())
return amphorae
@ -1683,7 +1721,7 @@ class DisableAmphoraHealthMonitoring(BaseDatabaseTask):
:param amphora: The amphora to disable health monitoring for
:returns: None
"""
self._delete_from_amp_health(amphora.id)
self._delete_from_amp_health(amphora.get(constants.ID))
class DisableLBAmphoraeHealthMonitoring(BaseDatabaseTask):
@ -1716,7 +1754,7 @@ class MarkAmphoraHealthBusy(BaseDatabaseTask):
:param amphora: The amphora to mark amphora health busy
:returns: None
"""
self._mark_amp_health_busy(amphora.id)
self._mark_amp_health_busy(amphora.get(constants.ID))
class MarkLBAmphoraeHealthBusy(BaseDatabaseTask):

3
octavia/controller/worker/v2/tasks/lifecycle_tasks.py
View File

@ -43,7 +43,8 @@ class AmphoraToErrorOnRevertTask(AmphoraIDToErrorOnRevertTask):
pass
def revert(self, amphora, *args, **kwargs):
super(AmphoraToErrorOnRevertTask, self).revert(amphora.id)
super(AmphoraToErrorOnRevertTask, self).revert(
amphora.get(constants.ID))
class HealthMonitorToErrorOnRevertTask(BaseLifecycleTask):

224
octavia/controller/worker/v2/tasks/network_tasks.py
View File

@ -39,6 +39,7 @@ class BaseNetworkTask(task.Task):
self._network_driver = None
self.task_utils = task_utils.TaskUtils()
self.loadbalancer_repo = repo.LoadBalancerRepository()
self.amphora_repo = repo.AmphoraRepository()
@property
def network_driver(self):
@ -52,11 +53,13 @@ class CalculateAmphoraDelta(BaseNetworkTask):
default_provides = constants.DELTA
def execute(self, loadbalancer, amphora):
LOG.debug("Calculating network delta for amphora id: %s", amphora.id)
LOG.debug("Calculating network delta for amphora id: %s",
amphora.get(constants.ID))
# Figure out what networks we want
# seed with lb network(s)
vrrp_port = self.network_driver.get_port(amphora.vrrp_port_id)
vrrp_port = self.network_driver.get_port(
amphora[constants.VRRP_PORT_ID])
desired_network_ids = {vrrp_port.network_id}.union(
CONF.controller_worker.amp_boot_network_list)
@ -68,7 +71,8 @@ class CalculateAmphoraDelta(BaseNetworkTask):
]
desired_network_ids.update(member_networks)
nics = self.network_driver.get_plugged_networks(amphora.compute_id)
nics = self.network_driver.get_plugged_networks(
amphora[constants.COMPUTE_ID])
# assume we don't have two nics in the same network
actual_network_nics = dict((nic.network_id, nic) for nic in nics)
@ -80,9 +84,10 @@ class CalculateAmphoraDelta(BaseNetworkTask):
add_nics = list(n_data_models.Interface(
network_id=net_id) for net_id in add_ids)
delta = n_data_models.Delta(
amphora_id=amphora.id, compute_id=amphora.compute_id,
amphora_id=amphora[constants.ID],
compute_id=amphora[constants.COMPUTE_ID],
add_nics=add_nics, delete_nics=delete_nics)
return delta
return delta.to_dict(recurse=True)
class CalculateDelta(BaseNetworkTask):
@ -112,7 +117,7 @@ class CalculateDelta(BaseNetworkTask):
lambda amp: amp.status == constants.AMPHORA_ALLOCATED,
loadbalancer.amphorae):
delta = calculate_amp.execute(loadbalancer, amphora)
delta = calculate_amp.execute(loadbalancer, amphora.to_dict())
deltas[amphora.id] = delta
return deltas
@ -129,9 +134,11 @@ class GetPlumbedNetworks(BaseNetworkTask):
def execute(self, amphora):
"""Get plumbed networks for the amphora."""
LOG.debug("Getting plumbed networks for amphora id: %s", amphora.id)
LOG.debug("Getting plumbed networks for amphora id: %s",
amphora[constants.ID])
return self.network_driver.get_plugged_networks(amphora.compute_id)
return self.network_driver.get_plugged_networks(
amphora[constants.COMPUTE_ID])
class PlugNetworks(BaseNetworkTask):
@ -143,28 +150,32 @@ class PlugNetworks(BaseNetworkTask):
def execute(self, amphora, delta):
"""Update the amphora networks for the delta."""
LOG.debug("Plug or unplug networks for amphora id: %s", amphora.id)
LOG.debug("Plug or unplug networks for amphora id: %s",
amphora[constants.ID])
if not delta:
LOG.debug("No network deltas for amphora id: %s", amphora.id)
LOG.debug("No network deltas for amphora id: %s",
amphora[constants.ID])
return
# add nics
for nic in delta.add_nics:
self.network_driver.plug_network(amphora.compute_id,
nic.network_id)
for nic in delta[constants.ADD_NICS]:
self.network_driver.plug_network(amphora[constants.COMPUTE_ID],
nic[constants.NETWORK_ID])
def revert(self, amphora, delta, *args, **kwargs):
"""Handle a failed network plug by removing all nics added."""
LOG.warning("Unable to plug networks for amp id %s", amphora.id)
LOG.warning("Unable to plug networks for amp id %s",
amphora[constants.ID])
if not delta:
return
for nic in delta.add_nics:
for nic in delta[constants.ADD_NICS]:
try:
self.network_driver.unplug_network(amphora.compute_id,
nic.network_id)
self.network_driver.unplug_network(
amphora[constants.COMPUTE_ID],
nic[constants.NETWORK_ID])
except base.NetworkNotFound:
pass
@ -181,15 +192,16 @@ class UnPlugNetworks(BaseNetworkTask):
LOG.debug("Unplug network for amphora")
if not delta:
LOG.debug("No network deltas for amphora id: %s", amphora.id)
LOG.debug("No network deltas for amphora id: %s",
amphora[constants.ID])
return
for nic in delta.delete_nics:
for nic in delta[constants.DELETE_NICS]:
try:
self.network_driver.unplug_network(amphora.compute_id,
nic.network_id)
self.network_driver.unplug_network(
amphora[constants.COMPUTE_ID], nic[constants.NETWORK_ID])
except base.NetworkNotFound:
LOG.debug("Network %d not found", nic.network_id)
LOG.debug("Network %d not found", nic[constants.NETWORK_ID])
except Exception:
LOG.exception("Unable to unplug network")
# TODO(xgerman) follow up if that makes sense
@ -201,14 +213,14 @@ class GetMemberPorts(BaseNetworkTask):
vip_port = self.network_driver.get_port(loadbalancer.vip.port_id)
member_ports = []
interfaces = self.network_driver.get_plugged_networks(
amphora.compute_id)
amphora[constants.COMPUTE_ID])
for interface in interfaces:
port = self.network_driver.get_port(interface.port_id)
if vip_port.network_id == port.network_id:
continue
port.network = self.network_driver.get_network(port.network_id)
for fixed_ip in port.fixed_ips:
if amphora.lb_network_ip == fixed_ip.ip_address:
if amphora['lb_network_ip'] == fixed_ip.ip_address:
break
fixed_ip.subnet = self.network_driver.get_subnet(
fixed_ip.subnet_id)
@ -227,22 +239,23 @@ class HandleNetworkDelta(BaseNetworkTask):
def execute(self, amphora, delta):
"""Handle network plugging based off deltas."""
added_ports = {}
added_ports[amphora.id] = []
for nic in delta.add_nics:
interface = self.network_driver.plug_network(delta.compute_id,
nic.network_id)
added_ports[amphora[constants.ID]] = []
for nic in delta[constants.ADD_NICS]:
interface = self.network_driver.plug_network(
delta[constants.COMPUTE_ID], nic[constants.NETWORK_ID])
port = self.network_driver.get_port(interface.port_id)
port.network = self.network_driver.get_network(port.network_id)
for fixed_ip in port.fixed_ips:
fixed_ip.subnet = self.network_driver.get_subnet(
fixed_ip.subnet_id)
added_ports[amphora.id].append(port)
for nic in delta.delete_nics:
added_ports[amphora[constants.ID]].append(port.to_dict(
recurse=True))
for nic in delta[constants.DELETE_NICS]:
try:
self.network_driver.unplug_network(delta.compute_id,
nic.network_id)
self.network_driver.unplug_network(
delta[constants.COMPUTE_ID], nic[constants.NETWORK_ID])
except base.NetworkNotFound:
LOG.debug("Network %d not found ", nic.network_id)
LOG.debug("Network %d not found ", nic[constants.NETWORK_ID])
except Exception:
LOG.exception("Unable to unplug network")
return added_ports
@ -257,12 +270,12 @@ class HandleNetworkDelta(BaseNetworkTask):
return
LOG.warning("Unable to plug networks for amp id %s",
delta.amphora_id)
delta['amphora_id'])
for nic in delta.add_nics:
for nic in delta[constants.ADD_NICS]:
try:
self.network_driver.unplug_network(delta.compute_id,
nic.network_id)
self.network_driver.unplug_network(delta[constants.COMPUTE_ID],
nic[constants.NETWORK_ID])
except Exception:
pass
@ -279,21 +292,23 @@ class HandleNetworkDeltas(BaseNetworkTask):
added_ports = {}
for amp_id, delta in six.iteritems(deltas):
added_ports[amp_id] = []
for nic in delta.add_nics:
interface = self.network_driver.plug_network(delta.compute_id,
nic.network_id)
for nic in delta[constants.ADD_NICS]:
interface = self.network_driver.plug_network(
delta[constants.COMPUTE_ID], nic[constants.NETWORK_ID])
port = self.network_driver.get_port(interface.port_id)
port.network = self.network_driver.get_network(port.network_id)
for fixed_ip in port.fixed_ips:
fixed_ip.subnet = self.network_driver.get_subnet(
fixed_ip.subnet_id)
added_ports[amp_id].append(port)
for nic in delta.delete_nics:
added_ports[amp_id].append(port.to_dict(recurse=True))
for nic in delta[constants.DELETE_NICS]:
try:
self.network_driver.unplug_network(delta.compute_id,
nic.network_id)
self.network_driver.unplug_network(
delta[constants.COMPUTE_ID],
nic[constants.NETWORK_ID])
except base.NetworkNotFound:
LOG.debug("Network %d not found ", nic.network_id)
LOG.debug("Network %d not found ",
nic[constants.NETWORK_ID])
except Exception:
LOG.exception("Unable to unplug network")
return added_ports
@ -305,14 +320,15 @@ class HandleNetworkDeltas(BaseNetworkTask):
return
for amp_id, delta in six.iteritems(deltas):
LOG.warning("Unable to plug networks for amp id %s",
delta.amphora_id)
delta[constants.AMPHORA_ID])
if not delta:
return
for nic in delta.add_nics:
for nic in delta[constants.ADD_NICS]:
try:
self.network_driver.unplug_network(delta.compute_id,
nic.network_id)
self.network_driver.unplug_network(
delta[constants.COMPUTE_ID],
nic[constants.NETWORK_ID])
except base.NetworkNotFound:
pass
@ -327,7 +343,7 @@ class PlugVIP(BaseNetworkTask):
amps_data = self.network_driver.plug_vip(loadbalancer,
loadbalancer.vip)
return amps_data
return [amp.to_dict() for amp in amps_data]
def revert(self, result, loadbalancer, *args, **kwargs):
"""Handle a failure to plumb a vip."""
@ -373,7 +389,8 @@ class GetSubnetFromVIP(BaseNetworkTask):
LOG.debug("Getting subnet for LB: %s", loadbalancer.id)
return self.network_driver.get_subnet(loadbalancer.vip.subnet_id)
return self.network_driver.get_subnet(
loadbalancer.vip.subnet_id).to_dict()
class PlugVIPAmpphora(BaseNetworkTask):
@ -382,27 +399,31 @@ class PlugVIPAmpphora(BaseNetworkTask):
def execute(self, loadbalancer, amphora, subnet):
"""Plumb a vip to an amphora."""
LOG.debug("Plumbing VIP for amphora id: %s", amphora.id)
LOG.debug("Plumbing VIP for amphora id: %s",
amphora.get(constants.ID))
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora.get(constants.ID))
db_subnet = self.network_driver.get_subnet(subnet[constants.ID])
amp_data = self.network_driver.plug_aap_port(
loadbalancer, loadbalancer.vip, amphora, subnet)
return amp_data
loadbalancer, loadbalancer.vip, db_amp, db_subnet)
return amp_data.to_dict()
def revert(self, result, loadbalancer, amphora, subnet, *args, **kwargs):
"""Handle a failure to plumb a vip."""
if isinstance(result, failure.Failure):
return
LOG.warning("Unable to plug VIP for amphora id %s "
"load balancer id %s",
amphora.id, loadbalancer.id)
amphora.get(constants.ID), loadbalancer.id)
try:
amphora.vrrp_port_id = result.vrrp_port_id
amphora.ha_port_id = result.ha_port_id
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora.get(constants.ID))
db_amp.vrrp_port_id = result[constants.VRRP_PORT_ID]
db_amp.ha_port_id = result[constants.HA_PORT_ID]
self.network_driver.unplug_aap_port(loadbalancer.vip,
amphora, subnet)
db_amp, subnet)
except Exception as e:
LOG.error('Failed to unplug AAP port. Resources may still be in '
'use for VIP: %s due to error: %s', loadbalancer.vip, e)
@ -497,8 +518,14 @@ class GetAmphoraNetworkConfigs(BaseNetworkTask):
def execute(self, loadbalancer, amphora=None):
LOG.debug("Retrieving vip network details.")
return self.network_driver.get_network_configs(loadbalancer,
amphora=amphora)
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora.get(constants.ID))
db_configs = self.network_driver.get_network_configs(
loadbalancer, amphora=db_amp)
provider_dict = {}
for amp_id, amp_conf in six.iteritems(db_configs):
provider_dict[amp_id] = amp_conf.to_dict(recurse=True)
return provider_dict
class GetAmphoraeNetworkConfigs(BaseNetworkTask):
@ -506,16 +533,22 @@ class GetAmphoraeNetworkConfigs(BaseNetworkTask):
def execute(self, loadbalancer):
LOG.debug("Retrieving vip network details.")
return self.network_driver.get_network_configs(loadbalancer)
db_configs = self.network_driver.get_network_configs(loadbalancer)
provider_dict = {}
for amp_id, amp_conf in six.iteritems(db_configs):
provider_dict[amp_id] = amp_conf.to_dict(recurse=True)
return provider_dict
class FailoverPreparationForAmphora(BaseNetworkTask):
"""Task to prepare an amphora for failover."""
def execute(self, amphora):
LOG.debug("Prepare amphora %s for failover.", amphora.id)
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID])
LOG.debug("Prepare amphora %s for failover.", amphora[constants.ID])
self.network_driver.failover_preparation(amphora)
self.network_driver.failover_preparation(db_amp)
class RetrievePortIDsOnAmphoraExceptLBNetwork(BaseNetworkTask):
@ -523,10 +556,10 @@ class RetrievePortIDsOnAmphoraExceptLBNetwork(BaseNetworkTask):
def execute(self, amphora):
LOG.debug("Retrieve all but the lb network port id on amphora %s.",
amphora.id)
amphora[constants.ID])
interfaces = self.network_driver.get_plugged_networks(
compute_id=amphora.compute_id)
compute_id=amphora[constants.COMPUTE_ID])
ports = []
for interface_ in interfaces:
@ -535,7 +568,7 @@ class RetrievePortIDsOnAmphoraExceptLBNetwork(BaseNetworkTask):
ips = port.fixed_ips
lb_network = False
for ip in ips:
if ip.ip_address == amphora.lb_network_ip:
if ip.ip_address == amphora[constants.LB_NETWORK_IP]:
lb_network = True
if not lb_network:
ports.append(port)
@ -547,32 +580,47 @@ class PlugPorts(BaseNetworkTask):
"""Task to plug neutron ports into a compute instance."""
def execute(self, amphora, ports):
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID])
for port in ports:
LOG.debug('Plugging port ID: %(port_id)s into compute instance: '
'%(compute_id)s.',
{'port_id': port.id, 'compute_id': amphora.compute_id})
self.network_driver.plug_port(amphora, port)
{constants.PORT_ID: port.id,
constants.COMPUTE_ID: amphora[constants.COMPUTE_ID]})
self.network_driver.plug_port(db_amp, port)
class PlugVIPPort(BaseNetworkTask):
"""Task to plug a VIP into a compute instance."""
def execute(self, amphora, amphorae_network_config):
vrrp_port = amphorae_network_config.get(amphora.id).vrrp_port
vrrp_port = amphorae_network_config.get(
amphora.get(constants.ID))[constants.VRRP_PORT]
LOG.debug('Plugging VIP VRRP port ID: %(port_id)s into compute '
'instance: %(compute_id)s.',
{'port_id': vrrp_port.id, 'compute_id': amphora.compute_id})
self.network_driver.plug_port(amphora, vrrp_port)
{constants.PORT_ID: vrrp_port.get(constants.ID),
constants.COMPUTE_ID: amphora[constants.COMPUTE_ID]})
db_vrrp_port = self.network_driver.get_port(
vrrp_port.get(constants.ID))
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID])
self.network_driver.plug_port(db_amp, db_vrrp_port)
def revert(self, result, amphora, amphorae_network_config,
*args, **kwargs):
vrrp_port = None
try:
vrrp_port = amphorae_network_config.get(amphora.id).vrrp_port
self.network_driver.unplug_port(amphora, vrrp_port)
vrrp_port = amphorae_network_config.get(
amphora.get(constants.ID))[constants.VRRP_PORT]
db_vrrp_port = self.network_driver.get_port(
vrrp_port.get(constants.ID))
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora[constants.ID])
self.network_driver.unplug_port(db_amp, db_vrrp_port)
except Exception:
LOG.warning('Failed to unplug vrrp port: %(port)s from amphora: '
'%(amp)s', {'port': vrrp_port.id, 'amp': amphora.id})
'%(amp)s',
{'port': vrrp_port, 'amp': amphora[constants.ID]})
class WaitForPortDetach(BaseNetworkTask):
@ -580,8 +628,10 @@ class WaitForPortDetach(BaseNetworkTask):
def execute(self, amphora):
LOG.debug('Waiting for ports to detach from amphora: %(amp_id)s.',
{'amp_id': amphora.id})
self.network_driver.wait_for_port_detach(amphora)
{'amp_id': amphora.get(constants.ID)})
db_amp = self.amphora_repo.get(db_apis.get_session(),
id=amphora.get(constants.ID))
self.network_driver.wait_for_port_detach(db_amp)
class ApplyQos(BaseNetworkTask):
@ -595,7 +645,7 @@ class ApplyQos(BaseNetworkTask):
apply_qos = ApplyQosAmphora()
for amp_data in amps_data:
apply_qos._apply_qos_on_vrrp_port(loadbalancer, amp_data,
apply_qos._apply_qos_on_vrrp_port(loadbalancer, amp_data.to_dict(),
qos_policy_id)
def execute(self, loadbalancer, amps_data=None, update_dict=None):
@ -604,7 +654,7 @@ class ApplyQos(BaseNetworkTask):
if not qos_policy_id and (
update_dict and (
'vip' not in update_dict or
'qos_policy_id' not in update_dict['vip'])):
'qos_policy_id' not in update_dict[constants.VIP])):
return
self._apply_qos_on_vrrp_ports(loadbalancer, amps_data, qos_policy_id)
@ -628,8 +678,9 @@ class ApplyQosAmphora(BaseNetworkTask):
is_revert=False, request_qos_id=None):
"""Call network driver to apply QoS Policy on the vrrp ports."""
try:
self.network_driver.apply_qos_on_port(qos_policy_id,
amp_data.vrrp_port_id)
self.network_driver.apply_qos_on_port(
qos_policy_id,
amp_data[constants.VRRP_PORT_ID])
except Exception:
if not is_revert:
raise
@ -637,8 +688,8 @@ class ApplyQosAmphora(BaseNetworkTask):
'on vrrp port: %(port)s from '
'amphorae: %(amp)s',
{'qos_id': request_qos_id,
'port': amp_data.vrrp_port_id,
'amp': [amp.id for amp in amp_data]})
'port': amp_data[constants.VRRP_PORT_ID],
'amp': [amp.get(constants.ID) for amp in amp_data]})
def execute(self, loadbalancer, amp_data=None, update_dict=None):
"""Apply qos policy on the vrrp ports which are related with vip."""
@ -646,7 +697,7 @@ class ApplyQosAmphora(BaseNetworkTask):
if not qos_policy_id and (
update_dict and (
'vip' not in update_dict or
'qos_policy_id' not in update_dict['vip'])):
'qos_policy_id' not in update_dict[constants.VIP])):
return
self._apply_qos_on_vrrp_port(loadbalancer, amp_data, qos_policy_id)
@ -664,4 +715,5 @@ class ApplyQosAmphora(BaseNetworkTask):
request_qos_id=request_qos_id)
except Exception as e:
LOG.error('Failed to remove QoS policy: %s from port: %s due '
'to error: %s', orig_qos_id, amp_data.vrrp_port_id, e)
'to error: %s', orig_qos_id,
amp_data[constants.VRRP_PORT_ID], e)

6
octavia/tests/unit/controller/queue/v2/test_endpoints.py
View File

@ -40,7 +40,7 @@ class TestEndpoints(base.TestCase):
self.resource_id = 1234
self.resource = {constants.ID: self.resource_id}
self.server_group_id = 3456
self.listener_dict = {constants.ID: uuidutils.generate_uuid()}
self.listener_dict = {constants.LISTENER_ID: uuidutils.generate_uuid()}
self.flavor_id = uuidutils.generate_uuid()
self.availability_zone = uuidutils.generate_uuid()
@ -183,6 +183,6 @@ class TestEndpoints(base.TestCase):
self.resource_id)
def test_update_amphora_agent_config(self):
self.ep.update_amphora_agent_config(self.context, self.resource_id)
self.ep.update_amphora_agent_config(self.context, self.resource)
self.ep.worker.update_amphora_agent_config.assert_called_once_with(
self.resource_id)
self.resource)

63
octavia/tests/unit/controller/worker/v2/flows/test_amphora_flows.py
View File

@ -80,8 +80,6 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@ -89,7 +87,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIn(constants.SERVER_PEM, amp_flow.provides)
self.assertEqual(5, len(amp_flow.provides))
self.assertEqual(4, len(amp_flow.requires))
self.assertEqual(3, len(amp_flow.requires))
def test_get_cert_create_amphora_for_lb_flow(self, mock_get_net_driver):
@ -100,8 +98,6 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@ -109,7 +105,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIn(constants.SERVER_PEM, amp_flow.provides)
self.assertEqual(5, len(amp_flow.provides))
self.assertEqual(4, len(amp_flow.requires))
self.assertEqual(3, len(amp_flow.requires))
def test_get_cert_master_create_amphora_for_lb_flow(
self, mock_get_net_driver):
@ -121,8 +117,6 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@ -130,7 +124,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIn(constants.SERVER_PEM, amp_flow.provides)
self.assertEqual(5, len(amp_flow.provides))
self.assertEqual(4, len(amp_flow.requires))
self.assertEqual(3, len(amp_flow.requires))
def test_get_cert_master_rest_anti_affinity_create_amphora_for_lb_flow(
self, mock_get_net_driver):
@ -149,7 +143,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIn(constants.SERVER_PEM, amp_flow.provides)
self.assertEqual(5, len(amp_flow.provides))
self.assertEqual(5, len(amp_flow.requires))
self.assertEqual(4, len(amp_flow.requires))
self.conf.config(group="nova", enable_anti_affinity=False)
def test_get_cert_backup_create_amphora_for_lb_flow(
@ -161,8 +155,6 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@ -170,7 +162,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIn(constants.SERVER_PEM, amp_flow.provides)
self.assertEqual(5, len(amp_flow.provides))
self.assertEqual(4, len(amp_flow.requires))
self.assertEqual(3, len(amp_flow.requires))
def test_get_cert_bogus_create_amphora_for_lb_flow(
self, mock_get_net_driver):
@ -181,8 +173,6 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@ -190,7 +180,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIn(constants.SERVER_PEM, amp_flow.provides)
self.assertEqual(5, len(amp_flow.provides))
self.assertEqual(4, len(amp_flow.requires))
self.assertEqual(3, len(amp_flow.requires))
def test_get_cert_backup_rest_anti_affinity_create_amphora_for_lb_flow(
self, mock_get_net_driver):
@ -208,7 +198,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIn(constants.SERVER_PEM, amp_flow.provides)
self.assertEqual(5, len(amp_flow.provides))
self.assertEqual(5, len(amp_flow.requires))
self.assertEqual(4, len(amp_flow.requires))
self.conf.config(group="nova", enable_anti_affinity=False)
def test_get_delete_amphora_flow(self, mock_get_net_driver):
@ -233,11 +223,13 @@ class TestAmphoraFlows(base.TestCase):
def test_create_new_amp_for_lb_decider(self, mock_get_net_driver):
history = mock.MagicMock()
values = mock.MagicMock(side_effect=[[None], ['TEST']])
values = mock.MagicMock(side_effect=[[], [None], ['TEST']])
history.values = values
result = self.AmpFlow._create_new_amp_for_lb_decider(history)
self.assertTrue(result)
result = self.AmpFlow._create_new_amp_for_lb_decider(history)
self.assertTrue(result)
result = self.AmpFlow._create_new_amp_for_lb_decider(history)
self.assertFalse(result)
def test_get_failover_flow_allocated(self, mock_get_net_driver):
@ -367,7 +359,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.FLAVOR, amp_flow.requires)
self.assertIn(constants.AMPHORA_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertEqual(1, len(amp_flow.provides))
@ -379,7 +371,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.FLAVOR, amp_flow.requires)
self.assertIn(constants.AMPHORA_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertEqual(1, len(amp_flow.provides))
@ -391,7 +383,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.FLAVOR, amp_flow.requires)
self.assertIn(constants.AMPHORA_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertEqual(1, len(amp_flow.provides))
@ -403,7 +395,7 @@ class TestAmphoraFlows(base.TestCase):
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.FLAVOR, amp_flow.requires)
self.assertIn(constants.AMPHORA_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertEqual(1, len(amp_flow.provides))
@ -420,3 +412,30 @@ class TestAmphoraFlows(base.TestCase):
self.assertEqual(2, len(amp_flow.requires))
self.assertEqual(0, len(amp_flow.provides))
def test__retry_flow(self, mock_get_net_driver):
amp_flow = self.AmpFlow._retry_flow('test_flow')
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.AMPHORA, amp_flow.requires)
self.assertEqual(1, len(amp_flow.requires))
self.assertEqual(0, len(amp_flow.provides))
def test__finalize_flow(self, mock_get_net_driver):
for role in [constants.ROLE_STANDALONE,
constants.ROLE_BACKUP,
constants.ROLE_MASTER]:
amp_flow = self.AmpFlow._finalize_flow('test',
role)
self.assertIsInstance(amp_flow, flow.Flow)
self.assertIn(constants.AMPHORA, amp_flow.requires)
self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
self.assertIn(constants.AMPHORA, amp_flow.provides)
self.assertEqual(2, len(amp_flow.requires))
self.assertEqual(1, len(amp_flow.provides))

119
octavia/tests/unit/controller/worker/v2/tasks/test_amphora_driver_tasks.py
View File

@ -26,6 +26,7 @@ from octavia.common import data_models
from octavia.common import utils
from octavia.controller.worker.v2.tasks import amphora_driver_tasks
from octavia.db import repositories as repo
from octavia.network import data_models as network_data_models
import octavia.tests.unit.base as base
@ -37,9 +38,14 @@ CONN_MAX_RETRIES = 10
CONN_RETRY_INTERVAL = 6
FAKE_CONFIG_FILE = 'fake config file'
_amphora_mock = mock.MagicMock()
_amphora_mock.id = AMP_ID
_amphora_mock.status = constants.AMPHORA_ALLOCATED
_db_amphora_mock = mock.MagicMock()
_db_amphora_mock.id = AMP_ID
_db_amphora_mock.status = constants.AMPHORA_ALLOCATED
_amphora_mock = {
constants.ID: AMP_ID,
constants.STATUS: constants.AMPHORA_ALLOCATED,
constants.COMPUTE_ID: COMPUTE_ID,
}
_load_balancer_mock = mock.MagicMock()
_load_balancer_mock.id = LB_ID
_listener_mock = mock.MagicMock()
@ -48,14 +54,13 @@ _load_balancer_mock.listeners = [_listener_mock]
_vip_mock = mock.MagicMock()
_load_balancer_mock.vip = _vip_mock
_LB_mock = mock.MagicMock()
_amphorae_mock = [_amphora_mock]
_amphorae_mock = [_db_amphora_mock]
_network_mock = mock.MagicMock()
_port_mock = mock.MagicMock()
_ports_mock = [_port_mock]
_session_mock = mock.MagicMock()
@mock.patch('octavia.db.repositories.AmphoraRepository.update')
@mock.patch('octavia.db.repositories.AmphoraRepository.get')
@mock.patch('octavia.db.repositories.ListenerRepository.update')
@mock.patch('octavia.db.repositories.ListenerRepository.get',
return_value=_listener_mock)
@ -67,7 +72,7 @@ class TestAmphoraDriverTasks(base.TestCase):
def setUp(self):
_LB_mock.amphorae = [_amphora_mock]
_LB_mock.amphorae = [_db_amphora_mock]
_LB_mock.id = LB_ID
conf = oslo_fixture.Config(cfg.CONF)
conf.config(group="haproxy_amphora",
@ -85,19 +90,20 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
timeout_dict = {constants.REQ_CONN_TIMEOUT: 1,
constants.REQ_READ_TIMEOUT: 2,
constants.CONN_MAX_RETRIES: 3,
constants.CONN_RETRY_INTERVAL: 4}
mock_amphora_repo_get.return_value = _db_amphora_mock
amp_list_update_obj = amphora_driver_tasks.AmpListenersUpdate()
amp_list_update_obj.execute(_load_balancer_mock, 0,
[_amphora_mock], timeout_dict)
mock_driver.update_amphora_listeners.assert_called_once_with(
_load_balancer_mock, _amphora_mock, timeout_dict)
_load_balancer_mock, _db_amphora_mock, timeout_dict)
mock_driver.update_amphora_listeners.side_effect = Exception('boom')
@ -116,6 +122,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
listeners_update_obj = amphora_driver_tasks.ListenersUpdate()
LB_ID = 'lb1'
@ -155,6 +162,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
listeners_start_obj = amphora_driver_tasks.ListenersStart()
mock_lb = mock.MagicMock()
@ -184,6 +192,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
listener_dict = {constants.LISTENER_ID: LISTENER_ID}
@ -217,13 +226,15 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphora_get_info_obj = amphora_driver_tasks.AmphoraGetInfo()
mock_amphora_repo_get.return_value = _db_amphora_mock
amphora_get_info_obj.execute(_amphora_mock)
mock_driver.get_info.assert_called_once_with(
_amphora_mock)
_db_amphora_mock)
def test_amphora_get_diagnostics(self,
mock_driver,
@ -232,6 +243,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphora_get_diagnostics_obj = (amphora_driver_tasks.
@ -248,13 +260,15 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphora_finalize_obj = amphora_driver_tasks.AmphoraFinalize()
mock_amphora_repo_get.return_value = _db_amphora_mock
amphora_finalize_obj.execute(_amphora_mock)
mock_driver.finalize_amphora.assert_called_once_with(
_amphora_mock)
_db_amphora_mock)
# Test revert
amp = amphora_finalize_obj.revert(None, _amphora_mock)
@ -281,14 +295,20 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphora_post_network_plug_obj = (amphora_driver_tasks.
AmphoraPostNetworkPlug())
amphora_post_network_plug_obj.execute(_amphora_mock, _ports_mock)
mock_amphora_repo_get.return_value = _db_amphora_mock
port_mock = {constants.NETWORK: mock.MagicMock(),
constants.FIXED_IPS: [mock.MagicMock()],
constants.ID: uuidutils.generate_uuid()}
amphora_post_network_plug_obj.execute(_amphora_mock, [port_mock])
(mock_driver.post_network_plug.
assert_called_once_with)(_amphora_mock, _port_mock)
assert_called_once_with)(_db_amphora_mock,
network_data_models.Port(**port_mock))
# Test revert
amp = amphora_post_network_plug_obj.revert(None, _amphora_mock)
@ -316,21 +336,26 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
mock_driver.get_network.return_value = _network_mock
_amphora_mock.id = AMP_ID
_amphora_mock.compute_id = COMPUTE_ID
_LB_mock.amphorae = [_amphora_mock]
_db_amphora_mock.id = AMP_ID
_db_amphora_mock.compute_id = COMPUTE_ID
_LB_mock.amphorae = [_db_amphora_mock]
mock_amphora_repo_get.return_value = _db_amphora_mock
amphora_post_network_plug_obj = (amphora_driver_tasks.
AmphoraePostNetworkPlug())
port_mock = mock.Mock()
_deltas_mock = {_amphora_mock.id: [port_mock]}
port_mock = {constants.NETWORK: mock.MagicMock(),
constants.FIXED_IPS: [mock.MagicMock()],
constants.ID: uuidutils.generate_uuid()}
_deltas_mock = {_db_amphora_mock.id: [port_mock]}
amphora_post_network_plug_obj.execute(_LB_mock, _deltas_mock)
(mock_driver.post_network_plug.
assert_called_once_with(_amphora_mock, port_mock))
assert_called_once_with(_db_amphora_mock,
network_data_models.Port(**port_mock)))
# Test revert
amp = amphora_post_network_plug_obj.revert(None, _LB_mock,
@ -363,16 +388,23 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphorae_net_config_mock = mock.Mock()
amphorae_net_config_mock = mock.MagicMock()
mock_amphora_repo_get.return_value = _db_amphora_mock
amphora_post_vip_plug_obj = amphora_driver_tasks.AmphoraPostVIPPlug()
amphora_post_vip_plug_obj.execute(_amphora_mock,
_LB_mock,
amphorae_net_config_mock)
vip_subnet = network_data_models.Subnet(
**amphorae_net_config_mock[AMP_ID]['vip_subnet'])
vrrp_port = network_data_models.Port(
**amphorae_net_config_mock[AMP_ID]['vrrp_port'])
mock_driver.post_vip_plug.assert_called_once_with(
_amphora_mock, _LB_mock, amphorae_net_config_mock)
_db_amphora_mock, _LB_mock, amphorae_net_config_mock,
vip_subnet=vip_subnet, vrrp_port=vrrp_port)
# Test revert
amp = amphora_post_vip_plug_obj.revert(None, _amphora_mock, _LB_mock)
@ -413,15 +445,22 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphorae_net_config_mock = mock.Mock()
amphorae_net_config_mock = mock.MagicMock()
mock_amphora_repo_get.return_value = _db_amphora_mock
vip_subnet = network_data_models.Subnet(
**amphorae_net_config_mock[AMP_ID]['vip_subnet'])
vrrp_port = network_data_models.Port(
**amphorae_net_config_mock[AMP_ID]['vrrp_port'])
amphora_post_vip_plug_obj = amphora_driver_tasks.AmphoraePostVIPPlug()
amphora_post_vip_plug_obj.execute(_LB_mock,
amphorae_net_config_mock)
mock_driver.post_vip_plug.assert_called_once_with(
_amphora_mock, _LB_mock, amphorae_net_config_mock)
_db_amphora_mock, _LB_mock, amphorae_net_config_mock,
vip_subnet=vip_subnet, vrrp_port=vrrp_port)
# Test revert
amp = amphora_post_vip_plug_obj.revert(None, _LB_mock)
@ -450,16 +489,18 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
key = utils.get_six_compatible_server_certs_key_passphrase()
mock_amphora_repo_get.return_value = _db_amphora_mock
fer = fernet.Fernet(key)
pem_file_mock = fer.encrypt(
utils.get_six_compatible_value('test-pem-file'))
utils.get_six_compatible_value('test-pem-file')).decode('utf-8')
amphora_cert_upload_mock = amphora_driver_tasks.AmphoraCertUpload()
amphora_cert_upload_mock.execute(_amphora_mock, pem_file_mock)
mock_driver.upload_cert_amp.assert_called_once_with(
_amphora_mock, fer.decrypt(pem_file_mock))
_db_amphora_mock, fer.decrypt(pem_file_mock.encode('utf-8')))
def test_amphora_update_vrrp_interface(self,
mock_driver,
@ -468,6 +509,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
_LB_mock.amphorae = _amphorae_mock
@ -478,7 +520,7 @@ class TestAmphoraDriverTasks(base.TestCase):
amphora_driver_tasks.AmphoraUpdateVRRPInterface())
amphora_update_vrrp_interface_obj.execute(_LB_mock)
mock_driver.get_vrrp_interface.assert_called_once_with(
_amphora_mock, timeout_dict=timeout_dict)
_db_amphora_mock, timeout_dict=timeout_dict)
# Test revert
mock_driver.reset_mock()
@ -486,7 +528,7 @@ class TestAmphoraDriverTasks(base.TestCase):
_LB_mock.amphorae = _amphorae_mock
amphora_update_vrrp_interface_obj.revert("BADRESULT", _LB_mock)
mock_amphora_repo_update.assert_called_with(_session_mock,
_amphora_mock.id,
_db_amphora_mock.id,
vrrp_interface=None)
mock_driver.reset_mock()
@ -504,7 +546,7 @@ class TestAmphoraDriverTasks(base.TestCase):
_LB_mock.amphorae = _amphorae_mock
amphora_update_vrrp_interface_obj.revert("BADRESULT", _LB_mock)
mock_amphora_repo_update.assert_called_with(_session_mock,
_amphora_mock.id,
_db_amphora_mock.id,
vrrp_interface=None)
def test_amphora_vrrp_update(self,
@ -514,6 +556,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphorae_network_config = mock.MagicMock()
amphora_vrrp_update_obj = (
@ -529,6 +572,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphora_vrrp_stop_obj = (
amphora_driver_tasks.AmphoraVRRPStop())
@ -542,6 +586,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amphora_vrrp_start_obj = (
amphora_driver_tasks.AmphoraVRRPStart())
@ -555,13 +600,15 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
amp_compute_conn_wait_obj = (
amphora_driver_tasks.AmphoraComputeConnectivityWait())
mock_amphora_repo_get.return_value = _db_amphora_mock
amp_compute_conn_wait_obj.execute(_amphora_mock,
raise_retry_exception=True)
mock_driver.get_info.assert_called_once_with(
_amphora_mock, raise_retry_exception=True)
_db_amphora_mock, raise_retry_exception=True)
mock_driver.get_info.side_effect = driver_except.TimeOutException()
self.assertRaises(driver_except.TimeOutException,
@ -579,6 +626,7 @@ class TestAmphoraDriverTasks(base.TestCase):
mock_get_session,
mock_listener_repo_get,
mock_listener_repo_update,
mock_amphora_repo_get,
mock_amphora_repo_update):
mock_build_config.return_value = FAKE_CONFIG_FILE
amp_config_update_obj = amphora_driver_tasks.AmphoraConfigUpdate()
@ -588,27 +636,28 @@ class TestAmphoraDriverTasks(base.TestCase):
# With Flavor
flavor = {constants.LOADBALANCER_TOPOLOGY:
constants.TOPOLOGY_ACTIVE_STANDBY}
mock_amphora_repo_get.return_value = _db_amphora_mock
amp_config_update_obj.execute(_amphora_mock, flavor)
mock_build_config.assert_called_once_with(
_amphora_mock.id, constants.TOPOLOGY_ACTIVE_STANDBY)
_db_amphora_mock.id, constants.TOPOLOGY_ACTIVE_STANDBY)
mock_driver.update_amphora_agent_config.assert_called_once_with(
_amphora_mock, FAKE_CONFIG_FILE)
_db_amphora_mock, FAKE_CONFIG_FILE)
# With no Flavor
mock_driver.reset_mock()
mock_build_config.reset_mock()
amp_config_update_obj.execute(_amphora_mock, None)
mock_build_config.assert_called_once_with(
_amphora_mock.id, constants.TOPOLOGY_SINGLE)
_db_amphora_mock.id, constants.TOPOLOGY_SINGLE)
mock_driver.update_amphora_agent_config.assert_called_once_with(
_amphora_mock, FAKE_CONFIG_FILE)
_db_amphora_mock, FAKE_CONFIG_FILE)
# With amphora that does not support config update
mock_driver.reset_mock()
mock_build_config.reset_mock()
amp_config_update_obj.execute(_amphora_mock, flavor)
mock_build_config.assert_called_once_with(
_amphora_mock.id, constants.TOPOLOGY_ACTIVE_STANDBY)
_db_amphora_mock.id, constants.TOPOLOGY_ACTIVE_STANDBY)
mock_driver.update_amphora_agent_config.assert_called_once_with(
_amphora_mock, FAKE_CONFIG_FILE)
_db_amphora_mock, FAKE_CONFIG_FILE)
# With an unknown exception
mock_driver.reset_mock()
mock_build_config.reset_mock()

2
octavia/tests/unit/controller/worker/v2/tasks/test_cert_task.py
View File

@ -39,7 +39,7 @@ class TestCertTasks(base.TestCase):
c = cert_task.GenerateServerPEMTask()
pem = c.execute('123')
self.assertEqual(
fer.decrypt(pem),
fer.decrypt(pem.encode('utf-8')),
dummy_cert.get_certificate() +
dummy_cert.get_private_key()
)

113
octavia/tests/unit/controller/worker/v2/tasks/test_compute_tasks.py
View File

@ -50,11 +50,15 @@ class TestException(Exception):
return repr(self.value)
_amphora_mock = mock.MagicMock()
_amphora_mock.id = AMPHORA_ID
_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock = mock.MagicMock()
_db_amphora_mock.id = AMPHORA_ID
_db_amphora_mock.compute_id = COMPUTE_ID
_amphora_mock = {
constants.ID: AMPHORA_ID,
constants.COMPUTE_ID: COMPUTE_ID
}
_load_balancer_mock = mock.MagicMock()
_load_balancer_mock.amphorae = [_amphora_mock]
_load_balancer_mock.amphorae = [_db_amphora_mock]
_port = mock.MagicMock()
_port.id = PORT_ID
@ -79,8 +83,8 @@ class TestComputeTasks(base.TestCase):
group="controller_worker", amp_secgroup_list=AMP_SEC_GROUPS)
self.conf.config(group="controller_worker", amp_image_owner_id='')
_amphora_mock.id = AMPHORA_ID
_amphora_mock.status = constants.AMPHORA_ALLOCATED
_db_amphora_mock.id = AMPHORA_ID
_db_amphora_mock.status = constants.AMPHORA_ALLOCATED
logging_mock = mock.MagicMock()
compute_tasks.LOG = logging_mock
@ -106,12 +110,12 @@ class TestComputeTasks(base.TestCase):
mock_driver.build.return_value = COMPUTE_ID
# Test execute()
compute_id = createcompute.execute(_amphora_mock.id, ports=[_port],
compute_id = createcompute.execute(_db_amphora_mock.id, ports=[_port],
server_group_id=SERVER_GRPOUP_ID)
# Validate that the build method was called properly
mock_driver.build.assert_called_once_with(
name="amphora-" + _amphora_mock.id,
name="amphora-" + _db_amphora_mock.id,
amphora_flavor=AMP_FLAVOR_ID,
image_id=AMP_IMAGE_ID,
image_tag=AMP_IMAGE_TAG,
@ -136,14 +140,14 @@ class TestComputeTasks(base.TestCase):
self.assertRaises(TypeError,
createcompute.execute,
_amphora_mock, config_drive_files='test_cert')
_db_amphora_mock, config_drive_files='test_cert')
# Test revert()
_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.compute_id = COMPUTE_ID
createcompute = compute_tasks.ComputeCreate()
createcompute.revert(compute_id, _amphora_mock.id)
createcompute.revert(compute_id, _db_amphora_mock.id)
# Validate that the delete method was called properly
mock_driver.delete.assert_called_once_with(
@ -151,7 +155,7 @@ class TestComputeTasks(base.TestCase):
# Test that a delete exception is not raised
createcompute.revert(COMPUTE_ID, _amphora_mock.id)
createcompute.revert(COMPUTE_ID, _db_amphora_mock.id)
@mock.patch('jinja2.Environment.get_template')
@mock.patch('octavia.amphorae.backends.agent.'
@ -171,11 +175,11 @@ class TestComputeTasks(base.TestCase):
mock_driver.build.return_value = COMPUTE_ID
# Test execute()
compute_id = createcompute.execute(_amphora_mock.id, ports=[_port])
compute_id = createcompute.execute(_db_amphora_mock.id, ports=[_port])
# Validate that the build method was called properly
mock_driver.build.assert_called_once_with(
name="amphora-" + _amphora_mock.id,
name="amphora-" + _db_amphora_mock.id,
amphora_flavor=AMP_FLAVOR_ID,
image_id=AMP_IMAGE_ID,
image_tag=AMP_IMAGE_TAG,
@ -197,14 +201,14 @@ class TestComputeTasks(base.TestCase):
self.assertRaises(TypeError,
createcompute.execute,
_amphora_mock, config_drive_files='test_cert')
_db_amphora_mock, config_drive_files='test_cert')
# Test revert()
_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.compute_id = COMPUTE_ID
createcompute = compute_tasks.ComputeCreate()
createcompute.revert(compute_id, _amphora_mock.id)
createcompute.revert(compute_id, _db_amphora_mock.id)
# Validate that the delete method was called properly
mock_driver.delete.assert_called_once_with(
@ -212,7 +216,7 @@ class TestComputeTasks(base.TestCase):
# Test that a delete exception is not raised
createcompute.revert(COMPUTE_ID, _amphora_mock.id)
createcompute.revert(COMPUTE_ID, _db_amphora_mock.id)
@mock.patch('octavia.common.jinja.logging.logging_jinja_cfg.'
'LoggingJinjaTemplater.build_logging_config')
@ -236,13 +240,13 @@ class TestComputeTasks(base.TestCase):
mock_driver.build.return_value = COMPUTE_ID
# Test execute()
compute_id = createcompute.execute(_amphora_mock.id, ports=[_port],
compute_id = createcompute.execute(_db_amphora_mock.id, ports=[_port],
server_group_id=SERVER_GRPOUP_ID,
availability_zone=az_dict)
# Validate that the build method was called properly
mock_driver.build.assert_called_once_with(
name="amphora-" + _amphora_mock.id,
name="amphora-" + _db_amphora_mock.id,
amphora_flavor=AMP_FLAVOR_ID,
image_id=AMP_IMAGE_ID,
image_tag=AMP_IMAGE_TAG,
@ -266,14 +270,14 @@ class TestComputeTasks(base.TestCase):
self.assertRaises(TypeError,
createcompute.execute,
_amphora_mock, config_drive_files='test_cert')
_db_amphora_mock, config_drive_files='test_cert')
# Test revert()
_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.compute_id = COMPUTE_ID
createcompute = compute_tasks.ComputeCreate()
createcompute.revert(compute_id, _amphora_mock.id)
createcompute.revert(compute_id, _db_amphora_mock.id)
# Validate that the delete method was called properly
mock_driver.delete.assert_called_once_with(
@ -281,7 +285,7 @@ class TestComputeTasks(base.TestCase):
# Test that a delete exception is not raised
createcompute.revert(COMPUTE_ID, _amphora_mock.id)
createcompute.revert(COMPUTE_ID, _db_amphora_mock.id)
@mock.patch('octavia.common.jinja.logging.logging_jinja_cfg.'
'LoggingJinjaTemplater.build_logging_config')
@ -303,12 +307,12 @@ class TestComputeTasks(base.TestCase):
mock_log_cfg.return_value = 'FAKE CFG'
# Test execute()
compute_id = createcompute.execute(_amphora_mock.id, ports=[_port],
compute_id = createcompute.execute(_db_amphora_mock.id, ports=[_port],
server_group_id=SERVER_GRPOUP_ID)
# Validate that the build method was called properly
mock_driver.build.assert_called_once_with(
name="amphora-" + _amphora_mock.id,
name="amphora-" + _db_amphora_mock.id,
amphora_flavor=AMP_FLAVOR_ID,
image_id=AMP_IMAGE_ID,
image_tag=AMP_IMAGE_TAG,
@ -331,14 +335,14 @@ class TestComputeTasks(base.TestCase):
self.assertRaises(TypeError,
createcompute.execute,
_amphora_mock, config_drive_files='test_cert')
_db_amphora_mock, config_drive_files='test_cert')
# Test revert()
_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.compute_id = COMPUTE_ID
createcompute = compute_tasks.ComputeCreate()
createcompute.revert(compute_id, _amphora_mock.id)
createcompute.revert(compute_id, _db_amphora_mock.id)
# Validate that the delete method was called properly
mock_driver.delete.assert_called_once_with(
@ -346,7 +350,7 @@ class TestComputeTasks(base.TestCase):
# Test that a delete exception is not raised
createcompute.revert(COMPUTE_ID, _amphora_mock.id)
createcompute.revert(COMPUTE_ID, _db_amphora_mock.id)
@mock.patch('octavia.common.jinja.logging.logging_jinja_cfg.'
'LoggingJinjaTemplater.build_logging_config')
@ -368,14 +372,14 @@ class TestComputeTasks(base.TestCase):
# Test execute()
test_cert = fer.encrypt(
utils.get_six_compatible_value('test_cert')
)
compute_id = createcompute.execute(_amphora_mock.id, test_cert,
).decode('utf-8')
compute_id = createcompute.execute(_db_amphora_mock.id, test_cert,
server_group_id=SERVER_GRPOUP_ID
)
# Validate that the build method was called properly
mock_driver.build.assert_called_once_with(
name="amphora-" + _amphora_mock.id,
name="amphora-" + _db_amphora_mock.id,
amphora_flavor=AMP_FLAVOR_ID,
image_id=AMP_IMAGE_ID,
image_tag=AMP_IMAGE_TAG,
@ -387,7 +391,8 @@ class TestComputeTasks(base.TestCase):
user_data=None,
config_drive_files={
'/etc/rsyslog.d/10-rsyslog.conf': 'FAKE CFG',
'/etc/octavia/certs/server.pem': fer.decrypt(test_cert),
'/etc/octavia/certs/server.pem': fer.decrypt(
test_cert.encode('utf-8')),
'/etc/octavia/certs/client_ca.pem': 'test',
'/etc/octavia/amphora-agent.conf': 'test_conf'},
server_group_id=SERVER_GRPOUP_ID,
@ -401,22 +406,22 @@ class TestComputeTasks(base.TestCase):
createcompute = compute_tasks.ComputeCreate()
self.assertRaises(TypeError,
createcompute.execute,
_amphora_mock,
_db_amphora_mock,
config_drive_files=test_cert)
# Test revert()
_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.compute_id = COMPUTE_ID
createcompute = compute_tasks.ComputeCreate()
createcompute.revert(compute_id, _amphora_mock.id)
createcompute.revert(compute_id, _db_amphora_mock.id)
# Validate that the delete method was called properly
mock_driver.delete.assert_called_once_with(COMPUTE_ID)
# Test that a delete exception is not raised
createcompute.revert(COMPUTE_ID, _amphora_mock.id)
createcompute.revert(COMPUTE_ID, _db_amphora_mock.id)
@mock.patch('octavia.controller.worker.amphora_rate_limit'
'.AmphoraBuildRateLimit.remove_from_build_req_queue')
@ -428,22 +433,22 @@ class TestComputeTasks(base.TestCase):
mock_remove_from_build_queue):
self.conf.config(group='haproxy_amphora', build_rate_limit=5)
_amphora_mock.compute_id = COMPUTE_ID
_amphora_mock.status = constants.ACTIVE
_amphora_mock.lb_network_ip = LB_NET_IP
_db_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.status = constants.ACTIVE
_db_amphora_mock.lb_network_ip = LB_NET_IP
mock_driver.get_amphora.return_value = _amphora_mock, None
mock_driver.get_amphora.return_value = _db_amphora_mock, None
computewait = compute_tasks.ComputeActiveWait()
computewait.execute(COMPUTE_ID, AMPHORA_ID)
mock_driver.get_amphora.assert_called_once_with(COMPUTE_ID)
_amphora_mock.status = constants.DELETED
_db_amphora_mock.status = constants.DELETED
self.assertRaises(exceptions.ComputeWaitTimeoutException,
computewait.execute,
_amphora_mock, AMPHORA_ID)
_db_amphora_mock, AMPHORA_ID)
@mock.patch('octavia.controller.worker.amphora_rate_limit'
'.AmphoraBuildRateLimit.remove_from_build_req_queue')
@ -455,22 +460,22 @@ class TestComputeTasks(base.TestCase):
mock_remove_from_build_queue):
self.conf.config(group='haproxy_amphora', build_rate_limit=5)
_amphora_mock.compute_id = COMPUTE_ID
_amphora_mock.status = constants.ACTIVE
_amphora_mock.lb_network_ip = LB_NET_IP
_db_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.status = constants.ACTIVE
_db_amphora_mock.lb_network_ip = LB_NET_IP
mock_driver.get_amphora.return_value = _amphora_mock, None
mock_driver.get_amphora.return_value = _db_amphora_mock, None
computewait = compute_tasks.ComputeActiveWait()
computewait.execute(COMPUTE_ID, AMPHORA_ID)
mock_driver.get_amphora.assert_called_once_with(COMPUTE_ID)
_amphora_mock.status = constants.ERROR
_db_amphora_mock.status = constants.ERROR
self.assertRaises(exceptions.ComputeBuildException,
computewait.execute,
_amphora_mock, AMPHORA_ID)
_db_amphora_mock, AMPHORA_ID)
@mock.patch('octavia.controller.worker.amphora_rate_limit'
'.AmphoraBuildRateLimit.remove_from_build_req_queue')
@ -480,11 +485,11 @@ class TestComputeTasks(base.TestCase):
mock_time_sleep,
mock_driver,
mock_remove_from_build_queue):
_amphora_mock.compute_id = COMPUTE_ID
_amphora_mock.status = constants.ACTIVE
_amphora_mock.lb_network_ip = LB_NET_IP
_db_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.status = constants.ACTIVE
_db_amphora_mock.lb_network_ip = LB_NET_IP
mock_driver.get_amphora.return_value = _amphora_mock, None
mock_driver.get_amphora.return_value = _db_amphora_mock, None
computewait = compute_tasks.ComputeActiveWait()
computewait.execute(COMPUTE_ID, AMPHORA_ID)

184
octavia/tests/unit/controller/worker/v2/tasks/test_database_tasks.py
View File

@ -55,28 +55,27 @@ CACHED_ZONE = 'zone1'
IMAGE_ID = uuidutils.generate_uuid()
COMPUTE_FLAVOR = uuidutils.generate_uuid()
_amphora_mock = mock.MagicMock()
_amphora_mock.id = AMP_ID
_amphora_mock.compute_id = COMPUTE_ID
_amphora_mock.lb_network_ip = LB_NET_IP
_amphora_mock.vrrp_ip = VRRP_IP
_amphora_mock.ha_ip = HA_IP
_amphora_mock.ha_port_id = HA_PORT_ID
_amphora_mock.vrrp_port_id = VRRP_PORT_ID
_amphora_mock.role = AMP_ROLE
_amphora_mock.vrrp_id = VRRP_ID
_amphora_mock.vrrp_priority = VRRP_PRIORITY
_amphorae = [_amphora_mock]
_db_amphora_mock = mock.MagicMock()
_db_amphora_mock.id = AMP_ID
_db_amphora_mock.compute_id = COMPUTE_ID
_db_amphora_mock.lb_network_ip = LB_NET_IP
_db_amphora_mock.vrrp_ip = VRRP_IP
_db_amphora_mock.ha_ip = HA_IP
_db_amphora_mock.ha_port_id = HA_PORT_ID
_db_amphora_mock.vrrp_port_id = VRRP_PORT_ID
_db_amphora_mock.role = AMP_ROLE
_db_amphora_mock.vrrp_id = VRRP_ID
_db_amphora_mock.vrrp_priority = VRRP_PRIORITY
_loadbalancer_mock = mock.MagicMock()
_loadbalancer_mock.id = LB_ID
_loadbalancer_mock.amphorae = [_amphora_mock]
_loadbalancer_mock.amphorae = [_db_amphora_mock]
_l7policy_mock = mock.MagicMock()
_l7policy_mock.id = L7POLICY_ID
_l7rule_mock = mock.MagicMock()
_l7rule_mock.id = L7RULE_ID
_listener_mock = mock.MagicMock()
_listener_to_dict_mock = mock.MagicMock(
return_value={'id': LISTENER_ID})
return_value={constants.ID: LISTENER_ID})
_listener_mock.id = LISTENER_ID
_listener_mock.to_dict = _listener_to_dict_mock
_tf_failure_mock = mock.Mock(spec=failure.Failure)
@ -86,11 +85,12 @@ _vip_mock.subnet_id = SUBNET_ID
_vip_mock.ip_address = VIP_IP
_vrrp_group_mock = mock.MagicMock()
_cert_mock = mock.MagicMock()
_compute_mock = mock.MagicMock()
_compute_mock.lb_network_ip = LB_NET_IP
_compute_mock.cached_zone = CACHED_ZONE
_compute_mock.image_id = IMAGE_ID
_compute_mock.compute_flavor = COMPUTE_FLAVOR
_compute_mock_dict = {
constants.LB_NETWORK_IP: LB_NET_IP,
constants.CACHED_ZONE: CACHED_ZONE,
constants.IMAGE_ID: IMAGE_ID,
constants.COMPUTE_FLAVOR: COMPUTE_FLAVOR
}
@mock.patch('octavia.db.repositories.AmphoraRepository.delete')
@ -133,10 +133,24 @@ class TestDatabaseTasks(base.TestCase):
self.l7rule_mock.id = L7RULE_ID
self.l7rule_mock.l7policy = self.l7policy_mock
self.amphora = {
constants.ID: AMP_ID,
constants.COMPUTE_ID: COMPUTE_ID,
constants.LB_NETWORK_IP: LB_NET_IP,
constants.VRRP_IP: VRRP_IP,
constants.HA_IP: HA_IP,
constants.HA_PORT_ID: HA_PORT_ID,
constants.VRRP_PORT_ID: VRRP_PORT_ID,
constants.ROLE: AMP_ROLE,
constants.VRRP_ID: VRRP_ID,
constants.VRRP_PRIORITY: VRRP_PRIORITY,
}
_db_amphora_mock.to_dict.return_value = self.amphora
super(TestDatabaseTasks, self).setUp()
@mock.patch('octavia.db.repositories.AmphoraRepository.create',
return_value=_amphora_mock)
return_value=_db_amphora_mock)
def test_create_amphora_in_db(self,
mock_create,
mock_generate_uuid,
@ -156,7 +170,7 @@ class TestDatabaseTasks(base.TestCase):
status=constants.PENDING_CREATE,
cert_busy=False)
self.assertEqual(_amphora_mock.id, amp_id)
self.assertEqual(_db_amphora_mock.id, amp_id)
# Test the revert
create_amp_in_db.revert(_tf_failure_mock)
@ -384,7 +398,7 @@ class TestDatabaseTasks(base.TestCase):
# operating_status=constants.ERROR)
@mock.patch('octavia.db.repositories.AmphoraRepository.get',
return_value=_amphora_mock)
return_value=_db_amphora_mock)
def test_reload_amphora(self,
mock_amp_get,
mock_generate_uuid,
@ -396,13 +410,13 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
reload_amp = database_tasks.ReloadAmphora()
amp = reload_amp.execute(AMP_ID)
amp = reload_amp.execute(self.amphora)
repo.AmphoraRepository.get.assert_called_once_with(
'TEST',
id=AMP_ID)
self.assertEqual(_amphora_mock, amp)
self.assertEqual(_db_amphora_mock.to_dict(), amp)
@mock.patch('octavia.db.repositories.LoadBalancerRepository.get',
return_value=_loadbalancer_mock)
@ -461,7 +475,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
update_amp_vip_data = database_tasks.UpdateAmphoraeVIPData()
update_amp_vip_data.execute(_amphorae)
update_amp_vip_data.execute([self.amphora])
mock_amphora_repo_update.assert_called_once_with(
'TEST',
@ -481,7 +495,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update,
mock_amphora_repo_delete):
update_amp_vip_data2 = database_tasks.UpdateAmphoraVIPData()
update_amp_vip_data2.execute(_amphorae[0])
update_amp_vip_data2.execute(self.amphora)
mock_amphora_repo_update.assert_called_once_with(
'TEST',
@ -502,7 +516,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
update_amp_fo_details = database_tasks.UpdateAmpFailoverDetails()
update_amp_fo_details.execute(_amphora_mock, _amphora_mock)
update_amp_fo_details.execute(self.amphora, self.amphora)
mock_amphora_repo_update.assert_called_once_with(
'TEST',
@ -551,7 +565,7 @@ class TestDatabaseTasks(base.TestCase):
@mock.patch('octavia.db.repositories.AmphoraRepository.'
'allocate_and_associate',
side_effect=[_amphora_mock, None])
side_effect=[_db_amphora_mock, None])
def test_map_loadbalancer_to_amphora(self,
mock_allocate_and_associate,
mock_generate_uuid,
@ -563,14 +577,14 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
map_lb_to_amp = database_tasks.MapLoadbalancerToAmphora()
amp_id = map_lb_to_amp.execute(self.loadbalancer_mock.id)
amp = map_lb_to_amp.execute(self.loadbalancer_mock.id)
repo.AmphoraRepository.allocate_and_associate.assert_called_once_with(
'TEST',
LB_ID,
None)
self.assertEqual(_amphora_mock.id, amp_id)
self.assertEqual(self.amphora, amp)
amp_id = map_lb_to_amp.execute(self.loadbalancer_mock.id)
@ -594,7 +608,7 @@ class TestDatabaseTasks(base.TestCase):
@mock.patch('octavia.db.repositories.AmphoraRepository.'
'allocate_and_associate',
side_effect=[_amphora_mock, None])
side_effect=[_db_amphora_mock, None])
def test_map_loadbalancer_to_amphora_with_az(self,
mock_allocate_and_associate,
mock_generate_uuid,
@ -606,7 +620,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
map_lb_to_amp = database_tasks.MapLoadbalancerToAmphora()
amp_id = map_lb_to_amp.execute(
amp = map_lb_to_amp.execute(
self.loadbalancer_mock.id, availability_zone={
constants.COMPUTE_ZONE: 'fakeaz'})
@ -615,11 +629,11 @@ class TestDatabaseTasks(base.TestCase):
LB_ID,
'fakeaz')
self.assertEqual(_amphora_mock.id, amp_id)
self.assertEqual(self.amphora, amp)
amp_id = map_lb_to_amp.execute(self.loadbalancer_mock.id)
amp = map_lb_to_amp.execute(self.loadbalancer_mock.id)
self.assertIsNone(amp_id)
self.assertIsNone(amp)
# Test revert
map_lb_to_amp.revert(None, self.loadbalancer_mock.id)
@ -638,7 +652,7 @@ class TestDatabaseTasks(base.TestCase):
provisioning_status=constants.ERROR)
@mock.patch('octavia.db.repositories.AmphoraRepository.get',
return_value=_amphora_mock)
return_value=_db_amphora_mock)
@mock.patch('octavia.db.repositories.LoadBalancerRepository.get',
return_value=_loadbalancer_mock)
def test_mark_lb_amphorae_deleted_in_db(self,
@ -662,7 +676,7 @@ class TestDatabaseTasks(base.TestCase):
status=constants.DELETED)
@mock.patch('octavia.db.repositories.AmphoraRepository.get',
return_value=_amphora_mock)
return_value=_db_amphora_mock)
@mock.patch('octavia.db.repositories.LoadBalancerRepository.get',
return_value=_loadbalancer_mock)
def test_mark_amphora_allocated_in_db(self,
@ -678,7 +692,7 @@ class TestDatabaseTasks(base.TestCase):
mark_amp_allocated_in_db = (database_tasks.
MarkAmphoraAllocatedInDB())
mark_amp_allocated_in_db.execute(_amphora_mock,
mark_amp_allocated_in_db.execute(self.amphora,
self.loadbalancer_mock.id)
repo.AmphoraRepository.update.assert_called_once_with(
@ -692,7 +706,7 @@ class TestDatabaseTasks(base.TestCase):
# Test the revert
mock_amphora_repo_update.reset_mock()
mark_amp_allocated_in_db.revert(None, _amphora_mock,
mark_amp_allocated_in_db.revert(None, self.amphora,
self.loadbalancer_mock.id)
repo.AmphoraRepository.update.assert_called_once_with(
@ -704,7 +718,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update.reset_mock()
mock_amphora_repo_update.side_effect = Exception('fail')
mark_amp_allocated_in_db.revert(None, _amphora_mock,
mark_amp_allocated_in_db.revert(None, self.amphora,
self.loadbalancer_mock.id)
repo.AmphoraRepository.update.assert_called_once_with(
@ -722,8 +736,8 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
mark_amp_booting_in_db = database_tasks.MarkAmphoraBootingInDB()
mark_amp_booting_in_db.execute(_amphora_mock.id,
_amphora_mock.compute_id)
mark_amp_booting_in_db.execute(_db_amphora_mock.id,
_db_amphora_mock.compute_id)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -734,8 +748,8 @@ class TestDatabaseTasks(base.TestCase):
# Test the revert
mock_amphora_repo_update.reset_mock()
mark_amp_booting_in_db.revert(None, _amphora_mock.id,
_amphora_mock.compute_id)
mark_amp_booting_in_db.revert(None, _db_amphora_mock.id,
_db_amphora_mock.compute_id)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -747,8 +761,8 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update.reset_mock()
mock_amphora_repo_update.side_effect = Exception('fail')
mark_amp_booting_in_db.revert(None, _amphora_mock.id,
_amphora_mock.compute_id)
mark_amp_booting_in_db.revert(None, _db_amphora_mock.id,
_db_amphora_mock.compute_id)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -766,7 +780,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
mark_amp_deleted_in_db = database_tasks.MarkAmphoraDeletedInDB()
mark_amp_deleted_in_db.execute(_amphora_mock)
mark_amp_deleted_in_db.execute(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -775,7 +789,7 @@ class TestDatabaseTasks(base.TestCase):
# Test the revert
mock_amphora_repo_update.reset_mock()
mark_amp_deleted_in_db.revert(_amphora_mock)
mark_amp_deleted_in_db.revert(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -785,7 +799,7 @@ class TestDatabaseTasks(base.TestCase):
# Test the revert with exception
mock_amphora_repo_update.reset_mock()
mock_amphora_repo_update.side_effect = Exception('fail')
mark_amp_deleted_in_db.revert(_amphora_mock)
mark_amp_deleted_in_db.revert(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -803,7 +817,7 @@ class TestDatabaseTasks(base.TestCase):
mark_amp_pending_delete_in_db = (database_tasks.
MarkAmphoraPendingDeleteInDB())
mark_amp_pending_delete_in_db.execute(_amphora_mock)
mark_amp_pending_delete_in_db.execute(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -812,7 +826,7 @@ class TestDatabaseTasks(base.TestCase):
# Test the revert
mock_amphora_repo_update.reset_mock()
mark_amp_pending_delete_in_db.revert(_amphora_mock)
mark_amp_pending_delete_in_db.revert(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -823,7 +837,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update.reset_mock()
mock_amphora_repo_update.side_effect = Exception('fail')
mark_amp_pending_delete_in_db.revert(_amphora_mock)
mark_amp_pending_delete_in_db.revert(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -841,7 +855,7 @@ class TestDatabaseTasks(base.TestCase):
mark_amp_pending_update_in_db = (database_tasks.
MarkAmphoraPendingUpdateInDB())
mark_amp_pending_update_in_db.execute(_amphora_mock)
mark_amp_pending_update_in_db.execute(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -850,7 +864,7 @@ class TestDatabaseTasks(base.TestCase):
# Test the revert
mock_amphora_repo_update.reset_mock()
mark_amp_pending_update_in_db.revert(_amphora_mock)
mark_amp_pending_update_in_db.revert(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -860,7 +874,7 @@ class TestDatabaseTasks(base.TestCase):
# Test the revert with exception
mock_amphora_repo_update.reset_mock()
mock_amphora_repo_update.side_effect = Exception('fail')
mark_amp_pending_update_in_db.revert(_amphora_mock)
mark_amp_pending_update_in_db.revert(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -876,10 +890,10 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update,
mock_amphora_repo_delete):
_amphora_mock.lb_network_ip = LB_NET_IP
self.amphora['lb_network_ip'] = LB_NET_IP
mark_amp_ready_in_db = database_tasks.MarkAmphoraReadyInDB()
mark_amp_ready_in_db.execute(_amphora_mock)
mark_amp_ready_in_db.execute(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -891,7 +905,7 @@ class TestDatabaseTasks(base.TestCase):
# Test the revert
mock_amphora_repo_update.reset_mock()
mark_amp_ready_in_db.revert(_amphora_mock)
mark_amp_ready_in_db.revert(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -904,7 +918,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update.reset_mock()
mock_amphora_repo_update.side_effect = Exception('fail')
mark_amp_ready_in_db.revert(_amphora_mock)
mark_amp_ready_in_db.revert(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -925,7 +939,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
update_amphora_info = database_tasks.UpdateAmphoraInfo()
update_amphora_info.execute(AMP_ID, _compute_mock)
update_amphora_info.execute(AMP_ID, _compute_mock_dict)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -1130,8 +1144,8 @@ class TestDatabaseTasks(base.TestCase):
fer = fernet.Fernet(key)
_pem_mock = fer.encrypt(
utils.get_six_compatible_value('test_cert')
)
update_amp_cert.execute(_amphora_mock.id, _pem_mock)
).decode('utf-8')
update_amp_cert.execute(_db_amphora_mock.id, _pem_mock)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
@ -1147,7 +1161,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update,
mock_amphora_repo_delete):
amp_cert_busy_to_F = database_tasks.UpdateAmphoraCertBusyToFalse()
amp_cert_busy_to_F.execute(_amphora_mock)
amp_cert_busy_to_F.execute(AMP_ID)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST',
AMP_ID,
@ -1764,7 +1778,10 @@ class TestDatabaseTasks(base.TestCase):
L7POLICY_ID,
provisioning_status=constants.ERROR)
@mock.patch('octavia.db.repositories.AmphoraRepository.get',
return_value=_db_amphora_mock)
def test_get_amphora_details(self,
mock_amp_get,
mock_generate_uuid,
mock_LOG,
mock_get_session,
@ -1774,15 +1791,15 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
get_amp_details = database_tasks.GetAmphoraDetails()
new_amp = get_amp_details.execute(_amphora_mock)
new_amp = get_amp_details.execute(self.amphora)
self.assertEqual(AMP_ID, new_amp.id)
self.assertEqual(VRRP_IP, new_amp.vrrp_ip)
self.assertEqual(HA_IP, new_amp.ha_ip)
self.assertEqual(VRRP_PORT_ID, new_amp.vrrp_port_id)
self.assertEqual(AMP_ROLE, new_amp.role)
self.assertEqual(VRRP_ID, new_amp.vrrp_id)
self.assertEqual(VRRP_PRIORITY, new_amp.vrrp_priority)
self.assertEqual(AMP_ID, new_amp[constants.ID])
self.assertEqual(VRRP_IP, new_amp[constants.VRRP_IP])
self.assertEqual(HA_IP, new_amp[constants.HA_IP])
self.assertEqual(VRRP_PORT_ID, new_amp[constants.VRRP_PORT_ID])
self.assertEqual(AMP_ROLE, new_amp[constants.ROLE])
self.assertEqual(VRRP_ID, new_amp[constants.VRRP_ID])
self.assertEqual(VRRP_PRIORITY, new_amp[constants.VRRP_PRIORITY])
def test_mark_amphora_role_indb(self,
mock_generate_uuid,
@ -1794,55 +1811,55 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_delete):
mark_amp_master_indb = database_tasks.MarkAmphoraMasterInDB()
mark_amp_master_indb.execute(_amphora_mock)
mark_amp_master_indb.execute(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST', AMP_ID, role='MASTER',
vrrp_priority=constants.ROLE_MASTER_PRIORITY)
mock_amphora_repo_update.reset_mock()
mark_amp_master_indb.revert("BADRESULT", _amphora_mock)
mark_amp_master_indb.revert("BADRESULT", self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST', AMP_ID, role=None, vrrp_priority=None)
mock_amphora_repo_update.reset_mock()
failure_obj = failure.Failure.from_exception(Exception("TESTEXCEPT"))
mark_amp_master_indb.revert(failure_obj, _amphora_mock)
mark_amp_master_indb.revert(failure_obj, self.amphora)
self.assertFalse(repo.AmphoraRepository.update.called)
mock_amphora_repo_update.reset_mock()
mark_amp_backup_indb = database_tasks.MarkAmphoraBackupInDB()
mark_amp_backup_indb.execute(_amphora_mock)
mark_amp_backup_indb.execute(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST', AMP_ID, role='BACKUP',
vrrp_priority=constants.ROLE_BACKUP_PRIORITY)
mock_amphora_repo_update.reset_mock()
mark_amp_backup_indb.revert("BADRESULT", _amphora_mock)
mark_amp_backup_indb.revert("BADRESULT", self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST', AMP_ID, role=None, vrrp_priority=None)
mock_amphora_repo_update.reset_mock()
mark_amp_standalone_indb = database_tasks.MarkAmphoraStandAloneInDB()
mark_amp_standalone_indb.execute(_amphora_mock)
mark_amp_standalone_indb.execute(self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST', AMP_ID, role='STANDALONE',
vrrp_priority=None)
mock_amphora_repo_update.reset_mock()
mark_amp_standalone_indb.revert("BADRESULT", _amphora_mock)
mark_amp_standalone_indb.revert("BADRESULT", self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST', AMP_ID, role=None, vrrp_priority=None)
# Test revert with exception
mock_amphora_repo_update.reset_mock()
mock_amphora_repo_update.side_effect = Exception('fail')
mark_amp_standalone_indb.revert("BADRESULT", _amphora_mock)
mark_amp_standalone_indb.revert("BADRESULT", self.amphora)
repo.AmphoraRepository.update.assert_called_once_with(
'TEST', AMP_ID, role=None, vrrp_priority=None)
@ -1863,11 +1880,12 @@ class TestDatabaseTasks(base.TestCase):
lb = mock.MagicMock()
lb.amphorae = [amp1, amp2]
mock_amphora_get.side_effect = [_amphora_mock, None]
mock_amphora_get.side_effect = [_db_amphora_mock, None]
get_amps_from_lb_obj = database_tasks.GetAmphoraeFromLoadbalancer()
result = get_amps_from_lb_obj.execute(lb)
self.assertEqual([_amphora_mock], result)
self.assertEqual([_db_amphora_mock.to_dict()], result)
self.assertEqual([_db_amphora_mock.to_dict()], result)
@mock.patch('octavia.db.repositories.ListenerRepository.get')
def test_get_listeners_from_loadbalancer(self,
@ -1934,7 +1952,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update,
mock_amphora_repo_delete):
disable_amp_health = database_tasks.DisableAmphoraHealthMonitoring()
disable_amp_health.execute(_amphora_mock)
disable_amp_health.execute(self.amphora)
mock_amp_health_repo_delete.assert_called_once_with(
'TEST', amphora_id=AMP_ID)
@ -1966,7 +1984,7 @@ class TestDatabaseTasks(base.TestCase):
mock_amphora_repo_update,
mock_amphora_repo_delete):
mark_busy = database_tasks.MarkAmphoraHealthBusy()
mark_busy.execute(_amphora_mock)
mark_busy.execute(self.amphora)
mock_amp_health_repo_update.assert_called_once_with(
'TEST', amphora_id=AMP_ID, busy=True)

5
octavia/tests/unit/controller/worker/v2/tasks/test_lifecycle_tasks.py
View File

@ -85,12 +85,13 @@ class TestLifecycleTasks(base.TestCase):
amp_to_error_on_revert = lifecycle_tasks.AmphoraToErrorOnRevertTask()
# Execute
amp_to_error_on_revert.execute(self.AMPHORA)
amp = {constants.ID: self.AMPHORA_ID}
amp_to_error_on_revert.execute(amp)
self.assertFalse(mock_amp_status_error.called)
# Revert
amp_to_error_on_revert.revert(self.AMPHORA)
amp_to_error_on_revert.revert(amp)
mock_amp_status_error.assert_called_once_with(self.AMPHORA_ID)
self.assertFalse(mock_amp_health_busy.called)

306
octavia/tests/unit/controller/worker/v2/tasks/test_network_tasks.py
View File

@ -71,15 +71,20 @@ class TestException(Exception):
class TestNetworkTasks(base.TestCase):
def setUp(self):
network_tasks.LOG = mock.MagicMock()
self.amphora_mock = mock.MagicMock()
self.db_amphora_mock = mock.MagicMock()
self.load_balancer_mock = mock.MagicMock()
self.vip_mock = mock.MagicMock()
self.vip_mock.subnet_id = SUBNET_ID
self.load_balancer_mock.vip = self.vip_mock
self.load_balancer_mock.amphorae = []
self.amphora_mock.id = AMPHORA_ID
self.amphora_mock.compute_id = COMPUTE_ID
self.amphora_mock.status = constants.AMPHORA_ALLOCATED
self.db_amphora_mock.id = AMPHORA_ID
self.db_amphora_mock.compute_id = COMPUTE_ID
self.db_amphora_mock.status = constants.AMPHORA_ALLOCATED
self.amphora_mock = {constants.ID: AMPHORA_ID,
constants.COMPUTE_ID: COMPUTE_ID,
constants.LB_NETWORK_IP: IP_ADDRESS,
}
conf = oslo_fixture.Config(cfg.CONF)
conf.config(group="controller_worker", amp_boot_network_list=['netid'])
@ -87,13 +92,21 @@ class TestNetworkTasks(base.TestCase):
def test_calculate_delta(self, mock_get_net_driver):
mock_driver = mock.MagicMock()
self.db_amphora_mock.to_dict.return_value = {
constants.ID: AMPHORA_ID, constants.COMPUTE_ID: COMPUTE_ID,
constants.VRRP_PORT_ID: PORT_ID}
mock_get_net_driver.return_value = mock_driver
mock_driver.get_plugged_networks.return_value = [
data_models.Interface(network_id='netid')]
mock_driver.get_port.return_value = data_models.Port(
network_id='netid')
EMPTY = {}
empty_deltas = {self.amphora_mock.id: data_models.Delta(
amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
empty_deltas = {self.db_amphora_mock.id: data_models.Delta(
amphora_id=AMPHORA_ID,
compute_id=COMPUTE_ID,
add_nics=[],
delete_nics=[])}
delete_nics=[]).to_dict(recurse=True)}
calc_delta = network_tasks.CalculateDelta()
@ -103,10 +116,9 @@ class TestNetworkTasks(base.TestCase):
# Delta should be empty
mock_driver.reset_mock()
self.amphora_mock.load_balancer = self.load_balancer_mock
self.load_balancer_mock.amphorae = [self.amphora_mock]
self.db_amphora_mock.load_balancer = self.load_balancer_mock
self.load_balancer_mock.amphorae = [self.db_amphora_mock]
self.load_balancer_mock.pools = []
self.assertEqual(empty_deltas,
calc_delta.execute(self.load_balancer_mock))
mock_driver.get_plugged_networks.assert_called_once_with(COMPUTE_ID)
@ -130,15 +142,15 @@ class TestNetworkTasks(base.TestCase):
mock_driver.get_subnet.return_value = data_models.Subnet(id=2,
network_id=3)
ndm = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[
data_models.Interface(network_id=2)],
delete_nics=[])
self.assertEqual({self.amphora_mock.id: ndm},
data_models.Interface(network_id=3)],
delete_nics=[]).to_dict(recurse=True)
self.assertEqual({self.db_amphora_mock.id: ndm},
calc_delta.execute(self.load_balancer_mock))
vrrp_port_call = mock.call(self.amphora_mock.vrrp_port_id)
vrrp_port_call = mock.call(PORT_ID)
mock_driver.get_port.assert_has_calls([vrrp_port_call])
self.assertEqual(1, mock_driver.get_port.call_count)
@ -153,7 +165,8 @@ class TestNetworkTasks(base.TestCase):
member_mock.subnet_id = 1
pool_mock.members = [member_mock]
mock_driver.get_plugged_networks.return_value = [
data_models.Interface(network_id=2)]
data_models.Interface(network_id=3),
data_models.Interface(network_id='netid')]
self.assertEqual(empty_deltas,
calc_delta.execute(self.load_balancer_mock))
@ -165,15 +178,17 @@ class TestNetworkTasks(base.TestCase):
member_mock.subnet_id = 1
pool_mock.members = [member_mock]
mock_driver.get_plugged_networks.return_value = [
data_models.Interface(network_id=3)]
data_models.Interface(network_id=2),
data_models.Interface(network_id='netid')]
ndm = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[
data_models.Interface(network_id=2)],
data_models.Interface(network_id=3)],
delete_nics=[
data_models.Interface(network_id=3)])
self.assertEqual({self.amphora_mock.id: ndm},
data_models.Interface(network_id=2)]
).to_dict(recurse=True)
self.assertEqual({self.db_amphora_mock.id: ndm},
calc_delta.execute(self.load_balancer_mock))
# Test with one amp and one pool and no members, one network plugged
@ -181,14 +196,17 @@ class TestNetworkTasks(base.TestCase):
mock_driver.reset_mock()
pool_mock.members = []
mock_driver.get_plugged_networks.return_value = [
data_models.Interface(network_id=2)]
data_models.Interface(network_id=2),
data_models.Interface(network_id='netid')
]
ndm = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=[
data_models.Interface(network_id=2)])
self.assertEqual({self.amphora_mock.id: ndm},
data_models.Interface(network_id=2)]
).to_dict(recurse=True)
self.assertEqual({self.db_amphora_mock.id: ndm},
calc_delta.execute(self.load_balancer_mock))
def test_get_plumbed_networks(self, mock_get_net_driver):
@ -213,17 +231,17 @@ class TestNetworkTasks(base.TestCase):
net.execute(self.amphora_mock, None)
self.assertFalse(mock_driver.plug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=[])
delete_nics=[]).to_dict(recurse=True)
net.execute(self.amphora_mock, delta)
self.assertFalse(mock_driver.plug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=_interface(1),
delete_nics=[])
delete_nics=[]).to_dict(recurse=True)
net.execute(self.amphora_mock, delta)
mock_driver.plug_network.assert_called_once_with(COMPUTE_ID, 1)
@ -231,17 +249,17 @@ class TestNetworkTasks(base.TestCase):
net.revert(self.amphora_mock, None)
self.assertFalse(mock_driver.unplug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=[])
delete_nics=[]).to_dict(recurse=True)
net.revert(self.amphora_mock, delta)
self.assertFalse(mock_driver.unplug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=_interface(1),
delete_nics=[])
delete_nics=[]).to_dict(recurse=True)
net.revert(self.amphora_mock, delta)
mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
@ -267,20 +285,21 @@ class TestNetworkTasks(base.TestCase):
net = network_tasks.UnPlugNetworks()
net.execute(self.amphora_mock, None)
net.execute(self.db_amphora_mock, None)
self.assertFalse(mock_driver.unplug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=[])
delete_nics=[]).to_dict(recurse=True)
net.execute(self.amphora_mock, delta)
self.assertFalse(mock_driver.unplug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=_interface(1))
delete_nics=_interface(1)
).to_dict(recurse=True)
net.execute(self.amphora_mock, delta)
mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
@ -332,11 +351,13 @@ class TestNetworkTasks(base.TestCase):
def test_handle_network_delta(self, mock_get_net_driver):
mock_net_driver = mock.MagicMock()
self.db_amphora_mock.to_dict.return_value = {
constants.ID: AMPHORA_ID, constants.COMPUTE_ID: COMPUTE_ID}
mock_get_net_driver.return_value = mock_net_driver
nic1 = mock.MagicMock()
nic1 = data_models.Interface()
nic1.network_id = uuidutils.generate_uuid()
nic2 = mock.MagicMock()
nic2 = data_models.Interface()
nic2.network_id = uuidutils.generate_uuid()
interface1 = mock.MagicMock()
interface1.port_id = uuidutils.generate_uuid()
@ -348,10 +369,11 @@ class TestNetworkTasks(base.TestCase):
subnet = mock.MagicMock()
network = mock.MagicMock()
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[nic1],
delete_nics=[nic2, nic2, nic2])
delete_nics=[nic2, nic2, nic2]
).to_dict(recurse=True)
mock_net_driver.plug_network.return_value = interface1
mock_net_driver.get_port.return_value = port1
@ -362,24 +384,26 @@ class TestNetworkTasks(base.TestCase):
None, net_base.NetworkNotFound, Exception]
handle_net_delta_obj = network_tasks.HandleNetworkDelta()
result = handle_net_delta_obj.execute(self.amphora_mock, delta)
result = handle_net_delta_obj.execute(self.amphora_mock,
delta)
mock_net_driver.plug_network.assert_called_once_with(
self.amphora_mock.compute_id, nic1.network_id)
self.db_amphora_mock.compute_id, nic1.network_id)
mock_net_driver.get_port.assert_called_once_with(interface1.port_id)
mock_net_driver.get_network.assert_called_once_with(port1.network_id)
mock_net_driver.get_subnet.assert_called_once_with(fixed_ip.subnet_id)
self.assertEqual({self.amphora_mock.id: [port1]}, result)
self.assertEqual({self.db_amphora_mock.id: [port1.to_dict()]}, result)
mock_net_driver.unplug_network.assert_called_with(
self.amphora_mock.compute_id, nic2.network_id)
self.db_amphora_mock.compute_id, nic2.network_id)
# Revert
delta2 = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta2 = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[nic1, nic1],
delete_nics=[nic2, nic2, nic2])
delete_nics=[nic2, nic2, nic2]
).to_dict(recurse=True)
mock_net_driver.unplug_network.reset_mock()
handle_net_delta_obj.revert(
@ -395,6 +419,8 @@ class TestNetworkTasks(base.TestCase):
def test_handle_network_deltas(self, mock_get_net_driver):
mock_driver = mock.MagicMock()
self.db_amphora_mock.to_dict.return_value = {
constants.ID: AMPHORA_ID, constants.COMPUTE_ID: COMPUTE_ID}
mock_get_net_driver.return_value = mock_driver
def _interface(network_id):
@ -405,35 +431,35 @@ class TestNetworkTasks(base.TestCase):
net.execute({})
self.assertFalse(mock_driver.plug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=[])
net.execute({self.amphora_mock.id: delta})
delete_nics=[]).to_dict(recurse=True)
net.execute({self.db_amphora_mock.id: delta})
self.assertFalse(mock_driver.plug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=_interface(1),
delete_nics=[])
net.execute({self.amphora_mock.id: delta})
delete_nics=[]).to_dict(recurse=True)
net.execute({self.db_amphora_mock.id: delta})
mock_driver.plug_network.assert_called_once_with(COMPUTE_ID, 1)
# revert
net.execute({self.amphora_mock.id: delta})
net.execute({self.db_amphora_mock.id: delta})
self.assertFalse(mock_driver.unplug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=[])
net.execute({self.amphora_mock.id: delta})
delete_nics=[]).to_dict(recurse=True)
net.execute({self.db_amphora_mock.id: delta})
self.assertFalse(mock_driver.unplug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=_interface(1),
delete_nics=[])
delete_nics=[]).to_dict(recurse=True)
mock_driver.reset_mock()
mock_driver.unplug_network.side_effect = net_base.NetworkNotFound
@ -441,44 +467,46 @@ class TestNetworkTasks(base.TestCase):
mock_driver.reset_mock()
mock_driver.unplug_network.side_effect = TestException('test')
self.assertRaises(TestException, net.revert, mock.ANY,
{self.amphora_mock.id: delta})
{self.db_amphora_mock.id: delta})
mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
mock_driver.reset_mock()
net.execute({})
self.assertFalse(mock_driver.unplug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=[])
net.execute({self.amphora_mock.id: delta})
delete_nics=[]).to_dict(recurse=True)
net.execute({self.db_amphora_mock.id: delta})
self.assertFalse(mock_driver.unplug_network.called)
delta = data_models.Delta(amphora_id=self.amphora_mock.id,
compute_id=self.amphora_mock.compute_id,
delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
compute_id=self.db_amphora_mock.compute_id,
add_nics=[],
delete_nics=_interface(1))
net.execute({self.amphora_mock.id: delta})
delete_nics=_interface(1)
).to_dict(recurse=True)
net.execute({self.db_amphora_mock.id: delta})
mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
mock_driver.reset_mock()
mock_driver.unplug_network.side_effect = net_base.NetworkNotFound
net.execute({self.amphora_mock.id: delta})
net.execute({self.db_amphora_mock.id: delta})
mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
# Do a test with a general exception in case behavior changes
mock_driver.reset_mock()
mock_driver.unplug_network.side_effect = Exception()
net.execute({self.amphora_mock.id: delta})
net.execute({self.db_amphora_mock.id: delta})
mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
def test_plug_vip(self, mock_get_net_driver):
mock_driver = mock.MagicMock()
mock_get_net_driver.return_value = mock_driver
net = network_tasks.PlugVIP()
mock_driver.plug_vip.return_value = ["vip"]
amp = mock.MagicMock()
amp.to_dict.return_value = 'vip'
mock_driver.plug_vip.return_value = [amp]
data = net.execute(LB)
mock_driver.plug_vip.assert_called_once_with(LB, LB.vip)
@ -680,14 +708,17 @@ class TestNetworkTasks(base.TestCase):
net_task.execute(lb)
mock_driver.get_network_configs.assert_called_once_with(lb)
def test_failover_preparation_for_amphora(self, mock_get_net_driver):
@mock.patch('octavia.db.repositories.AmphoraRepository.get')
@mock.patch('octavia.db.api.get_session', return_value=mock.MagicMock())
def test_failover_preparation_for_amphora(self, mock_session, mock_get,
mock_get_net_driver):
mock_driver = mock.MagicMock()
mock_get.return_value = self.db_amphora_mock
mock_get_net_driver.return_value = mock_driver
failover = network_tasks.FailoverPreparationForAmphora()
amphora = o_data_models.Amphora(id=AMPHORA_ID,
lb_network_ip=IP_ADDRESS)
failover.execute(amphora)
mock_driver.failover_preparation.assert_called_once_with(amphora)
failover.execute(self.amphora_mock)
mock_driver.failover_preparation.assert_called_once_with(
self.db_amphora_mock)
def test_retrieve_portids_on_amphora_except_lb_network(
self, mock_get_net_driver):
@ -698,11 +729,8 @@ class TestNetworkTasks(base.TestCase):
return [data_models.Interface(port_id=port_id)]
net_task = network_tasks.RetrievePortIDsOnAmphoraExceptLBNetwork()
amphora = o_data_models.Amphora(id=AMPHORA_ID, compute_id=COMPUTE_ID,
lb_network_ip=IP_ADDRESS)
mock_driver.get_plugged_networks.return_value = []
net_task.execute(amphora)
net_task.execute(self.amphora_mock)
mock_driver.get_plugged_networks.assert_called_once_with(
compute_id=COMPUTE_ID)
self.assertFalse(mock_driver.get_port.called)
@ -710,7 +738,7 @@ class TestNetworkTasks(base.TestCase):
mock_driver.reset_mock()
net_task = network_tasks.RetrievePortIDsOnAmphoraExceptLBNetwork()
mock_driver.get_plugged_networks.return_value = _interface(1)
net_task.execute(amphora)
net_task.execute(self.amphora_mock)
mock_driver.get_port.assert_called_once_with(port_id=1)
mock_driver.reset_mock()
@ -721,7 +749,7 @@ class TestNetworkTasks(base.TestCase):
port_mock.fixed_ips = [fixed_ip_mock]
mock_driver.get_plugged_networks.return_value = _interface(1)
mock_driver.get_port.return_value = port_mock
ports = net_task.execute(amphora)
ports = net_task.execute(self.amphora_mock)
self.assertEqual([], ports)
mock_driver.reset_mock()
@ -732,50 +760,68 @@ class TestNetworkTasks(base.TestCase):
port_mock.fixed_ips = [fixed_ip_mock]
mock_driver.get_plugged_networks.return_value = _interface(1)
mock_driver.get_port.return_value = port_mock
ports = net_task.execute(amphora)
ports = net_task.execute(self.amphora_mock)
self.assertEqual(1, len(ports))
def test_plug_ports(self, mock_get_net_driver):
@mock.patch('octavia.db.repositories.AmphoraRepository.get')
@mock.patch('octavia.db.api.get_session', return_value=mock.MagicMock())
def test_plug_ports(self, mock_session, mock_get, mock_get_net_driver):
mock_driver = mock.MagicMock()
mock_get.return_value = self.db_amphora_mock
mock_get_net_driver.return_value = mock_driver
amphora = mock.MagicMock()
port1 = mock.MagicMock()
port2 = mock.MagicMock()
amp = {constants.ID: AMPHORA_ID,
constants.COMPUTE_ID: '1234'}
plugports = network_tasks.PlugPorts()
plugports.execute(amphora, [port1, port2])
plugports.execute(amp, [port1, port2])
mock_driver.plug_port.assert_any_call(amphora, port1)
mock_driver.plug_port.assert_any_call(amphora, port2)
mock_driver.plug_port.assert_any_call(self.db_amphora_mock, port1)
mock_driver.plug_port.assert_any_call(self.db_amphora_mock, port2)
def test_plug_vip_port(self, mock_get_net_driver):
@mock.patch('octavia.db.repositories.AmphoraRepository.get')
@mock.patch('octavia.db.api.get_session', return_value=mock.MagicMock())
def test_plug_vip_port(self, mock_session, mock_get, mock_get_net_driver):
mock_driver = mock.MagicMock()
mock_get.return_value = self.db_amphora_mock
mock_get_net_driver.return_value = mock_driver
vrrp_port = mock.MagicMock()
amphorae_network_config = mock.MagicMock()
amphorae_network_config.get().vrrp_port = vrrp_port
mock_driver.get_port.return_value = vrrp_port
plugvipport = network_tasks.PlugVIPPort()
plugvipport.execute(self.amphora_mock, amphorae_network_config)
mock_driver.plug_port.assert_any_call(self.amphora_mock, vrrp_port)
amp = {constants.ID: AMPHORA_ID,
constants.COMPUTE_ID: '1234'}
plugvipport.execute(amp, amphorae_network_config)
mock_driver.plug_port.assert_called_once_with(self.db_amphora_mock,
vrrp_port)
dict_amp_config = {
AMPHORA_ID: {constants.VRRP_PORT: {constants.ID: 5555}}
}
# test revert
plugvipport.revert(None, self.amphora_mock, amphorae_network_config)
mock_driver.unplug_port.assert_any_call(self.amphora_mock, vrrp_port)
plugvipport.revert(None, amp, dict_amp_config)
mock_driver.unplug_port.assert_called_with(self.db_amphora_mock,
vrrp_port)
def test_wait_for_port_detach(self, mock_get_net_driver):
@mock.patch('octavia.db.repositories.AmphoraRepository.get')
@mock.patch('octavia.db.api.get_session', return_value=mock.MagicMock())
def test_wait_for_port_detach(self, mock_session, mock_get,
mock_get_net_driver):
mock_driver = mock.MagicMock()
mock_get.return_value = self.db_amphora_mock
mock_get_net_driver.return_value = mock_driver
amphora = o_data_models.Amphora(id=AMPHORA_ID,
lb_network_ip=IP_ADDRESS)
amphora = {constants.ID: AMPHORA_ID,
constants.LB_NETWORK_IP: IP_ADDRESS}
waitforportdetach = network_tasks.WaitForPortDetach()
waitforportdetach.execute(amphora)
mock_driver.wait_for_port_detach.assert_called_once_with(amphora)
mock_driver.wait_for_port_detach.assert_called_once_with(
self.db_amphora_mock)
def test_update_vip_sg(self, mock_get_net_driver):
mock_driver = mock.MagicMock()
@ -793,20 +839,32 @@ class TestNetworkTasks(base.TestCase):
net.execute(LB)
mock_driver.get_subnet.assert_called_once_with(LB.vip.subnet_id)
def test_plug_vip_amphora(self, mock_get_net_driver):
@mock.patch('octavia.db.repositories.AmphoraRepository.get')
@mock.patch('octavia.db.api.get_session', return_value=mock.MagicMock())
def test_plug_vip_amphora(self, mock_session, mock_get,
mock_get_net_driver):
mock_driver = mock.MagicMock()
amphora = {constants.ID: AMPHORA_ID,
constants.LB_NETWORK_IP: IP_ADDRESS}
mock_get.return_value = self.db_amphora_mock
mock_get_net_driver.return_value = mock_driver
net = network_tasks.PlugVIPAmpphora()
mockSubnet = mock.MagicMock()
net.execute(LB, self.amphora_mock, mockSubnet)
mockSubnet = mock_driver.get_subnet()
net.execute(LB, amphora, mockSubnet)
mock_driver.plug_aap_port.assert_called_once_with(
LB, LB.vip, self.amphora_mock, mockSubnet)
LB, LB.vip, self.db_amphora_mock, mockSubnet)
def test_revert_plug_vip_amphora(self, mock_get_net_driver):
@mock.patch('octavia.db.repositories.AmphoraRepository.get')
@mock.patch('octavia.db.api.get_session', return_value=mock.MagicMock())
def test_revert_plug_vip_amphora(self, mock_session, mock_get,
mock_get_net_driver):
mock_driver = mock.MagicMock()
mock_get.return_value = self.db_amphora_mock
mock_get_net_driver.return_value = mock_driver
net = network_tasks.PlugVIPAmpphora()
mockSubnet = mock.MagicMock()
net.revert(AMPS_DATA[0], LB, self.amphora_mock, mockSubnet)
amphora = {constants.ID: AMPHORA_ID,
constants.LB_NETWORK_IP: IP_ADDRESS}
net.revert(AMPS_DATA[0].to_dict(), LB, amphora, mockSubnet)
mock_driver.unplug_aap_port.assert_called_once_with(
LB.vip, self.amphora_mock, mockSubnet)
LB.vip, self.db_amphora_mock, mockSubnet)

54
octavia/tests/unit/controller/worker/v2/test_controller_worker.py
View File

@ -46,7 +46,11 @@ L7RULE_UPDATE_DICT = {
'compare_type': constants.L7RULE_COMPARE_TYPE_STARTS_WITH,
'value': '/api'}
_amphora_mock = mock.MagicMock()
_db_amphora_mock = mock.MagicMock()
_amphora_mock = {
constants.ID: AMP_ID,
constants.LOAD_BALANCER_ID: LB_ID,
}
_flow_mock = mock.MagicMock()
_health_mon_mock = mock.MagicMock()
_vip_mock = mock.MagicMock()
@ -60,8 +64,8 @@ _db_pool_mock = mock.MagicMock()
_l7policy_mock = mock.MagicMock()
_l7rule_mock = mock.MagicMock()
_create_map_flow_mock = mock.MagicMock()
_amphora_mock.load_balancer_id = LB_ID
_amphora_mock.id = AMP_ID
_db_amphora_mock.load_balancer_id = LB_ID
_db_amphora_mock.id = AMP_ID
_db_session = mock.MagicMock()
CONF = cfg.CONF
@ -77,7 +81,7 @@ class TestException(Exception):
@mock.patch('octavia.db.repositories.AmphoraRepository.get',
return_value=_amphora_mock)
return_value=_db_amphora_mock)
@mock.patch('octavia.db.repositories.HealthMonitorRepository.get',
return_value=_health_mon_mock)
@mock.patch('octavia.db.repositories.LoadBalancerRepository.get',
@ -105,14 +109,14 @@ class TestControllerWorker(base.TestCase):
_db_pool_mock.listeners = [_listener_mock]
_db_pool_mock.load_balancer = _load_balancer_mock
_health_mon_mock.pool = _db_pool_mock
_load_balancer_mock.amphorae = _amphora_mock
_load_balancer_mock.amphorae = _db_amphora_mock
_load_balancer_mock.vip = _vip_mock
_load_balancer_mock.id = LB_ID
_load_balancer_mock.project_id = PROJECT_ID
_listener_mock.load_balancer = _load_balancer_mock
_listener_mock.id = LISTENER_ID
_listener_mock.to_dict.return_value = {
'id': LISTENER_ID, constants.LOAD_BALANCER_ID: LB_ID}
constants.ID: LISTENER_ID, constants.LOAD_BALANCER_ID: LB_ID}
self.ref_listener_dict = {constants.LISTENER_ID: LISTENER_ID,
constants.LOADBALANCER_ID: LB_ID}
_member_mock.pool = _db_pool_mock
@ -230,10 +234,11 @@ class TestControllerWorker(base.TestCase):
mock_amp_repo_get.assert_called_once_with(
_db_session,
id=AMP_ID)
mock_amp_repo_get.return_value = _db_amphora_mock
(base_taskflow.BaseTaskFlowEngine._taskflow_load.
assert_called_once_with('TEST',
store={constants.AMPHORA: _amphora_mock}))
assert_called_once_with(
'TEST', store={constants.AMPHORA: _db_amphora_mock.to_dict()}))
_flow_mock.run.assert_called_once_with()
@ -1272,13 +1277,13 @@ class TestControllerWorker(base.TestCase):
cw = controller_worker.ControllerWorker()
cw.failover_amphora(AMP_ID)
mock_amp_repo_get.return_value = _db_amphora_mock
(base_taskflow.BaseTaskFlowEngine._taskflow_load.
assert_called_once_with(
_flow_mock,
store={constants.FAILED_AMPHORA: _amphora_mock,
store={constants.FAILED_AMPHORA: _db_amphora_mock.to_dict(),
constants.LOADBALANCER_ID:
_amphora_mock.load_balancer_id,
_db_amphora_mock.load_balancer_id,
constants.BUILD_TYPE_PRIORITY:
constants.LB_CREATE_FAILOVER_PRIORITY,
constants.FLAVOR: {},
@ -1401,7 +1406,7 @@ class TestControllerWorker(base.TestCase):
(base_taskflow.BaseTaskFlowEngine._taskflow_load.
assert_called_once_with(
_flow_mock,
store={constants.FAILED_AMPHORA: mock_amphora,
store={constants.FAILED_AMPHORA: mock_amphora.to_dict(),
constants.LOADBALANCER_ID: None,
constants.BUILD_TYPE_PRIORITY:
constants.LB_CREATE_FAILOVER_PRIORITY,
@ -1458,22 +1463,23 @@ class TestControllerWorker(base.TestCase):
_amphora_mock3 = mock.MagicMock()
_amphora_mock3.status = constants.DELETED
_load_balancer_mock.amphorae = [
_amphora_mock, _amphora_mock2, _amphora_mock3]
_db_amphora_mock, _amphora_mock2, _amphora_mock3]
cw = controller_worker.ControllerWorker()
cw.failover_loadbalancer('123')
mock_perform.assert_called_with(
_amphora_mock2, constants.LB_CREATE_ADMIN_FAILOVER_PRIORITY)
_amphora_mock2,
constants.LB_CREATE_ADMIN_FAILOVER_PRIORITY)
mock_update.assert_called_with(_db_session, '123',
provisioning_status=constants.ACTIVE)
_load_balancer_mock.amphorae = [
_amphora_mock, _amphora_mock2, _amphora_mock3]
_db_amphora_mock, _amphora_mock2, _amphora_mock3]
_amphora_mock2.role = constants.ROLE_BACKUP
cw.failover_loadbalancer('123')
# because mock2 gets failed over earlier now _amphora_mock
# is the last one
mock_perform.assert_called_with(
_amphora_mock, constants.LB_CREATE_ADMIN_FAILOVER_PRIORITY)
_db_amphora_mock, constants.LB_CREATE_ADMIN_FAILOVER_PRIORITY)
mock_update.assert_called_with(_db_session, '123',
provisioning_status=constants.ACTIVE)
@ -1521,9 +1527,9 @@ class TestControllerWorker(base.TestCase):
(base_taskflow.BaseTaskFlowEngine._taskflow_load.
assert_called_once_with(
_flow_mock,
store={constants.FAILED_AMPHORA: _amphora_mock,
store={constants.FAILED_AMPHORA: _db_amphora_mock.to_dict(),
constants.LOADBALANCER_ID:
_amphora_mock.load_balancer_id,
_db_amphora_mock.load_balancer_id,
constants.BUILD_TYPE_PRIORITY:
constants.LB_CREATE_FAILOVER_PRIORITY,
constants.SERVER_GROUP_ID: "123",
@ -1554,11 +1560,13 @@ class TestControllerWorker(base.TestCase):
_flow_mock.reset_mock()
cw = controller_worker.ControllerWorker()
cw.amphora_cert_rotation(AMP_ID)
mock_amp_repo_get.return_value = _db_amphora_mock
(base_taskflow.BaseTaskFlowEngine._taskflow_load.
assert_called_once_with(_flow_mock,
store={constants.AMPHORA: _amphora_mock,
store={constants.AMPHORA:
_db_amphora_mock.to_dict(),
constants.AMPHORA_ID:
_amphora_mock.id}))
_amphora_mock[constants.ID]}))
_flow_mock.run.assert_called_once_with()
@mock.patch('octavia.db.repositories.FlavorRepository.'
@ -1595,7 +1603,8 @@ class TestControllerWorker(base.TestCase):
mock_flavor_meta.assert_called_once_with(_db_session, 'vanilla')
(base_taskflow.BaseTaskFlowEngine._taskflow_load.
assert_called_once_with(_flow_mock,
store={constants.AMPHORA: _amphora_mock,
store={constants.AMPHORA:
_db_amphora_mock.to_dict(),
constants.FLAVOR: {'test': 'dict'}}))
_flow_mock.run.assert_called_once_with()
@ -1612,6 +1621,7 @@ class TestControllerWorker(base.TestCase):
mock_flavor_meta.assert_not_called()
(base_taskflow.BaseTaskFlowEngine._taskflow_load.
assert_called_once_with(_flow_mock,
store={constants.AMPHORA: _amphora_mock,
store={constants.AMPHORA:
_db_amphora_mock.to_dict(),
constants.FLAVOR: {}}))
_flow_mock.run.assert_called_once_with()