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

octavia/api/v2/controllers/flavor_profiles.py

@@ -29,7 +29,6 @@ from octavia.api.v2.controllers import base
 from octavia.api.v2.types import flavor_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__)
 
@@ -50,7 +49,9 @@ class FlavorProfileController(base.BaseController):
         if id == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Flavor profile',
                                       id=constants.NIL_UUID)
-        db_flavor_profile = self._get_db_flavor_profile(context.session, id)
+        with context.session.begin():
+            db_flavor_profile = self._get_db_flavor_profile(context.session,
+                                                            id)
         result = self._convert_db_to_type(db_flavor_profile,
                                           profile_types.FlavorProfileResponse)
         if fields is not None:
@@ -65,9 +66,12 @@ class FlavorProfileController(base.BaseController):
         context = pcontext.get('octavia_context')
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_GET_ALL)
-        db_flavor_profiles, links = self.repositories.flavor_profile.get_all(
-            context.session,
-            pagination_helper=pcontext.get(constants.PAGINATION_HELPER))
+        with context.session.begin():
+            db_flavor_profiles, links = (
+                self.repositories.flavor_profile.get_all(
+                    context.session,
+                    pagination_helper=pcontext.get(
+                        constants.PAGINATION_HELPER)))
         result = self._convert_db_to_type(
             db_flavor_profiles, [profile_types.FlavorProfileResponse])
         if fields is not None:
@@ -97,19 +101,19 @@ class FlavorProfileController(base.BaseController):
         driver_utils.call_provider(driver.name, driver.validate_flavor,
                                    flavor_data_dict)
 
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             flavorprofile_dict = flavorprofile.to_dict(render_unsets=True)
             flavorprofile_dict['id'] = uuidutils.generate_uuid()
             db_flavor_profile = self.repositories.flavor_profile.create(
-                lock_session, **flavorprofile_dict)
-            lock_session.commit()
+                context.session, **flavorprofile_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_flavor_profile, profile_types.FlavorProfileResponse)
         return profile_types.FlavorProfileRootResponse(flavorprofile=result)
@@ -142,7 +146,8 @@ class FlavorProfileController(base.BaseController):
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_PUT)
 
-        self._validate_update_fp(context, id, flavorprofile)
+        with context.session.begin():
+            self._validate_update_fp(context, id, flavorprofile)
         if id == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Flavor profile',
                                       id=constants.NIL_UUID)
@@ -157,8 +162,9 @@ class FlavorProfileController(base.BaseController):
                     option=constants.FLAVOR_DATA) from e
 
             if isinstance(flavorprofile.provider_name, wtypes.UnsetType):
-                db_flavor_profile = self._get_db_flavor_profile(
-                    context.session, id)
+                with context.session.begin():
+                    db_flavor_profile = self._get_db_flavor_profile(
+                        context.session, id)
                 provider_driver = db_flavor_profile.provider_name
             else:
                 provider_driver = flavorprofile.provider_name
@@ -168,21 +174,23 @@ class FlavorProfileController(base.BaseController):
             driver_utils.call_provider(driver.name, driver.validate_flavor,
                                        flavor_data_dict)
 
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             flavorprofile_dict = flavorprofile.to_dict(render_unsets=False)
             if flavorprofile_dict:
-                self.repositories.flavor_profile.update(lock_session, id,
+                self.repositories.flavor_profile.update(context.session, id,
                                                         **flavorprofile_dict)
-            lock_session.commit()
+            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_flavor_profile = self._get_db_flavor_profile(context.session, id)
+        with context.session.begin():
+            db_flavor_profile = self._get_db_flavor_profile(context.session,
+                                                            id)
         result = self._convert_db_to_type(
             db_flavor_profile, profile_types.FlavorProfileResponse)
         return profile_types.FlavorProfileRootResponse(flavorprofile=result)
@@ -200,13 +208,14 @@ class FlavorProfileController(base.BaseController):
                                       id=constants.NIL_UUID)
 
         # Don't allow it to be deleted if it is in use by a flavor
-        if self.repositories.flavor.count(
-                context.session, flavor_profile_id=flavor_profile_id) > 0:
-            raise exceptions.ObjectInUse(object='Flavor profile',
-                                         id=flavor_profile_id)
-        try:
-            self.repositories.flavor_profile.delete(context.session,
-                                                    id=flavor_profile_id)
-        except sa_exception.NoResultFound as e:
-            raise exceptions.NotFound(
-                resource='Flavor profile', id=flavor_profile_id) from e
+        with context.session.begin():
+            if self.repositories.flavor.count(
+                    context.session, flavor_profile_id=flavor_profile_id) > 0:
+                raise exceptions.ObjectInUse(object='Flavor profile',
+                                             id=flavor_profile_id)
+            try:
+                self.repositories.flavor_profile.delete(context.session,
+                                                        id=flavor_profile_id)
+            except sa_exception.NoResultFound as e:
+                raise exceptions.NotFound(
+                    resource='Flavor profile', id=flavor_profile_id) from e

octavia/api/v2/controllers/flavors.py

@@ -47,7 +47,8 @@ class FlavorsController(base.BaseController):
                                    constants.RBAC_GET_ONE)
         if id == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Flavor', id=constants.NIL_UUID)
-        db_flavor = self._get_db_flavor(context.session, id)
+        with context.session.begin():
+            db_flavor = self._get_db_flavor(context.session, id)
         result = self._convert_db_to_type(db_flavor,
                                           flavor_types.FlavorResponse)
         if fields is not None:
@@ -62,9 +63,10 @@ class FlavorsController(base.BaseController):
         context = pcontext.get('octavia_context')
         self._auth_validate_action(context, context.project_id,
                                    constants.RBAC_GET_ALL)
-        db_flavors, links = self.repositories.flavor.get_all(
-            context.session,
-            pagination_helper=pcontext.get(constants.PAGINATION_HELPER))
+        with context.session.begin():
+            db_flavors, links = self.repositories.flavor.get_all(
+                context.session,
+                pagination_helper=pcontext.get(constants.PAGINATION_HELPER))
         result = self._convert_db_to_type(
             db_flavors, [flavor_types.FlavorResponse])
         if fields is not None:
@@ -83,20 +85,20 @@ class FlavorsController(base.BaseController):
 
         # TODO(johnsom) Validate the flavor profile ID
 
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             flavor_dict = flavor.to_dict(render_unsets=True)
             flavor_dict['id'] = uuidutils.generate_uuid()
-            db_flavor = self.repositories.flavor.create(lock_session,
+            db_flavor = self.repositories.flavor.create(context.session,
                                                         **flavor_dict)
-            lock_session.commit()
+            context.session.commit()
         except odb_exceptions.DBDuplicateEntry as e:
-            lock_session.rollback()
+            context.session.rollback()
             raise exceptions.RecordAlreadyExists(field='flavor',
                                                  name=flavor.name) from e
         except Exception:
             with excutils.save_and_reraise_exception():
-                lock_session.rollback()
+                context.session.rollback()
         result = self._convert_db_to_type(db_flavor,
                                           flavor_types.FlavorResponse)
         return flavor_types.FlavorRootResponse(flavor=result)
@@ -111,21 +113,22 @@ class FlavorsController(base.BaseController):
                                    constants.RBAC_PUT)
         if id == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Flavor', id=constants.NIL_UUID)
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             flavor_dict = flavor.to_dict(render_unsets=False)
             if flavor_dict:
-                self.repositories.flavor.update(lock_session, id,
+                self.repositories.flavor.update(context.session, id,
                                                 **flavor_dict)
-            lock_session.commit()
+            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_flavor = self._get_db_flavor(context.session, id)
+        with context.session.begin():
+            db_flavor = self._get_db_flavor(context.session, id)
         result = self._convert_db_to_type(db_flavor,
                                           flavor_types.FlavorResponse)
         return flavor_types.FlavorRootResponse(flavor=result)
@@ -140,7 +143,8 @@ class FlavorsController(base.BaseController):
                                    constants.RBAC_DELETE)
         if flavor_id == constants.NIL_UUID:
             raise exceptions.NotFound(resource='Flavor', id=constants.NIL_UUID)
-        serial_session = db_api.get_session(autocommit=False)
+        serial_session = db_api.get_session()
+        serial_session.begin()
         serial_session.connection(
             execution_options={'isolation_level': 'SERIALIZABLE'})
         try:

octavia/api/v2/controllers/health_monitor.py

@@ -30,7 +30,6 @@ from octavia.api.v2.types import health_monitor as hm_types
 from octavia.common import constants as consts
 from octavia.common import data_models
 from octavia.common import exceptions
-from octavia.db import api as db_api
 from octavia.db import prepare as db_prepare
 from octavia.i18n import _
 
@@ -50,7 +49,8 @@ class HealthMonitorController(base.BaseController):
     def get_one(self, id, fields=None):
         """Gets a single healthmonitor's details."""
         context = pecan_request.context.get('octavia_context')
-        db_hm = self._get_db_hm(context.session, id, show_deleted=False)
+        with context.session.begin():
+            db_hm = self._get_db_hm(context.session, id, show_deleted=False)
 
         self._auth_validate_action(context, db_hm.project_id,
                                    consts.RBAC_GET_ONE)
@@ -70,10 +70,11 @@ class HealthMonitorController(base.BaseController):
 
         query_filter = self._auth_get_all(context, project_id)
 
-        db_hm, links = self.repositories.health_monitor.get_all_API_list(
-            context.session, show_deleted=False,
-            pagination_helper=pcontext.get(consts.PAGINATION_HELPER),
-            **query_filter)
+        with context.session.begin():
+            db_hm, links = self.repositories.health_monitor.get_all_API_list(
+                context.session, show_deleted=False,
+                pagination_helper=pcontext.get(consts.PAGINATION_HELPER),
+                **query_filter)
         result = self._convert_db_to_type(
             db_hm, [hm_types.HealthMonitorResponse])
         if fields is not None:
@@ -155,8 +156,10 @@ class HealthMonitorController(base.BaseController):
                     option='health monitors HTTP 1.1 domain name health check')
 
         try:
-            return self.repositories.health_monitor.create(
+            ret = self.repositories.health_monitor.create(
                 lock_session, **hm_dict)
+            lock_session.flush()
+            return ret
         except odb_exceptions.DBDuplicateEntry as e:
             raise exceptions.DuplicateHealthMonitor() from e
         except odb_exceptions.DBReferenceError as e:
@@ -200,10 +203,12 @@ class HealthMonitorController(base.BaseController):
         context = pecan_request.context.get('octavia_context')
         health_monitor = health_monitor_.healthmonitor
 
-        pool = self._get_db_pool(context.session, health_monitor.pool_id)
+        with context.session.begin():
+            pool = self._get_db_pool(context.session, health_monitor.pool_id)
 
-        health_monitor.project_id, provider = self._get_lb_project_id_provider(
-            context.session, pool.load_balancer_id)
+            health_monitor.project_id, provider = (
+                self._get_lb_project_id_provider(context.session,
+                                                 pool.load_balancer_id))
 
         self._auth_validate_action(context, health_monitor.project_id,
                                    consts.RBAC_POST)
@@ -230,11 +235,11 @@ class HealthMonitorController(base.BaseController):
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        lock_session = db_api.get_session(autocommit=False)
+        context.session.begin()
         try:
             if self.repositories.check_quota_met(
                     context.session,
-                    lock_session,
+                    context.session,
                     data_models.HealthMonitor,
                     health_monitor.project_id):
                 raise exceptions.QuotaException(
@@ -244,8 +249,8 @@ class HealthMonitorController(base.BaseController):
                 health_monitor.to_dict(render_unsets=True))
 
             self._test_lb_and_listener_and_pool_statuses(
-                lock_session, health_monitor)
-            db_hm = self._validate_create_hm(lock_session, hm_dict)
+                context.session, health_monitor)
+            db_hm = self._validate_create_hm(context.session, hm_dict)
 
             # Prepare the data for the driver data model
             provider_healthmon = driver_utils.db_HM_to_provider_HM(db_hm)
@@ -256,16 +261,17 @@ class HealthMonitorController(base.BaseController):
             driver_utils.call_provider(
                 driver.name, driver.health_monitor_create, provider_healthmon)
 
-            lock_session.commit()
+            context.session.commit()
         except odb_exceptions.DBError as e:
-            lock_session.rollback()
+            context.session.rollback()
             raise exceptions.InvalidOption(
                 value=hm_dict.get('type'), option='type') from e
         except Exception:
             with excutils.save_and_reraise_exception():
-                lock_session.rollback()
+                context.session.rollback()
 
-        db_hm = self._get_db_hm(context.session, db_hm.id)
+        with context.session.begin():
+            db_hm = self._get_db_hm(context.session, db_hm.id)
         result = self._convert_db_to_type(
             db_hm, hm_types.HealthMonitorResponse)
         return hm_types.HealthMonitorRootResponse(healthmonitor=result)
@@ -342,11 +348,12 @@ class HealthMonitorController(base.BaseController):
         """Updates a health monitor."""
         context = pecan_request.context.get('octavia_context')
         health_monitor = health_monitor_.healthmonitor
-        db_hm = self._get_db_hm(context.session, id, show_deleted=False)
+        with context.session.begin():
+            db_hm = self._get_db_hm(context.session, id, show_deleted=False)
 
-        pool = self._get_db_pool(context.session, db_hm.pool_id)
-        project_id, provider = self._get_lb_project_id_provider(
-            context.session, pool.load_balancer_id)
+            pool = self._get_db_pool(context.session, db_hm.pool_id)
+            project_id, provider = self._get_lb_project_id_provider(
+                context.session, pool.load_balancer_id)
 
         self._auth_validate_action(context, project_id, consts.RBAC_PUT)
 
@@ -363,9 +370,10 @@ class HealthMonitorController(base.BaseController):
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        with db_api.get_lock_session() as lock_session:
+        with context.session.begin():
 
-            self._test_lb_and_listener_and_pool_statuses(lock_session, db_hm)
+            self._test_lb_and_listener_and_pool_statuses(context.session,
+                                                         db_hm)
 
             # Prepare the data for the driver data model
             healthmon_dict = health_monitor.to_dict(render_unsets=False)
@@ -387,13 +395,14 @@ class HealthMonitorController(base.BaseController):
             # Update the database to reflect what the driver just accepted
             health_monitor.provisioning_status = consts.PENDING_UPDATE
             db_hm_dict = health_monitor.to_dict(render_unsets=False)
-            self.repositories.health_monitor.update(lock_session, id,
+            self.repositories.health_monitor.update(context.session, id,
                                                     **db_hm_dict)
 
         # Force SQL alchemy to query the DB, otherwise we get inconsistent
         # results
         context.session.expire_all()
-        db_hm = self._get_db_hm(context.session, id)
+        with context.session.begin():
+            db_hm = self._get_db_hm(context.session, id)
         result = self._convert_db_to_type(
             db_hm, hm_types.HealthMonitorResponse)
         return hm_types.HealthMonitorRootResponse(healthmonitor=result)
@@ -402,11 +411,12 @@ class HealthMonitorController(base.BaseController):
     def delete(self, id):
         """Deletes a health monitor."""
         context = pecan_request.context.get('octavia_context')
-        db_hm = self._get_db_hm(context.session, id, show_deleted=False)
+        with context.session.begin():
+            db_hm = self._get_db_hm(context.session, id, show_deleted=False)
 
-        pool = self._get_db_pool(context.session, db_hm.pool_id)
-        project_id, provider = self._get_lb_project_id_provider(
-            context.session, pool.load_balancer_id)
+            pool = self._get_db_pool(context.session, db_hm.pool_id)
+            project_id, provider = self._get_lb_project_id_provider(
+                context.session, pool.load_balancer_id)
 
         self._auth_validate_action(context, project_id, consts.RBAC_DELETE)
 
@@ -416,12 +426,13 @@ class HealthMonitorController(base.BaseController):
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        with db_api.get_lock_session() as lock_session:
+        with context.session.begin():
 
-            self._test_lb_and_listener_and_pool_statuses(lock_session, db_hm)
+            self._test_lb_and_listener_and_pool_statuses(context.session,
+                                                         db_hm)
 
             self.repositories.health_monitor.update(
-                lock_session, db_hm.id,
+                context.session, db_hm.id,
                 provisioning_status=consts.PENDING_DELETE)
 
             LOG.info("Sending delete Health Monitor %s to provider %s",

octavia/api/v2/controllers/l7policy.py

@@ -32,7 +32,6 @@ from octavia.common import constants
 from octavia.common import data_models
 from octavia.common import exceptions
 from octavia.common import validate
-from octavia.db import api as db_api
 from octavia.db import prepare as db_prepare
 
 
@@ -51,8 +50,9 @@ class L7PolicyController(base.BaseController):
     def get(self, id, fields=None):
         """Gets a single l7policy's details."""
         context = pecan_request.context.get('octavia_context')
-        db_l7policy = self._get_db_l7policy(context.session, id,
-                                            show_deleted=False)
+        with context.session.begin():
+            db_l7policy = self._get_db_l7policy(context.session, id,
+                                                show_deleted=False)
 
         self._auth_validate_action(context, db_l7policy.project_id,
                                    constants.RBAC_GET_ONE)
@@ -72,10 +72,11 @@ class L7PolicyController(base.BaseController):
 
         query_filter = self._auth_get_all(context, project_id)
 
-        db_l7policies, links = self.repositories.l7policy.get_all_API_list(
-            context.session, show_deleted=False,
-            pagination_helper=pcontext.get(constants.PAGINATION_HELPER),
-            **query_filter)
+        with context.session.begin():
+            db_l7policies, links = self.repositories.l7policy.get_all_API_list(
+                context.session, show_deleted=False,
+                pagination_helper=pcontext.get(constants.PAGINATION_HELPER),
+                **query_filter)
         result = self._convert_db_to_type(
             db_l7policies, [l7policy_types.L7PolicyResponse])
         if fields is not None:
@@ -121,11 +122,12 @@ class L7PolicyController(base.BaseController):
 
         # Verify the parent listener exists
         listener_id = l7policy.listener_id
-        listener = self._get_db_listener(
-            context.session, listener_id)
-        load_balancer_id = listener.load_balancer_id
-        l7policy.project_id, provider = self._get_lb_project_id_provider(
-            context.session, load_balancer_id)
+        with context.session.begin():
+            listener = self._get_db_listener(
+                context.session, listener_id)
+            load_balancer_id = listener.load_balancer_id
+            l7policy.project_id, provider = self._get_lb_project_id_provider(
+                context.session, load_balancer_id)
 
         self._auth_validate_action(context, l7policy.project_id,
                                    constants.RBAC_POST)
@@ -137,14 +139,16 @@ class L7PolicyController(base.BaseController):
 
         # Make sure any pool specified by redirect_pool_id exists
         if l7policy.redirect_pool_id:
-            db_pool = self._get_db_pool(
-                context.session, l7policy.redirect_pool_id)
+            with context.session.begin():
+                db_pool = self._get_db_pool(
+                    context.session, l7policy.redirect_pool_id)
             self._validate_protocol(listener.protocol, db_pool.protocol)
 
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        lock_session = db_api.get_session(autocommit=False)
+        lock_session = context.session
+        lock_session.begin()
         try:
             if self.repositories.check_quota_met(
                     context.session,
@@ -179,7 +183,9 @@ class L7PolicyController(base.BaseController):
             with excutils.save_and_reraise_exception():
                 lock_session.rollback()
 
-        db_l7policy = self._get_db_l7policy(context.session, db_l7policy.id)
+        with context.session.begin():
+            db_l7policy = self._get_db_l7policy(context.session,
+                                                db_l7policy.id)
         result = self._convert_db_to_type(db_l7policy,
                                           l7policy_types.L7PolicyResponse)
         return l7policy_types.L7PolicyRootResponse(l7policy=result)
@@ -209,12 +215,13 @@ class L7PolicyController(base.BaseController):
         """Updates a l7policy."""
         l7policy = l7policy_.l7policy
         context = pecan_request.context.get('octavia_context')
-        db_l7policy = self._get_db_l7policy(context.session, id,
-                                            show_deleted=False)
-        load_balancer_id, listener_id = self._get_listener_and_loadbalancer_id(
-            db_l7policy)
-        project_id, provider = self._get_lb_project_id_provider(
-            context.session, load_balancer_id)
+        with context.session.begin():
+            db_l7policy = self._get_db_l7policy(context.session, id,
+                                                show_deleted=False)
+            load_balancer_id, listener_id = (
+                self._get_listener_and_loadbalancer_id(db_l7policy))
+            project_id, provider = self._get_lb_project_id_provider(
+                context.session, load_balancer_id)
 
         self._auth_validate_action(context, project_id, constants.RBAC_PUT)
 
@@ -226,18 +233,21 @@ class L7PolicyController(base.BaseController):
                 l7policy_dict[attr] = l7policy_dict.pop(val)
         sanitized_l7policy = l7policy_types.L7PolicyPUT(**l7policy_dict)
 
-        listener = self._get_db_listener(
-            context.session, db_l7policy.listener_id)
+        with context.session.begin():
+            listener = self._get_db_listener(
+                context.session, db_l7policy.listener_id)
         # Make sure any specified redirect_pool_id exists
         if l7policy_dict.get('redirect_pool_id'):
-            db_pool = self._get_db_pool(
-                context.session, l7policy_dict['redirect_pool_id'])
+            with context.session.begin():
+                db_pool = self._get_db_pool(
+                    context.session, l7policy_dict['redirect_pool_id'])
             self._validate_protocol(listener.protocol, db_pool.protocol)
 
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        with db_api.get_lock_session() as lock_session:
+        with context.session.begin():
+            lock_session = context.session
 
             self._test_lb_and_listener_statuses(lock_session,
                                                 lb_id=load_balancer_id,
@@ -270,7 +280,8 @@ class L7PolicyController(base.BaseController):
         # Force SQL alchemy to query the DB, otherwise we get inconsistent
         # results
         context.session.expire_all()
-        db_l7policy = self._get_db_l7policy(context.session, id)
+        with context.session.begin():
+            db_l7policy = self._get_db_l7policy(context.session, id)
         result = self._convert_db_to_type(db_l7policy,
                                           l7policy_types.L7PolicyResponse)
         return l7policy_types.L7PolicyRootResponse(l7policy=result)
@@ -279,12 +290,13 @@ class L7PolicyController(base.BaseController):
     def delete(self, id):
         """Deletes a l7policy."""
         context = pecan_request.context.get('octavia_context')
-        db_l7policy = self._get_db_l7policy(context.session, id,
-                                            show_deleted=False)
-        load_balancer_id, listener_id = self._get_listener_and_loadbalancer_id(
-            db_l7policy)
-        project_id, provider = self._get_lb_project_id_provider(
-            context.session, load_balancer_id)
+        with context.session.begin():
+            db_l7policy = self._get_db_l7policy(context.session, id,
+                                                show_deleted=False)
+            load_balancer_id, listener_id = (
+                self._get_listener_and_loadbalancer_id(db_l7policy))
+            project_id, provider = self._get_lb_project_id_provider(
+                context.session, load_balancer_id)
 
         self._auth_validate_action(context, project_id, constants.RBAC_DELETE)
 
@@ -294,13 +306,12 @@ class L7PolicyController(base.BaseController):
         # Load the driver early as it also provides validation
         driver = driver_factory.get_driver(provider)
 
-        with db_api.get_lock_session() as lock_session:
-
-            self._test_lb_and_listener_statuses(lock_session,
+        with context.session.begin():
+            self._test_lb_and_listener_statuses(context.session,
                                                 lb_id=load_balancer_id,
                                                 listener_ids=[listener_id])
             self.repositories.l7policy.update(
-                lock_session, db_l7policy.id,
+                context.session, db_l7policy.id,
                 provisioning_status=constants.PENDING_DELETE)
 
             LOG.info("Sending delete L7 Policy %s to provider %s",
@@ -320,8 +331,9 @@ class L7PolicyController(base.BaseController):
         context = pecan_request.context.get('octavia_context')
         if l7policy_id and remainder and remainder[0] == 'rules':
             remainder = remainder[1:]
-            db_l7policy = self.repositories.l7policy.get(
-                context.session, id=l7policy_id)
+            with context.session.begin():
+                db_l7policy = self.repositories.l7policy.get(
+                    context.session, id=l7policy_id)
             if not db_l7policy:
                 LOG.info("L7Policy %s not found.", l7policy_id)
                 raise exceptions.NotFound(