def test_mark_lb_and_listener_active_in_db(self, mock_generate_uuid,
mock_LOG, mock_get_session,
mock_loadbalancer_repo_update,
mock_listener_repo_update,
mock_amphora_repo_update,
mock_amphora_repo_delete):
mark_lb_and_listener_active = (
database_tasks.MarkLBAndListenerActiveInDB())
mark_lb_and_listener_active.execute(self.loadbalancer_mock,
self.listener_mock)
repo.ListenerRepository.update.assert_called_once_with(
'TEST', LISTENER_ID, provisioning_status=constants.ACTIVE)
repo.LoadBalancerRepository.update.assert_called_once_with(
'TEST', LB_ID, provisioning_status=constants.ACTIVE)
# Test the revert
mock_loadbalancer_repo_update.reset_mock()
mock_listener_repo_update.reset_mock()
mark_lb_and_listener_active.revert(self.loadbalancer_mock,
self.listener_mock)
repo.ListenerRepository.update.assert_called_once_with(
'TEST', LISTENER_ID, provisioning_status=constants.ERROR)
repo.LoadBalancerRepository.update.assert_called_once_with(
'TEST', LB_ID, provisioning_status=constants.ERROR)
def get_create_health_monitor_flow(self):
"""Create a flow to create a health monitor
:returns: The flow for creating a health monitor
"""
create_hm_flow = linear_flow.Flow(constants.CREATE_HEALTH_MONITOR_FLOW)
create_hm_flow.add(amphora_driver_tasks.ListenerUpdate(
requires=[constants.LISTENER, constants.VIP]))
create_hm_flow.add(database_tasks.MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENER]))
return create_hm_flow
def get_create_pool_flow(self):
"""Create a flow to create a pool
:returns: The flow for creating a pool
"""
create_pool_flow = linear_flow.Flow(constants.CREATE_POOL_FLOW)
create_pool_flow.add(
amphora_driver_tasks.ListenerUpdate(
requires=[constants.LISTENER, constants.VIP]))
create_pool_flow.add(
database_tasks.MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENER]))
return create_pool_flow
def get_delete_health_monitor_flow(self):
"""Create a flow to delete a health monitor
:returns: The flow for deleting a health monitor
"""
delete_hm_flow = linear_flow.Flow(constants.DELETE_HEALTH_MONITOR_FLOW)
delete_hm_flow.add(model_tasks.
DeleteModelObject(rebind={constants.OBJECT:
constants.HEALTH_MON}))
delete_hm_flow.add(amphora_driver_tasks.ListenerUpdate(
requires=[constants.LISTENER, constants.VIP]))
delete_hm_flow.add(database_tasks.DeleteHealthMonitorInDB(
requires=constants.POOL_ID))
delete_hm_flow.add(database_tasks.MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENER]))
return delete_hm_flow
def get_update_health_monitor_flow(self):
"""Create a flow to update a health monitor
:returns: The flow for updating a health monitor
"""
update_hm_flow = linear_flow.Flow(constants.UPDATE_HEALTH_MONITOR_FLOW)
update_hm_flow.add(model_tasks.
UpdateAttributes(
rebind={constants.OBJECT: constants.HEALTH_MON},
requires=[constants.UPDATE_DICT]))
update_hm_flow.add(amphora_driver_tasks.ListenerUpdate(
requires=[constants.LISTENER, constants.VIP]))
update_hm_flow.add(database_tasks.UpdateHealthMonInDB(
requires=[constants.HEALTH_MON, constants.UPDATE_DICT]))
update_hm_flow.add(database_tasks.MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENER]))
return update_hm_flow
def get_delete_pool_flow(self):
"""Create a flow to delete a pool
:returns: The flow for deleting a pool
"""
delete_pool_flow = linear_flow.Flow(constants.DELETE_POOL_FLOW)
delete_pool_flow.add(
model_tasks.DeleteModelObject(
rebind={constants.OBJECT: constants.POOL}))
delete_pool_flow.add(
amphora_driver_tasks.ListenerUpdate(
requires=[constants.LISTENER, constants.VIP]))
delete_pool_flow.add(
database_tasks.DeletePoolInDB(requires=constants.POOL))
delete_pool_flow.add(
database_tasks.MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENER]))
return delete_pool_flow
def get_update_listener_flow(self):
"""Create a flow to update a listener
:returns: The flow for updating a listener
"""
update_listener_flow = linear_flow.Flow(constants.UPDATE_LISTENER_FLOW)
update_listener_flow.add(
model_tasks.UpdateAttributes(
rebind={constants.OBJECT: constants.LISTENER},
requires=[constants.UPDATE_DICT]))
update_listener_flow.add(
amphora_driver_tasks.ListenerUpdate(
requires=[constants.LISTENER, constants.VIP]))
update_listener_flow.add(
database_tasks.UpdateListenerInDB(
requires=[constants.LISTENER, constants.UPDATE_DICT]))
update_listener_flow.add(
database_tasks.MarkLBAndListenerActiveInDB(
requires=[constants.LOADBALANCER, constants.LISTENER]))
return update_listener_flow
def get_create_member_flow(self):
"""Create a flow to create a member
:returns: The flow for creating a member
"""
create_member_flow = linear_flow.Flow(constants.CREATE_MEMBER_FLOW)
create_member_flow.add(
network_tasks.CalculateDelta(requires=constants.LOADBALANCER,
provides=constants.DELTAS))
create_member_flow.add(
network_tasks.HandleNetworkDeltas(requires=constants.DELTAS,
provides=constants.ADDED_PORTS))
create_member_flow.add(
amphora_driver_tasks.AmphoraePostNetworkPlug(
requires=(constants.LOADBALANCER, constants.ADDED_PORTS)))
create_member_flow.add(
amphora_driver_tasks.ListenerUpdate(requires=(constants.LISTENER,
constants.VIP)))
create_member_flow.add(
database_tasks.MarkLBAndListenerActiveInDB(
requires=(constants.LOADBALANCER, constants.LISTENER)))
return create_member_flow