boot，rebuild，resize，migrate有关的scheduler流程

代码调用流程：

1. nova.scheduler.client.query.SchedulerQueryClient#select_destinations
2. nova.scheduler.rpcapi.SchedulerAPI#select_destinations
3. nova.scheduler.manager.SchedulerManager#select_destinations
4. nova.scheduler.filter_scheduler.FilterScheduler#select_destinations

scheduler的rpcapi和manager属于同步调用。

在第三步中scheduler会调用placement提供的API，对所有的`compute node`进行初步的筛选，placement的API会返回一个字典，格式如下：

{
    "provider_summaries": {
        "4cae2ef8-30eb-4571-80c3-3289e86bd65c": {
            "resources": {
                "VCPU": {
                    "used": 2,
                    "capacity": 64
                },
                "MEMORY_MB": {
                    "used": 1024,
                    "capacity": 11374
                },
                "DISK_GB": {
                    "used": 2,
                    "capacity": 49
                }
            }
        }
    },
    "allocation_requests": [
        {
            "allocations": [
                {
                    "resource_provider": {
                        "uuid": "4cae2ef8-30eb-4571-80c3-3289e86bd65c"
                    },
                    "resources": {
                        "VCPU": 1,
                        "MEMORY_MB": 512,
                        "DISK_GB": 1
                    }
                }
            ]
        }
    ]
}

对于placement API筛选出的节点，scheduler会再度进行筛选，大概的筛选过程：all hosts => filtering => weighting => random
1. get all hosts：这里的all host当然不是指环境中所有的host，而是在通过placement API，返回的所有host的详细信息；
2. filtering：首先过滤ignore host和force host，如果force host或者force node直接返回即可。然后结合nova的配置文件中available_filters和enabled_filters参数，依次执行所有的filter。下面我们举几个filter的例子，执行filter的入口：

nova.filters.BaseFilterHandler#get_filtered_objects
 
    def get_filtered_objects(self, filters, objs, spec_obj, index=0):
        list_objs = list(objs)
        LOG.debug("Starting with %d host(s)", len(list_objs))
        part_filter_results = []
        full_filter_results = []
        log_msg = "%(cls_name)s: (start: %(start)s, end: %(end)s)"
        # 循环遍历配置文件中指定的filters
        for filter_ in filters:
            if filter_.run_filter_for_index(index):
                cls_name = filter_.__class__.__name__
                # 记录开始该执行filter之前的host的个数
                start_count = len(list_objs)
                # 对所有的host执行该filter，返回只有经过该filter的host
                objs = filter_.filter_all(list_objs, spec_obj)
                if objs is None:
                    LOG.debug("Filter %s says to stop filtering", cls_name)
                    return
                list_objs = list(objs)
                end_count = len(list_objs)
                part_filter_results.append(log_msg % {"cls_name": cls_name,
                        "start": start_count, "end": end_count})
                if list_objs:
                    remaining = [(getattr(obj, "host", obj),
                                  getattr(obj, "nodename", ""))
                                 for obj in list_objs]
                    full_filter_results.append((cls_name, remaining))
                else:
                    LOG.info(_LI("Filter %s returned 0 hosts"), cls_name)
                    full_filter_results.append((cls_name, None))
                    break
                LOG.debug("Filter %(cls_name)s returned "
                          "%(obj_len)d host(s)",
                          {'cls_name': cls_name, 'obj_len': len(list_objs)})
        # 下边是一些日志中打印一些详细信息，不在赘述
        …………
        return list_objs

接下来介绍几个filter。

class AvailabilityZoneFilter(filters.BaseHostFilter):
 
    # 如果是一次创建多个虚机，则AvailabilityZoneFilter指执行一次
    run_filter_once_per_request = True  
    # 所有的filter都需要实现该方法
    def host_passes(self, host_state, spec_obj):
        # 获取request_spec中指定的availability_zone，这里需要强调一下，如果创建时，没有指定--availability-zone 参数，request_sepc中的availability_zone就是空的。
        availability_zone = spec_obj.availability_zone
        # 如果request_spec中availability_zone值为空，那么也就是这个操作是允许跨AZ操作的。
        if not availability_zone:
            return True
        # 获取host的availability_zone信息，首先获取该host所属的aggregate信息，aggregate信息中有availability_zone相关的信息
        metadata = utils.aggregate_metadata_get_by_host(
                host_state, key='availability_zone')
 
        if 'availability_zone' in metadata:
            # 判断request_spec中指定的availability_zone是否在该host所属的availability_zone中。
            hosts_passes = availability_zone in metadata['availability_zone']
            host_az = metadata['availability_zone']
        else:
            hosts_passes = availability_zone == CONF.default_availability_zone
            host_az = CONF.default_availability_zone
 
        if not hosts_passes:
            LOG.debug("Availability Zone '%(az)s' requested. "
                      "%(host_state)s has AZs: %(host_az)s",
                      {'host_state': host_state,
                       'az': availability_zone,
                       'host_az': host_az})
 
        return hosts_passes

nova.scheduler.filters.image_props_filter.ImagePropertiesFilter#host_passes
 
    # 主要是根据镜像中的property的值进行过滤，在ironic的调度中会使用到。
    def host_passes(self, host_state, spec_obj):
        image_props = spec_obj.image.properties if spec_obj.image else {}
        # 判断该compute_node是否支持image的property属性中指定的参数值。
        if not self._instance_supported(host_state, image_props,
                                        host_state.hypervisor_version):
            LOG.debug("%(host_state)s does not support requested "
                        "instance_properties", {'host_state': host_state})
            return False
        return True
     
    def _instance_supported(self, host_state, image_props,
                            hypervisor_version):
        img_arch = image_props.get('hw_architecture') # 架构，i686或x86_64
        img_h_type = image_props.get('img_hv_type') # hypervisor 类型
        img_vm_mode = image_props.get('hw_vm_mode') # 虚拟化类型
        …………
        # 获取该compute_node支持的instance类型，返回值为列表。比如：
        [["x86_64", "baremetal", "hvm"]]
        [["i686", "qemu", "hvm"], ["i686", "kvm", "hvm"], ["x86_64", "qemu", "hvm"], ["x86_64", "kvm", "hvm"]]
        supp_instances = host_state.supported_instances
        …………
        比较规则
        def _compare_props(props, other_props):
            # 对image的property指定的所有值进行遍历
            for i in props:
                查看该property是否是该compute_node支持的
                if i and i not in other_props:
                    return False
            return True
        # 对该compute_node支持的所有类型进行遍历
        for supp_inst in supp_instances:
            if _compare_props(checked_img_props, supp_inst)

对于Ironic的调度需要我们着重使用到ImagePropertiesFilter，虚机使用的镜像和裸机使用的镜像中的property的值是不同的，再结合相关的placement的调度，实现虚机不会调度到ironic node，同时创建裸机不会调度到qemu的node。

3. 把过滤后的hosts计算权重并且进行最优排序，下面我们举几个weight的例子：

class BaseWeightHandler(loadables.BaseLoader):
    object_class = WeighedObject
 
    def get_weighed_objects(self, weighers, obj_list, weighing_properties):
        """Return a sorted (descending), normalized list of WeighedObjects."""
        # obj_list 表示filter筛选出的所有hosts
        # weighing_properties 表示request_sepc信息
        weighed_objs = [self.object_class(obj, 0.0) for obj in obj_list]
        # 如果经过filter筛选只剩一个host，则无需进行权重的比较，直接返回该host即可
        if len(weighed_objs) <= 1:
            return weighed_objs
        # 根据配置文件中指定的weigher_classes，逐个计算权重
        for weigher in weighers:
            # 以RAMWeigher为例进行说明
            weights = weigher.weigh_objects(weighed_objs, weighing_properties)
 
            # Normalize the weights
            weights = normalize(weights,
                                minval=weigher.minval,
                                maxval=weigher.maxval)
 
            for i, weight in enumerate(weights):
                obj = weighed_objs[i]
                # 将计算后的权重值，保存到host信息中，并且将所有类型的权重加到一块，如果我们想要增加某种类型的权重比例，我们可以修改配置文件中*_weight_multiplier的值，比如我们想要在权重的计算中有关内存的权重占更大的作用，那么我们可以通过调节ram_weight_multiplier的值达到效果。
                obj.weight += weigher.weight_multiplier() * weight
        # 按照权重进行性排序（倒序）
        return sorted(weighed_objs, key=lambda x: x.weight, reverse=True)
         
class RAMWeigher(weights.BaseHostWeigher):
    minval = 0
 
    def weight_multiplier(self):
        """Override the weight multiplier."""
        return CONF.filter_scheduler.ram_weight_multiplier
 
    def _weigh_object(self, host_state, weight_properties):
        """Higher weights win.  We want spreading to be the default."""
        # 直接返回该节点的剩余内存，也就是剩余内存越多的节点，有关内存的权重越大。
        return host_state.free_ram_mb

4. random，这个过程我们通过代码进行详细的分析。

host_subset_size = CONF.filter_scheduler.host_subset_size
if host_subset_size < len(weighed_hosts):
    weighed_subset = weighed_hosts[0:host_subset_size]
else:
    weighed_subset = weighed_hosts
# 使用随机算法，从N个中抽取1个
chosen_host = random.choice(weighed_subset)
weighed_hosts.remove(chosen_host)
return [chosen_host] + weighed_hosts

对于host_subset_size参数，默认值为1。官方是这样解释的：如果设置大于1的正整数，当有多个scheduler进程处理相同的请求是会减少调度到同一台host的可能性，创造了一种竞争机制。从N个host中挑选最适合请求的一个host，会减少冲突。然而，如果该值设置的越大，对于给定的请求，选择的主机可能不太优化。