def __init__(self, image_service=None, **kwargs): super(API, self).__init__(**kwargs) self.compute_api = compute.API() self.image_service = image_service if image_service is not None else image.ImageService( ) self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() self.CAPABILITIES = CAPABILITIES self.sg_api = sg_driver.get_openstack_security_group_driver() # Fixup an power-states related to blessed instances. elevated = context.get_admin_context() instances = self.compute_api.get_all(elevated, {'deleted': False}) for instance in instances: if instance['power_state'] == None: # (dscannell) We need to update the power_state to something # valid. Since it is a blessed instance we simply update its # state to 'no state'. self.db.instance_update(elevated, instance['uuid'], {'power_state': power_state.NOSTATE}) # (rui-lin) Host or nova-gc process failure during bless can cause # source instance to be undeletable and stuck in 'blessing' state, # so we clear state to default and allow it to be deleted if needed if instance['vm_state'] == vm_states.ACTIVE: if instance['task_state'] == "blessing": self.db.instance_update(elevated, instance['uuid'], { 'disable_terminate': False, 'task_state': 'None' })
def _test_scheduler_api(self, method, rpc_method, **kwargs): ctxt = context.RequestContext('fake_user', 'fake_project') rpcapi = scheduler_rpcapi.SchedulerAPI() self.assertIsNotNone(rpcapi.client) self.assertEqual(rpcapi.client.target.topic, CONF.scheduler_topic) expected_retval = 'foo' if rpc_method == 'call' else None expected_version = kwargs.pop('version', None) expected_fanout = kwargs.pop('fanout', None) expected_kwargs = kwargs.copy() self.mox.StubOutWithMock(rpcapi, 'client') rpcapi.client.can_send_version( mox.IsA(str)).MultipleTimes().AndReturn(True) prepare_kwargs = {} if expected_fanout: prepare_kwargs['fanout'] = True if expected_version: prepare_kwargs['version'] = expected_version rpcapi.client.prepare(**prepare_kwargs).AndReturn(rpcapi.client) rpc_method = getattr(rpcapi.client, rpc_method) rpc_method(ctxt, method, **expected_kwargs).AndReturn('foo') self.mox.ReplayAll() # NOTE(markmc): MultipleTimes() is OnceOrMore() not ZeroOrMore() rpcapi.client.can_send_version('I fool you mox') retval = getattr(rpcapi, method)(ctxt, **kwargs) self.assertEqual(retval, expected_retval)
def _test_scheduler_api(self, method, rpc_method, **kwargs): ctxt = context.RequestContext('fake_user', 'fake_project') rpcapi = scheduler_rpcapi.SchedulerAPI() expected_retval = 'foo' if method == 'call' else None expected_version = kwargs.pop('version', rpcapi.BASE_RPC_API_VERSION) expected_msg = rpcapi.make_msg(method, **kwargs) expected_msg['version'] = expected_version self.fake_args = None self.fake_kwargs = None def _fake_rpc_method(*args, **kwargs): self.fake_args = args self.fake_kwargs = kwargs if expected_retval: return expected_retval self.stubs.Set(rpc, rpc_method, _fake_rpc_method) retval = getattr(rpcapi, method)(ctxt, **kwargs) self.assertEqual(retval, expected_retval) expected_args = [ctxt, CONF.scheduler_topic, expected_msg] for arg, expected_arg in zip(self.fake_args, expected_args): self.assertEqual(arg, expected_arg)
def _list_hosts(req, service=None): """Returns a summary list of hosts, optionally filtering by service type. """ context = req.environ['nova.context'] rpcapi = scheduler_rpcapi.SchedulerAPI() hosts = rpcapi.get_host_list(context) if service: hosts = [host for host in hosts if host["service"] == service] return hosts
def describe_resource(self, host): """Describes cpu/memory/hdd info for host. :param host: hostname. """ rpcapi = scheduler_rpcapi.SchedulerAPI() result = rpcapi.show_host_resources(context.get_admin_context(), host=host) if not isinstance(result, dict): print _('An unexpected error has occurred.') print _('[Result]'), result else: # Printing a total and used_now # (NOTE)The host name width 16 characters print '%(a)-25s%(b)16s%(c)8s%(d)8s%(e)8s' % {"a": _('HOST'), "b": _('PROJECT'), "c": _('cpu'), "d": _('mem(mb)'), "e": _('hdd')} print ('%(a)-16s(total)%(b)26s%(c)8s%(d)8s' % {"a": host, "b": result['resource']['vcpus'], "c": result['resource']['memory_mb'], "d": result['resource']['local_gb']}) print ('%(a)-16s(used_now)%(b)23s%(c)8s%(d)8s' % {"a": host, "b": result['resource']['vcpus_used'], "c": result['resource']['memory_mb_used'], "d": result['resource']['local_gb_used']}) # Printing a used_max cpu_sum = 0 mem_sum = 0 hdd_sum = 0 for p_id, val in result['usage'].items(): cpu_sum += val['vcpus'] mem_sum += val['memory_mb'] hdd_sum += val['root_gb'] hdd_sum += val['ephemeral_gb'] print '%(a)-16s(used_max)%(b)23s%(c)8s%(d)8s' % {"a": host, "b": cpu_sum, "c": mem_sum, "d": hdd_sum} for p_id, val in result['usage'].items(): print '%(a)-25s%(b)16s%(c)8s%(d)8s%(e)8s' % { "a": host, "b": p_id, "c": val['vcpus'], "d": val['memory_mb'], "e": val['root_gb'] + val['ephemeral_gb']}
def __init__(self, image_api=None, network_api=None, volume_api=None, security_group_api=None, **kwargs): super(HuaweiAPI, self).__init__(image_api, network_api, volume_api, security_group_api, **kwargs) self.conductor_api = conductor.API() self.compute_rpcapi = hw_rpcapi.HuaweiComputeAPI() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI()
def _test_scheduler_api(self, method, rpc_method, expected_args=None, **kwargs): ctxt = context.RequestContext('fake_user', 'fake_project') rpcapi = scheduler_rpcapi.SchedulerAPI() self.assertIsNotNone(rpcapi.client) self.assertEqual(rpcapi.client.target.topic, scheduler_rpcapi.RPC_TOPIC) expected_retval = 'foo' if rpc_method == 'call' else None expected_version = kwargs.pop('version', None) expected_fanout = kwargs.pop('fanout', None) expected_kwargs = kwargs.copy() if expected_args: expected_kwargs = expected_args prepare_kwargs = {} if method == 'select_destinations': prepare_kwargs.update({ 'call_monitor_timeout': CONF.rpc_response_timeout, 'timeout': CONF.long_rpc_timeout }) if expected_fanout: prepare_kwargs['fanout'] = True if expected_version: prepare_kwargs['version'] = expected_version # NOTE(sbauza): We need to persist the method before mocking it orig_prepare = rpcapi.client.prepare def fake_can_send_version(version=None): return orig_prepare(version=version).can_send_version() @mock.patch.object(rpcapi.client, rpc_method, return_value=expected_retval) @mock.patch.object(rpcapi.client, 'prepare', return_value=rpcapi.client) @mock.patch.object(rpcapi.client, 'can_send_version', side_effect=fake_can_send_version) def do_test(mock_csv, mock_prepare, mock_rpc_method): retval = getattr(rpcapi, method)(ctxt, **kwargs) self.assertEqual(retval, expected_retval) mock_prepare.assert_called_once_with(**prepare_kwargs) mock_rpc_method.assert_called_once_with(ctxt, method, **expected_kwargs) do_test()
def __init__(self, msg_runner): super(CellsScheduler, self).__init__() self.msg_runner = msg_runner self.state_manager = msg_runner.state_manager self.compute_api = compute.API() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() self.filter_handler = filters.CellFilterHandler() self.filter_classes = self.filter_handler.get_matching_classes( CONF.cells.scheduler_filter_classes) self.weight_handler = weights.CellWeightHandler() self.weigher_classes = self.weight_handler.get_matching_classes( CONF.cells.scheduler_weight_classes)
def __init__(self, context, instance, destination, block_migration, disk_over_commit): self.context = context self.instance = instance self.destination = destination self.block_migration = block_migration self.disk_over_commit = disk_over_commit self.source = instance.host self.migrate_data = None self.compute_rpcapi = compute_rpcapi.ComputeAPI() self.servicegroup_api = servicegroup.API() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() self.image_service = glance.get_default_image_service()
def __init__(self): self.data_path = tempfile.mkdtemp(prefix='nova-coverage_') self.compute_api = compute_api.API() self.network_api = network_api.API() self.conductor_api = conductor_api.API() self.consoleauth_api = consoleauth_api.ConsoleAuthAPI() self.console_api = console_api.API() self.scheduler_api = scheduler_api.SchedulerAPI() self.cert_api = cert_api.CertAPI() self.services = [] self.combine = False self._cover_inst = None self.host = CONF.host super(CoverageController, self).__init__()
def __init__(self): self.data_path = tempfile.mkdtemp(prefix='nova-coverage_') data_out = os.path.join(self.data_path, '.nova-coverage') self.coverInst = coverage.coverage(data_file=data_out) self.compute_api = compute_api.API() self.network_api = network_api.API() self.conductor_api = conductor_api.API() self.consoleauth_api = consoleauth_api.ConsoleAuthAPI() self.console_api = console_api.API() self.scheduler_api = scheduler_api.SchedulerAPI() self.cert_api = cert_api.CertAPI() self.services = [] self.combine = False super(CoverageController, self).__init__()
def test_select_destinations_old_with_new_params(self): self.flags(scheduler='4.4', group='upgrade_levels') fake_spec = objects.RequestSpec() ctxt = context.RequestContext('fake_user', 'fake_project') rpcapi = scheduler_rpcapi.SchedulerAPI() self.assertRaises(exc.SelectionObjectsWithOldRPCVersionNotSupported, rpcapi.select_destinations, ctxt, fake_spec, ['fake_uuids'], return_objects=True, return_alternates=True) self.assertRaises(exc.SelectionObjectsWithOldRPCVersionNotSupported, rpcapi.select_destinations, ctxt, fake_spec, ['fake_uuids'], return_objects=False, return_alternates=True) self.assertRaises(exc.SelectionObjectsWithOldRPCVersionNotSupported, rpcapi.select_destinations, ctxt, fake_spec, ['fake_uuids'], return_objects=True, return_alternates=False)
def __init__(self, host=None, db_driver=None, service_name='undefined'): self.last_capabilities = None self.service_name = service_name self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() super(SchedulerDependentManager, self).__init__(host, db_driver, service_name)
def __init__(self): super(ComputeTaskManager, self).__init__() self.compute_rpcapi = compute_rpcapi.ComputeAPI() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() self.image_api = image.API()
import pdb import chardet from oslo_log import log as logging import nova.conf from nova import config from nova import objects from nova import context from nova.scheduler import rpcapi as scheduler_rpcapi from nova.scheduler import utils as scheduler_utils from nova import utils as nova_utils CONF = nova.conf.CONF argv = [] default_config_files = ['/etc/nova/nova.conf'] config.parse_args(argv, default_config_files=default_config_files) objects.register_all() context = context.get_admin_context() inst = objects.Instance.get_by_uuid(context, 'a62179e2-d00d-4a68-bd85-b0ff54e3c178') filter_properties = {'ignore_hosts': [], 'rs_aggregate_id': 3} system_metadata = nova_utils.instance_sys_meta(inst) image = nova_utils.get_image_from_system_metadata(system_metadata) request_spec = scheduler_utils.build_request_spec(context, image, [inst]) spec_obj = objects.RequestSpec.from_primitives(context, request_spec, filter_properties) scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() destinations = scheduler_rpcapi.select_destinations(context, spec_obj) print destinations
def __init__(self, msg_runner): super(CellsScheduler, self).__init__() self.msg_runner = msg_runner self.state_manager = msg_runner.state_manager self.compute_api = compute.API() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI()
def __init__(self): super(ComputeTaskManager, self).__init__() self.compute_rpcapi = compute_rpcapi.ComputeAPI() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() self.image_service = glance.get_default_image_service() self.quotas = quota.QUOTAS
def __init__(self): super(ComputeTaskManager, self).__init__() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI()
def __init__(self, **kwargs): self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() super(API, self).__init__(**kwargs)
def __init__(self): self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI()
def __init__(self, *args, **kwargs): super(AdminActionsController, self).__init__(*args, **kwargs) self.compute_api = compute.API() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI()
def __init__(self, image_service=None, **kwargs): self.image_service = (image_service or glance.get_default_image_service()) self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() super(API, self).__init__(**kwargs)
def __init__(self, ext_mgr): self.host_api = compute.HostAPI() self.servicegroup_api = servicegroup.API() self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() super(HypervisorsController, self).__init__() self.ext_mgr = ext_mgr