public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
MemberId = Basics.DeserializeString(stream);
BigEndianConverter.ReadInt32(stream);
Metadata = new ConsumerGroupProtocolMetadata();
Metadata.Deserialize(stream, null, Basics.ApiVersion.Ignored);
}
public void Deserialize(ReusableMemoryStream stream, object extra, Basics.ApiVersion version)
{
Partition = BigEndianConverter.ReadInt32(stream);
ErrorCode = (ErrorCode)BigEndianConverter.ReadInt16(stream);
HighWatermarkOffset = BigEndianConverter.ReadInt64(stream);
Messages = DeserializeMessageSet(stream, extra as Deserializers);
}
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
Basics.SerializeString(stream, MemberId);
var pm = Metadata;
Basics.WriteWithSize(stream, s => pm.Serialize(s, null, Basics.ApiVersion.Ignored));
}
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
Basics.SerializeString(stream, ProtocolName);
var pm = ProtocolMetadata;
Basics.WriteSizeInBytes(stream, s => pm.Serialize(s, null, Basics.ApiVersion.Ignored));
}
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
BigEndianConverter.Write(stream, (short)ErrorCode);
BigEndianConverter.Write(stream, CoordinatorId);
Basics.SerializeString(stream, CoordinatorHost);
BigEndianConverter.Write(stream, CoordinatorPort);
}
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
Basics.SerializeString(stream, MemberId);
var ma = MemberAssignment;
Basics.WriteSizeInBytes(stream, s => ma.Serialize(s, null, Basics.ApiVersion.Ignored));
}
public void SerializeBody(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
Basics.SerializeString(stream, GroupId);
BigEndianConverter.Write(stream, GenerationId);
Basics.SerializeString(stream, MemberId);
Basics.WriteArray(stream, GroupAssignment);
}
public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
ErrorCode = (ErrorCode)BigEndianConverter.ReadInt16(stream);
CoordinatorId = BigEndianConverter.ReadInt32(stream);
CoordinatorHost = Basics.DeserializeString(stream);
CoordinatorPort = BigEndianConverter.ReadInt32(stream);
}
internal CompressionCodec Compression; // Only used in test for serializing
#region Deserialization
public void Deserialize(ReusableMemoryStream stream, object extra, Basics.ApiVersion version)
{
Partition = BigEndianConverter.ReadInt32(stream);
ErrorCode = (ErrorCode)BigEndianConverter.ReadInt16(stream);
HighWatermarkOffset = BigEndianConverter.ReadInt64(stream);
if (version >= Basics.ApiVersion.V4)
{
LastStableOffset = BigEndianConverter.ReadInt64(stream);
AbortedTransactions = Basics.DeserializeArray <AbortedTransaction>(stream);
}
if (version >= Basics.ApiVersion.V5)
{
LogStartOffset = BigEndianConverter.ReadInt64(stream);
}
try
{
Messages = version >= Basics.ApiVersion.V3
? DeserializeRecordBatch(stream, extra as Deserializers)
: DeserializeMessageSet(stream, extra as Deserializers);
}
catch (ProtocolException pEx)
{
pEx.Partition = Partition;
throw;
}
}
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
BigEndianConverter.Write(stream, Partition);
BigEndianConverter.Write(stream, Offset);
Basics.SerializeString(stream, Metadata);
BigEndianConverter.Write(stream, (short)ErrorCode);
}
public void SerializeBody(ReusableMemoryStream stream, object extra, Basics.ApiVersion version)
{
stream.Write(Basics.MinusOne32, 0, 4); // ReplicaId, non clients that are not a broker must use -1
BigEndianConverter.Write(stream, MaxWaitTime);
BigEndianConverter.Write(stream, MinBytes);
Basics.WriteArray(stream, TopicsData, extra, version);
}
public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
Partition = BigEndianConverter.ReadInt32(stream);
Offset = BigEndianConverter.ReadInt64(stream);
Metadata = Basics.DeserializeString(stream);
ErrorCode = (ErrorCode)BigEndianConverter.ReadInt16(stream);
}
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
BigEndianConverter.Write(stream, (short)ErrorCode);
var ma = MemberAssignment;
Basics.WriteWithSize(stream, s => ma.Serialize(s, null, Basics.ApiVersion.Ignored));
}
public void Deserialize(ReusableMemoryStream stream, object extra, Basics.ApiVersion version)
{
TopicName = Basics.DeserializeString(stream);
var count = BigEndianConverter.ReadInt32(stream);
var array = new TPartitionData[count];
object pdExtra = null;
if (extra != null)
{
var config = extra as SerializationConfig;
pdExtra = config.GetDeserializersForTopic(TopicName);
}
try
{
for (int i = 0; i < count; ++i)
{
array[i] = new TPartitionData();
array[i].Deserialize(stream, pdExtra, version);
}
PartitionsData = array;
}
catch (ProtocolException pEx)
{
pEx.Topic = TopicName;
throw;
}
}
public void Deserialize(ReusableMemoryStream stream, object extra, Basics.ApiVersion version)
{
ProducePartitionResponse.Deserialize(stream, extra, version);
if (version > Basics.ApiVersion.V0)
{
ThrottleTime = BigEndianConverter.ReadInt32(stream);
}
}
public void Serialize(ReusableMemoryStream stream, object extra, Basics.ApiVersion version)
{
ProducePartitionResponse.Serialize(stream, extra, version);
if (version > Basics.ApiVersion.V0)
{
BigEndianConverter.Write(stream, ThrottleTime);
}
}
// Used only in tests
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
BigEndianConverter.Write(stream, (short)ErrorCode);
BigEndianConverter.Write(stream, Id);
BigEndianConverter.Write(stream, Leader);
Basics.WriteArray(stream, Replicas, BigEndianConverter.Write);
Basics.WriteArray(stream, Isr, BigEndianConverter.Write);
}
public void SerializeBody(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
Basics.SerializeString(stream, ConsumerGroupId);
BigEndianConverter.Write(stream, ConsumerGroupGenerationId);
Basics.SerializeString(stream, ConsumerId);
BigEndianConverter.Write(stream, RetentionTime);
Basics.WriteArray(stream, TopicsData);
}
public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
ErrorCode = (ErrorCode)BigEndianConverter.ReadInt16(stream);
Id = BigEndianConverter.ReadInt32(stream);
Leader = BigEndianConverter.ReadInt32(stream);
Replicas = Basics.DeserializeArray(stream, BigEndianConverter.ReadInt32);
Isr = Basics.DeserializeArray(stream, BigEndianConverter.ReadInt32);
}
public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
ErrorCode = (ErrorCode)BigEndianConverter.ReadInt16(stream);
GenerationId = BigEndianConverter.ReadInt32(stream);
GroupProtocol = Basics.DeserializeString(stream);
LeaderId = Basics.DeserializeString(stream);
MemberId = Basics.DeserializeString(stream);
GroupMembers = Basics.DeserializeArray <GroupMember>(stream);
}
public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion version)
{
Partition = BigEndianConverter.ReadInt32(stream);
Time = BigEndianConverter.ReadInt64(stream);
if (version == Basics.ApiVersion.V0)
{
MaxNumberOfOffsets = BigEndianConverter.ReadInt32(stream);
}
}
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion version)
{
BigEndianConverter.Write(stream, Partition);
BigEndianConverter.Write(stream, Time);
if (version == Basics.ApiVersion.V0)
{
BigEndianConverter.Write(stream, MaxNumberOfOffsets);
}
}
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
BigEndianConverter.Write(stream, (short)ErrorCode);
BigEndianConverter.Write(stream, GenerationId);
Basics.SerializeString(stream, GroupProtocol);
Basics.SerializeString(stream, LeaderId);
Basics.SerializeString(stream, MemberId);
Basics.WriteArray(stream, GroupMembers, (s, m) => m.Serialize(s, null, Basics.ApiVersion.Ignored));
}
public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion version)
{
Partition = BigEndianConverter.ReadInt32(stream);
ErrorCode = (ErrorCode)BigEndianConverter.ReadInt16(stream);
Offset = BigEndianConverter.ReadInt64(stream);
if (version >= Basics.ApiVersion.V2)
{
Timestamp = BigEndianConverter.ReadInt64(stream);
}
}
public void SerializeBody(ReusableMemoryStream stream, object extra, Basics.ApiVersion version)
{
if (version >= Basics.ApiVersion.V3)
{
Basics.SerializeString(stream, TransactionalID);
}
BigEndianConverter.Write(stream, RequiredAcks);
BigEndianConverter.Write(stream, Timeout);
Basics.WriteArray(stream, TopicsData, extra, version);
}
public long LogStartOffset; // Required by the protocol, but will always be zero in our case (i.e. we are consumers, not brokers)
#region Serialization
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion version)
{
BigEndianConverter.Write(stream, Partition);
BigEndianConverter.Write(stream, FetchOffset);
BigEndianConverter.Write(stream, MaxBytes);
if (version >= Basics.ApiVersion.V5)
{
stream.Write(Basics.Zero64, 0, 8); // log_start_offset is 0 for consumer, only used by follower.
}
}
// Used only in tests
public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion version)
{
Partition = BigEndianConverter.ReadInt32(stream);
FetchOffset = BigEndianConverter.ReadInt64(stream);
MaxBytes = BigEndianConverter.ReadInt32(stream);
if (version >= Basics.ApiVersion.V5)
{
LogStartOffset = BigEndianConverter.ReadInt64(stream);
}
}
// Used only in tests
public void Serialize(ReusableMemoryStream stream, object _, Basics.ApiVersion version)
{
BigEndianConverter.Write(stream, Partition);
BigEndianConverter.Write(stream, (short)ErrorCode);
BigEndianConverter.Write(stream, Offset);
if (version >= Basics.ApiVersion.V2)
{
BigEndianConverter.Write(stream, Timestamp);
}
}
public void Serialize(ReusableMemoryStream stream, object extra, Basics.ApiVersion version)
{
BigEndianConverter.Write(stream, Partition);
Basics.WriteSizeInBytes(stream, Messages,
new SerializationInfo
{
Serializers = extra as Serializers,
CompressionCodec = CompressionCodec,
MessageVersion = version >= Basics.ApiVersion.V2 ? MessageVersion.V1 : MessageVersion.V0
}, SerializeMessages);
}
public void Deserialize(ReusableMemoryStream stream, object _, Basics.ApiVersion __)
{
ErrorCode = (ErrorCode)BigEndianConverter.ReadInt16(stream);
MemberAssignment = new ConsumerGroupMemberAssignment
{
PartitionAssignments = Enumerable.Empty <TopicData <PartitionAssignment> >()
};
if (BigEndianConverter.ReadInt32(stream) > 0)
{
MemberAssignment.Deserialize(stream, null, Basics.ApiVersion.Ignored);
}
}
