7755b759b4
Now that the RequestSpec provides a field for a requested destination, we can know if the admin user provided a destination to verify (and not force it). In order to verify this destination, we want to run the filters for only this host, so that if the filters are not okay for that possibility, the scheduler should raise a NoValidHost exception. For the moment, nothing is setting this field but the next patch will provide an API-level modification for putting it if the provided destination exists (and changing the behaviour if the admin provides the host field for evacuate and live-migrate) Change-Id: Ifb803c708e89b7101ded48571e1af49c33117758 Partially-Implements: blueprint check-destination-on-migrations
717 lines
30 KiB
Python
717 lines
30 KiB
Python
# Copyright (c) 2011 OpenStack Foundation
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
Manage hosts in the current zone.
|
|
"""
|
|
|
|
import collections
|
|
import functools
|
|
import time
|
|
try:
|
|
from collections import UserDict as IterableUserDict # Python 3
|
|
except ImportError:
|
|
from UserDict import IterableUserDict # Python 2
|
|
|
|
|
|
import iso8601
|
|
from oslo_log import log as logging
|
|
from oslo_utils import timeutils
|
|
import six
|
|
|
|
import nova.conf
|
|
from nova import context as context_module
|
|
from nova import exception
|
|
from nova.i18n import _LI, _LW
|
|
from nova import objects
|
|
from nova.pci import stats as pci_stats
|
|
from nova.scheduler import filters
|
|
from nova.scheduler import weights
|
|
from nova import utils
|
|
from nova.virt import hardware
|
|
|
|
|
|
CONF = nova.conf.CONF
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
HOST_INSTANCE_SEMAPHORE = "host_instance"
|
|
|
|
|
|
class ReadOnlyDict(IterableUserDict):
|
|
"""A read-only dict."""
|
|
def __init__(self, source=None):
|
|
self.data = {}
|
|
if source:
|
|
self.data.update(source)
|
|
|
|
def __setitem__(self, key, item):
|
|
raise TypeError()
|
|
|
|
def __delitem__(self, key):
|
|
raise TypeError()
|
|
|
|
def clear(self):
|
|
raise TypeError()
|
|
|
|
def pop(self, key, *args):
|
|
raise TypeError()
|
|
|
|
def popitem(self):
|
|
raise TypeError()
|
|
|
|
def update(self):
|
|
raise TypeError()
|
|
|
|
|
|
@utils.expects_func_args('self', 'spec_obj')
|
|
def set_update_time_on_success(function):
|
|
"""Set updated time of HostState when consuming succeed."""
|
|
|
|
@functools.wraps(function)
|
|
def decorated_function(self, spec_obj):
|
|
return_value = None
|
|
try:
|
|
return_value = function(self, spec_obj)
|
|
except Exception as e:
|
|
# Ignores exception raised from consume_from_request() so that
|
|
# booting instance would fail in the resource claim of compute
|
|
# node, other suitable node may be chosen during scheduling retry.
|
|
LOG.warning(_LW("Selected host: %(host)s failed to consume from "
|
|
"instance. Error: %(error)s"),
|
|
{'host': self.host, 'error': e})
|
|
else:
|
|
now = timeutils.utcnow()
|
|
# NOTE(sbauza): Objects are UTC tz-aware by default
|
|
self.updated = now.replace(tzinfo=iso8601.iso8601.Utc())
|
|
return return_value
|
|
|
|
return decorated_function
|
|
|
|
|
|
class HostState(object):
|
|
"""Mutable and immutable information tracked for a host.
|
|
This is an attempt to remove the ad-hoc data structures
|
|
previously used and lock down access.
|
|
"""
|
|
|
|
def __init__(self, host, node):
|
|
self.host = host
|
|
self.nodename = node
|
|
self._lock_name = (host, node)
|
|
|
|
# Mutable available resources.
|
|
# These will change as resources are virtually "consumed".
|
|
self.total_usable_ram_mb = 0
|
|
self.total_usable_disk_gb = 0
|
|
self.disk_mb_used = 0
|
|
self.free_ram_mb = 0
|
|
self.free_disk_mb = 0
|
|
self.vcpus_total = 0
|
|
self.vcpus_used = 0
|
|
self.pci_stats = None
|
|
self.numa_topology = None
|
|
|
|
# Additional host information from the compute node stats:
|
|
self.num_instances = 0
|
|
self.num_io_ops = 0
|
|
|
|
# Other information
|
|
self.host_ip = None
|
|
self.hypervisor_type = None
|
|
self.hypervisor_version = None
|
|
self.hypervisor_hostname = None
|
|
self.cpu_info = None
|
|
self.supported_instances = None
|
|
|
|
# Resource oversubscription values for the compute host:
|
|
self.limits = {}
|
|
|
|
# Generic metrics from compute nodes
|
|
self.metrics = None
|
|
|
|
# List of aggregates the host belongs to
|
|
self.aggregates = []
|
|
|
|
# Instances on this host
|
|
self.instances = {}
|
|
|
|
# Allocation ratios for this host
|
|
self.ram_allocation_ratio = None
|
|
self.cpu_allocation_ratio = None
|
|
self.disk_allocation_ratio = None
|
|
|
|
self.updated = None
|
|
|
|
def update(self, compute=None, service=None, aggregates=None,
|
|
inst_dict=None):
|
|
"""Update all information about a host."""
|
|
|
|
@utils.synchronized(self._lock_name)
|
|
def _locked_update(self, compute, service, aggregates, inst_dict):
|
|
# Scheduler API is inherently multi-threaded as every incoming RPC
|
|
# message will be dispatched in it's own green thread. So the
|
|
# shared host state should be updated in a consistent way to make
|
|
# sure its data is valid under concurrent write operations.
|
|
if compute is not None:
|
|
LOG.debug("Update host state from compute node: %s", compute)
|
|
self._update_from_compute_node(compute)
|
|
if aggregates is not None:
|
|
LOG.debug("Update host state with aggregates: %s", aggregates)
|
|
self.aggregates = aggregates
|
|
if service is not None:
|
|
LOG.debug("Update host state with service dict: %s", service)
|
|
self.service = ReadOnlyDict(service)
|
|
if inst_dict is not None:
|
|
LOG.debug("Update host state with instances: %s", inst_dict)
|
|
self.instances = inst_dict
|
|
|
|
return _locked_update(self, compute, service, aggregates, inst_dict)
|
|
|
|
def _update_from_compute_node(self, compute):
|
|
"""Update information about a host from a ComputeNode object."""
|
|
if (self.updated and compute.updated_at
|
|
and self.updated > compute.updated_at):
|
|
return
|
|
all_ram_mb = compute.memory_mb
|
|
|
|
# Assume virtual size is all consumed by instances if use qcow2 disk.
|
|
free_gb = compute.free_disk_gb
|
|
least_gb = compute.disk_available_least
|
|
if least_gb is not None:
|
|
if least_gb > free_gb:
|
|
# can occur when an instance in database is not on host
|
|
LOG.warning(_LW("Host %(hostname)s has more disk space than "
|
|
"database expected "
|
|
"(%(physical)s GB > %(database)s GB)"),
|
|
{'physical': least_gb, 'database': free_gb,
|
|
'hostname': compute.hypervisor_hostname})
|
|
free_gb = min(least_gb, free_gb)
|
|
free_disk_mb = free_gb * 1024
|
|
|
|
self.disk_mb_used = compute.local_gb_used * 1024
|
|
|
|
# NOTE(jogo) free_ram_mb can be negative
|
|
self.free_ram_mb = compute.free_ram_mb
|
|
self.total_usable_ram_mb = all_ram_mb
|
|
self.total_usable_disk_gb = compute.local_gb
|
|
self.free_disk_mb = free_disk_mb
|
|
self.vcpus_total = compute.vcpus
|
|
self.vcpus_used = compute.vcpus_used
|
|
self.updated = compute.updated_at
|
|
self.numa_topology = compute.numa_topology
|
|
self.pci_stats = pci_stats.PciDeviceStats(
|
|
compute.pci_device_pools)
|
|
|
|
# All virt drivers report host_ip
|
|
self.host_ip = compute.host_ip
|
|
self.hypervisor_type = compute.hypervisor_type
|
|
self.hypervisor_version = compute.hypervisor_version
|
|
self.hypervisor_hostname = compute.hypervisor_hostname
|
|
self.cpu_info = compute.cpu_info
|
|
if compute.supported_hv_specs:
|
|
self.supported_instances = [spec.to_list() for spec
|
|
in compute.supported_hv_specs]
|
|
else:
|
|
self.supported_instances = []
|
|
|
|
# Don't store stats directly in host_state to make sure these don't
|
|
# overwrite any values, or get overwritten themselves. Store in self so
|
|
# filters can schedule with them.
|
|
self.stats = compute.stats or {}
|
|
|
|
# Track number of instances on host
|
|
self.num_instances = int(self.stats.get('num_instances', 0))
|
|
|
|
self.num_io_ops = int(self.stats.get('io_workload', 0))
|
|
|
|
# update metrics
|
|
self.metrics = objects.MonitorMetricList.from_json(compute.metrics)
|
|
|
|
# update allocation ratios given by the ComputeNode object
|
|
self.cpu_allocation_ratio = compute.cpu_allocation_ratio
|
|
self.ram_allocation_ratio = compute.ram_allocation_ratio
|
|
self.disk_allocation_ratio = compute.disk_allocation_ratio
|
|
|
|
def consume_from_request(self, spec_obj):
|
|
"""Incrementally update host state from a RequestSpec object."""
|
|
|
|
@utils.synchronized(self._lock_name)
|
|
@set_update_time_on_success
|
|
def _locked(self, spec_obj):
|
|
# Scheduler API is inherently multi-threaded as every incoming RPC
|
|
# message will be dispatched in it's own green thread. So the
|
|
# shared host state should be consumed in a consistent way to make
|
|
# sure its data is valid under concurrent write operations.
|
|
self._locked_consume_from_request(spec_obj)
|
|
|
|
return _locked(self, spec_obj)
|
|
|
|
def _locked_consume_from_request(self, spec_obj):
|
|
disk_mb = (spec_obj.root_gb +
|
|
spec_obj.ephemeral_gb) * 1024
|
|
ram_mb = spec_obj.memory_mb
|
|
vcpus = spec_obj.vcpus
|
|
self.free_ram_mb -= ram_mb
|
|
self.free_disk_mb -= disk_mb
|
|
self.vcpus_used += vcpus
|
|
|
|
# Track number of instances on host
|
|
self.num_instances += 1
|
|
|
|
pci_requests = spec_obj.pci_requests
|
|
if pci_requests and self.pci_stats:
|
|
pci_requests = pci_requests.requests
|
|
else:
|
|
pci_requests = None
|
|
|
|
# Calculate the numa usage
|
|
host_numa_topology, _fmt = hardware.host_topology_and_format_from_host(
|
|
self)
|
|
instance_numa_topology = spec_obj.numa_topology
|
|
|
|
spec_obj.numa_topology = hardware.numa_fit_instance_to_host(
|
|
host_numa_topology, instance_numa_topology,
|
|
limits=self.limits.get('numa_topology'),
|
|
pci_requests=pci_requests, pci_stats=self.pci_stats)
|
|
if pci_requests:
|
|
instance_cells = None
|
|
if spec_obj.numa_topology:
|
|
instance_cells = spec_obj.numa_topology.cells
|
|
self.pci_stats.apply_requests(pci_requests, instance_cells)
|
|
|
|
# NOTE(sbauza): Yeah, that's crap. We should get rid of all of those
|
|
# NUMA helpers because now we're 100% sure that spec_obj.numa_topology
|
|
# is an InstanceNUMATopology object. Unfortunately, since
|
|
# HostState.host_numa_topology is still limbo between an NUMATopology
|
|
# object (when updated by consume_from_request), a ComputeNode object
|
|
# (when updated by update_from_compute_node), we need to keep the call
|
|
# to get_host_numa_usage_from_instance until it's fixed (and use a
|
|
# temporary orphaned Instance object as a proxy)
|
|
instance = objects.Instance(numa_topology=spec_obj.numa_topology)
|
|
|
|
self.numa_topology = hardware.get_host_numa_usage_from_instance(
|
|
self, instance)
|
|
|
|
# NOTE(sbauza): By considering all cases when the scheduler is called
|
|
# and when consume_from_request() is run, we can safely say that there
|
|
# is always an IO operation because we want to move the instance
|
|
self.num_io_ops += 1
|
|
|
|
def __repr__(self):
|
|
return ("(%(host)s, %(node)s) ram: %(free_ram)sMB "
|
|
"disk: %(free_disk)sMB io_ops: %(num_io_ops)s "
|
|
"instances: %(num_instances)s" %
|
|
{'host': self.host, 'node': self.nodename,
|
|
'free_ram': self.free_ram_mb, 'free_disk': self.free_disk_mb,
|
|
'num_io_ops': self.num_io_ops,
|
|
'num_instances': self.num_instances})
|
|
|
|
|
|
class HostManager(object):
|
|
"""Base HostManager class."""
|
|
|
|
# Can be overridden in a subclass
|
|
def host_state_cls(self, host, node, **kwargs):
|
|
return HostState(host, node)
|
|
|
|
def __init__(self):
|
|
self.host_state_map = {}
|
|
self.filter_handler = filters.HostFilterHandler()
|
|
filter_classes = self.filter_handler.get_matching_classes(
|
|
CONF.scheduler_available_filters)
|
|
self.filter_cls_map = {cls.__name__: cls for cls in filter_classes}
|
|
self.filter_obj_map = {}
|
|
self.default_filters = self._choose_host_filters(self._load_filters())
|
|
self.weight_handler = weights.HostWeightHandler()
|
|
weigher_classes = self.weight_handler.get_matching_classes(
|
|
CONF.scheduler_weight_classes)
|
|
self.weighers = [cls() for cls in weigher_classes]
|
|
# Dict of aggregates keyed by their ID
|
|
self.aggs_by_id = {}
|
|
# Dict of set of aggregate IDs keyed by the name of the host belonging
|
|
# to those aggregates
|
|
self.host_aggregates_map = collections.defaultdict(set)
|
|
self._init_aggregates()
|
|
self.tracks_instance_changes = CONF.scheduler_tracks_instance_changes
|
|
# Dict of instances and status, keyed by host
|
|
self._instance_info = {}
|
|
if self.tracks_instance_changes:
|
|
self._init_instance_info()
|
|
|
|
def _load_filters(self):
|
|
return CONF.scheduler_default_filters
|
|
|
|
def _init_aggregates(self):
|
|
elevated = context_module.get_admin_context()
|
|
aggs = objects.AggregateList.get_all(elevated)
|
|
for agg in aggs:
|
|
self.aggs_by_id[agg.id] = agg
|
|
for host in agg.hosts:
|
|
self.host_aggregates_map[host].add(agg.id)
|
|
|
|
def update_aggregates(self, aggregates):
|
|
"""Updates internal HostManager information about aggregates."""
|
|
if isinstance(aggregates, (list, objects.AggregateList)):
|
|
for agg in aggregates:
|
|
self._update_aggregate(agg)
|
|
else:
|
|
self._update_aggregate(aggregates)
|
|
|
|
def _update_aggregate(self, aggregate):
|
|
self.aggs_by_id[aggregate.id] = aggregate
|
|
for host in aggregate.hosts:
|
|
self.host_aggregates_map[host].add(aggregate.id)
|
|
# Refreshing the mapping dict to remove all hosts that are no longer
|
|
# part of the aggregate
|
|
for host in self.host_aggregates_map:
|
|
if (aggregate.id in self.host_aggregates_map[host]
|
|
and host not in aggregate.hosts):
|
|
self.host_aggregates_map[host].remove(aggregate.id)
|
|
|
|
def delete_aggregate(self, aggregate):
|
|
"""Deletes internal HostManager information about a specific aggregate.
|
|
"""
|
|
if aggregate.id in self.aggs_by_id:
|
|
del self.aggs_by_id[aggregate.id]
|
|
for host in aggregate.hosts:
|
|
if aggregate.id in self.host_aggregates_map[host]:
|
|
self.host_aggregates_map[host].remove(aggregate.id)
|
|
|
|
def _init_instance_info(self):
|
|
"""Creates the initial view of instances for all hosts.
|
|
|
|
As this initial population of instance information may take some time,
|
|
we don't wish to block the scheduler's startup while this completes.
|
|
The async method allows us to simply mock out the _init_instance_info()
|
|
method in tests.
|
|
"""
|
|
|
|
def _async_init_instance_info():
|
|
context = context_module.get_admin_context()
|
|
LOG.debug("START:_async_init_instance_info")
|
|
self._instance_info = {}
|
|
compute_nodes = objects.ComputeNodeList.get_all(context).objects
|
|
LOG.debug("Total number of compute nodes: %s", len(compute_nodes))
|
|
# Break the queries into batches of 10 to reduce the total number
|
|
# of calls to the DB.
|
|
batch_size = 10
|
|
start_node = 0
|
|
end_node = batch_size
|
|
while start_node <= len(compute_nodes):
|
|
curr_nodes = compute_nodes[start_node:end_node]
|
|
start_node += batch_size
|
|
end_node += batch_size
|
|
filters = {"host": [curr_node.host
|
|
for curr_node in curr_nodes],
|
|
"deleted": False}
|
|
result = objects.InstanceList.get_by_filters(context,
|
|
filters)
|
|
instances = result.objects
|
|
LOG.debug("Adding %s instances for hosts %s-%s",
|
|
len(instances), start_node, end_node)
|
|
for instance in instances:
|
|
host = instance.host
|
|
if host not in self._instance_info:
|
|
self._instance_info[host] = {"instances": {},
|
|
"updated": False}
|
|
inst_dict = self._instance_info[host]
|
|
inst_dict["instances"][instance.uuid] = instance
|
|
# Call sleep() to cooperatively yield
|
|
time.sleep(0)
|
|
LOG.debug("END:_async_init_instance_info")
|
|
|
|
# Run this async so that we don't block the scheduler start-up
|
|
utils.spawn_n(_async_init_instance_info)
|
|
|
|
def _choose_host_filters(self, filter_cls_names):
|
|
"""Since the caller may specify which filters to use we need
|
|
to have an authoritative list of what is permissible. This
|
|
function checks the filter names against a predefined set
|
|
of acceptable filters.
|
|
"""
|
|
if not isinstance(filter_cls_names, (list, tuple)):
|
|
filter_cls_names = [filter_cls_names]
|
|
|
|
good_filters = []
|
|
bad_filters = []
|
|
for filter_name in filter_cls_names:
|
|
if filter_name not in self.filter_obj_map:
|
|
if filter_name not in self.filter_cls_map:
|
|
bad_filters.append(filter_name)
|
|
continue
|
|
filter_cls = self.filter_cls_map[filter_name]
|
|
self.filter_obj_map[filter_name] = filter_cls()
|
|
good_filters.append(self.filter_obj_map[filter_name])
|
|
if bad_filters:
|
|
msg = ", ".join(bad_filters)
|
|
raise exception.SchedulerHostFilterNotFound(filter_name=msg)
|
|
return good_filters
|
|
|
|
def get_filtered_hosts(self, hosts, spec_obj, index=0):
|
|
"""Filter hosts and return only ones passing all filters."""
|
|
|
|
def _strip_ignore_hosts(host_map, hosts_to_ignore):
|
|
ignored_hosts = []
|
|
for host in hosts_to_ignore:
|
|
for (hostname, nodename) in list(host_map.keys()):
|
|
if host.lower() == hostname.lower():
|
|
del host_map[(hostname, nodename)]
|
|
ignored_hosts.append(host)
|
|
ignored_hosts_str = ', '.join(ignored_hosts)
|
|
LOG.info(_LI('Host filter ignoring hosts: %s'), ignored_hosts_str)
|
|
|
|
def _match_forced_hosts(host_map, hosts_to_force):
|
|
forced_hosts = []
|
|
lowered_hosts_to_force = [host.lower() for host in hosts_to_force]
|
|
for (hostname, nodename) in list(host_map.keys()):
|
|
if hostname.lower() not in lowered_hosts_to_force:
|
|
del host_map[(hostname, nodename)]
|
|
else:
|
|
forced_hosts.append(hostname)
|
|
if host_map:
|
|
forced_hosts_str = ', '.join(forced_hosts)
|
|
msg = _LI('Host filter forcing available hosts to %s')
|
|
else:
|
|
forced_hosts_str = ', '.join(hosts_to_force)
|
|
msg = _LI("No hosts matched due to not matching "
|
|
"'force_hosts' value of '%s'")
|
|
LOG.info(msg % forced_hosts_str)
|
|
|
|
def _match_forced_nodes(host_map, nodes_to_force):
|
|
forced_nodes = []
|
|
for (hostname, nodename) in list(host_map.keys()):
|
|
if nodename not in nodes_to_force:
|
|
del host_map[(hostname, nodename)]
|
|
else:
|
|
forced_nodes.append(nodename)
|
|
if host_map:
|
|
forced_nodes_str = ', '.join(forced_nodes)
|
|
msg = _LI('Host filter forcing available nodes to %s')
|
|
else:
|
|
forced_nodes_str = ', '.join(nodes_to_force)
|
|
msg = _LI("No nodes matched due to not matching "
|
|
"'force_nodes' value of '%s'")
|
|
LOG.info(msg % forced_nodes_str)
|
|
|
|
def _get_hosts_matching_request(hosts, requested_destination):
|
|
(host, node) = (requested_destination.host,
|
|
requested_destination.node)
|
|
requested_nodes = [x for x in hosts
|
|
if x.host == host and x.nodename == node]
|
|
if requested_nodes:
|
|
LOG.info(_LI('Host filter only checking host %(host)s and '
|
|
'node %(node)s') % {'host': host, 'node': node})
|
|
else:
|
|
# NOTE(sbauza): The API level should prevent the user from
|
|
# providing a wrong destination but let's make sure a wrong
|
|
# destination doesn't trample the scheduler still.
|
|
LOG.info(_LI('No hosts matched due to not matching requested '
|
|
'destination (%(host)s, %(node)s)'
|
|
) % {'host': host, 'node': node})
|
|
return iter(requested_nodes)
|
|
|
|
ignore_hosts = spec_obj.ignore_hosts or []
|
|
force_hosts = spec_obj.force_hosts or []
|
|
force_nodes = spec_obj.force_nodes or []
|
|
requested_node = spec_obj.requested_destination
|
|
|
|
if requested_node is not None:
|
|
# NOTE(sbauza): Reduce a potentially long set of hosts as much as
|
|
# possible to any requested destination nodes before passing the
|
|
# list to the filters
|
|
hosts = _get_hosts_matching_request(hosts, requested_node)
|
|
if ignore_hosts or force_hosts or force_nodes:
|
|
# NOTE(deva): we can't assume "host" is unique because
|
|
# one host may have many nodes.
|
|
name_to_cls_map = {(x.host, x.nodename): x for x in hosts}
|
|
if ignore_hosts:
|
|
_strip_ignore_hosts(name_to_cls_map, ignore_hosts)
|
|
if not name_to_cls_map:
|
|
return []
|
|
# NOTE(deva): allow force_hosts and force_nodes independently
|
|
if force_hosts:
|
|
_match_forced_hosts(name_to_cls_map, force_hosts)
|
|
if force_nodes:
|
|
_match_forced_nodes(name_to_cls_map, force_nodes)
|
|
if force_hosts or force_nodes:
|
|
# NOTE(deva): Skip filters when forcing host or node
|
|
if name_to_cls_map:
|
|
return name_to_cls_map.values()
|
|
else:
|
|
return []
|
|
hosts = six.itervalues(name_to_cls_map)
|
|
|
|
return self.filter_handler.get_filtered_objects(self.default_filters,
|
|
hosts, spec_obj, index)
|
|
|
|
def get_weighed_hosts(self, hosts, spec_obj):
|
|
"""Weigh the hosts."""
|
|
return self.weight_handler.get_weighed_objects(self.weighers,
|
|
hosts, spec_obj)
|
|
|
|
def get_all_host_states(self, context):
|
|
"""Returns a list of HostStates that represents all the hosts
|
|
the HostManager knows about. Also, each of the consumable resources
|
|
in HostState are pre-populated and adjusted based on data in the db.
|
|
"""
|
|
|
|
service_refs = {service.host: service
|
|
for service in objects.ServiceList.get_by_binary(
|
|
context, 'nova-compute', include_disabled=True)}
|
|
# Get resource usage across the available compute nodes:
|
|
compute_nodes = objects.ComputeNodeList.get_all(context)
|
|
seen_nodes = set()
|
|
for compute in compute_nodes:
|
|
service = service_refs.get(compute.host)
|
|
|
|
if not service:
|
|
LOG.warning(_LW(
|
|
"No compute service record found for host %(host)s"),
|
|
{'host': compute.host})
|
|
continue
|
|
host = compute.host
|
|
node = compute.hypervisor_hostname
|
|
state_key = (host, node)
|
|
host_state = self.host_state_map.get(state_key)
|
|
if not host_state:
|
|
host_state = self.host_state_cls(host, node, compute=compute)
|
|
self.host_state_map[state_key] = host_state
|
|
# We force to update the aggregates info each time a new request
|
|
# comes in, because some changes on the aggregates could have been
|
|
# happening after setting this field for the first time
|
|
host_state.update(compute,
|
|
dict(service),
|
|
self._get_aggregates_info(host),
|
|
self._get_instance_info(context, compute))
|
|
|
|
seen_nodes.add(state_key)
|
|
|
|
# remove compute nodes from host_state_map if they are not active
|
|
dead_nodes = set(self.host_state_map.keys()) - seen_nodes
|
|
for state_key in dead_nodes:
|
|
host, node = state_key
|
|
LOG.info(_LI("Removing dead compute node %(host)s:%(node)s "
|
|
"from scheduler"), {'host': host, 'node': node})
|
|
del self.host_state_map[state_key]
|
|
|
|
return six.itervalues(self.host_state_map)
|
|
|
|
def _get_aggregates_info(self, host):
|
|
return [self.aggs_by_id[agg_id] for agg_id in
|
|
self.host_aggregates_map[host]]
|
|
|
|
def _get_instance_info(self, context, compute):
|
|
"""Gets the host instance info from the compute host.
|
|
|
|
Some older compute nodes may not be sending instance change updates to
|
|
the Scheduler; other sites may disable this feature for performance
|
|
reasons. In either of these cases, there will either be no information
|
|
for the host, or the 'updated' value for that host dict will be False.
|
|
In those cases, we need to grab the current InstanceList instead of
|
|
relying on the version in _instance_info.
|
|
"""
|
|
host_name = compute.host
|
|
host_info = self._instance_info.get(host_name)
|
|
if host_info and host_info.get("updated"):
|
|
inst_dict = host_info["instances"]
|
|
else:
|
|
# Host is running old version, or updates aren't flowing.
|
|
inst_list = objects.InstanceList.get_by_host(context, host_name)
|
|
inst_dict = {instance.uuid: instance
|
|
for instance in inst_list.objects}
|
|
return inst_dict
|
|
|
|
def _recreate_instance_info(self, context, host_name):
|
|
"""Get the InstanceList for the specified host, and store it in the
|
|
_instance_info dict.
|
|
"""
|
|
instances = objects.InstanceList.get_by_host(context, host_name)
|
|
inst_dict = {instance.uuid: instance for instance in instances}
|
|
host_info = self._instance_info[host_name] = {}
|
|
host_info["instances"] = inst_dict
|
|
host_info["updated"] = False
|
|
|
|
@utils.synchronized(HOST_INSTANCE_SEMAPHORE)
|
|
def update_instance_info(self, context, host_name, instance_info):
|
|
"""Receives an InstanceList object from a compute node.
|
|
|
|
This method receives information from a compute node when it starts up,
|
|
or when its instances have changed, and updates its view of hosts and
|
|
instances with it.
|
|
"""
|
|
host_info = self._instance_info.get(host_name)
|
|
if host_info:
|
|
inst_dict = host_info.get("instances")
|
|
for instance in instance_info.objects:
|
|
# Overwrite the entry (if any) with the new info.
|
|
inst_dict[instance.uuid] = instance
|
|
host_info["updated"] = True
|
|
else:
|
|
instances = instance_info.objects
|
|
if len(instances) > 1:
|
|
# This is a host sending its full instance list, so use it.
|
|
host_info = self._instance_info[host_name] = {}
|
|
host_info["instances"] = {instance.uuid: instance
|
|
for instance in instances}
|
|
host_info["updated"] = True
|
|
else:
|
|
self._recreate_instance_info(context, host_name)
|
|
LOG.info(_LI("Received an update from an unknown host '%s'. "
|
|
"Re-created its InstanceList."), host_name)
|
|
|
|
@utils.synchronized(HOST_INSTANCE_SEMAPHORE)
|
|
def delete_instance_info(self, context, host_name, instance_uuid):
|
|
"""Receives the UUID from a compute node when one of its instances is
|
|
terminated.
|
|
|
|
The instance in the local view of the host's instances is removed.
|
|
"""
|
|
host_info = self._instance_info.get(host_name)
|
|
if host_info:
|
|
inst_dict = host_info["instances"]
|
|
# Remove the existing Instance object, if any
|
|
inst_dict.pop(instance_uuid, None)
|
|
host_info["updated"] = True
|
|
else:
|
|
self._recreate_instance_info(context, host_name)
|
|
LOG.info(_LI("Received a delete update from an unknown host '%s'. "
|
|
"Re-created its InstanceList."), host_name)
|
|
|
|
@utils.synchronized(HOST_INSTANCE_SEMAPHORE)
|
|
def sync_instance_info(self, context, host_name, instance_uuids):
|
|
"""Receives the uuids of the instances on a host.
|
|
|
|
This method is periodically called by the compute nodes, which send a
|
|
list of all the UUID values for the instances on that node. This is
|
|
used by the scheduler's HostManager to detect when its view of the
|
|
compute node's instances is out of sync.
|
|
"""
|
|
host_info = self._instance_info.get(host_name)
|
|
if host_info:
|
|
local_set = set(host_info["instances"].keys())
|
|
compute_set = set(instance_uuids)
|
|
if not local_set == compute_set:
|
|
self._recreate_instance_info(context, host_name)
|
|
LOG.info(_LI("The instance sync for host '%s' did not match. "
|
|
"Re-created its InstanceList."), host_name)
|
|
return
|
|
host_info["updated"] = True
|
|
LOG.info(_LI("Successfully synced instances from host '%s'."),
|
|
host_name)
|
|
else:
|
|
self._recreate_instance_info(context, host_name)
|
|
LOG.info(_LI("Received a sync request from an unknown host '%s'. "
|
|
"Re-created its InstanceList."), host_name)
|