Examples with AbstractResponse org.apache.kafka.common.requests.AbstractResponse used on opensource projects

Example 26 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class DeleteConsumerGroupOffsetsHandler method handleResponse.

@Override
public ApiResult<CoordinatorKey, Map<TopicPartition, Errors>> handleResponse(Node coordinator, Set<CoordinatorKey> groupIds, AbstractResponse abstractResponse) {
    validateKeys(groupIds);
    final OffsetDeleteResponse response = (OffsetDeleteResponse) abstractResponse;
    final Errors error = Errors.forCode(response.data().errorCode());
    if (error != Errors.NONE) {
        final Map<CoordinatorKey, Throwable> failed = new HashMap<>();
        final Set<CoordinatorKey> groupsToUnmap = new HashSet<>();
        handleGroupError(groupId, error, failed, groupsToUnmap);
        return new ApiResult<>(Collections.emptyMap(), failed, new ArrayList<>(groupsToUnmap));
    } else {
        final Map<TopicPartition, Errors> partitionResults = new HashMap<>();
        response.data().topics().forEach(topic -> topic.partitions().forEach(partition -> partitionResults.put(new TopicPartition(topic.name(), partition.partitionIndex()), Errors.forCode(partition.errorCode()))));
        return ApiResult.completed(groupId, partitionResults);
    }
}

Example 27 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class ListTransactionsHandler method handleResponse.

@Override
public ApiResult<AllBrokersStrategy.BrokerKey, Collection<TransactionListing>> handleResponse(Node broker, Set<AllBrokersStrategy.BrokerKey> keys, AbstractResponse abstractResponse) {
    int brokerId = broker.id();
    AllBrokersStrategy.BrokerKey key = requireSingleton(keys, brokerId);
    ListTransactionsResponse response = (ListTransactionsResponse) abstractResponse;
    Errors error = Errors.forCode(response.data().errorCode());
    if (error == Errors.COORDINATOR_LOAD_IN_PROGRESS) {
        log.debug("The `ListTransactions` request sent to broker {} failed because the " + "coordinator is still loading state. Will try again after backing off", brokerId);
        return ApiResult.empty();
    } else if (error == Errors.COORDINATOR_NOT_AVAILABLE) {
        log.debug("The `ListTransactions` request sent to broker {} failed because the " + "coordinator is shutting down", brokerId);
        return ApiResult.failed(key, new CoordinatorNotAvailableException("ListTransactions " + "request sent to broker " + brokerId + " failed because the coordinator is shutting down"));
    } else if (error != Errors.NONE) {
        log.error("The `ListTransactions` request sent to broker {} failed because of an " + "unexpected error {}", brokerId, error);
        return ApiResult.failed(key, error.exception("ListTransactions request " + "sent to broker " + brokerId + " failed with an unexpected exception"));
    } else {
        List<TransactionListing> listings = response.data().transactionStates().stream().map(transactionState -> new TransactionListing(transactionState.transactionalId(), transactionState.producerId(), TransactionState.parse(transactionState.transactionState()))).collect(Collectors.toList());
        return ApiResult.completed(key, listings);
    }
}

Example 28 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class DescribeProducersHandler method handleResponse.

@Override
public ApiResult<TopicPartition, PartitionProducerState> handleResponse(Node broker, Set<TopicPartition> keys, AbstractResponse abstractResponse) {
    DescribeProducersResponse response = (DescribeProducersResponse) abstractResponse;
    Map<TopicPartition, PartitionProducerState> completed = new HashMap<>();
    Map<TopicPartition, Throwable> failed = new HashMap<>();
    List<TopicPartition> unmapped = new ArrayList<>();
    for (DescribeProducersResponseData.TopicResponse topicResponse : response.data().topics()) {
        for (DescribeProducersResponseData.PartitionResponse partitionResponse : topicResponse.partitions()) {
            TopicPartition topicPartition = new TopicPartition(topicResponse.name(), partitionResponse.partitionIndex());
            Errors error = Errors.forCode(partitionResponse.errorCode());
            if (error != Errors.NONE) {
                ApiError apiError = new ApiError(error, partitionResponse.errorMessage());
                handlePartitionError(topicPartition, apiError, failed, unmapped);
                continue;
            }
            List<ProducerState> activeProducers = partitionResponse.activeProducers().stream().map(activeProducer -> {
                OptionalLong currentTransactionFirstOffset = activeProducer.currentTxnStartOffset() < 0 ? OptionalLong.empty() : OptionalLong.of(activeProducer.currentTxnStartOffset());
                OptionalInt coordinatorEpoch = activeProducer.coordinatorEpoch() < 0 ? OptionalInt.empty() : OptionalInt.of(activeProducer.coordinatorEpoch());
                return new ProducerState(activeProducer.producerId(), activeProducer.producerEpoch(), activeProducer.lastSequence(), activeProducer.lastTimestamp(), coordinatorEpoch, currentTransactionFirstOffset);
            }).collect(Collectors.toList());
            completed.put(topicPartition, new PartitionProducerState(activeProducers));
        }
    }
    return new ApiResult<>(completed, failed, unmapped);
}

Example 29 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class AllBrokersStrategy method handleResponse.

@Override
public LookupResult<BrokerKey> handleResponse(Set<BrokerKey> keys, AbstractResponse abstractResponse) {
    validateLookupKeys(keys);
    MetadataResponse response = (MetadataResponse) abstractResponse;
    MetadataResponseData.MetadataResponseBrokerCollection brokers = response.data().brokers();
    if (brokers.isEmpty()) {
        log.debug("Metadata response contained no brokers. Will backoff and retry");
        return LookupResult.empty();
    } else {
        log.debug("Discovered all brokers {} to send requests to", brokers);
    }
    Map<BrokerKey, Integer> brokerKeys = brokers.stream().collect(Collectors.toMap(broker -> new BrokerKey(OptionalInt.of(broker.nodeId())), MetadataResponseData.MetadataResponseBroker::nodeId));
    return new LookupResult<>(Collections.singletonList(ANY_BROKER), Collections.emptyMap(), brokerKeys);
}

Example 30 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class SaslClientAuthenticator method receiveKafkaResponse.

private AbstractResponse receiveKafkaResponse() throws IOException {
    if (netInBuffer == null)
        netInBuffer = new NetworkReceive(node);
    NetworkReceive receive = netInBuffer;
    try {
        byte[] responseBytes = receiveResponseOrToken();
        if (responseBytes == null)
            return null;
        else {
            AbstractResponse response = NetworkClient.parseResponse(ByteBuffer.wrap(responseBytes), currentRequestHeader);
            currentRequestHeader = null;
            return response;
        }
    } catch (BufferUnderflowException | SchemaException | IllegalArgumentException e) {
        /*
             * Account for the fact that during re-authentication there may be responses
             * arriving for requests that were sent in the past.
             */
        if (reauthInfo.reauthenticating()) {
            /*
                 * It didn't match the current request header, so it must be unrelated to
                 * re-authentication. Save it so it can be processed later.
                 */
            receive.payload().rewind();
            reauthInfo.pendingAuthenticatedReceives.add(receive);
            return null;
        }
        log.debug("Invalid SASL mechanism response, server may be expecting only GSSAPI tokens");
        setSaslState(SaslState.FAILED);
        throw new IllegalSaslStateException("Invalid SASL mechanism response, server may be expecting a different protocol", e);
    }
}