public static Task <ConsumerProxy> NewProducerConsumerGrainsAsync(Guid streamId, string streamProvider, TraceLogger logger, int[] grainIds, bool useReentrantGrain)
{
int grainCount = grainIds.Length;
if (grainCount < 1)
{
throw new ArgumentOutOfRangeException("grainIds", "The grain count must be at least one");
}
logger.Info("ConsumerProxy.NewProducerConsumerGrainsAsync: multiplexing {0} consumer grains for stream {1}.", grainCount, streamId);
var grains = new IStreaming_ConsumerGrain[grainCount];
var dedup = new Dictionary <int, IStreaming_ConsumerGrain>();
for (var i = 0; i < grainCount; ++i)
{
// we deduplicate the grain references to ensure that IEnumerable.Distinct() works as intended.
if (dedup.ContainsKey(grainIds[i]))
{
grains[i] = dedup[grainIds[i]];
}
else
{
if (useReentrantGrain)
{
grains[i] = GrainClient.GrainFactory.GetGrain <IStreaming_Reentrant_ProducerConsumerGrain>(grainIds[i]);
}
else
{
var grainFullName = typeof(Streaming_ProducerConsumerGrain).FullName;
grains[i] = GrainClient.GrainFactory.GetGrain <IStreaming_ProducerConsumerGrain>(grainIds[i], grainFullName);
}
dedup[grainIds[i]] = grains[i];
}
}
return(NewConsumerProxy(streamId, streamProvider, grains, logger));
}
public static Task <ConsumerProxy> NewConsumerGrainsAsync(Guid streamId, string streamProvider, ILogger logger, IInternalGrainFactory grainFactory, Guid[] grainIds = null, int grainCount = 1)
{
grainCount = grainIds != null ? grainIds.Length : grainCount;
if (grainCount < 1)
{
throw new ArgumentOutOfRangeException("grainCount", "The grain count must be at least one");
}
logger.LogInformation("ConsumerProxy.NewConsumerGrainsAsync: multiplexing {GrainCount} consumer grains for stream {StreamId}.", grainCount, streamId);
var grains = new IStreaming_ConsumerGrain[grainCount];
var dedup = new Dictionary <Guid, IStreaming_ConsumerGrain>();
var grainFullName = typeof(Streaming_ConsumerGrain).FullName;
for (var i = 0; i < grainCount; ++i)
{
if (grainIds != null)
{
// we deduplicate the grain references to ensure that IEnumerable.Distinct() works as intended.
if (dedup.ContainsKey(grainIds[i]))
{
grains[i] = dedup[grainIds[i]];
}
else
{
var gref = grainFactory.GetGrain <IStreaming_ConsumerGrain>(grainIds[i], grainFullName);
grains[i] = gref;
dedup[grainIds[i]] = gref;
}
}
else
{
grains[i] = grainFactory.GetGrain <IStreaming_ConsumerGrain>(Guid.NewGuid(), grainFullName);
}
}
return(NewConsumerProxy(streamId, streamProvider, grains, logger, grainFactory));
}
public async Task ProvidersTests_ConfigNotLoaded()
{
Guid streamId = Guid.NewGuid();
var grainFullName = typeof(Streaming_ConsumerGrain).FullName;
// consumer joins first, producer later
IStreaming_ConsumerGrain consumer = this.HostedCluster.GrainFactory.GetGrain <IStreaming_ConsumerGrain>(Guid.NewGuid(), grainFullName);
await Assert.ThrowsAsync <KeyNotFoundException>(() => consumer.BecomeConsumer(streamId, STREAM_PROVIDER_NAME, null));
}
public async Task ProvidersTests_ProviderWrongName()
{
Guid streamId = Guid.NewGuid();
var grainFullName = typeof(Streaming_ConsumerGrain).FullName;
// consumer joins first, producer later
IStreaming_ConsumerGrain consumer = this.grainFactory.GetGrain <IStreaming_ConsumerGrain>(Guid.NewGuid(), grainFullName);
await Assert.ThrowsAsync <KeyNotFoundException>(() => consumer.BecomeConsumer(streamId, "WrongProviderName", null));
}
public static Task <ConsumerProxy> NewConsumerClientObjectsAsync(Guid streamId, string streamProvider, TraceLogger logger, int consumerCount = 1)
{
if (consumerCount < 1)
{
throw new ArgumentOutOfRangeException("consumerCount", "argument must be 1 or greater");
}
logger.Info("ConsumerProxy.NewConsumerClientObjectsAsync: multiplexing {0} consumer client objects for stream {1}.", consumerCount, streamId);
var objs = new IStreaming_ConsumerGrain[consumerCount];
for (var i = 0; i < consumerCount; ++i)
{
objs[i] = Streaming_ConsumerClientObject.NewObserver(logger);
}
return(NewConsumerProxy(streamId, streamProvider, objs, logger));
}
public static ConsumerProxy NewConsumerGrainAsync_WithoutBecomeConsumer(Guid consumerGrainId, TraceLogger logger, string grainClassName = "")
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (string.IsNullOrEmpty(grainClassName))
{
grainClassName = typeof(Streaming_ConsumerGrain).FullName;
}
var grains = new IStreaming_ConsumerGrain[1];
grains[0] = GrainClient.GrainFactory.GetGrain <IStreaming_ConsumerGrain>(consumerGrainId, grainClassName);
ConsumerProxy newObj = new ConsumerProxy(grains, logger);
return(newObj);
}
public void ProvidersTests_ConfigNotLoaded()
{
bool hasThrown = false;
Guid streamId = Guid.NewGuid();
var grainFullName = typeof(Streaming_ConsumerGrain).FullName;
// consumer joins first, producer later
IStreaming_ConsumerGrain consumer = GrainClient.GrainFactory.GetGrain <IStreaming_ConsumerGrain>(Guid.NewGuid(), grainFullName);
try
{
consumer.BecomeConsumer(streamId, STREAM_PROVIDER_NAME, null).Wait();
}
catch (Exception exc)
{
hasThrown = true;
Exception baseException = exc.GetBaseException();
Assert.AreEqual(typeof(KeyNotFoundException), baseException.GetType());
}
Assert.IsTrue(hasThrown, "Should have thrown.");
}
public void ProvidersTests_ProviderWrongName()
{
bool hasThrown = false;
Guid streamId = Guid.NewGuid();
var grainFullName = typeof(Streaming_ConsumerGrain).FullName;
// consumer joins first, producer later
IStreaming_ConsumerGrain consumer = GrainClient.GrainFactory.GetGrain <IStreaming_ConsumerGrain>(Guid.NewGuid(), grainFullName);
try
{
consumer.BecomeConsumer(streamId, "WrongProviderName", null).Wait();
}
catch (Exception exc)
{
Exception baseException = exc.GetBaseException();
Assert.AreEqual(typeof(KeyNotFoundException), baseException.GetType());
}
hasThrown = true;
Assert.IsTrue(hasThrown);
}
