public TestBatchContainer(Guid streamGuid, string streamNamespace, List <object> events, long sequenceId)
{
StreamGuid = streamGuid;
StreamNamespace = streamNamespace;
_events = events ?? throw new ArgumentNullException(nameof(events));
_eventSequenceToken = new EventSequenceToken(sequenceId);
}
public override StreamPosition GetStreamPosition(EventData queueMessage)
{
IStreamIdentity stremIdentity = new StreamIdentity(partitionStreamGuid, null);
StreamSequenceToken token = new EventSequenceToken(queueMessage.SequenceNumber, 0);
return(new StreamPosition(stremIdentity, token));
}
public StreamPosition GetStreamPosition(TestQueueMessage queueMessage)
{
IStreamIdentity streamIdentity = new StreamIdentity(queueMessage.StreamGuid, queueMessage.StreamNamespace);
StreamSequenceToken sequenceToken = new EventSequenceToken(queueMessage.SequenceNumber);
return(new StreamPosition(streamIdentity, sequenceToken));
}
public AzureQueueBatchContainer(
StreamId streamId,
List <object> events,
Dictionary <string, object> requestContext,
EventSequenceToken sequenceToken)
: this(streamId, events, requestContext)
{
this.sequenceToken = sequenceToken;
}
/// <summary>
/// Gets the stream position from a queue message
/// </summary>
/// <param name="queueMessage"></param>
/// <returns></returns>
public virtual StreamPosition GetStreamPosition(EventData queueMessage)
{
Guid streamGuid = Guid.Parse(queueMessage.PartitionKey);
string streamNamespace = queueMessage.GetStreamNamespaceProperty();
IStreamIdentity stremIdentity = new StreamIdentity(streamGuid, streamNamespace);
StreamSequenceToken token = new EventSequenceToken(queueMessage.SequenceNumber, 0);
return(new StreamPosition(stremIdentity, token));
}
public AzureQueueBatchContainer(
Guid streamGuid,
String streamNamespace,
List <object> events,
Dictionary <string, object> requestContext,
EventSequenceToken sequenceToken)
: this(streamGuid, streamNamespace, events, requestContext)
{
this.sequenceToken = sequenceToken;
}
private Mock <IBatchContainer> GenerateBatchContainerMock(Guid streamGuid, string streamNamespace, int sequenceNumber)
{
Mock <IBatchContainer> batchMock = new Mock <IBatchContainer>();
EventSequenceToken seq = new EventSequenceToken(sequenceNumber);
batchMock.SetupGet(x => x.SequenceToken).Returns(seq);
batchMock.SetupGet(x => x.StreamGuid).Returns(streamGuid);
batchMock.SetupGet(x => x.StreamNamespace).Returns(streamNamespace);
return(batchMock);
}
private StreamSequenceToken FloorSequenceToken(StreamSequenceToken token)
{
if (!(token is EventSequenceToken))
{
return(token);
}
EventSequenceToken tokenAsEventSequenceToken = (EventSequenceToken)token;
if (tokenAsEventSequenceToken.EventIndex == 0)
{
return(token);
}
EventSequenceToken flooredToken = new EventSequenceToken(tokenAsEventSequenceToken.SequenceNumber);
return(flooredToken);
}
public IQueueAdapterCacheCursor GetCacheCursor(Guid streamGuid, string streamNamespace, StreamSequenceToken token)
{
EventSequenceToken sequenceToken;
if (token == null)
{
// Null token can come from a stream subscriber that is just interested to start consuming from latest (the most recent event added to the cache).
sequenceToken = new EventSequenceToken(lastReadMessage);
}
else
{
var eventToken = token as EventSequenceToken;
if (eventToken == null)
{
throw new ArgumentOutOfRangeException("token", "token must be of type EventSequenceToken");
}
sequenceToken = eventToken;
}
return(new SimpleQueueAdapterCacheCursor(cache, streamGuid, streamNamespace, sequenceToken));
}
public void EventSequenceToken_VerifyStillUsingFallbackSerializer()
{
var token = new EventSequenceToken(long.MaxValue, int.MaxValue);
VerifyUsingFallbackSerializer(token);
}
public bool NotifiedDeletion(EventSequenceToken token)
{
TimesCalled++;
return(true);
}
public MemoryBatchContainer(MemoryMessageData messageData)
{
serializer = new TSerializer();
MessageData = messageData;
realToken = new EventSequenceToken(messageData.SequenceNumber);
}
internal void SetSequenceToken(EventSequenceToken token)
{
this.sequenceToken = token;
}
public IEnumerable <Tuple <T, StreamSequenceToken> > GetEvents <T>() => _events .OfType <T>() .Select((e, i) => Tuple.Create <T, StreamSequenceToken>(e, EventSequenceToken?.CreateSequenceTokenForEvent(i))) .ToList();
public void EventSequenceToken_VerifyStillUsingFallbackSerializer()
{
var token = new EventSequenceToken(long.MaxValue, int.MaxValue);
Tester.SerializationTests.SerializationTestsUtils.VerifyUsingFallbackSerializer(token, this.fixture.Environment.GrainFactory);
}
public IEnumerable <Tuple <T, StreamSequenceToken> > GetEvents <T>()
{
return(Events.OfType <T>().Select((e, i) => Tuple.Create <T, StreamSequenceToken>(e, EventSequenceToken.CreateSequenceTokenForEvent(i))));
}
public int Compare(TestCachedMessage cachedMessage, StreamSequenceToken token)
{
var myToken = new EventSequenceToken(cachedMessage.SequenceNumber, cachedMessage.EventIndex);
return(myToken.CompareTo(token));
}
public GeneratedBatchContainer(Guid streamGuid, string streamNamespace, object payload, EventSequenceToken token)
{
StreamGuid = streamGuid;
StreamNamespace = streamNamespace;
this.Payload = payload;
this.RealToken = token;
}
public void EventSequenceToken_VerifyStillUsingFallbackSerializer()
{
var token = new EventSequenceToken(long.MaxValue, int.MaxValue);
Tester.SerializationTests.SerializationTestsUtils.VerifyUsingFallbackSerializer(token);
}
public IEnumerable <Tuple <T, StreamSequenceToken> > GetEvents <T>()
{
var res = _events.OfType <T>().Select((e, i) => Tuple.Create <T, StreamSequenceToken>(e, EventSequenceToken.CreateSequenceTokenForEvent(i))).ToList();
return(res);
}
public MemoryBatchContainer(MemoryMessageData messageData, TSerializer serializer)
{
this.serializer = serializer;
MessageData = messageData;
realToken = new EventSequenceToken(messageData.SequenceNumber);
}
public IEnumerable <Tuple <T, StreamSequenceToken> > GetEvents <T>()
{
return(_events.OfType <T>()
.Select((e, i) => Tuple.Create(e, (StreamSequenceToken)EventSequenceToken?.CreateSequenceTokenForEvent(i)))
.ToList());
}
private async Task SendAndReceiveFromQueueAdapter(IQueueAdapterFactory adapterFactory, IProviderConfiguration config)
{
IQueueAdapter adapter = await adapterFactory.CreateAdapter();
IQueueAdapterCache cache = adapterFactory.GetQueueAdapterCache();
// Create receiver per queue
IStreamQueueMapper mapper = adapterFactory.GetStreamQueueMapper();
Dictionary <QueueId, IQueueAdapterReceiver> receivers = mapper.GetAllQueues().ToDictionary(queueId => queueId, adapter.CreateReceiver);
Dictionary <QueueId, IQueueCache> caches = mapper.GetAllQueues().ToDictionary(queueId => queueId, cache.CreateQueueCache);
await Task.WhenAll(receivers.Values.Select(receiver => receiver.Initialize(TimeSpan.FromSeconds(5))));
// test using 2 streams
Guid streamId1 = Guid.NewGuid();
Guid streamId2 = Guid.NewGuid();
int receivedBatches = 0;
var streamsPerQueue = new ConcurrentDictionary <QueueId, HashSet <IStreamIdentity> >();
// reader threads (at most 2 active queues because only two streams)
var work = new List <Task>();
foreach (KeyValuePair <QueueId, IQueueAdapterReceiver> receiverKvp in receivers)
{
QueueId queueId = receiverKvp.Key;
var receiver = receiverKvp.Value;
var qCache = caches[queueId];
Task task = Task.Factory.StartNew(() =>
{
while (receivedBatches < NumBatches)
{
var messages = receiver.GetQueueMessagesAsync(CloudQueueMessage.MaxNumberOfMessagesToPeek).Result.ToArray();
if (!messages.Any())
{
continue;
}
foreach (AzureQueueBatchContainer message in messages.Cast <AzureQueueBatchContainer>())
{
streamsPerQueue.AddOrUpdate(queueId,
id => new HashSet <IStreamIdentity> {
new StreamIdentity(message.StreamGuid, message.StreamGuid.ToString())
},
(id, set) =>
{
set.Add(new StreamIdentity(message.StreamGuid, message.StreamGuid.ToString()));
return(set);
});
output.WriteLine("Queue {0} received message on stream {1}", queueId,
message.StreamGuid);
Assert.Equal(NumMessagesPerBatch / 2, message.GetEvents <int>().Count()); // "Half the events were ints"
Assert.Equal(NumMessagesPerBatch / 2, message.GetEvents <string>().Count()); // "Half the events were strings"
}
Interlocked.Add(ref receivedBatches, messages.Length);
qCache.AddToCache(messages);
}
});
work.Add(task);
}
// send events
List <object> events = CreateEvents(NumMessagesPerBatch);
work.Add(Task.Factory.StartNew(() => Enumerable.Range(0, NumBatches)
.Select(i => i % 2 == 0 ? streamId1 : streamId2)
.ToList()
.ForEach(streamId =>
adapter.QueueMessageBatchAsync(streamId, streamId.ToString(),
events.Take(NumMessagesPerBatch).ToArray(), null, RequestContext.Export()).Wait())));
await Task.WhenAll(work);
// Make sure we got back everything we sent
Assert.Equal(NumBatches, receivedBatches);
// check to see if all the events are in the cache and we can enumerate through them
StreamSequenceToken firstInCache = new EventSequenceToken(0);
foreach (KeyValuePair <QueueId, HashSet <IStreamIdentity> > kvp in streamsPerQueue)
{
var receiver = receivers[kvp.Key];
var qCache = caches[kvp.Key];
foreach (IStreamIdentity streamGuid in kvp.Value)
{
// read all messages in cache for stream
IQueueCacheCursor cursor = qCache.GetCacheCursor(streamGuid, firstInCache);
int messageCount = 0;
StreamSequenceToken tenthInCache = null;
StreamSequenceToken lastToken = firstInCache;
while (cursor.MoveNext())
{
Exception ex;
messageCount++;
IBatchContainer batch = cursor.GetCurrent(out ex);
output.WriteLine("Token: {0}", batch.SequenceToken);
Assert.True(batch.SequenceToken.CompareTo(lastToken) >= 0, $"order check for event {messageCount}");
lastToken = batch.SequenceToken;
if (messageCount == 10)
{
tenthInCache = batch.SequenceToken;
}
}
output.WriteLine("On Queue {0} we received a total of {1} message on stream {2}", kvp.Key, messageCount, streamGuid);
Assert.Equal(NumBatches / 2, messageCount);
Assert.NotNull(tenthInCache);
// read all messages from the 10th
cursor = qCache.GetCacheCursor(streamGuid, tenthInCache);
messageCount = 0;
while (cursor.MoveNext())
{
messageCount++;
}
output.WriteLine("On Queue {0} we received a total of {1} message on stream {2}", kvp.Key, messageCount, streamGuid);
const int expected = NumBatches / 2 - 10 + 1; // all except the first 10, including the 10th (10 + 1)
Assert.Equal(expected, messageCount);
}
}
}
public MemoryBatchContainer(MemoryEventData eventData, long sequenceId)
{
this.EventData = eventData;
this.realToken = new EventSequenceToken(sequenceId);
}
