}

	vars := mux.Vars(r)
	v := vars["pool"]
	byID := vars["by-id"] == "true"

	pools := strings.Split(v, ",")
	poolIndices := make([]int, 0, len(pools))

	for _, pool := range pools {
		var idx int
		if byID {
			var err error
			idx, err = strconv.Atoi(pool)
			if err != nil {
				// We didn't find any matching pools, invalid input
				writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, errInvalidArgument), r.URL)

			if err != nil {
				err = msgp.WrapError(err, "Pools")
				return
			}
			if cap(z.Pools) >= int(zb0002) {
				z.Pools = (z.Pools)[:zb0002]
			} else {
				z.Pools = make([]PoolStatus, zb0002)
			}
			for za0001 := range z.Pools {
				err = z.Pools[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Pools", za0001)
					return
				}
			}
		default:

		p.Pools[idx].LastUpdate = UTCNow()
		p.Pools[idx].Decommission.StartTime = time.Time{}
		p.Pools[idx].Decommission.Complete = false
		p.Pools[idx].Decommission.Failed = true
		p.Pools[idx].Decommission.Canceled = false
		return true
	}
	return false
}

func (p *poolMeta) DecommissionCancel(idx int) bool {
	if p.Pools[idx].Decommission != nil && !p.Pools[idx].Decommission.Canceled {

	// diskFillFraction is the fraction of a disk we allow to be filled.
	diskFillFraction = 0.99

	// diskReserveFraction is the fraction of a disk where we will fill other server pools first.
	// If all pools reach this, we will use all pools with regular placement.
	diskReserveFraction = 0.15

	// diskAssumeUnknownSize is the size to assume when an unknown size upload is requested.
	diskAssumeUnknownSize = 1 << 30

	GetPools() []int
}

type localPeerS3Client struct {
	node  Node
	pools []int
}

func (l *localPeerS3Client) GetHost() string {
	return l.node.Host
}

func (l *localPeerS3Client) SetPools(p []int) {
	l.pools = make([]int, len(p))
	copy(l.pools, p)
}

func (l localPeerS3Client) GetPools() []int {
	return l.pools
}

	setDriveCount uint64
}

// buildDisksLayoutFromConfFile supports with and without ellipses transparently.
func buildDisksLayoutFromConfFile(pools []poolArgs) (layout disksLayout, err error) {
	if len(pools) == 0 {
		return layout, errInvalidArgument
	}

	for _, list := range pools {
		var endpointsList endpointsList

		for _, arg := range list.args {
			switch {
			case ellipses.HasList(arg):

	if err != nil {
		return err
	}
	setDriveCount := uint64(v)

	var pools []poolArgs
	switch cv.Version {
	case "v1":
		cfV1 := config.ServerConfigV1{}
		if err = yaml.Unmarshal(rd, &cfV1); err != nil {
			return err
		}

		pools = make([]poolArgs, 0, len(cfV1.Pools))
		for _, list := range cfV1.Pools {
			pools = append(pools, poolArgs{
				args:          list,
				setDriveCount: setDriveCount,
			})

	if peer == "" {
		return nil
	}

	var pools []int
	for _, ep := range l {
		for _, endpoint := range ep.Endpoints {
			if endpoint.IsLocal {
				continue
			}

			if !slices.Contains(pools, endpoint.PoolIdx) {
				pools = append(pools, endpoint.PoolIdx)
			}
		}
	}

	return pools
}

			// Pool operations
			adminRouter.Methods(http.MethodGet).Path(adminVersion + "/pools/list").HandlerFunc(adminMiddleware(adminAPI.ListPools, traceAllFlag))
			adminRouter.Methods(http.MethodGet).Path(adminVersion+"/pools/status").HandlerFunc(adminMiddleware(adminAPI.StatusPool, traceAllFlag)).Queries("pool", "{pool:.*}")

			err := mergeDisksLayoutFromArgs(testCase.args, &srvCtxt)
			if err != nil && testCase.expectedErr == nil {
				t.Errorf("Test %d: unexpected error: %v", i+1, err)
			}
			pools, setupType, err := CreatePoolEndpoints(testCase.serverAddr, srvCtxt.Layout.pools...)
			if err == nil && testCase.expectedErr != nil {
				t.Errorf("Test %d: expected = %v, got = <nil>", i+1, testCase.expectedErr)
			}
			if err == nil {