def get_constraint_matrix(self, hosts, filter_properties):
        num_hosts = len(hosts)
        num_instances = filter_properties.get('num_instances')

        constraint_matrix = [[True for j in xrange(num_instances)]
                             for i in xrange(num_hosts)]

        scheduler_hints = filter_properties.get('scheduler_hints') or {}
        affinity_uuids = scheduler_hints.get('same_rack', [])

        if not affinity_uuids:
            return constraint_matrix

        if isinstance(affinity_uuids, six.string_types):
            affinity_uuids = [affinity_uuids]

        host_racks_map = solver_utils.get_host_racks_map(hosts)

        affinity_racks = set([])
        affinity_hosts = set([])

        for i in xrange(num_hosts):
            host_name = hosts[i].host
            host_racks = host_racks_map.get(host_name, set([]))
            if solver_utils.instance_uuids_overlap(hosts[i], affinity_uuids):
                affinity_racks = affinity_racks.union(host_racks)
                affinity_hosts.add(host_name)

        for i in xrange(num_hosts):
            host_name = hosts[i].host
            host_racks = host_racks_map.get(host_name, set([]))
            if host_name in affinity_hosts:
                LOG.debug(_("%(host)s passed same-rack check."),
                          {'host': host_name})
                continue
            elif (len(host_racks) == 0) or any(
                [rack not in affinity_racks for rack in host_racks]):
                constraint_matrix[i] = [False for j in xrange(num_instances)]
            else:
                LOG.debug(_("%(host)s passed same-rack check."),
                          {'host': host_name})

        return constraint_matrix
    def get_constraint_matrix(self, hosts, filter_properties):
        num_hosts = len(hosts)
        num_instances = filter_properties.get('num_instances')

        constraint_matrix = [[True for j in xrange(num_instances)]
                            for i in xrange(num_hosts)]

        scheduler_hints = filter_properties.get('scheduler_hints') or {}
        affinity_uuids = scheduler_hints.get('same_rack', [])

        if not affinity_uuids:
            return constraint_matrix

        if isinstance(affinity_uuids, six.string_types):
            affinity_uuids = [affinity_uuids]

        host_racks_map = solver_utils.get_host_racks_map(hosts)

        affinity_racks = set([])
        affinity_hosts = set([])

        for i in xrange(num_hosts):
            host_name = hosts[i].host
            host_racks = host_racks_map.get(host_name, set([]))
            if solver_utils.instance_uuids_overlap(hosts[i], affinity_uuids):
                affinity_racks = affinity_racks.union(host_racks)
                affinity_hosts.add(host_name)

        for i in xrange(num_hosts):
            host_name = hosts[i].host
            host_racks = host_racks_map.get(host_name, set([]))
            if host_name in affinity_hosts:
                LOG.debug(_("%(host)s passed same-rack check."),
                        {'host': host_name})
                continue
            elif (len(host_racks) == 0) or any([rack not in affinity_racks
                                                for rack in host_racks]):
                constraint_matrix[i] = [False for j in xrange(num_instances)]
            else:
                LOG.debug(_("%(host)s passed same-rack check."),
                        {'host': host_name})

        return constraint_matrix
Exemple #3
0
    def get_extended_cost_matrix(self, hosts, filter_properties):
        num_hosts = len(hosts)
        num_instances = filter_properties.get('num_instances')

        multiplier = self.cost_multiplier()
        if multiplier == 0:
            extended_cost_matrix = [[0 for j in xrange(num_instances + 1)]
                                    for i in xrange(num_hosts)]
            return extended_cost_matrix

        scheduler_hints = filter_properties.get('scheduler_hints') or {}
        affinity_uuids = scheduler_hints.get('soft_different_host', [])

        if affinity_uuids == '':
            extended_cost_matrix = [[
                float(j) / multiplier for j in xrange(num_instances + 1)
            ] for i in xrange(num_hosts)]
            LOG.debug(_('No instance specified for AntiAffinityCost.'))
            return extended_cost_matrix

        if isinstance(affinity_uuids, six.string_types):
            affinity_uuids = [affinity_uuids]

        if affinity_uuids:
            extended_cost_matrix = [[
                float(j) / multiplier for j in xrange(num_instances + 1)
            ] for i in xrange(num_hosts)]
            for i in xrange(num_hosts):
                if solver_utils.instance_uuids_overlap(hosts[i],
                                                       affinity_uuids):
                    extended_cost_matrix[i] = [
                        1 + (float(j) / multiplier)
                        for j in xrange(num_instances + 1)
                    ]
        else:
            extended_cost_matrix = [[0 for j in xrange(num_instances + 1)]
                                    for i in xrange(num_hosts)]

        return extended_cost_matrix
    def get_extended_cost_matrix(self, hosts, filter_properties):
        num_hosts = len(hosts)
        num_instances = filter_properties.get('num_instances')

        multiplier = self.cost_multiplier()
        if multiplier == 0:
            extended_cost_matrix = [[0 for j in xrange(num_instances + 1)]
                                    for i in xrange(num_hosts)]
            return extended_cost_matrix

        scheduler_hints = filter_properties.get('scheduler_hints') or {}
        affinity_uuids = scheduler_hints.get('soft_different_host', [])

        if affinity_uuids == '':
            extended_cost_matrix = [[float(j) / multiplier
                                    for j in xrange(num_instances + 1)]
                                    for i in xrange(num_hosts)]
            LOG.debug(_('No instance specified for AntiAffinityCost.'))
            return extended_cost_matrix

        if isinstance(affinity_uuids, six.string_types):
            affinity_uuids = [affinity_uuids]

        if affinity_uuids:
            extended_cost_matrix = [[float(j) / multiplier
                                    for j in xrange(num_instances + 1)]
                                    for i in xrange(num_hosts)]
            for i in xrange(num_hosts):
                if solver_utils.instance_uuids_overlap(hosts[i],
                                                       affinity_uuids):
                    extended_cost_matrix[i] = [1 + (float(j) / multiplier)
                                        for j in xrange(num_instances + 1)]
        else:
            extended_cost_matrix = [[0 for j in xrange(num_instances + 1)]
                                    for i in xrange(num_hosts)]

        return extended_cost_matrix