public void CanWrite_IsTrue()
{
using (var stream = new PayloadStream(null))
{
Assert.True(stream.CanWrite);
}
}
public async Task CanReadTwice_AfterMultipleWrites()
{
const int expectedReadCount = 200;
var producerBuffer = new byte[100];
var consumerBuffer = new byte[expectedReadCount];
var readCount1 = 0;
var readCount2 = 0;
var random = new Random();
random.NextBytes(producerBuffer);
using (var stream = new PayloadStream(null))
{
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
readCount1 = await stream.ReadAsync(consumerBuffer, 0, expectedReadCount);
readCount2 = await stream.ReadAsync(consumerBuffer, readCount1, expectedReadCount);
}
// only get 1 buffer
Assert.Equal(100, readCount1);
Assert.Equal(100, readCount2);
Assert.Equal(producerBuffer, consumerBuffer.Take(100).ToArray());
Assert.Equal(producerBuffer, consumerBuffer.Skip(100).ToArray());
}
public async Task DoneProducing_Data_WillCauseZeroRead()
{
const int expectedReadCount = 100;
var producerBuffer = new byte[100];
var consumerBuffer = new byte[expectedReadCount];
var readCount1 = 0;
var readCount2 = 0;
var random = new Random();
random.NextBytes(producerBuffer);
using (var stream = new PayloadStream(null))
{
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
stream.DoneProducing();
readCount1 = await stream.ReadAsync(consumerBuffer, 0, expectedReadCount);
readCount2 = await stream.ReadAsync(consumerBuffer, readCount1, expectedReadCount);
}
Assert.Equal(100, readCount1);
Assert.Equal(0, readCount2);
}
public async void DoneProducing_Data_WillCauseZeroRead_And_End()
{
const int expectedReadCount = 100;
var producerBuffer = new byte[100];
var consumerBuffer = new byte[expectedReadCount];
var readCount = 0;
var streamManager = new StreamManager(e => { });
var id = Guid.NewGuid();
var assembler = streamManager.GetPayloadAssembler(id);
assembler.ContentLength = 0;
var random = new Random();
random.NextBytes(producerBuffer);
var stream = new PayloadStream(assembler);
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
stream.DoneProducing();
readCount = stream.Read(consumerBuffer, 0, expectedReadCount);
Assert.Equal(100, readCount);
readCount = stream.Read(consumerBuffer, readCount, expectedReadCount);
Assert.Equal(0, readCount);
}
public void CanRead_IsTrue()
{
using (var stream = new PayloadStream(null))
{
Assert.IsTrue(stream.CanRead);
}
}
public async Task CanReadMore_GetLess_ThenMore_GivesFirstBuffer()
{
const int expectedReadCount = 200;
var producerBuffer = new byte[100];
var consumerBuffer = new byte[expectedReadCount];
var readCount1 = 0;
var readCount2 = 0;
var random = new Random();
random.NextBytes(producerBuffer);
using (var stream = new PayloadStream(null))
{
// write 200
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
// ask for less
readCount1 = await stream.ReadAsync(consumerBuffer, 0, 50);
// ask for more than what should be left in 1 buffer
readCount2 = await stream.ReadAsync(consumerBuffer, 50, 150);
}
Assert.Equal(50, readCount1);
Assert.Equal(50, readCount2);
}
public void CanSeek_IsFalse()
{
using (var stream = new PayloadStream(null))
{
Assert.False(stream.CanSeek);
}
}
public Payload(PayloadDirection direction, PayloadStream streamKind, DateTime transmissionDate, uint bodyTypeHash, byte[] body)
{
_payloadPackets = new ExtendedObservableCollection <PacketBase>();
Direction = direction;
StreamKind = streamKind;
TransmissionDate = transmissionDate;
BodyTypeHash = bodyTypeHash;
Body = body;
}
public void Seek_Throws()
{
using (var stream = new PayloadStream(null))
{
Assert.Throws <NotSupportedException>(() =>
{
stream.Seek(100, SeekOrigin.Begin);
});
}
}
public void SetLength_Throws()
{
using (var stream = new PayloadStream(null))
{
Assert.Throws <NotSupportedException>(() =>
{
stream.SetLength(100);
});
}
}
public void PositionSetter_Throws()
{
using (var stream = new PayloadStream(null))
{
Assert.Throws <NotSupportedException>(() =>
{
stream.Position = 10;
});
}
}
protected override void ExecuteOperation()
{
PayloadItem item = PayloadItems[Index];
bool skip = ItemSkipRegister != null && ItemSkipRegister.Contains(item.Identifier);
if (skip == false)
{
CipherStream itemEncryptor;
MacStream itemAuthenticator;
CreateEtMDecorator(item, out itemEncryptor, out itemAuthenticator);
if (Writing)
{
EmitHeader(itemAuthenticator);
}
else
{
ConsumeHeader(itemAuthenticator);
}
if (Writing)
{
int iterIn;
do
{
iterIn = item.StreamBinding.Read(Buffer, 0, BufferSize);
itemEncryptor.Write(Buffer, 0, iterIn);
} while (iterIn > 0);
}
else
{
itemEncryptor.ReadExactly(item.StreamBinding, item.InternalLength, true);
}
FinishItem(item, itemEncryptor, itemAuthenticator);
}
else
{
// Skipping
long skipLength = GetHeaderLength() + item.InternalLength + GetTrailerLength();
PayloadStream.Seek(skipLength, SeekOrigin.Current);
// Mark the item as completed in the register
ItemCompletionRegister[Index] = true;
ItemsCompleted++;
Debug.Print(DebugUtility.CreateReportString("SimplePayloadMux", "ExecuteOperation",
"[*** SKIPPED ITEM", String.Format("{0} ({1}) ***]", Index, item.Identifier)));
}
}
public async Task DoneProducing_Empty_WillCauseZeroRead()
{
const int expectedReadCount = 200;
var consumerBuffer = new byte[expectedReadCount];
var readCount = 0;
using (var stream = new PayloadStream(null))
{
stream.DoneProducing();
readCount = await stream.ReadAsync(consumerBuffer, 0, expectedReadCount);
}
Assert.Equal(0, readCount);
}
public async Task RequestDisassembler_WithVariableStream_Sends()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var ops = new SendOperations(sender);
var request = StreamingRequest.CreatePost("/a/b");
var stream = new PayloadStream(new PayloadStreamAssembler(null, Guid.NewGuid(), "blah", 100));
stream.Write(new byte[100], 0, 100);
request.AddStream(new StreamContent(stream));
await ops.SendRequestAsync(Guid.NewGuid(), request);
Assert.AreEqual(5, transport.Buffers.Count);
}
public async Task CanReadMore_GetLess()
{
const int expectedReadCount = 200;
var producerBuffer = new byte[100];
var consumerBuffer = new byte[expectedReadCount];
var readCount = 0;
var random = new Random();
random.NextBytes(producerBuffer);
using (var stream = new PayloadStream(null))
{
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
readCount = await stream.ReadAsync(consumerBuffer, 0, expectedReadCount);
}
Assert.Equal(100, readCount);
Assert.Equal(producerBuffer.Take(readCount).ToArray(), consumerBuffer.Take(readCount).ToArray());
}
public async Task CanReadExact()
{
var producerBuffer = new byte[100];
var consumerBuffer = new byte[producerBuffer.Length];
var expectedReadCount = producerBuffer.Length;
var readCount = 0;
var random = new Random();
random.NextBytes(producerBuffer);
using (var stream = new PayloadStream(null))
{
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
readCount = await stream.ReadAsync(consumerBuffer, 0, expectedReadCount);
}
Assert.Equal(expectedReadCount, readCount);
Assert.Equal(producerBuffer.Take(expectedReadCount).ToArray(), consumerBuffer.Take(expectedReadCount).ToArray());
}
public async Task CanReadLess()
{
var producerBuffer = new byte[100];
var consumerBuffer = new byte[producerBuffer.Length];
int expectedReadCount = 50;
int readCount = 0;
var random = new Random();
random.NextBytes(producerBuffer);
using (var stream = new PayloadStream(null))
{
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
readCount = await stream.ReadAsync(consumerBuffer, 0, expectedReadCount);
}
Assert.AreEqual(expectedReadCount, readCount);
CollectionAssert.AreEquivalent(producerBuffer.Take(expectedReadCount).ToArray(), consumerBuffer.Take(expectedReadCount).ToArray());
}
public async Task HttpContentStreamDisassembler_StreamContent_SendsAsVariableLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var stream = new PayloadStream(new PayloadStreamAssembler(null, Guid.NewGuid(), "blah", 100));
var content = new ResponseMessageStream(Guid.NewGuid())
{
Content = new StreamContent(stream),
};
stream.Write(new byte[100], 0, 100);
var disassembler = new ResponseMessageStreamDisassembler(sender, content);
await disassembler.DisassembleAsync();
Assert.AreEqual(3, transport.Buffers.Count);
}
public async Task CanRead_AfterMultipleWrites()
{
int expectedReadCount = 200;
var producerBuffer = new byte[100];
var consumerBuffer = new byte[expectedReadCount];
int readCount = 0;
var random = new Random();
random.NextBytes(producerBuffer);
using (var stream = new PayloadStream(null))
{
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
await stream.WriteAsync(producerBuffer, 0, producerBuffer.Length);
readCount = await stream.ReadAsync(consumerBuffer, 0, expectedReadCount);
}
// only get 1 buffer
Assert.AreEqual(100, readCount);
CollectionAssert.AreEquivalent(producerBuffer.Take(readCount).ToArray(), consumerBuffer.Take(readCount).ToArray());
}
private async Task ProducerConsumerMultithreadedTest(
int producerTotalCount,
int producerChunkCount,
int consumerTotalCount,
int consumerChunkCount)
{
var producerBuffer = new byte[producerTotalCount];
var consumerBuffer = new byte[consumerTotalCount];
var random = new Random();
random.NextBytes(producerBuffer);
var producerPosition = 0;
var consumerPosition = 0;
using (var ct = new CancellationTokenSource())
{
using (var s = new PayloadStream(null))
{
Func <Task> reader = async() =>
{
while (consumerPosition < consumerBuffer.Length)
{
var readCount = Math.Min(consumerChunkCount, consumerBuffer.Length - consumerPosition);
var bytesRead = await s.ReadAsync(consumerBuffer, consumerPosition, readCount, ct.Token);
if (bytesRead == 0)
{
break;
}
consumerPosition += bytesRead;
}
};
Func <Task> writer = async() =>
{
while (producerPosition < producerBuffer.Length)
{
var writeCount = Math.Min(producerChunkCount, producerBuffer.Length - producerPosition);
await s.WriteAsync(producerBuffer, producerPosition, writeCount, ct.Token);
producerPosition += writeCount;
await Task.Yield();
}
};
var readTask = reader();
var writeTask = writer();
await Task.WhenAll(readTask, writeTask);
}
}
Assert.Equal(producerTotalCount, producerPosition);
var consumableCount = Math.Min(producerTotalCount, consumerTotalCount);
Assert.Equal(consumableCount, consumerPosition);
Assert.Equal(producerBuffer.Take(consumableCount).ToArray(), consumerBuffer.Take(consumableCount).ToArray());
}
protected override void ExecuteOperation()
{
Debug.Assert(ItemCompletionRegister[Index] == false);
PayloadItem item = PayloadItems[Index];
Guid itemIdentifier = item.Identifier;
bool skip = ItemSkipRegister != null && ItemSkipRegister.Contains(itemIdentifier);
MuxItemResourceContainer itemContainer;
bool activeResource = _activeItemResources.ContainsKey(itemIdentifier);
if (activeResource)
{
itemContainer = _activeItemResources[itemIdentifier];
}
else
{
if (skip == false)
{
itemContainer = CreateEtMSchemeResources(item);
if (Writing)
{
EmitHeader(itemContainer.Authenticator);
}
else
{
ConsumeHeader(itemContainer.Authenticator);
}
}
else
{
itemContainer = new MuxItemResourceContainer(null, null, null);
}
_activeItemResources.Add(itemIdentifier, itemContainer);
}
int opLength = NextOperationLength();
if (skip == false)
{
CipherStream itemEncryptor = itemContainer.Encryptor;
MacStream itemAuthenticator = itemContainer.Authenticator;
if (Writing)
{
// Writing/multiplexing
if (itemEncryptor.BytesIn + opLength < item.ExternalLength)
{
// Normal operation
itemEncryptor.WriteExactly(item.StreamBinding, opLength);
}
else
{
// Final operation, or just prior to
if (itemContainer.Buffer.IsValueCreated == false)
{
// Redirect final ciphertext to buffer to account for possible expansion
itemAuthenticator.ReassignBinding(itemContainer.Buffer.Value, false, finish: false);
}
var remaining = (int)(item.ExternalLength - itemEncryptor.BytesIn);
if (remaining > 0)
{
while (remaining > 0)
{
int toRead = Math.Min(remaining, BufferSize);
int iterIn = item.StreamBinding.Read(Buffer, 0, toRead);
if (iterIn < toRead)
{
throw new EndOfStreamException();
}
itemEncryptor.Write(Buffer, 0, iterIn); // Writing into recently-lazy-inited buffer
remaining -= iterIn;
}
itemEncryptor.Close();
}
var toWrite = (int)Math.Min(opLength, itemContainer.Buffer.Value.Length);
Debug.Print(DebugUtility.CreateReportString("FabricPayloadMux", "ExecuteOperation",
"Multiplexing item: final stripe length", toWrite));
itemContainer.Buffer.Value.ReadTo(PayloadStream, toWrite);
}
}
else
{
// Reading/demultiplexing
long readRemaining = item.InternalLength - itemEncryptor.BytesIn;
bool finalOp = false;
if (readRemaining <= opLength)
{
// Final operation
opLength = (int)readRemaining;
finalOp = true;
Debug.Print(DebugUtility.CreateReportString("FabricPayloadMux", "ExecuteOperation",
"Demultiplexing item: final stripe length", opLength));
}
itemEncryptor.ReadExactly(item.StreamBinding, opLength, finalOp);
}
if ((Writing && itemEncryptor.BytesIn >= item.ExternalLength && itemContainer.Buffer.Value.Length == 0) ||
(Writing == false && itemEncryptor.BytesIn >= item.InternalLength))
{
// Now that we're finished we need to do some extra things, then clean up
FinishItem(item, itemEncryptor, itemAuthenticator);
}
}
else
{
// Skipping
Debug.Assert(Writing == false, "Should not be skipping when writing!");
if (itemContainer.SkippedLength == 0)
{
// Start of item
PayloadStream.Seek(opLength, SeekOrigin.Current);
itemContainer.SkippedLength += opLength;
}
else if (itemContainer.SkippedLength + opLength >= item.InternalLength)
{
int remainingToSkip = (int)(item.InternalLength - itemContainer.SkippedLength);
itemContainer.SkippedLength += remainingToSkip;
PayloadStream.Seek(remainingToSkip + GetTrailerLength(), SeekOrigin.Current);
// "Finish" item
_activeItemResources.Remove(item.Identifier);
// Mark the item as completed in the register
ItemCompletionRegister[Index] = true;
ItemsCompleted++;
Debug.Print(DebugUtility.CreateReportString("FabricPayloadMux", "ExecuteOperation", "[*** SKIPPED ITEM",
Index + " ***]"));
}
else
{
PayloadStream.Seek(opLength, SeekOrigin.Current);
itemContainer.SkippedLength += opLength;
}
}
}
