private async Task ReconnectAsync(CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
var transactions = _sessions.Values.Select(s => s.StartReconnecting()).ExcludeDefault().ToList();
if (transactions.Any())
{
try {
await WhenAllCancelOnFailure(transactions, (t, ct) => t.AcquireLockAsync(ct), cancellationToken);
await WhenAllCancelOnFailure(transactions, (t, ct) => t.ReconnectAsync(ct, reentrancyToken), cancellationToken);
} catch (OperationCanceledException ex) when(!(ex is RHostDisconnectedException))
{
throw;
} catch (Exception ex) {
_console.Write(Resources.RSessionProvider_ConnectionFailed.FormatInvariant(ex.Message));
throw;
} finally {
foreach (var transaction in transactions)
{
transaction.Dispose();
}
}
}
else
{
await TestBrokerConnectionWithRHost(_brokerProxy, cancellationToken, reentrancyToken);
}
}
private async Task ReconnectAsync(CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
var sessions = _sessions.Values.ToList();
if (sessions.Any())
{
// All sessions should participate in reconnect. If any of it didn't start, cancel the rest.
var transactions = sessions.Select(s => s.StartReconnecting()).ToList();
try {
await TaskUtilities.WhenAllCancelOnFailure(transactions, (t, ct) => t.AcquireLockAsync(ct), cancellationToken);
await TaskUtilities.WhenAllCancelOnFailure(transactions, (t, ct) => t.ReconnectAsync(ct, reentrancyToken), cancellationToken);
} catch (OperationCanceledException ex) when(!(ex is RHostDisconnectedException))
{
throw;
} catch (Exception ex) {
_callback.Write(Resources.RSessionProvider_ConnectionFailed.FormatInvariant(ex.Message));
throw;
} finally {
foreach (var transaction in transactions)
{
transaction.Dispose();
}
}
}
else
{
await TestBrokerConnectionWithRHost(_brokerProxy, cancellationToken, reentrancyToken);
}
}
public async Task ReconnectAsync(CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
using (_session._disposeToken.Link(ref cancellationToken)) {
if (!VerifyTransactionState(nameof(ConnectToNewBrokerAsync)))
{
return;
}
var host = _session._host;
// host may be null if previous attempts to start it have failed
if (host != null)
{
// Detach RHost from RSession
host.DetachCallback();
// Cancel all current requests (if any)
await _session.CancelAllAsync(cancellationToken);
host.Dispose();
await _session._hostRunTask;
}
var connectionInfo = new BrokerConnectionInfo(_session._startupInfo.Name, _session,
_session._startupInfo.RHostCommandLineArguments);
host = await _session.BrokerClient.ConnectAsync(connectionInfo, cancellationToken, reentrancyToken);
await _session.StartHostAsyncBackground(host, _lockToken, cancellationToken);
}
}
private async Task SwitchBrokerAsync(CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
var transactions = _sessions.Values.Select(s => s.StartSwitchingBroker()).ExcludeDefault().ToList();
if (transactions.Any())
{
await SwitchSessionsAsync(transactions, cancellationToken, reentrancyToken);
}
else
{
// Ping isn't enough here - need a "full" test with RHost
await TestBrokerConnectionWithRHost(_brokerProxy, cancellationToken, reentrancyToken);
}
}
public async Task ReconnectAsync(CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
if (_lockToken == null)
{
throw new InvalidOperationException($"{nameof(AcquireLockAsync)} must be called before {nameof(ReconnectAsync)}");
}
_session._disposeToken.ThrowIfDisposed();
if (_session._startupInfo == null)
{
// Session never started. No need to restart it.
// Reset _initializationLock so that next awaiter can proceed.
_lockToken.Reset();
return;
}
var host = _session._host;
// host may be null if previous attempts to start it have failed
if (host != null)
{
// Detach RHost from RSession
host.DetachCallback();
// Cancel all current requests (if any)
await _session.CancelAllAsync(cancellationToken);
host.Dispose();
await _session._hostRunTask;
}
host = await _session.BrokerClient.ConnectAsync(_session._startupInfo.Name, _session, _session._startupInfo.RHostCommandLineArguments,
cancellationToken : cancellationToken, reentrancyToken : reentrancyToken);
await _session.StartHostAsyncBackground(host, _lockToken, cancellationToken);
}
private async Task ConnectToNewBrokerAsync(IEnumerable <IRSessionSwitchBrokerTransaction> transactions, CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
try {
await TaskUtilities.WhenAllCancelOnFailure(transactions, (t, ct) => t.ConnectToNewBrokerAsync(ct, reentrancyToken), cancellationToken);
} catch (OperationCanceledException ex) when(!(ex is RHostDisconnectedException))
{
throw;
} catch (Exception ex) {
_callback.Write(Resources.RSessionProvider_ConnectionFailed.FormatInvariant(ex.Message));
throw;
}
}
public Token(LockSource lockSource) {
_lockSource = lockSource;
Reentrancy = LockTokenFactory.Create(lockSource);
}
private async Task SwitchSessionsAsync(IEnumerable <RSession> sessions, CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
// All sessions should participate in switch. If any of it didn't start, cancel the rest.
var transactions = sessions.Select(s => s.StartSwitchingBroker()).ToList();
try {
await TaskUtilities.WhenAllCancelOnFailure(transactions, (t, ct) => t.AcquireLockAsync(ct), cancellationToken);
await ConnectToNewBrokerAsync(transactions, cancellationToken, reentrancyToken);
OnBrokerDisconnected();
await CompleteSwitchingBrokerAsync(transactions, cancellationToken);
} finally {
foreach (var transaction in transactions)
{
transaction.Dispose();
}
}
}
private async Task SwitchBrokerAsync(IBrokerClient oldBroker, CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
var sessions = _sessions.Values.ToList();
if (sessions.Any())
{
await SwitchSessionsAsync(sessions, cancellationToken, reentrancyToken);
}
else
{
// Ping isn't enough here - need a "full" test with RHost
await TestBrokerConnectionWithRHost(_brokerProxy, cancellationToken, reentrancyToken);
}
}
private static async Task TestBrokerConnectionWithRHost(IBrokerClient brokerClient, CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
var callbacks = new NullRCallbacks();
var rhost = await brokerClient.ConnectAsync(nameof(TestBrokerConnectionAsync), callbacks, cancellationToken : cancellationToken, reentrancyToken : reentrancyToken);
try {
var rhostRunTask = rhost.Run(cancellationToken);
callbacks.SetReadConsoleInput("q()\n");
await rhostRunTask;
} finally {
rhost.Dispose();
}
}
public override async Task <RHost> ConnectAsync(BrokerConnectionInfo connectionInfo, CancellationToken cancellationToken = default(CancellationToken), ReentrancyToken reentrancyToken = default(ReentrancyToken))
{
await EnsureBrokerStartedAsync();
return(await base.ConnectAsync(connectionInfo, cancellationToken, reentrancyToken));
}
public async Task <RHost> ConnectAsync(string name, IRCallbacks callbacks, string rCommandLineArguments = null, int timeout = 3000,
CancellationToken cancellationToken = default(CancellationToken), ReentrancyToken reentrancyToken = default(ReentrancyToken))
{
using (await _connectArwl.ReaderLockAsync(cancellationToken, reentrancyToken)) {
return(await _broker.ConnectAsync(name, callbacks, rCommandLineArguments, timeout, cancellationToken));
}
}
public Task <RHost> ConnectAsync(string name, IRCallbacks callbacks, string rCommandLineArguments = null, int timeout = 3000,
CancellationToken cancellationToken = new CancellationToken(), ReentrancyToken reentrancyToken = new ReentrancyToken()) => Result;
public async Task <RHost> ConnectAsync(BrokerConnectionInfo connectionInfo, CancellationToken cancellationToken = default(CancellationToken), ReentrancyToken reentrancyToken = default(ReentrancyToken))
{
using (await _connectArwl.ReaderLockAsync(cancellationToken, reentrancyToken)) {
return(await _broker.ConnectAsync(connectionInfo, cancellationToken, reentrancyToken));
}
}
public async Task ConnectToNewBrokerAsync(CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
using (_session._disposeToken.Link(ref cancellationToken)) {
if (!VerifyTransactionState(nameof(ConnectToNewBrokerAsync)))
{
return;
}
var startupInfo = _session._startupInfo;
// host requires _startupInfo, so proceed only if session was started at least once
var connectionInfo = new BrokerConnectionInfo(startupInfo.Name, _session, startupInfo.RHostCommandLineArguments);
_hostToSwitch = await _session.BrokerClient.ConnectAsync(connectionInfo, cancellationToken, reentrancyToken);
}
}
public Token(LockSource lockSource)
{
_lockSource = lockSource;
Reentrancy = LockTokenFactory.Create(lockSource);
}
public async Task ConnectToNewBrokerAsync(CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
if (_lockToken == null)
{
throw new InvalidOperationException($"{nameof(AcquireLockAsync)} must be called before {nameof(ConnectToNewBrokerAsync)}");
}
_session._disposeToken.ThrowIfDisposed();
var startupInfo = _session._startupInfo;
if (startupInfo != null)
{
// host requires _startupInfo, so proceed only if session was started at least once
_hostToSwitch = await _session.BrokerClient.ConnectAsync(startupInfo.Name, _session, startupInfo.RHostCommandLineArguments, cancellationToken : cancellationToken, reentrancyToken : reentrancyToken);
}
}
public Task <RHost> ConnectAsync(BrokerConnectionInfo connectionInfo, CancellationToken cancellationToken = default(CancellationToken), ReentrancyToken reentrancyToken = default(ReentrancyToken)) => Result;
public TSource GetSource(ReentrancyToken token) => token._source as TSource;
private async Task SwitchSessionsAsync(IReadOnlyCollection <IRSessionSwitchBrokerTransaction> transactions, CancellationToken cancellationToken, ReentrancyToken reentrancyToken)
{
// All sessions should participate in switch. If any of it didn't start, cancel the rest.
try {
await WhenAllCancelOnFailure(transactions, (t, ct) => t.AcquireLockAsync(ct), cancellationToken);
await ConnectToNewBrokerAsync(transactions, cancellationToken, reentrancyToken);
OnBrokerDisconnected();
await CompleteSwitchingBrokerAsync(transactions, cancellationToken);
} finally {
foreach (var transaction in transactions)
{
transaction.Dispose();
}
}
}
public override async Task <RHost> ConnectAsync(string name, IRCallbacks callbacks, string rCommandLineArguments = null, int timeout = 3000,
CancellationToken cancellationToken = default(CancellationToken), ReentrancyToken reentrancyToken = default(ReentrancyToken))
{
await EnsureBrokerStartedAsync();
return(await base.ConnectAsync(name, callbacks, rCommandLineArguments, timeout, cancellationToken));
}
public TSource GetSource(ReentrancyToken token)
{
return(token._source as TSource);
}
