Merge "Fix usage of oslo.config"

doc/source/usage.rst

@@ -8,6 +8,7 @@ To use oslo.db in a project::
   
   .. code:: python
 
+    from oslo.config import cfg
     from oslo.db.sqlalchemy import session as db_session
 
     _FACADE = None
@@ -15,8 +16,7 @@ To use oslo.db in a project::
     def _create_facade_lazily():
         global _FACADE
         if _FACADE is None:
-            _FACADE = db_session.EngineFacade.from_config(
+            _FACADE = db_session.EngineFacade.from_config(cfg.CONF)
-                CONF.database.connection, CONF)
         return _FACADE
 
     def get_engine():
@@ -48,12 +48,10 @@ To use oslo.db in a project::
     from oslo.config import cfg
     from oslo.db import api as db_api
 
-    CONF = cfg.CONF
-    CONF.import_opt('backend', 'oslo.db.options', group='database')
 
     _BACKEND_MAPPING = {'sqlalchemy': 'project.db.sqlalchemy.api'}
 
-    IMPL = db_api.DBAPI(CONF.database.backend, backend_mapping=_BACKEND_MAPPING)
+    IMPL = db_api.DBAPI.from_config(cfg.CONF, backend_mapping=_BACKEND_MAPPING)
 
     def get_engine():
         return IMPL.get_engine()

oslo/db/api.py

@@ -28,6 +28,7 @@ import time
 from oslo.db import exception
 from oslo.db.openstack.common.gettextutils import _LE
 from oslo.db.openstack.common import importutils
+from oslo.db import options
 
 
 LOG = logging.getLogger(__name__)
@@ -160,3 +161,29 @@ class DBAPI(object):
                 max_retry_interval=self.max_retry_interval)(attr)
 
         return attr
+
+    @classmethod
+    def from_config(cls, conf, backend_mapping=None, lazy=False):
+        """Initialize DBAPI instance given a config instance.
+
+        :param conf: oslo.config config instance
+        :type conf: oslo.config.cfg.ConfigOpts
+
+        :param backend_mapping: backend name -> module/class to load mapping
+        :type backend_mapping: dict
+
+        :param lazy: load the DB backend lazily on the first DB API method call
+        :type lazy: bool
+
+        """
+
+        conf.register_opts(options.database_opts, 'database')
+
+        return cls(backend_name=conf.database.backend,
+                   backend_mapping=backend_mapping,
+                   lazy=lazy,
+                   use_db_reconnect=conf.database.use_db_reconnect,
+                   retry_interval=conf.database.db_retry_interval,
+                   inc_retry_interval=conf.database.db_inc_retry_interval,
+                   max_retry_interval=conf.database.db_max_retry_interval,
+                   max_retries=conf.database.db_max_retries)

oslo/db/options.py

@@ -130,26 +130,24 @@ database_opts = [
                     'count.'),
 ]
 
-CONF = cfg.CONF
-CONF.register_opts(database_opts, 'database')
 
-
+def set_defaults(conf, connection=None, sqlite_db=None,
-def set_defaults(sql_connection, sqlite_db, max_pool_size=None,
+                 max_pool_size=None, max_overflow=None,
-                 max_overflow=None, pool_timeout=None):
+                 pool_timeout=None):
     """Set defaults for configuration variables."""
-    cfg.set_defaults(database_opts,
+
-                     connection=sql_connection,
+    conf.register_opts(database_opts, group='database')
-                     sqlite_db=sqlite_db)
+
-    # Update the QueuePool defaults
+    if connection is not None:
+        conf.set_default('connection', connection, group='database')
+    if sqlite_db is not None:
+        conf.set_default('sqlite_db', sqlite_db, group='database')
     if max_pool_size is not None:
-        cfg.set_defaults(database_opts,
+        conf.set_default('max_pool_size', max_pool_size, group='database')
-                         max_pool_size=max_pool_size)
     if max_overflow is not None:
-        cfg.set_defaults(database_opts,
+        conf.set_default('max_overflow', max_overflow, group='database')
-                         max_overflow=max_overflow)
     if pool_timeout is not None:
-        cfg.set_defaults(database_opts,
+        conf.set_default('pool_timeout', pool_timeout, group='database')
-                         pool_timeout=pool_timeout)
 
 
 def list_opts():

oslo/db/sqlalchemy/session.py

@@ -291,6 +291,7 @@ from sqlalchemy.pool import NullPool, StaticPool
 from sqlalchemy.sql.expression import literal_column
 
 from oslo.db import exception
+from oslo.db import options
 from oslo.db.openstack.common.gettextutils import _LE, _LW
 from oslo.db.openstack.common import timeutils
 
@@ -877,13 +878,10 @@ class EngineFacade(object):
         return self._session_maker(**kwargs)
 
     @classmethod
-    def from_config(cls, connection_string, conf,
+    def from_config(cls, conf,
                     sqlite_fk=False, autocommit=True, expire_on_commit=False):
         """Initialize EngineFacade using oslo.config config instance options.
 
-        :param connection_string: SQLAlchemy connection string
-        :type connection_string: string
-
         :param conf: oslo.config config instance
         :type conf: oslo.config.cfg.ConfigOpts
 
@@ -898,7 +896,9 @@ class EngineFacade(object):
 
         """
 
-        return cls(sql_connection=connection_string,
+        conf.register_opts(options.database_opts, 'database')
+
+        return cls(sql_connection=conf.database.connection,
                    sqlite_fk=sqlite_fk,
                    autocommit=autocommit,
                    expire_on_commit=expire_on_commit,

tests/sqlalchemy/test_options.py

@@ -14,19 +14,17 @@
 from oslo.config import cfg
 
 from oslo.db.openstack.common.fixture import config
+from oslo.db import options
 from tests import utils as test_utils
 
 
-cfg.CONF.import_opt('connection', 'oslo.db.options',
-                    group='database')
-
-
 class DbApiOptionsTestCase(test_utils.BaseTestCase):
     def setUp(self):
         super(DbApiOptionsTestCase, self).setUp()
 
         config_fixture = self.useFixture(config.Config())
         self.conf = config_fixture.conf
+        self.conf.register_opts(options.database_opts, group='database')
         self.config = config_fixture.config
 
     def test_deprecated_session_parameters(self):
@@ -118,3 +116,12 @@ pool_timeout=7
 
         self.conf(['--config-file', path])
         self.assertEqual(self.conf.database.backend, 'test_123')
+
+    def test_set_defaults(self):
+        conf = cfg.ConfigOpts()
+
+        options.set_defaults(conf,
+                             connection='sqlite:///:memory:')
+
+        self.assertTrue(len(conf.database.items()) > 1)
+        self.assertEqual('sqlite:///:memory:', conf.database.connection)

tests/sqlalchemy/test_sqlalchemy.py

@@ -352,13 +352,14 @@ class EngineFacadeTestCase(oslo_test.BaseTestCase):
     @mock.patch('oslo.db.sqlalchemy.session.create_engine')
     def test_creation_from_config(self, create_engine, get_maker):
         conf = mock.MagicMock()
+        conf.database.connection = 'sqlite:///:memory:'
         conf.database.items.return_value = [
             ('connection_debug', 100),
             ('max_pool_size', 10),
             ('mysql_sql_mode', 'TRADITIONAL'),
         ]
 
-        session.EngineFacade.from_config('sqlite:///:memory:', conf,
+        session.EngineFacade.from_config(conf,
                                          autocommit=False,
                                          expire_on_commit=True)
 

tests/test_api.py

@@ -16,6 +16,7 @@
 """Unit tests for DB API."""
 
 import mock
+from oslo.config import cfg
 
 from oslo.db import api
 from oslo.db import exception
@@ -78,6 +79,13 @@ class DBAPITestCase(test_utils.BaseTestCase):
         dbapi.api_class_call1(1, 'abc')
         self.assertIsNotNone(dbapi._backend)
 
+    def test_dbapi_from_config(self):
+        conf = cfg.ConfigOpts()
+
+        dbapi = api.DBAPI.from_config(conf,
+                                      backend_mapping={'sqlalchemy': __name__})
+        self.assertIsNotNone(dbapi._backend)
+
 
 class DBReconnectTestCase(DBAPITestCase):
     def setUp(self):