Java Code Examples for org.apache.kafka.streams.KafkaStreams#State

@Produces
@ApplicationScoped
@Current
public AsyncBiFunctionService<Void, Void, KafkaStreams.State> stateService(
    KafkaStreams streams,
    HostInfo storageLocalHost,
    LocalService<AsyncBiFunctionService.WithSerdes<Void, Void, KafkaStreams.State>> localStateService
) {
    return new DistributedAsyncBiFunctionService<>(
        streams,
        storageLocalHost,
        "stateStore",
        localStateService,
        new DefaultGrpcChannelProvider()
    );
}
 

@Override public CheckResult check() {
  try {
    KafkaFuture<String> maybeClusterId = getAdminClient().describeCluster().clusterId();
    maybeClusterId.get(1, TimeUnit.SECONDS);
    KafkaStreams.State state = getAggregationStream().state();
    if (!state.isRunning()) {
      return CheckResult.failed(
          new IllegalStateException("Aggregation stream not running. " + state));
    }
    KafkaStreams.State traceStateStore = getTraceStorageStream().state();
    if (!traceStateStore.isRunning()) {
      return CheckResult.failed(
          new IllegalStateException("Store stream not running. " + traceStateStore));
    }
    KafkaStreams.State dependencyStateStore = getDependencyStorageStream().state();
    if (!dependencyStateStore.isRunning()) {
      return CheckResult.failed(
          new IllegalStateException("Store stream not running. " + dependencyStateStore));
    }
    return CheckResult.OK;
  } catch (Exception e) {
    return CheckResult.failed(e);
  }
}
 

@Produces
@Singleton
public LocalService<AsyncBiFunctionService.WithSerdes<Void, Void, KafkaStreams.State>> localStateService(
    StateService localService
) {
    return new LocalService<>(
        StateService.NAME,
        localService
    );
}
 

@Produces
@Singleton
public AsyncBiFunctionServiceGrpc.AsyncBiFunctionServiceImplBase storageAsyncBiFunctionServiceGrpcImpl(
    LocalService<AsyncBiFunctionService.WithSerdes<String, Long, Str.Data>> localWaitForDataService,
    LocalService<AsyncBiFunctionService.WithSerdes<Void, Void, KafkaStreams.State>> localStateService
) {
    return new AsyncBiFunctionServiceGrpcLocalDispatcher(
        Arrays.asList(localWaitForDataService, localStateService)
    );
}
 

private void startStreams(KafkaStreams kafkaStreams) {
    CountDownLatch streamsStartedLatch = new CountDownLatch(1);

    // wait for consistent state
    kafkaStreams.setStateListener((newState, oldState) -> {
        logger.trace("Kafka Streams state has been changed from {} to {}", oldState, newState);

        if (oldState == KafkaStreams.State.REBALANCING && newState == KafkaStreams.State.RUNNING) {
            streamsStartedLatch.countDown();
        }
    });
    kafkaStreams.cleanUp();
    kafkaStreams.start();
    long timeout = System.currentTimeMillis() + streamsStartupTimeout;

    try {
        streamsStartedLatch.await(timeout - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupted();
    }

    KafkaStreams.State state = kafkaStreams.state();

    if (state != KafkaStreams.State.RUNNING) {
        logger.error("Unable to start Kafka Streams in {} ms, the current state is {}",
                streamsStartupTimeout, state);
        System.exit(1);
    }
}
 

@Override
public HealthCheckResponse call() {
    HealthCheckResponseBuilder responseBuilder = HealthCheckResponse.named("Kafka Streams state health check");
    try {
        KafkaStreams.State state = manager.getStreams().state();
        responseBuilder.state(state.isRunningOrRebalancing())
                .withData("state", state.name());
    } catch (Exception e) {
        responseBuilder.down().withData("technical_error", e.getMessage());
    }
    return responseBuilder.build();
}
 

@Override
public void onChange(KafkaStreams.State newState, KafkaStreams.State oldState) {
    if (newState == KafkaStreams.State.ERROR) {
        _fatalErrorEncountered.set(true);
        _streams.close(Duration.ofMillis(1));
    } else if (newState == KafkaStreams.State.NOT_RUNNING && _fatalErrorEncountered.get()) {
        notifyFailed(_uncaughtException.get());
    }
}
 

public void destroyStateService(@Observes ShutdownEvent event, @Current AsyncBiFunctionService<Void, Void, KafkaStreams.State> service) {
    close(service);
}
 

@Override
public Serde<KafkaStreams.State> resSerde() {
    return new StateSerde();
}
 

@Override
public Stream<CompletionStage<KafkaStreams.State>> apply() {
    return Stream.of(apply(null, null));
}
 

@Override
public CompletionStage<KafkaStreams.State> apply(Void v1, Void v2) {
    return CompletableFuture.completedFuture(streams.state());
}
 

@Override
public KafkaStreams.State deserialize(String topic, byte[] data) {
    return KafkaStreams.State.valueOf(IoUtil.toString(data));
}
 

@Override
public byte[] serialize(String topic, KafkaStreams.State data) {
    return IoUtil.toBytes(data.toString());
}
 

/**
 * Build down details for the stream down.
 *
 * @param message Down message
 * @param state The stream state
 * @return Map of details messages
 */
private Map<String, String> buildDownDetails(String message, KafkaStreams.State state) {
    final Map<String, String> details = new HashMap<>();
    details.put("threadState", state.name());
    details.put("error", message);
    return details;
}
 

/**
 * Build down details for the stream down.
 *
 * @param state The stream state
 * @return Map of details messages
 */
private Map<String, String> buildDownDetails(KafkaStreams.State state) {
    return buildDownDetails("Processor appears to be down", state);
}