public async Task ResubscriptionTest(Guid streamGuid, string streamNamespace)
{
// get producer and consumer
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
IMultipleSubscriptionConsumerGrain consumer = MultipleSubscriptionConsumerGrainFactory.GetGrain(Guid.NewGuid());
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
// setup one subscription and send messsages
StreamSubscriptionHandle <int> firstSubscriptionHandle = await consumer.BecomeConsumer(streamGuid, streamNamespace, streamProviderName);
await producer.StartPeriodicProducing();
Thread.Sleep(1000);
await producer.StopPeriodicProducing();
await UnitTestUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, 1, lastTry), Timeout);
// Resume
StreamSubscriptionHandle <int> resumeHandle = await consumer.Resume(firstSubscriptionHandle);
Assert.AreEqual(firstSubscriptionHandle, resumeHandle, "Handle matches");
await producer.StartPeriodicProducing();
Thread.Sleep(1000);
await producer.StopPeriodicProducing();
await UnitTestUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, 1, lastTry), Timeout);
// remove subscription
await consumer.StopConsuming(resumeHandle);
}
public async Task MultipleSubscriptionTest(Guid streamGuid, string streamNamespace)
{
// get producer and consumer
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
IMultipleSubscriptionConsumerGrain consumer = MultipleSubscriptionConsumerGrainFactory.GetGrain(Guid.NewGuid());
// setup two subscriptions
StreamSubscriptionHandle <int> firstSubscriptionHandle = await consumer.BecomeConsumer(streamGuid, streamNamespace, streamProviderName);
StreamSubscriptionHandle <int> secondSubscriptionHandle = await consumer.BecomeConsumer(streamGuid, streamNamespace, streamProviderName);
// produce some messages
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
await producer.StartPeriodicProducing();
Thread.Sleep(1000);
await producer.StopPeriodicProducing();
// check
await UnitTestUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, 2, lastTry), Timeout);
// unsubscribe
await consumer.StopConsuming(firstSubscriptionHandle);
await consumer.StopConsuming(secondSubscriptionHandle);
}
public async Task DeactivationTest(Guid streamGuid, string streamNamespace)
{
// get producer and consumer
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
IMultipleSubscriptionConsumerGrain consumer = MultipleSubscriptionConsumerGrainFactory.GetGrain(Guid.NewGuid());
// subscribe (PubSubRendezvousGrain will have one consumer)
StreamSubscriptionHandle <int> subscriptionHandle = await consumer.BecomeConsumer(streamGuid, streamNamespace, streamProviderName);
// produce one message (PubSubRendezvousGrain will have one consumer and one producer)
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
await producer.Produce();
var count = await consumer.GetNumberConsumed();
Assert.AreEqual(count[subscriptionHandle], 1, "Consumer grain has not received stream message");
//TODO: trigger deactivation programmatically
await Task.Delay(TimeSpan.FromMilliseconds(130000)); // wait for the PubSubRendezvousGrain and the SampleStreaming_ProducerGrain to be deactivated
// deactivating PubSubRendezvousGrain and SampleStreaming_ProducerGrain during the same GC cycle causes a deadlock
// resume producing after the PubSubRendezvousGrain and the SampleStreaming_ProducerGrain grains have been deactivated:
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName).WithTimeout(Timeout, "BecomeProducer is hung due to deactivation deadlock");
await producer.Produce().WithTimeout(Timeout, "Produce is hung due to deactivation deadlock");
// consumer grain should continue to receive stream messages:
count = await consumer.GetNumberConsumed();
Assert.AreEqual(count[subscriptionHandle], 2, "Consumer did not receive stream messages after PubSubRendezvousGrain and SampleStreaming_ProducerGrain reactivation");
}
public async Task DeactivationTest_ClientConsumer(Guid streamGuid, string streamNamespace)
{
// get producer and consumer
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
var count = new Counter();
// get stream and subscribe
IStreamProvider streamProvider = GrainClient.GetStreamProvider(streamProviderName);
var stream = streamProvider.GetStream <int>(streamGuid, streamNamespace);
StreamSubscriptionHandle <int> subscriptionHandle = await stream.SubscribeAsync((e, t) => count.Increment());
// produce one message (PubSubRendezvousGrain will have one consumer and one producer)
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
await producer.Produce();
Assert.AreEqual(count.Value, 1, "Client consumer grain has not received stream message");
//TODO: trigger deactivation programmatically
await Task.Delay(TimeSpan.FromMilliseconds(130000)); // wait for the PubSubRendezvousGrain and the SampleStreaming_ProducerGrain to be deactivated
// deactivating PubSubRendezvousGrain and SampleStreaming_ProducerGrain during the same GC cycle causes a deadlock
// resume producing after the PubSubRendezvousGrain and the SampleStreaming_ProducerGrain grains have been deactivated:
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName).WithTimeout(Timeout, "BecomeProducer is hung due to deactivation deadlock");
await producer.Produce().WithTimeout(Timeout, "Produce is hung due to deactivation deadlock");
Assert.AreEqual(count.Value, 2, "Client consumer grain did not receive stream messages after PubSubRendezvousGrain and SampleStreaming_ProducerGrain reactivation");
}
public async Task AddAndRemoveSubscriptionTest(Guid streamGuid, string streamNamespace)
{
// get producer and consumer
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
IMultipleSubscriptionConsumerGrain consumer = MultipleSubscriptionConsumerGrainFactory.GetGrain(Guid.NewGuid());
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
// setup one subscription and send messsages
StreamSubscriptionHandle <int> firstSubscriptionHandle = await consumer.BecomeConsumer(streamGuid, streamNamespace, streamProviderName);
await producer.StartPeriodicProducing();
await Task.Delay(TimeSpan.FromMilliseconds(1000));
await producer.StopPeriodicProducing();
await TestingUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, 1, lastTry), Timeout);
// clear counts
await consumer.ClearNumberConsumed();
await producer.ClearNumberProduced();
// setup second subscription and send messages
StreamSubscriptionHandle <int> secondSubscriptionHandle = await consumer.BecomeConsumer(streamGuid, streamNamespace, streamProviderName);
await producer.StartPeriodicProducing();
await Task.Delay(TimeSpan.FromMilliseconds(1000));
await producer.StopPeriodicProducing();
await TestingUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, 2, lastTry), Timeout);
// clear counts
await consumer.ClearNumberConsumed();
await producer.ClearNumberProduced();
// remove first subscription and send messages
await consumer.StopConsuming(firstSubscriptionHandle);
await producer.StartPeriodicProducing();
await Task.Delay(TimeSpan.FromMilliseconds(1000));
await producer.StopPeriodicProducing();
await TestingUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, 1, lastTry), Timeout);
// remove second subscription
await consumer.StopConsuming(secondSubscriptionHandle);
}
public async Task ResubscriptionAfterDeactivationTest(Guid streamGuid, string streamNamespace)
{
// get producer and consumer
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
IMultipleSubscriptionConsumerGrain consumer = MultipleSubscriptionConsumerGrainFactory.GetGrain(Guid.NewGuid());
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
// setup one subscription and send messsages
StreamSubscriptionHandle <int> firstSubscriptionHandle = await consumer.BecomeConsumer(streamGuid, streamNamespace, streamProviderName);
await producer.StartPeriodicProducing();
await Task.Delay(TimeSpan.FromMilliseconds(1000));
await producer.StopPeriodicProducing();
await TestingUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, 1, lastTry), Timeout);
// Deactivate grain
await consumer.Deactivate();
// make sure grain has time to deactivate.
await Task.Delay(TimeSpan.FromMilliseconds(100));
// clear producer counts
await producer.ClearNumberProduced();
// Resume
StreamSubscriptionHandle <int> resumeHandle = await consumer.Resume(firstSubscriptionHandle);
Assert.AreEqual(firstSubscriptionHandle, resumeHandle, "Handle matches");
await producer.StartPeriodicProducing();
await Task.Delay(TimeSpan.FromMilliseconds(1000));
await producer.StopPeriodicProducing();
await TestingUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, 1, lastTry), Timeout);
// remove subscription
await consumer.StopConsuming(resumeHandle);
}
private async Task StreamingTests_Consumer_Producer(Guid streamId, string streamProvider)
{
// consumer joins first, producer later
ISampleStreaming_ConsumerGrain consumer = SampleStreaming_ConsumerGrainFactory.GetGrain(Guid.NewGuid());
await consumer.BecomeConsumer(streamId, StreamNamespace, streamProvider);
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
await producer.BecomeProducer(streamId, StreamNamespace, streamProvider);
await producer.StartPeriodicProducing();
Thread.Sleep(1000);
await producer.StopPeriodicProducing();
await TestingUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, lastTry), _timeout);
await consumer.StopConsuming();
}
private async Task StreamingTests_Producer_InlineConsumer(Guid streamId, string streamProvider)
{
// producer joins first, consumer later
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
await producer.BecomeProducer(streamId, StreamNamespace, streamProvider);
ISampleStreaming_InlineConsumerGrain consumer = SampleStreaming_InlineConsumerGrainFactory.GetGrain(Guid.NewGuid());
await consumer.BecomeConsumer(streamId, StreamNamespace, streamProvider);
await producer.StartPeriodicProducing();
await Task.Delay(TimeSpan.FromMilliseconds(1000));
await producer.StopPeriodicProducing();
//int numProduced = await producer.NumberProduced;
await TestingUtils.WaitUntilAsync(lastTry => CheckCounters(producer, consumer, lastTry), _timeout);
await consumer.StopConsuming();
}
private async Task StreamingTests_Producer_InlineConsumer(Guid streamId, string streamProvider)
{
// producer joins first, consumer later
ISampleStreaming_ProducerGrain producer = SampleStreaming_ProducerGrainFactory.GetGrain(Guid.NewGuid());
await producer.BecomeProducer(streamId, streamProvider);
ISampleStreaming_InlineConsumerGrain consumer = SampleStreaming_InlineConsumerGrainFactory.GetGrain(Guid.NewGuid());
await consumer.BecomeConsumer(streamId, streamProvider);
await producer.StartPeriodicProducing();
Thread.Sleep(1000);
await producer.StopPeriodicProducing();
//int numProduced = producer.NumberProduced.Result;
await UnitTestUtils.WaitUntilAsync(() => CheckCounters( producer, consumer, assertAreEqual : false ), _timeout);
await CheckCounters(producer, consumer);
await consumer.StopConsuming();
}
