/// <summary>
/// Allocates a message in a block and returns the block the message is in.
/// </summary>
/// <returns>The cached message block which the message was allocated in.</returns>
public CachedMessageBlock AllocateMessage(CachedMessage message)
{
CachedMessageBlock returnBlock = currentMessageBlock ?? (currentMessageBlock = messagePool.Allocate());
returnBlock.Add(message);
// blocks at capacity are eligable for purge, so we don't want to be holding on to them.
if (!currentMessageBlock.HasCapacity)
{
currentMessageBlock = messagePool.Allocate();
}
return(returnBlock);
}
private void RemoveAndCheck(CachedMessageBlock <TestCachedMessage> block, int first, int last)
{
Assert.Equal(first, block.OldestMessageIndex);
Assert.Equal(last, block.NewestMessageIndex);
Assert.False(block.IsEmpty);
Assert.Equal(last + 1 < TestBlockSize, block.HasCapacity);
Assert.True(block.Remove());
first++;
Assert.Equal(first > last, block.IsEmpty);
Assert.Equal(last + 1 < TestBlockSize, block.HasCapacity);
Assert.Equal(first, block.OldestMessageIndex);
Assert.Equal(last, block.NewestMessageIndex);
}
private void AddAndCheck(CachedMessageBlock <TestCachedMessage> block, ICacheDataAdapter <TestQueueMessage, TestCachedMessage> dataAdapter, TestQueueMessage message, int first, int last)
{
Assert.Equal(first, block.OldestMessageIndex);
Assert.Equal(last, block.NewestMessageIndex);
Assert.True(block.HasCapacity);
block.Add(message, DateTime.UtcNow, dataAdapter);
last++;
Assert.Equal(first > last, block.IsEmpty);
Assert.Equal(last + 1 < TestBlockSize, block.HasCapacity);
Assert.Equal(first, block.OldestMessageIndex);
Assert.Equal(last, block.NewestMessageIndex);
Assert.True(block.GetSequenceToken(last, dataAdapter).Equals(message.SequenceToken));
}
private void AddAndCheck(CachedMessageBlock <TestQueueMessage, TestCachedMessage> block, TestQueueMessage message, int first, int last)
{
Assert.AreEqual(first, block.OldestMessageIndex);
Assert.AreEqual(last, block.NewestMessageIndex);
Assert.IsTrue(block.HasCapacity);
block.Add(message);
last++;
Assert.AreEqual(first > last, block.IsEmpty);
Assert.AreEqual(last + 1 < TestBlockSize, block.HasCapacity);
Assert.AreEqual(first, block.OldestMessageIndex);
Assert.AreEqual(last, block.NewestMessageIndex);
Assert.IsTrue(block.GetSequenceToken(last).Equals(message.SequenceToken));
}
public void FirstMessageWithSequenceNumberTest()
{
IObjectPool <CachedMessageBlock <TestQueueMessage, TestCachedMessage> > pool = new MyTestPooled();
CachedMessageBlock <TestQueueMessage, TestCachedMessage> block = pool.Allocate();
int last = -1;
int sequenceNumber = 0;
while (block.HasCapacity)
{
// add message to end of block
AddAndCheck(block, 0, last, sequenceNumber);
last++;
sequenceNumber += 2;
}
Assert.AreEqual(block.OldestMessageIndex, block.GetIndexOfFirstMessageLessThanOrEqualTo(new EventSequenceToken(0)));
Assert.AreEqual(block.OldestMessageIndex, block.GetIndexOfFirstMessageLessThanOrEqualTo(new EventSequenceToken(1)));
Assert.AreEqual(block.NewestMessageIndex, block.GetIndexOfFirstMessageLessThanOrEqualTo(new EventSequenceToken(sequenceNumber - 2)));
Assert.AreEqual(block.NewestMessageIndex - 1, block.GetIndexOfFirstMessageLessThanOrEqualTo(new EventSequenceToken(sequenceNumber - 3)));
Assert.AreEqual(50, block.GetIndexOfFirstMessageLessThanOrEqualTo(new EventSequenceToken(sequenceNumber / 2)));
Assert.AreEqual(50, block.GetIndexOfFirstMessageLessThanOrEqualTo(new EventSequenceToken(sequenceNumber / 2 + 1)));
}
public void Free(CachedMessageBlock <TestCachedMessage> resource)
{
}
public void NextInStreamTest()
{
IObjectPool <CachedMessageBlock <TestCachedMessage> > pool = new MyTestPooled();
ICacheDataAdapter <TestQueueMessage, TestCachedMessage> dataAdapter = new TestCacheDataAdapter();
CachedMessageBlock <TestCachedMessage> block = pool.Allocate();
int last = 0;
int sequenceNumber = 0;
// define 2 streams
var streams = new[] { new TestStreamIdentity {
Guid = Guid.NewGuid()
}, new TestStreamIdentity {
Guid = Guid.NewGuid()
} };
// add both streams interleaved, until lock is full
while (block.HasCapacity)
{
var stream = streams[last % 2];
var message = new TestQueueMessage
{
StreamGuid = stream.Guid,
SequenceToken = new EventSequenceToken(sequenceNumber)
};
// add message to end of block
AddAndCheck(block, dataAdapter, message, 0, last - 1);
last++;
sequenceNumber += 2;
}
// get index of first stream
int streamIndex;
Assert.IsTrue(block.TryFindFirstMessage(streams[0], TestCacheDataComparer.Instance, out streamIndex));
Assert.AreEqual(0, streamIndex);
Assert.AreEqual(0, (block.GetSequenceToken(streamIndex, dataAdapter) as EventSequenceToken).SequenceNumber);
// find stream1 messages
int iteration = 1;
while (block.TryFindNextMessage(streamIndex + 1, streams[0], TestCacheDataComparer.Instance, out streamIndex))
{
Assert.AreEqual(iteration * 2, streamIndex);
Assert.AreEqual(iteration * 4, (block.GetSequenceToken(streamIndex, dataAdapter) as EventSequenceToken).SequenceNumber);
iteration++;
}
Assert.AreEqual(iteration, TestBlockSize / 2);
// get index of first stream
Assert.IsTrue(block.TryFindFirstMessage(streams[1], TestCacheDataComparer.Instance, out streamIndex));
Assert.AreEqual(1, streamIndex);
Assert.AreEqual(2, (block.GetSequenceToken(streamIndex, dataAdapter) as EventSequenceToken).SequenceNumber);
// find stream1 messages
iteration = 1;
while (block.TryFindNextMessage(streamIndex + 1, streams[1], TestCacheDataComparer.Instance, out streamIndex))
{
Assert.AreEqual(iteration * 2 + 1, streamIndex);
Assert.AreEqual(iteration * 4 + 2, (block.GetSequenceToken(streamIndex, dataAdapter) as EventSequenceToken).SequenceNumber);
iteration++;
}
Assert.AreEqual(iteration, TestBlockSize / 2);
}
