kafka_protocol

0.3.2
4.3.4 4.3.3 4.3.2 4.3.1 4.3.0 4.2.9 4.2.8 4.2.7 4.2.6 4.2.5 4.2.4 4.2.3 4.2.2 4.2.1 4.2.0 4.1.10 4.1.9 4.1.8 4.1.7 4.1.6 4.1.5 4.1.4 4.1.3 4.1.2 4.1.1 4.1.0 4.0.3 4.0.2 4.0.1 3.0.1 3.0.0 2.4.1 2.3.6 2.3.5 2.3.4 2.3.3 2.3.2 2.3.1 2.3.0 2.2.9 2.2.8 2.2.7 2.2.6 2.2.5 2.2.4 2.2.3 2.2.2 2.2.1 2.2.0 2.1.2 2.1.1 2.1.0 2.0.1 2.0.0 1.1.3 1.1.2 1.1.1 1.1.0 1.0.0 0.9.2 0.9.1 0.9.0 0.8.0 0.7.8 0.7.7 0.7.6 0.7.5 0.7.4 0.7.3 0.7.2 0.7.1 0.7.0 0.6.0 0.4.0 0.3.2 0.3.1 0.2.3
Kafka protocol library for Erlang/Elixir
HexDocs
Current section
Files
Jump to
Readme 77 Versions 0 Dependencies 2 Dependants Files Activity
kafka_protocol src kpro_structs.erl
Raw
src/kpro_structs.erl

%% generated code, do not edit!
-module(kpro_structs).

-export([encode/1]).

-export([decode/2]).

-include("kpro.hrl").

encode(#kpro_ProduceRequest{} = R) ->
    [enc({int16, R#kpro_ProduceRequest.requiredAcks}),
     enc({int32, R#kpro_ProduceRequest.timeout}),
     enc({array, R#kpro_ProduceRequest.topicMessageSet_L})];
encode(#kpro_TopicMessageSet{} = R) ->
    [enc({string, R#kpro_TopicMessageSet.topicName}),
     enc({array,
	  R#kpro_TopicMessageSet.partitionMessageSet_L})];
encode(#kpro_PartitionMessageSet{} = R) ->
    [enc({int32, R#kpro_PartitionMessageSet.partition}),
     enc({int32, R#kpro_PartitionMessageSet.messageSetSize}),
     enc({array, R#kpro_PartitionMessageSet.message_L})];
encode(#kpro_Message{} = R) ->
    [enc({int64, R#kpro_Message.offset}),
     enc({int32, R#kpro_Message.messageSize}),
     enc({int32, R#kpro_Message.crc}),
     enc({int8, R#kpro_Message.magicByte}),
     enc({int8, R#kpro_Message.attributes}),
     enc({bytes, R#kpro_Message.key}),
     enc({bytes, R#kpro_Message.value})];
encode(#kpro_FetchRequest{} = R) ->
    [enc({int32, R#kpro_FetchRequest.replicaId}),
     enc({int32, R#kpro_FetchRequest.maxWaitTime}),
     enc({int32, R#kpro_FetchRequest.minBytes}),
     enc({array, R#kpro_FetchRequest.fetchRequestTopic_L})];
encode(#kpro_FetchRequestTopic{} = R) ->
    [enc({string, R#kpro_FetchRequestTopic.topicName}),
     enc({array,
	  R#kpro_FetchRequestTopic.fetchRequestPartition_L})];
encode(#kpro_FetchRequestPartition{} = R) ->
    [enc({int32, R#kpro_FetchRequestPartition.partition}),
     enc({int64, R#kpro_FetchRequestPartition.fetchOffset}),
     enc({int32, R#kpro_FetchRequestPartition.maxBytes})];
encode(#kpro_OffsetRequest{} = R) ->
    [enc({int32, R#kpro_OffsetRequest.replicaId}),
     enc({array,
	  R#kpro_OffsetRequest.offsetRequestTopic_L})];
encode(#kpro_OffsetRequestTopic{} = R) ->
    [enc({string, R#kpro_OffsetRequestTopic.topicName}),
     enc({array,
	  R#kpro_OffsetRequestTopic.offsetRequestPartition_L})];
encode(#kpro_OffsetRequestPartition{} = R) ->
    [enc({int32, R#kpro_OffsetRequestPartition.partition}),
     enc({int64, R#kpro_OffsetRequestPartition.time}),
     enc({int32,
	  R#kpro_OffsetRequestPartition.maxNumberOfOffsets})];
encode(#kpro_MetadataRequest{} = R) ->
    [enc({{array, string},
	  R#kpro_MetadataRequest.topicName_L})];
encode(#kpro_OffsetCommitRequestV2{} = R) ->
    [enc({string,
	  R#kpro_OffsetCommitRequestV2.consumerGroupId}),
     enc({int32,
	  R#kpro_OffsetCommitRequestV2.consumerGroupGenerationId}),
     enc({string, R#kpro_OffsetCommitRequestV2.consumerId}),
     enc({int64,
	  R#kpro_OffsetCommitRequestV2.retentionTime}),
     enc({array,
	  R#kpro_OffsetCommitRequestV2.oCReqV2Topic_L})];
encode(#kpro_OCReqV2Topic{} = R) ->
    [enc({string, R#kpro_OCReqV2Topic.topicName}),
     enc({array, R#kpro_OCReqV2Topic.oCReqV2Partition_L})];
encode(#kpro_OCReqV2Partition{} = R) ->
    [enc({int32, R#kpro_OCReqV2Partition.partition}),
     enc({int64, R#kpro_OCReqV2Partition.offset}),
     enc({string, R#kpro_OCReqV2Partition.metadata})];
encode(#kpro_OffsetCommitRequestV1{} = R) ->
    [enc({string,
	  R#kpro_OffsetCommitRequestV1.consumerGroupId}),
     enc({int32,
	  R#kpro_OffsetCommitRequestV1.consumerGroupGenerationId}),
     enc({string, R#kpro_OffsetCommitRequestV1.consumerId}),
     enc({array,
	  R#kpro_OffsetCommitRequestV1.oCReqV1Topic_L})];
encode(#kpro_OCReqV1Topic{} = R) ->
    [enc({string, R#kpro_OCReqV1Topic.topicName}),
     enc({array, R#kpro_OCReqV1Topic.oCReqV1Partition_L})];
encode(#kpro_OCReqV1Partition{} = R) ->
    [enc({int32, R#kpro_OCReqV1Partition.partition}),
     enc({int64, R#kpro_OCReqV1Partition.offset}),
     enc({int64, R#kpro_OCReqV1Partition.timeStamp}),
     enc({string, R#kpro_OCReqV1Partition.metadata})];
encode(#kpro_OffsetCommitRequestV0{} = R) ->
    [enc({string,
	  R#kpro_OffsetCommitRequestV0.consumerGroupId}),
     enc({array,
	  R#kpro_OffsetCommitRequestV0.oCReqV0Topic_L})];
encode(#kpro_OCReqV0Topic{} = R) ->
    [enc({string, R#kpro_OCReqV0Topic.topicName}),
     enc({array, R#kpro_OCReqV0Topic.oCReqV0Partition_L})];
encode(#kpro_OCReqV0Partition{} = R) ->
    [enc({int32, R#kpro_OCReqV0Partition.partition}),
     enc({int64, R#kpro_OCReqV0Partition.offset}),
     enc({string, R#kpro_OCReqV0Partition.metadata})];
encode(#kpro_OffsetFetchRequest{} = R) ->
    [enc({string, R#kpro_OffsetFetchRequest.consumerGroup}),
     enc({array, R#kpro_OffsetFetchRequest.oFReqTopic_L})];
encode(#kpro_OFReqTopic{} = R) ->
    [enc({string, R#kpro_OFReqTopic.topicName}),
     enc({{array, int32}, R#kpro_OFReqTopic.partition_L})];
encode(#kpro_GroupCoordinatorRequest{} = R) ->
    [enc({string, R#kpro_GroupCoordinatorRequest.groupId})];
encode(#kpro_JoinGroupRequest{} = R) ->
    [enc({string, R#kpro_JoinGroupRequest.groupId}),
     enc({int32, R#kpro_JoinGroupRequest.sessionTimeout}),
     enc({string, R#kpro_JoinGroupRequest.memberId}),
     enc({string, R#kpro_JoinGroupRequest.protocolType}),
     enc({array, R#kpro_JoinGroupRequest.groupProtocol_L})];
encode(#kpro_GroupProtocol{} = R) ->
    [enc({string, R#kpro_GroupProtocol.protocolName}),
     enc({bytes, R#kpro_GroupProtocol.protocolMetadata})];
encode(#kpro_HeartbeatRequest{} = R) ->
    [enc({string, R#kpro_HeartbeatRequest.groupId}),
     enc({int32, R#kpro_HeartbeatRequest.generationId}),
     enc({string, R#kpro_HeartbeatRequest.memberId})];
encode(#kpro_LeaveGroupRequest{} = R) ->
    [enc({string, R#kpro_LeaveGroupRequest.groupId}),
     enc({string, R#kpro_LeaveGroupRequest.memberId})];
encode(#kpro_SyncGroupRequest{} = R) ->
    [enc({string, R#kpro_SyncGroupRequest.groupId}),
     enc({int32, R#kpro_SyncGroupRequest.generationId}),
     enc({string, R#kpro_SyncGroupRequest.memberId}),
     enc({array,
	  R#kpro_SyncGroupRequest.groupAssignment_L})];
encode(#kpro_GroupAssignment{} = R) ->
    [enc({string, R#kpro_GroupAssignment.memberId}),
     enc({bytes, R#kpro_GroupAssignment.memberAssignment})];
encode(#kpro_DescribeGroupsRequest{} = R) ->
    [enc({{array, string},
	  R#kpro_DescribeGroupsRequest.groupId_L})];
encode(#kpro_ListGroupsRequest{}) -> [];
encode(#kpro_ConsumerGroupProtocolMetadata{} = R) ->
    [enc({int16,
	  R#kpro_ConsumerGroupProtocolMetadata.version}),
     enc({{array, string},
	  R#kpro_ConsumerGroupProtocolMetadata.topicName_L}),
     enc({bytes,
	  R#kpro_ConsumerGroupProtocolMetadata.userData})];
encode(#kpro_ConsumerGroupMemberAssignment{} = R) ->
    [enc({int16,
	  R#kpro_ConsumerGroupMemberAssignment.version}),
     enc({array,
	  R#kpro_ConsumerGroupMemberAssignment.consumerGroupPartitionAssignment_L}),
     enc({bytes,
	  R#kpro_ConsumerGroupMemberAssignment.userData})];
encode(#kpro_ConsumerGroupPartitionAssignment{} = R) ->
    [enc({string,
	  R#kpro_ConsumerGroupPartitionAssignment.topicName}),
     enc({{array, int32},
	  R#kpro_ConsumerGroupPartitionAssignment.partition_L})].

decode(kpro_ProduceResponse, Bin) ->
    Fields = [{produceResponseTopic_L,
	       {array, kpro_ProduceResponseTopic}}],
    kpro:decode_fields(kpro_ProduceResponse, Fields, Bin);
decode(kpro_ProduceResponseTopic, Bin) ->
    Fields = [{topicName, string},
	      {produceResponsePartition_L,
	       {array, kpro_ProduceResponsePartition}}],
    kpro:decode_fields(kpro_ProduceResponseTopic, Fields,
		       Bin);
decode(kpro_ProduceResponsePartition, Bin) ->
    Fields = [{partition, int32}, {errorCode, int16},
	      {offset, int64}],
    kpro:decode_fields(kpro_ProduceResponsePartition,
		       Fields, Bin);
decode(kpro_FetchResponse, Bin) ->
    Fields = [{fetchResponseTopic_L,
	       {array, kpro_FetchResponseTopic}}],
    kpro:decode_fields(kpro_FetchResponse, Fields, Bin);
decode(kpro_FetchResponseTopic, Bin) ->
    Fields = [{topicName, string},
	      {fetchResponsePartition_L,
	       {array, kpro_FetchResponsePartition}}],
    kpro:decode_fields(kpro_FetchResponseTopic, Fields,
		       Bin);
decode(kpro_FetchResponsePartition, Bin) ->
    Fields = [{partition, int32}, {errorCode, int16},
	      {highWatermarkOffset, int64}, {messageSetSize, int32},
	      {message_L, {array, kpro_Message}}],
    kpro:decode_fields(kpro_FetchResponsePartition, Fields,
		       Bin);
decode(kpro_Message, Bin) ->
    Fields = [{offset, int64}, {messageSize, int32},
	      {crc, int32}, {magicByte, int8}, {attributes, int8},
	      {key, bytes}, {value, bytes}],
    kpro:decode_fields(kpro_Message, Fields, Bin);
decode(kpro_OffsetResponse, Bin) ->
    Fields = [{topicOffsets_L, {array, kpro_TopicOffsets}}],
    kpro:decode_fields(kpro_OffsetResponse, Fields, Bin);
decode(kpro_TopicOffsets, Bin) ->
    Fields = [{topicName, string},
	      {partitionOffsets_L, {array, kpro_PartitionOffsets}}],
    kpro:decode_fields(kpro_TopicOffsets, Fields, Bin);
decode(kpro_PartitionOffsets, Bin) ->
    Fields = [{partition, int32}, {errorCode, int16},
	      {offset_L, {array, int64}}],
    kpro:decode_fields(kpro_PartitionOffsets, Fields, Bin);
decode(kpro_MetadataResponse, Bin) ->
    Fields = [{broker_L, {array, kpro_Broker}},
	      {topicMetadata_L, {array, kpro_TopicMetadata}}],
    kpro:decode_fields(kpro_MetadataResponse, Fields, Bin);
decode(kpro_Broker, Bin) ->
    Fields = [{nodeId, int32}, {host, string},
	      {port, int32}],
    kpro:decode_fields(kpro_Broker, Fields, Bin);
decode(kpro_TopicMetadata, Bin) ->
    Fields = [{errorCode, int16}, {topicName, string},
	      {partitionMetadata_L, {array, kpro_PartitionMetadata}}],
    kpro:decode_fields(kpro_TopicMetadata, Fields, Bin);
decode(kpro_PartitionMetadata, Bin) ->
    Fields = [{errorCode, int16}, {partition, int32},
	      {leader, int32}, {replicas, {array, int32}},
	      {isr, {array, int32}}],
    kpro:decode_fields(kpro_PartitionMetadata, Fields, Bin);
decode(kpro_OffsetCommitResponse, Bin) ->
    Fields = [{oCRspTopic_L, {array, kpro_OCRspTopic}}],
    kpro:decode_fields(kpro_OffsetCommitResponse, Fields,
		       Bin);
decode(kpro_OCRspTopic, Bin) ->
    Fields = [{topicName, string},
	      {oCRspPartition_L, {array, kpro_OCRspPartition}}],
    kpro:decode_fields(kpro_OCRspTopic, Fields, Bin);
decode(kpro_OCRspPartition, Bin) ->
    Fields = [{partition, int32}, {errorCode, int16}],
    kpro:decode_fields(kpro_OCRspPartition, Fields, Bin);
decode(kpro_OffsetFetchResponse, Bin) ->
    Fields = [{topicOffset_L, {array, kpro_TopicOffset}}],
    kpro:decode_fields(kpro_OffsetFetchResponse, Fields,
		       Bin);
decode(kpro_TopicOffset, Bin) ->
    Fields = [{topicName, string},
	      {partitionOffset_L, {array, kpro_PartitionOffset}}],
    kpro:decode_fields(kpro_TopicOffset, Fields, Bin);
decode(kpro_PartitionOffset, Bin) ->
    Fields = [{partition, int32}, {offset, int64},
	      {metadata, string}, {errorCode, int16}],
    kpro:decode_fields(kpro_PartitionOffset, Fields, Bin);
decode(kpro_GroupCoordinatorResponse, Bin) ->
    Fields = [{errorCode, int16}, {coordinatorId, int32},
	      {coordinatorHost, string}, {coordinatorPort, int32}],
    kpro:decode_fields(kpro_GroupCoordinatorResponse,
		       Fields, Bin);
decode(kpro_JoinGroupResponse, Bin) ->
    Fields = [{errorCode, int16}, {generationId, int32},
	      {protocolName, string}, {leaderId, string},
	      {memberId, string},
	      {groupMemberMetadata_L,
	       {array, kpro_GroupMemberMetadata}}],
    kpro:decode_fields(kpro_JoinGroupResponse, Fields, Bin);
decode(kpro_GroupMemberMetadata, Bin) ->
    Fields = [{memberId, string},
	      {protocolMetadata, bytes}],
    kpro:decode_fields(kpro_GroupMemberMetadata, Fields,
		       Bin);
decode(kpro_HeartbeatResponse, Bin) ->
    Fields = [{errorCode, int16}],
    kpro:decode_fields(kpro_HeartbeatResponse, Fields, Bin);
decode(kpro_LeaveGroupResponse, Bin) ->
    Fields = [{errorCode, int16}],
    kpro:decode_fields(kpro_LeaveGroupResponse, Fields,
		       Bin);
decode(kpro_SyncGroupResponse, Bin) ->
    Fields = [{errorCode, int16},
	      {memberAssignment, bytes}],
    kpro:decode_fields(kpro_SyncGroupResponse, Fields, Bin);
decode(kpro_DescribeGroupsResponse, Bin) ->
    Fields = [{groupDescription_L,
	       {array, kpro_GroupDescription}}],
    kpro:decode_fields(kpro_DescribeGroupsResponse, Fields,
		       Bin);
decode(kpro_GroupDescription, Bin) ->
    Fields = [{errorCode, int16}, {groupId, string},
	      {state, string}, {protocolType, string},
	      {protocol, string},
	      {groupMemberDescription_L,
	       {array, kpro_GroupMemberDescription}}],
    kpro:decode_fields(kpro_GroupDescription, Fields, Bin);
decode(kpro_GroupMemberDescription, Bin) ->
    Fields = [{memberId, string}, {clientId, string},
	      {clientHost, string}, {memberMetadata, bytes},
	      {memberAssignment, bytes}],
    kpro:decode_fields(kpro_GroupMemberDescription, Fields,
		       Bin);
decode(kpro_ListGroupsResponse, Bin) ->
    Fields = [{errorCode, int16},
	      {groupInfo_L, {array, kpro_GroupInfo}}],
    kpro:decode_fields(kpro_ListGroupsResponse, Fields,
		       Bin);
decode(kpro_GroupInfo, Bin) ->
    Fields = [{groupId, string}, {protocolType, string}],
    kpro:decode_fields(kpro_GroupInfo, Fields, Bin);
decode(kpro_ConsumerGroupProtocolMetadata, Bin) ->
    Fields = [{version, int16},
	      {topicName_L, {array, string}}, {userData, bytes}],
    kpro:decode_fields(kpro_ConsumerGroupProtocolMetadata,
		       Fields, Bin);
decode(kpro_ConsumerGroupMemberAssignment, Bin) ->
    Fields = [{version, int16},
	      {consumerGroupPartitionAssignment_L,
	       {array, kpro_ConsumerGroupPartitionAssignment}},
	      {userData, bytes}],
    kpro:decode_fields(kpro_ConsumerGroupMemberAssignment,
		       Fields, Bin);
decode(kpro_ConsumerGroupPartitionAssignment, Bin) ->
    Fields = [{topicName, string},
	      {partition_L, {array, int32}}],
    kpro:decode_fields(kpro_ConsumerGroupPartitionAssignment,
		       Fields, Bin).

enc(X) -> kpro:encode(X).
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT