ENOTCONN        Errno = 107 /* Socket is not connected */
	ESHUTDOWN       Errno = 108 /* Can't send after socket shutdown */
	ETOOMANYREFS    Errno = 109
	ETIMEDOUT       Errno = 110 /* Connection timed out */
	ECONNREFUSED    Errno = 111 /* Connection refused */
	EHOSTDOWN       Errno = 112 /* Host is down */
	EHOSTUNREACH    Errno = 113 /* Host is unreachable */
	EALREADY        Errno = 114 /* Socket already connected */

            }
            try {
                if (!p.destroyForcibly().waitFor(timeout, TimeUnit.MILLISECONDS)) {
                    logger.warn("Terminating process {} is timed out.", p);
                } else if (logger.isDebugEnabled()) {
                    logger.debug("Terminated process {}.", p);
                }
            } catch (final Exception e) {

          .url(server!!.url("/"))
          .build(),
      )
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isIn("timeout", "Read timed out")
    }
    assertThat(listener.recordedEventTypes()).containsExactly(
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "NoNewExchanges",
      "ConnectionReleased",

func (c *connection) RemoveStreams(streams ...httpstream.Stream) {
	c.streamLock.Lock()
	for _, stream := range streams {
		// It may be possible that the provided stream is nil if timed out.
		if stream != nil {
			delete(c.streams, stream.Identifier())
		}
	}
	c.streamLock.Unlock()
}

// CreateStream creates a new stream with the specified headers and registers

  @GwtIncompatible
  @ParametricNullness
  static <T extends @Nullable Object> T invokeAnyImpl(
      ListeningExecutorService executorService,
      Collection<? extends Callable<T>> tasks,
      boolean timed,
      long timeout,
      TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    checkNotNull(executorService);
    checkNotNull(unit);
    int ntasks = tasks.size();

                                log.debug("Transport still in use, no idle timeout " + this);
                            }
                            // notify, so that callers with timed-out requests can handle them
                            for ( Response response : this.response_map.values() ) {
                                synchronized ( response ) {
                                    response.notifyAll();

	if errno != 0 {
		if errno != _EINTR {
			println("errno=", errno, " len(pollsubs)=", len(pollsubs))
			throw("poll_oneoff failed")
		}
		// If a timed sleep was interrupted, just return to
		// recalculate how long we should sleep now.
		if delay > 0 {
			unlock(&mtx)
			return gList{}, 0
		}
		goto retry
	}

	var toRun gList
	delta := int32(0)

      } else {
        try {
          ScheduledFuture<?> timer = timeoutFuture.timer;
          timeoutFuture.timer = null; // Don't include already elapsed delay in delegate.toString()
          String message = "Timed out";
          // This try-finally block ensures that we complete the timeout future, even if attempting
          // to produce the message throws (probably StackOverflowError from delegate.toString())
          try {

	ESTALE - APPLICATION_ERROR:          "stale NFS file handle",
	ESTRPIPE - APPLICATION_ERROR:        "streams pipe error",
	ETIME - APPLICATION_ERROR:           "timer expired",
	ETIMEDOUT - APPLICATION_ERROR:       "connection timed out",
	ETOOMANYREFS - APPLICATION_ERROR:    "too many references: cannot splice",
	ETXTBSY - APPLICATION_ERROR:         "text file busy",
	EUCLEAN - APPLICATION_ERROR:         "structure needs cleaning",

	klog.Infof("Starting OpenAPI V3 controller")

	c.openAPIV3Service = openAPIV3Service

	if !cache.WaitForCacheSync(stopCh, c.crdsSynced) {
		utilruntime.HandleError(fmt.Errorf("timed out waiting for caches to sync"))
		return
	}

	crds, err := c.crdLister.List(labels.Everything())
	if err != nil {
		utilruntime.HandleError(fmt.Errorf("failed to initially list all CRDs: %v", err))
		return