"net/http"
	"sync"
	"time"

	"github.com/moby/spdystream"
	"k8s.io/apimachinery/pkg/util/httpstream"
	"k8s.io/klog/v2"
)

// connection maintains state about a spdystream.Connection and its associated
// streams.
type connection struct {
	conn             *spdystream.Connection
	streams          map[uint32]httpstream.Stream
	streamLock       sync.Mutex
	newStreamHandler httpstream.NewStreamHandler

}

func (c *connection) Name() string {
	return c.helper.Name()
}

func (c *connection) TotalRequests() uint64 {
	return c.helper.TotalRequests()
}

func (c *connection) ActiveRequests() uint64 {
	return c.helper.ActiveRequests()
}

func (c *connection) Latency() *timeseries.Instance {
	return c.helper.Latency()
}

func (c *connection) Request(onDone func()) {
	c.helper.Request(c.request, onDone)

 * <li>should allow stopping or requesting stopping from a different thread than receiving/dispatching</li>
 * <li>don't guarantee allowing multiple threads dispatching</li>
 * </ul>
 */
public interface Connection<T> extends Dispatch<T>, Receive<T>, Stoppable {

)

// Config represents the configuration for setting up an opentelemetry
// collector.
type Config struct {
	// Cluster to be used in a multicluster environment
	Cluster cluster.Cluster

	// HTTP Address of ingress gateway of the cluster to be used to install open telemetry collector in.
	IngressAddr string
}

// Instance represents a opencensus collector deployment on kubernetes.
type Instance interface {
	resource.Resource
}

User -> DefaultGradleConnector: use distribution/version/URI
DefaultGradleConnector -> DistributionFactory: get distribution
DistributionFactory --> DefaultGradleConnector: Distribution
User -> DefaultGradleConnector: connect()
DefaultGradleConnector -> ConnectionFactory: create()
ConnectionFactory --> DefaultGradleConnector: DefaultProjectConnection
note left
With a chain of ConsumerActionExecutors
and tooling implementation loader
end note

	}

	// Call ConnectEx API.
	if err := fd.pfd.ConnectEx(ra); err != nil {
		select {
		case <-ctx.Done():
			return nil, mapErr(ctx.Err())
		default:
			if _, ok := err.(syscall.Errno); ok {
				err = os.NewSyscallError("connectex", err)
			}
			return nil, err
		}
	}
	// Refresh socket properties.

 */
package okhttp3.internal.connection

/** Reuse a connection from the pool. */
internal class ReusePlan(
  val connection: RealConnection,
) : RoutePlanner.Plan {
  override val isReady = true

  override fun connectTcp() = error("already connected")

  override fun connectTlsEtc() = error("already connected")

  override fun handleSuccess() = connection

        }

        // Wait for an in-flight connect to complete or fail.
        if (connectResult == null) {
          connectResult = awaitTcpConnect(awaitTimeoutNanos, TimeUnit.NANOSECONDS) ?: continue
        }

        if (connectResult.isSuccess) {
          // We have a connected TCP connection. Cancel and defer the racing connects that all lost.
          cancelInFlightConnects()

        }
    }

    /* Build a connection. Only one thread will ever call this method at
     * any one time. If this method throws an exception or the connect timeout
     * expires an encapsulating TransportException will be thrown from connect
     * and the transport will be in error.
     */

    protected abstract void doConnect() throws Exception;

    /* Tear down a connection. If the hard parameter is true, the diconnection

	EALREADY:        "Socket already connected",
	EBADF:           "Bad file number",
	EBADMSG:         "Trying to read unreadable message",
	EBUSY:           "Device or resource busy",
	ECANCELED:       "Operation canceled.",
	ECHILD:          "No child processes",
	ECONNABORTED:    "Connection aborted",
	ECONNREFUSED:    "Connection refused",
	ECONNRESET:      "Connection reset by peer",