public interface ConnectionAcceptor extends AsyncStoppable {
    Address getAddress();

    /**
     * Stops accepting incoming connections.
     */
    @Override
    void requestStop();

    /**
     * Stops accepting incoming connections and blocks until the accept action has completed executing for any queued connections.
     */
    @Override
    void stop();

@ServiceScope(Scope.Global.class)
public interface IncomingConnector {
    /**
     * Starts listening for incoming connections. Assigns an arbitrary address for the endpoint.
     *
     * @param action the action to execute on incoming connection. The supplied action is not required to be thread-safe.
     * @param allowRemote If true, only allow connections from remote machines. If false, allow only from the local machine.

						break graceful_loop
					}
					log.Warnf("Retrying (%d attempt) to obtain active connections...", retryCount)
					continue graceful_loop
				}
				if ac == -1 {
					log.Info("downstream_cx_active are not available. This either means there are no downstream connection established yet" +
						" or the stats are not enabled. Skipping active connections check...")
					a.abortCh <- errAbort
					break graceful_loop
				}

            return;
        }

        try {
            // Close expired connections
            clientConnectionManager.closeExpiredConnections();
            // Close idle connections
            clientConnectionManager.closeIdleConnections(idleConnectionTimeout, TimeUnit.MILLISECONDS);
        } catch (final Exception e) {
            logger.warn("A connection monitoring exception occurs.", e);
        }
    }

          |||
        ),
      ],

      xdsConnections: [
        self.query(
          'Connections (client reported)',
          |||
            sum(envoy_cluster_upstream_cx_active{cluster_name="xds-grpc"})
          |||
        ),
        self.query(
          'Connections (server reported)',
          |||
            sum(pilot_xds{})
          |||
        ),
      ],

						t.Logf("UNKNOWN state for %v", result)
					default:
					}
				}
			}()
			wg.Wait()

			// log the number of connections received in each pod for debugging test failures.
			for _, pod := range fakePods {
				n := pod.connections()
				t.Logf("Number of connections %d", n)
			}

		})
	}

}

func newProbe(handler v1.ProbeHandler) *v1.Probe {
	return &v1.Probe{

        def connection = new TestConnection()

        given:
        connectCompletion.create(_) >> connection

        when:
        connectionBuilder.connect()
        connectionBuilder.addOutgoing(Worker)

        then:
        def e = thrown(GradleException)
        e.message == "Cannot add outgoing message transmitter after connection established."

        cleanup:
        connection?.stop()

	// DefaultShutdownTimeout - default shutdown timeout to gracefully shutdown server.
	DefaultShutdownTimeout = 5 * time.Second

	// DefaultIdleTimeout for idle inactive connections
	DefaultIdleTimeout = 30 * time.Second

	// DefaultReadHeaderTimeout for very slow inactive connections
	DefaultReadHeaderTimeout = 30 * time.Second

	// DefaultMaxHeaderBytes - default maximum HTTP header size in bytes.
	DefaultMaxHeaderBytes = 1 * humanize.MiByte
)

		name     string
		stats    string
		expected int
	}{
		{
			"invalid stats",
			invalidStats,
			-1,
		},
		{
			"valid active connections",
			downstreamCxPostiveAcStats,
			19,
		},
		{
			"zero active connections",
			downstreamCxZeroAcStats,
			0,
		},
	}

	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {

import okhttp3.internal.toImmutableList

/**
 * A specification for a connection to an origin server. For simple connections, this is the
 * server's hostname and port. If an explicit proxy is requested (or [no proxy][Proxy.NO_PROXY] is
 * explicitly requested), this also includes that proxy information. For secure connections the
 * address also includes the SSL socket factory, hostname verifier, and certificate pinner.
 *