noNewExchanges = true
              routeFailureCount++
            }
          }

          e.errorCode == ErrorCode.CANCEL && call.isCanceled() -> {
            // Permit any number of CANCEL errors on locally-canceled calls.
          }

          else -> {
            // Everything else wants a fresh connection.
            noNewExchangesEvent = !noNewExchanges

  fun noNewExchangesOnConnection() {
    codec.carrier.noNewExchanges()
  }

  fun cancel() {
    codec.cancel()
  }

  /**
   * Revoke this exchange's access to streams. This is necessary when a follow-up request is
   * required but the preceding exchange hasn't completed yet.
   */
  fun detachWithViolence() {
    codec.cancel()
    call.messageDone(
      exchange = this,
      requestDone = true,

  NO_ERROR(0),

  PROTOCOL_ERROR(1),

  INTERNAL_ERROR(2),

  FLOW_CONTROL_ERROR(3),

  SETTINGS_TIMEOUT(4),

  STREAM_CLOSED(5),

  FRAME_SIZE_ERROR(6),

  REFUSED_STREAM(7),

  CANCEL(8),

  COMPRESSION_ERROR(9),

  CONNECT_ERROR(0xa),

  ENHANCE_YOUR_CALM(0xb),

  INADEQUATE_SECURITY(0xc),

  HTTP_1_1_REQUIRED(0xd),
  ;

  companion object {

            - elastic
          allow-whitelist-orgs-as-admins: true
          trigger-phrase: '.*run\W+elasticsearch-ci/full-bwc.*'
          github-hooks: true
          status-context: elasticsearch-ci/full-bwc
          cancel-builds-on-update: true
          excluded-regions:
            - ^docs/.*
          white-list-labels:
            - 'test-full-bwc'
          black-list-labels:
            - '>test-mute'
    axes:
      - axis:

    }

    /**
     * Cancel notification for a handle
     *
     * @param handle notification handle
     */
    private void cancelNotification(ChangeNotificationHandle handle) {
        CompletableFuture<Void> future = handle.getNotificationFuture();
        if (future != null && !future.isDone()) {
            future.cancel(true);
        }
    }

          allow-whitelist-orgs-as-admins: true
          trigger-phrase: '.*run\W+elasticsearch-ci/part-2-windows.*'
          github-hooks: true
          status-context: elasticsearch-ci/part-2-windows
          cancel-builds-on-update: true
          black-list-target-branches:
            - 6.8
          excluded-regions:
            - ^docs/.*
          white-list-labels:
            - 'test-windows'
          black-list-labels:

	if dc, ok := c.(*DeadlineConn); ok {
		return dc.Conn
	}
	return c
}

// Sets read deadline
func (c *DeadlineConn) setReadDeadline() {
	// Do not set a Read deadline, if upstream wants to cancel all reads.
	if c.readDeadline <= 0 || c.abortReads.Load() || c.infReads.Load() {
		return
	}

	c.mu.Lock()
	defer c.mu.Unlock()
	if c.abortReads.Load() {
		return
	}

	now := time.Now()

          allow-whitelist-orgs-as-admins: true
          trigger-phrase: '.*run\W+elasticsearch-ci/eql-correctness.*'
          github-hooks: true
          status-context: elasticsearch-ci/eql-correctness
          cancel-builds-on-update: true
          black-list-target-branches:
            - 6.8
          excluded-regions:
            - ^docs/.*
          black-list-labels:
            - '>test-mute'
    builders:

	if _, ok := tx.ConnPool.(*gorm.PreparedStmtDB); !ok {
		t.Fatalf("should assign PreparedStatement Manager back to database when using PrepareStmt mode")
	}

	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()
	txCtx := tx.WithContext(ctx)

	user := *GetUser("prepared_stmt", Config{})

	txCtx.Create(&user)

	var result1 User

   */
  fun cancel()

  fun interface Factory {
    /**
     * Creates a new web socket and immediately returns it. Creating a web socket initiates an
     * asynchronous process to connect the socket. Once that succeeds or fails, `listener` will be
     * notified. The caller must either close or cancel the returned web socket when it is no longer
     * in use.