//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);
}
