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 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 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 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 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_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 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):
abs_path = migration_helpers.find_migrate_repo(federation)
migration.db_sync(abs_path)
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):
migration.db_sync(sql.get_engine(),
migration_helpers.find_migrate_repo(oauth1))
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)
def db_sync(self):
abs_path = migration_helpers.find_migrate_repo(federation)
migration.db_sync(sql.get_engine(), abs_path)
