//public async Task StreamTest_17_Persistence_OneProducerGrainOneConsumerGrain() //{ // Heading("StreamTest_17_Persistence_OneProducerGrainOneConsumerGrain"); // StreamId streamId = StreamId.NewRandomStreamId(); // // consumer joins first, producer later // consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); // producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, logger); // await BasicTestAsync(false); // await consumer.DeactivateOnIdle(); // await producer.DeactivateOnIdle(); // await UnitTestBase.WaitUntilAsync(() => CheckGrainsDeactivated(null, consumer, assertAreEqual: false), _timeout); // await UnitTestBase.WaitUntilAsync(() => CheckGrainsDeactivated(producer, null, assertAreEqual: false), _timeout); // logger.Info("*******************************************************************"); // //await BasicTestAsync(false); // //await StopProxies(); //} public async Task StreamTest_19_ConsumerImplicitlySubscribedToProducerClient() { Heading("StreamTest_19_ConsumerImplicitlySubscribedToProducerClient"); string consumerTypeName = typeof(Streaming_ImplicitlySubscribedConsumerGrain).FullName; Guid streamGuid = Guid.NewGuid(); producer = await ProducerProxy.NewProducerClientObjectsAsync(streamGuid, streamProviderName, "TestNamespace1", logger); consumer = ConsumerProxy.NewConsumerGrainAsync_WithoutBecomeConsumer(streamGuid, logger, consumerTypeName); logger.Info("\n** Starting Test {0}.\n", testNumber); var producerCount = await producer.ProducerCount; logger.Info("\n** Test {0} BasicTestAsync: producerCount={1}.\n", testNumber, producerCount); Func <bool, Task <bool> > waitUntilFunc = async lastTry => 0 < await TestUtils.GetActivationCount(consumerTypeName) && await CheckCounters(producer, consumer, false); await producer.ProduceSequentialSeries(ItemCount); await TestingUtils.WaitUntilAsync(waitUntilFunc, _timeout); await CheckCounters(producer, consumer); await StopProxies(); }
public async Task StreamTest_16_Deactivation_OneProducerGrainOneConsumerGrain() { Heading("StreamTest_16_Deactivation_OneProducerGrainOneConsumerGrain"); Guid streamId = Guid.NewGuid(); Guid[] consumerGrainIds = { Guid.NewGuid() }; Guid[] producerGrainIds = { Guid.NewGuid() }; // consumer joins first, producer later consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger, consumerGrainIds); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger, producerGrainIds); await BasicTestAsync(false); //await consumer.StopBeingConsumer(); await StopProxies(); await consumer.DeactivateOnIdle(); await producer.DeactivateOnIdle(); await TestingUtils.WaitUntilAsync(lastTry => CheckGrainsDeactivated(null, consumer, false), _timeout); await TestingUtils.WaitUntilAsync(lastTry => CheckGrainsDeactivated(producer, null, false), _timeout); logger.Info("\n\n\n*******************************************************************\n\n\n"); consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger, consumerGrainIds); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger, producerGrainIds); await BasicTestAsync(false); await StopProxies(); }
private async Task <bool> CheckGrainsDeactivated(ProducerProxy producer, ConsumerProxy consumer, bool assertAreEqual = true) { var activationCount = 0; string str = ""; if (producer != null) { str = "Producer"; activationCount = await producer.GetNumActivations(this.client); } else if (consumer != null) { str = "Consumer"; activationCount = await consumer.GetNumActivations(this.client); } var expectActivationCount = 0; logger.Info( "Test {testNumber} CheckGrainsDeactivated: {type}ActivationCount = {activationCount}, Expected{type}ActivationCount = {expectActivationCount}", testNumber, str, activationCount, str, expectActivationCount); if (assertAreEqual) { Assert.Equal(expectActivationCount, activationCount); // String.Format("Expected{0}ActivationCount = {1}, {0}ActivationCount = {2}", str, expectActivationCount, activationCount)); } return(expectActivationCount == activationCount); }
public async Task StreamTest_21_GenericConsumerImplicitlySubscribedToProducerGrain() { Heading("StreamTest_21_GenericConsumerImplicitlySubscribedToProducerGrain"); //ToDo in migrate: the following consumer grain is not implemented in VSO and all tests depend on it fail. string consumerTypeName = "UnitTests.Grains.Streaming_ImplicitlySubscribedGenericConsumerGrain";//typeof(Streaming_ImplicitlySubscribedGenericConsumerGrain).FullName; Guid streamGuid = Guid.NewGuid(); producer = await ProducerProxy.NewProducerGrainsAsync(streamGuid, streamProviderName, "TestNamespace1", logger); consumer = ConsumerProxy.NewConsumerGrainAsync_WithoutBecomeConsumer(streamGuid, logger, consumerTypeName); logger.Info("\n** Starting Test {0}.\n", testNumber); var producerCount = await producer.ProducerCount; logger.Info("\n** Test {0} BasicTestAsync: producerCount={1}.\n", testNumber, producerCount); Func <bool, Task <bool> > waitUntilFunc = async lastTry => 0 < await TestUtils.GetActivationCount(consumerTypeName) && await CheckCounters(producer, consumer, false); await producer.ProduceSequentialSeries(ItemCount); await TestingUtils.WaitUntilAsync(waitUntilFunc, _timeout); await CheckCounters(producer, consumer); await StopProxies(); }
private async Task <bool> CheckCounters(ProducerProxy producer, ConsumerProxy consumer, bool assertAreEqual = true) { var consumerCount = await consumer.ConsumerCount; Assert.NotEqual(0, consumerCount); // "no consumers were detected." _ = await producer.ProducerCount; var numProduced = await producer.ExpectedItemsProduced; var expectConsumed = numProduced * consumerCount; var numConsumed = await consumer.ItemsConsumed; logger.LogInformation( "Test {TestNumber} CheckCounters: numProduced = {NumProduced}, expectConsumed = {ExpectedConsumed}, numConsumed = {NumConsumed}", testNumber, numProduced, expectConsumed, numConsumed); if (assertAreEqual) { Assert.Equal(expectConsumed, numConsumed); // String.Format("expectConsumed = {0}, numConsumed = {1}", expectConsumed, numConsumed)); return(true); } else { return(expectConsumed == numConsumed); } }
internal async Task StreamTest_Create_OneProducerGrainOneConsumerGrain() { Guid streamId = Guid.NewGuid(); this.consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, this.streamProviderName, this.logger, this.client); this.producer = await ProducerProxy.NewProducerGrainsAsync(streamId, this.streamProviderName, null, this.logger, this.client); }
internal async Task StreamTest_Create_OneProducerGrainOneConsumerGrain() { Guid streamId = Guid.NewGuid(); consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); }
public async Task StreamTest_08_ManyDifferent_ManyProducerClientsManyConsumerClients() { Heading("StreamTest_08_ManyDifferent_ManyProducerClientsManyConsumerClients"); Guid streamId = Guid.NewGuid(); consumer = await ConsumerProxy.NewConsumerClientObjectsAsync(streamId, streamProviderName, logger, Many); producer = await ProducerProxy.NewProducerClientObjectsAsync(streamId, streamProviderName, null, logger, Many); await BasicTestAsync(); await StopProxies(); }
//------------------------ MANY to Many different grains ----------------------// public async Task StreamTest_05_ManyDifferent_ManyProducerGrainsManyConsumerGrains() { Heading("StreamTest_05_ManyDifferent_ManyProducerGrainsManyConsumerGrains"); Guid streamId = Guid.NewGuid(); this.consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, this.streamProviderName, this.logger, this.client, null, Many); this.producer = await ProducerProxy.NewProducerGrainsAsync(streamId, this.streamProviderName, null, this.logger, this.client, null, Many); await BasicTestAsync(); await StopProxies(); }
public async Task StreamTest_12_ManySame_ManyProducerClientsManyConsumerGrains() { Heading("StreamTest_12_ManySame_ManyProducerClientsManyConsumerGrains"); Guid streamId = Guid.NewGuid(); Guid grain1 = Guid.NewGuid(); Guid[] consumerGrainIds = new Guid[] { grain1, grain1, grain1 }; consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger, consumerGrainIds); producer = await ProducerProxy.NewProducerClientObjectsAsync(streamId, streamProviderName, null, logger, Many); await BasicTestAsync(); await StopProxies(); }
//------------------------ MANY to Many producer consumer same grain ----------------------// public async Task StreamTest_13_SameGrain_ConsumerFirstProducerLater(bool useReentrantGrain) { Heading("StreamTest_13_SameGrain_ConsumerFirstProducerLater"); Guid streamId = Guid.NewGuid(); int grain1 = ThreadSafeRandom.Next(); int[] grainIds = new int[] { grain1 }; // consumer joins first, producer later this.consumer = await ConsumerProxy.NewProducerConsumerGrainsAsync(streamId, this.streamProviderName, this.logger, grainIds, useReentrantGrain, this.client); this.producer = await ProducerProxy.NewProducerConsumerGrainsAsync(streamId, this.streamProviderName, this.logger, grainIds, useReentrantGrain, this.client); await BasicTestAsync(); await StopProxies(); }
public async Task StreamTest_14_SameGrain_ProducerFirstConsumerLater(bool useReentrantGrain) { Heading("StreamTest_14_SameGrain_ProducerFirstConsumerLater"); Guid streamId = Guid.NewGuid(); int grain1 = random.Next(); int[] grainIds = new int[] { grain1 }; // produce joins first, consumer later producer = await ProducerProxy.NewProducerConsumerGrainsAsync(streamId, streamProviderName, logger, grainIds, useReentrantGrain); consumer = await ConsumerProxy.NewProducerConsumerGrainsAsync(streamId, streamProviderName, logger, grainIds, useReentrantGrain); await BasicTestAsync(); await StopProxies(); }
public async Task StreamTest_10_ManySame_ManyConsumerGrainsManyProducerGrains() { Heading("StreamTest_10_ManySame_ManyConsumerGrainsManyProducerGrains"); Guid streamId = Guid.NewGuid(); Guid grain1 = Guid.NewGuid(); Guid grain2 = Guid.NewGuid(); Guid[] consumerGrainIds = new Guid[] { grain1, grain1, grain1 }; Guid[] producerGrainIds = new Guid[] { grain2, grain2, grain2 }; // consumer joins first, producer later consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger, consumerGrainIds); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger, producerGrainIds); await BasicTestAsync(); await StopProxies(); }
//----------------------------------------------// public async Task StreamTest_15_ConsumeAtProducersRequest() { Heading("StreamTest_15_ConsumeAtProducersRequest"); Guid streamId = Guid.NewGuid(); // this reproduces a scenario was discovered to not work (deadlock) by the Halo team. the scenario is that // where a producer calls a consumer, which subscribes to the calling producer. producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); Guid consumerGrainId = await producer.AddNewConsumerGrain(); consumer = ConsumerProxy.NewConsumerGrainAsync_WithoutBecomeConsumer(consumerGrainId, logger); await BasicTestAsync(); await StopProxies(); }
public async Task StreamTest_03_OneProducerClientOneConsumerGrain() { Heading("StreamTest_03_OneProducerClientOneConsumerGrain"); Guid streamId = Guid.NewGuid(); consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); producer = await ProducerProxy.NewProducerClientObjectsAsync(streamId, streamProviderName, null, logger); await BasicTestAsync(); await StopProxies(); streamId = Guid.NewGuid(); producer = await ProducerProxy.NewProducerClientObjectsAsync(streamId, streamProviderName, null, logger); consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); await BasicTestAsync(); await StopProxies(); }
//------------------------ One to One ----------------------// public async Task StreamTest_01_OneProducerGrainOneConsumerGrain() { Heading("StreamTest_01_ConsumerJoinsFirstProducerLater"); Guid streamId = Guid.NewGuid(); // consumer joins first, producer later consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); await BasicTestAsync(); await StopProxies(); streamId = Guid.NewGuid(); // produce joins first, consumer later producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); await BasicTestAsync(); await StopProxies(); }
private static async Task <ProducerProxy> NewProducerProxy(IStreaming_ProducerGrain[] targets, Guid streamId, string streamProvider, string streamNamespace, TraceLogger logger) { if (targets == null) { throw new ArgumentNullException("targets"); } if (String.IsNullOrWhiteSpace(streamProvider)) { throw new ArgumentException("Stream provider name is either null or whitespace", "streamProvider"); } if (logger == null) { throw new ArgumentNullException("logger"); } ProducerProxy newObj = new ProducerProxy(targets, streamId, streamProvider, logger); await newObj.BecomeProducer(streamId, streamProvider, streamNamespace); return(newObj); }