boolean isRunning();

  /** Returns the lifecycle state of the service. */
  State state();

  /**
   * If the service is {@linkplain State#STARTING starting} or {@linkplain State#RUNNING running},
   * this initiates service shutdown and returns immediately. If the service is {@linkplain
   * State#NEW new}, it is {@linkplain State#TERMINATED terminated} without having been started nor

              + this
              + " to reach a terminal state. "
              + "Current state: "
              + state());
    }
  }

  /** Checks that the current state is equal to the expected state. */
  @GuardedBy("monitor")
  private void checkCurrentState(State expected) {
    State actual = state();
    if (actual != expected) {
      if (actual == FAILED) {

      }
    }

    @Override
    public void stopping(State from) {
      ServiceManagerState state = this.state.get();
      if (state != null) {
        state.transitionService(service, from, STOPPING);
      }
    }

    @Override
    public void terminated(State from) {
      ServiceManagerState state = this.state.get();
      if (state != null) {
        if (!(service instanceof NoOpService)) {

    state = STATE_WRITING_REQUEST_BODY
    return ChunkedSink()
  }

  private fun newKnownLengthSink(): Sink {
    check(state == STATE_OPEN_REQUEST_BODY) { "state: $state" }
    state = STATE_WRITING_REQUEST_BODY
    return KnownLengthSink()
  }

  private fun newFixedLengthSource(
    url: HttpUrl,
    length: Long,
  ): Source {
    check(state == STATE_OPEN_RESPONSE_BODY) { "state: $state" }

        // Utility class
    }

    /**
     * Check if state has read caching
     * @param state lease state
     * @return true if read caching is enabled
     */
    public static boolean hasReadCaching(int state) {
        return (state & SMB2_LEASE_READ_CACHING) != 0;
    }

    /**
     * Check if state has handle caching
     * @param state lease state
     * @return true if handle caching is enabled
     */

    }

    /**
     * Get current channel state
     *
     * @return channel state
     */
    public ChannelState getState() {
        return state;
    }

    /**
     * Set channel state
     *
     * @param state new state
     */
    public void setState(ChannelState state) {
        this.state = state;
    }

    /**

            // NOTE: Implementation behavior - custom predicate may not prevent all state changes
            // Skipping assertions that assume non-critical errors don't affect circuit state
            // as the actual implementation may handle this differently

            // Reset to ensure clean state for critical error test
            if (customCb.getState() != State.CLOSED) {
                customCb.reset();
            }

    * Introduce Alpha field `AllowWatchBookmarks` in ListOptions for requesting watch bookmarks from apiserver. The implementation in apiserver is hidden behind feature gate `WatchBookmark` (currently in Alpha stage).
* Override protocol between etcd server and kube-apiserver on master with HTTPS instead HTTP when mTLS is enabled in GCE ([#74690](https://github.com/kubernetes/kubernetes/pull/74690), [@wenjiaswe](https://github.com/wenjiaswe))

    checkState(state != State.FAILED);
    switch (state) {
      case DONE:
        return false;
      case READY:
        return true;
      default:
    }
    return tryToComputeNext();
  }

  private boolean tryToComputeNext() {
    state = State.FAILED; // temporary pessimism
    next = computeNext();
    if (state != State.DONE) {
      state = State.READY;
      return true;
    }

        AggregateFutureState<?> state, @Nullable Set<Throwable> expect, Set<Throwable> update) {
      synchronized (state) {
        if (state.seenExceptionsField == expect) {
          state.seenExceptionsField = update;
        }
      }
    }

    @Override
    int decrementAndGetRemainingCount(AggregateFutureState<?> state) {
      synchronized (state) {
        return --state.remainingField;
      }