Compact pre-Grizzly database migrations.

Compacts the pre-Grizzly database migrations into a single
migration (133_folsom.py).

Pre-Grizzly users will need to upgrade to Folsom before
running any Grizzly migrations.

Tested on PostgreSQL and MySQL schemas on Fedora 17 to ensure the
new compacted migration generates an identical schema to the previous
migrate scripts in Folsom.

Change-Id: I1235215bfb6edc00c78240f895f927a079585559
This commit is contained in:
Dan Prince
2012-11-16 13:42:35 -05:00
parent 1213556e5a
commit a6e642d420

View File

@@ -304,203 +304,3 @@ class TestMigrations(test.TestCase):
self.assertEqual(version,
migration_api.db_version(engine,
TestMigrations.REPOSITORY))
def test_migration_98(self):
"""Test that migration 98 runs
This test exists to prove bug 1047633 has been fixed
"""
for key, engine in self.engines.items():
migration_api.version_control(engine, TestMigrations.REPOSITORY,
migration.INIT_VERSION)
migration_api.upgrade(engine, TestMigrations.REPOSITORY, 97)
# Set up a single volume, values don't matter
metadata = sqlalchemy.schema.MetaData()
metadata.bind = engine
volumes = sqlalchemy.Table('volumes', metadata, autoload=True)
vol_id = '9db3c2e5-8cac-4e94-9e6c-b5f750736727'
volumes.insert().values(id=vol_id).execute()
migration_api.upgrade(engine, TestMigrations.REPOSITORY, 98)
migration_api.downgrade(engine, TestMigrations.REPOSITORY, 97)
def test_migration_91(self):
"""Test that migration 91 works correctly.
This test prevents regression of bugs 1052244 and 1052220.
"""
for key, engine in self.engines.items():
migration_api.version_control(engine, TestMigrations.REPOSITORY,
migration.INIT_VERSION)
migration_api.upgrade(engine, TestMigrations.REPOSITORY, 90)
vol1_id = '10'
vol1_uuid = '9db3c2e5-8cac-4e94-9e6c-b5f750736727'
vol2_id = '11'
vol2_uuid = 'fb17fb5a-ca3d-4bba-8903-fc776ea81d78'
snap_id = '7'
snap_uuid = 'a87e5108-8a2b-4c89-be96-0e8760db2c6a'
inst_id = '0ec45d38-aefd-4c42-a209-361e848240b7'
metadata = sqlalchemy.schema.MetaData()
metadata.bind = engine
instances = sqlalchemy.Table('instances', metadata, autoload=True)
volumes = sqlalchemy.Table('volumes', metadata, autoload=True)
sm_flavors = sqlalchemy.Table(
'sm_flavors', metadata, autoload=True)
sm_backend_config = sqlalchemy.Table(
'sm_backend_config', metadata, autoload=True)
sm_volume = sqlalchemy.Table(
'sm_volume', metadata, autoload=True)
volume_mappings = sqlalchemy.Table(
'volume_id_mappings', metadata, autoload=True)
iscsi_targets = sqlalchemy.Table(
'iscsi_targets', metadata, autoload=True)
volume_metadata = sqlalchemy.Table(
'volume_metadata', metadata, autoload=True)
snapshots = sqlalchemy.Table('snapshots', metadata, autoload=True)
snapshot_mappings = sqlalchemy.Table(
'snapshot_id_mappings', metadata, autoload=True)
block_device_mapping = sqlalchemy.Table(
'block_device_mapping', metadata, autoload=True)
volumes.insert().values(id=vol1_id).execute()
volume_mappings.insert() \
.values(id=vol1_id, uuid=vol1_uuid).execute()
snapshots.insert().values(id=snap_id, volume_id=vol1_id).execute()
snapshot_mappings.insert() \
.values(id=snap_id, uuid=snap_uuid).execute()
volumes.insert().values(id=vol2_id, snapshot_id=snap_id).execute()
volume_mappings.insert() \
.values(id=vol2_id, uuid=vol2_uuid).execute()
sm_flavors.insert().values(id=7).execute()
sm_backend_config.insert().values(id=7, flavor_id=7).execute()
sm_volume.insert().values(id=vol1_id, backend_id=7).execute()
volume_metadata.insert().values(id=7, volume_id=vol1_id).execute()
iscsi_targets.insert().values(id=7, volume_id=vol1_id).execute()
instances.insert().values(id=7, uuid=inst_id).execute()
block_device_mapping.insert()\
.values(id=7, volume_id=vol1_id, instance_uuid=inst_id) \
.execute()
vols = volumes.select().execute().fetchall()
self.assertEqual(set([vol.id for vol in vols]),
set([vol1_id, vol2_id]))
self.assertEqual(snap_id, vols[1].snapshot_id)
query = volume_metadata.select(volume_metadata.c.id == 7)
self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
query = iscsi_targets.select(iscsi_targets.c.id == 7)
self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
query = block_device_mapping.select(block_device_mapping.c.id == 7)
self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
snaps = sqlalchemy.select([snapshots.c.id]).execute().fetchall()
self.assertEqual(set([snap.id for snap in snaps]),
set([snap_id]))
sm_vols = sqlalchemy.select([sm_volume.c.id]).execute().fetchall()
self.assertEqual(set([sm_vol.id for sm_vol in sm_vols]),
set([vol1_id]))
migration_api.upgrade(engine, TestMigrations.REPOSITORY, 91)
vols = volumes.select().execute().fetchall()
self.assertEqual(set([vol.id for vol in vols]),
set([vol1_uuid, vol2_uuid]))
self.assertEqual(snap_uuid, vols[1].snapshot_id)
query = volume_metadata.select(volume_metadata.c.id == 7)
self.assertEqual(vol1_uuid, query.execute().fetchone().volume_id)
query = iscsi_targets.select(iscsi_targets.c.id == 7)
self.assertEqual(vol1_uuid, query.execute().fetchone().volume_id)
query = block_device_mapping.select(block_device_mapping.c.id == 7)
self.assertEqual(vol1_uuid, query.execute().fetchone().volume_id)
snaps = sqlalchemy.select([snapshots.c.id]).execute().fetchall()
self.assertEqual(set([snap.id for snap in snaps]),
set([snap_uuid]))
sm_vols = sqlalchemy.select([sm_volume.c.id]).execute().fetchall()
self.assertEqual(set([sm_vol.id for sm_vol in sm_vols]),
set([vol1_uuid]))
migration_api.downgrade(engine, TestMigrations.REPOSITORY, 90)
vols = volumes.select().execute().fetchall()
self.assertEqual(set([vol.id for vol in vols]),
set([vol1_id, vol2_id]))
self.assertEqual(snap_id, vols[1].snapshot_id)
query = volume_metadata.select(volume_metadata.c.id == 7)
self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
query = iscsi_targets.select(iscsi_targets.c.id == 7)
self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
query = block_device_mapping.select(block_device_mapping.c.id == 7)
self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
snaps = sqlalchemy.select([snapshots.c.id]).execute().fetchall()
self.assertEqual(set([snap.id for snap in snaps]),
set([snap_id]))
sm_vols = sqlalchemy.select([sm_volume.c.id]).execute().fetchall()
self.assertEqual(set([sm_vol.id for sm_vol in sm_vols]),
set([vol1_id]))
def test_migration_111(self):
for key, engine in self.engines.items():
migration_api.version_control(engine, TestMigrations.REPOSITORY,
migration.INIT_VERSION)
migration_api.upgrade(engine, TestMigrations.REPOSITORY, 110)
metadata = sqlalchemy.schema.MetaData()
metadata.bind = engine
aggregate_hosts = sqlalchemy.Table('aggregate_hosts', metadata,
autoload=True)
host = 'host'
aggregate_hosts.insert().values(id=1,
aggregate_id=1, host=host).execute()
migration_api.upgrade(engine, TestMigrations.REPOSITORY, 111)
agg = sqlalchemy.select([aggregate_hosts.c.host]).execute().first()
self.assertEqual(host, agg.host)
aggregate_hosts.insert().values(id=2,
aggregate_id=2, host=host).execute()
migration_api.downgrade(engine, TestMigrations.REPOSITORY, 111)
agg = sqlalchemy.select([aggregate_hosts.c.host]).execute().first()
self.assertEqual(host, agg.host)
def test_migration_133(self):
for key, engine in self.engines.items():
migration_api.version_control(engine, TestMigrations.REPOSITORY,
migration.INIT_VERSION)
migration_api.upgrade(engine, TestMigrations.REPOSITORY, 132)
# Set up a single volume, values don't matter
metadata = sqlalchemy.schema.MetaData()
metadata.bind = engine
aggregates = sqlalchemy.Table('aggregates', metadata,
autoload=True)
name = 'name'
aggregates.insert().values(id=1, availability_zone='nova',
aggregate_name=1, name=name).execute()
migration_api.upgrade(engine, TestMigrations.REPOSITORY, 133)
aggregates.insert().values(id=2, availability_zone='nova',
aggregate_name=2, name=name).execute()
migration_api.downgrade(engine, TestMigrations.REPOSITORY, 132)
agg = sqlalchemy.select([aggregates.c.name]).execute().first()
self.assertEqual(name, agg.name)