def main(): version = CONF.command.version extension = CONF.command.extension if not extension: abs_path = migration_helpers.find_migrate_repo() else: try: package_name = '.'.join((contrib.__name__, extension)) package = importutils.import_module(package_name) except ImportError: raise ImportError(_("%s extension does not exist.") % package_name) try: abs_path = migration_helpers.find_migrate_repo(package) try: migration.db_version_control(abs_path) # Register the repo with the version control API # If it already knows about the repo, it will throw # an exception that we can safely ignore except exceptions.DatabaseAlreadyControlledError: pass except exception.MigrationNotProvided as e: print(e) exit(0) migration.db_sync(abs_path, version=version)
def main(): version = CONF.command.version extension = CONF.command.extension if not extension: abs_path = migration_helpers.find_migrate_repo() else: try: package_name = '.'.join((contrib.__name__, extension)) package = importutils.import_module(package_name) except ImportError: raise ImportError( _("%s extension does not exist.") % package_name) try: abs_path = migration_helpers.find_migrate_repo(package) try: migration.db_version_control(abs_path) # Register the repo with the version control API # If it already knows about the repo, it will throw # an exception that we can safely ignore except exceptions.DatabaseAlreadyControlledError: pass except exception.MigrationNotProvided as e: print(e) exit(0) migration.db_sync(abs_path, version=version)
def setUp(self): super(SqlMigrateBase, self).setUp() database.initialize_sql_session() conn_str = CONF.database.connection if (conn_str != tests.IN_MEM_DB_CONN_STRING and conn_str.startswith('sqlite') and conn_str[10:] == tests.DEFAULT_TEST_DB_FILE): # Override the default with a DB that is specific to the migration # tests only if the DB Connection string is the same as the global # default. This is required so that no conflicts occur due to the # global default DB already being under migrate control. This is # only needed if the DB is not-in-memory db_file = tests.dirs.tmp('keystone_migrate_test.db') self.config_fixture.config( group='database', connection='sqlite:///%s' % db_file) # create and share a single sqlalchemy engine for testing self.engine = sql.get_engine() self.Session = db_session.get_maker(self.engine, autocommit=False) self.initialize_sql() self.repo_path = migration_helpers.find_migrate_repo( self.repo_package()) self.schema = versioning_api.ControlledSchema.create( self.engine, self.repo_path, self.initial_db_version) # auto-detect the highest available schema version in the migrate_repo self.max_version = self.schema.repository.version().version
def test_extension_federation_upgraded_values(self): abs_path = migration_helpers.find_migrate_repo(federation) migration.db_version_control(sql.get_engine(), abs_path) migration.db_sync(sql.get_engine(), abs_path, version=6) idp_table = sqlalchemy.Table("identity_provider", self.metadata, autoload=True) idps = [{'id': uuid.uuid4().hex, 'enabled': True, 'description': uuid.uuid4().hex, 'remote_id': uuid.uuid4().hex}, {'id': uuid.uuid4().hex, 'enabled': True, 'description': uuid.uuid4().hex, 'remote_id': uuid.uuid4().hex}] for idp in idps: ins = idp_table.insert().values({'id': idp['id'], 'enabled': idp['enabled'], 'description': idp['description'], 'remote_id': idp['remote_id']}) self.engine.execute(ins) migration.db_sync(sql.get_engine(), abs_path) idp_remote_ids_table = sqlalchemy.Table("idp_remote_ids", self.metadata, autoload=True) for idp in idps: s = idp_remote_ids_table.select().where( idp_remote_ids_table.c.idp_id == idp['id']) remote = self.engine.execute(s).fetchone() self.assertEqual(idp['remote_id'], remote['remote_id'], 'remote_ids must be preserved during the ' 'migration from identity_provider table to ' 'idp_remote_ids table')
def test_extension_initial(self): """When get the initial version of an extension, it's 0.""" for name, extension in six.iteritems(EXTENSIONS): abs_path = migration_helpers.find_migrate_repo(extension) migration.db_version_control(sql.get_engine(), abs_path) version = migration_helpers.get_db_version(extension=name) self.assertEqual(0, version, "Migrate version for %s is not 0" % name)
def setup_database(self): super(OAuth1Tests, self).setup_database() package_name = '.'.join((contrib.__name__, self.EXTENSION_NAME)) package = importutils.import_module(package_name) abs_path = migration_helpers.find_migrate_repo(package) migration.db_version_control(abs_path) migration.db_sync(abs_path)
def setup_database(self): super(TestExtensionCase, self).setup_database() package_name = '.'.join((contrib.__name__, self.EXTENSION_NAME)) package = importutils.import_module(package_name) abs_path = migration_helpers.find_migrate_repo(package) migration.db_version_control(sql.get_engine(), abs_path) migration.db_sync(sql.get_engine(), abs_path)
def setUp(self): super(SqlMigrateBase, self).setUp() database.initialize_sql_session() conn_str = CONF.database.connection if (conn_str != tests.IN_MEM_DB_CONN_STRING and conn_str.startswith('sqlite') and conn_str[10:] == tests.DEFAULT_TEST_DB_FILE): # Override the default with a DB that is specific to the migration # tests only if the DB Connection string is the same as the global # default. This is required so that no conflicts occur due to the # global default DB already being under migrate control. This is # only needed if the DB is not-in-memory db_file = tests.dirs.tmp('keystone_migrate_test.db') self.config_fixture.config(group='database', connection='sqlite:///%s' % db_file) # create and share a single sqlalchemy engine for testing self.engine = sql.get_engine() self.Session = db_session.get_maker(self.engine, autocommit=False) self.initialize_sql() self.repo_path = migration_helpers.find_migrate_repo( self.repo_package()) self.schema = versioning_api.ControlledSchema.create( self.engine, self.repo_path, self.initial_db_version) # auto-detect the highest available schema version in the migrate_repo self.max_version = self.schema.repository.version().version
def setup_database(self): super(TestExtensionCase, self).setup_database() package_name = '.'.join((contrib.__name__, self.EXTENSION_NAME)) package = importutils.import_module(package_name) abs_path = migration_helpers.find_migrate_repo(package) migration.db_version_control(abs_path) migration.db_sync(abs_path)
def setup_database(self): super(OAuth1Tests, self).setup_database() package_name = '.'.join((contrib.__name__, self.EXTENSION_NAME)) package = importutils.import_module(package_name) abs_path = migration_helpers.find_migrate_repo(package) migration.db_version_control(sql.get_engine(), abs_path) migration.db_sync(sql.get_engine(), abs_path)
def test_extension_initial(self): """When get the initial version of an extension, it's 0.""" for name, extension in six.iteritems(EXTENSIONS): abs_path = migration_helpers.find_migrate_repo(extension) migration.db_version_control(sql.get_engine(), abs_path) version = migration_helpers.get_db_version(extension=name) self.assertEqual(0, version, 'Migrate version for %s is not 0' % name)
def main(): extension = CONF.command.extension if extension: try: package_name = '.'.join((contrib.__name__, extension)) package = importutils.import_module(package_name) except ImportError: raise ImportError(_("%s extension does not exist.") % package_name) try: print(migration.db_version( migration_helpers.find_migrate_repo(package), 0)) except exception.MigrationNotProvided as e: print(e) exit(0) else: print(migration.db_version( migration_helpers.find_migrate_repo(), 0))
def db_sync(version=None, package=None): if version is not None: try: version = int(version) except ValueError: raise Exception(_('version should be an integer')) repo_path = migration_helpers.find_migrate_repo(package=package) current_version = db_version(package=package) return migrate_repository(version, current_version, repo_path)
def setup_database(self): self.conf_files = super(TestExtensionCase, self).config_files() self.conf_files.append( tests.dirs.tests('test_associate_project_endpoint_extension.conf')) super(TestExtensionCase, self).setup_database() package_name = '.'.join((contrib.__name__, self.EXTENSION_NAME)) package = importutils.import_module(package_name) abs_path = migration_helpers.find_migrate_repo(package) migration.db_version_control(abs_path) migration.db_sync(abs_path)
def main(): extension = CONF.command.extension if extension: try: package_name = '.'.join((contrib.__name__, extension)) package = importutils.import_module(package_name) except ImportError: raise ImportError( _("%s extension does not exist.") % package_name) try: print( migration.db_version( migration_helpers.find_migrate_repo(package), 0)) except exception.MigrationNotProvided as e: print(e) exit(0) else: print( migration.db_version(migration_helpers.find_migrate_repo(), 0))
def test_extension_migrated(self): """When get the version after migrating an extension, it's not 0.""" for name, extension in six.iteritems(EXTENSIONS): abs_path = migration_helpers.find_migrate_repo(extension) migration.db_version_control(sql.get_engine(), abs_path) migration.db_sync(sql.get_engine(), abs_path) version = migration_helpers.get_db_version(extension=name) self.assertTrue( version > 0, "Version for %s didn't change after migrated?" % name)
def setup_database(): db = dirs.tmp('test.db') pristine = dirs.tmp('test.db.pristine') if os.path.exists(db): os.unlink(db) if not os.path.exists(pristine): migration.db_sync(migration_helpers.find_migrate_repo()) shutil.copyfile(db, pristine) else: shutil.copyfile(pristine, db)
def test_extension_migrated(self): """When get the version after migrating an extension, it's not 0.""" for name, extension in six.iteritems(EXTENSIONS): abs_path = migration_helpers.find_migrate_repo(extension) migration.db_version_control(sql.get_engine(), abs_path) migration.db_sync(sql.get_engine(), abs_path) version = migration_helpers.get_db_version(extension=name) self.assertTrue(version > 0, "Version for %s didn't change after migrated?" % name) # Verify downgrades cannot occur self.assertRaises( db_exception.DbMigrationError, migration_helpers._sync_extension_repo, extension=name, version=0 )
def setup_database(): db = dirs.tmp('test.db') pristine = dirs.tmp('test.db.pristine') if os.path.exists(db): os.unlink(db) if not os.path.exists(pristine): migration.db_sync(sql.get_engine(), migration_helpers.find_migrate_repo()) migration_helpers.sync_database_to_version(extension='revoke') shutil.copyfile(db, pristine) else: shutil.copyfile(pristine, db)
def test_extension_migrated(self): """When get the version after migrating an extension, it's not 0.""" for name, extension in EXTENSIONS.items(): abs_path = migration_helpers.find_migrate_repo(extension) migration.db_version_control(sql.get_engine(), abs_path) migration.db_sync(sql.get_engine(), abs_path) version = migration_helpers.get_db_version(extension=name) self.assertTrue( version > 0, "Version for %s didn't change after migrated?" % name) # Verify downgrades cannot occur self.assertRaises(db_exception.DbMigrationError, migration_helpers._sync_extension_repo, extension=name, version=0)
def _setup_database(extensions=None): if CONF.database.connection != tests.IN_MEM_DB_CONN_STRING: db = tests.dirs.tmp('test.db') pristine = tests.dirs.tmp('test.db.pristine') if os.path.exists(db): os.unlink(db) if not os.path.exists(pristine): migration.db_sync(sql.get_engine(), migration_helpers.find_migrate_repo()) for extension in (extensions or []): migration_helpers.sync_database_to_version(extension=extension) shutil.copyfile(db, pristine) else: shutil.copyfile(pristine, db)
def setUp(self): super(SqlMigrateBase, self).setUp() # Set keystone's connection URL to be the test engine's url. database.initialize_sql_session(self.engine.url) # Override keystone's context manager to be oslo.db's global context # manager. sql.core._TESTING_USE_GLOBAL_CONTEXT_MANAGER = True self.addCleanup(setattr, sql.core, '_TESTING_USE_GLOBAL_CONTEXT_MANAGER', False) self.addCleanup(sql.cleanup) self.initialize_sql() self.repo_path = migration_helpers.find_migrate_repo( self.repo_package()) self.schema_ = versioning_api.ControlledSchema.create( self.engine, self.repo_path, self._initial_db_version) # auto-detect the highest available schema version in the migrate_repo self.max_version = self.schema_.repository.version().version
def will_db_change(conf): """ Check if the database version will change after the sync. conf is the path to the keystone config file """ # Load the config file options try: # before icehouse sql.migration.CONF(project='keystone', default_config_files=[conf]) current_version = sql.migration.db_version() except AttributeError: # starting with icehouse sql.core.CONF(project='keystone', default_config_files=[conf]) current_version = migration.get_db_version() # in havana the method _find_migrate_repo has been renamed to find_migrate_repo try: repo_path = migration.find_migrate_repo() except AttributeError: repo_path = migration._find_migrate_repo() repo_version = versioning_api.repository.Repository(repo_path).latest return current_version != repo_version
def db_sync(self): migration.db_sync(sql.get_engine(), migration_helpers.find_migrate_repo(oauth1))
def db_sync(self): migration.db_sync(migration_helpers.find_migrate_repo(oauth1))
def db_sync(self): abs_path = migration_helpers.find_migrate_repo(federation) migration.db_sync(abs_path)
def db_version(package=None): repo_path = migration_helpers.find_migrate_repo(package=package) try: return versioning_api.db_version(CONF.database.connection, repo_path) except versioning_exceptions.DatabaseNotControlledError: return db_version_control(version=0, package=package)
def db_sync(self, version=None): migration.db_sync( sql.get_engine(), migration_helpers.find_migrate_repo(), version=version)
def db_version_control(version=None, package=None): repo_path = migration_helpers.find_migrate_repo(package=package) versioning_api.version_control(CONF.database.connection, repo_path, version) return version
def db_sync(self, version=None): migration.db_sync(sql.get_engine(), migration_helpers.find_migrate_repo(), version=version)
def db_sync(self): abs_path = migration_helpers.find_migrate_repo(federation) migration.db_sync(sql.get_engine(), abs_path)
def db_sync(self, version=None): migration.db_sync( migration_helpers.find_migrate_repo(), version=version)
def db_sync(self, version=None): abs_path = migration_helpers.find_migrate_repo(endpoint_filter) migration.db_sync(abs_path, version=version)
def db_sync(self, version=None): migration.db_sync(migration_helpers.find_migrate_repo(), version=version)
def db_sync(self, version=None): abs_path = migration_helpers.find_migrate_repo(endpoint_filter) migration.db_sync(sql.get_engine(), abs_path, version=version)