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

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

@@ -55,16 +55,10 @@ class CalculateAmphoraDelta(BaseNetworkTask):
 
     default_provides = constants.DELTA
 
-    # TODO(gthiemonge) ensure we no longer need vrrp_port
     def execute(self, loadbalancer, amphora, availability_zone):
         LOG.debug("Calculating network delta for amphora id: %s",
                   amphora.get(constants.ID))
 
-        vip_subnet_to_net_map = {
-            loadbalancer[constants.VIP_SUBNET_ID]:
-            loadbalancer[constants.VIP_NETWORK_ID]
-        }
-
         # Figure out what networks we want
         # seed with lb network(s)
         if (availability_zone and
@@ -74,15 +68,15 @@ class CalculateAmphoraDelta(BaseNetworkTask):
         else:
             management_nets = CONF.controller_worker.amp_boot_network_list
 
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID])
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer[constants.LOADBALANCER_ID])
 
-        desired_subnet_to_net_map = {}
-        for mgmt_net_id in management_nets:
-            for subnet_id in self.network_driver.get_network(
-                    mgmt_net_id).subnets:
-                desired_subnet_to_net_map[subnet_id] = mgmt_net_id
-        desired_subnet_to_net_map.update(vip_subnet_to_net_map)
+        desired_subnet_to_net_map = {
+            loadbalancer[constants.VIP_SUBNET_ID]:
+            loadbalancer[constants.VIP_NETWORK_ID]
+        }
 
         for pool in db_lb.pools:
             for member in pool.members:
@@ -101,7 +95,12 @@ class CalculateAmphoraDelta(BaseNetworkTask):
         nics = self.network_driver.get_plugged_networks(
             amphora[constants.COMPUTE_ID])
         # we don't have two nics in the same network
-        network_to_nic_map = {nic.network_id: nic for nic in nics}
+        # Don't include the nics connected to the management network, we don't
+        # want to update these interfaces.
+        network_to_nic_map = {
+            nic.network_id: nic
+            for nic in nics
+            if nic.network_id not in management_nets}
 
         plugged_network_ids = set(network_to_nic_map)
 
@@ -183,8 +182,10 @@ class CalculateDelta(BaseNetworkTask):
 
         calculate_amp = CalculateAmphoraDelta()
         deltas = {}
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID])
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer[constants.LOADBALANCER_ID])
         for amphora in filter(
             lambda amp: amp.status == constants.AMPHORA_ALLOCATED,
                 db_lb.amphorae):
@@ -317,8 +318,10 @@ class HandleNetworkDelta(BaseNetworkTask):
 
     def execute(self, amphora, delta):
         """Handle network plugging based off deltas."""
-        db_amp = self.amphora_repo.get(db_apis.get_session(),
-                                       id=amphora.get(constants.ID))
+        session = db_apis.get_session()
+        with session.begin():
+            db_amp = self.amphora_repo.get(session,
+                                           id=amphora.get(constants.ID))
         updated_ports = {}
         for nic in delta[constants.ADD_NICS]:
             subnet_id = nic[constants.FIXED_IPS][0][constants.SUBNET_ID]
@@ -432,8 +435,10 @@ class HandleNetworkDeltas(BaseNetworkTask):
 
     def execute(self, deltas, loadbalancer):
         """Handle network plugging based off deltas."""
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID])
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer[constants.LOADBALANCER_ID])
         amphorae = {amp.id: amp for amp in db_lb.amphorae}
 
         updated_ports = {}
@@ -481,9 +486,11 @@ class PlugVIP(BaseNetworkTask):
 
         LOG.debug("Plumbing VIP for loadbalancer id: %s",
                   loadbalancer[constants.LOADBALANCER_ID])
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(),
-            id=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]
@@ -496,9 +503,11 @@ class PlugVIP(BaseNetworkTask):
         LOG.warning("Unable to plug VIP for loadbalancer id %s",
                     loadbalancer[constants.LOADBALANCER_ID])
 
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(),
-            id=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:
@@ -524,8 +533,10 @@ class UpdateVIPSecurityGroup(BaseNetworkTask):
 
         LOG.debug("Setting up VIP SG for load balancer id: %s",
                   loadbalancer_id)
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer_id)
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer_id)
 
         sg_id = self.network_driver.update_vip_sg(db_lb, db_lb.vip)
         LOG.info("Set up VIP SG %s for load balancer %s complete",
@@ -557,11 +568,13 @@ class PlugVIPAmphora(BaseNetworkTask):
 
         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])
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID])
+        session = db_apis.get_session()
+        with session.begin():
+            db_amp = self.amphora_repo.get(session,
+                                           id=amphora.get(constants.ID))
+            db_subnet = self.network_driver.get_subnet(subnet[constants.ID])
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer[constants.LOADBALANCER_ID])
         amp_data = self.network_driver.plug_aap_port(
             db_lb, db_lb.vip, db_amp, db_subnet)
         return amp_data.to_dict()
@@ -576,14 +589,17 @@ class PlugVIPAmphora(BaseNetworkTask):
                     loadbalancer[constants.LOADBALANCER_ID])
 
         try:
-            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]
-            db_subnet = self.network_driver.get_subnet(subnet[constants.ID])
-            db_lb = self.loadbalancer_repo.get(
-                db_apis.get_session(),
-                id=loadbalancer[constants.LOADBALANCER_ID])
+            session = db_apis.get_session()
+            with session.begin():
+                db_amp = self.amphora_repo.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]
+                db_subnet = self.network_driver.get_subnet(
+                    subnet[constants.ID])
+                db_lb = self.loadbalancer_repo.get(
+                    session,
+                    id=loadbalancer[constants.LOADBALANCER_ID])
 
             self.network_driver.unplug_aap_port(db_lb.vip,
                                                 db_amp, db_subnet)
@@ -600,9 +616,11 @@ class UnplugVIP(BaseNetworkTask):
 
         LOG.debug("Unplug vip on amphora")
         try:
-            db_lb = self.loadbalancer_repo.get(
-                db_apis.get_session(),
-                id=loadbalancer[constants.LOADBALANCER_ID])
+            session = db_apis.get_session()
+            with session.begin():
+                db_lb = self.loadbalancer_repo.get(
+                    session,
+                    id=loadbalancer[constants.LOADBALANCER_ID])
             self.network_driver.unplug_vip(db_lb, db_lb.vip)
         except Exception:
             LOG.exception("Unable to unplug vip from load balancer %s",
@@ -621,8 +639,10 @@ class AllocateVIP(BaseNetworkTask):
                   loadbalancer[constants.VIP_SUBNET_ID],
                   loadbalancer[constants.VIP_ADDRESS],
                   loadbalancer[constants.LOADBALANCER_ID])
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID])
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer[constants.LOADBALANCER_ID])
         vip, additional_vips = self.network_driver.allocate_vip(db_lb)
         LOG.info("Allocated vip with port id %s, subnet id %s, ip address %s "
                  "for load balancer %s",
@@ -682,10 +702,12 @@ class DeallocateVIP(BaseNetworkTask):
         # will need access to the load balancer that the vip is/was attached
         # to.  However the data model serialization for the vip does not give a
         # backref to the loadbalancer if accessed through the loadbalancer.
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID])
-        vip = db_lb.vip
-        vip.load_balancer = db_lb
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer[constants.LOADBALANCER_ID])
+            vip = db_lb.vip
+            vip.load_balancer = db_lb
         self.network_driver.deallocate_vip(vip)
 
 
@@ -693,8 +715,10 @@ class UpdateVIP(BaseNetworkTask):
     """Task to update a VIP."""
 
     def execute(self, listeners):
-        loadbalancer = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=listeners[0][constants.LOADBALANCER_ID])
+        session = db_apis.get_session()
+        with session.begin():
+            loadbalancer = self.loadbalancer_repo.get(
+                session, id=listeners[0][constants.LOADBALANCER_ID])
 
         LOG.debug("Updating VIP of load_balancer %s.", loadbalancer.id)
 
@@ -705,8 +729,10 @@ class UpdateVIPForDelete(BaseNetworkTask):
     """Task to update a VIP for listener delete flows."""
 
     def execute(self, loadbalancer_id):
-        loadbalancer = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer_id)
+        session = db_apis.get_session()
+        with session.begin():
+            loadbalancer = self.loadbalancer_repo.get(
+                session, id=loadbalancer_id)
         LOG.debug("Updating VIP for listener delete on load_balancer %s.",
                   loadbalancer.id)
         self.network_driver.update_vip(loadbalancer, for_delete=True)
@@ -717,10 +743,12 @@ class GetAmphoraNetworkConfigs(BaseNetworkTask):
 
     def execute(self, loadbalancer, amphora=None):
         LOG.debug("Retrieving vip network details.")
-        db_amp = self.amphora_repo.get(db_apis.get_session(),
-                                       id=amphora.get(constants.ID))
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID])
+        session = db_apis.get_session()
+        with session.begin():
+            db_amp = self.amphora_repo.get(session,
+                                           id=amphora.get(constants.ID))
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer[constants.LOADBALANCER_ID])
         db_configs = self.network_driver.get_network_configs(
             db_lb, amphora=db_amp)
         provider_dict = {}
@@ -734,9 +762,11 @@ class GetAmphoraNetworkConfigsByID(BaseNetworkTask):
 
     def execute(self, loadbalancer_id, amphora_id=None):
         LOG.debug("Retrieving vip network details.")
-        loadbalancer = self.loadbalancer_repo.get(db_apis.get_session(),
-                                                  id=loadbalancer_id)
-        amphora = self.amphora_repo.get(db_apis.get_session(), id=amphora_id)
+        session = db_apis.get_session()
+        with session.begin():
+            loadbalancer = self.loadbalancer_repo.get(session,
+                                                      id=loadbalancer_id)
+            amphora = self.amphora_repo.get(session, id=amphora_id)
         db_configs = self.network_driver.get_network_configs(loadbalancer,
                                                              amphora=amphora)
         provider_dict = {}
@@ -750,8 +780,10 @@ class GetAmphoraeNetworkConfigs(BaseNetworkTask):
 
     def execute(self, loadbalancer_id):
         LOG.debug("Retrieving vip network details.")
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(), id=loadbalancer_id)
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session, id=loadbalancer_id)
         db_configs = self.network_driver.get_network_configs(db_lb)
         provider_dict = {}
         for amp_id, amp_conf in db_configs.items():
@@ -763,8 +795,10 @@ class FailoverPreparationForAmphora(BaseNetworkTask):
     """Task to prepare an amphora for failover."""
 
     def execute(self, amphora):
-        db_amp = self.amphora_repo.get(db_apis.get_session(),
-                                       id=amphora[constants.ID])
+        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)
@@ -799,8 +833,10 @@ 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])
+        session = db_apis.get_session()
+        with session.begin():
+            db_amp = self.amphora_repo.get(session,
+                                           id=amphora[constants.ID])
         for port in ports:
             LOG.debug('Plugging port ID: %(port_id)s into compute instance: '
                       '%(compute_id)s.',
@@ -816,15 +852,17 @@ class ApplyQos(BaseNetworkTask):
                                  is_revert=False, request_qos_id=None):
         """Call network driver to apply QoS Policy on the vrrp ports."""
 
-        if not amps_data:
-            db_lb = self.loadbalancer_repo.get(
-                db_apis.get_session(),
-                id=loadbalancer[constants.LOADBALANCER_ID])
-            amps_data = db_lb.amphorae
+        session = db_apis.get_session()
+        with session.begin():
+            if not amps_data:
+                db_lb = self.loadbalancer_repo.get(
+                    session,
+                    id=loadbalancer[constants.LOADBALANCER_ID])
+                amps_data = db_lb.amphorae
 
-        amps_data = [amp
-                     for amp in amps_data
-                     if amp.status == constants.AMPHORA_ALLOCATED]
+            amps_data = [amp
+                         for amp in amps_data
+                         if amp.status == constants.AMPHORA_ALLOCATED]
 
         apply_qos = ApplyQosAmphora()
         for amp_data in amps_data:
@@ -833,9 +871,11 @@ class ApplyQos(BaseNetworkTask):
 
     def execute(self, loadbalancer, amps_data=None, update_dict=None):
         """Apply qos policy on the vrrp ports which are related with vip."""
-        db_lb = self.loadbalancer_repo.get(
-            db_apis.get_session(),
-            id=loadbalancer[constants.LOADBALANCER_ID])
+        session = db_apis.get_session()
+        with session.begin():
+            db_lb = self.loadbalancer_repo.get(
+                session,
+                id=loadbalancer[constants.LOADBALANCER_ID])
 
         qos_policy_id = db_lb.vip.qos_policy_id
         if not qos_policy_id and (

octavia/db/api.py

@@ -12,15 +12,13 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import contextlib
 import time
 
 from sqlalchemy.sql.expression import select
 
 from oslo_config import cfg
-from oslo_db.sqlalchemy import session as db_session
+from oslo_db.sqlalchemy import enginefacade
 from oslo_log import log as logging
-from oslo_utils import excutils
 
 LOG = logging.getLogger(__name__)
 _FACADE = None
@@ -29,32 +27,37 @@ _FACADE = None
 def _create_facade_lazily():
     global _FACADE
     if _FACADE is None:
-        _FACADE = db_session.EngineFacade.from_config(cfg.CONF, sqlite_fk=True)
-    return _FACADE
+        _FACADE = True
+        enginefacade.configure(sqlite_fk=True, expire_on_commit=True)
+
+
+def _get_transaction_context(reader=False):
+    _create_facade_lazily()
+    # TODO(gthiemonge) Create and use new functions to get read-only sessions
+    if reader:
+        context = enginefacade.reader
+    else:
+        context = enginefacade.writer
+    return context
+
+
+def _get_sessionmaker(reader=False):
+    context = _get_transaction_context(reader)
+    return context.get_sessionmaker()
 
 
 def get_engine():
-    facade = _create_facade_lazily()
-    return facade.get_engine()
+    context = _get_transaction_context()
+    return context.get_engine()
 
 
-def get_session(expire_on_commit=True, autocommit=True):
+def get_session():
     """Helper method to grab session."""
-    facade = _create_facade_lazily()
-    return facade.get_session(expire_on_commit=expire_on_commit,
-                              autocommit=autocommit)
-
-
-@contextlib.contextmanager
-def get_lock_session():
-    """Context manager for using a locking (not auto-commit) session."""
-    lock_session = get_session(autocommit=False)
-    try:
-        yield lock_session
-        lock_session.commit()
-    except Exception:
-        with excutils.save_and_reraise_exception():
-            lock_session.rollback()
+    return _get_sessionmaker()()
+
+
+def session():
+    return _get_sessionmaker()
 
 
 def wait_for_connection(exit_event):

octavia/db/base_models.py

@@ -16,8 +16,8 @@ from oslo_db.sqlalchemy import models
 from oslo_utils import strutils
 from oslo_utils import uuidutils
 import sqlalchemy as sa
-from sqlalchemy.ext import declarative
 from sqlalchemy.orm import collections
+from sqlalchemy.orm import declarative_base
 
 
 class OctaviaBase(models.ModelBase):
@@ -189,7 +189,7 @@ class TagMixin(object):
         self._tags = new_tags
 
 
-BASE = declarative.declarative_base(cls=OctaviaBase)
+BASE = declarative_base(cls=OctaviaBase)
 
 
 class Tags(BASE):

octavia/db/healthcheck.py

@@ -12,6 +12,7 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 from oslo_log import log as logging
+from sqlalchemy import text
 
 from octavia.i18n import _
 
@@ -28,7 +29,7 @@ def check_database_connection(session):
     :returns: True if the connection check is successful, False if not.
     """
     try:
-        session.execute('SELECT 1;')
+        session.execute(text('SELECT 1;'))
         return True, None
     except Exception as e:
         message = _('Database health check failed due to: {err}.').format(

octavia/db/migration/alembic_migrations/versions/632152d2d32e_add_http_strict_transport_security_.py

@@ -0,0 +1,42 @@
+#    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.
+
+"""Add HTTP Strict Transport Security support
+
+Revision ID: 632152d2d32e
+Revises: 0995c26fc506
+Create Date: 2023-04-19 13:36:44.015581
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '632152d2d32e'
+down_revision = '0995c26fc506'
+
+
+def upgrade():
+    op.add_column(
+        'listener',
+        sa.Column('hsts_max_age', sa.Integer, nullable=True)
+    )
+    op.add_column(
+        'listener',
+        sa.Column('hsts_include_subdomains', sa.Boolean, nullable=True)
+    )
+    op.add_column(
+        'listener',
+        sa.Column('hsts_preload', sa.Boolean, nullable=True)
+    )

octavia/db/models.py

@@ -19,6 +19,7 @@ from oslo_db.sqlalchemy import models
 import sqlalchemy as sa
 from sqlalchemy.ext import orderinglist
 from sqlalchemy import orm
+from sqlalchemy.orm import Mapped
 from sqlalchemy.orm import validates
 from sqlalchemy.sql import func
 from sqlalchemy_utils import ScalarListType
@@ -353,7 +354,8 @@ class Pool(base_models.BASE, base_models.IdMixin, base_models.ProjectMixin,
         "SessionPersistence", uselist=False, cascade="delete",
         back_populates="pool")
     _default_listeners = orm.relationship("Listener", uselist=True,
-                                          back_populates="default_pool")
+                                          back_populates="default_pool",
+                                          cascade_backrefs=False)
     l7policies = orm.relationship("L7Policy", uselist=True,
                                   back_populates="redirect_pool")
     _tags = orm.relationship(
@@ -453,6 +455,7 @@ class LoadBalancer(base_models.BASE, base_models.IdMixin,
         sa.ForeignKey("availability_zone.name",
                       name="fk_load_balancer_availability_zone_name"),
         nullable=True)
+    flavor: Mapped["Flavor"] = orm.relationship("Flavor")
 
     def __str__(self):
         return (f"LoadBalancer(id={self.id!r}, name={self.name!r}, "
@@ -573,7 +576,8 @@ class Listener(base_models.BASE, base_models.IdMixin,
     load_balancer = orm.relationship("LoadBalancer", uselist=False,
                                      back_populates="listeners")
     default_pool = orm.relationship("Pool", uselist=False,
-                                    back_populates="_default_listeners")
+                                    back_populates="_default_listeners",
+                                    cascade_backrefs=False)
     sni_containers = orm.relationship(
         'SNI', cascade='all,delete-orphan',
         uselist=True, backref=orm.backref('listener', uselist=False))
@@ -599,6 +603,9 @@ class Listener(base_models.BASE, base_models.IdMixin,
     tls_ciphers = sa.Column(sa.String(2048), nullable=True)
     tls_versions = sa.Column(ScalarListType(), nullable=True)
     alpn_protocols = sa.Column(ScalarListType(), nullable=True)
+    hsts_max_age = sa.Column(sa.Integer, nullable=True)
+    hsts_include_subdomains = sa.Column(sa.Boolean, nullable=True)
+    hsts_preload = sa.Column(sa.Boolean, nullable=True)
 
     _tags = orm.relationship(
         'Tags',
@@ -907,6 +914,7 @@ class Flavor(base_models.BASE,
         sa.ForeignKey("flavor_profile.id",
                       name="fk_flavor_flavor_profile_id"),
         nullable=False)
+    flavor_profile: Mapped["FlavorProfile"] = orm.relationship("FlavorProfile")
 
 
 class AvailabilityZoneProfile(base_models.BASE, base_models.IdMixin,
@@ -942,6 +950,8 @@ class AvailabilityZone(base_models.BASE,
         sa.ForeignKey("availability_zone_profile.id",
                       name="fk_az_az_profile_id"),
         nullable=False)
+    availability_zone_profile: Mapped["AvailabilityZoneProfile"] = (
+        orm.relationship("AvailabilityZoneProfile"))
 
 
 class ClientAuthenticationMode(base_models.BASE):

octavia/db/prepare.py

@@ -169,6 +169,8 @@ def create_pool(pool_dict, lb_id=None):
 
 
 def create_member(member_dict, pool_id, has_health_monitor=False):
+    if not member_dict.get('id'):
+        member_dict['id'] = uuidutils.generate_uuid()
     member_dict['pool_id'] = pool_id
     member_dict[constants.PROVISIONING_STATUS] = constants.PENDING_CREATE
     if has_health_monitor: