← Back to branch summary

~ubuntu-cloud-archive/ubuntu/precise/nova/trunk

« back to all changes in this revision

Viewing changes to nova/tests/test_migrations.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Adam Gandelman, Chuck Short, Vishvananda Ishaya
  • Date: 2012-09-20 07:45:50 UTC
  • mfrom: (1.1.62)
  • Revision ID: package-import@ubuntu.com-20120920074550-fzmmmzqcntnw1vu7
Tags: 2012.2~rc1-0ubuntu1
[ Adam Gandelman ]
* Ensure /etc/nova/rootwrap.d/ is only writable by root, ensure
  those permissions on /etc/nova/rootwrap.conf as well as
  all individual filter configurations.

[ Chuck Short ]
* Fix lintian warnings
* debian/*.lograote: compress logfiles when they are rotated. (LP:
  #1049915)
* debian/control: 
  - Suggest ceph-common for nova-volume.
  - Add python-cinderclient as a build depends.

[Vishvananda Ishaya]
* Split up vncproxy and xvpvncproxy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_migrations.py
323
323
 
324
324
            migration_api.upgrade(engine, TestMigrations.REPOSITORY, 98)
325
325
            migration_api.downgrade(engine, TestMigrations.REPOSITORY, 97)
 
326
 
 
327
    def test_migration_91(self):
 
328
        """Test that migration 91 works correctly.
 
329
 
 
330
        This test prevents regression of bugs 1052244 and 1052220.
 
331
        """
 
332
        for key, engine in self.engines.items():
 
333
            migration_api.version_control(engine, TestMigrations.REPOSITORY,
 
334
                                          migration.INIT_VERSION)
 
335
            migration_api.upgrade(engine, TestMigrations.REPOSITORY, 90)
 
336
 
 
337
            vol1_id = '10'
 
338
            vol1_uuid = '9db3c2e5-8cac-4e94-9e6c-b5f750736727'
 
339
 
 
340
            vol2_id = '11'
 
341
            vol2_uuid = 'fb17fb5a-ca3d-4bba-8903-fc776ea81d78'
 
342
 
 
343
            snap_id = '7'
 
344
            snap_uuid = 'a87e5108-8a2b-4c89-be96-0e8760db2c6a'
 
345
 
 
346
            inst_id = '0ec45d38-aefd-4c42-a209-361e848240b7'
 
347
 
 
348
            metadata = sqlalchemy.schema.MetaData()
 
349
            metadata.bind = engine
 
350
 
 
351
            instances = sqlalchemy.Table('instances', metadata, autoload=True)
 
352
            volumes = sqlalchemy.Table('volumes', metadata, autoload=True)
 
353
            sm_flavors = sqlalchemy.Table(
 
354
                    'sm_flavors', metadata, autoload=True)
 
355
            sm_backend_config = sqlalchemy.Table(
 
356
                    'sm_backend_config', metadata, autoload=True)
 
357
            sm_volume = sqlalchemy.Table(
 
358
                    'sm_volume', metadata, autoload=True)
 
359
            volume_mappings = sqlalchemy.Table(
 
360
                    'volume_id_mappings', metadata, autoload=True)
 
361
            iscsi_targets = sqlalchemy.Table(
 
362
                    'iscsi_targets', metadata, autoload=True)
 
363
            volume_metadata = sqlalchemy.Table(
 
364
                    'volume_metadata', metadata, autoload=True)
 
365
            snapshots = sqlalchemy.Table('snapshots', metadata, autoload=True)
 
366
            snapshot_mappings = sqlalchemy.Table(
 
367
                    'snapshot_id_mappings', metadata, autoload=True)
 
368
            block_device_mapping = sqlalchemy.Table(
 
369
                    'block_device_mapping', metadata, autoload=True)
 
370
 
 
371
            volumes.insert().values(id=vol1_id).execute()
 
372
            volume_mappings.insert() \
 
373
                    .values(id=vol1_id, uuid=vol1_uuid).execute()
 
374
            snapshots.insert().values(id=snap_id, volume_id=vol1_id).execute()
 
375
            snapshot_mappings.insert() \
 
376
                    .values(id=snap_id, uuid=snap_uuid).execute()
 
377
            volumes.insert().values(id=vol2_id, snapshot_id=snap_id).execute()
 
378
            volume_mappings.insert() \
 
379
                    .values(id=vol2_id, uuid=vol2_uuid).execute()
 
380
            sm_flavors.insert().values(id=7).execute()
 
381
            sm_backend_config.insert().values(id=7, flavor_id=7).execute()
 
382
            sm_volume.insert().values(id=vol1_id, backend_id=7).execute()
 
383
            volume_metadata.insert().values(id=7, volume_id=vol1_id).execute()
 
384
            iscsi_targets.insert().values(id=7, volume_id=vol1_id).execute()
 
385
            instances.insert().values(id=7, uuid=inst_id).execute()
 
386
            block_device_mapping.insert()\
 
387
                    .values(id=7, volume_id=vol1_id, instance_uuid=inst_id) \
 
388
                    .execute()
 
389
 
 
390
            vols = volumes.select().execute().fetchall()
 
391
            self.assertEqual(set([vol.id for vol in vols]),
 
392
                             set([vol1_id, vol2_id]))
 
393
            self.assertEqual(snap_id, vols[1].snapshot_id)
 
394
 
 
395
            query = volume_metadata.select(volume_metadata.c.id == 7)
 
396
            self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
 
397
 
 
398
            query = iscsi_targets.select(iscsi_targets.c.id == 7)
 
399
            self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
 
400
 
 
401
            query = block_device_mapping.select(block_device_mapping.c.id == 7)
 
402
            self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
 
403
 
 
404
            snaps = sqlalchemy.select([snapshots.c.id]).execute().fetchall()
 
405
            self.assertEqual(set([snap.id for snap in snaps]),
 
406
                             set([snap_id]))
 
407
 
 
408
            sm_vols = sqlalchemy.select([sm_volume.c.id]).execute().fetchall()
 
409
            self.assertEqual(set([sm_vol.id for sm_vol in sm_vols]),
 
410
                             set([vol1_id]))
 
411
 
 
412
            migration_api.upgrade(engine, TestMigrations.REPOSITORY, 91)
 
413
 
 
414
            vols = volumes.select().execute().fetchall()
 
415
            self.assertEqual(set([vol.id for vol in vols]),
 
416
                             set([vol1_uuid, vol2_uuid]))
 
417
            self.assertEqual(snap_uuid, vols[1].snapshot_id)
 
418
 
 
419
            query = volume_metadata.select(volume_metadata.c.id == 7)
 
420
            self.assertEqual(vol1_uuid, query.execute().fetchone().volume_id)
 
421
 
 
422
            query = iscsi_targets.select(iscsi_targets.c.id == 7)
 
423
            self.assertEqual(vol1_uuid, query.execute().fetchone().volume_id)
 
424
 
 
425
            query = block_device_mapping.select(block_device_mapping.c.id == 7)
 
426
            self.assertEqual(vol1_uuid, query.execute().fetchone().volume_id)
 
427
 
 
428
            snaps = sqlalchemy.select([snapshots.c.id]).execute().fetchall()
 
429
            self.assertEqual(set([snap.id for snap in snaps]),
 
430
                             set([snap_uuid]))
 
431
 
 
432
            sm_vols = sqlalchemy.select([sm_volume.c.id]).execute().fetchall()
 
433
            self.assertEqual(set([sm_vol.id for sm_vol in sm_vols]),
 
434
                             set([vol1_uuid]))
 
435
 
 
436
            migration_api.downgrade(engine, TestMigrations.REPOSITORY, 90)
 
437
 
 
438
            vols = volumes.select().execute().fetchall()
 
439
            self.assertEqual(set([vol.id for vol in vols]),
 
440
                             set([vol1_id, vol2_id]))
 
441
            self.assertEqual(snap_id, vols[1].snapshot_id)
 
442
 
 
443
            query = volume_metadata.select(volume_metadata.c.id == 7)
 
444
            self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
 
445
 
 
446
            query = iscsi_targets.select(iscsi_targets.c.id == 7)
 
447
            self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
 
448
 
 
449
            query = block_device_mapping.select(block_device_mapping.c.id == 7)
 
450
            self.assertEqual(vol1_id, query.execute().fetchone().volume_id)
 
451
 
 
452
            snaps = sqlalchemy.select([snapshots.c.id]).execute().fetchall()
 
453
            self.assertEqual(set([snap.id for snap in snaps]),
 
454
                             set([snap_id]))
 
455
 
 
456
            sm_vols = sqlalchemy.select([sm_volume.c.id]).execute().fetchall()
 
457
            self.assertEqual(set([sm_vol.id for sm_vol in sm_vols]),
 
458
                             set([vol1_id]))
 
459
 
 
460
    def test_migration_111(self):
 
461
        for key, engine in self.engines.items():
 
462
            migration_api.version_control(engine, TestMigrations.REPOSITORY,
 
463
                                          migration.INIT_VERSION)
 
464
            migration_api.upgrade(engine, TestMigrations.REPOSITORY, 110)
 
465
 
 
466
            metadata = sqlalchemy.schema.MetaData()
 
467
            metadata.bind = engine
 
468
            aggregate_hosts = sqlalchemy.Table('aggregate_hosts', metadata,
 
469
                    autoload=True)
 
470
            host = 'host'
 
471
            aggregate_hosts.insert().values(id=1,
 
472
                    aggregate_id=1, host=host).execute()
 
473
 
 
474
            migration_api.upgrade(engine, TestMigrations.REPOSITORY, 111)
 
475
            agg = sqlalchemy.select([aggregate_hosts.c.host]).execute().first()
 
476
            self.assertEqual(host, agg.host)
 
477
            aggregate_hosts.insert().values(id=2,
 
478
                    aggregate_id=2, host=host).execute()
 
479
 
 
480
            migration_api.downgrade(engine, TestMigrations.REPOSITORY, 111)
 
481
            agg = sqlalchemy.select([aggregate_hosts.c.host]).execute().first()
 
482
            self.assertEqual(host, agg.host)
 
483
 
 
484
    def test_migration_133(self):
 
485
        for key, engine in self.engines.items():
 
486
            migration_api.version_control(engine, TestMigrations.REPOSITORY,
 
487
                                          migration.INIT_VERSION)
 
488
            migration_api.upgrade(engine, TestMigrations.REPOSITORY, 132)
 
489
 
 
490
            # Set up a single volume, values don't matter
 
491
            metadata = sqlalchemy.schema.MetaData()
 
492
            metadata.bind = engine
 
493
            aggregates = sqlalchemy.Table('aggregates', metadata,
 
494
                    autoload=True)
 
495
            name = 'name'
 
496
            aggregates.insert().values(id=1, availability_zone='nova',
 
497
                    aggregate_name=1, name=name).execute()
 
498
 
 
499
            migration_api.upgrade(engine, TestMigrations.REPOSITORY, 133)
 
500
            aggregates.insert().values(id=2, availability_zone='nova',
 
501
                    aggregate_name=2, name=name).execute()
 
502
 
 
503
            migration_api.downgrade(engine, TestMigrations.REPOSITORY, 132)
 
504
            agg = sqlalchemy.select([aggregates.c.name]).execute().first()
 
505
            self.assertEqual(name, agg.name)