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 Thread.Sleep(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 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 Thread.Sleep(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 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 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); }
private async Task <bool> CheckCounters(ISampleStreaming_ProducerGrain producer, Func <int> eventCount, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = eventCount(); if (assertIsTrue) { Assert.IsTrue(numProduced > 0, "Events were not produced"); Assert.AreEqual(numProduced, numConsumed, "Produced and consumed counts do not match"); } else if (numProduced <= 0 || // no events produced? numProduced != numConsumed) { if (numProduced <= 0) { logger.Info("numProduced <= 0: Events were not produced"); } if (numProduced != numConsumed) { logger.Info("numProduced != numConsumed: Produced and consumed counts do not match. numProduced = {0}, consumed = {1}", numProduced, numConsumed); } return(false); } logger.Info("All counts are equal. numProduced = {0}, numConsumed = {1}", numProduced, numConsumed); return(true); }
private async Task <bool> CheckCounters(ISampleStreaming_ProducerGrain producer, IMultipleSubscriptionConsumerGrain consumer, int consumerCount, StreamSubscriptionHandle <int> handler, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = await consumer.GetNumberConsumed(); if (assertIsTrue) { Assert.IsTrue(numProduced > 0, "Events were not produced"); Assert.AreEqual(consumerCount, numConsumed.Count, "Incorrect number of consumers"); if (handler != null) { var numHandlerConsumed = numConsumed[handler]; Assert.AreEqual(numProduced, numHandlerConsumed, "Producer and consumer do not match"); } else { foreach (int consumed in numConsumed.Values) { Assert.AreEqual(numProduced, consumed, "Produced and consumed counts do not match"); } } } else if (numProduced <= 0 || // no events produced? consumerCount != numConsumed.Count || // subscription counts are wrong? handler == null ? numConsumed.Values.All(consumedCount => consumedCount != numProduced) : numConsumed[handler] != numProduced) // consumed events don't match produced events for any subscription or specific handler (if sent)? { if (numProduced <= 0) { _logger.Info("numProduced <= 0: Events were not produced"); } if (consumerCount != numConsumed.Count) { _logger.Info("consumerCount != numConsumed.Count: Incorrect number of consumers. consumerCount = {0}, numConsumed.Count = {1}", consumerCount, numConsumed.Count); } foreach (int consumed in numConsumed.Values) { if (numProduced != consumed) { _logger.Info("numProduced != consumed: Produced and consumed counts do not match. numProduced = {0}, consumed = {1}", numProduced, consumed); //numProduced, Utils.DictionaryToString(numConsumed)); } } return(false); } if (handler != null) { _logger.Info("All counts are equal. numProduced = {0}, numHandlerConsumed = {1}, consumersCount = {2}", numProduced, numConsumed[handler], consumerCount); //Utils.DictionaryToString(numConsumed)); } else { _logger.Info("All counts are equal. numProduced = {0}, consumersCount = {1}", numProduced, consumerCount); //Utils.DictionaryToString(numConsumed)); } return(true); }
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); }
private async Task <bool> CheckCounters(ISampleStreaming_ProducerGrain producer, IMultipleSubscriptionConsumerGrain consumer, int consumerCount, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = await consumer.GetNumberConsumed(); if (assertIsTrue) { Assert.True(numConsumed.Values.All(v => v.Item2 == 0), "Errors"); Assert.True(numProduced > 0, "Events were not produced"); Assert.Equal(consumerCount, numConsumed.Count); foreach (int consumed in numConsumed.Values.Select(v => v.Item1)) { Assert.Equal(numProduced, consumed); } } else if (numProduced <= 0 || // no events produced? consumerCount != numConsumed.Count || // subscription counts are wrong? numConsumed.Values.Any(consumedCount => consumedCount.Item1 != numProduced) || // consumed events don't match produced events for any subscription? numConsumed.Values.Any(v => v.Item2 != 0)) // stream errors { if (numProduced <= 0) { logger.LogInformation("numProduced <= 0: Events were not produced"); } if (consumerCount != numConsumed.Count) { logger.LogInformation( "consumerCount != numConsumed.Count: Incorrect number of consumers. consumerCount = {ConsumerCount}, numConsumed.Count = {ConsumedCount}", consumerCount, numConsumed.Count); } foreach (var consumed in numConsumed) { if (numProduced != consumed.Value.Item1) { logger.LogInformation("numProduced != consumed: Produced and consumed counts do not match. numProduced = {ProducedCount}, consumed = {ConsumedCount}", numProduced, consumed.Key.HandleId + " -> " + consumed.Value); //numProduced, Utils.DictionaryToString(numConsumed)); } } return(false); } logger.LogInformation( "All counts are equal. numProduced = {ProducedCount}, numConsumed = {ConsumedCount}", numProduced, Utils.EnumerableToString( numConsumed, kvp => kvp.Key.HandleId.ToString() + "->" + kvp.Value.ToString())); return(true); }
private async Task <bool> CheckCounters(ISampleStreaming_ProducerGrain producer, ISampleStreaming_ConsumerGrain consumer, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = await consumer.GetNumberConsumed(); logger.Info("CheckCounters: numProduced = {0}, numConsumed = {1}", numProduced, numConsumed); if (assertIsTrue) { Assert.Equal(numProduced, numConsumed); return(true); } else { return(numProduced == numConsumed); } }
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 <bool> CheckCounters(ISampleStreaming_ProducerGrain producer, IMultipleSubscriptionConsumerGrain consumer, int consumerCount, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = await consumer.GetNumberConsumed(); if (assertIsTrue) { Assert.IsTrue(numProduced > 0, "Events were not produced"); Assert.AreEqual(consumerCount, numConsumed.Count, "Incorrect number of consumers"); foreach (int consumed in numConsumed.Values) { Assert.AreEqual(numProduced, consumed, "Produced and consumed counts do not match"); } } else if (numProduced <= 0 || // no events produced? consumerCount != numConsumed.Count || // subscription counts are wrong? numConsumed.Values.Any(consumedCount => consumedCount != numProduced)) // consumed events don't match produced events for any subscription? { return(false); } return(true); }
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(); }
private async Task<bool> CheckCounters(ISampleStreaming_ProducerGrain producer, Func<int> eventCount, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = eventCount(); if (assertIsTrue) { Assert.IsTrue(numProduced > 0, "Events were not produced"); Assert.AreEqual(numProduced, numConsumed, "Produced and consumed counts do not match"); } else if (numProduced <= 0 || // no events produced? numProduced != numConsumed) { if (numProduced <= 0) { logger.Info("numProduced <= 0: Events were not produced"); } if (numProduced != numConsumed) { logger.Info("numProduced != numConsumed: Produced and consumed counts do not match. numProduced = {0}, consumed = {1}", numProduced, numConsumed); } return false; } logger.Info("All counts are equal. numProduced = {0}, numConsumed = {1}", numProduced, numConsumed); return true; }
private async Task<bool> CheckCounters(ISampleStreaming_ProducerGrain producer, IMultipleSubscriptionConsumerGrain consumer, int consumerCount, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = await consumer.GetNumberConsumed(); if (assertIsTrue) { Assert.IsTrue(numConsumed.Values.All(v => v.Item2 == 0), "Errors"); Assert.IsTrue(numProduced > 0, "Events were not produced"); Assert.AreEqual(consumerCount, numConsumed.Count, "Incorrect number of consumers"); foreach (int consumed in numConsumed.Values.Select(v => v.Item1)) { Assert.AreEqual(numProduced, consumed, "Produced and consumed counts do not match"); } } else if (numProduced <= 0 || // no events produced? consumerCount != numConsumed.Count || // subscription counts are wrong? numConsumed.Values.Any(consumedCount => consumedCount.Item1 != numProduced) ||// consumed events don't match produced events for any subscription? numConsumed.Values.Any(v => v.Item2 != 0)) // stream errors { if (numProduced <= 0) { logger.Info("numProduced <= 0: Events were not produced"); } if (consumerCount != numConsumed.Count) { logger.Info("consumerCount != numConsumed.Count: Incorrect number of consumers. consumerCount = {0}, numConsumed.Count = {1}", consumerCount, numConsumed.Count); } foreach (var consumed in numConsumed) { if (numProduced != consumed.Value.Item1) { logger.Info("numProduced != consumed: Produced and consumed counts do not match. numProduced = {0}, consumed = {1}", numProduced, consumed.Key.HandleId + " -> " + consumed.Value); //numProduced, Utils.DictionaryToString(numConsumed)); } } return false; } logger.Info("All counts are equal. numProduced = {0}, numConsumed = {1}", numProduced, Utils.EnumerableToString(numConsumed, kvp => kvp.Key.HandleId.ToString() + "->" + kvp.Value.ToString())); return true; }
private async Task<bool> CheckCounters(ISampleStreaming_ProducerGrain producer, ISampleStreaming_ConsumerGrain consumer, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = await consumer.GetNumberConsumed(); logger.Info("CheckCounters: numProduced = {0}, numConsumed = {1}", numProduced, numConsumed); if (assertIsTrue) { Assert.AreEqual(numProduced, numConsumed, String.Format("numProduced = {0}, numConsumed = {1}", numProduced, numConsumed)); return true; } else { return numProduced == numConsumed; } }
private async Task<bool> CheckCounters(ISampleStreaming_ProducerGrain producer, IMultipleSubscriptionConsumerGrain consumer, int consumerCount, StreamSubscriptionHandle<int> handler, bool assertIsTrue) { var numProduced = await producer.GetNumberProduced(); var numConsumed = await consumer.GetNumberConsumed(); if (assertIsTrue) { Assert.IsTrue(numProduced > 0, "Events were not produced"); Assert.AreEqual(consumerCount, numConsumed.Count, "Incorrect number of consumers"); if (handler != null) { var numHandlerConsumed = numConsumed[handler]; Assert.AreEqual(numProduced, numHandlerConsumed, "Producer and consumer do not match"); } else { foreach (int consumed in numConsumed.Values) { Assert.AreEqual(numProduced, consumed, "Produced and consumed counts do not match"); } } } else if (numProduced <= 0 || // no events produced? consumerCount != numConsumed.Count || // subscription counts are wrong? handler == null ? numConsumed.Values.All(consumedCount => consumedCount != numProduced) : numConsumed[handler] != numProduced) // consumed events don't match produced events for any subscription or specific handler (if sent)? { if (numProduced <= 0) { _logger.Info("numProduced <= 0: Events were not produced"); } if (consumerCount != numConsumed.Count) { _logger.Info("consumerCount != numConsumed.Count: Incorrect number of consumers. consumerCount = {0}, numConsumed.Count = {1}", consumerCount, numConsumed.Count); } foreach (int consumed in numConsumed.Values) { if (numProduced != consumed) { _logger.Info("numProduced != consumed: Produced and consumed counts do not match. numProduced = {0}, consumed = {1}", numProduced, consumed); //numProduced, Utils.DictionaryToString(numConsumed)); } } return false; } if (handler != null) { _logger.Info("All counts are equal. numProduced = {0}, numHandlerConsumed = {1}, consumersCount = {2}", numProduced, numConsumed[handler], consumerCount); //Utils.DictionaryToString(numConsumed)); } else { _logger.Info("All counts are equal. numProduced = {0}, consumersCount = {1}", numProduced, consumerCount); //Utils.DictionaryToString(numConsumed)); } return true; }