← Back to branch summary

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

« back to all changes in this revision

Viewing changes to nova/tests/compute/test_compute.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Chuck Short, Soren Hansen
  • Date: 2012-09-07 17:49:53 UTC
  • mfrom: (1.1.61)
  • Revision ID: package-import@ubuntu.com-20120907174953-oapuvix1jxm830he
Tags: 2012.2~rc1~20120907.15996-0ubuntu1
https://launchpad.net/bugs/995285
[ Chuck Short ]
* New upstream release.
* debian/nova-common.postinst: Drop nova_sudoers permission changing
  since we do it in the debian/rules. (LP: #995285)

[ Soren Hansen ]
* Update debian/watch to account for symbolically named tarballs and
  use newer URL.
* Fix Launchpad URLs in debian/watch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/compute/test_compute.py
86
86
    def setUp(self):
87
87
        super(BaseTestCase, self).setUp()
88
88
        self.flags(compute_driver='nova.virt.fake.FakeDriver',
89
 
         notification_driver=['nova.openstack.common.notifier.test_notifier'],
 
89
                   notification_driver=[test_notifier.__name__],
90
90
                   network_manager='nova.network.manager.FlatManager')
91
91
        self.compute = importutils.import_object(FLAGS.compute_manager)
92
92
 
152
152
 
153
153
    def _create_instance(self, params=None, type_name='m1.tiny'):
154
154
        """Create a test instance. Returns uuid"""
155
 
        return self._create_fake_instance(params, type_name=type_name)['uuid']
 
155
        return self._create_fake_instance(params, type_name=type_name)
156
156
 
157
157
    def _create_instance_type(self, params=None):
158
158
        """Create a test instance type"""
199
199
        timeutils.clear_time_override()
200
200
 
201
201
    def test_wrap_instance_fault(self):
202
 
        inst_uuid = "fake_uuid"
 
202
        inst = {"uuid": "fake_uuid"}
203
203
 
204
204
        called = {'fault_added': False}
205
205
 
210
210
                       did_it_add_fault)
211
211
 
212
212
        @nova.compute.manager.wrap_instance_fault
213
 
        def failer(self2, context, instance_uuid):
 
213
        def failer(self2, context, instance):
214
214
            raise NotImplementedError()
215
215
 
216
216
        self.assertRaises(NotImplementedError, failer,
217
 
                          self.compute, self.context, instance_uuid=inst_uuid)
 
217
                          self.compute, self.context, instance=inst)
218
218
 
219
219
        self.assertTrue(called['fault_added'])
220
220
 
398
398
            raise test.TestingException()
399
399
        self.stubs.Set(nova.compute.manager.ComputeManager,
400
400
                       '_setup_block_device_mapping', fake)
401
 
        instance_uuid = self._create_instance()
 
401
        instance = self._create_instance()
402
402
        self.assertRaises(test.TestingException, self.compute.run_instance,
403
 
                          self.context, instance_uuid=instance_uuid)
 
403
                          self.context, instance=instance)
404
404
        #check state is failed even after the periodic poll
405
405
        self._assert_state({'vm_state': vm_states.ERROR,
406
406
                            'task_state': None})
416
416
        def fake(*args, **kwargs):
417
417
            raise test.TestingException()
418
418
        self.stubs.Set(self.compute.driver, 'spawn', fake)
419
 
        instance_uuid = self._create_instance()
 
419
        instance = self._create_instance()
420
420
        self.assertRaises(test.TestingException, self.compute.run_instance,
421
 
                          self.context, instance_uuid=instance_uuid)
 
421
                          self.context, instance=instance)
422
422
        #check state is failed even after the periodic poll
423
423
        self._assert_state({'vm_state': vm_states.ERROR,
424
424
                            'task_state': None})
430
430
        """Make sure that the instance can be terminated in ERROR state"""
431
431
        elevated = context.get_admin_context()
432
432
        #check failed to schedule --> terminate
433
 
        instance_uuid = self._create_instance(params={'vm_state':
434
 
                                                vm_states.ERROR})
435
 
        inst_ref = db.instance_get_by_uuid(elevated, instance_uuid)
436
 
        instance = jsonutils.to_primitive(inst_ref)
 
433
        instance = self._create_instance(params={'vm_state': vm_states.ERROR})
437
434
        self.compute.terminate_instance(self.context, instance=instance)
438
435
        self.assertRaises(exception.InstanceNotFound, db.instance_get_by_uuid,
439
 
                          elevated, instance_uuid)
 
436
                          elevated, instance['uuid'])
440
437
 
441
438
    def test_run_terminate(self):
442
439
        """Make sure it is possible to  run and terminate instance"""
533
530
        """Ensure instance can be stopped"""
534
531
        instance = jsonutils.to_primitive(self._create_fake_instance())
535
532
        self.compute.run_instance(self.context, instance=instance)
 
533
        db.instance_update(self.context, instance['uuid'],
 
534
                           {"task_state": task_states.STOPPING})
536
535
        self.compute.stop_instance(self.context, instance=instance)
537
536
        self.compute.terminate_instance(self.context, instance=instance)
538
537
 
540
539
        """Ensure instance can be started"""
541
540
        instance = jsonutils.to_primitive(self._create_fake_instance())
542
541
        self.compute.run_instance(self.context, instance=instance)
 
542
        db.instance_update(self.context, instance['uuid'],
 
543
                           {"task_state": task_states.STOPPING})
543
544
        self.compute.stop_instance(self.context, instance=instance)
 
545
        db.instance_update(self.context, instance['uuid'],
 
546
                           {"task_state": task_states.STARTING})
544
547
        self.compute.start_instance(self.context, instance=instance)
545
548
        self.compute.terminate_instance(self.context, instance=instance)
546
549
 
566
569
        instance_uuid = instance['uuid']
567
570
        self.compute.run_instance(self.context, instance=instance)
568
571
 
569
 
        # Make sure these methods work with both instance and instance_uuid
570
 
 
 
572
        db.instance_update(self.context, instance['uuid'],
 
573
                           {"task_state": task_states.RESCUING})
571
574
        self.compute.rescue_instance(self.context, instance=instance)
572
575
        self.assertTrue(called['rescued'])
 
576
        db.instance_update(self.context, instance['uuid'],
 
577
                           {"task_state": task_states.UNRESCUING})
573
578
        self.compute.unrescue_instance(self.context, instance=instance)
574
579
        self.assertTrue(called['unrescued'])
575
580
 
576
 
        self.compute.rescue_instance(self.context, instance_uuid=instance_uuid)
577
 
        self.assertTrue(called['rescued'])
578
 
        self.compute.unrescue_instance(self.context,
579
 
                                       instance_uuid=instance_uuid)
580
 
        self.assertTrue(called['unrescued'])
581
 
 
582
581
        self.compute.terminate_instance(self.context, instance=instance)
583
582
 
584
583
    def test_power_on(self):
594
593
 
595
594
        instance = jsonutils.to_primitive(self._create_fake_instance())
596
595
        self.compute.run_instance(self.context, instance=instance)
 
596
        db.instance_update(self.context, instance['uuid'],
 
597
                           {"task_state": task_states.POWERING_ON})
597
598
        self.compute.power_on_instance(self.context, instance=instance)
598
599
        self.assertTrue(called['power_on'])
599
600
        self.compute.terminate_instance(self.context, instance=instance)
611
612
 
612
613
        instance = jsonutils.to_primitive(self._create_fake_instance())
613
614
        self.compute.run_instance(self.context, instance=instance)
 
615
        db.instance_update(self.context, instance['uuid'],
 
616
                           {"task_state": task_states.POWERING_OFF})
614
617
        self.compute.power_off_instance(self.context, instance=instance)
615
618
        self.assertTrue(called['power_off'])
616
619
        self.compute.terminate_instance(self.context, instance=instance)
619
622
        """Ensure instance can be paused and unpaused"""
620
623
        instance = jsonutils.to_primitive(self._create_fake_instance())
621
624
        self.compute.run_instance(self.context, instance=instance)
 
625
        db.instance_update(self.context, instance['uuid'],
 
626
                           {"task_state": task_states.PAUSING})
622
627
        self.compute.pause_instance(self.context, instance=instance)
 
628
        db.instance_update(self.context, instance['uuid'],
 
629
                           {"task_state": task_states.UNPAUSING})
623
630
        self.compute.unpause_instance(self.context, instance=instance)
624
631
        self.compute.terminate_instance(self.context, instance=instance)
625
632
 
627
634
        """ensure instance can be suspended and resumed"""
628
635
        instance = jsonutils.to_primitive(self._create_fake_instance())
629
636
        self.compute.run_instance(self.context, instance=instance)
 
637
        db.instance_update(self.context, instance['uuid'],
 
638
                           {"task_state": task_states.SUSPENDING})
630
639
        self.compute.suspend_instance(self.context, instance=instance)
 
640
        db.instance_update(self.context, instance['uuid'],
 
641
                           {"task_state": task_states.RESUMING})
631
642
        self.compute.resume_instance(self.context, instance=instance)
632
643
        self.compute.terminate_instance(self.context, instance=instance)
633
644
 
652
663
        """Ensure instance can be rebuilt"""
653
664
        instance = jsonutils.to_primitive(self._create_fake_instance())
654
665
        image_ref = instance['image_ref']
655
 
 
 
666
        sys_metadata = db.instance_system_metadata_get(self.context,
 
667
                        instance['uuid'])
656
668
        self.compute.run_instance(self.context, instance=instance)
657
 
        self.compute.rebuild_instance(self.context, image_ref, image_ref,
658
 
                instance=instance)
 
669
        db.instance_update(self.context, instance['uuid'],
 
670
                           {"task_state": task_states.REBUILDING})
 
671
        self.compute.rebuild_instance(self.context, instance,
 
672
                                      image_ref, image_ref,
 
673
                                      injected_files=[],
 
674
                                      new_pass="new_password",
 
675
                                      orig_sys_metadata=sys_metadata)
659
676
        self.compute.terminate_instance(self.context, instance=instance)
660
677
 
661
678
    def test_rebuild_launch_time(self):
669
686
 
670
687
        self.compute.run_instance(self.context, instance=instance)
671
688
        timeutils.set_time_override(cur_time)
672
 
        self.compute.rebuild_instance(self.context, image_ref, image_ref,
673
 
                instance=instance)
 
689
        db.instance_update(self.context, instance['uuid'],
 
690
                           {"task_state": task_states.REBUILDING})
 
691
        self.compute.rebuild_instance(self.context, instance,
 
692
                                      image_ref, image_ref,
 
693
                                      injected_files=[],
 
694
                                      new_pass="new_password")
674
695
        instance = db.instance_get_by_uuid(self.context, instance_uuid)
675
696
        self.assertEquals(cur_time, instance['launched_at'])
676
697
        self.compute.terminate_instance(self.context,
755
776
        self.stubs.Set(nova.virt.fake.FakeDriver, 'get_info',
756
777
                       fake_driver_get_info)
757
778
 
 
779
        db.instance_update(self.context, instance['uuid'],
 
780
                           {"task_state": task_states.UPDATING_PASSWORD})
758
781
        self.assertRaises(exception.InstancePasswordSetFailed,
759
782
                          self.compute.set_admin_password,
760
783
                          self.context,
868
891
        instance_uuid = instance['uuid']
869
892
        self.compute.run_instance(self.context, instance=instance)
870
893
 
871
 
        # Make sure it works with both an instance and instance_uuid
872
894
        self.compute.reset_network(self.context, instance=instance)
873
 
        self.compute.reset_network(self.context, instance_uuid=instance_uuid)
874
895
 
875
 
        self.assertEqual(called['count'], 2)
 
896
        self.assertEqual(called['count'], 1)
876
897
 
877
898
        self.compute.terminate_instance(self.context, instance=instance)
878
899
 
882
903
        instance_uuid = instance['uuid']
883
904
        name = "myfakesnapshot"
884
905
        self.compute.run_instance(self.context, instance=instance)
 
906
        db.instance_update(self.context, instance['uuid'],
 
907
                           {"task_state": task_states.IMAGE_SNAPSHOT})
885
908
        self.compute.snapshot_instance(self.context, name, instance=instance)
886
909
        self.compute.terminate_instance(self.context, instance=instance)
887
910
 
894
917
 
895
918
        instance = jsonutils.to_primitive(self._create_fake_instance())
896
919
        self.compute.run_instance(self.context, instance=instance)
 
920
        db.instance_update(self.context, instance['uuid'],
 
921
                           {"task_state": task_states.IMAGE_SNAPSHOT})
897
922
        self.assertRaises(test.TestingException,
898
923
                          self.compute.snapshot_instance,
899
924
                          self.context, "failing_snapshot", instance=instance)
944
969
                                               instance=instance)
945
970
        self.assert_(console)
946
971
 
947
 
        # Also make sure it still works with just the instance UUID
948
 
        console = self.compute.get_vnc_console(self.context, 'novnc',
949
 
                                               instance_uuid=instance['uuid'])
950
 
        self.assert_(console)
951
 
 
952
972
        self.compute.terminate_instance(self.context, instance=instance)
953
973
 
954
974
    def test_xvpvnc_vnc_console(self):
987
1007
        self.compute.run_instance(self.context, instance=instance)
988
1008
 
989
1009
        diagnostics = self.compute.get_diagnostics(self.context,
990
 
                instance_uuid=instance['uuid'])
 
1010
                instance=instance)
991
1011
        self.assertEqual(diagnostics, 'FAKE_DIAGNOSTICS')
992
1012
 
993
1013
        diagnostics = self.compute.get_diagnostics(self.context,
1180
1200
 
1181
1201
        self.compute.terminate_instance(self.context, instance=instance)
1182
1202
 
1183
 
    def test_get_lock(self):
1184
 
        instance = jsonutils.to_primitive(self._create_fake_instance())
1185
 
        self.assertFalse(self.compute._get_lock(self.context,
1186
 
                                                instance['uuid']))
1187
 
        db.instance_update(self.context, instance['uuid'], {'locked': True})
1188
 
        self.assertTrue(self.compute._get_lock(self.context, instance['uuid']))
1189
 
 
1190
1203
    def test_lock(self):
1191
1204
        """ensure locked instance cannot be changed"""
1192
1205
        instance = jsonutils.to_primitive(self._create_fake_instance())
1201
1214
            instance = db.instance_get_by_uuid(self.context, instance_uuid)
1202
1215
            self.assertEqual(instance['task_state'], task_state)
1203
1216
 
 
1217
        # should fail with locked nonadmin context
 
1218
        self.compute_api.lock(self.context, instance)
 
1219
        instance = db.instance_get_by_uuid(self.context, instance_uuid)
 
1220
        self.assertRaises(exception.InstanceIsLocked,
 
1221
                          self.compute_api.reboot,
 
1222
                          non_admin_context, instance, 'SOFT')
 
1223
        check_task_state(None)
 
1224
 
 
1225
        # should fail with invalid task state
 
1226
        self.compute_api.unlock(self.context, instance)
1204
1227
        instance = db.instance_update(self.context, instance_uuid,
1205
1228
                                      {'task_state': task_states.REBOOTING})
1206
 
 
1207
 
        # should fail with locked nonadmin context, task_state won't be cleared
1208
 
        self.compute_api.lock(self.context, instance)
1209
 
        instance = db.instance_get_by_uuid(self.context, instance_uuid)
1210
 
        self.compute.reboot_instance(non_admin_context,
1211
 
                instance=jsonutils.to_primitive(instance))
1212
 
        check_task_state(task_states.REBOOTING)
1213
 
 
1214
 
        # should succeed with unlocked nonadmin context, task_state cleared
1215
 
        self.compute_api.unlock(self.context, instance)
1216
 
        instance = db.instance_get_by_uuid(self.context, instance_uuid)
1217
 
        self.compute.reboot_instance(non_admin_context,
1218
 
                instance=jsonutils.to_primitive(instance))
1219
 
        check_task_state(None)
 
1229
        self.assertRaises(exception.InstanceInvalidState,
 
1230
                          self.compute_api.reboot,
 
1231
                          non_admin_context, instance, 'SOFT')
 
1232
        check_task_state(task_states.REBOOTING)
 
1233
 
 
1234
        # should succeed with admin context
 
1235
        instance = db.instance_update(self.context, instance_uuid,
 
1236
                                      {'task_state': None})
 
1237
        self.compute_api.reboot(self.context, instance, 'SOFT')
 
1238
        check_task_state(task_states.REBOOTING)
1220
1239
 
1221
1240
        self.compute.terminate_instance(self.context,
1222
1241
                instance=jsonutils.to_primitive(instance))
1230
1249
        db.instance_update(self.context, instance['uuid'],
1231
1250
                           {"task_state": pre_task_state})
1232
1251
 
 
1252
        orig_elevated = self.context.elevated
 
1253
        orig_notify = self.compute._notify_about_instance_usage
 
1254
 
 
1255
        def _get_an_exception(*args, **kwargs):
 
1256
            raise Exception("This fails every single time!")
 
1257
 
 
1258
        self.stubs.Set(self.context, 'elevated', _get_an_exception)
 
1259
        self.stubs.Set(self.compute,
 
1260
                       '_notify_about_instance_usage', _get_an_exception)
 
1261
 
1233
1262
        raised = False
1234
1263
        try:
1235
1264
            ret_val = getattr(self.compute, operation)(self.context,
1236
1265
                                                       instance=instance)
1237
1266
        except Exception:
1238
1267
            raised = True
 
1268
        finally:
 
1269
            # self.context.elevated() is called in tearDown()
 
1270
            self.stubs.Set(self.context, 'elevated', orig_elevated)
 
1271
            self.stubs.Set(self.compute,
 
1272
                           '_notify_about_instance_usage', orig_notify)
 
1273
 
1239
1274
        self.assertTrue(raised)
1240
1275
 
1241
1276
        # Fetch the instance's task_state and make sure it went to None
1264
1299
            ("resume_instance", task_states.RESUMING),
1265
1300
            ]
1266
1301
 
1267
 
        def _get_an_exception(*args, **kwargs):
1268
 
            raise Exception("This fails every single time!")
1269
 
 
1270
 
        self.stubs.Set(self.compute, "_get_lock", _get_an_exception)
1271
1302
        for operation, pre_state in actions:
1272
1303
            self._test_state_revert(operation, pre_state)
1273
1304
 
1299
1330
 
1300
1331
        context = self.context.elevated()
1301
1332
        instance = jsonutils.to_primitive(self._create_fake_instance())
1302
 
        self.compute.prep_resize(context, instance=instance, instance_type={},
 
1333
        instance_type = instance_types.get_default_instance_type()
 
1334
        db.instance_update(self.context, instance["uuid"],
 
1335
                          {"task_state": task_states.RESIZE_PREP})
 
1336
        self.compute.prep_resize(context, instance=instance,
 
1337
                                 instance_type=instance_type,
1303
1338
                                 image={})
1304
1339
        migration_ref = db.migration_get_by_instance_and_status(context,
1305
1340
                instance['uuid'], 'pre-migrating')
 
1341
        db.instance_update(self.context, instance["uuid"],
 
1342
                           {"task_state": task_states.RESIZE_MIGRATED})
1306
1343
        self.compute.finish_resize(context,
1307
1344
                migration_id=int(migration_ref['id']),
1308
1345
                disk_info={}, image={}, instance=instance,
1324
1361
 
1325
1362
        context = self.context.elevated()
1326
1363
        instance = jsonutils.to_primitive(self._create_fake_instance())
1327
 
        self.compute.prep_resize(context, instance=instance, instance_type={},
 
1364
        instance_type = instance_types.get_default_instance_type()
 
1365
        self.compute.prep_resize(context, instance=instance,
 
1366
                                 instance_type=instance_type,
1328
1367
                                 image={}, reservations=reservations)
1329
1368
        migration_ref = db.migration_get_by_instance_and_status(context,
1330
1369
                instance['uuid'], 'pre-migrating')
1331
1370
 
 
1371
        db.instance_update(self.context, instance["uuid"],
 
1372
                           {"task_state": task_states.RESIZE_MIGRATED})
1332
1373
        self.assertRaises(test.TestingException, self.compute.finish_resize,
1333
1374
                          context, migration_id=int(migration_ref['id']),
1334
1375
                          disk_info={}, image={}, instance=instance,
1350
1391
 
1351
1392
        test_notifier.NOTIFICATIONS = []
1352
1393
        instance = db.instance_get_by_uuid(self.context, inst_ref['uuid'])
1353
 
 
 
1394
        orig_sys_metadata = db.instance_system_metadata_get(self.context,
 
1395
                inst_ref['uuid'])
1354
1396
        image_ref = instance["image_ref"]
1355
1397
        new_image_ref = image_ref + '-new_image_ref'
1356
1398
        db.instance_update(self.context, inst_ref['uuid'],
1360
1402
 
1361
1403
        instance = db.instance_get_by_uuid(self.context, inst_ref['uuid'])
1362
1404
 
 
1405
        db.instance_update(self.context, instance['uuid'],
 
1406
                           {"task_state": task_states.REBUILDING})
1363
1407
        self.compute.rebuild_instance(self.context.elevated(),
1364
 
                image_ref, new_image_ref,
1365
 
                instance=jsonutils.to_primitive(instance),
1366
 
                new_pass=password)
 
1408
                                      jsonutils.to_primitive(instance),
 
1409
                                      image_ref, new_image_ref,
 
1410
                                      injected_files=[],
 
1411
                                      new_pass=password,
 
1412
                                      orig_sys_metadata=orig_sys_metadata)
1367
1413
 
1368
1414
        instance = db.instance_get_by_uuid(self.context, inst_ref['uuid'])
1369
1415
 
1415
1461
        self.compute.run_instance(self.context, instance=instance)
1416
1462
 
1417
1463
        db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
 
1464
        db.instance_update(self.context, instance["uuid"],
 
1465
                           {"task_state": task_states.RESIZE_PREP})
1418
1466
        self.compute.prep_resize(context, instance=instance,
1419
1467
                instance_type=new_type, image={})
1420
1468
        migration_ref = db.migration_get_by_instance_and_status(context,
1421
1469
                                                instance['uuid'],
1422
1470
                                                'pre-migrating')
1423
 
        self.compute.resize_instance(context, migration_ref['id'], {},
1424
 
                                     instance=instance)
 
1471
        self.compute.resize_instance(context, instance=instance,
 
1472
                                     migration_id=migration_ref['id'],
 
1473
                                     image={})
1425
1474
        timeutils.set_time_override(cur_time)
1426
1475
        test_notifier.NOTIFICATIONS = []
1427
1476
 
1465
1514
        test_notifier.NOTIFICATIONS = []
1466
1515
 
1467
1516
        db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
 
1517
        instance_type = instance_types.get_default_instance_type()
1468
1518
        self.compute.prep_resize(context, instance=instance,
1469
 
                instance_type={}, image={})
 
1519
                instance_type=instance_type, image={})
1470
1520
        db.migration_get_by_instance_and_status(context,
1471
1521
                                                instance['uuid'],
1472
1522
                                                'pre-migrating')
1509
1559
        new_instance = db.instance_update(self.context, instance['uuid'],
1510
1560
                                          {'host': 'foo'})
1511
1561
        new_instance = jsonutils.to_primitive(new_instance)
 
1562
        instance_type = instance_types.get_default_instance_type()
1512
1563
 
1513
1564
        self.assertRaises(exception.MigrationError, self.compute.prep_resize,
1514
1565
                          context, instance=new_instance,
1515
 
                          instance_type={}, image={},
 
1566
                          instance_type=instance_type, image={},
1516
1567
                          reservations=reservations)
1517
1568
        self.compute.terminate_instance(context, instance=new_instance)
1518
1569
 
1526
1577
                       throw_up)
1527
1578
 
1528
1579
        instance = jsonutils.to_primitive(self._create_fake_instance())
 
1580
        instance_type = instance_types.get_default_instance_type()
1529
1581
        context = self.context.elevated()
1530
1582
 
1531
1583
        reservations = self._ensure_quota_reservations_rolledback()
1533
1585
        self.compute.run_instance(self.context, instance=instance)
1534
1586
        db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
1535
1587
        self.compute.prep_resize(context, instance=instance,
1536
 
                                 instance_type={}, image={},
 
1588
                                 instance_type=instance_type, image={},
1537
1589
                                 reservations=reservations)
1538
1590
        migration_ref = db.migration_get_by_instance_and_status(context,
1539
1591
                instance['uuid'], 'pre-migrating')
1540
1592
 
 
1593
        db.instance_update(self.context, instance['uuid'],
 
1594
                           {"task_state": task_states.RESIZE_PREP})
1541
1595
        #verify
1542
1596
        self.assertRaises(test.TestingException, self.compute.resize_instance,
1543
 
                          context, migration_ref['id'], {}, instance=instance,
 
1597
                          context, instance=instance,
 
1598
                          migration_id=migration_ref['id'], image={},
1544
1599
                          reservations=reservations)
1545
1600
        instance = db.instance_get_by_uuid(context, instance['uuid'])
1546
1601
        self.assertEqual(instance['vm_state'], vm_states.ERROR)
1551
1606
    def test_resize_instance(self):
1552
1607
        """Ensure instance can be migrated/resized"""
1553
1608
        instance = jsonutils.to_primitive(self._create_fake_instance())
 
1609
        instance_type = instance_types.get_default_instance_type()
1554
1610
        context = self.context.elevated()
1555
1611
 
1556
1612
        self.compute.run_instance(self.context, instance=instance)
1557
1613
        db.instance_update(self.context, instance['uuid'],
1558
1614
                           {'host': 'foo'})
1559
1615
        self.compute.prep_resize(context, instance=instance,
1560
 
                instance_type={}, image={})
 
1616
                instance_type=instance_type, image={})
1561
1617
        migration_ref = db.migration_get_by_instance_and_status(context,
1562
1618
                instance['uuid'], 'pre-migrating')
1563
 
        self.compute.resize_instance(context, migration_ref['id'], {},
1564
 
                                     instance=instance)
 
1619
        db.instance_update(self.context, instance['uuid'],
 
1620
                           {"task_state": task_states.RESIZE_PREP})
 
1621
        self.compute.resize_instance(context, instance=instance,
 
1622
                                     migration_id=migration_ref['id'],
 
1623
                                     image={})
1565
1624
        self.compute.terminate_instance(context,
1566
1625
            instance=jsonutils.to_primitive(instance))
1567
1626
 
1599
1658
        migration_ref = db.migration_get_by_instance_and_status(context,
1600
1659
                inst_ref['uuid'], 'pre-migrating')
1601
1660
 
1602
 
        self.compute.resize_instance(context, migration_ref['id'], {},
1603
 
                instance=jsonutils.to_primitive(inst_ref))
 
1661
        instance = jsonutils.to_primitive(inst_ref)
 
1662
        db.instance_update(self.context, instance["uuid"],
 
1663
                           {"task_state": task_states.RESIZE_PREP})
 
1664
        self.compute.resize_instance(context, instance=instance,
 
1665
                                     migration_id=migration_ref['id'],
 
1666
                                     image={})
1604
1667
        self.compute.finish_resize(context,
1605
1668
                    migration_id=int(migration_ref['id']), disk_info={},
1606
 
                    image={}, instance=jsonutils.to_primitive(inst_ref))
 
1669
                    image={}, instance=instance)
1607
1670
 
1608
1671
        # Prove that the instance size is now the new size
1609
1672
        inst_ref = db.instance_get_by_uuid(context, instance['uuid'])
1613
1676
 
1614
1677
        # Finally, revert and confirm the old flavor has been applied
1615
1678
        rpcinst = jsonutils.to_primitive(inst_ref)
 
1679
        db.instance_update(self.context, instance["uuid"],
 
1680
                           {"task_state": task_states.RESIZE_REVERTING})
1616
1681
        self.compute.revert_resize(context,
1617
1682
                migration_id=migration_ref['id'], instance=rpcinst,
1618
1683
                reservations=reservations)
1644
1709
        instance = jsonutils.to_primitive(self._create_fake_instance())
1645
1710
        self.compute.run_instance(self.context, instance=instance)
1646
1711
        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
 
1712
        instance_type = instance_types.get_default_instance_type()
1647
1713
        self.assertRaises(exception.MigrationError, self.compute.prep_resize,
1648
1714
                self.context, instance=instance,
1649
 
                instance_type={}, image={}, reservations=reservations)
 
1715
                instance_type=instance_type, image={},
 
1716
                reservations=reservations)
1650
1717
        self.compute.terminate_instance(self.context,
1651
1718
                instance=jsonutils.to_primitive(instance))
1652
1719
 
1661
1728
        reservations = self._ensure_quota_reservations_rolledback()
1662
1729
 
1663
1730
        inst_ref = jsonutils.to_primitive(self._create_fake_instance())
 
1731
        instance_type = instance_types.get_default_instance_type()
1664
1732
        context = self.context.elevated()
1665
1733
 
1666
1734
        self.compute.run_instance(self.context, instance=inst_ref)
1667
1735
        db.instance_update(self.context, inst_ref['uuid'], {'host': 'foo'})
1668
 
        self.compute.prep_resize(context, instance=inst_ref, instance_type={},
 
1736
        self.compute.prep_resize(context, instance=inst_ref,
 
1737
                                 instance_type=instance_type,
1669
1738
                                 image={}, reservations=reservations)
1670
1739
        migration_ref = db.migration_get_by_instance_and_status(context,
1671
1740
                inst_ref['uuid'], 'pre-migrating')
 
1741
        db.instance_update(self.context, inst_ref['uuid'],
 
1742
                           {"task_state": task_states.RESIZE_PREP})
1672
1743
        self.assertRaises(test.TestingException, self.compute.resize_instance,
1673
 
                          context, migration_ref['id'], {}, instance=inst_ref,
 
1744
                          context, instance=inst_ref,
 
1745
                          migration_id=migration_ref['id'], image={},
1674
1746
                          reservations=reservations)
1675
1747
        inst_ref = db.instance_get_by_uuid(context, inst_ref['uuid'])
1676
1748
        self.assertEqual(inst_ref['vm_state'], vm_states.ERROR)
1853
1925
                mox.IsA(instance), True, None, instance['host']).AndRaise(
1854
1926
                                        rpc.common.RemoteError('', '', ''))
1855
1927
 
 
1928
        db.instance_update(self.context, instance['uuid'],
 
1929
                           {'task_state': task_states.MIGRATING})
1856
1930
        # mocks for rollback
1857
1931
        rpc.call(c, 'network', {'method': 'setup_networks_on_host',
1858
1932
                                'args': {'instance_id': inst_id,
1864
1938
                {"method": "remove_volume_connection",
1865
1939
                 "args": {'instance': rpcinst,
1866
1940
                          'volume_id': volume_id},
1867
 
                 "version": "1.26"}, None)
 
1941
                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION},
 
1942
                 None)
1868
1943
        rpc.cast(c, topic,
1869
1944
                {"method": "rollback_live_migration_at_destination",
1870
1945
                 "args": {'instance': rpcinst},
1871
 
                 "version": "1.32"})
 
1946
                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION})
1872
1947
 
1873
1948
        # start test
1874
1949
        self.mox.ReplayAll()
1902
1977
                 "args": {'instance': instance,
1903
1978
                          'block_migration': False,
1904
1979
                          'disk': None},
1905
 
                 "version": '1.23'},
 
1980
                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION},
1906
1981
                None)
1907
1982
 
1908
1983
        # start test
1944
2019
        rpc.call(c, rpc.queue_get_for(c, FLAGS.compute_topic, dest),
1945
2020
            {"method": "post_live_migration_at_destination",
1946
2021
             "args": {'instance': inst_ref, 'block_migration': False},
1947
 
             "version": "1.20"}, None)
 
2022
             "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION},
 
2023
            None)
1948
2024
        self.mox.StubOutWithMock(self.compute.driver, 'unplug_vifs')
1949
2025
        self.compute.driver.unplug_vifs(inst_ref, [])
1950
2026
        rpc.call(c, 'network', {'method': 'setup_networks_on_host',
2508
2584
        try:
2509
2585
            sys_metadata = db.instance_system_metadata_get(self.context,
2510
2586
                    ref[0]['uuid'])
2511
 
            self.assertEqual(sys_metadata,
2512
 
                    {'image_kernel_id': 'fake_kernel_id',
 
2587
 
 
2588
            image_props = {'image_kernel_id': 'fake_kernel_id',
2513
2589
                     'image_ramdisk_id': 'fake_ramdisk_id',
2514
 
                     'image_something_else': 'meow', })
 
2590
                     'image_something_else': 'meow', }
 
2591
            for key, value in image_props.iteritems():
 
2592
                self.assertTrue(key in sys_metadata)
 
2593
                self.assertEqual(value, sys_metadata[key])
 
2594
 
2515
2595
        finally:
2516
2596
            db.instance_destroy(self.context, ref[0]['uuid'])
2517
2597
 
2659
2739
        instance_uuid = instance['uuid']
2660
2740
        self.compute.run_instance(self.context, instance=instance)
2661
2741
 
 
2742
        db.instance_update(self.context, instance['uuid'],
 
2743
                           {"task_state": task_states.STOPPING})
2662
2744
        self.compute.stop_instance(self.context, instance=instance)
2663
2745
 
2664
2746
        instance = db.instance_get_by_uuid(self.context, instance_uuid)
2881
2963
 
2882
2964
        self.assertEqual(instance['task_state'], None)
2883
2965
 
 
2966
        db.instance_update(self.context, instance['uuid'],
 
2967
                           {"task_state": task_states.PAUSING})
2884
2968
        self.compute.pause_instance(self.context, instance=instance)
2885
2969
        # set the state that the instance gets when pause finishes
2886
2970
        instance = db.instance_update(self.context, instance['uuid'],
2994
3078
 
2995
3079
        db.instance_destroy(self.context, inst_ref['uuid'])
2996
3080
 
 
3081
    def test_hard_reboot_of_soft_rebooting_instance(self):
 
3082
        """Ensure instance can be hard rebooted while soft rebooting"""
 
3083
        instance = jsonutils.to_primitive(self._create_fake_instance())
 
3084
        self.compute.run_instance(self.context, instance=instance)
 
3085
 
 
3086
        inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
 
3087
 
 
3088
        db.instance_update(self.context, instance['uuid'],
 
3089
                           {"task_state": task_states.REBOOTING})
 
3090
 
 
3091
        reboot_type = "HARD"
 
3092
        self.compute_api.reboot(self.context, inst_ref, reboot_type)
 
3093
 
 
3094
        inst_ref = db.instance_get_by_uuid(self.context, inst_ref['uuid'])
 
3095
        self.assertEqual(inst_ref['task_state'], task_states.REBOOTING_HARD)
 
3096
 
 
3097
        db.instance_destroy(self.context, inst_ref['uuid'])
 
3098
 
 
3099
    def test_soft_reboot_of_rebooting_instance(self):
 
3100
        """Ensure instance can't be soft rebooted while rebooting"""
 
3101
        instance = jsonutils.to_primitive(self._create_fake_instance())
 
3102
        self.compute.run_instance(self.context, instance=instance)
 
3103
 
 
3104
        inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
 
3105
 
 
3106
        db.instance_update(self.context, instance['uuid'],
 
3107
                           {"task_state": task_states.REBOOTING})
 
3108
 
 
3109
        inst_ref = db.instance_get_by_uuid(self.context, inst_ref['uuid'])
 
3110
        reboot_type = "SOFT"
 
3111
        self.assertRaises(exception.InstanceInvalidState,
 
3112
                          self.compute_api.reboot,
 
3113
                          self.context,
 
3114
                          inst_ref,
 
3115
                          reboot_type)
 
3116
 
2997
3117
    def test_hostname_create(self):
2998
3118
        """Ensure instance hostname is set during creation."""
2999
3119
        inst_type = instance_types.get_instance_type_by_name('m1.tiny')
3911
4031
            self.context, instance['uuid']):
3912
4032
            db.block_device_mapping_destroy(self.context, bdm['id'])
3913
4033
        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
3914
 
        self.compute.terminate_instance(self.context,
3915
 
                                        instance_uuid=instance['uuid'])
 
4034
        self.compute.terminate_instance(self.context, instance)
3916
4035
 
3917
4036
    def test_volume_size(self):
3918
4037
        ephemeral_size = 2
4010
4129
                self.context,
4011
4130
                {'locked': False},
4012
4131
                None,
4013
 
                '/dev/invalid')
 
4132
                '/invalid')
4014
4133
 
4015
4134
    def test_vnc_console(self):
4016
4135
        """Make sure we can a vnc console for an instance."""
4031
4150
        rpc_msg1 = {'method': 'get_vnc_console',
4032
4151
                    'args': {'instance': fake_instance,
4033
4152
                             'console_type': fake_console_type},
4034
 
                   'version': '1.17'}
 
4153
                   'version': compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION}
4035
4154
        rpc_msg2 = {'method': 'authorize_console',
4036
4155
                    'args': fake_connect_info,
4037
4156
                    'version': '1.0'}
4067
4186
        rpc_msg = {'method': 'get_console_output',
4068
4187
                   'args': {'instance': fake_instance,
4069
4188
                            'tail_length': fake_tail_length},
4070
 
                   'version': '1.7'}
 
4189
                   'version': compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION}
4071
4190
        rpc.call(self.context, 'compute.%s' % fake_instance['host'],
4072
4191
                rpc_msg, None).AndReturn(fake_console_output)
4073
4192
 
4177
4296
        rpc.cast(self.context, topic,
4178
4297
                {"method": "refresh_instance_security_rules",
4179
4298
                 "args": {'instance': jsonutils.to_primitive(instance)},
4180
 
                 "version": '1.41'})
 
4299
                 "version":
 
4300
                    compute_rpcapi.SecurityGroupAPI.BASE_RPC_API_VERSION})
4181
4301
        self.mox.ReplayAll()
4182
4302
 
4183
4303
        self.security_group_api.trigger_members_refresh(self.context, [1])
4205
4325
        rpc.cast(self.context, topic,
4206
4326
                {"method": "refresh_instance_security_rules",
4207
4327
                 "args": {'instance': jsonutils.to_primitive(instance)},
4208
 
                 "version": '1.41'})
 
4328
                 "version":
 
4329
                   compute_rpcapi.SecurityGroupAPI.BASE_RPC_API_VERSION})
4209
4330
        self.mox.ReplayAll()
4210
4331
 
4211
4332
        self.security_group_api.trigger_members_refresh(self.context, [1, 2])
4245
4366
        rpc.cast(self.context, topic,
4246
4367
                {"method": "refresh_instance_security_rules",
4247
4368
                 "args": {'instance': jsonutils.to_primitive(instance)},
4248
 
                 "version": '1.41'})
 
4369
                 "version":
 
4370
                   compute_rpcapi.SecurityGroupAPI.BASE_RPC_API_VERSION})
4249
4371
        self.mox.ReplayAll()
4250
4372
 
4251
4373
        self.security_group_api.trigger_rules_refresh(self.context, [1])
4265
4387
        rpc.cast(self.context, topic,
4266
4388
                {"method": "refresh_instance_security_rules",
4267
4389
                 "args": {'instance': jsonutils.to_primitive(instance)},
4268
 
                 "version": '1.41'})
 
4390
                 "version":
 
4391
                   compute_rpcapi.SecurityGroupAPI.BASE_RPC_API_VERSION})
4269
4392
        self.mox.ReplayAll()
4270
4393
 
4271
4394
        self.security_group_api.trigger_rules_refresh(self.context, [1, 2])
4593
4716
        self.assertEqual(call_info['msg'],
4594
4717
                {'method': 'get_host_uptime',
4595
4718
                 'args': {},
4596
 
                 'version': '1.1'})
 
4719
                 'version': compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION})
4597
4720
 
4598
4721
    def test_host_power_action(self):
4599
4722
        ctxt = context.RequestContext('fake', 'fake')
4932
5055
        # this won't be re-scheduled:
4933
5056
        self.assertRaises(ThatsNoOrdinaryRabbitException,
4934
5057
                self.compute._run_instance, self.context,
4935
 
                None, {}, None, None, None, None, self.fake_instance, None)
 
5058
                None, {}, None, None, None, None, self.fake_instance)
4936
5059
 
4937
5060
    def test_exception_with_rescheduling_enabled(self):
4938
5061
        """Spawn fails and re-scheduling is enabled.  Original exception
4962
5085
        # the original exception should now be raised:
4963
5086
        self.assertRaises(ThatsNoOrdinaryRabbitException,
4964
5087
                self.compute._run_instance, self.context,
4965
 
                None, {}, None, None, None, None, self.fake_instance, None)
 
5088
                None, {}, None, None, None, None, self.fake_instance)