public async Task<StreamSubscriptionHandle<int>> Resume(StreamSubscriptionHandle<int> handle)
{
logger.Info("Resume");
if(handle == null)
throw new ArgumentNullException("handle");
// new counter for this subscription
Tuple<Counter,Counter> counters;
if (!consumedMessageCounts.TryGetValue(handle, out counters))
{
counters = Tuple.Create(new Counter(), new Counter());
}
int countCapture = consumerCount;
consumerCount++;
// subscribe
StreamSubscriptionHandle<int> newhandle = await handle.ResumeAsync(
(e, t) => OnNext(e, t, countCapture, counters.Item1),
e => OnError(e, countCapture, counters.Item2));
// track counter
consumedMessageCounts[newhandle] = counters;
// return handle
return newhandle;
}
public async Task BecomeConsumer(Guid streamId, string streamNamespace, string providerToUse)
{
logger.Info("BecomeConsumer");
IStreamProvider streamProvider = GetStreamProvider(providerToUse);
consumer = streamProvider.GetStream<int>(streamId, streamNamespace);
consumerHandle = await consumer.SubscribeAsync(OnNextAsync, OnErrorAsync, OnActivateAsync);
}
public async Task StopConsuming()
{
logger.Info("StopConsuming");
if (consumerHandle != null)
{
await consumerHandle.UnsubscribeAsync();
consumerHandle = null;
}
}
public override Task OnActivateAsync()
{
logger = base.GetLogger("FaultableConsumerGrain " + base.IdentityString);
logger.Info("OnActivateAsync");
eventsConsumedCount = 0;
errorsCount = 0;
eventsFailedCount = 0;
consumerHandle = null;
failPeriodTimer = null;
return TaskDone.Done;
}
public async Task Join()
{
subscription = await room.SubscribeAsync<ChatRoomMessage>((msg, token) =>
{
if (msg.User != UserName)
Console.WriteLine(msg.Text);
return TaskDone.Done;
});
await user.Tell(new Join {Room = RoomName});
}
public async Task Subscribe()
{
var ccGrain = GrainFactory.GetGrain<IDataGrain>(0);
//var stream = await ccGrain.GetStream();
//_handler = await stream.SubscribeAsync(this, new SimpleSequenceToken(0));
//var details = await ccGrain.GetStreamDetails();
//var providerName = details.Item1;
//var nameSpace = details.Item2;
//var guid = details.Item3;
//var provider = GrainClient.GetStreamProvider(providerName);
//var stream = provider.GetStream<int>(guid, nameSpace);
var stream = await ccGrain.GetStream();
_handler = await stream.SubscribeAsync(this, null);
}
public async Task<StreamSubscriptionHandle<int>> Resume(StreamSubscriptionHandle<int> handle)
{
logger.Info("Resume");
if(handle == null)
throw new ArgumentNullException("handle");
// new counter for this subscription
Counter count;
if(!consumedMessageCounts.TryGetValue(handle, out count))
{
count = new Counter();
}
// subscribe
StreamSubscriptionHandle<int> newhandle = await handle.ResumeAsync((e, t) => count.Increment());
// track counter
consumedMessageCounts[newhandle] = count;
// return handle
return newhandle;
}
//Jerk_ConsumerGrai would unsubscrube on any subscription added to it
private async Task OnAdd(StreamSubscriptionHandle <int> handle)
{
await handle.UnsubscribeAsync();
}
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 SubscribeToStream(Guid guid, string providerName)
{
var stream = GetStreamProvider(providerName).GetStream <StreamImmutabilityTestObject>(guid, "Namespace");
_streamSubscriptionHandle = await stream.SubscribeAsync(OnNextAsync);
}
//Jerk_ConsumerGrai would unsubscrube on any subscription added to it
public async Task OnSubscribed(StreamSubscriptionHandle <int> handle)
{
await handle.UnsubscribeAsync();
}
public async Task StopConsuming(StreamSubscriptionHandle<int> handle)
{
logger.Info("StopConsuming");
// unsubscribe
await handle.UnsubscribeAsync();
// stop tracking event count for stream
consumedMessageCounts.Remove(handle);
}
protected internal StreamSubscription(StreamSubscriptionHandle<object> handle)
{
this.handle = handle;
}
internal async Task IncomingMessage(NList message)
{
try
{
int message_id = message.Get <int>(0);
NList dispatch_msg = message.GetRange(1, message.Count - 1);
if (message_id == SystemMsg.CLIENT.ACCESS_TOKEN && !Access)
{
string access_token = dispatch_msg.Get <string>(0);
IAccessToken token = _ClusterClient.GetGrain <IAccessToken>(access_token);
Guid user_id = await token.GetUserId();
if (user_id == Guid.Empty)
{
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.ACCESS_TOKEN).Add(false));
return;
}
_PlatformAccount = _ClusterClient.GetGrain <IUserAccount>(user_id);
IReadOnlyList <Role> roles = await _PlatformAccount.GetRoles();
if (roles == null)
{
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.ACCESS_TOKEN).Add(false));
return;
}
Access = true;
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.ACCESS_TOKEN).Add(true).Add(JsonConvert.SerializeObject(roles)));
}
else if (message_id == SystemMsg.CLIENT.CREATE_ROLE && Access)
{
int realm = dispatch_msg.Get <int>(0);
string json = dispatch_msg.Get <string>(1);
Role role = await _PlatformAccount.CreateRole(realm, json);
if (role != null)
{
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.CREATE_ROLE).Add(true).Add(JsonConvert.SerializeObject(role)));
}
else
{
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.CREATE_ROLE).Add(false));
}
}
else if (message_id == SystemMsg.CLIENT.SELECT_ROLE && Access && !Inited)
{
long role_id = dispatch_msg.Get <long>(0);
if (!await _PlatformAccount.HasRole(role_id))
{
return;
}
RoleAgent = _ClusterClient.GetGrain <IRoleAgent>(role_id);
await RoleAgent.BindSession(_PlatformAccount.GetPrimaryKey(), Protocol.ToString());
_AgentObserver = new AgentObserver(this);
var stream = _ClusterClient.GetStreamProvider(StreamProviders.AgentProvider).GetStream <NList>(_PlatformAccount.GetPrimaryKey(), Protocol.ToString());
_SubscriptionHandle = await stream.SubscribeAsync(_AgentObserver);
await RoleAgent.SendEntities();
Inited = true;
}
else if (message_id == SystemMsg.CLIENT.ONLINE && Inited)
{
if (RoleAgent != null)
{
await RoleAgent.Online();
}
}
else if (Inited)
{
if (RoleAgent != null)
{
await RoleAgent.OnResponse(message_id, dispatch_msg);
}
}
}
catch (Exception ex)
{
_Logger.LogError(ex, "IncomingMessage Failed!");
}
}
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 async Task RemoveConsumer(Guid streamId, string providerName, StreamSubscriptionHandle <T> subsHandle)
public override Task OnActivateAsync()
{
logger.Info("OnActivateAsync");
ConsumerHandle = null;
return(Task.CompletedTask);
}
private async Task<bool> CheckCounter(IBatchProducerGrain producer, IMultipleSubscriptionConsumerGrain consumer,
StreamSubscriptionHandle<int> handler, bool assertIsTrue)
{
var numProduced = await producer.GetNumberProduced();
var consumers = await consumer.GetNumberConsumed();
var numConsumed = consumers[handler];
_logger.Info("Checking now for handler for stream: {0}", handler.StreamIdentity.ToString());
return await CheckCounter(numProduced, numConsumed, assertIsTrue);
}
public override Task OnActivateAsync(CancellationToken cancellationToken)
{
logger.LogInformation("OnActivateAsync");
ConsumerHandle = null;
return(Task.CompletedTask);
}
protected internal StreamSubscription(StreamSubscriptionHandle <object> handle)
{
this.handle = handle;
}
public ExternalStreamSubscriptionHandle(StreamSubscriptionHandle <T> handle)
{
this.handle = handle;
}
public override bool Equals(StreamSubscriptionHandle <T> other)
{
return(this.handle.Equals(other));
}
public override bool Equals(StreamSubscriptionHandle <T> other)
{
throw new NotImplementedException();
}
public async Task RemoveConsumer(Guid streamId, string streamNamespace, string providerName, StreamSubscriptionHandle <int> subsHandle)
{
if (logger.IsVerbose)
{
logger.Verbose("RemoveConsumer StreamId={0} StreamProvider={1}", streamId, providerName);
}
if (State.ConsumerSubscriptionHandles.Count == 0)
{
throw new InvalidOperationException("Not a Consumer");
}
await subsHandle.UnsubscribeAsync();
Observers.Remove(subsHandle);
State.ConsumerSubscriptionHandles.Remove(subsHandle);
await WriteStateAsync();
}
protected internal StreamSubscription(StreamRef <TItem> stream, StreamSubscriptionHandle <TItem> handle, Guid?id = null)
{
this.handle = handle;
Stream = stream;
Id = id ?? handle.HandleId;
}
public async Task<StreamSubscriptionHandle<int>> Resume(StreamSubscriptionHandle<int> handle)
{
logger.Info("Resume");
if(handle == null)
throw new ArgumentNullException("handle");
// new counter for this subscription
Counter count;
if(!consumedMessageCounts.TryGetValue(handle, out count))
{
count = new Counter();
}
// subscribe
StreamSubscriptionHandle<int> newhandle = await handle.ResumeAsync((e, t) =>
{
logger.Info("Got next event {0}", e);
string contextValue = RequestContext.Get(SampleStreaming_ProducerGrain.RequestContextKey) as string;
if (!String.Equals(contextValue, SampleStreaming_ProducerGrain.RequestContextValue))
{
throw new Exception(String.Format("Got the wrong RequestContext value {0}.", contextValue));
}
count.Increment();
return TaskDone.Done;
});
// track counter
consumedMessageCounts[newhandle] = count;
// return handle
return newhandle;
}
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 StreamSubscription(StreamSubscriptionHandle<object> handle)
{
this.handle = handle;
}
public override bool Equals(StreamSubscriptionHandle <T> other)
{
return(ReferenceEquals(this, other));
}
public async Task SubscribeToStream(Guid guid, string providerName)
{
var stream = GetStreamProvider(providerName).GetStream<StreamImmutabilityTestObject>(guid, "Namespace");
_streamSubscriptionHandle = await stream.SubscribeAsync(OnNextAsync);
}
public async Task PubSubStoreRetrievalTest()
{
//var strmId = Guid.NewGuid();
var strmId = Guid.Parse("761E3BEC-636E-4F6F-A56B-9CC57E66B712");
var streamProv = GrainClient.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) =>
{
Trace.WriteLine(string.Format("{0}{1}", e, t));
return(TaskDone.Done);
},
e => { return(TaskDone.Done); });
//StreamSubscriptionHandle<int> handleIn = await streamIn.SubscribeAsync(
// (e, t) =>
// {
// Trace.WriteLine(string.Format("{0}{1}", e, t));
// return TaskDone.Done;
// },
// e => { return TaskDone.Done; });
//await handle.ResumeAsync(
// (e, t) =>
// {
// Trace.WriteLine(string.Format("{0}{1}", e, t));
// return TaskDone.Done;
// },
// e => { return TaskDone.Done; });
for (int i = 100; i < 25; i++)
{
await stream.OnNextAsync(i);
}
StreamSubscriptionHandle <int> handle2 = await stream.SubscribeAsync(
(e, t) =>
{
Trace.WriteLine(string.Format("2222-{0}{1}", e, t));
return(TaskDone.Done);
},
e => { return(TaskDone.Done); });
for (int i = 1000; i < 25; i++)
{
await stream.OnNextAsync(i);
}
//await handle2.ResumeAsync(
// (e, t) =>
// {
// Trace.WriteLine(string.Format("{0}{1}", e, t));
// return TaskDone.Done;
// },
// e => { return TaskDone.Done; });
var sh = await stream.GetAllSubscriptionHandles();
Assert.AreEqual <int>(2, sh.Count());
//await handle.UnsubscribeAsync();
//var sh1 = await stream.GetAllSubscriptionHandles();
//Assert.AreEqual<int>(1, sh1.Count());
//await handle2.UnsubscribeAsync();
//var sh2 = await stream.GetAllSubscriptionHandles();
//Assert.AreEqual<int>(0, sh2.Count());
//var silos = base.GetActiveSilos();
//foreach (var silo in silos)
//{
// base.RestartSilo(silo);
//}
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) =>
{
Trace.WriteLine(string.Format("{0}{1}", e, t));
return(TaskDone.Done);
},
e => { return(TaskDone.Done); });
for (int i = 10000; i < 25; i++)
{
await stream2.OnNextAsync(i);
}
}
