Examples with StaleMetadataException org.apache.kafka.clients.StaleMetadataException used on opensource projects

Example 1 with StaleMetadataException

use of org.apache.kafka.clients.StaleMetadataException in project kafka by apache.

the class Fetcher method sendListOffsetsRequests.

/**
 * Search the offsets by target times for the specified partitions.
 *
 * @param timestampsToSearch the mapping between partitions and target time
 * @param requireTimestamps true if we should fail with an UnsupportedVersionException if the broker does
 *                         not support fetching precise timestamps for offsets
 * @return A response which can be polled to obtain the corresponding timestamps and offsets.
 */
private RequestFuture<ListOffsetResult> sendListOffsetsRequests(final Map<TopicPartition, Long> timestampsToSearch, final boolean requireTimestamps) {
    final Set<TopicPartition> partitionsToRetry = new HashSet<>();
    Map<Node, Map<TopicPartition, ListOffsetsPartition>> timestampsToSearchByNode = groupListOffsetRequests(timestampsToSearch, partitionsToRetry);
    if (timestampsToSearchByNode.isEmpty())
        return RequestFuture.failure(new StaleMetadataException());
    final RequestFuture<ListOffsetResult> listOffsetRequestsFuture = new RequestFuture<>();
    final Map<TopicPartition, ListOffsetData> fetchedTimestampOffsets = new HashMap<>();
    final AtomicInteger remainingResponses = new AtomicInteger(timestampsToSearchByNode.size());
    for (Map.Entry<Node, Map<TopicPartition, ListOffsetsPartition>> entry : timestampsToSearchByNode.entrySet()) {
        RequestFuture<ListOffsetResult> future = sendListOffsetRequest(entry.getKey(), entry.getValue(), requireTimestamps);
        future.addListener(new RequestFutureListener<ListOffsetResult>() {

            @Override
            public void onSuccess(ListOffsetResult partialResult) {
                synchronized (listOffsetRequestsFuture) {
                    fetchedTimestampOffsets.putAll(partialResult.fetchedOffsets);
                    partitionsToRetry.addAll(partialResult.partitionsToRetry);
                    if (remainingResponses.decrementAndGet() == 0 && !listOffsetRequestsFuture.isDone()) {
                        ListOffsetResult result = new ListOffsetResult(fetchedTimestampOffsets, partitionsToRetry);
                        listOffsetRequestsFuture.complete(result);
                    }
                }
            }

            @Override
            public void onFailure(RuntimeException e) {
                synchronized (listOffsetRequestsFuture) {
                    if (!listOffsetRequestsFuture.isDone())
                        listOffsetRequestsFuture.raise(e);
                }
            }
        });
    }
    return listOffsetRequestsFuture;
}

Example 2 with StaleMetadataException

use of org.apache.kafka.clients.StaleMetadataException in project kafka by apache.

the class KafkaAdminClient method listConsumerGroups.

@Override
public ListConsumerGroupsResult listConsumerGroups(ListConsumerGroupsOptions options) {
    final KafkaFutureImpl<Collection<Object>> all = new KafkaFutureImpl<>();
    final long nowMetadata = time.milliseconds();
    final long deadline = calcDeadlineMs(nowMetadata, options.timeoutMs());
    runnable.call(new Call("findAllBrokers", deadline, new LeastLoadedNodeProvider()) {

        @Override
        MetadataRequest.Builder createRequest(int timeoutMs) {
            return new MetadataRequest.Builder(new MetadataRequestData().setTopics(Collections.emptyList()).setAllowAutoTopicCreation(true));
        }

        @Override
        void handleResponse(AbstractResponse abstractResponse) {
            MetadataResponse metadataResponse = (MetadataResponse) abstractResponse;
            Collection<Node> nodes = metadataResponse.brokers();
            if (nodes.isEmpty())
                throw new StaleMetadataException("Metadata fetch failed due to missing broker list");
            HashSet<Node> allNodes = new HashSet<>(nodes);
            final ListConsumerGroupsResults results = new ListConsumerGroupsResults(allNodes, all);
            for (final Node node : allNodes) {
                final long nowList = time.milliseconds();
                runnable.call(new Call("listConsumerGroups", deadline, new ConstantNodeIdProvider(node.id())) {

                    @Override
                    ListGroupsRequest.Builder createRequest(int timeoutMs) {
                        List<String> states = options.states().stream().map(s -> s.toString()).collect(Collectors.toList());
                        return new ListGroupsRequest.Builder(new ListGroupsRequestData().setStatesFilter(states));
                    }

                    private void maybeAddConsumerGroup(ListGroupsResponseData.ListedGroup group) {
                        String protocolType = group.protocolType();
                        if (protocolType.equals(ConsumerProtocol.PROTOCOL_TYPE) || protocolType.isEmpty()) {
                            final String groupId = group.groupId();
                            final Optional<ConsumerGroupState> state = group.groupState().equals("") ? Optional.empty() : Optional.of(ConsumerGroupState.parse(group.groupState()));
                            final ConsumerGroupListing groupListing = new ConsumerGroupListing(groupId, protocolType.isEmpty(), state);
                            results.addListing(groupListing);
                        }
                    }

                    @Override
                    void handleResponse(AbstractResponse abstractResponse) {
                        final ListGroupsResponse response = (ListGroupsResponse) abstractResponse;
                        synchronized (results) {
                            Errors error = Errors.forCode(response.data().errorCode());
                            if (error == Errors.COORDINATOR_LOAD_IN_PROGRESS || error == Errors.COORDINATOR_NOT_AVAILABLE) {
                                throw error.exception();
                            } else if (error != Errors.NONE) {
                                results.addError(error.exception(), node);
                            } else {
                                for (ListGroupsResponseData.ListedGroup group : response.data().groups()) {
                                    maybeAddConsumerGroup(group);
                                }
                            }
                            results.tryComplete(node);
                        }
                    }

                    @Override
                    void handleFailure(Throwable throwable) {
                        synchronized (results) {
                            results.addError(throwable, node);
                            results.tryComplete(node);
                        }
                    }
                }, nowList);
            }
        }

        @Override
        void handleFailure(Throwable throwable) {
            KafkaException exception = new KafkaException("Failed to find brokers to send ListGroups", throwable);
            all.complete(Collections.singletonList(exception));
        }
    }, nowMetadata);
    return new ListConsumerGroupsResult(all);
}