diff --git a/nova/cells/filters/target_cell.py b/nova/cells/filters/target_cell.py index ac5fad252d..de2ef6d18e 100644 --- a/nova/cells/filters/target_cell.py +++ b/nova/cells/filters/target_cell.py @@ -64,11 +64,8 @@ class TargetCellFilter(filters.BaseCellFilter): return [scheduler.state_manager.get_my_state()] ctxt = filter_properties['context'] - # NOTE(belliott) Remove after deprecated schedule_run_instance - # code goes away: - schedule = filter_properties['cell_scheduler_method'] - schedule = getattr(scheduler.msg_runner, schedule) - schedule(ctxt, cell_name, filter_properties['host_sched_kwargs']) + scheduler.msg_runner.build_instances(ctxt, cell_name, + filter_properties['host_sched_kwargs']) # Returning None means to skip further scheduling, because we # handled it. diff --git a/nova/cells/manager.py b/nova/cells/manager.py index 9a7211a999..a203f1b676 100644 --- a/nova/cells/manager.py +++ b/nova/cells/manager.py @@ -191,15 +191,6 @@ class CellsManager(manager.Manager): else: self.instance_update_at_top(ctxt, instance) - def schedule_run_instance(self, ctxt, host_sched_kwargs): - """Pick a cell (possibly ourselves) to build new instance(s) - and forward the request accordingly. - """ - # Target is ourselves first. - our_cell = self.state_manager.get_my_state() - self.msg_runner.schedule_run_instance(ctxt, our_cell, - host_sched_kwargs) - def build_instances(self, ctxt, build_inst_kwargs): """Pick a cell (possibly ourselves) to build new instance(s) and forward the request accordingly. diff --git a/nova/cells/messaging.py b/nova/cells/messaging.py index b77781bbb4..13c4f5f262 100644 --- a/nova/cells/messaging.py +++ b/nova/cells/messaging.py @@ -653,10 +653,6 @@ class _TargetedMessageMethods(_BaseMessageMethods): def __init__(self, *args, **kwargs): super(_TargetedMessageMethods, self).__init__(*args, **kwargs) - def schedule_run_instance(self, message, host_sched_kwargs): - """Parent cell told us to schedule new instance creation.""" - self.msg_runner.scheduler.run_instance(message, host_sched_kwargs) - def build_instances(self, message, build_inst_kwargs): """Parent cell told us to schedule new instance creation.""" self.msg_runner.scheduler.build_instances(message, build_inst_kwargs) @@ -1412,15 +1408,6 @@ class MessageRunner(object): method_kwargs, 'up', cell, fanout=True) message.process() - def schedule_run_instance(self, ctxt, target_cell, host_sched_kwargs): - """Called by the scheduler to tell a child cell to schedule - a new instance for build. - """ - method_kwargs = dict(host_sched_kwargs=host_sched_kwargs) - message = _TargetedMessage(self, ctxt, 'schedule_run_instance', - method_kwargs, 'down', target_cell) - message.process() - def build_instances(self, ctxt, target_cell, build_inst_kwargs): """Called by the cell scheduler to tell a child cell to build instance(s). diff --git a/nova/cells/rpcapi.py b/nova/cells/rpcapi.py index 247d64198d..cad1776f58 100644 --- a/nova/cells/rpcapi.py +++ b/nova/cells/rpcapi.py @@ -134,12 +134,6 @@ class CellsAPI(object): method_info=method_info, call=True) - # NOTE(alaski): Deprecated and should be removed later. - def schedule_run_instance(self, ctxt, **kwargs): - """Schedule a new instance for creation.""" - self.client.cast(ctxt, 'schedule_run_instance', - host_sched_kwargs=kwargs) - def build_instances(self, ctxt, **kwargs): """Build instances.""" build_inst_kwargs = kwargs diff --git a/nova/cells/scheduler.py b/nova/cells/scheduler.py index 9d3d32ed9c..bfd9157343 100644 --- a/nova/cells/scheduler.py +++ b/nova/cells/scheduler.py @@ -35,7 +35,6 @@ from nova.objects import instance as instance_obj from nova.objects import instance_action as instance_action_obj from nova.openstack.common.gettextutils import _ from nova.openstack.common import log as logging -from nova.scheduler import rpcapi as scheduler_rpcapi from nova.scheduler import utils as scheduler_utils from nova import utils @@ -73,7 +72,6 @@ class CellsScheduler(base.Base): self.msg_runner = msg_runner self.state_manager = msg_runner.state_manager self.compute_api = compute.API() - self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() self.compute_task_api = conductor.ComputeTaskAPI() self.filter_handler = filters.CellFilterHandler() self.filter_classes = self.filter_handler.get_matching_classes( @@ -158,46 +156,6 @@ class CellsScheduler(base.Base): target_cells = [cell.obj for cell in weighted_cells] return target_cells - def _run_instance(self, message, target_cells, instance_uuids, - host_sched_kwargs): - """Attempt to schedule instance(s).""" - ctxt = message.ctxt - request_spec = host_sched_kwargs['request_spec'] - instance_properties = request_spec['instance_properties'] - instance_type = request_spec['instance_type'] - image = request_spec['image'] - security_groups = request_spec['security_group'] - block_device_mapping = request_spec['block_device_mapping'] - - LOG.debug("Scheduling with routing_path=%(routing_path)s", - {'routing_path': message.routing_path}) - - for target_cell in target_cells: - try: - if target_cell.is_me: - # Need to create instance DB entries as the host scheduler - # expects that the instance(s) already exists. - self._create_instances_here(ctxt, instance_uuids, - instance_properties, instance_type, image, - security_groups, block_device_mapping) - # Need to record the create action in the db as the - # scheduler expects it to already exist. - self._create_action_here(ctxt, instance_uuids) - self.scheduler_rpcapi.run_instance(ctxt, - **host_sched_kwargs) - return - self.msg_runner.schedule_run_instance(ctxt, target_cell, - host_sched_kwargs) - return - except Exception: - LOG.exception(_("Couldn't communicate with cell '%s'") % - target_cell.name) - # FIXME(comstud): Would be nice to kick this back up so that - # the parent cell could retry, if we had a parent. - msg = _("Couldn't communicate with any cells") - LOG.error(msg) - raise exception.NoCellsAvailable() - def _build_instances(self, message, target_cells, instance_uuids, build_inst_kwargs): """Attempt to build instance(s) or send msg to child cell.""" @@ -252,29 +210,10 @@ class CellsScheduler(base.Base): 'routing_path': message.routing_path, 'host_sched_kwargs': build_inst_kwargs, 'request_spec': request_spec}) - # NOTE(belliott) remove when deprecated schedule_run_instance - # code gets removed. - filter_properties['cell_scheduler_method'] = 'build_instances' self._schedule_build_to_cells(message, instance_uuids, filter_properties, self._build_instances, build_inst_kwargs) - def run_instance(self, message, host_sched_kwargs): - request_spec = host_sched_kwargs['request_spec'] - instance_uuids = request_spec['instance_uuids'] - filter_properties = copy.copy(host_sched_kwargs['filter_properties']) - filter_properties.update({'context': message.ctxt, - 'scheduler': self, - 'routing_path': message.routing_path, - 'host_sched_kwargs': host_sched_kwargs, - 'request_spec': request_spec}) - # NOTE(belliott) remove when deprecated schedule_run_instance - # code gets removed. - filter_properties['cell_scheduler_method'] = 'schedule_run_instance' - - self._schedule_build_to_cells(message, instance_uuids, - filter_properties, self._run_instance, host_sched_kwargs) - def _schedule_build_to_cells(self, message, instance_uuids, filter_properties, method, method_kwargs): """Pick a cell where we should create a new instance(s).""" diff --git a/nova/compute/cells_api.py b/nova/compute/cells_api.py index 56dd0dc987..372a8f5bfd 100644 --- a/nova/compute/cells_api.py +++ b/nova/compute/cells_api.py @@ -64,16 +64,6 @@ class ComputeRPCAPIRedirect(object): return _noop_rpc_wrapper -class SchedulerRPCAPIRedirect(object): - def __init__(self, cells_rpcapi_obj): - self.cells_rpcapi = cells_rpcapi_obj - - def __getattr__(self, key): - def _noop_rpc_wrapper(*args, **kwargs): - return None - return _noop_rpc_wrapper - - class ConductorTaskRPCAPIRedirect(object): # NOTE(comstud): These are a list of methods where the cells_rpcapi # and the compute_task_rpcapi methods have the same signatures. This @@ -175,8 +165,6 @@ class ComputeCellsAPI(compute_api.API): self.cells_rpcapi = cells_rpcapi.CellsAPI() # Avoid casts/calls directly to compute self.compute_rpcapi = ComputeRPCAPIRedirect(self.cells_rpcapi) - # Redirect scheduler run_instance to cells. - self.scheduler_rpcapi = SchedulerRPCAPIRedirect(self.cells_rpcapi) # Redirect conductor build_instances to cells self._compute_task_api = ConductorTaskRPCAPIRedirect(self.cells_rpcapi) self._cell_type = 'api' diff --git a/nova/compute/manager.py b/nova/compute/manager.py index 32217d0ee5..7fee74bd35 100644 --- a/nova/compute/manager.py +++ b/nova/compute/manager.py @@ -2107,6 +2107,9 @@ class ComputeManager(manager.Manager): filter_properties, requested_networks, injected_files, admin_password, is_first_time, node, legacy_bdm_in_spec): + # NOTE(alaski) This method should be deprecated when the scheduler and + # compute rpc interfaces are bumped to 4.x, and slated for removal in + # 5.x as it is no longer used. if filter_properties is None: filter_properties = {} diff --git a/nova/compute/rpcapi.py b/nova/compute/rpcapi.py index 6fbbdc6460..8c65ea327e 100644 --- a/nova/compute/rpcapi.py +++ b/nova/compute/rpcapi.py @@ -767,6 +767,8 @@ class ComputeAPI(object): cctxt.cast(ctxt, 'rollback_live_migration_at_destination', instance=instance) + # NOTE(alaski): Remove this method when the scheduler rpc interface is + # bumped to 4.x as the only callers of this method will be removed. def run_instance(self, ctxt, instance, host, request_spec, filter_properties, requested_networks, injected_files, admin_password, diff --git a/nova/scheduler/chance.py b/nova/scheduler/chance.py index 8efd0fa87d..bb04eb9c3d 100644 --- a/nova/scheduler/chance.py +++ b/nova/scheduler/chance.py @@ -78,6 +78,8 @@ class ChanceScheduler(driver.Scheduler): raise exception.NoValidHost(reason='') return dests + # NOTE(alaski): Remove this method when the scheduler rpc interface is + # bumped to 4.x as it is no longer used. def schedule_run_instance(self, context, request_spec, admin_password, injected_files, requested_networks, is_first_time, diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py index f0533dbcbf..b75fb42bca 100644 --- a/nova/scheduler/driver.py +++ b/nova/scheduler/driver.py @@ -114,6 +114,8 @@ class Scheduler(object): for service in services if self.servicegroup_api.service_is_up(service)] + # NOTE(alaski): Remove this method when the scheduler rpc interface is + # bumped to 4.x as it is no longer used. def schedule_run_instance(self, context, request_spec, admin_password, injected_files, requested_networks, is_first_time, diff --git a/nova/scheduler/filter_scheduler.py b/nova/scheduler/filter_scheduler.py index facee55205..18917904bf 100644 --- a/nova/scheduler/filter_scheduler.py +++ b/nova/scheduler/filter_scheduler.py @@ -62,6 +62,8 @@ class FilterScheduler(driver.Scheduler): self.compute_rpcapi = compute_rpcapi.ComputeAPI() self.notifier = rpc.get_notifier('scheduler') + # NOTE(alaski): Remove this method when the scheduler rpc interface is + # bumped to 4.x as it is no longer used. def schedule_run_instance(self, context, request_spec, admin_password, injected_files, requested_networks, is_first_time, diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py index dfebb25e1e..b255b371ef 100644 --- a/nova/scheduler/manager.py +++ b/nova/scheduler/manager.py @@ -123,6 +123,8 @@ class SchedulerManager(manager.Manager): dest, block_migration, disk_over_commit) return task.execute() + # NOTE(alaski): Remove this method when the scheduler rpc interface is + # bumped to 4.x as it is no longer used. def run_instance(self, context, request_spec, admin_password, injected_files, requested_networks, is_first_time, filter_properties, legacy_bdm_in_spec=True): diff --git a/nova/scheduler/rpcapi.py b/nova/scheduler/rpcapi.py index b36e8fc7c0..3ff86f0ebf 100644 --- a/nova/scheduler/rpcapi.py +++ b/nova/scheduler/rpcapi.py @@ -106,19 +106,6 @@ class SchedulerAPI(object): return cctxt.call(ctxt, 'select_destinations', request_spec=request_spec, filter_properties=filter_properties) - def run_instance(self, ctxt, request_spec, admin_password, - injected_files, requested_networks, is_first_time, - filter_properties, legacy_bdm_in_spec=True): - msg_kwargs = {'request_spec': request_spec, - 'admin_password': admin_password, - 'injected_files': injected_files, - 'requested_networks': requested_networks, - 'is_first_time': is_first_time, - 'filter_properties': filter_properties, - 'legacy_bdm_in_spec': legacy_bdm_in_spec} - cctxt = self.client.prepare() - cctxt.cast(ctxt, 'run_instance', **msg_kwargs) - def prep_resize(self, ctxt, instance, instance_type, image, request_spec, filter_properties, reservations): instance_p = jsonutils.to_primitive(instance) diff --git a/nova/tests/cells/test_cells_filters.py b/nova/tests/cells/test_cells_filters.py index c1aaeeb6d0..8db481f05c 100644 --- a/nova/tests/cells/test_cells_filters.py +++ b/nova/tests/cells/test_cells_filters.py @@ -140,13 +140,13 @@ class TestTargetCellFilter(_FilterTestClass): def test_target_cell_specified_not_me(self): info = {} - def _fake_sched_run_instance(ctxt, cell, sched_kwargs): + def _fake_build_instances(ctxt, cell, sched_kwargs): info['ctxt'] = ctxt info['cell'] = cell info['sched_kwargs'] = sched_kwargs - self.stubs.Set(self.msg_runner, 'schedule_run_instance', - _fake_sched_run_instance) + self.stubs.Set(self.msg_runner, 'build_instances', + _fake_build_instances) cells = [1, 2, 3] target_cell = 'fake!cell!path' current_cell = 'not!the!same' @@ -155,7 +155,7 @@ class TestTargetCellFilter(_FilterTestClass): 'scheduler': self.scheduler, 'context': self.context, 'host_sched_kwargs': 'meow', - 'cell_scheduler_method': 'schedule_run_instance'} + 'cell_scheduler_method': 'build_instances'} # None is returned to bypass further scheduling. self.assertIsNone(self._filter_cells(cells, filter_props)) # The filter should have re-scheduled to the child cell itself. diff --git a/nova/tests/cells/test_cells_manager.py b/nova/tests/cells/test_cells_manager.py index 629d58c0ea..1c214839bb 100644 --- a/nova/tests/cells/test_cells_manager.py +++ b/nova/tests/cells/test_cells_manager.py @@ -113,16 +113,6 @@ class CellsManagerClassTestCase(test.NoDBTestCase): self.mox.ReplayAll() self.cells_manager._update_our_parents(self.ctxt) - def test_schedule_run_instance(self): - host_sched_kwargs = 'fake_host_sched_kwargs_silently_passed' - self.mox.StubOutWithMock(self.msg_runner, 'schedule_run_instance') - our_cell = self.msg_runner.state_manager.get_my_state() - self.msg_runner.schedule_run_instance(self.ctxt, our_cell, - host_sched_kwargs) - self.mox.ReplayAll() - self.cells_manager.schedule_run_instance(self.ctxt, - host_sched_kwargs=host_sched_kwargs) - def test_build_instances(self): build_inst_kwargs = {'instances': [1, 2]} self.mox.StubOutWithMock(self.msg_runner, 'build_instances') diff --git a/nova/tests/cells/test_cells_messaging.py b/nova/tests/cells/test_cells_messaging.py index 289407f23f..3ffc5810a1 100644 --- a/nova/tests/cells/test_cells_messaging.py +++ b/nova/tests/cells/test_cells_messaging.py @@ -648,17 +648,6 @@ class CellsTargetedMethodsTestCase(test.TestCase): self.tgt_db_inst = methods_cls.db self.tgt_c_rpcapi = methods_cls.compute_rpcapi - def test_schedule_run_instance(self): - host_sched_kwargs = {'filter_properties': {}, - 'key1': 'value1', - 'key2': 'value2'} - self.mox.StubOutWithMock(self.tgt_scheduler, 'run_instance') - self.tgt_scheduler.run_instance(self.ctxt, host_sched_kwargs) - self.mox.ReplayAll() - self.src_msg_runner.schedule_run_instance(self.ctxt, - self.tgt_cell_name, - host_sched_kwargs) - def test_build_instances(self): build_inst_kwargs = {'filter_properties': {}, 'key1': 'value1', diff --git a/nova/tests/cells/test_cells_rpcapi.py b/nova/tests/cells/test_cells_rpcapi.py index fcecbb8177..322521ec52 100644 --- a/nova/tests/cells/test_cells_rpcapi.py +++ b/nova/tests/cells/test_cells_rpcapi.py @@ -122,18 +122,6 @@ class CellsAPITestCase(test.NoDBTestCase): expected_args) self.assertEqual(fake_response, result) - def test_schedule_run_instance(self): - call_info = self._stub_rpc_method('cast', None) - - self.cells_rpcapi.schedule_run_instance( - self.fake_context, arg1=1, arg2=2, arg3=3) - - expected_args = {'host_sched_kwargs': {'arg1': 1, - 'arg2': 2, - 'arg3': 3}} - self._check_result(call_info, 'schedule_run_instance', - expected_args) - def test_build_instances(self): call_info = self._stub_rpc_method('cast', None) diff --git a/nova/tests/cells/test_cells_scheduler.py b/nova/tests/cells/test_cells_scheduler.py index 8548598e00..1a60c7394f 100644 --- a/nova/tests/cells/test_cells_scheduler.py +++ b/nova/tests/cells/test_cells_scheduler.py @@ -81,11 +81,9 @@ class CellsSchedulerTestCase(test.TestCase): self.instances = [{'uuid': uuid} for uuid in instance_uuids] self.request_spec = { 'instance_uuids': instance_uuids, - 'instance_properties': 'fake_properties', + 'instance_properties': self.instances[0], 'instance_type': 'fake_type', - 'image': 'fake_image', - 'security_group': 'fake_sec_groups', - 'block_device_mapping': 'fake_bdm'} + 'image': 'fake_image'} self.build_inst_kwargs = { 'instances': self.instances, 'image': 'fake_image', @@ -137,42 +135,6 @@ class CellsSchedulerTestCase(test.TestCase): instance['display_name']) self.assertEqual('fake_image_ref', instance['image_ref']) - def test_run_instance_selects_child_cell(self): - # Make sure there's no capacity info so we're sure to - # select a child cell - our_cell_info = self.state_manager.get_my_state() - our_cell_info.capacities = {} - - call_info = {'times': 0} - - orig_fn = self.msg_runner.schedule_run_instance - - def msg_runner_schedule_run_instance(ctxt, target_cell, - host_sched_kwargs): - # This gets called twice. Once for our running it - # in this cell.. and then it'll get called when the - # child cell is picked. So, first time.. just run it - # like normal. - if not call_info['times']: - call_info['times'] += 1 - return orig_fn(ctxt, target_cell, host_sched_kwargs) - call_info['ctxt'] = ctxt - call_info['target_cell'] = target_cell - call_info['host_sched_kwargs'] = host_sched_kwargs - - self.stubs.Set(self.msg_runner, 'schedule_run_instance', - msg_runner_schedule_run_instance) - - host_sched_kwargs = {'request_spec': self.request_spec, - 'filter_properties': {}} - self.msg_runner.schedule_run_instance(self.ctxt, - self.my_cell_state, host_sched_kwargs) - - self.assertEqual(self.ctxt, call_info['ctxt']) - self.assertEqual(host_sched_kwargs, call_info['host_sched_kwargs']) - child_cells = self.state_manager.get_child_cells() - self.assertIn(call_info['target_cell'], child_cells) - def test_build_instances_selects_child_cell(self): # Make sure there's no capacity info so we're sure to # select a child cell @@ -215,51 +177,6 @@ class CellsSchedulerTestCase(test.TestCase): child_cells = self.state_manager.get_child_cells() self.assertIn(call_info['target_cell'], child_cells) - def test_run_instance_selects_current_cell(self): - # Make sure there's no child cells so that we will be - # selected - self.state_manager.child_cells = {} - - call_info = {} - - def fake_create_instances_here(ctxt, instance_uuids, - instance_properties, instance_type, image, security_groups, - block_device_mapping): - call_info['ctxt'] = ctxt - call_info['instance_uuids'] = instance_uuids - call_info['instance_properties'] = instance_properties - call_info['instance_type'] = instance_type - call_info['image'] = image - call_info['security_groups'] = security_groups - call_info['block_device_mapping'] = block_device_mapping - - def fake_rpc_run_instance(ctxt, **host_sched_kwargs): - call_info['host_sched_kwargs'] = host_sched_kwargs - - self.stubs.Set(self.scheduler, '_create_instances_here', - fake_create_instances_here) - self.stubs.Set(self.scheduler.scheduler_rpcapi, - 'run_instance', fake_rpc_run_instance) - - host_sched_kwargs = {'request_spec': self.request_spec, - 'filter_properties': {}, - 'other': 'stuff'} - self.msg_runner.schedule_run_instance(self.ctxt, - self.my_cell_state, host_sched_kwargs) - - self.assertEqual(self.ctxt, call_info['ctxt']) - self.assertEqual(host_sched_kwargs, call_info['host_sched_kwargs']) - self.assertEqual(self.instance_uuids, call_info['instance_uuids']) - self.assertEqual(self.request_spec['instance_properties'], - call_info['instance_properties']) - self.assertEqual(self.request_spec['instance_type'], - call_info['instance_type']) - self.assertEqual(self.request_spec['image'], call_info['image']) - self.assertEqual(self.request_spec['security_group'], - call_info['security_groups']) - self.assertEqual(self.request_spec['block_device_mapping'], - call_info['block_device_mapping']) - def test_build_instances_selects_current_cell(self): # Make sure there's no child cells so that we will be # selected @@ -317,36 +234,6 @@ class CellsSchedulerTestCase(test.TestCase): call_info['build_inst_kwargs']) self.assertEqual(self.instance_uuids, call_info['instance_uuids']) - def test_run_instance_retries_when_no_cells_avail(self): - self.flags(scheduler_retries=7, group='cells') - - host_sched_kwargs = {'request_spec': self.request_spec, - 'filter_properties': {}} - - call_info = {'num_tries': 0, 'errored_uuids': []} - - def fake_grab_target_cells(filter_properties): - call_info['num_tries'] += 1 - raise exception.NoCellsAvailable() - - def fake_sleep(_secs): - return - - def fake_instance_update(ctxt, instance_uuid, values): - self.assertEqual(vm_states.ERROR, values['vm_state']) - call_info['errored_uuids'].append(instance_uuid) - - self.stubs.Set(self.scheduler, '_grab_target_cells', - fake_grab_target_cells) - self.stubs.Set(time, 'sleep', fake_sleep) - self.stubs.Set(db, 'instance_update', fake_instance_update) - - self.msg_runner.schedule_run_instance(self.ctxt, - self.my_cell_state, host_sched_kwargs) - - self.assertEqual(8, call_info['num_tries']) - self.assertEqual(self.instance_uuids, call_info['errored_uuids']) - def test_build_instances_retries_when_no_cells_avail(self): self.flags(scheduler_retries=7, group='cells') @@ -470,7 +357,7 @@ class CellsSchedulerTestCase(test.TestCase): call_info['security_groups'] = security_groups call_info['block_device_mapping'] = block_device_mapping - def fake_rpc_run_instance(ctxt, **host_sched_kwargs): + def fake_rpc_build_instances(ctxt, **host_sched_kwargs): call_info['host_sched_kwargs'] = host_sched_kwargs def fake_get_filtered_objs(filter_classes, cells, filt_properties): @@ -479,19 +366,32 @@ class CellsSchedulerTestCase(test.TestCase): call_info['filt_props'] = filt_properties return cells + def fake_build_request_spec(ctxt, image, instances): + request_spec = { + 'instance_uuids': [inst['uuid'] for inst in instances], + 'instance_properties': instances[0], + 'image': image, + 'instance_type': 'fake_type'} + return request_spec + self.stubs.Set(self.scheduler, '_create_instances_here', fake_create_instances_here) - self.stubs.Set(self.scheduler.scheduler_rpcapi, - 'run_instance', fake_rpc_run_instance) + self.stubs.Set(self.scheduler.compute_task_api, + 'build_instances', fake_rpc_build_instances) + self.stubs.Set(scheduler_utils, 'build_request_spec', + fake_build_request_spec) filter_handler = self.scheduler.filter_handler self.stubs.Set(filter_handler, 'get_filtered_objects', fake_get_filtered_objs) - host_sched_kwargs = {'request_spec': self.request_spec, - 'filter_properties': {}, - 'other': 'stuff'} + host_sched_kwargs = {'image': 'fake_image', + 'instances': self.instances, + 'filter_properties': + {'instance_type': 'fake_type'}, + 'security_groups': 'fake_sec_groups', + 'block_device_mapping': 'fake_bdm'} - self.msg_runner.schedule_run_instance(self.ctxt, + self.msg_runner.build_instances(self.ctxt, self.my_cell_state, host_sched_kwargs) # Our cell was selected. self.assertEqual(self.ctxt, call_info['ctxt']) @@ -501,10 +401,6 @@ class CellsSchedulerTestCase(test.TestCase): self.assertEqual(self.request_spec['instance_type'], call_info['instance_type']) self.assertEqual(self.request_spec['image'], call_info['image']) - self.assertEqual(self.request_spec['security_group'], - call_info['security_groups']) - self.assertEqual(self.request_spec['block_device_mapping'], - call_info['block_device_mapping']) self.assertEqual(host_sched_kwargs, call_info['host_sched_kwargs']) # Filter args are correct expected_filt_props = {'context': self.ctxt, @@ -512,8 +408,7 @@ class CellsSchedulerTestCase(test.TestCase): 'routing_path': self.my_cell_state.name, 'host_sched_kwargs': host_sched_kwargs, 'request_spec': self.request_spec, - 'cell_scheduler_method': - 'schedule_run_instance'} + 'instance_type': 'fake_type'} self.assertEqual(expected_filt_props, call_info['filt_props']) self.assertEqual([FakeFilterClass1, FakeFilterClass2], call_info['filt_classes']) @@ -548,7 +443,7 @@ class CellsSchedulerTestCase(test.TestCase): self.stubs.Set(filter_handler, 'get_filtered_objects', fake_get_filtered_objs) - self.msg_runner.schedule_run_instance(self.ctxt, + self.msg_runner.build_instances(self.ctxt, self.my_cell_state, {}) self.assertFalse(call_info['scheduled']) @@ -577,7 +472,7 @@ class CellsSchedulerTestCase(test.TestCase): call_info['security_groups'] = security_groups call_info['block_device_mapping'] = block_device_mapping - def fake_rpc_run_instance(ctxt, **host_sched_kwargs): + def fake_rpc_build_instances(ctxt, **host_sched_kwargs): call_info['host_sched_kwargs'] = host_sched_kwargs def fake_get_weighed_objs(weight_classes, cells, filt_properties): @@ -586,19 +481,32 @@ class CellsSchedulerTestCase(test.TestCase): call_info['weight_props'] = filt_properties return [weights.WeightedCell(cells[0], 0.0)] + def fake_build_request_spec(ctxt, image, instances): + request_spec = { + 'instance_uuids': [inst['uuid'] for inst in instances], + 'instance_properties': instances[0], + 'image': image, + 'instance_type': 'fake_type'} + return request_spec + self.stubs.Set(self.scheduler, '_create_instances_here', fake_create_instances_here) - self.stubs.Set(self.scheduler.scheduler_rpcapi, - 'run_instance', fake_rpc_run_instance) + self.stubs.Set(scheduler_utils, 'build_request_spec', + fake_build_request_spec) + self.stubs.Set(self.scheduler.compute_task_api, + 'build_instances', fake_rpc_build_instances) weight_handler = self.scheduler.weight_handler self.stubs.Set(weight_handler, 'get_weighed_objects', fake_get_weighed_objs) - host_sched_kwargs = {'request_spec': self.request_spec, - 'filter_properties': {}, - 'other': 'stuff'} + host_sched_kwargs = {'image': 'fake_image', + 'instances': self.instances, + 'filter_properties': + {'instance_type': 'fake_type'}, + 'security_groups': 'fake_sec_groups', + 'block_device_mapping': 'fake_bdm'} - self.msg_runner.schedule_run_instance(self.ctxt, + self.msg_runner.build_instances(self.ctxt, self.my_cell_state, host_sched_kwargs) # Our cell was selected. self.assertEqual(self.ctxt, call_info['ctxt']) @@ -608,10 +516,6 @@ class CellsSchedulerTestCase(test.TestCase): self.assertEqual(self.request_spec['instance_type'], call_info['instance_type']) self.assertEqual(self.request_spec['image'], call_info['image']) - self.assertEqual(self.request_spec['security_group'], - call_info['security_groups']) - self.assertEqual(self.request_spec['block_device_mapping'], - call_info['block_device_mapping']) self.assertEqual(host_sched_kwargs, call_info['host_sched_kwargs']) # Weight args are correct expected_filt_props = {'context': self.ctxt, @@ -619,8 +523,7 @@ class CellsSchedulerTestCase(test.TestCase): 'routing_path': self.my_cell_state.name, 'host_sched_kwargs': host_sched_kwargs, 'request_spec': self.request_spec, - 'cell_scheduler_method': - 'schedule_run_instance'} + 'instance_type': 'fake_type'} self.assertEqual(expected_filt_props, call_info['weight_props']) self.assertEqual([FakeWeightClass1, FakeWeightClass2], call_info['weight_classes']) diff --git a/nova/tests/scheduler/test_rpcapi.py b/nova/tests/scheduler/test_rpcapi.py index e189575678..de088b2212 100644 --- a/nova/tests/scheduler/test_rpcapi.py +++ b/nova/tests/scheduler/test_rpcapi.py @@ -63,14 +63,6 @@ class SchedulerRpcAPITestCase(test.NoDBTestCase): retval = getattr(rpcapi, method)(ctxt, **kwargs) self.assertEqual(retval, expected_retval) - def test_run_instance(self): - self._test_scheduler_api('run_instance', rpc_method='cast', - request_spec='fake_request_spec', - admin_password='pw', injected_files='fake_injected_files', - requested_networks='fake_requested_networks', - is_first_time=True, filter_properties='fake_filter_properties', - legacy_bdm_in_spec=False) - def test_prep_resize(self): self._test_scheduler_api('prep_resize', rpc_method='cast', instance='fake_instance', diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py index 747854701f..01858059c3 100644 --- a/nova/tests/test_quota.py +++ b/nova/tests/test_quota.py @@ -27,8 +27,6 @@ from nova.db.sqlalchemy import models as sqa_models from nova import exception from nova.openstack.common import timeutils from nova import quota -from nova.scheduler import driver as scheduler_driver -from nova.scheduler import rpcapi as scheduler_rpcapi from nova import test import nova.tests.image.fake @@ -59,15 +57,6 @@ class QuotaIntegrationTestCase(test.TestCase): self.compute_api = compute.API() - def fake_run_instance(self, ctxt, request_spec, *args): - """Stub out the scheduler creating the instance entry.""" - instance = scheduler_driver.Scheduler().create_instance_db_entry( - context, request_spec, None) - return [scheduler_driver.encode_instance(instance)] - - self.stubs.Set(scheduler_rpcapi.SchedulerAPI, 'run_instance', - fake_run_instance) - def tearDown(self): super(QuotaIntegrationTestCase, self).tearDown() nova.tests.image.fake.FakeImageService_reset()