private async Task EnsureOrleansClusterConnection()
{
if (_clusterClient == null)
{
throw new NullReferenceException(nameof(_clusterClient));
}
if (_clusterClient.IsInitialized)
{
OrleansLog.Connected(_logger);
return;
}
OrleansLog.NotConnected(_logger);
await _clusterClient.Connect(async ex =>
{
if (_retries >= 5)
{
throw ex;
}
OrleansLog.ConnectionFailed(_logger, ex);
await Task.Delay(2000);
_retries++;
return(true);
});
OrleansLog.ConnectionRestored(_logger);
}
private async Task ConnectToClusterAsync()
{
await EnsureOrleansClusterConnection();
OrleansLog.Subscribing(_logger, _id);
var provider = _clusterClient.GetStreamProvider(Constants.STREAM_PROVIDER);
_clientMessageStream = provider.GetStream <ClientInvocationMessage>(_id, Constants.CLIENT_MESSAGE_STREAM_NAMESPACE);
await _clientMessageStream.SubscribeAsync(async (message, token) => await OnReceivedClientMessageAsync(message));
_allMessageStream = provider.GetStream <AllInvocationMessage>(_hubTypeId, Constants.HUB_MESSAGE_STREAM_NAMESPACE);
await _allMessageStream.SubscribeAsync(async (message, token) => await OnReceivedAllMessageAsync(message));
try
{
await _clusterClient.GetHubLifetimeManagerGrain(_id, _hubTypeId).OnInitializeAsync(_options.TimeoutInterval ?? TimeSpan.FromSeconds(30));
// Tick heartbeat
heartbeatDisposable = Observable.Interval(TimeSpan.FromSeconds(1))
.Subscribe(async value =>
{
await _clusterClient.GetHubLifetimeManagerGrain(_id, _hubTypeId).OnHeartbeatAsync();
});
}
catch (Exception e)
{
OrleansLog.InternalMessageFailed(_logger, e);
}
}
private async Task OnReceivedClientMessageAsync(ClientInvocationMessage message)
{
OrleansLog.ReceivedFromStream(_logger, _id);
if (connectionsById.TryGetValue(message.ConnectionId, out var connection))
{
var invocationMessage = new InvocationMessage(message.MethodName, message.Args);
try
{
await connection.WriteAsync(invocationMessage).AsTask();
}
catch (Exception e)
{
OrleansLog.FailedWritingMessage(_logger, e);
}
}
}
public void Dispose()
{
if (!_initialized)
{
return;
}
OrleansLog.Unsubscribe(_logger, _id);
var tasks = connectionsById.Keys.Select(id => _clusterClient.GetStreamProvider(SignalRConstants.STREAM_PROVIDER)
.GetStream <EventArgs>(InternalSignalRConstants.DISCONNECTION_STREAM_ID, id)
.OnNextAsync(EventArgs.Empty));
Task.WaitAll(tasks.ToArray());
Task.WaitAll(_allMessageHandle.UnsubscribeAsync());
}
private async Task OnReceivedAllMessageAsync(AllInvocationMessage message)
{
OrleansLog.ReceivedFromStream(_logger, _id);
var invocationMessage = new InvocationMessage(message.MethodName, message.Args);
var tasks = connectionsById.Where(pair => !pair.Value.ConnectionAborted.IsCancellationRequested && !message.ExcludedConnectionIds.Contains(pair.Key))
.Select(pair => pair.Value.WriteAsync(invocationMessage).AsTask());
try
{
await Task.WhenAll(tasks);
}
catch (Exception e)
{
OrleansLog.FailedWritingMessage(_logger, e);
}
}
private async Task InitializeAsync()
{
await EnsureOrleansClusterConnection();
OrleansLog.Subscribing(_logger, _id);
try
{
_clientMessageStream = _clusterClient.GetStreamProvider(SignalRConstants.STREAM_PROVIDER).GetStream <SendClientInvocationMessage>(_id, InternalSignalRConstants.SEND_CLIENT_MESSAGE_STREAM_NAMESPACE);
_clientMessageHandle = await _clientMessageStream.SubscribeAsync(async (message, token) => await OnReceivedAsync(message));
_allMessageHandle = await HubProxy.AllMessageStream.SubscribeAsync(async (message, token) => await OnReceivedAsync(message));
}
catch (Exception e)
{
OrleansLog.InternalMessageFailed(_logger, e);
}
}
private async Task EnsureOrleansClusterConnection()
{
if (_clusterClient.IsInitialized)
{
OrleansLog.Connected(_logger);
return;
}
OrleansLog.NotConnected(_logger);
await _clusterClient.Connect(async e =>
{
if (_retries >= 8)
{
throw e;
}
OrleansLog.ConnectionFailed(_logger, e);
await Task.Delay(2000);
_retries++;
return(true);
});
OrleansLog.ConnectionRestored(_logger);
}
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);
}
