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

octavia/api/drivers/driver_agent/driver_get.py

@@ -25,56 +25,64 @@ def process_get(get_data):
 
     if get_data[constants.OBJECT] == lib_consts.LOADBALANCERS:
         lb_repo = repositories.LoadBalancerRepository()
-        db_lb = lb_repo.get(session, id=get_data[lib_consts.ID],
-                            show_deleted=False)
+        with session.begin():
+            db_lb = lb_repo.get(session, id=get_data[lib_consts.ID],
+                                show_deleted=False)
         if db_lb:
             provider_lb = (
                 driver_utils.db_loadbalancer_to_provider_loadbalancer(db_lb))
             return provider_lb.to_dict(recurse=True, render_unsets=True)
     elif get_data[constants.OBJECT] == lib_consts.LISTENERS:
         listener_repo = repositories.ListenerRepository()
-        db_listener = listener_repo.get(
-            session, id=get_data[lib_consts.ID], show_deleted=False)
+        with session.begin():
+            db_listener = listener_repo.get(
+                session, id=get_data[lib_consts.ID], show_deleted=False)
         if db_listener:
             provider_listener = (
                 driver_utils.db_listener_to_provider_listener(db_listener))
             return provider_listener.to_dict(recurse=True, render_unsets=True)
     elif get_data[constants.OBJECT] == lib_consts.POOLS:
         pool_repo = repositories.PoolRepository()
-        db_pool = pool_repo.get(session, id=get_data[lib_consts.ID],
-                                show_deleted=False)
+        with session.begin():
+            db_pool = pool_repo.get(session, id=get_data[lib_consts.ID],
+                                    show_deleted=False)
         if db_pool:
             provider_pool = (
                 driver_utils.db_pool_to_provider_pool(db_pool))
             return provider_pool.to_dict(recurse=True, render_unsets=True)
     elif get_data[constants.OBJECT] == lib_consts.MEMBERS:
         member_repo = repositories.MemberRepository()
-        db_member = member_repo.get(session, id=get_data[lib_consts.ID],
-                                    show_deleted=False)
+        with session.begin():
+            db_member = member_repo.get(session, id=get_data[lib_consts.ID],
+                                        show_deleted=False)
         if db_member:
             provider_member = (
                 driver_utils.db_member_to_provider_member(db_member))
             return provider_member.to_dict(recurse=True, render_unsets=True)
     elif get_data[constants.OBJECT] == lib_consts.HEALTHMONITORS:
         hm_repo = repositories.HealthMonitorRepository()
-        db_hm = hm_repo.get(session, id=get_data[lib_consts.ID],
-                            show_deleted=False)
+        with session.begin():
+            db_hm = hm_repo.get(session, id=get_data[lib_consts.ID],
+                                show_deleted=False)
         if db_hm:
             provider_hm = (
                 driver_utils.db_HM_to_provider_HM(db_hm))
             return provider_hm.to_dict(recurse=True, render_unsets=True)
     elif get_data[constants.OBJECT] == lib_consts.L7POLICIES:
         l7policy_repo = repositories.L7PolicyRepository()
-        db_l7policy = l7policy_repo.get(session, id=get_data[lib_consts.ID],
-                                        show_deleted=False)
+        with session.begin():
+            db_l7policy = l7policy_repo.get(session,
+                                            id=get_data[lib_consts.ID],
+                                            show_deleted=False)
         if db_l7policy:
             provider_l7policy = (
                 driver_utils.db_l7policy_to_provider_l7policy(db_l7policy))
             return provider_l7policy.to_dict(recurse=True, render_unsets=True)
     elif get_data[constants.OBJECT] == lib_consts.L7RULES:
         l7rule_repo = repositories.L7RuleRepository()
-        db_l7rule = l7rule_repo.get(session, id=get_data[lib_consts.ID],
-                                    show_deleted=False)
+        with session.begin():
+            db_l7rule = l7rule_repo.get(session, id=get_data[lib_consts.ID],
+                                        show_deleted=False)
         if db_l7rule:
             provider_l7rule = (
                 driver_utils.db_l7rule_to_provider_l7rule(db_l7rule))

octavia/api/drivers/driver_agent/driver_updater.py

@@ -46,7 +46,8 @@ class DriverUpdater(object):
         super().__init__(**kwargs)
 
     def _check_for_lb_vip_deallocate(self, repo, lb_id):
-        lb = repo.get(self.db_session, id=lb_id)
+        with self.db_session.begin():
+            lb = repo.get(self.db_session, id=lb_id)
         if lb.vip.octavia_owned:
             vip = lb.vip
             # We need a backreference
@@ -56,7 +57,8 @@ class DriverUpdater(object):
             network_driver.deallocate_vip(vip)
 
     def _decrement_quota(self, repo, object_name, record_id):
-        lock_session = db_apis.get_session(autocommit=False)
+        lock_session = self.db_session
+        lock_session.begin()
         db_object = repo.get(lock_session, id=record_id)
         if db_object is None:
             lock_session.rollback()
@@ -106,7 +108,8 @@ class DriverUpdater(object):
                         return
 
                     if delete_record and object_name != consts.LOADBALANCERS:
-                        repo.delete(self.db_session, id=record_id)
+                        with self.db_session.begin():
+                            repo.delete(self.db_session, id=record_id)
                         return
 
                 record_kwargs[consts.PROVISIONING_STATUS] = prov_status
@@ -114,7 +117,8 @@ class DriverUpdater(object):
             if op_status:
                 record_kwargs[consts.OPERATING_STATUS] = op_status
             if prov_status or op_status:
-                repo.update(self.db_session, record_id, **record_kwargs)
+                with self.db_session.begin():
+                    repo.update(self.db_session, record_id, **record_kwargs)
         except Exception as e:
             # We need to raise a failure here to notify the driver it is
             # sending bad status data.

octavia/api/drivers/utils.py

@@ -132,8 +132,10 @@ def lb_dict_to_provider_dict(lb_dict, vip=None, add_vips=None, db_pools=None,
         new_lb_dict['vip_qos_policy_id'] = vip.qos_policy_id
     if 'flavor_id' in lb_dict and lb_dict['flavor_id']:
         flavor_repo = repositories.FlavorRepository()
-        new_lb_dict['flavor'] = flavor_repo.get_flavor_metadata_dict(
-            db_api.get_session(), lb_dict['flavor_id'])
+        session = db_api.get_session()
+        with session.begin():
+            new_lb_dict['flavor'] = flavor_repo.get_flavor_metadata_dict(
+                session, lb_dict['flavor_id'])
     if add_vips:
         new_lb_dict['additional_vips'] = db_additional_vips_to_provider_vips(
             add_vips)

octavia/api/healthcheck/healthcheck_plugins.py

@@ -42,8 +42,10 @@ class OctaviaDBHealthcheck(pluginbase.HealthcheckBaseExtension):
                 result = self.last_result
                 message = self.last_message
             else:
-                result, message = healthcheck.check_database_connection(
-                    db_apis.get_session())
+                session = db_apis.get_session()
+                with session.begin():
+                    result, message = healthcheck.check_database_connection(
+                        session)
                 self.last_check = datetime.datetime.now()
                 self.last_result = result
                 self.last_message = message

octavia/api/root_controller.py

@@ -143,6 +143,9 @@ class RootController(object):
         self._add_a_version(versions, 'v2.25', 'v2', 'SUPPORTED',
                             '2021-10-02T00:00:00Z', host_url)
         # Additional VIPs
-        self._add_a_version(versions, 'v2.26', 'v2', 'CURRENT',
+        self._add_a_version(versions, 'v2.26', 'v2', 'SUPPORTED',
                             '2022-08-29T00:00:00Z', host_url)
+        # HTTP Strict Transport Security (HSTS)
+        self._add_a_version(versions, 'v2.27', 'v2', 'CURRENT',
+                            '2023-05-05T00:00:00Z', host_url)
         return {'versions': versions}

octavia/api/v2/controllers/amphora.py

@@ -28,7 +28,6 @@ from octavia.api.v2.types import amphora as amp_types
 from octavia.common import constants
 from octavia.common import exceptions
 from octavia.common import rpc
-from octavia.db import api as db_api
 
 CONF = cfg.CONF
 LOG = logging.getLogger(__name__)
@@ -50,7 +49,8 @@ class AmphoraController(base.BaseController):
     def get_one(self, id, fields=None):
         """Gets a single amphora's details."""
         context = pecan_request.context.get('octavia_context')
-        db_amp = self._get_db_amp(context.session, id, show_deleted=False)
+        with context.session.begin():
+            db_amp = self._get_db_amp(context.session, id, show_deleted=False)
 
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_GET_ONE)
@@ -71,9 +71,10 @@ class AmphoraController(base.BaseController):
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_GET_ALL)
 
-        db_amp, links = self.repositories.amphora.get_all_API_list(
-            context.session, show_deleted=False,
-            pagination_helper=pcontext.get(constants.PAGINATION_HELPER))
+        with context.session.begin():
+            db_amp, links = self.repositories.amphora.get_all_API_list(
+                context.session, show_deleted=False,
+                pagination_helper=pcontext.get(constants.PAGINATION_HELPER))
         result = self._convert_db_to_type(
             db_amp, [amp_types.AmphoraResponse])
         if fields is not None:
@@ -89,10 +90,10 @@ class AmphoraController(base.BaseController):
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_DELETE)
 
-        with db_api.get_lock_session() as lock_session:
+        with context.session.begin():
             try:
                 self.repositories.amphora.test_and_set_status_for_delete(
-                    lock_session, id)
+                    context.session, id)
             except sa_exception.NoResultFound as e:
                 raise exceptions.NotFound(resource='Amphora', id=id) from e
 
@@ -124,12 +125,8 @@ class FailoverController(base.BaseController):
 
     def __init__(self, amp_id):
         super().__init__()
-        if CONF.api_settings.default_provider_driver == constants.AMPHORAV1:
-            topic = cfg.CONF.oslo_messaging.topic
-            version = "1.0"
-        else:
-            topic = constants.TOPIC_AMPHORA_V2
-            version = "2.0"
+        topic = constants.TOPIC_AMPHORA_V2
+        version = "2.0"
         self.target = messaging.Target(
             namespace=constants.RPC_NAMESPACE_CONTROLLER_AGENT,
             topic=topic, version=version, fanout=False)
@@ -141,27 +138,29 @@ class FailoverController(base.BaseController):
         """Fails over an amphora"""
         pcontext = pecan_request.context
         context = pcontext.get('octavia_context')
-        db_amp = self._get_db_amp(context.session, self.amp_id,
-                                  show_deleted=False)
+        with context.session.begin():
+            db_amp = self._get_db_amp(context.session, self.amp_id,
+                                      show_deleted=False)
 
         self._auth_validate_action(
             context, db_amp.load_balancer.project_id,
             constants.RBAC_PUT_FAILOVER)
 
-        self.repositories.load_balancer.test_and_set_provisioning_status(
-            context.session, db_amp.load_balancer_id,
-            status=constants.PENDING_UPDATE, raise_exception=True)
+        with context.session.begin():
+            self.repositories.load_balancer.test_and_set_provisioning_status(
+                context.session, db_amp.load_balancer_id,
+                status=constants.PENDING_UPDATE, raise_exception=True)
 
-        try:
-            LOG.info("Sending failover request for amphora %s to the queue",
-                     self.amp_id)
-            payload = {constants.AMPHORA_ID: db_amp.id}
-            self.client.cast({}, 'failover_amphora', **payload)
-        except Exception:
-            with excutils.save_and_reraise_exception(reraise=False):
-                self.repositories.load_balancer.update(
-                    context.session, db_amp.load_balancer.id,
-                    provisioning_status=constants.ERROR)
+            try:
+                LOG.info("Sending failover request for amphora %s to the "
+                         "queue", self.amp_id)
+                payload = {constants.AMPHORA_ID: db_amp.id}
+                self.client.cast({}, 'failover_amphora', **payload)
+            except Exception:
+                with excutils.save_and_reraise_exception(reraise=False):
+                    self.repositories.load_balancer.update(
+                        context.session, db_amp.load_balancer.id,
+                        provisioning_status=constants.ERROR)
 
 
 class AmphoraUpdateController(base.BaseController):
@@ -170,12 +169,8 @@ class AmphoraUpdateController(base.BaseController):
     def __init__(self, amp_id):
         super().__init__()
 
-        if CONF.api_settings.default_provider_driver == constants.AMPHORAV1:
-            topic = cfg.CONF.oslo_messaging.topic
-            version = "1.0"
-        else:
-            topic = constants.TOPIC_AMPHORA_V2
-            version = "2.0"
+        topic = constants.TOPIC_AMPHORA_V2
+        version = "2.0"
         self.target = messaging.Target(
             namespace=constants.RPC_NAMESPACE_CONTROLLER_AGENT,
             topic=topic, version=version, fanout=False)
@@ -187,8 +182,9 @@ class AmphoraUpdateController(base.BaseController):
         """Update amphora agent configuration"""
         pcontext = pecan_request.context
         context = pcontext.get('octavia_context')
-        db_amp = self._get_db_amp(context.session, self.amp_id,
-                                  show_deleted=False)
+        with context.session.begin():
+            db_amp = self._get_db_amp(context.session, self.amp_id,
+                                      show_deleted=False)
 
         self._auth_validate_action(
             context, db_amp.load_balancer.project_id,
@@ -220,8 +216,9 @@ class AmphoraStatsController(base.BaseController):
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_GET_STATS)
 
-        stats = self.repositories.get_amphora_stats(context.session,
-                                                    self.amp_id)
+        with context.session.begin():
+            stats = self.repositories.get_amphora_stats(context.session,
+                                                        self.amp_id)
         if not stats:
             raise exceptions.NotFound(resource='Amphora stats for',
                                       id=self.amp_id)

octavia/api/v2/controllers/availability_zone_profiles.py

@@ -28,7 +28,6 @@ from octavia.api.v2.controllers import base
 from octavia.api.v2.types import availability_zone_profile as profile_types
 from octavia.common import constants
 from octavia.common import exceptions
-from octavia.db import api as db_api
 
 LOG = logging.getLogger(__name__)
 
@@ -49,8 +48,9 @@ class AvailabilityZoneProfileController(base.BaseController):
         if id == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Availability Zone Profile',
                                       id=constants.NIL_UUID)
-        db_availability_zone_profile = self._get_db_availability_zone_profile(
-            context.session, id)
+        with context.session.begin():
+            db_availability_zone_profile = (
+                self._get_db_availability_zone_profile(context.session, id))
         result = self._convert_db_to_type(
             db_availability_zone_profile,
             profile_types.AvailabilityZoneProfileResponse)
@@ -67,10 +67,12 @@ class AvailabilityZoneProfileController(base.BaseController):
         context = pcontext.get('octavia_context')
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_GET_ALL)
-        db_availability_zone_profiles, links = (
-            self.repositories.availability_zone_profile.get_all(
-                context.session,
-                pagination_helper=pcontext.get(constants.PAGINATION_HELPER)))
+        with context.session.begin():
+            db_availability_zone_profiles, links = (
+                self.repositories.availability_zone_profile.get_all(
+                    context.session,
+                    pagination_helper=pcontext.get(
+                        constants.PAGINATION_HELPER)))
         result = self._convert_db_to_type(
             db_availability_zone_profiles,
             [profile_types.AvailabilityZoneProfileResponse])
@@ -106,21 +108,21 @@ class AvailabilityZoneProfileController(base.BaseController):
             driver.name, driver.validate_availability_zone,
             availability_zone_data_dict)
 
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             availability_zone_profile_dict = availability_zone_profile.to_dict(
                 render_unsets=True)
             availability_zone_profile_dict['id'] = uuidutils.generate_uuid()
             db_availability_zone_profile = (
                 self.repositories.availability_zone_profile.create(
-                    lock_session, **availability_zone_profile_dict))
-            lock_session.commit()
+                    context.session, **availability_zone_profile_dict))
+            context.session.commit()
         except odb_exceptions.DBDuplicateEntry as e:
-            lock_session.rollback()
+            context.session.rollback()
             raise exceptions.IDAlreadyExists() from e
         except Exception:
             with excutils.save_and_reraise_exception():
-                lock_session.rollback()
+                context.session.rollback()
         result = self._convert_db_to_type(
             db_availability_zone_profile,
             profile_types.AvailabilityZoneProfileResponse)
@@ -159,7 +161,8 @@ class AvailabilityZoneProfileController(base.BaseController):
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_PUT)
 
-        self._validate_update_azp(context, id, availability_zone_profile)
+        with context.session.begin():
+            self._validate_update_azp(context, id, availability_zone_profile)
         if id == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Availability Zone Profile',
                                       id=constants.NIL_UUID)
@@ -177,9 +180,10 @@ class AvailabilityZoneProfileController(base.BaseController):
 
             if isinstance(availability_zone_profile.provider_name,
                           wtypes.UnsetType):
-                db_availability_zone_profile = (
-                    self._get_db_availability_zone_profile(
-                        context.session, id))
+                with context.session.begin():
+                    db_availability_zone_profile = (
+                        self._get_db_availability_zone_profile(
+                            context.session, id))
                 provider_driver = db_availability_zone_profile.provider_name
             else:
                 provider_driver = availability_zone_profile.provider_name
@@ -190,23 +194,25 @@ class AvailabilityZoneProfileController(base.BaseController):
                 driver.name, driver.validate_availability_zone,
                 availability_zone_data_dict)
 
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             availability_zone_profile_dict = availability_zone_profile.to_dict(
                 render_unsets=False)
             if availability_zone_profile_dict:
                 self.repositories.availability_zone_profile.update(
-                    lock_session, id, **availability_zone_profile_dict)
-            lock_session.commit()
+                    context.session, id, **availability_zone_profile_dict)
+            context.session.commit()
         except Exception:
             with excutils.save_and_reraise_exception():
-                lock_session.rollback()
+                context.session.rollback()
 
         # Force SQL alchemy to query the DB, otherwise we get inconsistent
         # results
         context.session.expire_all()
-        db_availability_zone_profile = self._get_db_availability_zone_profile(
-            context.session, id)
+        with context.session.begin():
+            db_availability_zone_profile = (
+                self._get_db_availability_zone_profile(context.session,
+                                                       id))
         result = self._convert_db_to_type(
             db_availability_zone_profile,
             profile_types.AvailabilityZoneProfileResponse)
@@ -224,14 +230,18 @@ class AvailabilityZoneProfileController(base.BaseController):
             raise exceptions.NotFound(resource='Availability Zone Profile',
                                       id=constants.NIL_UUID)
         # Don't allow it to be deleted if it is in use by an availability zone
-        if self.repositories.availability_zone.count(
-                context.session,
-                availability_zone_profile_id=availability_zone_profile_id) > 0:
-            raise exceptions.ObjectInUse(object='Availability Zone Profile',
-                                         id=availability_zone_profile_id)
-        try:
-            self.repositories.availability_zone_profile.delete(
-                context.session, id=availability_zone_profile_id)
-        except sa_exception.NoResultFound as e:
-            raise exceptions.NotFound(resource='Availability Zone Profile',
-                                      id=availability_zone_profile_id) from e
+        with context.session.begin():
+            if self.repositories.availability_zone.count(
+                    context.session,
+                    availability_zone_profile_id=availability_zone_profile_id
+            ) > 0:
+                raise exceptions.ObjectInUse(
+                    object='Availability Zone Profile',
+                    id=availability_zone_profile_id)
+            try:
+                self.repositories.availability_zone_profile.delete(
+                    context.session, id=availability_zone_profile_id)
+            except sa_exception.NoResultFound as e:
+                raise exceptions.NotFound(
+                    resource='Availability Zone Profile',
+                    id=availability_zone_profile_id) from e

octavia/api/v2/controllers/availability_zones.py

@@ -46,8 +46,9 @@ class AvailabilityZonesController(base.BaseController):
         if name == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Availability Zone',
                                       id=constants.NIL_UUID)
-        db_availability_zone = self._get_db_availability_zone(
-            context.session, name)
+        with context.session.begin():
+            db_availability_zone = self._get_db_availability_zone(
+                context.session, name)
         result = self._convert_db_to_type(
             db_availability_zone,
             availability_zone_types.AvailabilityZoneResponse)
@@ -64,10 +65,12 @@ class AvailabilityZonesController(base.BaseController):
         context = pcontext.get('octavia_context')
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_GET_ALL)
-        db_availability_zones, links = (
-            self.repositories.availability_zone.get_all(
-                context.session,
-                pagination_helper=pcontext.get(constants.PAGINATION_HELPER)))
+        with context.session.begin():
+            db_availability_zones, links = (
+                self.repositories.availability_zone.get_all(
+                    context.session,
+                    pagination_helper=pcontext.get(
+                        constants.PAGINATION_HELPER)))
         result = self._convert_db_to_type(
             db_availability_zones,
             [availability_zone_types.AvailabilityZoneResponse])
@@ -86,20 +89,20 @@ class AvailabilityZonesController(base.BaseController):
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_POST)
 
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             availability_zone_dict = availability_zone.to_dict(
                 render_unsets=True)
             db_availability_zone = self.repositories.availability_zone.create(
-                lock_session, **availability_zone_dict)
-            lock_session.commit()
+                context.session, **availability_zone_dict)
+            context.session.commit()
         except odb_exceptions.DBDuplicateEntry as e:
-            lock_session.rollback()
+            context.session.rollback()
             raise exceptions.RecordAlreadyExists(
                 field='availability zone', name=availability_zone.name) from e
         except Exception:
             with excutils.save_and_reraise_exception():
-                lock_session.rollback()
+                context.session.rollback()
         result = self._convert_db_to_type(
             db_availability_zone,
             availability_zone_types.AvailabilityZoneResponse)
@@ -117,23 +120,24 @@ class AvailabilityZonesController(base.BaseController):
         if name == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Availability Zone',
                                       id=constants.NIL_UUID)
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             availability_zone_dict = availability_zone.to_dict(
                 render_unsets=False)
             if availability_zone_dict:
                 self.repositories.availability_zone.update(
-                    lock_session, name, **availability_zone_dict)
-            lock_session.commit()
+                    context.session, name, **availability_zone_dict)
+            context.session.commit()
         except Exception:
             with excutils.save_and_reraise_exception():
-                lock_session.rollback()
+                context.session.rollback()
 
         # Force SQL alchemy to query the DB, otherwise we get inconsistent
         # results
         context.session.expire_all()
-        db_availability_zone = self._get_db_availability_zone(
-            context.session, name)
+        with context.session.begin():
+            db_availability_zone = self._get_db_availability_zone(
+                context.session, name)
         result = self._convert_db_to_type(
             db_availability_zone,
             availability_zone_types.AvailabilityZoneResponse)
@@ -151,7 +155,7 @@ class AvailabilityZonesController(base.BaseController):
         if availability_zone_name == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Availability Zone',
                                       id=constants.NIL_UUID)
-        serial_session = db_api.get_session(autocommit=False)
+        serial_session = db_api.get_session()
         serial_session.connection(
             execution_options={'isolation_level': 'SERIALIZABLE'})
         try: