Пример #1
0
def setup():
    import mox  # Fail fast if you don't have mox. Workaround for bug 810424

    from cinder import rpc  # Register rpc_backend before fake_flags sets it
    FLAGS.register_opts(rpc.rpc_opts)

    from cinder.db import migration
    from cinder.tests import fake_flags

    if FLAGS.sql_connection == "sqlite://":
        if migration.db_version() > 1:
            return
    else:
        testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db)
        if os.path.exists(testdb):
            return
    migration.db_sync()

    if FLAGS.sql_connection == "sqlite://":
        global _DB
        engine = get_engine()
        conn = engine.connect()
        _DB = "".join(line for line in conn.connection.iterdump())
    else:
        cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db)
        shutil.copyfile(testdb, cleandb)
Пример #2
0
    def __init__(self,
                 connection,
                 sqlite_synchronous=True,
                 soft_deletes=False):
        self.soft_deletes = soft_deletes
        cfg.CONF.set_override('connection', connection, 'database')
        cfg.CONF.set_override('sqlite_synchronous', sqlite_synchronous,
                              'database')

        # Suppress logging for migration
        migrate_logger = logging.getLogger('migrate')
        migrate_logger.setLevel(logging.WARNING)

        self._clear_facade()
        self.db_instance = db_api.oslo_db_api.DBAPI.from_config(
            conf=cfg.CONF, backend_mapping=db_api._BACKEND_MAPPING, lazy=True)

        # We need to wrap some get methods that get called before the volume is
        # actually created.
        self.original_vol_type_get = self.db_instance.volume_type_get
        self.db_instance.volume_type_get = self.vol_type_get
        self.original_qos_specs_get = self.db_instance.qos_specs_get
        self.db_instance.qos_specs_get = self.qos_specs_get
        self.original_get_by_id = self.db_instance.get_by_id
        self.db_instance.get_by_id = self.get_by_id

        migration.db_sync()
        self._create_key_value_table()
        super(DBPersistence, self).__init__()
Пример #3
0
    def sync(self, version=None, bump_versions=False):
        """Sync the database up to the most recent version."""
        if version is not None and version > db.MAX_INT:
            print(
                _('Version should be less than or equal to '
                  '%(max_version)d.') % {'max_version': db.MAX_INT})
            sys.exit(1)
        try:
            db_migration.db_sync(version)
        except db_exc.DBMigrationError as ex:
            print("Error during database migration: %s" % ex)
            sys.exit(1)

        try:
            if bump_versions:
                ctxt = context.get_admin_context()
                services = objects.ServiceList.get_all(ctxt)
                for service in services:
                    rpc_version = RPC_VERSIONS[service.binary]
                    if (service.rpc_current_version != rpc_version
                            or service.object_current_version != OVO_VERSION):
                        service.rpc_current_version = rpc_version
                        service.object_current_version = OVO_VERSION
                        service.save()
        except Exception as ex:
            print(_('Error during service version bump: %s') % ex)
            sys.exit(2)
Пример #4
0
 def _cache_schema(self):
     global DB_SCHEMA
     if not DB_SCHEMA:
         engine = sqla_api.get_engine()
         conn = engine.connect()
         migration.db_sync()
         DB_SCHEMA = "".join(line for line in conn.connection.iterdump())
         engine.dispose()
Пример #5
0
    def __init__(self,
                 connection,
                 sqlite_synchronous=True,
                 soft_deletes=False):
        self.soft_deletes = soft_deletes
        cfg.CONF.set_override('connection', connection, 'database')
        cfg.CONF.set_override('sqlite_synchronous', sqlite_synchronous,
                              'database')

        # Suppress logging for migration
        migrate_logger = logging.getLogger('migrate')
        migrate_logger.setLevel(logging.WARNING)

        self._clear_facade()
        self.db_instance = db_api.oslo_db_api.DBAPI.from_config(
            conf=cfg.CONF, backend_mapping=db_api._BACKEND_MAPPING, lazy=True)

        # We need to wrap some get methods that get called before the volume is
        # actually created.
        self.original_vol_type_get = self.db_instance.volume_type_get
        self.db_instance.volume_type_get = self.vol_type_get
        self.original_qos_specs_get = self.db_instance.qos_specs_get
        self.db_instance.qos_specs_get = self.qos_specs_get
        self.original_get_by_id = self.db_instance.get_by_id
        self.db_instance.get_by_id = self.get_by_id

        try:
            migration.db_sync()
        except exception.DBMigrationError as exc:
            # We can be running 2 Cinder versions at the same time on the same
            # DB while we upgrade, so we must ignore the fact that the DB is
            # now on a newer version.
            if not isinstance(getattr(exc, 'inner_exception', None),
                              migrate.exceptions.VersionNotFoundError):
                raise
        self._create_key_value_table()

        # NOTE : At this point, the persistence isn't ready so we need to use
        # db_instance instead of sqlalchemy API or DB API.
        orm_obj = self.db_instance.volume_type_get_by_name(
            objects.CONTEXT, '__DEFAULT__')
        cls = cinder_objs.VolumeType
        expected_attrs = cls._get_expected_attrs(objects.CONTEXT)
        self.DEFAULT_TYPE = cls._from_db_object(objects.CONTEXT,
                                                cls(objects.CONTEXT),
                                                orm_obj,
                                                expected_attrs=expected_attrs)
        super(DBPersistence, self).__init__()
Пример #6
0
    def sync(self, version=None, bump_versions=False):
        """Sync the database up to the most recent version."""
        if version is not None and version > db.MAX_INT:
            print(_('Version should be less than or equal to '
                    '%(max_version)d.') % {'max_version': db.MAX_INT})
            sys.exit(1)
        try:
            result = db_migration.db_sync(version)
        except db_exc.DBMigrationError as ex:
            print("Error during database migration: %s" % ex)
            sys.exit(1)

        try:
            if bump_versions:
                ctxt = context.get_admin_context()
                services = objects.ServiceList.get_all(ctxt)
                for service in services:
                    rpc_version = RPC_VERSIONS[service.binary]
                    if (service.rpc_current_version != rpc_version or
                            service.object_current_version != OVO_VERSION):
                        service.rpc_current_version = rpc_version
                        service.object_current_version = OVO_VERSION
                        service.save()
        except Exception as ex:
            print(_('Error during service version bump: %s') % ex)
            sys.exit(2)

        return result
Пример #7
0
    def _test_db_sync(
        self,
        has_migrate,
        has_alembic,
        mock_get_engine,
        mock_find_repo,
        mock_find_conf,
        mock_is_migrate,
        mock_is_alembic,
        mock_init,
        mock_upgrade,
    ):
        mock_is_migrate.return_value = has_migrate
        mock_is_alembic.return_value = has_alembic
        migration.db_sync()
        mock_get_engine.assert_called_once_with()
        mock_find_repo.assert_called_once_with()
        mock_find_conf.assert_called_once_with()
        mock_find_conf.return_value.set_main_option.assert_called_once_with(
            'sqlalchemy.url',
            str(mock_get_engine.return_value.url),
        )
        mock_is_migrate.assert_called_once_with(mock_get_engine.return_value,
                                                mock_find_repo.return_value)
        if has_migrate:
            mock_is_alembic.assert_called_once_with(
                mock_get_engine.return_value)
        else:
            mock_is_alembic.assert_not_called()

        # we should only attempt the upgrade of the remaining
        # sqlalchemy-migrate-based migrations and fake apply of the initial
        # alembic migrations if sqlalchemy-migrate is in place but alembic
        # hasn't been used yet
        if has_migrate and not has_alembic:
            mock_init.assert_called_once_with(mock_get_engine.return_value,
                                              mock_find_repo.return_value,
                                              mock_find_conf.return_value)
        else:
            mock_init.assert_not_called()

        # however, we should always attempt to upgrade the requested migration
        # to alembic
        mock_upgrade.assert_called_once_with(mock_get_engine.return_value,
                                             mock_find_conf.return_value, None)
Пример #8
0
    def __init__(self, connection, sqlite_synchronous=True,
                 soft_deletes=False):
        self.soft_deletes = soft_deletes
        volume_cmd.CONF.database.connection = connection
        volume_cmd.CONF.database.sqlite_synchronous = sqlite_synchronous

        # Suppress logging for migration
        migrate_logger = logging.getLogger('migrate')
        migrate_logger.setLevel(logging.WARNING)

        self._clear_facade()
        self.db_instance = db_api.oslo_db_api.DBAPI.from_config(
            conf=volume_cmd.CONF, backend_mapping=db_api._BACKEND_MAPPING,
            lazy=True)

        migration.db_sync()
        self._create_key_value_table()
        super(DBPersistence, self).__init__()
Пример #9
0
 def sync(self, version=None):
     """Sync the database up to the most recent version."""
     if version is not None and version > db.MAX_INT:
         print(_('Version should be less than or equal to '
                 '%(max_version)d.') % {'max_version': db.MAX_INT})
         sys.exit(1)
     try:
         return db_migration.db_sync(version)
     except db_exc.DbMigrationError as ex:
         print("Error during database migration: %s" % ex)
         sys.exit(1)
Пример #10
0
 def sync(self, version=None):
     """Sync the database up to the most recent version."""
     if version is not None and version > db.MAX_INT:
         print(_('Version should be less than or equal to '
                 '%(max_version)d.') % {'max_version': db.MAX_INT})
         sys.exit(1)
     try:
         return db_migration.db_sync(version)
     except db_exc.DBMigrationError as ex:
         print("Error during database migration: %s" % ex)
         sys.exit(1)
Пример #11
0
    def test_mysql_innodb(self):
        """Test that table creation on mysql only builds InnoDB tables."""
        # add this to the global lists to make reset work with it, it's removed
        # automatically in tearDown so no need to clean it up here.
        # sanity check
        migration.db_sync(engine=self.migrate_engine)

        total = self.migrate_engine.execute(
            "SELECT count(*) "
            "from information_schema.TABLES "
            "where TABLE_SCHEMA='{0}'".format(
                self.migrate_engine.url.database))
        self.assertGreater(total.scalar(), 0,
                           msg="No tables found. Wrong schema?")

        noninnodb = self.migrate_engine.execute(
            "SELECT count(*) "
            "from information_schema.TABLES "
            "where TABLE_SCHEMA='openstack_citest' "
            "and ENGINE!='InnoDB' "
            "and TABLE_NAME!='migrate_version'")
        count = noninnodb.scalar()
        self.assertEqual(count, 0, "%d non InnoDB tables created" % count)
Пример #12
0
def setup():
    import mox  # Fail fast if you don't have mox. Workaround for bug 810424

    from cinder.db import migration
    from cinder.tests import fake_flags
    fake_flags.set_defaults(FLAGS)

    if FLAGS.sql_connection == "sqlite://":
        if migration.db_version() > 1:
            return
    else:
        testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db)
        if os.path.exists(testdb):
            return
    migration.db_sync()

    if FLAGS.sql_connection == "sqlite://":
        global _DB
        engine = get_engine()
        conn = engine.connect()
        _DB = "".join(line for line in conn.connection.iterdump())
    else:
        cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db)
        shutil.copyfile(testdb, cleandb)
Пример #13
0
 def sync(self, version=None):
     """Sync the database up to the most recent version."""
     return db_migration.db_sync(version)
Пример #14
0
 def sync(self, version=None):
     """Sync the database up to the most recent version."""
     return db_migration.db_sync(version)
Пример #15
0
 def test_db_version_alembic(self):
     migration.db_sync()
     head = alembic_script.ScriptDirectory.from_config(
         self.config, ).get_current_head()
     self.assertEqual(head, migration.db_version())