public void Dispose()
{
_timer?.Dispose();
var toUnsubscribe = new List <Task>();
if (_serverStream is not null)
{
toUnsubscribe.Add(Task.Factory.StartNew(async() =>
{
var subscriptions = await _serverStream.GetAllSubscriptionHandles();
var subs = new List <Task>();
subs.AddRange(subscriptions.Select(s => s.UnsubscribeAsync()));
await Task.WhenAll(subs);
}));
}
if (_allStream is not null)
{
toUnsubscribe.Add(Task.Factory.StartNew(async() =>
{
var subscriptions = await _allStream.GetAllSubscriptionHandles();
var subs = new List <Task>();
subs.AddRange(subscriptions.Select(s => s.UnsubscribeAsync()));
await Task.WhenAll(subs);
}));
}
var serverDirectoryGrain = _clusterClientProvider.GetClient().GetServerDirectoryGrain();
toUnsubscribe.Add(serverDirectoryGrain.Unregister(_serverId));
Task.WhenAll(toUnsubscribe.ToArray()).GetAwaiter().GetResult();
}
public override async Task OnActivateAsync()
{
_keyData = new ConnectionGrainKey(this.GetPrimaryKeyString());
_streamProvider = GetStreamProvider(Constants.STREAM_PROVIDER);
_clientDisconnectStream = _streamProvider.GetStream <string>(Constants.CLIENT_DISCONNECT_STREAM_ID, _keyData.Id);
if (_clientState.State.ServerId == Guid.Empty)
{
return;
}
_serverStream = _streamProvider.GetStream <ClientMessage>(_clientState.State.ServerId, Constants.SERVERS_STREAM);
_serverDisconnectedStream = _streamProvider.GetStream <Guid>(_clientState.State.ServerId, Constants.SERVER_DISCONNECTED);
var subscriptions = await _serverDisconnectedStream.GetAllSubscriptionHandles();
var subscriptionTasks = ArrayPool <Task> .Shared.Rent(subscriptions.Count);
for (int i = 0; i < subscriptions.Count; i++)
{
var subscription = subscriptions[i];
subscriptionTasks[i] = subscription.ResumeAsync((serverId, _) => OnDisconnect("server-disconnected"));
}
await Task.WhenAll(subscriptionTasks);
ArrayPool <Task> .Shared.Return(subscriptionTasks);
}
public override async Task OnActivateAsync()
{
logger = this.GetLogger("RecoverableStreamCollectorGrain " + base.IdentityString);
logger.Info("OnActivateAsync");
Faults.onActivateFault.TryFire(InjectFault);
await ReadStateAsync();
Guid streamGuid = this.GetPrimaryKey();
if (State.StreamGuid != streamGuid)
{
State.StreamGuid = streamGuid;
State.StreamNamespace = StreamNamespace;
await WriteStateAsync();
}
var streamProvider = GetStreamProvider(GeneratedStreamTestConstants.StreamProviderName);
stream = streamProvider.GetStream <GeneratedEvent>(State.StreamGuid, State.StreamNamespace);
foreach (StreamSubscriptionHandle <GeneratedEvent> handle in await stream.GetAllSubscriptionHandles())
{
await handle.ResumeAsync(OnNextAsync, OnErrorAsync, State.RecoveryToken);
}
}
public static async Task UnsubscribeAllSubscriptionHandlers <T>(this IAsyncStream <T> stream)
{
var subscriptions = await stream.GetAllSubscriptionHandles();
if (subscriptions?.Count > 0)
{
var tasks = subscriptions.Select(x => x.UnsubscribeAsync());
await Task.WhenAll(tasks);
}
}
public static async Task ResumeAllSubscriptionHandlers <T>(this IAsyncStream <T> stream, Func <T, StreamSequenceToken, Task> onNextAsync)
{
var subscriptions = await stream.GetAllSubscriptionHandles();
if (subscriptions?.Count > 0)
{
var tasks = subscriptions.Select(x => x.ResumeAsync(onNextAsync));
await Task.WhenAll(tasks);
}
}
public async override Task OnDeactivateAsync()
{
Console.WriteLine($"{typeof(MainEntryGrain)}OnDeactivateAsync");
await m_SSHandle.UnsubscribeAsync();
var tmplist = await m_Stream.GetAllSubscriptionHandles();
Console.WriteLine($"Stream:Count{tmplist.Count}");
//m_Stream.
//m_Stream.GetAllSubscriptionHandles().Dispose();
m_subsManager.Clear();
await base.OnDeactivateAsync();
}
public static async Task QuickSubscribe <T>(this IAsyncStream <T> stream, Func <T, StreamSequenceToken, Task> onNextAsync)
{
var subscriptionHandles = await stream.GetAllSubscriptionHandles();
if (subscriptionHandles.Count > 0)
{
foreach (var subscriptionHandle in subscriptionHandles)
{
await subscriptionHandle.ResumeAsync(onNextAsync);
}
}
await stream.SubscribeAsync(onNextAsync);
}
public async override Task OnActivateAsync()
{
var streamProvider = this.GetStreamProvider("SMSProvider");
stream = streamProvider.GetStream <string>(this.GetPrimaryKey(), "GrainExplicitStream");
var subscriptionHandles = await stream.GetAllSubscriptionHandles();
if (subscriptionHandles.Count > 0)
{
subscriptionHandles.ToList().ForEach(async x =>
{
await x.ResumeAsync((payload, token) => this.ReceivedMessageAsync(payload));
});
}
}
public async Task SubscribeAsync(IAsyncStream <string> stream)
{
IList <StreamSubscriptionHandle <string> > streamHandles = await stream.GetAllSubscriptionHandles();
if (streamHandles != null && streamHandles.Count > 0)
{
foreach (StreamSubscriptionHandle <string> item in streamHandles)
{
await item.ResumeAsync(OnReceiving, OnSubscribeError);
}
}
else
{
await stream.SubscribeAsync(OnReceiving, OnSubscribeError);
}
}
public override async Task OnActivateAsync()
{
var provider = GrainClient.GetStreamProvider(Configuration.StreamProviderName);
tcs = new TaskCompletionSource <ChatMessage>();
messages = provider.GetStream <ChatMessage>(this.GetPrimaryKey(), Configuration.Namespace);
subscriptions = new List <StreamSubscriptionHandle <ChatMessage> >();
foreach (var handle in await messages.GetAllSubscriptionHandles())
{
var subscription = await handle.ResumeAsync(OnNextMessage);
subscriptions.Add(subscription);
}
await base.OnActivateAsync();
}
public override async Task OnActivateAsync()
{
var streamProvider = base.GetStreamProvider(Constants.StreamProvider);
eventStream = streamProvider.GetStream <Progression>(this.GetPrimaryKey(), "Game");
var handles = await eventStream.GetAllSubscriptionHandles();
if (handles.Count == 0)
{
consumeHandle = await eventStream.SubscribeAsync(this);
}
else
{
consumeHandle = await handles[0].ResumeAsync(this);
}
}
public override async Task OnActivateAsync()
{
try
{
if (State.FirstTime)
{
State = new ClockWriterState();
State.FirstTime = false;
}
await WriteStateAsync();
}
catch (Exception ex)
{
throw;
}
//streamProvider = GetStreamProvider(StreamProviderName.Default);
streamProvider = GetStreamProvider("myname");
stream = streamProvider.GetStream <string>(Guid.Empty, "TIME");
stream = streamProvider.GetStream <WorkspaceCreated>(tenId, "Workspace");
stream = streamProvider.GetStream <GroupCreated>(tenId, "Workspace");
_logger.LogDebug("Getting stream {StreamName}", stream.Namespace);
subscriptionHandles = await stream.GetAllSubscriptionHandles();
if (subscriptionHandles.Count > 0)
{
subscriptionHandles.ToList().ForEach(async x =>
{
_logger.LogDebug("Resuming {StreamName}", stream.Namespace);
await x.ResumeAsync((payload, token) => OnNextAsync(payload));
});
}
await base.OnActivateAsync();
}
public override async Task OnActivateAsync()
{
_keyData = new ConnectionGrainKey(this.GetPrimaryKeyString());
_streamProvider = GetStreamProvider(Constants.STREAM_PROVIDER);
_clientDisconnectStream = _streamProvider.GetStream <string>(Constants.CLIENT_DISCONNECT_STREAM_ID, _keyData.Id);
if (State.ServerId == Guid.Empty)
{
return;
}
_serverStream = _streamProvider.GetStream <ClientMessage>(State.ServerId, Constants.SERVERS_STREAM);
_serverDisconnectedStream = _streamProvider.GetStream <Guid>(State.ServerId, Constants.SERVER_DISCONNECTED);
var subscriptions = await _serverDisconnectedStream.GetAllSubscriptionHandles();
var subscriptionTasks = new List <Task>();
foreach (var subscription in subscriptions)
{
subscriptionTasks.Add(subscription.ResumeAsync(async(serverId, _) => await OnDisconnect("server-disconnected")));
}
await Task.WhenAll(subscriptionTasks);
}
public static async Task WireUpSubscriptionAsync()
{
Console.WriteLine("...Setting up subscription...");
IStreamProvider streamProvider = Orleans.GrainClient.GetStreamProvider("StreamProviding");
IAsyncStream <SimpleMessage> messageStream = streamProvider.GetStream <SimpleMessage>(Guid.Empty, "test");
if (messageStream == null)
{
Console.WriteLine("OrleansBrcMessageSpy.WireUpSubscription got a null messageStream!?!?!?");
}
IList <StreamSubscriptionHandle <SimpleMessage> > allMyHandles = await messageStream.GetAllSubscriptionHandles();
bool atLeastOneStreamResumed = false;
foreach (StreamSubscriptionHandle <SimpleMessage> subscription in allMyHandles)
{
atLeastOneStreamResumed = true;
await subscription.ResumeAsync <SimpleMessage>(ReceivePubSubMessageFromTcpServerStream);
Console.WriteLine("ResumeAsync: WireUpSubscriptionAsync guy = " + subscription.ToString());
}
if (!atLeastOneStreamResumed)
{
StreamSubscriptionHandle <SimpleMessage> subscriptionHandle = await messageStream.SubscribeAsync <SimpleMessage>
(
(m, s) => ReceivePubSubMessageFromTcpServerStream(m, s),
(e) =>
{
Console.WriteLine(e.Message);
return(TaskDone.Done);
});
Console.WriteLine("SubscribeAsync: WireUpSubscriptionAsync guy");
}
}
public void Dispose()
{
var toUnsubscribe = new List <Task>();
if (_serverStream != null)
{
var subscriptions = _serverStream.GetAllSubscriptionHandles().Result;
toUnsubscribe.AddRange(subscriptions.Select(s => s.UnsubscribeAsync()));
}
if (_allStream != null)
{
var subscriptions = _allStream.GetAllSubscriptionHandles().Result;
toUnsubscribe.AddRange(subscriptions.Select(s => s.UnsubscribeAsync()));
}
var serverDirectoryGrain = _clusterClientProvider.GetClient().GetServerDirectoryGrain();
toUnsubscribe.Add(serverDirectoryGrain.Unregister(_serverId));
Task.WaitAll(toUnsubscribe.ToArray());
_timer?.Dispose();
}
public void Dispose()
{
if (!isInitialized)
{
return;
}
heartbeatDisposable.Dispose();
OrleansLog.Unsubscribe(_logger, _id);
var clientHandles = _clientMessageStream.GetAllSubscriptionHandles().Result;
var clientTasks = clientHandles.Select(handle => handle.UnsubscribeAsync()).ToArray();
Task.WaitAll(clientTasks);
//var allHandles = _allMessageStream.GetAllSubscriptionHandles().Result;
//var allTasks = clientHandles.Select(handle => handle.UnsubscribeAsync()).ToArray();
//Task.WaitAll(allTasks);
var task = _clusterClient.GetHubLifetimeManagerGrain(_id, _hubTypeId).AbortAsync();
Task.WaitAll(task);
}
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);
}
}