Java ApiKeys类代码示例

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
/**
 * Disconnects the connection to a particular node, if there is one.
 * Any pending ClientRequests for this connection will receive disconnections.
 *
 * @param nodeId The id of the node
 */
@Override
public void disconnect(String nodeId) {
    selector.close(nodeId);
    List<ApiKeys> requestTypes = new ArrayList<>();
    long now = time.milliseconds();
    for (InFlightRequest request : inFlightRequests.clearAll(nodeId)) {
        if (request.isInternalRequest) {
            if (request.header.apiKey() == ApiKeys.METADATA.id) {
                metadataUpdater.handleDisconnection(request.destination);
            }
        } else {
            requestTypes.add(ApiKeys.forId(request.header.apiKey()));
            abortedSends.add(new ClientResponse(request.header,
                    request.callback, request.destination, request.createdTimeMs, now,
                    true, null, null));
        }
    }
    connectionStates.disconnected(nodeId, now);
    if (log.isDebugEnabled()) {
        log.debug("Manually disconnected from {}.  Removed requests: {}.", nodeId,
            Utils.join(requestTypes, ", "));
    }
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
protected Struct toStruct(short version) {
    Struct struct = new Struct(ApiKeys.JOIN_GROUP.responseSchema(version));
    if (struct.hasField(THROTTLE_TIME_KEY_NAME))
        struct.set(THROTTLE_TIME_KEY_NAME, throttleTimeMs);

    struct.set(ERROR_CODE_KEY_NAME, error.code());
    struct.set(GENERATION_ID_KEY_NAME, generationId);
    struct.set(GROUP_PROTOCOL_KEY_NAME, groupProtocol);
    struct.set(MEMBER_ID_KEY_NAME, memberId);
    struct.set(LEADER_ID_KEY_NAME, leaderId);

    List<Struct> memberArray = new ArrayList<>();
    for (Map.Entry<String, ByteBuffer> entries : members.entrySet()) {
        Struct memberData = struct.instance(MEMBERS_KEY_NAME);
        memberData.set(MEMBER_ID_KEY_NAME, entries.getKey());
        memberData.set(MEMBER_METADATA_KEY_NAME, entries.getValue());
        memberArray.add(memberData);
    }
    struct.set(MEMBERS_KEY_NAME, memberArray.toArray());

    return struct;
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
protected Struct toStruct() {
    short version = version();
    Struct struct = new Struct(ApiKeys.JOIN_GROUP.requestSchema(version));
    struct.set(GROUP_ID_KEY_NAME, groupId);
    struct.set(SESSION_TIMEOUT_KEY_NAME, sessionTimeout);
    if (version >= 1) {
        struct.set(REBALANCE_TIMEOUT_KEY_NAME, rebalanceTimeout);
    }
    struct.set(MEMBER_ID_KEY_NAME, memberId);
    struct.set(PROTOCOL_TYPE_KEY_NAME, protocolType);
    List<Struct> groupProtocolsList = new ArrayList<>(groupProtocols.size());
    for (ProtocolMetadata protocol : groupProtocols) {
        Struct protocolStruct = struct.instance(GROUP_PROTOCOLS_KEY_NAME);
        protocolStruct.set(PROTOCOL_NAME_KEY_NAME, protocol.name);
        protocolStruct.set(PROTOCOL_METADATA_KEY_NAME, protocol.metadata);
        groupProtocolsList.add(protocolStruct);
    }
    struct.set(GROUP_PROTOCOLS_KEY_NAME, groupProtocolsList.toArray());
    return struct;
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
public DescribeConfigsResponse getErrorResponse(int throttleTimeMs, Throwable e) {
    short version = version();
    switch (version) {
        case 0:
            ApiError error = ApiError.fromThrowable(e);
            Map<Resource, DescribeConfigsResponse.Config> errors = new HashMap<>(resources().size());
            DescribeConfigsResponse.Config config = new DescribeConfigsResponse.Config(error,
                    Collections.<DescribeConfigsResponse.ConfigEntry>emptyList());
            for (Resource resource : resources())
                errors.put(resource, config);
            return new DescribeConfigsResponse(throttleTimeMs, errors);
        default:
            throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d",
                    version, this.getClass().getSimpleName(), ApiKeys.DESCRIBE_CONFIGS.latestVersion()));
    }
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
public AbstractResponse getErrorResponse(int throttleTimeMs, Throwable e) {
    Map<TopicPartition, DeleteRecordsResponse.PartitionResponse> responseMap = new HashMap<>();

    for (Map.Entry<TopicPartition, Long> entry : partitionOffsets.entrySet()) {
        responseMap.put(entry.getKey(), new DeleteRecordsResponse.PartitionResponse(DeleteRecordsResponse.INVALID_LOW_WATERMARK, Errors.forException(e)));
    }

    short versionId = version();
    switch (versionId) {
        case 0:
            return new DeleteRecordsResponse(throttleTimeMs, responseMap);
        default:
            throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d",
                versionId, this.getClass().getSimpleName(), ApiKeys.DELETE_RECORDS.latestVersion()));
    }
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
protected Struct toStruct(short version) {
    Struct struct = new Struct(ApiKeys.CONTROLLED_SHUTDOWN_KEY.responseSchema(version));

    struct.set(ERROR_CODE_KEY_NAME, error.code());

    List<Struct> partitionsRemainingList = new ArrayList<>(partitionsRemaining.size());
    for (TopicPartition topicPartition : partitionsRemaining) {
        Struct topicPartitionStruct = struct.instance(PARTITIONS_REMAINING_KEY_NAME);
        topicPartitionStruct.set(TOPIC_KEY_NAME, topicPartition.topic());
        topicPartitionStruct.set(PARTITION_KEY_NAME, topicPartition.partition());
        partitionsRemainingList.add(topicPartitionStruct);
    }
    struct.set(PARTITIONS_REMAINING_KEY_NAME, partitionsRemainingList.toArray());

    return struct;
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
protected Struct toStruct(short version) {
    Struct struct = new Struct(ApiKeys.LEADER_AND_ISR.responseSchema(version));

    List<Struct> responseDatas = new ArrayList<>(responses.size());
    for (Map.Entry<TopicPartition, Errors> response : responses.entrySet()) {
        Struct partitionData = struct.instance(PARTITIONS_KEY_NAME);
        TopicPartition partition = response.getKey();
        partitionData.set(PARTITIONS_TOPIC_KEY_NAME, partition.topic());
        partitionData.set(PARTITIONS_PARTITION_KEY_NAME, partition.partition());
        partitionData.set(PARTITIONS_ERROR_CODE_KEY_NAME, response.getValue().code());
        responseDatas.add(partitionData);
    }

    struct.set(PARTITIONS_KEY_NAME, responseDatas.toArray());
    struct.set(ERROR_CODE_KEY_NAME, error.code());

    return struct;
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
public AbstractResponse getErrorResponse(int throttleTimeMs, Throwable e) {
    Map<TopicPartition, Errors> responses = new HashMap<>(partitions.size());
    for (TopicPartition partition : partitions) {
        responses.put(partition, Errors.forException(e));
    }

    short versionId = version();
    switch (versionId) {
        case 0:
            return new StopReplicaResponse(Errors.NONE, responses);
        default:
            throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d",
                    versionId, this.getClass().getSimpleName(), ApiKeys.STOP_REPLICA.latestVersion()));
    }
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
protected Struct toStruct() {
    Struct struct = new Struct(ApiKeys.OFFSET_FETCH.requestSchema(version()));
    struct.set(GROUP_ID_KEY_NAME, groupId);
    if (partitions != null) {
        Map<String, List<Integer>> topicsData = CollectionUtils.groupDataByTopic(partitions);

        List<Struct> topicArray = new ArrayList<>();
        for (Map.Entry<String, List<Integer>> entries : topicsData.entrySet()) {
            Struct topicData = struct.instance(TOPICS_KEY_NAME);
            topicData.set(TOPIC_KEY_NAME, entries.getKey());
            List<Struct> partitionArray = new ArrayList<>();
            for (Integer partitionId : entries.getValue()) {
                Struct partitionData = topicData.instance(PARTITIONS_KEY_NAME);
                partitionData.set(PARTITION_KEY_NAME, partitionId);
                partitionArray.add(partitionData);
            }
            topicData.set(PARTITIONS_KEY_NAME, partitionArray.toArray());
            topicArray.add(topicData);
        }
        struct.set(TOPICS_KEY_NAME, topicArray.toArray());
    } else
        struct.set(TOPICS_KEY_NAME, null);

    return struct;
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
public AbstractResponse getErrorResponse(int throttleTimeMs, Throwable e) {
    List<MetadataResponse.TopicMetadata> topicMetadatas = new ArrayList<>();
    Errors error = Errors.forException(e);
    List<MetadataResponse.PartitionMetadata> partitions = Collections.emptyList();

    if (topics != null) {
        for (String topic : topics)
            topicMetadatas.add(new MetadataResponse.TopicMetadata(error, topic, false, partitions));
    }

    short versionId = version();
    switch (versionId) {
        case 0:
        case 1:
        case 2:
            return new MetadataResponse(Collections.<Node>emptyList(), null, MetadataResponse.NO_CONTROLLER_ID, topicMetadatas);
        case 3:
        case 4:
            return new MetadataResponse(throttleTimeMs, Collections.<Node>emptyList(), null, MetadataResponse.NO_CONTROLLER_ID, topicMetadatas);
        default:
            throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d",
                    versionId, this.getClass().getSimpleName(), ApiKeys.METADATA.latestVersion()));
    }
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
public AbstractResponse getErrorResponse(int throttleTimeMs, Throwable e) {
    short versionId = version();
    switch (versionId) {
        case 0:
            return new SyncGroupResponse(
                    Errors.forException(e),
                    ByteBuffer.wrap(new byte[]{}));
        case 1:
            return new SyncGroupResponse(
                    throttleTimeMs,
                    Errors.forException(e),
                    ByteBuffer.wrap(new byte[]{}));
        default:
            throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d",
                    versionId, this.getClass().getSimpleName(), ApiKeys.SYNC_GROUP.latestVersion()));
    }
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
protected Struct toStruct() {
    Struct struct = new Struct(ApiKeys.SYNC_GROUP.requestSchema(version()));
    struct.set(GROUP_ID_KEY_NAME, groupId);
    struct.set(GENERATION_ID_KEY_NAME, generationId);
    struct.set(MEMBER_ID_KEY_NAME, memberId);

    List<Struct> memberArray = new ArrayList<>();
    for (Map.Entry<String, ByteBuffer> entries: groupAssignment.entrySet()) {
        Struct memberData = struct.instance(GROUP_ASSIGNMENT_KEY_NAME);
        memberData.set(MEMBER_ID_KEY_NAME, entries.getKey());
        memberData.set(MEMBER_ASSIGNMENT_KEY_NAME, entries.getValue());
        memberArray.add(memberData);
    }
    struct.set(GROUP_ASSIGNMENT_KEY_NAME, memberArray.toArray());
    return struct;
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
public ProduceResponse getErrorResponse(int throttleTimeMs, Throwable e) {
    /* In case the producer doesn't actually want any response */
    if (acks == 0)
        return null;

    Errors error = Errors.forException(e);
    Map<TopicPartition, ProduceResponse.PartitionResponse> responseMap = new HashMap<>();
    ProduceResponse.PartitionResponse partitionResponse = new ProduceResponse.PartitionResponse(error);

    for (TopicPartition tp : partitions())
        responseMap.put(tp, partitionResponse);

    short versionId = version();
    switch (versionId) {
        case 0:
        case 1:
        case 2:
        case 3:
            return new ProduceResponse(responseMap, throttleTimeMs);
        default:
            throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d",
                    versionId, this.getClass().getSimpleName(), ApiKeys.PRODUCE.latestVersion()));
    }
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Override
public Struct toStruct(short version) {
    Struct struct = new Struct(ApiKeys.OFFSET_COMMIT.responseSchema(version));
    if (struct.hasField(THROTTLE_TIME_KEY_NAME))
        struct.set(THROTTLE_TIME_KEY_NAME, throttleTimeMs);

    Map<String, Map<Integer, Errors>> topicsData = CollectionUtils.groupDataByTopic(responseData);
    List<Struct> topicArray = new ArrayList<>();
    for (Map.Entry<String, Map<Integer, Errors>> entries: topicsData.entrySet()) {
        Struct topicData = struct.instance(RESPONSES_KEY_NAME);
        topicData.set(TOPIC_KEY_NAME, entries.getKey());
        List<Struct> partitionArray = new ArrayList<>();
        for (Map.Entry<Integer, Errors> partitionEntry : entries.getValue().entrySet()) {
            Struct partitionData = topicData.instance(PARTITIONS_KEY_NAME);
            partitionData.set(PARTITION_KEY_NAME, partitionEntry.getKey());
            partitionData.set(ERROR_CODE_KEY_NAME, partitionEntry.getValue().code());
            partitionArray.add(partitionData);
        }
        topicData.set(PARTITIONS_KEY_NAME, partitionArray.toArray());
        topicArray.add(topicData);
    }
    struct.set(RESPONSES_KEY_NAME, topicArray.toArray());

    return struct;
}
 

import org.apache.kafka.common.protocol.ApiKeys; //导入依赖的package包/类
@Test
public void produceRequestToStringTest() {
    ProduceRequest request = createProduceRequest(ApiKeys.PRODUCE.latestVersion());
    assertEquals(1, request.partitionRecordsOrFail().size());
    assertFalse(request.toString(false).contains("partitionSizes"));
    assertTrue(request.toString(false).contains("numPartitions=1"));
    assertTrue(request.toString(true).contains("partitionSizes"));
    assertFalse(request.toString(true).contains("numPartitions"));

    request.clearPartitionRecords();
    try {
        request.partitionRecordsOrFail();
        fail("partitionRecordsOrFail should fail after clearPartitionRecords()");
    } catch (IllegalStateException e) {
        // OK
    }

    // `toString` should behave the same after `clearPartitionRecords`
    assertFalse(request.toString(false).contains("partitionSizes"));
    assertTrue(request.toString(false).contains("numPartitions=1"));
    assertTrue(request.toString(true).contains("partitionSizes"));
    assertFalse(request.toString(true).contains("numPartitions"));
}