public Task BecomeProducer(Guid streamId, string streamNamespace, string providerToUse)
{
Logger.Info("BecomeProducer");
IStreamProvider streamProvider = GetStreamProvider(providerToUse);
_producer = streamProvider.GetStream<int>(streamId, streamNamespace);
return TaskDone.Done;
}
public override async Task OnActivateAsync()
{
logger = base.GetLogger("MultipleImplicitSubscriptionGrain " + base.IdentityString);
logger.Info("OnActivateAsync");
var streamProvider = GetStreamProvider("SMSProvider");
redStream = streamProvider.GetStream<int>(this.GetPrimaryKey(), "red");
blueStream = streamProvider.GetStream<int>(this.GetPrimaryKey(), "blue");
await redStream.SubscribeAsync(
(e, t) =>
{
logger.Info("Received a red event {0}", e);
redCounter++;
return TaskDone.Done;
});
await blueStream.SubscribeAsync(
(e, t) =>
{
logger.Info("Received a blue event {0}", e);
blueCounter++;
return TaskDone.Done;
});
}
public override async Task OnActivateAsync()
{
logger = base.GetLogger("GeneratedEvenCollectorGrain " + base.IdentityString);
logger.Info("OnActivateAsync");
var streamProvider = GetStreamProvider(StreamProviderName);
stream = streamProvider.GetStream<GeneratedEvent>(this.GetPrimaryKey(), StreamNamespace);
await stream.SubscribeAsync(
(e, t) =>
{
counter++;
logger.Info("Received a generated event {0}, of {1} events", e, counter);
if (e.EventType == GeneratedEvent.GeneratedEventType.Fill)
{
return TaskDone.Done;
}
var reporter = this.GrainFactory.GetGrain<IGeneratedEventReporterGrain>(ReporterId);
return reporter.ReportResult(this.GetPrimaryKey(), StreamProviderName, StreamNamespace, counter);
});
}
// Accept a queryResult instance which we shall observe public OrleansQueryResultStream(IAsyncStream <TIGrain> stream) => this._stream = stream;
public static IAsyncStream <TOutput> Chain <TInput, TOutput>(this IAsyncStream <TInput> source, AsyncStreamFunc <TInput, TOutput> target, TOutput sentinel = default, CancellationToken cancellationToken = default)
{
return(target(source).ToStream(sentinel, cancellationToken));
}
public int CompareTo(IAsyncStream <T> other)
{
throw new NotImplementedException();
}
protected virtual Task ProducerOnNextAsync(IAsyncStream <T> theProducer)
{
return(theProducer.OnNextAsync(Activator.CreateInstance <T>()));
}
public EventStream(IAsyncStream <byte[]> asyncStream)
{
this.asyncStream = asyncStream;
}
public int CompareTo(IAsyncStream <T> other)
{
var o = other as StreamImpl <T>;
return(o == null ? 1 : streamId.CompareTo(o.streamId));
}
public StreamVentilator(IAsyncStream <T> stream, Func <T, Task> fan, Func <IEnumerable <T>, Task> batchFan)
{
this.stream = stream;
this.fan = fan;
this.batchFan = batchFan;
}
private IInternalAsyncObservable <T> GetConsumerInterfaceImpl <T>(IAsyncStream <T> stream)
{
return(new StreamConsumer <T>((StreamImpl <T>)stream, Name, providerRuntime,
providerRuntime.PubSub(this.options.PubSubType), this.logger, IsRewindable));
}
IInternalAsyncBatchObserver <T> IInternalStreamProvider.GetProducerInterface <T>(IAsyncStream <T> stream)
{
if (queueAdapter.Direction == StreamProviderDirection.ReadOnly)
{
throw new InvalidOperationException($"Stream provider {queueAdapter.Name} is ReadOnly.");
}
return(new PersistentStreamProducer <T>((StreamImpl <T>)stream, providerRuntime, queueAdapter, IsRewindable, this.serializationManager));
}
public async Task PubSubStoreRetrievalTest()
{
//var strmId = Guid.NewGuid();
var strmId = Guid.Parse("761E3BEC-636E-4F6F-A56B-9CC57E66B712");
var streamProv = _client.GetStreamProvider("SMSProvider");
IAsyncStream <int> stream = streamProv.GetStream <int>(strmId, "test1");
//IAsyncStream<int> streamIn = streamProv.GetStream<int>(strmId, "test1");
for (int i = 0; i < 25; i++)
{
await stream.OnNextAsync(i);
}
StreamSubscriptionHandle <int> handle = await stream.SubscribeAsync(
(e, t) =>
{
Console.WriteLine(string.Format("{0}{1}", e, t));
return(Task.CompletedTask);
},
e => { return(Task.CompletedTask); });
for (int i = 100; i < 25; i++)
{
await stream.OnNextAsync(i);
}
StreamSubscriptionHandle <int> handle2 = await stream.SubscribeAsync(
(e, t) =>
{
Console.WriteLine(string.Format("2222-{0}{1}", e, t));
return(Task.CompletedTask);
},
e => { return(Task.CompletedTask); });
for (int i = 1000; i < 25; i++)
{
await stream.OnNextAsync(i);
}
var sh = await stream.GetAllSubscriptionHandles();
Assert.Equal(2, sh.Count);
IAsyncStream <int> stream2 = streamProv.GetStream <int>(strmId, "test1");
for (int i = 10000; i < 25; i++)
{
await stream2.OnNextAsync(i);
}
StreamSubscriptionHandle <int> handle2More = await stream2.SubscribeAsync(
(e, t) =>
{
Console.WriteLine(string.Format("{0}{1}", e, t));
return(Task.CompletedTask);
},
e => { return(Task.CompletedTask); });
for (int i = 10000; i < 25; i++)
{
await stream2.OnNextAsync(i);
}
}
public InternalStreamMessageSender(IStreamProvider provider, StreamIdentity targetStream)
{
_streamIdentity = targetStream;
_messageStream = provider.GetStream <IStreamMessage>(_streamIdentity.Guid, _streamIdentity.Namespace);
_tearDownExecuted = false;
}
public SendToStream(IAsyncStream <Immutable <PayloadMessage> > stream, int batchingLimit = 100) : base(batchingLimit)
{
this.stream = stream;
}
public static IAsyncStream <T> ComposeAndChain <T>(this IAsyncStream <T> source, params AsyncStreamFunc <T, T>[] functions)
{
return(functions.Aggregate(
source,
(stream, f) => stream.Chain(f)));
}
IInternalAsyncBatchObserver <T> IInternalStreamProvider.GetProducerInterface <T>(IAsyncStream <T> stream)
{
return(new SimpleMessageStreamProducer <T>((StreamImpl <T>)stream, Name, providerRuntime,
fireAndForgetDelivery, optimizeForImmutableData, providerRuntime.PubSub(pubSubType), IsRewindable));
}
public bool Equals(IAsyncStream <T> other) => stream.Equals(other);
/// <inheritdoc/>
IInternalAsyncObservable <T> IInternalStreamProvider.GetConsumerInterface <T>(IAsyncStream <T> streamId)
{
return(GetConsumerInterfaceImpl(streamId));
}
public int CompareTo(IAsyncStream <T> other) => stream.CompareTo(other);
/// <inheritdoc/>
IInternalAsyncBatchObserver <T> IInternalStreamProvider.GetProducerInterface <T>(IAsyncStream <T> stream)
{
return(new SimpleMessageStreamProducer <T>(
(StreamImpl <T>)stream,
Name,
providerRuntime,
this.options.FireAndForgetDelivery,
this.options.OptimizeForImmutableData,
providerRuntime.PubSub(this.options.PubSubType),
this.streamFilter,
IsRewindable,
this.runtimeClient.ServiceProvider.GetRequiredService <DeepCopier <T> >(),
this.loggerFactory.CreateLogger <SimpleMessageStreamProducer <T> >()));
}
public Parser(TranslationUnit tu, IAsyncStream <Token> input)
{
TranslationUnit = tu;
InputStream = input;
}
public Task OnConnect(Guid serverId)
{
State.ServerId = serverId;
_serverStream = _streamProvider.GetStream <ClientMessage>(State.ServerId, Constants.SERVERS_STREAM);
return(WriteStateAsync());
}
public IAsyncBatchObserver <T> GetProducerInterface <T>(IAsyncStream <T> stream)
{
return(new PersistentStreamProducer <T>((StreamImpl <T>)stream, providerRuntime, queueAdapter, IsRewindable));
}
public virtual bool Equals(IAsyncStream <T> other)
{
var o = other as StreamImpl <T>;
return(o != null && streamId.Equals(o.streamId));
}
private IInternalAsyncObservable <T> GetConsumerInterfaceImpl <T>(IAsyncStream <T> stream)
{
return(new StreamConsumer <T>((StreamImpl <T>)stream, Name, providerRuntime, providerRuntime.PubSub(StreamPubSubType.GrainBased), IsRewindable));
}
public bool Equals(IAsyncStream <T> other)
{
throw new NotImplementedException();
}
public abstract Task <Task> CustomExcutionMethod(StreamMessage msg, IAsyncStream <StreamMessage> stream);
protected override Task ProducerOnNextAsync(IAsyncStream <int> theProducer)
{
return(theProducer.OnNextAsync(this.numProducedItems));
}
private void SetupStreams()
{
_serverStream = _streamProvider.GetStreamReplicaRandom <ClientMessage>(State.ServerId, Constants.SERVERS_STREAM, Constants.STREAM_SEND_REPLICAS);
_serverDisconnectedStream = _streamProvider.GetStream <Guid>(State.ServerId, Constants.SERVER_DISCONNECTED);
}
IInternalAsyncBatchObserver <T> IInternalStreamProvider.GetProducerInterface <T>(IAsyncStream <T> stream)
{
return(new SimpleMessageStreamProducer <T>(
(StreamImpl <T>)stream,
Name,
providerRuntime,
this.options.FireAndForgetDelivery,
this.options.OptimizeForImmutableData,
providerRuntime.PubSub(this.options.PubSubType),
IsRewindable,
this.serializationManager,
this.loggerFactory.CreateLogger <SimpleMessageStreamProducer <T> >()));
}
protected async Task <Task> ExecuteMessagesByDownStreamOperators(StreamMessage msg, IAsyncStream <StreamMessage> stream, IOperator op)
{
if (downStreamOperators.Count > 0)
{
int batchID = msg.BatchID;
var targetKey = op.GetPrimaryKey();
try
{
msg.From = this.GetPrimaryKey();
//if is barrier message, set the message count
if (msg.Value == Constants.Barrier_Value)
{
if (downStreamMessageCountMaps.ContainsKey(batchID))
{
if (downStreamMessageCountMaps[batchID].ContainsKey(op.GetPrimaryKey()))
{
msg.Count = downStreamMessageCountMaps[batchID][op.GetPrimaryKey()];
}
else
{
msg.Count = 0;
}
}
else
{
msg.Count = 0;
}
}
//if it is a normal message, increment the count map
else if (msg.Value != Constants.System_Key)
{
if (!downStreamMessageCountMaps.ContainsKey(batchID))
{
downStreamMessageCountMaps.Add(batchID, new Dictionary <Guid, int>());
}
var key = op.GetPrimaryKey();
if (downStreamMessageCountMaps[batchID].ContainsKey(key))
{
downStreamMessageCountMaps[batchID][key] = downStreamMessageCountMaps[batchID][key] + 1;
}
else
{
downStreamMessageCountMaps[batchID].Add(key, 1);
}
}
op.ExecuteMessage(msg, stream);
}
catch (Exception e)
{
PrettyConsole.Line("Get Exception : " + e + "; Start Receovry");
topologyManager.ReplaceTheOldOperator(targetKey);
}
}
return(Task.CompletedTask);
}
public Task EnableStreamNotifications()
{
IStreamProvider streamProvider = GrainClient.GetStreamProvider("SMSProvider");
Guid guid = new Guid((int) this.GetPrimaryKeyLong(), 0, 0, new byte[8]);
stream = streamProvider.GetStream<int>(guid, "notificationtest");
return TaskDone.Done;
}
public override async Task OnActivateAsync()
{
_asyncStream = provider.GetStream <OrderEvent>(WellKnownIds.OrderUpdates, WellKnownIds.StreamOrdersNamespace);
// await _asyncStream.OnNextAsync(new OrderEvent(this.GetPrimaryKeyString(), Event.Created));
await base.OnActivateAsync();
}