Ejemplo n.º 1
0
    def check_can_live_migrate_destination(self, ctxt, instance, destination,
                                           block_migration, disk_over_commit):
        version = '4.11'
        if not self.client.can_send_version(version):
            # NOTE(eliqiao): This is a new feature that is only available
            # once all compute nodes support at least version 4.11.
            # This means the new REST API that supports this needs to handle
            # this exception correctly. This can all be removed when we bump
            # the major version of this RPC API.
            if block_migration is None or disk_over_commit is None:
                raise exception.LiveMigrationWithOldNovaNotSupported()
            else:
                version = '4.0'

        cctxt = self.client.prepare(server=destination, version=version)
        result = cctxt.call(ctxt, 'check_can_live_migrate_destination',
                            instance=instance,
                            block_migration=block_migration,
                            disk_over_commit=disk_over_commit)
        if isinstance(result, migrate_data_obj.LiveMigrateData):
            return result
        elif result:
            return migrate_data_obj.LiveMigrateData.detect_implementation(
                result)
        else:
            return result
Ejemplo n.º 2
0
class TestInstanceNotificationSampleWithMultipleCompute(
        notification_sample_base.NotificationSampleTestBase):
    def setUp(self):
        self.flags(use_neutron=True)
        super(TestInstanceNotificationSampleWithMultipleCompute, self).setUp()
        self.neutron = fixtures.NeutronFixture(self)
        self.useFixture(self.neutron)
        self.cinder = fixtures.CinderFixture(self)
        self.useFixture(self.cinder)

    def test_live_migration_actions(self):
        server = self._boot_a_server(
            extra_params={'networks': [{
                'port': self.neutron.port_1['id']
            }]})
        self._wait_for_notification('instance.create.end')
        # server will boot on host1
        self.useFixture(fixtures.ConfPatcher(host='host2'))
        self.compute2 = self.start_service('compute', host='host2')

        actions = [
            self._test_live_migration_rollback,
        ]

        for action in actions:
            fake_notifier.reset()
            action(server)
            # Ensure that instance is in active state after an action
            self._wait_for_state_change(self.admin_api, server, 'ACTIVE')

    @mock.patch('nova.compute.rpcapi.ComputeAPI.pre_live_migration',
                side_effect=exception.LiveMigrationWithOldNovaNotSupported())
    def _test_live_migration_rollback(self, server, mock_migration):
        post = {
            'os-migrateLive': {
                'host': 'host2',
                'block_migration': True,
                'force': True,
            }
        }
        self.admin_api.post_server_action(server['id'], post)
        self._wait_for_notification('instance.live_migration_rollback.start')
        self._wait_for_notification('instance.live_migration_rollback.end')

        self.assertEqual(2, len(fake_notifier.VERSIONED_NOTIFICATIONS))
        self._verify_notification(
            'instance-live_migration_rollback-start',
            replacements={
                'reservation_id': server['reservation_id'],
                'uuid': server['id']
            },
            actual=fake_notifier.VERSIONED_NOTIFICATIONS[0])
        self._verify_notification(
            'instance-live_migration_rollback-end',
            replacements={
                'reservation_id': server['reservation_id'],
                'uuid': server['id']
            },
            actual=fake_notifier.VERSIONED_NOTIFICATIONS[1])
Ejemplo n.º 3
0
 def test_migrate_live_migration_with_old_nova_not_supported(self):
     self._test_migrate_live_failed_with_exception(
         exception.LiveMigrationWithOldNovaNotSupported())