for i, pool := range z.serverPools {
		pool := pool
		eg.Go(func() error {
			dObjectsByPool[i], dErrsByPool[i] = pool.DeleteObjects(ctx, bucket, objects, opts)
			return nil
		}, i)
	}
	eg.Wait() // wait to check all the pools.

	for i := range dobjects {
		// Iterate over pools
		for pool := range z.serverPools {

	for i, pool := range nmeta2.Pools {
		if i == 0 {
			nmeta2.Pools[i] = PoolStatus{
				CmdLine:    pool.CmdLine,
				ID:         i,
				LastUpdate: UTCNow(),
				Decommission: &PoolDecommissionInfo{
					Complete: false,
				},
			}
		}
	}

	testCases := []struct {
		meta           poolMeta
		pools          []*erasureSets
		expectedUpdate bool
		expectedErr    bool

	// Use ID as the object name...
	o.pool = z.getAvailablePoolIdx(ctx, minioMetaBucket, o.ID, 10<<20)
	if o.pool < 0 {
		// No space or similar, don't persist the listing.
		o.pool = 0
		o.Create = false
		o.ID = ""
		o.Transient = true
		return entries, errDiskFull
	}
	o.set = z.serverPools[o.pool].getHashedSetIndex(o.ID)
	saver := z.serverPools[o.pool].sets[o.set]

	for idx, pool := range pools {
		specifiedPools[pool.endpoints.CmdLine] = idx
	}

	var update bool
	// Check if specified pools need to be removed from decommissioned pool.
	for k := range specifiedPools {
		pi, ok := rememberedPools[k]
		if !ok {
			// we do not have the pool anymore that we previously remembered, since all
			// the CLI checks out we can allow updates since we are mostly adding a pool here.
			update = true
		}

)

//go:generate msgp -file $GOFILE -unexported

// rebalanceStats contains per-pool rebalance statistics like number of objects,
// versions and bytes rebalanced out of a pool
type rebalanceStats struct {
	InitFreeSpace uint64 `json:"initFreeSpace" msg:"ifs"` // Pool free space at the start of rebalance
	InitCapacity  uint64 `json:"initCapacity" msg:"ic"`   // Pool capacity at the start of rebalance

		return
	}

	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

	if err != nil {
		log.Fatalln(err)
	}

	zipFile, err := os.Create("format.json.zip")
	if err != nil {
		log.Fatalf("failed to create format.json.zip: %v", err)
	}
	defer zipFile.Close()
	fmtZipW := zip.NewWriter(zipFile)
	defer fmtZipW.Close()
	for _, pool := range pools { // for each pool
		setCount, setDriveCount := pool.SetCount, pool.DrivesPerSet

        assertTrue(pool.contains(transport), "Transport should be in pool initially");

        // When: Remove the transport
        pool.removeTransport(transport);

        // Then: Transport should no longer be in pool
        assertFalse(pool.contains(transport), "Transport should be removed from pool");
    }

    @Test

        this.totalAllocated = new AtomicLong();
        this.totalReleased = new AtomicLong();

        // Pre-allocate buffer pool
        initializeBufferPool();
    }

    /**
     * Initialize the buffer pool with pre-allocated regions
     */
    private void initializeBufferPool() {
        // Allocate send buffers
        for (int i = 0; i < initialSendBuffers; i++) {

    // Running at time 75, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(75L)).isEqualTo(75L)
    assertThat(pool.connectionCount()).isEqualTo(2)

    // Running at time 149, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(149L)).isEqualTo(1L)
    assertThat(pool.connectionCount()).isEqualTo(2)