public async Task SMS_Limits_FindMax_Producers()
{
// 1 Stream, X Producers, 1 Consumer
Guid streamId = Guid.NewGuid();
string streamProviderName = SmsStreamProviderName;
output.WriteLine("Starting search for MaxProducersPerStream value using stream {0}", streamId);
IStreamLifecycleConsumerGrain consumer = this.GrainFactory.GetGrain <IStreamLifecycleConsumerGrain>(Guid.NewGuid());
await consumer.BecomeConsumer(streamId, this.StreamNamespace, streamProviderName);
int loopCount = 0;
try
{
// Loop until something breaks!
for (loopCount = 1; loopCount <= MaxExpectedPerStream; loopCount++)
{
IStreamLifecycleProducerGrain producer = this.GrainFactory.GetGrain <IStreamLifecycleProducerGrain>(Guid.NewGuid());
await producer.BecomeProducer(streamId, this.StreamNamespace, streamProviderName);
}
}
catch (Exception exc)
{
this.output.WriteLine("Stopping loop at loopCount={0} due to exception {1}", loopCount, exc);
}
MaxProducersPerStream = loopCount - 1;
output.WriteLine("Finished search for MaxProducersPerStream with value {0}", MaxProducersPerStream);
Assert.NotEqual(0, MaxProducersPerStream); // "MaxProducersPerStream should be greater than zero."
output.WriteLine("MaxProducersPerStream={0}", MaxProducersPerStream);
}
public async Task SMS_Limits_FindMax_Consumers()
{
// 1 Stream, 1 Producer, X Consumers
Guid streamId = Guid.NewGuid();
string streamProviderName = StreamTestsConstants.SMS_STREAM_PROVIDER_NAME;
Console.WriteLine("Starting search for MaxConsumersPerStream value using stream {0}", streamId);
IStreamLifecycleProducerGrain producer = GrainClient.GrainFactory.GetGrain <IStreamLifecycleProducerGrain>(Guid.NewGuid());
await producer.BecomeProducer(streamId, this.StreamNamespace, streamProviderName);
int loopCount = 0;
try
{
// Loop until something breaks!
for (loopCount = 1; loopCount <= MaxExpectedPerStream; loopCount++)
{
IStreamLifecycleConsumerGrain consumer = GrainClient.GrainFactory.GetGrain <IStreamLifecycleConsumerGrain>(Guid.NewGuid());
await consumer.BecomeConsumer(streamId, this.StreamNamespace, streamProviderName);
}
}
catch (Exception exc)
{
Console.WriteLine("Stopping loop at loopCount={0} due to exception {1}", loopCount, exc);
}
MaxConsumersPerStream = loopCount - 1;
Console.WriteLine("Finished search for MaxConsumersPerStream with value {0}", MaxConsumersPerStream);
Assert.AreNotEqual(0, MaxConsumersPerStream, "MaxConsumersPerStream should be greater than zero.");
Console.WriteLine("MaxConsumersPerStream={0}", MaxConsumersPerStream);
}
private async Task Test_PubSub_Stream(string streamProviderName, Guid streamId)
{
// Consumer
IStreamLifecycleConsumerGrain consumer = this.GrainFactory.GetGrain <IStreamLifecycleConsumerGrain>(Guid.NewGuid());
await consumer.BecomeConsumer(streamId, this.StreamNamespace, streamProviderName);
// Producer
IStreamLifecycleProducerGrain producer = this.GrainFactory.GetGrain <IStreamLifecycleProducerGrain>(Guid.NewGuid());
await producer.BecomeProducer(StreamId, this.StreamNamespace, streamProviderName);
await producer.SendItem(1);
int received1 = await consumer.GetReceivedCount();
Assert.True(received1 > 1, $"Received count for consumer {consumer} is too low = {received1}");
// Unsubscribe
await consumer.ClearGrain();
// Send one more message
await producer.SendItem(2);
int received2 = await consumer.GetReceivedCount();
Assert.Equal(0, received2); // $"Received count for consumer {consumer} is wrong = {received2}"
}
protected async Task Test_Filter_TwoObsv_Different()
{
streamProviderName.Should().NotBeNull("Stream provider name not set.");
Guid id1 = Guid.NewGuid();
Guid id2 = Guid.NewGuid();
// Same consumer grain subscribes twice, with two different filters
IFilteredStreamConsumerGrain consumer = GrainClient.GrainFactory.GetGrain <IFilteredStreamConsumerGrain>(id1);
await consumer.BecomeConsumer(StreamId, StreamNamespace, streamProviderName, true); // Even
await consumer.BecomeConsumer(StreamId, StreamNamespace, streamProviderName, false); // Odd
IStreamLifecycleProducerGrain producer = GrainClient.GrainFactory.GetGrain <IStreamLifecycleProducerGrain>(id2);
await producer.BecomeProducer(StreamId, StreamNamespace, streamProviderName);
int expectedCount = 1; // Producer always sends first message when it becomes active
await producer.SendItem(1);
expectedCount++; // One observer receives, the other does not.
if (StreamTestsConstants.AZURE_QUEUE_STREAM_PROVIDER_NAME.Equals(streamProviderName))
{
// Allow some time for messages to propagate through the system
await TestingUtils.WaitUntilAsync(async tryLast => await producer.GetSendCount() >= 2, timeout);
}
int count = await consumer.GetReceivedCount();
logger.Info("Received count = {0} after first send for consumer {1}", count, consumer);
count.Should().Be(expectedCount, "Expected count after first send");
await producer.SendItem(2);
expectedCount++;
if (StreamTestsConstants.AZURE_QUEUE_STREAM_PROVIDER_NAME.Equals(streamProviderName))
{
// Allow some time for messages to propagate through the system
await TestingUtils.WaitUntilAsync(async tryLast => await producer.GetSendCount() >= 3, timeout);
}
count = await consumer.GetReceivedCount();
logger.Info("Received count = {0} after second send for consumer {1}", count, consumer);
count.Should().Be(expectedCount, "Expected count after second send");
await producer.SendItem(3);
expectedCount++;
if (StreamTestsConstants.AZURE_QUEUE_STREAM_PROVIDER_NAME.Equals(streamProviderName))
{
// Allow some time for messages to propagate through the system
await TestingUtils.WaitUntilAsync(async tryLast => await producer.GetSendCount() >= 4, timeout);
}
count = await consumer.GetReceivedCount();
logger.Info("Received count = {0} after third send for consumer {1}", count, consumer);
count.Should().Be(expectedCount, "Expected count after second send");
}
protected async Task Test_Filter_TwoObsv_Same()
{
streamProviderName.Should().NotBeNull("Stream provider name not set.");
Guid id1 = Guid.NewGuid();
Guid id2 = Guid.NewGuid();
// Same consumer grain subscribes twice, with two identical filters
IFilteredStreamConsumerGrain consumer = GrainClient.GrainFactory.GetGrain <IFilteredStreamConsumerGrain>(id1);
await consumer.BecomeConsumer(StreamId, StreamNamespace, streamProviderName, true); // Even
await consumer.BecomeConsumer(StreamId, StreamNamespace, streamProviderName, true); // Even
IStreamLifecycleProducerGrain producer = GrainClient.GrainFactory.GetGrain <IStreamLifecycleProducerGrain>(id2);
await producer.BecomeProducer(StreamId, StreamNamespace, streamProviderName);
int expectedCount = 2; // When Producer becomes active, it always sends first message to each subscriber
await producer.SendItem(1);
if (StreamTestsConstants.AZURE_QUEUE_STREAM_PROVIDER_NAME.Equals(streamProviderName))
{
// Allow some time for messages to propagate through the system
await TestingUtils.WaitUntilAsync(async tryLast => await producer.GetSendCount() >= 2, timeout);
}
int count = await consumer.GetReceivedCount();
Console.WriteLine("Received count = {0} after first send for consumer {1}", count, consumer);
count.Should().Be(expectedCount, "Expected count after first send");
await producer.SendItem(2);
expectedCount += 2;
if (StreamTestsConstants.AZURE_QUEUE_STREAM_PROVIDER_NAME.Equals(streamProviderName))
{
// Allow some time for messages to propagate through the system
await TestingUtils.WaitUntilAsync(async tryLast => await producer.GetSendCount() >= 3, timeout);
}
count = await consumer.GetReceivedCount();
Console.WriteLine("Received count = {0} after second send for consumer {1}", count, consumer);
count.Should().Be(expectedCount, "Expected count after second send");
await producer.SendItem(3);
if (StreamTestsConstants.AZURE_QUEUE_STREAM_PROVIDER_NAME.Equals(streamProviderName))
{
// Allow some time for messages to propagate through the system
await TestingUtils.WaitUntilAsync(async tryLast => await producer.GetSendCount() >= 4, timeout);
}
count = await consumer.GetReceivedCount();
Console.WriteLine("Received count = {0} after third send for consumer {1}", count, consumer);
count.Should().Be(expectedCount, "Expected count after second send");
}
// Test support functions
protected async Task Test_Filter_EvenOdd(bool allCheckEven = false)
{
streamProviderName.Should().NotBeNull("Stream provider name not set.");
// Consumers
const int numConsumers = 10;
var consumers = new IFilteredStreamConsumerGrain[numConsumers];
var promises = new List <Task>();
for (int loopCount = 0; loopCount < numConsumers; loopCount++)
{
IFilteredStreamConsumerGrain grain = GrainClient.GrainFactory.GetGrain <IFilteredStreamConsumerGrain>(Guid.NewGuid());
consumers[loopCount] = grain;
bool isEven = allCheckEven || loopCount % 2 == 0;
Task promise = grain.BecomeConsumer(StreamId, StreamNamespace, streamProviderName, isEven);
promises.Add(promise);
}
await Task.WhenAll(promises);
// Producer
IStreamLifecycleProducerGrain producer = GrainClient.GrainFactory.GetGrain <IStreamLifecycleProducerGrain>(Guid.NewGuid());
await producer.BecomeProducer(StreamId, StreamNamespace, streamProviderName);
if (StreamTestsConstants.AZURE_QUEUE_STREAM_PROVIDER_NAME.Equals(streamProviderName))
{
// Allow some time for messages to propagate through the system
await TestingUtils.WaitUntilAsync(async tryLast => await producer.GetSendCount() >= 1, timeout);
}
// Check initial counts
var sb = new StringBuilder();
int[] counts = new int[numConsumers];
for (int i = 0; i < numConsumers; i++)
{
counts[i] = await consumers[i].GetReceivedCount();
sb.AppendFormat("Baseline count = {0} for consumer {1}", counts[i], i);
sb.AppendLine();
}
logger.Info(sb.ToString());
// Get producer to send some messages
for (int round = 1; round <= 10; round++)
{
bool roundIsEven = round % 2 == 0;
await producer.SendItem(round);
if (StreamTestsConstants.AZURE_QUEUE_STREAM_PROVIDER_NAME.Equals(streamProviderName))
{
// Allow some time for messages to propagate through the system
await TestingUtils.WaitUntilAsync(async tryLast => await producer.GetSendCount() >= 2, timeout);
}
for (int i = 0; i < numConsumers; i++)
{
bool indexIsEven = i % 2 == 0;
int expected = counts[i];
if (roundIsEven)
{
if (indexIsEven || allCheckEven)
{
expected += 1;
}
}
else if (allCheckEven)
{
// No change to expected counts for odd rounds
}
else
{
if (!indexIsEven)
{
expected += 1;
}
}
int count = await consumers[i].GetReceivedCount();
logger.Info("Received count = {0} in round {1} for consumer {2}", count, round, i);
count.Should().Be(expected, "Expected count in round {0} for consumer {1}", round, i);
counts[i] = expected; // Set new baseline
}
}
}
private async Task IncrementalAddProducers(IStreamLifecycleProducerGrain[] producers, string when)
{
for (int i = 1; i <= producers.Length; i++)
{
var producer = producers[i - 1];
await producer.BecomeProducer(StreamId, StreamNamespace, StreamProviderName);
// These Producers test grains always send first message when they register
await StreamTestUtils.CheckPubSubCounts(
string.Format("producer #{0} create - {1}", i, when),
i, 1,
StreamId, StreamProviderName, StreamNamespace);
}
}
public static Task BecomeProducer(this IStreamLifecycleProducerGrain grain, Guid streamIdGuid, string streamNamespace, string providerName)
{
var streamId = StreamId.Create(streamNamespace, streamIdGuid);
return(grain.BecomeProducer(streamId, providerName));
}
