val connectionClose = CountDownLatch(1)
    val streams =
      object : RealWebSocket.Streams(false, source, sink) {
        override fun close() = connectionClose.countDown()

        override fun cancel() {
          socket.closeQuietly()
        }
      }
    val webSocket =
      RealWebSocket(
        taskRunner = taskRunner,
        originalRequest = fancyRequest,

    try {
      future.get(timeoutMillis, MILLISECONDS);
      shouldThrow();
    } catch (TimeoutException success) {
    } catch (Exception e) {
      threadUnexpectedException(e);
    } finally {
      future.cancel(true);
    }
    assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
  }

  /** Fails with message "should throw exception". */
  public void shouldThrow() {
    fail("Should throw exception");
  }

		w.WriteHeader(http.StatusNotFound)
	case errInvalidAccessKeyID, errAccessKeyDisabled, errNoAuthToken, errMalformedAuth, errAuthentication, errSkewedAuthTime:
		w.WriteHeader(http.StatusUnauthorized)
	case context.Canceled, context.DeadlineExceeded:
		w.WriteHeader(499)
	default:
		w.WriteHeader(http.StatusForbidden)
	}
	w.Write([]byte(err.Error()))
}

// DefaultSkewTime - skew time is 15 minutes between minio peers.

	return MetricDescription{
		Namespace: s3MetricNamespace,
		Subsystem: requestsSubsystem,
		Name:      canceledTotal,
		Help:      "Total number of S3 requests that were canceled by the client",
		Type:      counterMetric,
	}
}

func getS3RejectedAuthRequestsTotalMD() MetricDescription {
	return MetricDescription{
		Namespace: s3MetricNamespace,

TF_CAPI_EXPORT extern void TFE_DeleteCancellationManager(
    TFE_CancellationManager*);

// Associates the given `cancellation_manager` with `op`, so that invoking
// `TFE_CancellationManagerStartCancel(cancellation_manager)` will cancel the
// execution of `op`.
typedef struct TFE_CancellationManager TFE_CancellationManager;
TF_CAPI_EXPORT extern void TFE_OpSetCancellationManager(
    TFE_Op* op, TFE_CancellationManager* cancellation_manager,

    try {
      future.get(timeoutMillis, MILLISECONDS);
      shouldThrow();
    } catch (TimeoutException success) {
    } catch (Exception e) {
      threadUnexpectedException(e);
    } finally {
      future.cancel(true);
    }
    assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
  }

  /** Fails with message "should throw exception". */
  public void shouldThrow() {
    fail("Should throw exception");
  }

		} else {
			t.Log("ok")
		}
	}
	result := string(buf[0:n])
	if result != "hello" {
		t.Errorf("got: %q; want: %q", result, "hello")
	}
}

func timeout(after time.Duration) (cancel func()) {
	c := time.After(after)
	cc := make(chan struct{})
	go func() {
		select {
		case <-cc:
			return
		case <-c:
			buf := make([]byte, 1<<20)
			stacklen := runtime.Stack(buf, true)

	}
	store.runlock()

	if len(missingPolicies) > 0 {
		m := make(map[string]PolicyDoc)
		for _, policy := range missingPolicies {
			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
			_ = store.loadPolicyDoc(ctx, policy, m)
			cancel()
		}

		cache := store.lock()
		for policy, p := range m {
			cache.iamPolicyDocsMap[policy] = p
		}
		store.unlock()

		Healing:          false,
	}

	mrfCheck := make(chan FileInfo)
	defer xioutil.SafeClose(mrfCheck)

	var rw sync.Mutex

	// Ask for all disks first;
	go func() {
		ctx, cancel := context.WithCancel(ctx)
		defer cancel()

		wg := sync.WaitGroup{}
		for i, disk := range disks {
			if disk == nil {
				done <- false
				continue
			}
			if !disk.IsOnline() {
				done <- false
				continue

- Ignore context canceled from validate and mutate webhook ([#120020](https://github.com/kubernetes/kubernetes/pull/120020), [@divyasri537](https://github.com/divyasri537)) [SIG API Machinery]