octavia 13.0.0.0rc1__py3-none-any.whl → 14.0.0__py3-none-any.whl

octavia/controller/worker/v2/tasks/database_tasks.py

@@ -14,6 +14,7 @@
 #
 
 from cryptography import fernet
+from octavia_lib.common import constants as lib_consts
 from oslo_config import cfg
 from oslo_db import exception as odb_exceptions
 from oslo_log import log as logging
@@ -27,6 +28,7 @@ from taskflow.types import failure
 from octavia.api.drivers import utils as provider_utils
 from octavia.common import constants
 from octavia.common import data_models
+from octavia.common import exceptions
 from octavia.common.tls_utils import cert_parser
 from octavia.common import utils
 from octavia.controller.worker import task_utils as task_utilities
@@ -2621,15 +2623,13 @@ class DecrementHealthMonitorQuota(BaseDatabaseTask):
 
             try:
                 session = db_apis.get_session()
-                lock_session = db_apis.get_session()
                 try:
                     self.repos.check_quota_met(session,
-                                               lock_session,
                                                data_models.HealthMonitor,
                                                project_id)
-                    lock_session.commit()
+                    session.commit()
                 except Exception:
-                    lock_session.rollback()
+                    session.rollback()
             except Exception:
                 # Don't fail the revert flow
                 pass
@@ -2679,15 +2679,13 @@ class DecrementListenerQuota(BaseDatabaseTask):
 
             try:
                 session = db_apis.get_session()
-                lock_session = db_apis.get_session()
                 try:
                     self.repos.check_quota_met(session,
-                                               lock_session,
                                                data_models.Listener,
                                                project_id)
-                    lock_session.commit()
+                    session.commit()
                 except Exception:
-                    lock_session.rollback()
+                    session.rollback()
             except Exception:
                 # Don't fail the revert flow
                 pass
@@ -2739,15 +2737,13 @@ class DecrementLoadBalancerQuota(BaseDatabaseTask):
 
             try:
                 session = db_apis.get_session()
-                lock_session = db_apis.get_session()
                 try:
                     self.repos.check_quota_met(session,
-                                               lock_session,
                                                data_models.LoadBalancer,
                                                project_id)
-                    lock_session.commit()
+                    session.commit()
                 except Exception:
-                    lock_session.rollback()
+                    session.rollback()
             except Exception:
                 # Don't fail the revert flow
                 pass
@@ -2798,15 +2794,13 @@ class DecrementMemberQuota(BaseDatabaseTask):
 
             try:
                 session = db_apis.get_session()
-                lock_session = db_apis.get_session()
                 try:
                     self.repos.check_quota_met(session,
-                                               lock_session,
                                                data_models.Member,
                                                project_id)
-                    lock_session.commit()
+                    session.commit()
                 except Exception:
-                    lock_session.rollback()
+                    session.rollback()
             except Exception:
                 # Don't fail the revert flow
                 pass
@@ -2871,42 +2865,38 @@ class DecrementPoolQuota(BaseDatabaseTask):
             # in case other quota actions have occurred
             try:
                 session = db_apis.get_session()
-                lock_session = db_apis.get_session()
                 try:
                     self.repos.check_quota_met(session,
-                                               lock_session,
                                                data_models.Pool,
                                                project_id)
-                    lock_session.commit()
+                    session.commit()
                 except Exception:
-                    lock_session.rollback()
+                    session.rollback()
 
                 # Attempt to increment back the health monitor quota
                 if pool_child_count['HM'] > 0:
-                    lock_session = db_apis.get_session()
+                    session = db_apis.get_session()
                     try:
                         self.repos.check_quota_met(session,
-                                                   lock_session,
                                                    data_models.HealthMonitor,
                                                    project_id)
-                        lock_session.commit()
+                        session.commit()
                     except Exception:
-                        lock_session.rollback()
+                        session.rollback()
 
                 # Attempt to increment back the member quota
                 # This is separate calls to maximize the correction
                 # should other factors have increased the in use quota
                 # before this point in the revert flow
                 for i in range(pool_child_count['member']):
-                    lock_session = db_apis.get_session()
+                    session = db_apis.get_session()
                     try:
                         self.repos.check_quota_met(session,
-                                                   lock_session,
                                                    data_models.Member,
                                                    project_id)
-                        lock_session.commit()
+                        session.commit()
                     except Exception:
-                        lock_session.rollback()
+                        session.rollback()
             except Exception:
                 # Don't fail the revert flow
                 pass
@@ -2954,7 +2944,8 @@ class DecrementL7policyQuota(BaseDatabaseTask):
                                        data_models.L7Policy,
                                        l7policy[constants.PROJECT_ID])
             db_l7policy = self.l7policy_repo.get(
-                db_apis.get_session(), id=l7policy[constants.L7POLICY_ID])
+                lock_session,
+                id=l7policy[constants.L7POLICY_ID])
 
             if db_l7policy and db_l7policy.l7rules:
                 self.repos.decrement_quota(lock_session,
@@ -2982,28 +2973,26 @@ class DecrementL7policyQuota(BaseDatabaseTask):
         if not isinstance(result, failure.Failure):
             try:
                 session = db_apis.get_session()
-                lock_session = db_apis.get_session()
                 try:
                     self.repos.check_quota_met(session,
-                                               lock_session,
                                                data_models.L7Policy,
                                                l7policy[constants.PROJECT_ID])
-                    lock_session.commit()
+                    session.commit()
                 except Exception:
-                    lock_session.rollback()
+                    session.rollback()
                 db_l7policy = self.l7policy_repo.get(
                     session, id=l7policy[constants.L7POLICY_ID])
                 if db_l7policy:
                     # Attempt to increment back the L7Rule quota
                     for i in range(len(db_l7policy.l7rules)):
-                        lock_session = db_apis.get_session()
+                        session = db_apis.get_session()
                         try:
                             self.repos.check_quota_met(
-                                session, lock_session, data_models.L7Rule,
+                                session, data_models.L7Rule,
                                 db_l7policy.project_id)
-                            lock_session.commit()
+                            session.commit()
                         except Exception:
-                            lock_session.rollback()
+                            session.rollback()
             except Exception:
                 # Don't fail the revert flow
                 pass
@@ -3054,15 +3043,13 @@ class DecrementL7ruleQuota(BaseDatabaseTask):
 
             try:
                 session = db_apis.get_session()
-                lock_session = db_apis.get_session()
                 try:
                     self.repos.check_quota_met(session,
-                                               lock_session,
                                                data_models.L7Rule,
                                                l7rule[constants.PROJECT_ID])
-                    lock_session.commit()
+                    session.commit()
                 except Exception:
-                    lock_session.rollback()
+                    session.rollback()
             except Exception:
                 # Don't fail the revert flow
                 pass
@@ -3088,3 +3075,47 @@ class UpdatePoolMembersOperatingStatusInDB(BaseDatabaseTask):
         with db_apis.session().begin() as session:
             self.member_repo.update_pool_members(
                 session, pool_id, operating_status=operating_status)
+
+
+class GetAmphoraFirewallRules(BaseDatabaseTask):
+    """Task to build firewall rules for the amphora."""
+
+    def execute(self, amphorae, amphora_index, amphorae_network_config):
+        this_amp_id = amphorae[amphora_index][constants.ID]
+        amp_net_config = amphorae_network_config[this_amp_id]
+
+        lb_dict = amp_net_config[constants.AMPHORA]['load_balancer']
+        vip_dict = lb_dict[constants.VIP]
+
+        if vip_dict[constants.VNIC_TYPE] != constants.VNIC_TYPE_DIRECT:
+            LOG.debug('Load balancer VIP port is not SR-IOV enabled. Skipping '
+                      'firewall rules update.')
+            return [{'non-sriov-vip': True}]
+
+        session = db_apis.get_session()
+        with session.begin():
+            rules = self.listener_repo.get_port_protocol_cidr_for_lb(
+                session,
+                amp_net_config[constants.AMPHORA][constants.LOAD_BALANCER_ID])
+
+        # If we are act/stdby, inject the VRRP firewall rule(s)
+        if lb_dict[constants.TOPOLOGY] == constants.TOPOLOGY_ACTIVE_STANDBY:
+            for amp_cfg in lb_dict[constants.AMPHORAE]:
+                if (amp_cfg[constants.ID] != this_amp_id and
+                        amp_cfg[constants.STATUS] ==
+                        lib_consts.AMPHORA_ALLOCATED):
+                    vrrp_ip = amp_cfg[constants.VRRP_IP]
+                    vrrp_ip_ver = utils.ip_version(vrrp_ip)
+
+                    if vrrp_ip_ver == 4:
+                        vrrp_ip_cidr = f'{vrrp_ip}/32'
+                    elif vrrp_ip_ver == 6:
+                        vrrp_ip_cidr = f'{vrrp_ip}/128'
+                    else:
+                        raise exceptions.InvalidIPAddress(ip_addr=vrrp_ip)
+
+                    rules.append({constants.PROTOCOL: constants.VRRP,
+                                  constants.CIDR: vrrp_ip_cidr,
+                                  constants.PORT: 112})
+        LOG.debug('Amphora %s SR-IOV firewall rules: %s', this_amp_id, rules)
+        return rules

octavia/controller/worker/v2/tasks/lifecycle_tasks.py

@@ -19,7 +19,7 @@ from octavia.controller.worker import task_utils as task_utilities
 
 
 class BaseLifecycleTask(task.Task):
-    """Base task to instansiate common classes."""
+    """Base task to instantiate common classes."""
 
     def __init__(self, **kwargs):
         self.task_utils = task_utilities.TaskUtils()
@@ -54,15 +54,22 @@ class HealthMonitorToErrorOnRevertTask(BaseLifecycleTask):
         pass
 
     def revert(self, health_mon, listeners, loadbalancer, *args, **kwargs):
-        self.task_utils.mark_health_mon_prov_status_error(
-            health_mon[constants.HEALTHMONITOR_ID])
-        self.task_utils.mark_pool_prov_status_active(
-            health_mon[constants.POOL_ID])
+        try:
+            self.task_utils.mark_health_mon_prov_status_error(
+                health_mon[constants.HEALTHMONITOR_ID])
+            self.task_utils.mark_pool_prov_status_active(
+                health_mon[constants.POOL_ID])
+            for listener in listeners:
+                self.task_utils.mark_listener_prov_status_active(
+                    listener[constants.LISTENER_ID])
+        except Exception:
+            # Catching and skipping, errors are already reported by task_utils
+            # and we want to ensure that mark_loadbalancer_prov_status_active
+            # is called to unlock the LB (it will pass or it will fail after a
+            # very long timeout)
+            pass
         self.task_utils.mark_loadbalancer_prov_status_active(
             loadbalancer[constants.LOADBALANCER_ID])
-        for listener in listeners:
-            self.task_utils.mark_listener_prov_status_active(
-                listener[constants.LISTENER_ID])
 
 
 class L7PolicyToErrorOnRevertTask(BaseLifecycleTask):
@@ -72,12 +79,19 @@ class L7PolicyToErrorOnRevertTask(BaseLifecycleTask):
         pass
 
     def revert(self, l7policy, listeners, loadbalancer_id, *args, **kwargs):
-        self.task_utils.mark_l7policy_prov_status_error(
-            l7policy[constants.L7POLICY_ID])
+        try:
+            self.task_utils.mark_l7policy_prov_status_error(
+                l7policy[constants.L7POLICY_ID])
+            for listener in listeners:
+                self.task_utils.mark_listener_prov_status_active(
+                    listener[constants.LISTENER_ID])
+        except Exception:
+            # Catching and skipping, errors are already reported by task_utils
+            # and we want to ensure that mark_loadbalancer_prov_status_active
+            # is called to unlock the LB (it will pass or it will fail after a
+            # very long timeout)
+            pass
         self.task_utils.mark_loadbalancer_prov_status_active(loadbalancer_id)
-        for listener in listeners:
-            self.task_utils.mark_listener_prov_status_active(
-                listener[constants.LISTENER_ID])
 
 
 class L7RuleToErrorOnRevertTask(BaseLifecycleTask):
@@ -88,14 +102,21 @@ class L7RuleToErrorOnRevertTask(BaseLifecycleTask):
 
     def revert(self, l7rule, l7policy_id, listeners, loadbalancer_id, *args,
                **kwargs):
-        self.task_utils.mark_l7rule_prov_status_error(
-            l7rule[constants.L7RULE_ID])
-        self.task_utils.mark_l7policy_prov_status_active(l7policy_id)
+        try:
+            self.task_utils.mark_l7rule_prov_status_error(
+                l7rule[constants.L7RULE_ID])
+            self.task_utils.mark_l7policy_prov_status_active(l7policy_id)
+            for listener in listeners:
+                self.task_utils.mark_listener_prov_status_active(
+                    listener[constants.LISTENER_ID])
+        except Exception:
+            # Catching and skipping, errors are already reported by task_utils
+            # and we want to ensure that mark_loadbalancer_prov_status_active
+            # is called to unlock the LB (it will pass or it will fail after a
+            # very long timeout)
+            pass
         self.task_utils.mark_loadbalancer_prov_status_active(
             loadbalancer_id)
-        for listener in listeners:
-            self.task_utils.mark_listener_prov_status_active(
-                listener[constants.LISTENER_ID])
 
 
 class ListenerToErrorOnRevertTask(BaseLifecycleTask):
@@ -105,8 +126,15 @@ class ListenerToErrorOnRevertTask(BaseLifecycleTask):
         pass
 
     def revert(self, listener, *args, **kwargs):
-        self.task_utils.mark_listener_prov_status_error(
-            listener[constants.LISTENER_ID])
+        try:
+            self.task_utils.mark_listener_prov_status_error(
+                listener[constants.LISTENER_ID])
+        except Exception:
+            # Catching and skipping, errors are already reported by task_utils
+            # and we want to ensure that mark_loadbalancer_prov_status_active
+            # is called to unlock the LB (it will pass or it will fail after a
+            # very long timeout)
+            pass
         self.task_utils.mark_loadbalancer_prov_status_active(
             listener[constants.LOADBALANCER_ID])
 
@@ -118,9 +146,16 @@ class ListenersToErrorOnRevertTask(BaseLifecycleTask):
         pass
 
     def revert(self, listeners, *args, **kwargs):
-        for listener in listeners:
-            self.task_utils.mark_listener_prov_status_error(
-                listener[constants.LISTENER_ID])
+        try:
+            for listener in listeners:
+                self.task_utils.mark_listener_prov_status_error(
+                    listener[constants.LISTENER_ID])
+        except Exception:
+            # Catching and skipping, errors are already reported by task_utils
+            # and we want to ensure that mark_loadbalancer_prov_status_active
+            # is called to unlock the LB (it will pass or it will fail after a
+            # very long timeout)
+            pass
         self.task_utils.mark_loadbalancer_prov_status_active(
             listeners[0][constants.LOADBALANCER_ID])
 
@@ -154,12 +189,19 @@ class MemberToErrorOnRevertTask(BaseLifecycleTask):
 
     def revert(self, member, listeners, loadbalancer, pool_id, *args,
                **kwargs):
-        self.task_utils.mark_member_prov_status_error(
-            member[constants.MEMBER_ID])
-        for listener in listeners:
-            self.task_utils.mark_listener_prov_status_active(
-                listener[constants.LISTENER_ID])
-        self.task_utils.mark_pool_prov_status_active(pool_id)
+        try:
+            self.task_utils.mark_member_prov_status_error(
+                member[constants.MEMBER_ID])
+            for listener in listeners:
+                self.task_utils.mark_listener_prov_status_active(
+                    listener[constants.LISTENER_ID])
+            self.task_utils.mark_pool_prov_status_active(pool_id)
+        except Exception:
+            # Catching and skipping, errors are already reported by task_utils
+            # and we want to ensure that mark_loadbalancer_prov_status_active
+            # is called to unlock the LB (it will pass or it will fail after a
+            # very long timeout)
+            pass
         self.task_utils.mark_loadbalancer_prov_status_active(
             loadbalancer[constants.LOADBALANCER_ID])
 
@@ -172,13 +214,20 @@ class MembersToErrorOnRevertTask(BaseLifecycleTask):
 
     def revert(self, members, listeners, loadbalancer, pool_id, *args,
                **kwargs):
-        for m in members:
-            self.task_utils.mark_member_prov_status_error(
-                m[constants.MEMBER_ID])
-        for listener in listeners:
-            self.task_utils.mark_listener_prov_status_active(
-                listener[constants.LISTENER_ID])
-        self.task_utils.mark_pool_prov_status_active(pool_id)
+        try:
+            for m in members:
+                self.task_utils.mark_member_prov_status_error(
+                    m[constants.MEMBER_ID])
+            for listener in listeners:
+                self.task_utils.mark_listener_prov_status_active(
+                    listener[constants.LISTENER_ID])
+            self.task_utils.mark_pool_prov_status_active(pool_id)
+        except Exception:
+            # Catching and skipping, errors are already reported by task_utils
+            # and we want to ensure that mark_loadbalancer_prov_status_active
+            # is called to unlock the LB (it will pass or it will fail after a
+            # very long timeout)
+            pass
         self.task_utils.mark_loadbalancer_prov_status_active(
             loadbalancer[constants.LOADBALANCER_ID])
 
@@ -190,9 +239,16 @@ class PoolToErrorOnRevertTask(BaseLifecycleTask):
         pass
 
     def revert(self, pool_id, listeners, loadbalancer, *args, **kwargs):
-        self.task_utils.mark_pool_prov_status_error(pool_id)
+        try:
+            self.task_utils.mark_pool_prov_status_error(pool_id)
+            for listener in listeners:
+                self.task_utils.mark_listener_prov_status_active(
+                    listener[constants.LISTENER_ID])
+        except Exception:
+            # Catching and skipping, errors are already reported by task_utils
+            # and we want to ensure that mark_loadbalancer_prov_status_active
+            # is called to unlock the LB (it will pass or it will fail after a
+            # very long timeout)
+            pass
         self.task_utils.mark_loadbalancer_prov_status_active(
             loadbalancer[constants.LOADBALANCER_ID])
-        for listener in listeners:
-            self.task_utils.mark_listener_prov_status_active(
-                listener[constants.LISTENER_ID])

octavia/controller/worker/v2/tasks/network_tasks.py

@@ -478,53 +478,6 @@ class HandleNetworkDeltas(BaseNetworkTask):
                     LOG.exception("Unable to delete port %s", port_id)
 
 
-class PlugVIP(BaseNetworkTask):
-    """Task to plumb a VIP."""
-
-    def execute(self, loadbalancer):
-        """Plumb a vip to an amphora."""
-
-        LOG.debug("Plumbing VIP for loadbalancer id: %s",
-                  loadbalancer[constants.LOADBALANCER_ID])
-        session = db_apis.get_session()
-        with session.begin():
-            db_lb = self.loadbalancer_repo.get(
-                session,
-                id=loadbalancer[constants.LOADBALANCER_ID])
-        amps_data = self.network_driver.plug_vip(db_lb,
-                                                 db_lb.vip)
-        return [amp.to_dict() for amp in amps_data]
-
-    def revert(self, result, loadbalancer, *args, **kwargs):
-        """Handle a failure to plumb a vip."""
-
-        if isinstance(result, failure.Failure):
-            return
-        LOG.warning("Unable to plug VIP for loadbalancer id %s",
-                    loadbalancer[constants.LOADBALANCER_ID])
-
-        session = db_apis.get_session()
-        with session.begin():
-            db_lb = self.loadbalancer_repo.get(
-                session,
-                id=loadbalancer[constants.LOADBALANCER_ID])
-        try:
-            # Make sure we have the current port IDs for cleanup
-            for amp_data in result:
-                for amphora in filter(
-                        # pylint: disable=cell-var-from-loop
-                        lambda amp: amp.id == amp_data['id'],
-                        db_lb.amphorae):
-                    amphora.vrrp_port_id = amp_data['vrrp_port_id']
-                    amphora.ha_port_id = amp_data['ha_port_id']
-
-            self.network_driver.unplug_vip(db_lb, db_lb.vip)
-        except Exception as e:
-            LOG.error("Failed to unplug VIP.  Resources may still "
-                      "be in use from vip: %(vip)s due to error: %(except)s",
-                      {'vip': loadbalancer['vip_address'], 'except': str(e)})
-
-
 class UpdateVIPSecurityGroup(BaseNetworkTask):
     """Task to setup SG for LB."""
 
@@ -791,19 +744,6 @@ class GetAmphoraeNetworkConfigs(BaseNetworkTask):
         return provider_dict
 
 
-class FailoverPreparationForAmphora(BaseNetworkTask):
-    """Task to prepare an amphora for failover."""
-
-    def execute(self, amphora):
-        session = db_apis.get_session()
-        with session.begin():
-            db_amp = self.amphora_repo.get(session,
-                                           id=amphora[constants.ID])
-        LOG.debug("Prepare amphora %s for failover.", amphora[constants.ID])
-
-        self.network_driver.failover_preparation(db_amp)
-
-
 class RetrievePortIDsOnAmphoraExceptLBNetwork(BaseNetworkTask):
     """Task retrieving all the port ids on an amphora, except lb network."""
 
@@ -1098,3 +1038,60 @@ class GetVIPSecurityGroupID(BaseNetworkTask):
                 else:
                     ctxt.reraise = False
         return None
+
+
+class CreateSRIOVBasePort(BaseNetworkTask):
+    """Task to create a SRIOV base port for an amphora."""
+
+    @tenacity.retry(retry=tenacity.retry_if_exception_type(),
+                    stop=tenacity.stop_after_attempt(
+                        CONF.networking.max_retries),
+                    wait=tenacity.wait_exponential(
+                        multiplier=CONF.networking.retry_backoff,
+                        min=CONF.networking.retry_interval,
+                        max=CONF.networking.retry_max), reraise=True)
+    def execute(self, loadbalancer, amphora, subnet):
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer[constants.LOADBALANCER_ID])
+        port_name = constants.AMP_BASE_PORT_PREFIX + amphora[constants.ID]
+        fixed_ips = [{constants.SUBNET_ID: subnet[constants.ID]}]
+        addl_vips = [obj.ip_address for obj in db_lb.additional_vips]
+        addl_vips.append(loadbalancer[constants.VIP_ADDRESS])
+        port = self.network_driver.create_port(
+            loadbalancer[constants.VIP_NETWORK_ID],
+            name=port_name, fixed_ips=fixed_ips,
+            secondary_ips=addl_vips,
+            qos_policy_id=loadbalancer[constants.VIP_QOS_POLICY_ID],
+            vnic_type=constants.VNIC_TYPE_DIRECT)
+        LOG.info('Created port %s with ID %s for amphora %s',
+                 port_name, port.id, amphora[constants.ID])
+        return port.to_dict(recurse=True)
+
+    def revert(self, result, loadbalancer, amphora, subnet, *args, **kwargs):
+        if isinstance(result, failure.Failure):
+            return
+        try:
+            port_name = constants.AMP_BASE_PORT_PREFIX + amphora['id']
+            self.network_driver.delete_port(result[constants.ID])
+            LOG.info('Deleted port %s with ID %s for amphora %s due to a '
+                     'revert.', port_name, result[constants.ID], amphora['id'])
+        except Exception as e:
+            LOG.error('Failed to delete port %s. Resources may still be in '
+                      'use for a port intended for amphora %s due to error '
+                      '%s. Search for a port named %s',
+                      result, amphora['id'], str(e), port_name)
+
+
+class BuildAMPData(BaseNetworkTask):
+    """Glue task to store the AMP_DATA dict from netork port information."""
+
+    def execute(self, loadbalancer, amphora, port_data):
+        amphora[constants.HA_IP] = loadbalancer[constants.VIP_ADDRESS]
+        amphora[constants.HA_PORT_ID] = loadbalancer[constants.VIP_PORT_ID]
+        amphora[constants.VRRP_ID] = 1
+        amphora[constants.VRRP_PORT_ID] = port_data[constants.ID]
+        amphora[constants.VRRP_IP] = port_data[
+            constants.FIXED_IPS][0][constants.IP_ADDRESS]
+        return amphora

octavia/controller/worker/v2/tasks/shim_tasks.py

@@ -0,0 +1,28 @@
+# Copyright 2024 Red Hat
+#
+# 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 import task
+
+from octavia.common import constants
+
+
+class AmphoraToAmphoraeWithVRRPIP(task.Task):
+    """A shim class to convert a single Amphora instance to a list."""
+
+    def execute(self, amphora: dict, base_port: dict):
+        # The VRRP_IP has not been stamped on the Amphora at this point in the
+        # flow, so inject it from our port create call in a previous task.
+        amphora[constants.VRRP_IP] = (
+            base_port[constants.FIXED_IPS][0][constants.IP_ADDRESS])
+        return [amphora]

octavia/db/migration/alembic_migrations/versions/55874a4ceed6_add_l7policy_action_redirect_prefix.py

@@ -30,7 +30,7 @@ down_revision = '76aacf2e176c'
 
 
 def upgrade():
-    # Add collumn redirect_prefix
+    # Add column redirect_prefix
     op.add_column(
         u'l7policy',
         sa.Column(u'redirect_prefix', sa.String(255), nullable=True)

octavia/db/migration/alembic_migrations/versions/5a3ee5472c31_add_cert_expiration__infor_in_amphora_table.py

@@ -11,7 +11,7 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
-"""add cert expiration infor in amphora table
+"""add cert expiration info in amphora table
 
 Revision ID: 5a3ee5472c31
 Revises: 3b199c848b96

octavia/db/migration/alembic_migrations/versions/6742ca1b27c2_add_l7policy_redirect_http_code.py

@@ -29,7 +29,7 @@ down_revision = 'a7f187cd221f'
 
 
 def upgrade():
-    # Add collumn redirect_prefix
+    # Add column redirect_prefix
     op.add_column(
         u'l7policy',
         sa.Column(u'redirect_http_code', sa.Integer(), nullable=True)