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()); } }