Beispiel #1
0
    def test_restore_raises_conflict_on_invalid_state(self):
        self.mox.StubOutWithMock(compute_api.API, 'get')
        self.mox.StubOutWithMock(compute_api.API, 'restore')

        fake_instance = 'fake_instance'
        exc = exception.InstanceInvalidState(attr='fake_attr',
                                             state='fake_state',
                                             method='fake_method',
                                             instance_uuid='fake')

        compute_api.API.get(self.fake_context,
                            self.fake_uuid,
                            expected_attrs=None,
                            want_objects=True).AndReturn(fake_instance)
        compute_api.API.restore(self.fake_context, fake_instance).AndRaise(exc)

        self.mox.ReplayAll()
        self.assertRaises(webob.exc.HTTPConflict, self.extension._restore,
                          self.fake_req, self.fake_uuid, self.fake_input_dict)
Beispiel #2
0
    def test_restore_raises_conflict_on_invalid_state(self,
            mock_restore, mock_get):
        instance = fake_instance.fake_instance_obj(
            self.fake_req.environ['nova.context'])
        mock_get.return_value = instance
        mock_restore.side_effect = exception.InstanceInvalidState(
            attr='fake_attr', state='fake_state', method='fake_method',
            instance_uuid='fake')

        self.assertRaises(webob.exc.HTTPConflict, self.extension._restore,
                self.fake_req, self.fake_uuid, self.fake_input_dict)

        mock_get.assert_called_once_with(self.fake_context,
                                         self.fake_uuid,
                                         expected_attrs=None,
                                         cell_down_support=False)

        mock_restore.assert_called_once_with(self.fake_context,
                                             instance)
Beispiel #3
0
    def _test_invalid_state(self,
                            action,
                            method=None,
                            body_map=None,
                            compute_api_args_map=None,
                            exception_arg=None):
        # Reset the mock.
        self.mock_get.reset_mock()

        if method is None:
            method = action.replace('_', '')
        if body_map is None:
            body_map = {}
        if compute_api_args_map is None:
            compute_api_args_map = {}

        instance = self._stub_instance_get()

        args, kwargs = compute_api_args_map.get(action, ((), {}))

        with mock.patch.object(self.compute_api,
                               method,
                               side_effect=exception.InstanceInvalidState(
                                   attr='vm_state',
                                   instance_uuid=instance.uuid,
                                   state='foo',
                                   method=method)) as mock_method:
            controller_function = getattr(self.controller, action)
            ex = self.assertRaises(webob.exc.HTTPConflict,
                                   controller_function,
                                   self.req,
                                   instance.uuid,
                                   body=body_map)
            self.assertIn(
                "Cannot \'%(action)s\' instance %(id)s" % {
                    'action': exception_arg or method,
                    'id': instance.uuid
                }, ex.explanation)
            mock_method.assert_called_once_with(self.context, instance, *args,
                                                **kwargs)
        self.mock_get.assert_called_once_with(self.context,
                                              instance.uuid,
                                              expected_attrs=None)
    def test_force_delete_raises_conflict_on_invalid_state(self):
        self.mox.StubOutWithMock(compute_api.API, 'get')
        self.mox.StubOutWithMock(compute_api.API, 'force_delete')

        fake_instance = 'fake_instance'

        compute_api.API.get(self.fake_context,
                            self.fake_uuid).AndReturn(fake_instance)

        exc = exception.InstanceInvalidState(attr='fake_attr',
                                             state='fake_state',
                                             method='fake_method',
                                             instance_uuid='fake')

        compute_api.API.force_delete(self.fake_context, fake_instance)\
            .AndRaise(exc)

        self.mox.ReplayAll()
        self.assertRaises(webob.exc.HTTPConflict, self.extension._force_delete,
                          self.fake_req, self.fake_uuid, self.fake_input_dict)
Beispiel #5
0
class ServerDiagnosticsTest(test.NoDBTestCase):
    def setUp(self):
        super(ServerDiagnosticsTest, self).setUp()
        self.flags(verbose=True,
                   osapi_compute_extension=[
                       'nova.api.openstack.compute.contrib.select_extensions'
                   ],
                   osapi_compute_ext_list=['Server_diagnostics'])

        self.router = compute.APIRouter(init_only=('servers', 'diagnostics'))

    @mock.patch.object(compute_api.API, 'get_diagnostics',
                       fake_get_diagnostics)
    @mock.patch.object(compute_api.API, 'get', fake_instance_get)
    def test_get_diagnostics(self):
        req = fakes.HTTPRequest.blank('/fake/servers/%s/diagnostics' % UUID)
        res = req.get_response(self.router)
        output = jsonutils.loads(res.body)
        self.assertEqual(output, {'data': 'Some diagnostic info'})

    @mock.patch.object(compute_api.API, 'get_diagnostics',
                       fake_get_diagnostics)
    @mock.patch.object(compute_api.API,
                       'get',
                       side_effect=exception.InstanceNotFound(instance_id=UUID)
                       )
    def test_get_diagnostics_with_non_existed_instance(self, mock_get):
        req = fakes.HTTPRequest.blank('/fake/servers/%s/diagnostics' % UUID)
        res = req.get_response(self.router)
        self.assertEqual(res.status_int, 404)

    @mock.patch.object(
        compute_api.API,
        'get_diagnostics',
        side_effect=exception.InstanceInvalidState('fake message'))
    @mock.patch.object(compute_api.API, 'get', fake_instance_get)
    def test_get_diagnostics_raise_conflict_on_invalid_state(
            self, mock_get_diagnostics):
        req = fakes.HTTPRequest.blank('/fake/servers/%s/diagnostics' % UUID)
        res = req.get_response(self.router)
        self.assertEqual(409, res.status_int)
    def _test_invalid_state(self,
                            action,
                            method=None,
                            body_map=None,
                            compute_api_args_map=None,
                            exception_arg=None,
                            expected_attrs=None):
        if method is None:
            method = action.replace('_', '')
        if body_map is None:
            body_map = {}
        if compute_api_args_map is None:
            compute_api_args_map = {}

        instance = self._stub_instance_get(expected_attrs=expected_attrs)

        args, kwargs = compute_api_args_map.get(action, ((), {}))

        getattr(self.compute_api,
                method)(self.context, instance, *args, **kwargs).AndRaise(
                    exception.InstanceInvalidState(attr='vm_state',
                                                   instance_uuid=instance.uuid,
                                                   state='foo',
                                                   method=method))

        self.mox.ReplayAll()
        controller_function = getattr(self.controller, action)
        ex = self.assertRaises(webob.exc.HTTPConflict,
                               controller_function,
                               self.req,
                               instance.uuid,
                               body=body_map)
        self.assertIn(
            "Cannot \'%(action)s\' instance %(id)s" % {
                'action': exception_arg or method,
                'id': instance.uuid
            }, ex.explanation)
        # Do these here instead of tearDown because this method is called
        # more than once for the same test case
        self.mox.VerifyAll()
        self.mox.UnsetStubs()
Beispiel #7
0
 def update(self, context, instance, **kwargs):
     """Update an instance."""
     cell_name = instance.cell_name
     if cell_name and self._cell_read_only(cell_name):
         raise exception.InstanceInvalidState(attr="vm_state",
                                              instance_uuid=instance.uuid,
                                              state="temporary_readonly",
                                              method='update')
     rv = super(ComputeCellsAPI, self).update(context, instance, **kwargs)
     kwargs_copy = kwargs.copy()
     # We need to skip vm_state/task_state updates as the child
     # cell is authoritative for these.  The admin API does
     # support resetting state, but it has been converted to use
     # Instance.save() with an appropriate kwarg.
     kwargs_copy.pop('vm_state', None)
     kwargs_copy.pop('task_state', None)
     if kwargs_copy:
         try:
             self._cast_to_cells(context, instance, 'update', **kwargs_copy)
         except exception.InstanceUnknownCell:
             pass
     return rv
Beispiel #8
0
 def _handle_cell_delete(self, context, instance, method, method_name):
     """Terminate an instance."""
     # We can't use the decorator because we have special logic in the
     # case we don't know the cell_name...
     cell_name = instance['cell_name']
     if cell_name and self._cell_read_only(cell_name):
         raise exception.InstanceInvalidState(
             attr="vm_state",
             instance_uuid=instance['uuid'],
             state="temporary_readonly",
             method=method_name)
     method(context, instance)
     try:
         self._cast_to_cells(context, instance, method_name)
     except exception.InstanceUnknownCell:
         # If there's no cell, there's also no host... which means
         # the instance was destroyed from the DB here.  Let's just
         # broadcast a message down to all cells and hope this ends
         # up resolving itself...  Worse case.. the instance will
         # show back up again here.
         delete_type = method == 'soft_delete' and 'soft' or 'hard'
         self.cells_rpcapi.instance_delete_everywhere(
             context, instance['uuid'], delete_type)
    def _test_invalid_state(self,
                            action,
                            method=None,
                            body_map=None,
                            compute_api_args_map=None):
        if method is None:
            method = action
        if body_map is None:
            body_map = {}
        if compute_api_args_map is None:
            compute_api_args_map = {}

        instance = self._stub_instance_get()

        args, kwargs = compute_api_args_map.get(action, ((), {}))

        getattr(self.compute_api,
                method)(self.context, instance, *args, **kwargs).AndRaise(
                    exception.InstanceInvalidState(attr='vm_state',
                                                   instance_uuid=instance.uuid,
                                                   state='foo',
                                                   method=method))

        self.mox.ReplayAll()

        res = self._make_request('/servers/%s/action' % instance.uuid,
                                 {action: body_map.get(action)})
        self.assertEqual(409, res.status_int)
        self.assertIn(
            "Cannot \'%(action)s\' instance %(id)s" % {
                'action': action,
                'id': instance.uuid
            }, res.body)
        # Do these here instead of tearDown because this method is called
        # more than once for the same test case
        self.mox.VerifyAll()
        self.mox.UnsetStubs()
Beispiel #10
0
 def fake_rescue(*args, **kwargs):
     raise exception.InstanceInvalidState('fake message')
Beispiel #11
0
 def fake_revert_resize(*args, **kwargs):
     raise exception.InstanceInvalidState(attr='fake_attr',
         state='fake_state', method='fake_method',
         instance_uuid='fake')
Beispiel #12
0
 def snapshot(*args, **kwargs):
     raise exception.InstanceInvalidState(attr='fake_attr',
         state='fake_state', method='fake_method',
         instance_uuid='fake')
Beispiel #13
0
def fake_swap_volume_instance_invalid_state(self, context, instance, volume_id,
                                            device):
    raise exception.InstanceInvalidState(instance_uuid=UUID1,
                                         state='',
                                         method='',
                                         attr='')
Beispiel #14
0
 def test_migrate_live_instance_not_active(self):
     self._test_migrate_live_failed_with_exception(
         exception.InstanceInvalidState(
             instance_uuid='', state='', attr='', method=''),
         expected_status_code=409,
         check_response=False)
Beispiel #15
0
 def test_migrate_live_instance_not_active(self):
     self._test_migrate_live_failed_with_exception(
         exception.InstanceInvalidState(
             instance_uuid='', state='', attr='', method=''),
         expected_exc=webob.exc.HTTPConflict,
         check_response=False)
class ServerDiagnosticsTest(test.NoDBTestCase):
    def setUp(self):
        super(ServerDiagnosticsTest, self).setUp()
        self.router = compute.APIRouterV3(init_only=('servers',
                                                     'os-server-diagnostics'))

    @mock.patch.object(compute_api.API, 'get_instance_diagnostics',
                       fake_get_instance_diagnostics)
    @mock.patch.object(compute_api.API, 'get', fake_instance_get)
    def test_get_diagnostics(self):
        req = fakes.HTTPRequestV3.blank('/servers/%s/os-server-diagnostics' %
                                        UUID)
        res = req.get_response(self.router)
        output = jsonutils.loads(res.body)
        expected = {
            'state':
            'running',
            'driver':
            'fake',
            'uptime':
            7,
            'cpu_details': [{
                'time': 1024
            }],
            'nic_details': [{
                'rx_octets': 0,
                'rx_errors': 0,
                'rx_drop': 0,
                'rx_packets': 0,
                'tx_octets': 0,
                'tx_errors': 0,
                'tx_drop': 0,
                'tx_packets': 0
            }],
            'disk_details': [{
                'read_bytes': 0,
                'read_requests': 0,
                'write_bytes': 0,
                'write_requests': 0,
                'errors': 0
            }],
            'memory_details': {
                'maximum': 512,
                'used': 256
            },
            'version':
            '1.0'
        }
        self.assertEqual(expected, output)

    @mock.patch.object(compute_api.API, 'get_instance_diagnostics',
                       fake_get_instance_diagnostics)
    @mock.patch.object(compute_api.API,
                       'get',
                       side_effect=exception.InstanceNotFound(instance_id=UUID)
                       )
    def test_get_diagnostics_with_non_existed_instance(self, mock_get):
        req = fakes.HTTPRequestV3.blank('/servers/%s/os-server-diagnostics' %
                                        UUID)
        res = req.get_response(self.router)
        self.assertEqual(res.status_int, 404)

    @mock.patch.object(
        compute_api.API,
        'get_instance_diagnostics',
        side_effect=exception.InstanceInvalidState('fake message'))
    @mock.patch.object(compute_api.API, 'get', fake_instance_get)
    def test_get_diagnostics_raise_conflict_on_invalid_state(
            self, mock_get_diagnostics):
        req = fakes.HTTPRequestV3.blank('/servers/%s/os-server-diagnostics' %
                                        UUID)
        res = req.get_response(self.router)
        self.assertEqual(409, res.status_int)
Beispiel #17
0
class ServerDiagnosticsTestV21(test.NoDBTestCase):
    def _setup_router(self):
        self.router = compute.APIRouterV21(init_only=('servers',
                                                      'os-server-diagnostics'))

    def _get_request(self):
        return fakes.HTTPRequest.blank('/fake/servers/%s/diagnostics' % UUID)

    def setUp(self):
        super(ServerDiagnosticsTestV21, self).setUp()
        self._setup_router()

    @mock.patch.object(compute_api.API, 'get_diagnostics',
                       fake_get_diagnostics)
    @mock.patch.object(compute_api.API, 'get', fake_instance_get)
    def test_get_diagnostics(self):
        req = self._get_request()
        res = req.get_response(self.router)
        output = jsonutils.loads(res.body)
        self.assertEqual(output, {'data': 'Some diagnostic info'})

    @mock.patch.object(compute_api.API, 'get_diagnostics',
                       fake_get_diagnostics)
    @mock.patch.object(compute_api.API,
                       'get',
                       side_effect=exception.InstanceNotFound(instance_id=UUID)
                       )
    def test_get_diagnostics_with_non_existed_instance(self, mock_get):
        req = self._get_request()
        res = req.get_response(self.router)
        self.assertEqual(res.status_int, 404)

    @mock.patch.object(
        compute_api.API,
        'get_diagnostics',
        side_effect=exception.InstanceInvalidState('fake message'))
    @mock.patch.object(compute_api.API, 'get', fake_instance_get)
    def test_get_diagnostics_raise_conflict_on_invalid_state(
            self, mock_get_diagnostics):
        req = self._get_request()
        res = req.get_response(self.router)
        self.assertEqual(409, res.status_int)

    @mock.patch.object(compute_api.API,
                       'get_diagnostics',
                       side_effect=exception.InstanceNotReady('fake message'))
    @mock.patch.object(compute_api.API, 'get', fake_instance_get)
    def test_get_diagnostics_raise_instance_not_ready(self,
                                                      mock_get_diagnostics):
        req = self._get_request()
        res = req.get_response(self.router)
        self.assertEqual(409, res.status_int)

    @mock.patch.object(compute_api.API,
                       'get_diagnostics',
                       side_effect=NotImplementedError)
    @mock.patch.object(compute_api.API, 'get', fake_instance_get)
    def test_get_diagnostics_raise_no_notimplementederror(
            self, mock_get_diagnostics):
        req = self._get_request()
        res = req.get_response(self.router)
        self.assertEqual(501, res.status_int)
Beispiel #18
0
 def fake_live_migrate(self, context, instance, block_migration,
                       disk_over_commit, host_name):
     raise exception.InstanceInvalidState(instance_uuid='',
                                          attr='',
                                          state='',
                                          method='')
Beispiel #19
0
 def test_assisted_delete_instance_invalid_state(self):
     api_error = exception.InstanceInvalidState(
         instance_uuid=FAKE_UUID, attr='task_state',
         state=task_states.UNSHELVING,
         method='volume_snapshot_delete')
     self._test_assisted_delete_instance_conflict(api_error)
Beispiel #20
0
        # Correct args
        exc = exception.InstanceInvalidState(attr='fake_attr',
                                             state='fake_state',
                                             method='fake_method')
        try:
            common.raise_http_conflict_for_instance_invalid_state(exc, 'meow')
        except Exception, e:
            self.assertTrue(isinstance(e, webob.exc.HTTPConflict))
            msg = str(e)
            self.assertEqual(
                msg, "Cannot 'meow' while instance is in fake_attr fake_state")
        else:
            self.fail("webob.exc.HTTPConflict was not raised")

        # Incorrect args
        exc = exception.InstanceInvalidState()
        try:
            common.raise_http_conflict_for_instance_invalid_state(exc, 'meow')
        except Exception, e:
            self.assertTrue(isinstance(e, webob.exc.HTTPConflict))
            msg = str(e)
            self.assertEqual(msg, "Instance is in an invalid state for 'meow'")
        else:
            self.fail("webob.exc.HTTPConflict was not raised")

    def test_check_img_metadata_properties_quota_valid_metadata(self):
        ctxt = test_utils.get_test_admin_context()
        metadata1 = {"key": "value"}
        actual = common.check_img_metadata_properties_quota(ctxt, metadata1)
        self.assertEqual(actual, None)
 def test_force_complete_instance_not_migrating(self):
     self._test_force_complete_failed_with_exception(
         exception.InstanceInvalidState(instance_uuid='',
                                        state='',
                                        attr='',
                                        method=''), webob.exc.HTTPConflict)
Beispiel #22
0
class AdminPasswordTestV21(test.NoDBTestCase):
    validation_error = exception.ValidationError

    def setUp(self):
        super(AdminPasswordTestV21, self).setUp()
        self.stub_out('nova.compute.api.API.set_admin_password',
                      fake_set_admin_password)
        self.stub_out('nova.compute.api.API.get', fake_get)
        self.fake_req = fakes.HTTPRequest.blank('')

    def _get_action(self):
        return admin_password_v21.AdminPasswordController().change_password

    def _check_status(self, expected_status, res, controller_method):
        self.assertEqual(expected_status, controller_method.wsgi_code)

    def test_change_password(self):
        body = {'changePassword': {'adminPass': '******'}}
        res = self._get_action()(self.fake_req, '1', body=body)
        self._check_status(202, res, self._get_action())

    def test_change_password_empty_string(self):
        body = {'changePassword': {'adminPass': ''}}
        res = self._get_action()(self.fake_req, '1', body=body)
        self._check_status(202, res, self._get_action())

    @mock.patch('nova.compute.api.API.set_admin_password',
                side_effect=NotImplementedError())
    def test_change_password_with_non_implement(self, mock_set_admin_password):
        body = {'changePassword': {'adminPass': '******'}}
        self.assertRaises(webob.exc.HTTPNotImplemented,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    @mock.patch('nova.compute.api.API.get',
                side_effect=exception.InstanceNotFound(instance_id='1'))
    def test_change_password_with_non_existed_instance(self, mock_get):
        body = {'changePassword': {'adminPass': '******'}}
        self.assertRaises(webob.exc.HTTPNotFound,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    def test_change_password_with_non_string_password(self):
        body = {'changePassword': {'adminPass': 1234}}
        self.assertRaises(self.validation_error,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    @mock.patch('nova.compute.api.API.set_admin_password',
                side_effect=exception.InstancePasswordSetFailed(instance="1",
                                                                reason=''))
    def test_change_password_failed(self, mock_set_admin_password):
        body = {'changePassword': {'adminPass': '******'}}
        self.assertRaises(webob.exc.HTTPConflict,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    @mock.patch('nova.compute.api.API.set_admin_password',
                side_effect=exception.SetAdminPasswdNotSupported(instance="1",
                                                                 reason=''))
    def test_change_password_not_supported(self, mock_set_admin_password):
        body = {'changePassword': {'adminPass': '******'}}
        self.assertRaises(webob.exc.HTTPConflict,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    @mock.patch('nova.compute.api.API.set_admin_password',
                side_effect=exception.InstanceAgentNotEnabled(instance="1",
                                                              reason=''))
    def test_change_password_guest_agent_disabled(self,
                                                  mock_set_admin_password):
        body = {'changePassword': {'adminPass': '******'}}
        self.assertRaises(webob.exc.HTTPConflict,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    def test_change_password_without_admin_password(self):
        body = {'changPassword': {}}
        self.assertRaises(self.validation_error,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    def test_change_password_none(self):
        body = {'changePassword': {'adminPass': None}}
        self.assertRaises(self.validation_error,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    def test_change_password_adminpass_none(self):
        body = {'changePassword': None}
        self.assertRaises(self.validation_error,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    def test_change_password_bad_request(self):
        body = {'changePassword': {'pass': '******'}}
        self.assertRaises(self.validation_error,
                          self._get_action(),
                          self.fake_req, '1', body=body)

    def test_server_change_password_pass_disabled(self):
        # run with enable_instance_password disabled to verify adminPass
        # is missing from response. See lp bug 921814
        self.flags(enable_instance_password=False, group='api')
        body = {'changePassword': {'adminPass': '******'}}
        res = self._get_action()(self.fake_req, '1', body=body)
        self._check_status(202, res, self._get_action())

    @mock.patch('nova.compute.api.API.set_admin_password',
                side_effect=exception.InstanceInvalidState(
                    instance_uuid='fake', attr='vm_state', state='stopped',
                    method='set_admin_password'))
    def test_change_password_invalid_state(self, mock_set_admin_password):
        body = {'changePassword': {'adminPass': '******'}}
        self.assertRaises(webob.exc.HTTPConflict,
                          self._get_action(),
                          self.fake_req, 'fake', body=body)
 def test_cancel_live_migration_invalid_state(self):
     self._test_cancel_live_migration_failed(
         exception.InstanceInvalidState(instance_uuid='',
                                        state='',
                                        attr='',
                                        method=''), webob.exc.HTTPConflict)
Beispiel #24
0
def fake_compute_api_raises_invalid_state(*args, **kwargs):
    raise exception.InstanceInvalidState(attr='fake_attr',
            state='fake_state', method='fake_method',
            instance_uuid='fake')
Beispiel #25
0
 def fake_detach_interface_invalid_state(*args, **kwargs):
     raise exception.InstanceInvalidState(instance_uuid='',
                                          attr='',
                                          state='',
                                          method='detach_interface')
Beispiel #26
0
 def test_get_diagnostics_raise_conflict_on_invalid_state(self):
     req = self._get_request()
     with mock.patch.object(compute_api.API, self.mock_diagnostics_method,
             side_effect=exception.InstanceInvalidState('fake message')):
         res = req.get_response(self.router)
     self.assertEqual(409, res.status_int)