| `minio_cluster_erasure_set_online_drives_count`  | `gauge` | Count of online drives in the erasure set in a pool           | `pool_id,set_id` |
| `minio_cluster_erasure_set_healing_drives_count` | `gauge` | Count of healing drives in the erasure set in a pool          | `pool_id,set_id` |

}

// Close - releases the resources used by the pool.
func (target *RedisTarget) Close() error {
	close(target.quitCh)
	if target.pool != nil {
		return target.pool.Close()
	}
	return nil
}

func (target *RedisTarget) init() error {
	return target.initOnce.Do(target.initRedis)
}

func (target *RedisTarget) initRedis() error {
	conn := target.pool.Get()
	defer conn.Close()

`v1` format
```yaml
pools: # Specify the nodes and drives with pools
  -
    - "https://server-example-pool1:9000/mnt/disk{1...4}/"
    - "https://server{1...2}-pool1:9000/mnt/disk{1...4}/"
    - "https://server3-pool1:9000/mnt/disk{1...4}/"
    - "https://server4-pool1:9000/mnt/disk{1...4}/"
```

to `v2` format

```yaml
pools:
  - args:

		case "StopDiskAtLimit":
			z.StopDiskAtLimit, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "StopDiskAtLimit")
				return
			}
		case "pool":
			z.pool, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "pool")
				return
			}
		case "set":
			z.set, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "set")
				return
			}
		default:

		}
		if !ps.Participating {
			continue
		}
		// for participating pools, total bytes to be rebalanced by this pool is given by,
		// pf_c = (f_i + x)/c_i,
		// pf_c - percentage free space across pools, f_i - ith pool's free space, c_i - ith pool's capacity
		// i.e. x = c_i*pfc -f_i
		totalBytesToRebal := float64(ps.InitCapacity)*meta.PercentFreeGoal - float64(ps.InitFreeSpace)
		elapsed := time.Since(ps.Info.StartTime)

    // 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)

	erasureSetWriteQuorumMD = NewGaugeMD(erasureSetWriteQuorum,
		"Write quorum for the erasure set in a pool", poolIDL, setIDL)
	erasureSetOnlineDrivesCountMD = NewGaugeMD(erasureSetOnlineDrivesCount,
		"Count of online drives in the erasure set in a pool", poolIDL, setIDL)
	erasureSetHealingDrivesCountMD = NewGaugeMD(erasureSetHealingDrivesCount,
		"Count of healing drives in the erasure set in a pool", poolIDL, setIDL)

  var uriPort: Int = 1

  fun newConnection(
    pool: RealConnectionPool,
    route: Route,
    idleAtNanos: Long = Long.MAX_VALUE,
    taskRunner: TaskRunner = this.taskRunner,
  ): RealConnection {
    val result =
      RealConnection.newTestConnection(
        taskRunner = taskRunner,
        connectionPool = pool,
        route = route,
        socket = Socket(),
        idleAtNs = idleAtNanos,

                                pool for the upstream service that can be ejected.
                              format: int32
                              type: integer
                            minHealthPercent:
                              description: Outlier detection will be enabled as long
                                as the associated load balancing pool has at least

	}
	sort.Slice(nodes, func(i, j int) bool {
		return nodes[i].Host < nodes[j].Host
	})
	return
}

// GetPoolIdx return pool index
func (l EndpointServerPools) GetPoolIdx(pool string) int {
	for id, ep := range globalEndpoints {
		if ep.CmdLine != pool {
			continue
		}
		return id
	}
	return -1
}

// GetLocalPoolIdx returns the pool which endpoint belongs to locally.