octavia 12.0.0.0rc2__py3-none-any.whl → 13.0.0.0rc1__py3-none-any.whl

octavia/controller/worker/v1/flows/health_monitor_flows.py

@@ -1,105 +0,0 @@
-# Copyright 2015 Hewlett-Packard Development Company, L.P.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-
-from taskflow.patterns import linear_flow
-
-from octavia.common import constants
-from octavia.controller.worker.v1.tasks import amphora_driver_tasks
-from octavia.controller.worker.v1.tasks import database_tasks
-from octavia.controller.worker.v1.tasks import lifecycle_tasks
-from octavia.controller.worker.v1.tasks import model_tasks
-
-
-class HealthMonitorFlows(object):
-
-    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(lifecycle_tasks.HealthMonitorToErrorOnRevertTask(
-            requires=[constants.HEALTH_MON,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        create_hm_flow.add(database_tasks.MarkHealthMonitorPendingCreateInDB(
-            requires=constants.HEALTH_MON))
-        create_hm_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        create_hm_flow.add(database_tasks.MarkHealthMonitorActiveInDB(
-            requires=constants.HEALTH_MON))
-        create_hm_flow.add(database_tasks.MarkPoolActiveInDB(
-            requires=constants.POOL))
-        create_hm_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        return create_hm_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(lifecycle_tasks.HealthMonitorToErrorOnRevertTask(
-            requires=[constants.HEALTH_MON,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        delete_hm_flow.add(database_tasks.MarkHealthMonitorPendingDeleteInDB(
-            requires=constants.HEALTH_MON))
-        delete_hm_flow.add(model_tasks.
-                           DeleteModelObject(rebind={constants.OBJECT:
-                                                     constants.HEALTH_MON}))
-        delete_hm_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        delete_hm_flow.add(database_tasks.DeleteHealthMonitorInDB(
-            requires=constants.HEALTH_MON))
-        delete_hm_flow.add(database_tasks.DecrementHealthMonitorQuota(
-            requires=constants.HEALTH_MON))
-        delete_hm_flow.add(
-            database_tasks.UpdatePoolMembersOperatingStatusInDB(
-                requires=constants.POOL,
-                inject={constants.OPERATING_STATUS: constants.NO_MONITOR}))
-        delete_hm_flow.add(database_tasks.MarkPoolActiveInDB(
-            requires=constants.POOL))
-        delete_hm_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        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(lifecycle_tasks.HealthMonitorToErrorOnRevertTask(
-            requires=[constants.HEALTH_MON,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        update_hm_flow.add(database_tasks.MarkHealthMonitorPendingUpdateInDB(
-            requires=constants.HEALTH_MON))
-        update_hm_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        update_hm_flow.add(database_tasks.UpdateHealthMonInDB(
-            requires=[constants.HEALTH_MON, constants.UPDATE_DICT]))
-        update_hm_flow.add(database_tasks.MarkHealthMonitorActiveInDB(
-            requires=constants.HEALTH_MON))
-        update_hm_flow.add(database_tasks.MarkPoolActiveInDB(
-            requires=constants.POOL))
-        update_hm_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        return update_hm_flow

octavia/controller/worker/v1/flows/l7policy_flows.py

@@ -1,94 +0,0 @@
-# Copyright 2016 Blue Box, an IBM Company
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-
-from taskflow.patterns import linear_flow
-
-from octavia.common import constants
-from octavia.controller.worker.v1.tasks import amphora_driver_tasks
-from octavia.controller.worker.v1.tasks import database_tasks
-from octavia.controller.worker.v1.tasks import lifecycle_tasks
-from octavia.controller.worker.v1.tasks import model_tasks
-
-
-class L7PolicyFlows(object):
-
-    def get_create_l7policy_flow(self):
-        """Create a flow to create an L7 policy
-
-        :returns: The flow for creating an L7 policy
-        """
-        create_l7policy_flow = linear_flow.Flow(constants.CREATE_L7POLICY_FLOW)
-        create_l7policy_flow.add(lifecycle_tasks.L7PolicyToErrorOnRevertTask(
-            requires=[constants.L7POLICY,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        create_l7policy_flow.add(database_tasks.MarkL7PolicyPendingCreateInDB(
-            requires=constants.L7POLICY))
-        create_l7policy_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        create_l7policy_flow.add(database_tasks.MarkL7PolicyActiveInDB(
-            requires=constants.L7POLICY))
-        create_l7policy_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        return create_l7policy_flow
-
-    def get_delete_l7policy_flow(self):
-        """Create a flow to delete an L7 policy
-
-        :returns: The flow for deleting an L7 policy
-        """
-        delete_l7policy_flow = linear_flow.Flow(constants.DELETE_L7POLICY_FLOW)
-        delete_l7policy_flow.add(lifecycle_tasks.L7PolicyToErrorOnRevertTask(
-            requires=[constants.L7POLICY,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        delete_l7policy_flow.add(database_tasks.MarkL7PolicyPendingDeleteInDB(
-            requires=constants.L7POLICY))
-        delete_l7policy_flow.add(model_tasks.DeleteModelObject(
-            rebind={constants.OBJECT: constants.L7POLICY}))
-        delete_l7policy_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        delete_l7policy_flow.add(database_tasks.DeleteL7PolicyInDB(
-            requires=constants.L7POLICY))
-        delete_l7policy_flow.add(database_tasks.DecrementL7policyQuota(
-            requires=constants.L7POLICY))
-        delete_l7policy_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        return delete_l7policy_flow
-
-    def get_update_l7policy_flow(self):
-        """Create a flow to update an L7 policy
-
-        :returns: The flow for updating an L7 policy
-        """
-        update_l7policy_flow = linear_flow.Flow(constants.UPDATE_L7POLICY_FLOW)
-        update_l7policy_flow.add(lifecycle_tasks.L7PolicyToErrorOnRevertTask(
-            requires=[constants.L7POLICY,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        update_l7policy_flow.add(database_tasks.MarkL7PolicyPendingUpdateInDB(
-            requires=constants.L7POLICY))
-        update_l7policy_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        update_l7policy_flow.add(database_tasks.UpdateL7PolicyInDB(
-            requires=[constants.L7POLICY, constants.UPDATE_DICT]))
-        update_l7policy_flow.add(database_tasks.MarkL7PolicyActiveInDB(
-            requires=constants.L7POLICY))
-        update_l7policy_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        return update_l7policy_flow

octavia/controller/worker/v1/flows/l7rule_flows.py

@@ -1,100 +0,0 @@
-# Copyright 2016 Blue Box, an IBM Company
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-
-from taskflow.patterns import linear_flow
-
-from octavia.common import constants
-from octavia.controller.worker.v1.tasks import amphora_driver_tasks
-from octavia.controller.worker.v1.tasks import database_tasks
-from octavia.controller.worker.v1.tasks import lifecycle_tasks
-from octavia.controller.worker.v1.tasks import model_tasks
-
-
-class L7RuleFlows(object):
-
-    def get_create_l7rule_flow(self):
-        """Create a flow to create an L7 rule
-
-        :returns: The flow for creating an L7 rule
-        """
-        create_l7rule_flow = linear_flow.Flow(constants.CREATE_L7RULE_FLOW)
-        create_l7rule_flow.add(lifecycle_tasks.L7RuleToErrorOnRevertTask(
-            requires=[constants.L7RULE,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        create_l7rule_flow.add(database_tasks.MarkL7RulePendingCreateInDB(
-            requires=constants.L7RULE))
-        create_l7rule_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        create_l7rule_flow.add(database_tasks.MarkL7RuleActiveInDB(
-            requires=constants.L7RULE))
-        create_l7rule_flow.add(database_tasks.MarkL7PolicyActiveInDB(
-            requires=constants.L7POLICY))
-        create_l7rule_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        return create_l7rule_flow
-
-    def get_delete_l7rule_flow(self):
-        """Create a flow to delete an L7 rule
-
-        :returns: The flow for deleting an L7 rule
-        """
-        delete_l7rule_flow = linear_flow.Flow(constants.DELETE_L7RULE_FLOW)
-        delete_l7rule_flow.add(lifecycle_tasks.L7RuleToErrorOnRevertTask(
-            requires=[constants.L7RULE,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        delete_l7rule_flow.add(database_tasks.MarkL7RulePendingDeleteInDB(
-            requires=constants.L7RULE))
-        delete_l7rule_flow.add(model_tasks.DeleteModelObject(
-            rebind={constants.OBJECT: constants.L7RULE}))
-        delete_l7rule_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        delete_l7rule_flow.add(database_tasks.DeleteL7RuleInDB(
-            requires=constants.L7RULE))
-        delete_l7rule_flow.add(database_tasks.DecrementL7ruleQuota(
-            requires=constants.L7RULE))
-        delete_l7rule_flow.add(database_tasks.MarkL7PolicyActiveInDB(
-            requires=constants.L7POLICY))
-        delete_l7rule_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        return delete_l7rule_flow
-
-    def get_update_l7rule_flow(self):
-        """Create a flow to update an L7 rule
-
-        :returns: The flow for updating an L7 rule
-        """
-        update_l7rule_flow = linear_flow.Flow(constants.UPDATE_L7RULE_FLOW)
-        update_l7rule_flow.add(lifecycle_tasks.L7RuleToErrorOnRevertTask(
-            requires=[constants.L7RULE,
-                      constants.LISTENERS,
-                      constants.LOADBALANCER]))
-        update_l7rule_flow.add(database_tasks.MarkL7RulePendingUpdateInDB(
-            requires=constants.L7RULE))
-        update_l7rule_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        update_l7rule_flow.add(database_tasks.UpdateL7RuleInDB(
-            requires=[constants.L7RULE, constants.UPDATE_DICT]))
-        update_l7rule_flow.add(database_tasks.MarkL7RuleActiveInDB(
-            requires=constants.L7RULE))
-        update_l7rule_flow.add(database_tasks.MarkL7PolicyActiveInDB(
-            requires=constants.L7POLICY))
-        update_l7rule_flow.add(database_tasks.MarkLBAndListenersActiveInDB(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-
-        return update_l7rule_flow

octavia/controller/worker/v1/flows/listener_flows.py

@@ -1,128 +0,0 @@
-# Copyright 2015 Hewlett-Packard Development Company, L.P.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-
-from taskflow.patterns import linear_flow
-
-from octavia.common import constants
-from octavia.controller.worker.v1.tasks import amphora_driver_tasks
-from octavia.controller.worker.v1.tasks import database_tasks
-from octavia.controller.worker.v1.tasks import lifecycle_tasks
-from octavia.controller.worker.v1.tasks import network_tasks
-
-
-class ListenerFlows(object):
-
-    def get_create_listener_flow(self):
-        """Create a flow to create a listener
-
-        :returns: The flow for creating a listener
-        """
-        create_listener_flow = linear_flow.Flow(constants.CREATE_LISTENER_FLOW)
-        create_listener_flow.add(lifecycle_tasks.ListenersToErrorOnRevertTask(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-        create_listener_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        create_listener_flow.add(network_tasks.UpdateVIP(
-            requires=constants.LOADBALANCER))
-        create_listener_flow.add(database_tasks.
-                                 MarkLBAndListenersActiveInDB(
-                                     requires=[constants.LOADBALANCER,
-                                               constants.LISTENERS]))
-        return create_listener_flow
-
-    def get_create_all_listeners_flow(self):
-        """Create a flow to create all listeners
-
-        :returns: The flow for creating all listeners
-        """
-        create_all_listeners_flow = linear_flow.Flow(
-            constants.CREATE_LISTENERS_FLOW)
-        create_all_listeners_flow.add(
-            database_tasks.GetListenersFromLoadbalancer(
-                requires=constants.LOADBALANCER,
-                provides=constants.LISTENERS))
-        create_all_listeners_flow.add(database_tasks.ReloadLoadBalancer(
-            requires=constants.LOADBALANCER_ID,
-            provides=constants.LOADBALANCER))
-        create_all_listeners_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        create_all_listeners_flow.add(network_tasks.UpdateVIP(
-            requires=constants.LOADBALANCER))
-        return create_all_listeners_flow
-
-    def get_delete_listener_flow(self):
-        """Create a flow to delete a listener
-
-        :returns: The flow for deleting a listener
-        """
-        delete_listener_flow = linear_flow.Flow(constants.DELETE_LISTENER_FLOW)
-        delete_listener_flow.add(lifecycle_tasks.ListenerToErrorOnRevertTask(
-            requires=constants.LISTENER))
-        delete_listener_flow.add(amphora_driver_tasks.ListenerDelete(
-            requires=constants.LISTENER))
-        delete_listener_flow.add(network_tasks.UpdateVIPForDelete(
-            requires=constants.LOADBALANCER))
-        delete_listener_flow.add(database_tasks.DeleteListenerInDB(
-            requires=constants.LISTENER))
-        delete_listener_flow.add(database_tasks.DecrementListenerQuota(
-            requires=constants.LISTENER))
-        delete_listener_flow.add(database_tasks.MarkLBActiveInDB(
-            requires=constants.LOADBALANCER))
-
-        return delete_listener_flow
-
-    def get_delete_listener_internal_flow(self, listener_name):
-        """Create a flow to delete a listener and l7policies internally
-
-           (will skip deletion on the amp and marking LB active)
-
-        :returns: The flow for deleting a listener
-        """
-        delete_listener_flow = linear_flow.Flow(constants.DELETE_LISTENER_FLOW)
-        # Should cascade delete all L7 policies
-        delete_listener_flow.add(network_tasks.UpdateVIPForDelete(
-            name='delete_update_vip_' + listener_name,
-            requires=constants.LOADBALANCER))
-        delete_listener_flow.add(database_tasks.DeleteListenerInDB(
-            name='delete_listener_in_db_' + listener_name,
-            requires=constants.LISTENER,
-            rebind={constants.LISTENER: listener_name}))
-        delete_listener_flow.add(database_tasks.DecrementListenerQuota(
-            name='decrement_listener_quota_' + listener_name,
-            requires=constants.LISTENER,
-            rebind={constants.LISTENER: listener_name}))
-
-        return delete_listener_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(lifecycle_tasks.ListenersToErrorOnRevertTask(
-            requires=[constants.LOADBALANCER, constants.LISTENERS]))
-        update_listener_flow.add(amphora_driver_tasks.ListenersUpdate(
-            requires=constants.LOADBALANCER))
-        update_listener_flow.add(network_tasks.UpdateVIP(
-            requires=constants.LOADBALANCER))
-        update_listener_flow.add(database_tasks.UpdateListenerInDB(
-            requires=[constants.LISTENER, constants.UPDATE_DICT]))
-        update_listener_flow.add(database_tasks.
-                                 MarkLBAndListenersActiveInDB(
-                                     requires=[constants.LOADBALANCER,
-                                               constants.LISTENERS]))
-
-        return update_listener_flow