private static void Uncompress(ReusableMemoryStream uncompressed, byte[] body, int offset, int length, CompressionCodec codec) { try { if (codec == CompressionCodec.Snappy) { #if NET_CORE throw new NotImplementedException(); #else uncompressed.SetLength(SnappyCodec.GetUncompressedLength(body, offset, length)); SnappyCodec.Uncompress(body, offset, length, uncompressed.GetBuffer(), 0); #endif } else if (codec == CompressionCodec.Gzip) { using (var compressed = new MemoryStream(body, offset, length, false)) { using (var zipped = new GZipStream(compressed, CompressionMode.Decompress)) { using (var tmp = uncompressed.Pool.Reserve()) { zipped.ReusableCopyTo(uncompressed, tmp); } } } } else // compression == CompressionCodec.Lz4 { KafkaLz4.Uncompress(uncompressed, body, offset); } uncompressed.Position = 0; } catch (Exception ex) { throw new UncompressException("Invalid compressed data.", codec, ex); } }
public static void Compress(ReusableMemoryStream target, byte[] body, int count) { target.Write(FrameDescriptor, 0, FrameDescriptor.Length); // Blocks var left = count; while (left >= BLOCK_SIZE) { BlockCompress(target, body, count - left, BLOCK_SIZE); left -= BLOCK_SIZE; } // Last block if any if (left > 0) { BlockCompress(target, body, count - left, left); } // EndMark target.Write(Basics.Zero32, 0, Basics.Zero32.Length); target.SetLength(target.Position); }
public void TestSendAsyncErrorSocketSendThrow() { var socket = new Mock <ISocket>(); socket.Setup(s => s.CreateEventArgs()).Returns(() => { var saea = new Mock <ISocketAsyncEventArgs>(); return(saea.Object); }); socket.Setup(s => s.Connected).Returns(true); SocketError error = SocketError.WouldBlock; var buffer = new ReusableMemoryStream(null); buffer.SetLength(14); socket.Setup( s => s.Send(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <SocketFlags>(), out error)) .Throws <InvalidOperationException>(); var connection = new Connection(new IPEndPoint(0, 0), _ => socket.Object, BPool, RPool, 1024, 1024); var e = Assert.ThrowsAsync <TransportException>(async() => await connection.SendAsync(12, buffer, true)); Assert.That(e.Error, Is.EqualTo(TransportError.WriteError)); Assert.IsInstanceOf <InvalidOperationException>(e.InnerException); }
public void TestFetchWithNoErrors(Basics.ApiVersion version) { // Prepare var serializer = new Mock <Node.ISerialization>(); var connection = new Mock <IConnection>(); var node = new Node("Node", () => connection.Object, serializer.Object, new Configuration { TaskScheduler = new CurrentThreadTaskScheduler(), ConsumeBatchSize = 1, Compatibility = version == Basics.ApiVersion.V0 ? Compatibility.V0_8_2 : Compatibility.V0_10_1 }, 1); var ev = new ManualResetEvent(false); var corrs = new Queue <int>(); connection.Setup(c => c.SendAsync(It.IsAny <int>(), It.IsAny <ReusableMemoryStream>(), It.IsAny <bool>())) .Returns((int c, ReusableMemoryStream d, bool a) => { corrs.Enqueue(c); return(Success); }) .Callback(() => ev.Set()); connection.Setup(c => c.ConnectAsync()).Returns(Success); var message = new FetchMessage { Topic = "balbuzzard", Offset = 42, Partition = 1, MaxBytes = 1242 }; node.Fetch(message); ev.WaitOne(); Assert.AreEqual(1, corrs.Count); int corr = corrs.Dequeue(); int response = 0; node.ResponseReceived += (n, l) => { Assert.AreSame(node, n); ++response; }; var acknowledgement = new CommonAcknowledgement <FetchResponse>(); node.FetchAcknowledgement += (n, ack) => { acknowledgement = ack; Assert.AreSame(node, n); }; serializer.Setup(s => s.DeserializeResponse <FetchResponse>(corr, It.IsAny <ReusableMemoryStream>(), version)) .Returns(new FetchResponse { FetchPartitionResponse = new CommonResponse <FetchPartitionResponse> { TopicsResponse = new[] { new TopicData <FetchPartitionResponse> { TopicName = "balbuzzard", PartitionsData = new[] { new FetchPartitionResponse { ErrorCode = ErrorCode.NoError, HighWatermarkOffset = 42, Partition = 1, Messages = new List <ResponseMessage> { new ResponseMessage { Offset = 28, Message = new Message() } } } } } } } }); bool resp = false; node.FetchResponseReceived += (n, c, s) => { Assert.That(n, Is.EqualTo(node)); Assert.That(c, Is.EqualTo(1)); Assert.That(s, Is.EqualTo(28)); resp = true; }; // Now send a response var r = new ReusableMemoryStream(null); r.SetLength(28); connection.Raise(c => c.Response += null, connection.Object, corr, r); serializer.Verify(s => s.DeserializeResponse <FetchResponse>(corr, It.IsAny <ReusableMemoryStream>(), It.IsAny <Basics.ApiVersion>()), Times.Once); serializer.Verify(s => s.DeserializeResponse <FetchResponse>(corr, It.IsAny <ReusableMemoryStream>(), version)); // Checks Assert.IsTrue(resp); Assert.AreNotEqual(default(DateTime), acknowledgement.ReceivedDate); Assert.AreEqual(1, acknowledgement.Response.FetchPartitionResponse.TopicsResponse.Length); Assert.AreEqual("balbuzzard", acknowledgement.Response.FetchPartitionResponse.TopicsResponse[0].TopicName); Assert.AreEqual(1, acknowledgement.Response.FetchPartitionResponse.TopicsResponse[0].PartitionsData.Count()); var fetch = acknowledgement.Response.FetchPartitionResponse.TopicsResponse[0].PartitionsData.First(); Assert.AreEqual(ErrorCode.NoError, fetch.ErrorCode); Assert.AreEqual(42, fetch.HighWatermarkOffset); Assert.AreEqual(1, fetch.Partition); Assert.AreEqual(1, fetch.Messages.Count()); Assert.AreEqual(28, fetch.Messages.First().Offset); Assert.AreEqual(new Message(), fetch.Messages.First().Message); // This is not full proof but come on... }
public async Task TestSendAsync() { var mocked = new Dictionary <ISocketAsyncEventArgs, Mock <ISocketAsyncEventArgs> >(); var socket = new Mock <ISocket>(); int step = 0; // we'll do 3 async steps socket.Setup(s => s.CreateEventArgs()).Returns(() => { var saea = new Mock <ISocketAsyncEventArgs>(); saea.Setup(a => a.SocketError).Returns(SocketError.Success); saea.SetupProperty(a => a.UserToken); saea.Setup(a => a.BytesTransferred).Returns(() => { switch (step) { case 1: return(4); case 2: return(7); default: return(3); } }); saea.Setup(a => a.Count).Returns(() => { switch (step) { case 1: return(14); case 2: return(10); default: return(3); } }); saea.Setup(a => a.Offset).Returns(() => { switch (step) { case 1: return(0); case 2: return(4); default: return(11); } }); mocked.Add(saea.Object, saea); return(saea.Object); }); socket.Setup(s => s.Connected).Returns(true); SocketError error = SocketError.WouldBlock; var buffer = new ReusableMemoryStream(null); buffer.SetLength(14); socket.Setup( s => s.Send(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <SocketFlags>(), out error)) .Returns(0); socket.Setup(s => s.SendAsync(It.IsAny <ISocketAsyncEventArgs>())) .Returns(() => ++ step == 3) // simulate a synchronous return on step 1 and 2 .Callback((ISocketAsyncEventArgs args) => { if (step == 3) { mocked[args].Raise(a => a.Completed += null, socket.Object, args); } }); var connection = new Connection(new IPEndPoint(0, 0), _ => socket.Object, BPool, RPool, 1024, 1024); await connection.SendAsync(12, buffer, true); socket.Verify(s => s.Send(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <SocketFlags>(), out error), Times.Once()); socket.Verify(s => s.SendAsync(It.IsAny <ISocketAsyncEventArgs>()), Times.Exactly(3)); }