Examples with State org.apache.kafka.streams.processor.internals.GlobalStreamThread.State used on opensource projects

Example 1 with State

use of org.apache.kafka.streams.processor.internals.GlobalStreamThread.State in project kafka by apache.

the class KafkaStreams method query.

/**
 * Run an interactive query against a state store.
 * <p>
 * This method allows callers outside of the Streams runtime to access the internal state of
 * stateful processors. See https://kafka.apache.org/documentation/streams/developer-guide/interactive-queries.html
 * for more information.
 *
 * @param <R> The result type specified by the query.
 * @throws StreamsNotStartedException If Streams has not yet been started. Just call {@link
 *                                    KafkaStreams#start()} and then retry this call.
 * @throws StreamsStoppedException    If Streams is in a terminal state like PENDING_SHUTDOWN,
 *                                    NOT_RUNNING, PENDING_ERROR, or ERROR. The caller should
 *                                    discover a new instance to query.
 * @throws UnknownStateStoreException If the specified store name does not exist in the
 *                                    topology.
 */
@Evolving
public <R> StateQueryResult<R> query(final StateQueryRequest<R> request) {
    final String storeName = request.getStoreName();
    if (!topologyMetadata.hasStore(storeName)) {
        throw new UnknownStateStoreException("Cannot get state store " + storeName + " because no such store is registered in the topology.");
    }
    if (state().hasNotStarted()) {
        throw new StreamsNotStartedException("KafkaStreams has not been started, you can retry after calling start().");
    }
    if (state().isShuttingDown() || state.hasCompletedShutdown()) {
        throw new StreamsStoppedException("KafkaStreams has been stopped (" + state + ")." + " This instance can no longer serve queries.");
    }
    final StateQueryResult<R> result = new StateQueryResult<>();
    final Map<String, StateStore> globalStateStores = topologyMetadata.globalStateStores();
    if (globalStateStores.containsKey(storeName)) {
        // See KAFKA-13523
        result.setGlobalResult(QueryResult.forFailure(FailureReason.UNKNOWN_QUERY_TYPE, "Global stores do not yet support the KafkaStreams#query API. Use KafkaStreams#store instead."));
    } else {
        for (final StreamThread thread : threads) {
            final Map<TaskId, Task> tasks = thread.allTasks();
            for (final Entry<TaskId, Task> entry : tasks.entrySet()) {
                final TaskId taskId = entry.getKey();
                final int partition = taskId.partition();
                if (request.isAllPartitions() || request.getPartitions().contains(partition)) {
                    final Task task = entry.getValue();
                    final StateStore store = task.getStore(storeName);
                    if (store != null) {
                        final StreamThread.State state = thread.state();
                        final boolean active = task.isActive();
                        if (request.isRequireActive() && (state != StreamThread.State.RUNNING || !active)) {
                            result.addResult(partition, QueryResult.forFailure(FailureReason.NOT_ACTIVE, "Query requires a running active task," + " but partition was in state " + state + " and was " + (active ? "active" : "not active") + "."));
                        } else {
                            final QueryResult<R> r = store.query(request.getQuery(), request.isRequireActive() ? PositionBound.unbounded() : request.getPositionBound(), new QueryConfig(request.executionInfoEnabled()));
                            result.addResult(partition, r);
                        }
                        // we can return right away.
                        if (!request.isAllPartitions() && result.getPartitionResults().keySet().containsAll(request.getPartitions())) {
                            return result;
                        }
                    }
                }
            }
        }
    }
    if (!request.isAllPartitions()) {
        for (final Integer partition : request.getPartitions()) {
            if (!result.getPartitionResults().containsKey(partition)) {
                result.addResult(partition, QueryResult.forFailure(FailureReason.NOT_PRESENT, "The requested partition was not present at the time of the query."));
            }
        }
    }
    return result;
}

Example 2 with State

use of org.apache.kafka.streams.processor.internals.GlobalStreamThread.State in project kafka by apache.

the class KafkaStreams method setState.

/**
 * Sets the state
 * @param newState New state
 */
private boolean setState(final State newState) {
    final State oldState;
    synchronized (stateLock) {
        oldState = state;
        if (state == State.PENDING_SHUTDOWN && newState != State.NOT_RUNNING) {
            // refused but we do not throw exception here, to allow appropriate error handling
            return false;
        } else if (state == State.NOT_RUNNING && (newState == State.PENDING_SHUTDOWN || newState == State.NOT_RUNNING)) {
            // will be refused but we do not throw exception here, to allow idempotent close calls
            return false;
        } else if (state == State.REBALANCING && newState == State.REBALANCING) {
            // when the state is already in REBALANCING, it should not transit to REBALANCING again
            return false;
        } else if (state == State.ERROR && (newState == State.PENDING_ERROR || newState == State.ERROR)) {
            // when the state is already in ERROR, its transition to PENDING_ERROR or ERROR (due to consecutive close calls)
            return false;
        } else if (state == State.PENDING_ERROR && newState != State.ERROR) {
            // refused but we do not throw exception here, to allow appropriate error handling
            return false;
        } else if (!state.isValidTransition(newState)) {
            throw new IllegalStateException("Stream-client " + clientId + ": Unexpected state transition from " + oldState + " to " + newState);
        } else {
            log.info("State transition from {} to {}", oldState, newState);
        }
        state = newState;
        stateLock.notifyAll();
    }
    // we need to call the user customized state listener outside the state lock to avoid potential deadlocks
    if (stateListener != null) {
        stateListener.onChange(newState, oldState);
    }
    return true;
}