org.apache.kafka.streams.state.StreamsMetadata Java Examples

protected final Collection<S> allServices() {
    Collection<StreamsMetadata> smetas = streams.allMetadata();
    if (smetas.isEmpty()) {
        throw new StreamsException(
            "StreamsMetadata is currently unavailable. " +
            "This can occur during rebalance operations. "
        );
    }
    ArrayList<S> services = new ArrayList<>(smetas.size());
    for (StreamsMetadata smeta : smetas) {
        // only use stores that have some active partitions
        if (smeta.topicPartitions().size() > 0) {
            services.add(serviceForHostInfo(smeta.hostInfo()));
        }
    }
    return services;
}
 

@Override protected CompletableFuture<List<V>> listFuture() {
  List<CompletableFuture<AggregatedHttpResponse>> responseFutures =
    kafkaStreams.allMetadataForStore(storeName)
      .stream()
      .map(StreamsMetadata::hostInfo)
      .map(this::httpClient)
      .map(c -> c.get(httpPath).aggregate()).collect(Collectors.toList());
  return CompletableFuture.allOf(responseFutures.toArray(new CompletableFuture[0]))
    .thenApply(unused ->
      responseFutures.stream()
        .map(s -> s.getNow(AggregatedHttpResponse.of(HttpStatus.INTERNAL_SERVER_ERROR)))
        .map(this::content)
        .map(this::parseList)
        .flatMap(Collection::stream)
        .distinct()
        .limit(limit)
        .collect(Collectors.toList()));
}
 

public GetWeatherStationDataResult getWeatherStationData(int id) {
    StreamsMetadata metadata = streams.metadataForKey(
            TopologyProducer.WEATHER_STATIONS_STORE,
            id,
            Serdes.Integer().serializer());

    if (metadata == null || metadata == StreamsMetadata.NOT_AVAILABLE) {
        LOG.warnv("Found no metadata for key {0}", id);
        return GetWeatherStationDataResult.notFound();
    } else if (metadata.host().equals(host)) {
        LOG.infov("Found data for key {0} locally", id);
        Aggregation result = getWeatherStationStore().get(id);

        if (result != null) {
            return GetWeatherStationDataResult.found(WeatherStationData.from(result));
        } else {
            return GetWeatherStationDataResult.notFound();
        }
    } else {
        LOG.infov("Found data for key {0} on remote host {1}:{2}", id, metadata.host(), metadata.port());
        return GetWeatherStationDataResult.foundRemotely(metadata.host(), metadata.port());
    }
}
 

@SuppressWarnings("unchecked")
private String fetchAllFromKeyValueStore(Map<String, String> params) {
    String store = params.get(STORE_PARAM);
    List<KeyValue<String, Long>> allResults = gson.fromJson(getKeyValuesAsJson(store), List.class);
    Collection<StreamsMetadata> streamsMetadata = kafkaStreams.allMetadataForStore(store);
    for (StreamsMetadata streamsMetadatum : streamsMetadata) {
        if (dataNotLocal(streamsMetadatum.hostInfo())) {
            Map<String, String> newParams = new HashMap<>();
            newParams.put(STORE_PARAM, store);
            newParams.put(":local", "local");
            List<KeyValue<String, Long>> remoteResults = gson.fromJson(fetchRemote(streamsMetadatum.hostInfo(), "kv", newParams), List.class);
            allResults.addAll(remoteResults);
        }
    }
    return gson.toJson(new HashSet<>(allResults));
}
 

/**
 * Metrics for a machine
 *
 * @param machine
 * @return the metric
 */
@GET
@Path("{machine}")
@Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
public Response getMachineMetric(@PathParam("machine") String machine) {
    LOGGER.log(Level.INFO, "Fetching metrics for machine {0}", machine);

    KafkaStreams ks = GlobalAppState.getInstance().getKafkaStreams();
    HostInfo thisInstance = GlobalAppState.getInstance().getHostPortInfo();

    Metrics metrics = null;

    StreamsMetadata metadataForMachine = ks.metadataForKey(storeName, machine, new StringSerializer());

    if (metadataForMachine.host().equals(thisInstance.host()) && metadataForMachine.port() == thisInstance.port()) {
        LOGGER.log(Level.INFO, "Querying local store for machine {0}", machine);
        metrics = getLocalMetrics(machine);
    } else {
        //LOGGER.log(Level.INFO, "Querying remote store for machine {0}", machine);
        String url = "http://" + metadataForMachine.host() + ":" + metadataForMachine.port() + "/metrics/remote/" + machine;
        metrics = Utils.getRemoteStoreState(url, 2, TimeUnit.SECONDS);
        LOGGER.log(Level.INFO, "Metric from remote store at {0} == {1}", new Object[]{url, metrics});
    }

    return Response.ok(metrics).build();
}
 

protected final Collection<S> allServicesForStore() {
    Collection<StreamsMetadata> smetas = streams.allMetadataForStore(storeName);
    if (smetas.isEmpty()) {
        throw new InvalidStateStoreException(
            "StreamsMetadata is currently unavailable. " +
            "This can occur during rebalance operations. " +
            "Store-name: " + storeName
        );
    }
    ArrayList<S> services = new ArrayList<>(smetas.size());
    for (StreamsMetadata smeta : smetas) {
        // only use stores that have some active partitions
        if (smeta.topicPartitions().size() > 0) {
            services.add(serviceForHostInfo(smeta.hostInfo()));
        }
    }
    return services;
}
 

@Get("/instances/:store_name")
@ProducesJson
public KafkaStreamsMetadata getInstancesByStore(@Param("store_name") String storeName) {
  Collection<StreamsMetadata> metadata =
      storage.getTraceStorageStream().allMetadataForStore(storeName);
  metadata.addAll(storage.getDependencyStorageStream().allMetadataForStore(storeName));
  return KafkaStreamsMetadata.create(metadata);
}
 

@Get("/instances")
@ProducesJson
public KafkaStreamsMetadata getInstances() {
  Collection<StreamsMetadata> metadata = storage.getTraceStorageStream().allMetadata();
  metadata.addAll(storage.getDependencyStorageStream().allMetadata());
  return KafkaStreamsMetadata.create(metadata);
}
 

@Override protected CompletableFuture<List<V>> listFuture() {
  StreamsMetadata metadata = kafkaStreams.metadataForKey(storeName, key, STRING_SERIALIZER);
  WebClient httpClient = httpClient(metadata.hostInfo());
  return httpClient.get(httpPath)
    .aggregate()
    .thenApply(response -> {
      String content = content(response);
      return parseList(content);
    });
}
 

private String fetchAllFromLocalKeyValueStore(Map<String, String> params) {
    String store = params.get(STORE_PARAM);
    Collection<StreamsMetadata> metadata = kafkaStreams.allMetadataForStore(store);
    for (StreamsMetadata streamsMetadata : metadata) {
        if (localData(streamsMetadata.hostInfo())) {
            return getKeyValuesAsJson(store);
        }
    }
    return "[]";
}
 

/**
 * Local interface for fetching metrics
 *
 * @return Metrics from local and other remote stores (if needed)
 * @throws Exception
 */
@GET
@Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
public Response all_metrics() throws Exception {
    Response response = null;
    try {
        KafkaStreams ks = GlobalAppState.getInstance().getKafkaStreams();
        HostInfo thisInstance = GlobalAppState.getInstance().getHostPortInfo();

        LOGGER.info("Querying local store");
        Metrics metrics = getLocalMetrics();

        // LOGGER.info("Querying remote stores....");
        ks.allMetadataForStore(storeName)
                .stream()
                .filter(sm -> !(sm.host().equals(thisInstance.host()) && sm.port() == thisInstance.port())) //only query remote node stores
                .forEach(new Consumer<StreamsMetadata>() {
                    @Override
                    public void accept(StreamsMetadata t) {
                        String url = "http://" + t.host() + ":" + t.port() + "/metrics/remote";
                        //LOGGER.log(Level.INFO, "Fetching remote store at {0}", url);
                        Metrics remoteMetrics = Utils.getRemoteStoreState(url, 2, TimeUnit.SECONDS);
                        metrics.add(remoteMetrics);
                        LOGGER.log(Level.INFO, "Metric from remote store at {0} == {1}", new Object[]{url, remoteMetrics});
                    }

                });

        LOGGER.log(Level.INFO, "Complete store state {0}", metrics);
        response = Response.ok(metrics).build();
    } catch (Exception e) {
        LOGGER.log(Level.SEVERE, "Error - {0}", e.getMessage());
        e.printStackTrace();
    }

    return response;
}
 

@Test
public void success(TestContext context){

    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);
    StreamsMetadata host = new StreamsMetadata(new HostInfo("host", 1), Collections.emptySet(), Collections.emptySet());
    when(mock.metadataForKey(anyString(), any(), any(Serializer.class))).thenReturn(host);
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);

    rule.vertx().eventBus().consumer(Config.WINDOWED_QUERY_ADDRESS_PREFIX + "host", msg -> {
        SortedMap<Long, String> result = new TreeMap<>();

        result.put(1L, "abc");
        result.put(2L, "def");
        msg.reply(new WindowedQueryResponse(result ));
    });

    rule.vertx().deployVerticle(new KeyBasedQueryFacadeVerticle<WindowedQuery, WindowedQueryResponse>(Config.WINDOWED_QUERY_FACADE_ADDRESS, Config.WINDOWED_QUERY_ADDRESS_PREFIX), context.asyncAssertSuccess(deployment->{

        WindowedQuery query = new WindowedQuery("store", Serdes.String().getClass().getName(), "key".getBytes(),Serdes.String().getClass().getName(),  1, 2);

        rule.vertx().eventBus().send(Config.WINDOWED_QUERY_FACADE_ADDRESS, query, context.asyncAssertSuccess(reply ->{

            context.assertTrue(reply.body() instanceof WindowedQueryResponse);
            WindowedQueryResponse response = (WindowedQueryResponse) reply.body();
            context.assertEquals(2, response.getValues().size());
            context.assertTrue(response.getValues().containsKey(1L));
            context.assertEquals("abc", response.getValues().get(1L));
            context.assertTrue(response.getValues().containsKey(2L));
            context.assertEquals("def", response.getValues().get(2L));

        }));


    }));

}
 

public <K> StreamsMetadata metadataForKey(final String storeName,
                                          final K key,
                                          final Serializer<K> keySerializer) {

    return streamsClient.metadataForKey(storeName, key, keySerializer);
}
 

@Test
public void forwardingFailureDuringInstanceLookup(TestContext context){

    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);
    StreamsMetadata host = new StreamsMetadata(new HostInfo("host", 1), Collections.emptySet(), Collections.emptySet());
    when(mock.metadataForKey(anyString(), any(), any(Serializer.class))).thenReturn(null);
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);


    rule.vertx().deployVerticle(new KeyBasedQueryFacadeVerticle<KeyBasedQuery, ScalarKeyValueQueryResponse>(Config.KEY_VALUE_QUERY_FACADE_ADDRESS, Config.KEY_VALUE_QUERY_ADDRESS_PREFIX), context.asyncAssertSuccess(deployment->{

        KeyBasedQuery query = new KeyBasedQuery("store", Serdes.String().getClass().getName(), "key".getBytes(), Serdes.String().getClass().getName());

        rule.vertx().eventBus().send(Config.KEY_VALUE_QUERY_FACADE_ADDRESS, query, context.asyncAssertFailure(handler ->{

            context.assertTrue(handler instanceof ReplyException);
            ReplyException ex = (ReplyException) handler;
            context.assertEquals(404, ex.failureCode());

        }));
    }));

}
 

@Test
public void forwardingFailureDuringInstanceLookup(TestContext context){

    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);
    StreamsMetadata host = new StreamsMetadata(new HostInfo("host", 1), Collections.emptySet(), Collections.emptySet());
    when(mock.metadataForKey(anyString(), any(), any(Serializer.class))).thenReturn(null);
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);


    rule.vertx().deployVerticle(new KeyBasedQueryFacadeVerticle<WindowedQuery, WindowedQueryResponse>(Config.WINDOWED_QUERY_FACADE_ADDRESS, Config.WINDOWED_QUERY_ADDRESS_PREFIX), context.asyncAssertSuccess(deployment->{

        WindowedQuery query = new WindowedQuery("store", Serdes.String().getClass().getName(), "key".getBytes(),Serdes.String().getClass().getName(),  1, 2);

        rule.vertx().eventBus().send(Config.WINDOWED_QUERY_FACADE_ADDRESS, query, context.asyncAssertFailure(handler ->{

            context.assertTrue(handler instanceof ReplyException);
            ReplyException ex = (ReplyException) handler;
            context.assertEquals(404, ex.failureCode());

        }));
    }));

}
 

public <K> StreamsMetadata metadataForKey(final String storeName,
                                          final K key,
                                          final StreamPartitioner<? super K, ?> partitioner) {
    return streamsClient.metadataForKey(storeName, key, partitioner);
}
 

public Collection<StreamsMetadata> allMetadataForStore(final String storeName) {
    return streamsClient.allMetadataForStore(storeName);
}
 

public Collection<StreamsMetadata> allMetadata() {
    return streamsClient.allMetadata();
}
 

private HostInfo getHostInfo(String storeName, String key) {
    StreamsMetadata metadata = kafkaStreams.metadataForKey(storeName, key, stringSerializer);
    return metadata.hostInfo();
}
 

@Test
public void successOneInstances(TestContext context){


    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);
    StreamsMetadata host1 = new StreamsMetadata(new HostInfo("host1", 1), Collections.emptySet(), Collections.emptySet());
    when(mock.allMetadataForStore(anyString())).thenReturn( Arrays.asList(new StreamsMetadata[]{host1}));
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);

    rule.vertx().eventBus().consumer(Config.RANGE_KEY_VALUE_QUERY_ADDRESS_PREFIX + "host1", msg -> {
        Map<String, String> result = new HashMap<>();
        result.put("key1", "value1");
        msg.reply(new MultiValuedKeyValueQueryResponse(result));
    });


    rule.vertx().deployVerticle(new ScatterGatherQueryFacadeVerticle<MultiValuedKeyValueQueryResponse>(Config.RANGE_KEY_VALUE_QUERY_FACADE_ADDRESS, Config.RANGE_KEY_VALUE_QUERY_ADDRESS_PREFIX, () -> new MultiValuedKeyValueQueryResponse(), (a, b) -> a.merge(b)), context.asyncAssertSuccess(deployment->{

        RangeKeyValueQuery query = new RangeKeyValueQuery("store", Serdes.String().getClass().getName(), Serdes.String().getClass().getName(), "key".getBytes(), "key".getBytes());

        rule.vertx().eventBus().send(Config.RANGE_KEY_VALUE_QUERY_FACADE_ADDRESS, query, context.asyncAssertSuccess(reply ->{

            context.assertTrue(reply.body() instanceof MultiValuedKeyValueQueryResponse);
            MultiValuedKeyValueQueryResponse response = (MultiValuedKeyValueQueryResponse) reply.body();
            context.assertEquals(1, response.getResults().size());
            context.assertTrue(response.getResults().containsKey("key1"));
            context.assertEquals("value1", response.getResults().get("key1"));

        }));


    }));

}
 

@Test
public void failureOneSourceFails(TestContext context){


    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);

    StreamsMetadata host1 = new StreamsMetadata(new HostInfo("host1", 1), Collections.emptySet(), Collections.emptySet());
    StreamsMetadata host2 = new StreamsMetadata(new HostInfo("host2", 1), Collections.emptySet(), Collections.emptySet());

    when(mock.allMetadataForStore(anyString())).thenReturn( Arrays.asList(new StreamsMetadata[]{host1, host2}));
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);

    rule.vertx().eventBus().consumer(Config.RANGE_KEY_VALUE_QUERY_ADDRESS_PREFIX + "host1", msg -> {
        Map<String, String> result = new HashMap<>();
        result.put("key1", "value1");
        msg.reply(new MultiValuedKeyValueQueryResponse(result));
    });
    rule.vertx().eventBus().consumer(Config.RANGE_KEY_VALUE_QUERY_ADDRESS_PREFIX + "host2", msg -> {
       msg.fail(400, "msg");
    });

    rule.vertx().deployVerticle(new ScatterGatherQueryFacadeVerticle<MultiValuedKeyValueQueryResponse>(Config.RANGE_KEY_VALUE_QUERY_FACADE_ADDRESS, Config.RANGE_KEY_VALUE_QUERY_ADDRESS_PREFIX, () -> new MultiValuedKeyValueQueryResponse(), (a, b) -> a.merge(b)), context.asyncAssertSuccess(deployment->{

        RangeKeyValueQuery query = new RangeKeyValueQuery("store", Serdes.String().getClass().getName(), Serdes.String().getClass().getName(), "key".getBytes(), "key".getBytes());

        rule.vertx().eventBus().send(Config.RANGE_KEY_VALUE_QUERY_FACADE_ADDRESS, query, context.asyncAssertFailure(handler ->{

            context.assertTrue(handler instanceof ReplyException);
            ReplyException ex = (ReplyException) handler;
            context.assertEquals(400, ex.failureCode());

        }));


    }));

}
 

@Test
public void failureOfInstanceResolution(TestContext context){


    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);



    when(mock.allMetadataForStore(anyString())).thenReturn( Arrays.asList(new StreamsMetadata[]{}));
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);


    rule.vertx().deployVerticle(new ScatterGatherQueryFacadeVerticle<MultiValuedKeyValueQueryResponse>(Config.RANGE_KEY_VALUE_QUERY_FACADE_ADDRESS, Config.RANGE_KEY_VALUE_QUERY_ADDRESS_PREFIX, () -> new MultiValuedKeyValueQueryResponse(), (a, b) -> a.merge(b)), context.asyncAssertSuccess(deployment->{

        RangeKeyValueQuery query = new RangeKeyValueQuery("store", Serdes.String().getClass().getName(), Serdes.String().getClass().getName(), "key".getBytes(), "key".getBytes());


        rule.vertx().eventBus().send(Config.RANGE_KEY_VALUE_QUERY_FACADE_ADDRESS, query, context.asyncAssertFailure(handler ->{

            context.assertTrue(handler instanceof ReplyException);
            ReplyException ex = (ReplyException) handler;
            context.assertEquals(404, ex.failureCode());

        }));


    }));

}
 

@Test
public void forwardingFailureDuringQuery(TestContext context){


    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);
    StreamsMetadata host = new StreamsMetadata(new HostInfo("host", 1), Collections.emptySet(), Collections.emptySet());
    when(mock.metadataForKey(anyString(), any(), any(Serializer.class))).thenReturn(host);
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);


    rule.vertx().eventBus().consumer(Config.WINDOWED_QUERY_ADDRESS_PREFIX + "host", msg -> {
        msg.fail(400, "msg");
    });

    rule.vertx().deployVerticle(new KeyBasedQueryFacadeVerticle<WindowedQuery, WindowedQueryResponse>(Config.WINDOWED_QUERY_FACADE_ADDRESS, Config.WINDOWED_QUERY_ADDRESS_PREFIX), context.asyncAssertSuccess(deployment->{

        WindowedQuery query = new WindowedQuery("store", Serdes.String().getClass().getName(), "key".getBytes(),Serdes.String().getClass().getName(),  1, 2);

        rule.vertx().eventBus().send(Config.WINDOWED_QUERY_FACADE_ADDRESS, query, context.asyncAssertFailure(handler ->{

            context.assertTrue(handler instanceof ReplyException);
            ReplyException ex = (ReplyException) handler;
            context.assertEquals(400, ex.failureCode());
            context.assertEquals("msg", ex.getMessage());

        }));
    }));

}
 

@Test
public void successOneInstances(TestContext context){

    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);

    StreamsMetadata host1 = new StreamsMetadata(new HostInfo("host1", 1), Collections.emptySet(), Collections.emptySet());


    when(mock.allMetadataForStore(anyString())).thenReturn( Arrays.asList(new StreamsMetadata[]{host1}));
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);

    rule.vertx().eventBus().consumer(Config.ALL_KEY_VALUE_QUERY_ADDRESS_PREFIX + "host1", msg -> {
        Map<String, String> result = new HashMap<>();
        result.put("key1", "value1");
        msg.reply(new MultiValuedKeyValueQueryResponse(result));
    });


    rule.vertx().deployVerticle(new ScatterGatherQueryFacadeVerticle<MultiValuedKeyValueQueryResponse>(Config.ALL_KEY_VALUE_QUERY_FACADE_ADDRESS, Config.ALL_KEY_VALUE_QUERY_ADDRESS_PREFIX, () -> new MultiValuedKeyValueQueryResponse(), (a, b) -> a.merge(b)), context.asyncAssertSuccess(deployment->{

        StoreWideQuery query = new StoreWideQuery("store", Serdes.String().getClass().getName(), Serdes.String().getClass().getName());

        rule.vertx().eventBus().send(Config.ALL_KEY_VALUE_QUERY_FACADE_ADDRESS, query, context.asyncAssertSuccess(reply ->{

            context.assertTrue(reply.body() instanceof MultiValuedKeyValueQueryResponse);
            MultiValuedKeyValueQueryResponse response = (MultiValuedKeyValueQueryResponse) reply.body();
            context.assertEquals(1, response.getResults().size());
            context.assertTrue(response.getResults().containsKey("key1"));
            context.assertEquals("value1", response.getResults().get("key1"));

        }));


    }));

}
 

@Test
public void failureOneSourceFails(TestContext context){


    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);

    StreamsMetadata host1 = new StreamsMetadata(new HostInfo("host1", 1), Collections.emptySet(), Collections.emptySet());
    StreamsMetadata host2 = new StreamsMetadata(new HostInfo("host2", 1), Collections.emptySet(), Collections.emptySet());

    when(mock.allMetadataForStore(anyString())).thenReturn( Arrays.asList(new StreamsMetadata[]{host1, host2}));

    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);


    rule.vertx().eventBus().consumer(Config.ALL_KEY_VALUE_QUERY_ADDRESS_PREFIX + "host1", msg -> {
        Map<String, String> result = new HashMap<>();
        result.put("key1", "value1");
        msg.reply(new MultiValuedKeyValueQueryResponse(result));
    });
    rule.vertx().eventBus().consumer(Config.ALL_KEY_VALUE_QUERY_ADDRESS_PREFIX + "host2", msg -> {
       msg.fail(400, "msg");
    });

    rule.vertx().deployVerticle(new ScatterGatherQueryFacadeVerticle<MultiValuedKeyValueQueryResponse>(Config.ALL_KEY_VALUE_QUERY_FACADE_ADDRESS, Config.ALL_KEY_VALUE_QUERY_ADDRESS_PREFIX, () -> new MultiValuedKeyValueQueryResponse(), (a, b) -> a.merge(b)), context.asyncAssertSuccess(deployment->{

        StoreWideQuery query = new StoreWideQuery("store", Serdes.String().getClass().getName(), Serdes.String().getClass().getName());

        rule.vertx().eventBus().send(Config.ALL_KEY_VALUE_QUERY_FACADE_ADDRESS, query, context.asyncAssertFailure(handler ->{

            context.assertTrue(handler instanceof ReplyException);
            ReplyException ex = (ReplyException) handler;
            context.assertEquals(400, ex.failureCode());

        }));


    }));

}
 

@Test
public void success(TestContext context){

    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);
    StreamsMetadata host = new StreamsMetadata(new HostInfo("host", 1), Collections.emptySet(), Collections.emptySet());
    when(mock.metadataForKey(anyString(), any(), any(Serializer.class))).thenReturn(host);
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);

    rule.vertx().eventBus().consumer(Config.KEY_VALUE_QUERY_ADDRESS_PREFIX + "host", msg -> {
       msg.reply(new ScalarKeyValueQueryResponse("value"));
    });

    rule.vertx().deployVerticle(new KeyBasedQueryFacadeVerticle<KeyBasedQuery, ScalarKeyValueQueryResponse>(Config.KEY_VALUE_QUERY_FACADE_ADDRESS, Config.KEY_VALUE_QUERY_ADDRESS_PREFIX), context.asyncAssertSuccess(deployment->{

        KeyBasedQuery query = new KeyBasedQuery("store", Serdes.String().getClass().getName(), "key".getBytes(), Serdes.String().getClass().getName());

        rule.vertx().eventBus().send(Config.KEY_VALUE_QUERY_FACADE_ADDRESS, query, context.asyncAssertSuccess(reply ->{

            context.assertTrue(reply.body() instanceof ScalarKeyValueQueryResponse);
            ScalarKeyValueQueryResponse response = (ScalarKeyValueQueryResponse) reply.body();
            context.assertEquals("value", response.getValue());

        }));


    }));

}
 

@Test
public void forwardingFailureDuringQuery(TestContext context){


    ShareableStreamsMetadataProvider mock = mock(ShareableStreamsMetadataProvider.class);
    StreamsMetadata host = new StreamsMetadata(new HostInfo("host", 1), Collections.emptySet(), Collections.emptySet());
    when(mock.metadataForKey(anyString(), any(), any(Serializer.class))).thenReturn(host);
    rule.vertx().sharedData().getLocalMap("metadata").put("metadata", mock);

    rule.vertx().eventBus().consumer(Config.KEY_VALUE_QUERY_ADDRESS_PREFIX + "host", msg -> {
        msg.fail(400, "msg");
    });

    rule.vertx().deployVerticle(new KeyBasedQueryFacadeVerticle<KeyBasedQuery, ScalarKeyValueQueryResponse>(Config.KEY_VALUE_QUERY_FACADE_ADDRESS, Config.KEY_VALUE_QUERY_ADDRESS_PREFIX), context.asyncAssertSuccess(deployment->{

        KeyBasedQuery query = new KeyBasedQuery("store", Serdes.String().getClass().getName(), "key".getBytes(), Serdes.String().getClass().getName());

        rule.vertx().eventBus().send(Config.KEY_VALUE_QUERY_FACADE_ADDRESS, query, context.asyncAssertFailure(handler ->{

            context.assertTrue(handler instanceof ReplyException);
            ReplyException ex = (ReplyException) handler;
            context.assertEquals(400, ex.failureCode());
            context.assertEquals("msg", ex.getMessage());

        }));
    }));

}
 

/**
 * Gets the {@link HostInfo} where the provided store and key are hosted on. This may
 * not be the current host that is running the application. Kafka Streams will look
 * through all the consumer instances under the same application id and retrieves the
 * proper host.
 *
 * Note that the end user applications must provide `applicaiton.server` as a
 * configuration property for all the application instances when calling this method.
 * If this is not available, then null maybe returned.
 * @param <K> generic type for key
 * @param store store name
 * @param key key to look for
 * @param serializer {@link Serializer} for the key
 * @return the {@link HostInfo} where the key for the provided store is hosted
 * currently
 */
public <K> HostInfo getHostInfo(String store, K key, Serializer<K> serializer) {
	StreamsMetadata streamsMetadata = this.kafkaStreamsRegistry.getKafkaStreams()
			.stream()
			.map((k) -> Optional.ofNullable(k.metadataForKey(store, key, serializer)))
			.filter(Optional::isPresent).map(Optional::get).findFirst().orElse(null);
	return streamsMetadata != null ? streamsMetadata.hostInfo() : null;
}
 

/**
 * Gets the list of {@link HostInfo} where the provided store is hosted on.
 * It also can include current host info.
 * Kafka Streams will look through all the consumer instances under the same application id
 * and retrieves all hosts info.
 *
 * Note that the end-user applications must provide `application.server` as a configuration property
 * for all the application instances when calling this method. If this is not available, then an empty list will be returned.
 *
 * @param store store name
 * @return the list of {@link HostInfo} where provided store is hosted on
 */
public List<HostInfo> getAllHostsInfo(String store) {
	return kafkaStreamsRegistry.getKafkaStreams()
			.stream()
			.flatMap(k -> k.allMetadataForStore(store).stream())
			.filter(Objects::nonNull)
			.map(StreamsMetadata::hostInfo)
			.collect(Collectors.toList());
}
 

@Override
public void start() throws Exception {
    vertx.eventBus().consumer(listeningAddress, msg -> {
        HasStoreName query = (HasStoreName) msg.body();


        ShareableStreamsMetadataProvider metadataProvider = (ShareableStreamsMetadataProvider) vertx.sharedData().getLocalMap("metadata").get("metadata");

        Collection<StreamsMetadata> allMetadata = metadataProvider.allMetadataForStore(query.getStoreName());


        if (allMetadata.isEmpty()) {
            msg.fail(404, "No instance for store found: " + query.getStoreName());
        } else if (allMetadata.stream().anyMatch(meta -> "unavailable".equals(meta.host()))) {
            msg.fail(503, "Streaming application currently unavailable");
        }


        List<Future> results = allMetadata.stream().map(StreamsMetadata::host)
                .map(instanceId -> {
                    Future<Message<Object>> future = Future.<Message<Object>>future();
                    vertx.eventBus().send(queryAddressPrefix + instanceId, query, future.completer());
                    return future;
                }).collect(Collectors.toList());

        CompositeFuture all = CompositeFuture.all(results);


        all.setHandler(compoundFutureHandler -> {

            if (compoundFutureHandler.succeeded()) {
                List<Message<RES>> list = compoundFutureHandler.result().list();

                RES reduced = list.stream().map(message -> message.body()).reduce(identity.get(), reducer);
                msg.reply(reduced);
            } else {
                ReplyException cause = (ReplyException) compoundFutureHandler.cause();
                msg.fail(cause.failureCode(), cause.getMessage());
            }
        });


    });

}