Replace usage of LegacyEngineFacade

Switch to using oslo_db.sqlalchemy.enginefacade instead, as this is
required for SQLAlchemy 2.x support.

Change-Id: Ifcad28239b6907b8ca396d348cbfa54185355f68

Author: MoteHue

cloudkitty/common/db/alembic/env.py

@@ -32,10 +32,11 @@ def run_migrations_online(target_metadata, version_table):
     :param target_metadata: Model's metadata used for autogenerate support.
     :param version_table: Override the default version table for alembic.
     """
-    engine = db.get_engine()
-    with engine.connect() as connection:
-        context.configure(connection=connection,
-                          target_metadata=target_metadata,
-                          version_table=version_table)
-        with context.begin_transaction():
-            context.run_migrations()
+    with db.session_for_write() as session:
+        engine = session.get_bind()
+        with engine.connect() as connection:
+            context.configure(connection=connection,
+                              target_metadata=target_metadata,
+                              version_table=version_table)
+            with context.begin_transaction():
+                context.run_migrations()

cloudkitty/db/__init__.py

@@ -13,28 +13,26 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 #
-from oslo_config import cfg
-from oslo_db.sqlalchemy import session
+import threading
 
+from oslo_db.sqlalchemy import enginefacade
+
+_CONTEXT = threading.local()
 _FACADE = None
 
 
 def _create_facade_lazily():
     global _FACADE
     if _FACADE is None:
-        # FIXME(priteau): Remove autocommit=True (and ideally use of
-        # LegacyEngineFacade) asap since it's not compatible with SQLAlchemy
-        # 2.0.
-        _FACADE = session.EngineFacade.from_config(cfg.CONF, sqlite_fk=True,
-                                                   autocommit=True)
+        ctx = enginefacade.transaction_context()
+        ctx.configure(sqlite_fk=True)
+        _FACADE = ctx
     return _FACADE
 
 
-def get_engine():
-    facade = _create_facade_lazily()
-    return facade.get_engine()
+def session_for_read():
+    return _create_facade_lazily().reader.using(_CONTEXT)
 
 
-def get_session(**kwargs):
-    facade = _create_facade_lazily()
-    return facade.get_session(**kwargs)
+def session_for_write():
+    return _create_facade_lazily().writer.using(_CONTEXT)

cloudkitty/db/sqlalchemy/api.py

@@ -30,16 +30,15 @@ def get_backend():
 class State(api.State):
 
     def get_state(self, name):
-        session = db.get_session()
-        q = utils.model_query(
-            models.StateInfo,
-            session)
-        q = q.filter(models.StateInfo.name == name)
-        return q.value(models.StateInfo.state)
+        with db.session_for_read() as session:
+            q = utils.model_query(
+                models.StateInfo,
+                session)
+            q = q.filter(models.StateInfo.name == name)
+            return q.value(models.StateInfo.state)
 
     def set_state(self, name, state):
-        session = db.get_session()
-        with session.begin():
+        with db.session_for_write() as session:
             try:
                 q = utils.model_query(
                     models.StateInfo,
@@ -55,16 +54,15 @@ def set_state(self, name, state):
         return db_state.state
 
     def get_metadata(self, name):
-        session = db.get_session()
-        q = utils.model_query(
-            models.StateInfo,
-            session)
-        q.filter(models.StateInfo.name == name)
-        return q.value(models.StateInfo.s_metadata)
+        with db.session_for_read() as session:
+            q = utils.model_query(
+                models.StateInfo,
+                session)
+            q.filter(models.StateInfo.name == name)
+            return q.value(models.StateInfo.s_metadata)
 
     def set_metadata(self, name, metadata):
-        session = db.get_session()
-        with session.begin():
+        with db.session_for_write() as session:
             try:
                 q = utils.model_query(
                     models.StateInfo,
@@ -83,20 +81,19 @@ class ModuleInfo(api.ModuleInfo):
     """Base class for module info management."""
 
     def get_priority(self, name):
-        session = db.get_session()
-        q = utils.model_query(
-            models.ModuleStateInfo,
-            session)
-        q = q.filter(models.ModuleStateInfo.name == name)
-        res = q.value(models.ModuleStateInfo.priority)
-        if res:
-            return int(res)
-        else:
-            return 1
+        with db.session_for_read() as session:
+            q = utils.model_query(
+                models.ModuleStateInfo,
+                session)
+            q = q.filter(models.ModuleStateInfo.name == name)
+            res = q.value(models.ModuleStateInfo.priority)
+            if res:
+                return int(res)
+            else:
+                return 1
 
     def set_priority(self, name, priority):
-        session = db.get_session()
-        with session.begin():
+        with db.session_for_write() as session:
             try:
                 q = utils.model_query(
                     models.ModuleStateInfo,
@@ -113,20 +110,19 @@ def set_priority(self, name, priority):
         return int(db_state.priority)
 
     def get_state(self, name):
-        session = db.get_session()
-        try:
-            q = utils.model_query(
-                models.ModuleStateInfo,
-                session)
-            q = q.filter(models.ModuleStateInfo.name == name)
-            res = q.value(models.ModuleStateInfo.state)
-            return bool(res)
-        except sqlalchemy.orm.exc.NoResultFound:
-            return None
+        with db.session_for_read() as session:
+            try:
+                q = utils.model_query(
+                    models.ModuleStateInfo,
+                    session)
+                q = q.filter(models.ModuleStateInfo.name == name)
+                res = q.value(models.ModuleStateInfo.state)
+                return bool(res)
+            except sqlalchemy.orm.exc.NoResultFound:
+                return None
 
     def set_state(self, name, state):
-        session = db.get_session()
-        with session.begin():
+        with db.session_for_write() as session:
             try:
                 q = utils.model_query(
                     models.ModuleStateInfo,
@@ -145,20 +141,19 @@ class ServiceToCollectorMapping(object):
     """Base class for service to collector mapping."""
 
     def get_mapping(self, service):
-        session = db.get_session()
-        try:
-            q = utils.model_query(
-                models.ServiceToCollectorMapping,
-                session)
-            q = q.filter(
-                models.ServiceToCollectorMapping.service == service)
-            return q.one()
-        except sqlalchemy.orm.exc.NoResultFound:
-            raise api.NoSuchMapping(service)
+        with db.session_for_read() as session:
+            try:
+                q = utils.model_query(
+                    models.ServiceToCollectorMapping,
+                    session)
+                q = q.filter(
+                    models.ServiceToCollectorMapping.service == service)
+                return q.one()
+            except sqlalchemy.orm.exc.NoResultFound:
+                raise api.NoSuchMapping(service)
 
     def set_mapping(self, service, collector):
-        session = db.get_session()
-        with session.begin():
+        with db.session_for_write() as session:
             try:
                 q = utils.model_query(
                     models.ServiceToCollectorMapping,
@@ -176,37 +171,37 @@ def set_mapping(self, service, collector):
         return db_mapping
 
     def list_services(self, collector=None):
-        session = db.get_session()
-        q = utils.model_query(
-            models.ServiceToCollectorMapping,
-            session)
-        if collector:
-            q = q.filter(
-                models.ServiceToCollectorMapping.collector == collector)
-        res = q.distinct().values(
-            models.ServiceToCollectorMapping.service)
-        return res
+        with db.session_for_read() as session:
+            q = utils.model_query(
+                models.ServiceToCollectorMapping,
+                session)
+            if collector:
+                q = q.filter(
+                    models.ServiceToCollectorMapping.collector == collector)
+            res = q.distinct().values(
+                models.ServiceToCollectorMapping.service)
+            return res
 
     def list_mappings(self, collector=None):
-        session = db.get_session()
-        q = utils.model_query(
-            models.ServiceToCollectorMapping,
-            session)
-        if collector:
-            q = q.filter(
-                models.ServiceToCollectorMapping.collector == collector)
-        res = q.all()
-        return res
+        with db.session_for_read() as session:
+            q = utils.model_query(
+                models.ServiceToCollectorMapping,
+                session)
+            if collector:
+                q = q.filter(
+                    models.ServiceToCollectorMapping.collector == collector)
+            res = q.all()
+            return res
 
     def delete_mapping(self, service):
-        session = db.get_session()
-        q = utils.model_query(
-            models.ServiceToCollectorMapping,
-            session)
-        q = q.filter(models.ServiceToCollectorMapping.service == service)
-        r = q.delete()
-        if not r:
-            raise api.NoSuchMapping(service)
+        with db.session_for_write() as session:
+            q = utils.model_query(
+                models.ServiceToCollectorMapping,
+                session)
+            q = q.filter(models.ServiceToCollectorMapping.service == service)
+            r = q.delete()
+            if not r:
+                raise api.NoSuchMapping(service)
 
 
 class DBAPIManager(object):

cloudkitty/rating/hash/db/sqlalchemy/alembic/models/f8c799db4aa0_fix_unnamed_constraints.py

@@ -29,13 +29,11 @@ class HashMapBase(models.ModelBase):
                       'mysql_engine': "InnoDB"}
     fk_to_resolve = {}
 
-    def save(self, session=None):
+    def save(self):
         from cloudkitty import db
 
-        if session is None:
-            session = db.get_session()
-
-        super(HashMapBase, self).save(session=session)
+        with db.session_for_write() as session:
+            super(HashMapBase, self).save(session=session)
 
     def as_dict(self):
         d = {}