public static void WriteRequestHeader(ReusableMemoryStream stream, int correlationId, ApiKey requestType, byte[] clientId)
{
stream.Write(MinusOne32, 0, 4); // reserve space for message size
BigEndianConverter.Write(stream, (short)requestType);
stream.Write(ApiVersion, 0, 2);
BigEndianConverter.Write(stream, correlationId);
BigEndianConverter.Write(stream, (short)clientId.Length);
stream.Write(clientId, 0, clientId.Length);
}
private void OnResponse(int c, ReusableMemoryStream b)
{
var ev = Response;
if (ev != null)
{
ev(this, c, b);
}
}
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 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));
}
static void WriteHeader(ReusableMemoryStream stream, long initPos)
{
var pos = stream.Position;
var size = pos - initPos;
stream.Position = initPos - 4;
BigEndianConverter.Write(stream, (int)size);
stream.Position = pos;
}
private void HandleInvalidSerializedKeyValue(ReusableMemoryStream stream)
{
_logger?.LogError("Invalid SerializedKeyValue. Length is only " + SerializedKeyValue.Length
+ " bytes. Message cannot be serialized : " + SerializedKeyValue.GetBuffer());
// Simulate an empty key & message to not send a corrupted message
stream.Write(Basics.MinusOne32, 0, 4);
stream.Write(Basics.MinusOne32, 0, 4);
}
public MockFile(string fullName, string contents)
{
this.FullName = fullName;
this.Name = Path.GetFileName(this.FullName);
this.FileProperties = FileProperties.DefaultFile;
this.contentStream = new ReusableMemoryStream(contents);
}
public void TestDeserializeFetchResponse()
{
var response = new CommonResponse <FetchPartitionResponse>
{
TopicsResponse = new []
{
new TopicData <FetchPartitionResponse>
{
TopicName = "Buffy_contre_les_zombies",
PartitionsData = new[]
{
new FetchPartitionResponse
{
ErrorCode = ErrorCode.NoError,
HighWatermarkOffset = 714,
Partition = 999999,
Messages = new List <ResponseMessage>
{
new ResponseMessage
{
Offset = 44,
Message = new Message
{
Key = Key,
Value = Value
}
}
}
}
}
}
}
};
using (var serialized = new ReusableMemoryStream(null))
{
var config = new SerializationConfig();
Basics.WriteArray(serialized, response.TopicsResponse, config);
TestCommonResponse(serialized, config, response, (p1, p2) =>
{
Assert.AreEqual(p1.Partition, p2.Partition);
Assert.AreEqual(p1.ErrorCode, p2.ErrorCode);
Assert.AreEqual(p1.HighWatermarkOffset, p2.HighWatermarkOffset);
Assert.AreEqual(p1.Messages.Count, p2.Messages.Count);
foreach (var zipped in p1.Messages.Zip(p2.Messages, Tuple.Create))
{
Assert.AreEqual(zipped.Item1.Offset, zipped.Item2.Offset);
CollectionAssert.AreEqual(zipped.Item1.Message.Key as byte[], zipped.Item2.Message.Key as byte[]);
CollectionAssert.AreEqual(zipped.Item1.Message.Value as byte[], zipped.Item2.Message.Value as byte[]);
}
return(true);
});
}
}
/// <summary>
/// The serialize event.
/// </summary>
/// <param name="eventData"> The event data.</param>
/// <returns>The serialized event.</returns>
/// <exception cref="T:System.IO.InvalidDataException">
/// A value can not be serialized.
///</exception>
///<exception cref="T:System.ArrayTypeMismatchException">
/// A collection with different types can not be serialized.
///</exception>
public byte[] SerializeEventData(EventData eventData)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
this.SerializeEventData(stream, eventData);
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, RtsMessageType.Event, false);
return(stream.ToArray());
}
}
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 static ReusableMemoryStream WriteMessageLength(ReusableMemoryStream stream)
{
stream.Position = 0;
var len = (int)stream.Length - 4; // -4 because do not count size flag itself
// write message length to the head
// TODO: use seek?
BigEndianConverter.Write(stream, len);
return(stream);
}
/// <summary>
/// Serializes an operation request.
/// </summary>
/// <param name="operationRequest">The operation request.</param>
/// <returns>a serialized operation request message</returns>
public byte[] SerializeOperationRequest(OperationRequest operationRequest)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.WriteByte(0xf3);
stream.WriteByte(2);
SerializeOperationRequest(stream, operationRequest);
return(stream.ToArray());
}
}
// 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);
}
}
/// <summary>
/// The serialize event.
/// </summary>
/// <param name="eventData">The event data.</param>
/// <returns>The serialized event.</returns>
/// <exception cref="T:System.IO.InvalidDataException">
///A value can not be serialized.
///</exception>
///<exception cref="T:System.ArrayTypeMismatchException">
/// A collection with different types can not be serialized.
///</exception>
public byte[] SerializeEventData(EventData eventData)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.WriteByte(0xf3);
stream.WriteByte(4);
SerializeEventData(stream, eventData);
return(stream.ToArray());
}
}
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.
}
}
private void SerializeMessageSet(ReusableMemoryStream stream, Serializers serializers, MessageVersion version)
{
Basics.WriteWithSize(stream, Messages,
new SerializationInfo
{
Serializers = serializers,
CompressionCodec = CompressionCodec,
MessageVersion = version
}, SerializeMessages);
}
/// <summary>
/// Serializes an <see cref="T:Photon.SocketServer.OperationResponse"/>.
/// </summary>
/// <param name="operationResponse">The operation response to serialize.</param>
/// <param name="messageType">
/// The message type.
/// Should be eiter <see
/// cref="F:Photon.SocketServer.Rpc.Protocols.RtsMessageType.OperationResponse"/> or <see
/// cref="F:Photon.SocketServer.Rpc.Protocols.RtsMessageType.InternalOperationResponse"/>.
/// </param>
/// <returns>A serialized operation response.</returns>
private byte[] SerializeOperationResponse(OperationResponse operationResponse, RtsMessageType messageType)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.WriteByte(0xf3);
stream.WriteByte((byte)messageType);
SerializeOperationResponse(stream, operationResponse);
return(stream.ToArray());
}
}
public static object DeserializeByteArray(ReusableMemoryStream stream, IDeserializer deserializer)
{
var len = BigEndianConverter.ReadInt32(stream);
if (len == -1)
{
return(null);
}
return(deserializer.Deserialize(stream, len));
}
// 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);
}
}
private RetryWrapper <GitObjectTaskResult> .InvocationResult StreamObjects(
IEnumerable <string> objectIds,
Func <int, GitEndPointResponseData, RetryWrapper <GitObjectTaskResult> .CallbackResult> onSuccess,
Action <RetryWrapper <GitObjectTaskResult> .ErrorEventArgs> onFailure)
{
for (int i = 0; i < this.RetryConfig.MaxAttempts; ++i)
{
try
{
using (ReusableMemoryStream mem = new ReusableMemoryStream(string.Empty))
using (BinaryWriter writer = new BinaryWriter(mem))
{
writer.Write(new byte[] { (byte)'G', (byte)'V', (byte)'F', (byte)'S', (byte)' ', 1 });
foreach (string objectId in objectIds)
{
string contents = this.objectResolver(objectId);
if (!string.IsNullOrEmpty(contents))
{
writer.Write(this.SHA1BytesFromString(objectId));
byte[] bytes = Encoding.UTF8.GetBytes(contents);
writer.Write((long)bytes.Length);
writer.Write(bytes);
}
else
{
writer.Write(new byte[20]);
writer.Write(0L);
}
}
writer.Write(new byte[20]);
writer.Flush();
mem.Seek(0, SeekOrigin.Begin);
using (GitEndPointResponseData response = new GitEndPointResponseData(
HttpStatusCode.OK,
GSDConstants.MediaTypes.CustomLooseObjectsMediaType,
mem,
message: null,
onResponseDisposed: null))
{
RetryWrapper <GitObjectTaskResult> .CallbackResult result = onSuccess(1, response);
return(new RetryWrapper <GitObjectTaskResult> .InvocationResult(1, true, result.Result));
}
}
}
catch
{
continue;
}
}
return(new RetryWrapper <GitObjectTaskResult> .InvocationResult(this.RetryConfig.MaxAttempts, null));
}
static void CheckCrc(int crc, ReusableMemoryStream stream, long crcStartPos)
{
var computedCrc = (int)Crc32.Compute(stream, crcStartPos, stream.Position - crcStartPos);
if (computedCrc != crc)
{
throw new CrcException(
string.Format("Corrupt message: CRC32 does not match. Calculated {0} but got {1}", computedCrc,
crc));
}
}
public byte[] SerializeOperationRequest(OperationRequest operationRequest)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.Position = this.headerSize;
SerializeOperationRequest(stream, operationRequest);
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, RtsMessageType.Operation, false);
return(stream.ToArray());
}
}
private byte[] SerializeOperationResponse(OperationResponse operationResponse, RtsMessageType messageType)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.Position = this.headerSize;
SerializeOperationResponse(stream, operationResponse);
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, messageType, false);
return(stream.ToArray());
}
}
/// <summary>
/// The serialize init request.
/// </summary>
/// <param name="headerWriter">The header Writer.</param>
/// <param name="protocolVersion">The protocol version</param>
/// <param name="clientVersion">The client version.</param>
/// <param name="applicationId">The application id.</param>
/// <returns>the serialized init request</returns>
internal static byte[] SerializeInitRequest(IRtsMessageHeaderConverter headerWriter, Version protocolVersion, Version clientVersion, string applicationId)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.Position = headerWriter.HeaderSize;
new RtsInitMessage(new byte[] { (byte)protocolVersion.Major, (byte)protocolVersion.Minor }, new byte[] { (byte)clientVersion.Major, (byte)clientVersion.Minor, (byte)clientVersion.Build }, applicationId).Serialize(stream);
stream.Position = 0L;
headerWriter.WriteHeader(stream, RtsMessageType.Init, false);
return(stream.ToArray());
}
}
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 static void SerializeStringWithVarIntSize(ReusableMemoryStream stream, string s)
{
if (s == null)
{
stream.Write(MinusOneVarInt, 0, MinusOneVarInt.Length);
return;
}
VarIntConverter.Write(stream, _stringSer.SerializedSize(s));
_stringSer.Serialize(s, stream);
}
public static void SerializeBytesWithVarIntSize(ReusableMemoryStream stream, byte[] b)
{
if (b == null)
{
stream.Write(MinusOneVarInt, 0, MinusOneVarInt.Length);
return;
}
VarIntConverter.Write(stream, b.Length);
stream.Write(b, 0, b.Length);
}
public static void SerializeBytes(ReusableMemoryStream stream, byte[] b)
{
if (b == null)
{
stream.Write(MinusOne32, 0, 4);
return;
}
BigEndianConverter.Write(stream, b.Length);
stream.Write(b, 0, b.Length);
}
/// <summary>
/// The serialize init response.
/// </summary>
/// <param name="headerWriter">The header writer.</param>
/// <returns> the init response</returns>
internal static byte[] SerializeInitResponse(IRtsMessageHeaderConverter headerWriter)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.Position = headerWriter.HeaderSize;
RtsInitResponseMessage.Serialize(stream);
stream.Position = 0L;
headerWriter.WriteHeader(stream, RtsMessageType.InitResponse, false);
return(stream.ToArray());
}
}
