}

  final NetworkConnections<N, E> checkedConnections(N node) {
    NetworkConnections<N, E> connections = nodeConnections.get(node);
    if (connections == null) {
      checkNotNull(node);
      throw new IllegalArgumentException(String.format(NODE_NOT_IN_GRAPH, node));
    }
    return connections;
  }

  final N checkedReferenceNode(E edge) {
    N referenceNode = edgeToReferenceNode.get(edge);

  /**
   * Request immediate close of connection without even reading the request. Use to simulate buggy
   * SSL servers closing connections in response to unrecognized TLS extensions.
   */
  object DisconnectAtStart : SocketPolicy

  /**
   * Close connection after reading the request but before writing the response. Use this to
   * simulate late connection pool failures.
   */

        0 * _._
    }

    def "close connections when closed"() {
        def connection1 = Mock(ConsumerConnection)
        def connection2 = Mock(ConsumerConnection)
        def distribution1 = Mock(Distribution)
        def distribution2 = Mock(Distribution)

        given:
        target.create(distribution1, loggerFactory, progressListener, params, cancellationToken) >> connection1

	}
	return res, model.DefaultXdsLogDetails, nil
}

// isSidecar ad-hoc method to see if connection represents a sidecar
func isProxy(con *Connection) bool {
	return con != nil &&
		con.proxy != nil &&
		con.proxy.Metadata != nil &&
		con.proxy.Metadata.ProxyConfig != nil
}

func isZtunnel(con *Connection) bool {
	return con != nil &&
		con.proxy != nil &&
		con.proxy.Metadata != nil &&

		5*time.Second,
		"The minimum duration for which agent waits before it checks for active connections and terminates proxy "+
			"when number of active connections become zero").Get()

	exitOnZeroActiveConnectionsEnv = env.Register("EXIT_ON_ZERO_ACTIVE_CONNECTIONS",
		false,
		"When set to true, terminates proxy when number of active connections become zero during draining").Get()

	ValidFrom      string `json:"validFrom"`
	ExpirationTime string `json:"expirationTime"`
}

type WorkloadState struct {
	State       string              `json:"state,omitempty"`
	Connections WorkloadConnections `json:"connections,omitempty"`
	Info        WorkloadInfo        `json:"info"`
}

type WorkloadConnections struct {
	Inbound  []InboundConnection  `json:"inbound"`
	Outbound []OutboundConnection `json:"outbound"`

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Fake network poller for js/wasm.
// Should never be used, because js/wasm network connections do not honor "SetNonblock".

//go:build js && wasm

package runtime

func netpollinit() {
}

func netpollIsPollDescriptor(fd uintptr) bool {
	return false
}

/**
 * A {@code MessagingServer} allows the creation of multiple bi-directional uni-cast connections.
 */
@ServiceScope(Scope.Global.class)
public interface MessagingServer {
    /**
     * Creates an endpoint that peers can connect to. Assigns an arbitrary address.
     *
     * @param action The action to execute when a connection has been established.
     * @return The local address of the endpoint, for the peer to connect to.

		// connections open (i.e. basically degrade them to the
		// performance of http1 with keep-alive disabled).
		if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.UnauthenticatedHTTP2DOSMitigation) && req.ProtoMajor == 2 && isAnonymousUser(resp.User) {
			// limit this connection to just this request,
			// and then send a GOAWAY and tear down the TCP connection

package okhttp3

import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.Socket
import java.net.SocketAddress
import okhttp3.internal.platform.Platform

/**
 * A [SocketFactory] that redirects connections to [defaultAddress] or specific overridden address via [set].
 */
class SpecificHostSocketFactory(
  val defaultAddress: InetSocketAddress?,
) : DelegatingSocketFactory(getDefault()) {