Method Close

internal/pool/pool.go:1655–1712

()

}

func (p *ConnPool) Close() error {
	if !atomic.CompareAndSwapUint32(&p._closed, 0, 1) {
		return ErrClosed
	}

	var firstErr error
	nowNs := time.Now().UnixNano()
	p.connsMu.Lock()

	// Emit -1 for each connection. Since all idle↔used transitions happen
	// under connsMu, the idleConns slice is the source of truth for state.
	cb := getMetricConnectionCountCallback()
	idleSet := make(map[uint64]struct{}, len(p.idleConns))
	for _, cn := range p.idleConns {
		idleSet[cn.GetID()] = struct{}{}
	}
	ctx := context.Background()
	for _, cn := range p.conns {
		// Check health before closing, since closeConn invalidates the
		// underlying fd and would make connCheck (inside isHealthyConn)
		// always fail with EBADF.
		// Only check health for idle connections to avoid data races when
		// peeking at the socket/reader while another goroutine is reading from it.
		// Non-idle connections are either in use or in transitional states and
		// shouldn't be health-checked during shutdown.
		_, isIdle := idleSet[cn.GetID()]
		var healthy bool
		if isIdle {
			healthy = p.isHealthyConn(cn, nowNs)
		} else {
			healthy = true
		}
		if cb != nil {
			if isIdle {
				cb(ctx, -1, cn, "idle", false)
			} else {
				cb(ctx, -1, cn, "used", false)
			}
		}
		if closedCb := getMetricConnectionClosedCallback(); closedCb != nil {
			closedCb(ctx, cn, "pool_shutdown", nil)
		}
		if err := p.closeConn(cn); err != nil && firstErr == nil {
			// Suppress close errors for stale connections, consistent
			// with how Get() handles them (see CloseReasonStale path).
			if healthy {
				firstErr = err
			}
		}
	}
	p.conns = nil
	p.poolSize.Store(0)
	p.idleConns = nil
	p.idleConnsLen.Store(0)
	p.connsMu.Unlock()

	return firstErr
}