case madmin.ServiceActionFreeze:
		serviceSig = serviceFreeze
	case madmin.ServiceActionUnfreeze:
		serviceSig = serviceUnFreeze
	default:
		adminLogIf(ctx, fmt.Errorf("Unrecognized service action %s requested", action), logger.ErrorKind)
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrMalformedPOSTRequest), r.URL)
		return
	}

	var objectAPI ObjectLayer
	switch serviceSig {
	case serviceRestart:

                doLast {
                    println "configurationCache.requested=" + buildFeatures.configurationCache.requested.getOrNull()
                    println "configurationCache.active=" + buildFeatures.configurationCache.active.get()
                    println "isolatedProjects.requested=" + buildFeatures.isolatedProjects.requested.getOrNull()

        def candidate2 = attributes(usage: "no match")
        def requested = attributes(usage: "match")

        expect:
        matcher.matches([candidate1, candidate2], requested, explanationBuilder) == [candidate1]
        matcher.matches([candidate2], requested, explanationBuilder) == []

        matcher.isMatching(candidate1, requested)
        !matcher.isMatching(candidate2, requested)
    }

							Capacity:  100,
						},
					},
					0,
				},
				{
					classResourceMap{
						classHDD: &StorageResource{
							Requested: 0,
							Capacity:  100,
						},
						classSSD: &StorageResource{
							Requested: 30,
							Capacity:  100,
						},
					},
					15,
				},
				{
					classResourceMap{
						classHDD: &StorageResource{
							Requested: 30,

)

// leastResourceScorer favors nodes with fewer requested resources.
// It calculates the percentage of memory, CPU and other resources requested by pods scheduled on the node, and
// prioritizes based on the minimum of the average of the fraction of requested to capacity.
//
// Details:
// (cpu((capacity-requested)*MaxNodeScore*cpuWeight/capacity) + memory((capacity-requested)*MaxNodeScore*memoryWeight/capacity) + ...)/weightSum

        }

        where:
        requested | outcome
        'qa'      | 'succeeds'
        'canary'  | 'fails'
    }

    @Unroll("selects the first version which matches the component-level attributes (requested=#requested)")
    def "selects the first version which matches the component-level attributes"() {
        given:

            private final ImmutableAttributes requested;
            private final int hashCode;

            public CacheKey(List<ImmutableAttributes> variantAttributes, ImmutableAttributes requested) {
                this.variantAttributes = variantAttributes;
                this.requested = requested;
                this.hashCode = variantAttributes.hashCode() ^ requested.hashCode();
            }

            @Override

        when:
        def dep = factory.createUnresolvedDependency(selector('requested'), fromModule, false, selectedModule, new ModuleVersionResolveException(moduleVersionSelector('requested'), broken))
        def same = factory.createUnresolvedDependency(selector('requested'), fromModule, false, selectedModule, new ModuleVersionResolveException(moduleVersionSelector('requested'), broken))

        // incompatible attributes are not compatible with requested
        1 * attributeMatcher.isMatching(incompatible, requested) >> false
        // compatible attributes are compatible with requested
        1 * attributeMatcher.isMatching(compatible, requested) >> true

        0 * attributeMatcher._
    }

    def "selects all transforms that can produce variant that is compatible with requested"() {

		if alloc == 0 {
			continue
		}
		allocatable[i] = alloc
		requested[i] = req
	}

	score := r.scorer(requested, allocatable)

	if loggerV := logger.V(10); loggerV.Enabled() { // Serializing these maps is costly.
		loggerV.Info("Listed internal info for allocatable resources, requested resources and score", "pod",
			klog.KObj(pod), "node", klog.KObj(node), "resourceAllocationScorer", r.Name,