Example #1
0
    def test_set_vm_state_and_notify(self, mock_save, mock_add, mock_get):
        expected_uuid = 'fake-uuid'
        request_spec = dict(instance_properties=dict(uuid='other-uuid'))
        updates = dict(vm_state='fake-vm-state')
        service = 'fake-service'
        method = 'fake-method'
        exc_info = 'exc_info'

        payload = dict(request_spec=request_spec,
                       instance_properties=request_spec.get(
                           'instance_properties', {}),
                       instance_id=expected_uuid,
                       state='fake-vm-state',
                       method=method,
                       reason=exc_info)
        event_type = '%s.%s' % (service, method)

        scheduler_utils.set_vm_state_and_notify(self.context,
                                                expected_uuid,
                                                service,
                                                method,
                                                updates,
                                                exc_info,
                                                request_spec)
        mock_save.assert_called_once_with()
        mock_add.assert_called_once_with(self.context, mock.ANY,
                                         exc_info, mock.ANY)
        self.assertIsInstance(mock_add.call_args[0][1], objects.Instance)
        self.assertIsInstance(mock_add.call_args[0][3], tuple)
        mock_get.return_value.error.assert_called_once_with(self.context,
                                                            event_type,
                                                            payload)
Example #2
0
 def _live_migrate(self, context, instance, scheduler_hint, block_migration, disk_over_commit):
     destination = scheduler_hint.get("host")
     try:
         live_migrate.execute(context, instance, destination, block_migration, disk_over_commit)
     except (
         exception.NoValidHost,
         exception.ComputeServiceUnavailable,
         exception.InvalidHypervisorType,
         exception.InvalidCPUInfo,
         exception.UnableToMigrateToSelf,
         exception.DestinationHypervisorTooOld,
         exception.InvalidLocalStorage,
         exception.InvalidSharedStorage,
         exception.HypervisorUnavailable,
         exception.MigrationPreCheckError,
     ) as ex:
         with excutils.save_and_reraise_exception():
             # TODO(johngarbutt) - eventually need instance actions here
             request_spec = {"instance_properties": {"uuid": instance["uuid"]}}
             scheduler_utils.set_vm_state_and_notify(
                 context,
                 "compute_task",
                 "migrate_server",
                 dict(vm_state=instance["vm_state"], task_state=None, expected_task_state=task_states.MIGRATING),
                 ex,
                 request_spec,
                 self.db,
             )
     except Exception as ex:
         LOG.error(
             _("Migration of instance %(instance_id)s to host" " %(dest)s unexpectedly failed."),
             {"instance_id": instance["uuid"], "dest": destination},
             exc_info=True,
         )
         raise exception.MigrationError(reason=ex)
Example #3
0
 def _live_migrate(self, context, instance, scheduler_hint,
                   block_migration, disk_over_commit):
     destination = scheduler_hint.get("host")
     try:
         live_migrate.execute(context, instance, destination,
                          block_migration, disk_over_commit)
     except (exception.NoValidHost,
             exception.ComputeServiceUnavailable,
             exception.InvalidHypervisorType,
             exception.UnableToMigrateToSelf,
             exception.DestinationHypervisorTooOld,
             exception.InvalidLocalStorage,
             exception.InvalidSharedStorage,
             exception.MigrationPreCheckError) as ex:
         with excutils.save_and_reraise_exception():
             #TODO(johngarbutt) - eventually need instance actions here
             request_spec = {'instance_properties': {
                 'uuid': instance['uuid'], },
             }
             scheduler_utils.set_vm_state_and_notify(context,
                     'compute_task', 'migrate_server',
                     dict(vm_state=instance['vm_state'],
                          task_state=None,
                          expected_task_state=task_states.MIGRATING,),
                     ex, request_spec, self.db)
     except Exception as ex:
         with excutils.save_and_reraise_exception():
             request_spec = {'instance_properties': {
                 'uuid': instance['uuid'], },
             }
             scheduler_utils.set_vm_state_and_notify(context,
                     'compute_task', 'migrate_server',
                     {'vm_state': vm_states.ERROR},
                     ex, request_spec, self.db)
Example #4
0
 def _live_migrate(self, context, instance, scheduler_hint,
                   block_migration, disk_over_commit):
     destination = scheduler_hint.get("host")
     try:
         live_migrate.execute(context, instance, destination,
                          block_migration, disk_over_commit)
     except (exception.NoValidHost,
             exception.ComputeServiceUnavailable,
             exception.InvalidHypervisorType,
             exception.InvalidCPUInfo,
             exception.UnableToMigrateToSelf,
             exception.DestinationHypervisorTooOld,
             exception.InvalidLocalStorage,
             exception.InvalidSharedStorage,
             exception.HypervisorUnavailable,
             exception.InstanceNotRunning,
             exception.MigrationPreCheckError) as ex:
         with excutils.save_and_reraise_exception():
             # TODO(johngarbutt) - eventually need instance actions here
             request_spec = {'instance_properties': {
                 'uuid': instance['uuid'], },
             }
             scheduler_utils.set_vm_state_and_notify(context,
                     'compute_task', 'migrate_server',
                     dict(vm_state=instance['vm_state'],
                          task_state=None,
                          expected_task_state=task_states.MIGRATING,),
                     ex, request_spec, self.db)
     except Exception as ex:
         LOG.error(_('Migration of instance %(instance_id)s to host'
                    ' %(dest)s unexpectedly failed.'),
                    {'instance_id': instance['uuid'], 'dest': destination},
                    exc_info=True)
         raise exception.MigrationError(reason=ex)
Example #5
0
 def _set_vm_state(context, instance, ex, vm_state=None,
                   task_state=None):
     request_spec = {'instance_properties': {
         'uuid': instance['uuid'], },
     }
     scheduler_utils.set_vm_state_and_notify(context,
         'compute_task', 'migrate_server',
         dict(vm_state=vm_state,
              task_state=task_state,
              expected_task_state=task_states.MIGRATING,),
         ex, request_spec, self.db)
Example #6
0
 def _set_vm_state(context, instance, ex, vm_state=None, task_state=None):
     request_spec = {"instance_properties": {"uuid": instance["uuid"]}}
     scheduler_utils.set_vm_state_and_notify(
         context,
         instance.uuid,
         "compute_task",
         "migrate_server",
         dict(vm_state=vm_state, task_state=task_state, expected_task_state=task_states.MIGRATING),
         ex,
         request_spec,
         self.db,
     )
    def _test_set_vm_state_and_notify(self, request_spec,
                                      expected_uuids):
        updates = dict(vm_state='fake-vm-state')
        service = 'fake-service'
        method = 'fake-method'
        exc_info = 'exc_info'

        self.mox.StubOutWithMock(compute_utils,
                                 'add_instance_fault_from_exc')
        self.mox.StubOutWithMock(notifications, 'send_update')
        self.mox.StubOutWithMock(db, 'instance_update_and_get_original')

        self.mox.StubOutWithMock(rpc, 'get_notifier')
        notifier = self.mox.CreateMockAnything()
        rpc.get_notifier(service).AndReturn(notifier)

        old_ref = 'old_ref'
        new_ref = 'new_ref'
        inst_obj = 'inst_obj'

        for _uuid in expected_uuids:
            db.instance_update_and_get_original(
                    self.context, _uuid, updates,
                    columns_to_join=['system_metadata']).AndReturn(
                            (old_ref, new_ref))
            notifications.send_update(self.context, old_ref, inst_obj,
                                      service=service)
            compute_utils.add_instance_fault_from_exc(
                    self.context,
                    new_ref, exc_info, mox.IsA(tuple))

            payload = dict(request_spec=request_spec,
                           instance_properties=request_spec.get(
                               'instance_properties', {}),
                           instance_id=_uuid,
                           state='fake-vm-state',
                           method=method,
                           reason=exc_info)
            event_type = '%s.%s' % (service, method)
            notifier.error(self.context, event_type, payload)

        self.mox.ReplayAll()

        with mock.patch.object(objects.Instance, '_from_db_object',
                               return_value=inst_obj):
            scheduler_utils.set_vm_state_and_notify(self.context,
                                                    service,
                                                    method,
                                                    updates,
                                                    exc_info,
                                                    request_spec,
                                                    db)
    def _test_set_vm_state_and_notify(self, request_spec,
                                      expected_uuids):
        updates = dict(vm_state='fake-vm-state')
        service = 'fake-service'
        method = 'fake-method'
        exc_info = 'exc_info'

        self.mox.StubOutWithMock(compute_utils,
                                 'add_instance_fault_from_exc')
        self.mox.StubOutWithMock(notifications, 'send_update')
        self.mox.StubOutWithMock(db, 'instance_update_and_get_original')

        self.mox.StubOutWithMock(notify, 'get_notifier')
        notifier = self.mox.CreateMockAnything()
        notify.get_notifier('conductor', CONF.host).AndReturn(notifier)
        notify.get_notifier(service).AndReturn(notifier)

        old_ref = 'old_ref'
        new_ref = 'new_ref'

        for uuid in expected_uuids:
            db.instance_update_and_get_original(
                    self.context, uuid, updates).AndReturn((old_ref, new_ref))
            notifications.send_update(self.context, old_ref, new_ref,
                                      service=service)
            compute_utils.add_instance_fault_from_exc(
                    self.context,
                    mox.IsA(conductor_api.LocalAPI),
                    new_ref, exc_info, mox.IsA(tuple))

            payload = dict(request_spec=request_spec,
                           instance_properties=request_spec.get(
                               'instance_properties', {}),
                           instance_id=uuid,
                           state='fake-vm-state',
                           method=method,
                           reason=exc_info)
            event_type = '%s.%s' % (service, method)
            notifier.error(self.context, event_type, payload)

        self.mox.ReplayAll()

        scheduler_utils.set_vm_state_and_notify(self.context,
                                                service,
                                                method,
                                                updates,
                                                exc_info,
                                                request_spec,
                                                db)
    def _test_set_vm_state_and_notify(self, request_spec,
                                      expected_uuids):
        updates = dict(vm_state='fake-vm-state')
        service = 'fake-service'
        method = 'fake-method'
        exc_info = 'exc_info'

        self.mox.StubOutWithMock(compute_utils,
                                 'add_instance_fault_from_exc')
        self.mox.StubOutWithMock(notifications, 'send_update')
        self.mox.StubOutWithMock(db, 'instance_update_and_get_original')

        self.mox.StubOutWithMock(rpc, 'get_notifier')
        notifier = self.mox.CreateMockAnything()
        rpc.get_notifier('conductor', CONF.host).AndReturn(notifier)
        rpc.get_notifier(service).AndReturn(notifier)

        old_ref = 'old_ref'
        new_ref = 'new_ref'

        for uuid in expected_uuids:
            db.instance_update_and_get_original(
                    self.context, uuid, updates).AndReturn((old_ref, new_ref))
            notifications.send_update(self.context, old_ref, new_ref,
                                      service=service)
            compute_utils.add_instance_fault_from_exc(
                    self.context,
                    mox.IsA(conductor_api.LocalAPI),
                    new_ref, exc_info, mox.IsA(tuple))

            payload = dict(request_spec=request_spec,
                           instance_properties=request_spec.get(
                               'instance_properties', {}),
                           instance_id=uuid,
                           state='fake-vm-state',
                           method=method,
                           reason=exc_info)
            event_type = '%s.%s' % (service, method)
            notifier.error(self.context, event_type, payload)

        self.mox.ReplayAll()

        scheduler_utils.set_vm_state_and_notify(self.context,
                                                service,
                                                method,
                                                updates,
                                                exc_info,
                                                request_spec,
                                                db)
Example #10
0
 def _set_vm_state(context,
                   instance,
                   ex,
                   vm_state=None,
                   task_state=None):
     request_spec = {
         'instance_properties': {
             'uuid': instance['uuid'],
         },
     }
     scheduler_utils.set_vm_state_and_notify(
         context, instance.uuid, 'compute_task', 'migrate_server',
         dict(
             vm_state=vm_state,
             task_state=task_state,
             expected_task_state=task_states.MIGRATING,
         ), ex, request_spec, self.db)
Example #11
0
    def _test_set_vm_state_and_notify(self, mock_save, mock_add, mock_notifier,
                                      mock_notify_task,
                                      request_spec, payload_request_spec):
        expected_uuid = uuids.instance
        updates = dict(vm_state='fake-vm-state')
        service = 'fake-service'
        method = 'fake-method'
        exc_info = 'exc_info'

        payload = dict(request_spec=payload_request_spec,
                       instance_properties=payload_request_spec.get(
                           'instance_properties', {}),
                       instance_id=expected_uuid,
                       state='fake-vm-state',
                       method=method,
                       reason=exc_info)
        event_type = '%s.%s' % (service, method)

        scheduler_utils.set_vm_state_and_notify(self.context,
                                                expected_uuid,
                                                service,
                                                method,
                                                updates,
                                                exc_info,
                                                request_spec)
        mock_save.assert_called_once_with()
        mock_add.assert_called_once_with(self.context, mock.ANY,
                                         exc_info, mock.ANY)
        self.assertIsInstance(mock_add.call_args[0][1], objects.Instance)
        self.assertIsInstance(mock_add.call_args[0][3], tuple)
        mock_notifier.return_value.error.assert_called_once_with(self.context,
                                                                 event_type,
                                                                 payload)
        mock_notify_task.assert_called_once_with(
            self.context, method, expected_uuid,
            payload_request_spec, updates['vm_state'],
            exc_info)
Example #12
0
    def _test_set_vm_state_and_notify(self, mock_save, mock_add, mock_notifier,
                                      mock_notify_task,
                                      request_spec, payload_request_spec):
        expected_uuid = uuids.instance
        updates = dict(vm_state='fake-vm-state')
        service = 'fake-service'
        method = 'fake-method'
        exc_info = 'exc_info'

        payload = dict(request_spec=payload_request_spec,
                       instance_properties=payload_request_spec.get(
                           'instance_properties', {}),
                       instance_id=expected_uuid,
                       state='fake-vm-state',
                       method=method,
                       reason=exc_info)
        event_type = '%s.%s' % (service, method)

        scheduler_utils.set_vm_state_and_notify(self.context,
                                                expected_uuid,
                                                service,
                                                method,
                                                updates,
                                                exc_info,
                                                request_spec)
        mock_save.assert_called_once_with()
        mock_add.assert_called_once_with(self.context, mock.ANY,
                                         exc_info, mock.ANY)
        self.assertIsInstance(mock_add.call_args[0][1], objects.Instance)
        self.assertIsInstance(mock_add.call_args[0][3], tuple)
        mock_notifier.return_value.error.assert_called_once_with(self.context,
                                                                 event_type,
                                                                 payload)
        mock_notify_task.assert_called_once_with(
            self.context, method, expected_uuid,
            payload_request_spec, updates['vm_state'],
            exc_info, test.MatchType(str))
Example #13
0
 def _live_migrate(self, context, instance, scheduler_hint, block_migration,
                   disk_over_commit):
     destination = scheduler_hint.get("host")
     try:
         live_migrate.execute(context, instance, destination,
                              block_migration, disk_over_commit)
     except (exception.NoValidHost, exception.ComputeServiceUnavailable,
             exception.InvalidHypervisorType,
             exception.UnableToMigrateToSelf,
             exception.DestinationHypervisorTooOld,
             exception.InvalidLocalStorage, exception.InvalidSharedStorage,
             exception.MigrationPreCheckError) as ex:
         with excutils.save_and_reraise_exception():
             #TODO(johngarbutt) - eventually need instance actions here
             request_spec = {
                 'instance_properties': {
                     'uuid': instance['uuid'],
                 },
             }
             scheduler_utils.set_vm_state_and_notify(
                 context, 'compute_task', 'migrate_server',
                 dict(
                     vm_state=instance['vm_state'],
                     task_state=None,
                     expected_task_state=task_states.MIGRATING,
                 ), ex, request_spec, self.db)
     except Exception as ex:
         with excutils.save_and_reraise_exception():
             request_spec = {
                 'instance_properties': {
                     'uuid': instance['uuid'],
                 },
             }
             scheduler_utils.set_vm_state_and_notify(
                 context, 'compute_task', 'migrate_server',
                 {'vm_state': vm_states.ERROR}, ex, request_spec, self.db)
Example #14
0
 def _live_migrate(self, context, instance, scheduler_hint, block_migration,
                   disk_over_commit):
     destination = scheduler_hint.get("host")
     try:
         live_migrate.execute(context, instance, destination,
                              block_migration, disk_over_commit)
     except (exception.NoValidHost, exception.ComputeServiceUnavailable,
             exception.InvalidHypervisorType, exception.InvalidCPUInfo,
             exception.UnableToMigrateToSelf,
             exception.DestinationHypervisorTooOld,
             exception.InvalidLocalStorage, exception.InvalidSharedStorage,
             exception.HypervisorUnavailable, exception.InstanceNotRunning,
             exception.MigrationPreCheckError,
             exception.LiveMigrationWithOldNovaNotSafe) as ex:
         with excutils.save_and_reraise_exception():
             # TODO(johngarbutt) - eventually need instance actions here
             request_spec = {
                 'instance_properties': {
                     'uuid': instance['uuid'],
                 },
             }
             scheduler_utils.set_vm_state_and_notify(
                 context, 'compute_task', 'migrate_server',
                 dict(
                     vm_state=instance['vm_state'],
                     task_state=None,
                     expected_task_state=task_states.MIGRATING,
                 ), ex, request_spec, self.db)
     except Exception as ex:
         LOG.error(_LE('Migration of instance %(instance_id)s to host'
                       ' %(dest)s unexpectedly failed.'), {
                           'instance_id': instance['uuid'],
                           'dest': destination
                       },
                   exc_info=True)
         raise exception.MigrationError(reason=six.text_type(ex))
Example #15
0
 def _set_vm_state_and_notify(self, method, updates, context, ex, request_spec):
     scheduler_utils.set_vm_state_and_notify(context, "scheduler", method, updates, ex, request_spec, self.db)
Example #16
0
 def _set_vm_state_and_notify(self, context, instance_uuid, method, updates, ex, request_spec):
     scheduler_utils.set_vm_state_and_notify(
         context, instance_uuid, "compute_task", method, updates, ex, request_spec, self.db
     )
Example #17
0
 def _set_vm_state_and_notify(self, context, method, updates, ex,
                              request_spec):
     scheduler_utils.set_vm_state_and_notify(context, 'compute_task',
                                             method, updates, ex,
                                             request_spec, self.db)
Example #18
0
 def _set_vm_state_and_notify(self, context, method, updates, ex,
                              request_spec):
     scheduler_utils.set_vm_state_and_notify(
             context, 'compute_task', method, updates,
             ex, request_spec, self.db)