adsClients.Total = len(connections)

	for _, c := range connections {
		adsClient := AdsClient{
			ConnectionID: c.ID(),
			ConnectedAt:  c.ConnectedAt(),
			PeerAddress:  c.Peer(),
		}
		adsClients.Connected = append(adsClients.Connected, adsClient)
	}
	writeJSON(w, adsClients, req)
}

// adsz implements a status and debug interface for ADS.
// It is mapped to /debug/adsz

    }

    def "cannot create new project connection after disconnect"() {
        setup:
        def connector = toolingApi.connector()
        withConnection(connector) { connection ->
            connection.getModel(EclipseProject)
        }
        connector.disconnect()

        when:
        connector.connect()

        then:
        def e = thrown(RuntimeException)

  Graph<N> asGraph();

  //
  // Network properties
  //

  /**
   * Returns true if the edges in this network are directed. Directed edges connect a {@link
   * EndpointPair#source() source node} to a {@link EndpointPair#target() target node}, while
   * undirected edges connect a pair of nodes to each other.
   */
  boolean isDirected();

  /**

    }

    def <T> T withConnection(@DelegatesTo(ProjectConnection) Closure<T> cl) {
        def connector = connector()
        withConnection(connector, cl)
    }

    def <T> T withConnection(connector, @DelegatesTo(ProjectConnection) Closure<T> cl) {
        return withConnectionRaw(connector, cl)
    }

   * same value those two ranges will be coalesced.
   *
   * <p><b>Note:</b> coalescing requires calling {@code .equals()} on any connected values, which
   * may be expensive depending on the value type. Using this method on range maps with large values
   * such as {@link Collection} types is discouraged.
   *
   * @since 22.0
   */
  void putCoalescing(Range<K> range, V value);

        def port = connector.port
        server.removeConnector(connector)
        connector.stop()
        portAllocator.releasePort(port)
    }

    private boolean createConnector() {
        def assignedPort = portAllocator.assignPort()
        connector = new ServerConnector(server)
        connector.port = assignedPort
        server.addConnector(connector)
        try {

        expect:
        def connection = connector.connect({it.pid != 0} as DummyExplainingSpec)
        connection == null

        and:
        numAllDaemons == 1
    }

    def "suspect address is removed from the registry on connect failure"() {
        given:
        startIdleDaemon()
        assert !registry.all.empty

        def connector = connector()
        connector.forProjectDirectory(rootDir.absoluteFile)
        connector.searchUpwards(searchUpwards)
        def model = withConnection(connector) { it.getModel(modelType) }
        return toGradleProject(model)
    }

    private <T> T getModelWithProjectConnection(TestFile rootDir, Class<T> modelType) {
        def connector = connector()

     *
     * @param question The text of the question.
     * @param defaultValue The option to present to the user as the default choice, and the value to use when not connected to a console
     * @return the answer or the given default if not connected to a console.
     */
    boolean askBooleanQuestion(String question, boolean defaultValue);

    /**

    assertEvents(
      "plan 1 TCP connected",
      "plan 0 cancel",
      "plan 1 TLS connecting...",
      "plan 1 TLS connect failed",
      "plan 2 TCP connecting...",
      "plan 2 TCP connected",
      "plan 2 TLS connecting...",
      "plan 2 TLS connected",
    )

    taskFaker.advanceUntil(270.ms)
    assertEvents(
      "plan 0 TCP connect canceled",
    )