public async Task <ExecutionResult> InitializeAsync()
{
try {
if (!Session.IsHostRunning)
{
var startupInfo = new RHostStartupInfo {
Name = "REPL",
RHostCommandLineArguments = _connections.ActiveConnection?.RCommandLineArguments,
CranMirrorName = _settings.CranMirror,
CodePage = _settings.RCodePage,
WorkingDirectory = _settings.WorkingDirectory,
TerminalWidth = _terminalWidth,
};
if (CurrentWindow != null)
{
CurrentWindow.TextView.VisualElement.SizeChanged += VisualElement_SizeChanged;
CurrentWindow.OutputBuffer.Changed += OutputBuffer_Changed;
}
await Session.EnsureHostStartedAsync(startupInfo, new RSessionCallback(CurrentWindow, Session, _settings, _coreShell, new FileSystem()));
}
return(ExecutionResult.Success);
} catch (RHostBrokerBinaryMissingException) {
await _coreShell.ShowErrorMessageAsync(Resources.Error_Microsoft_R_Host_Missing);
return(ExecutionResult.Failure);
} catch (RHostDisconnectedException ex) {
CurrentWindow?.WriteError(Environment.NewLine + ex.Message);
return(ExecutionResult.Success);
} catch (Exception ex) {
await _coreShell.ShowErrorMessageAsync(ex.Message);
return(ExecutionResult.Failure);
}
}
private void ScheduleAfterHostStarted(RHostStartupInfo startupInfo)
{
var afterHostStartedEvaluationSource = new RSessionEvaluationSource(CancellationToken.None);
_pendingEvaluationSources.Post(afterHostStartedEvaluationSource);
Interlocked.Exchange(ref _afterHostStartedTask, AfterHostStarted(afterHostStartedEvaluationSource, startupInfo));
}
private void ScheduleAfterHostStarted(RHostStartupInfo startupInfo)
{
var afterHostStartedEvaluationSource = new RSessionEvaluationSource(CancellationToken.None);
_pendingEvaluationSources.Post(afterHostStartedEvaluationSource);
AfterHostStarted(afterHostStartedEvaluationSource, startupInfo).DoNotWait();
}
public async Task <IRSessionEvaluation> BeginEvaluationAsync(RHostStartupInfo startupInfo,
CancellationToken cancellationToken = default(CancellationToken))
{
var session = GetOrCreate(Guid.NewGuid());
cancellationToken.ThrowIfCancellationRequested();
try {
await session.StartHostAsync(new RHostStartupInfo {
Name = "IsolatedRHost" + session.Id,
CranMirrorName = startupInfo.CranMirrorName,
CodePage = startupInfo.CodePage
}, null);
cancellationToken.ThrowIfCancellationRequested();
var evaluation = await session.BeginEvaluationAsync(cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
return(new IsolatedRSessionEvaluation(session, evaluation));
} finally {
if (cancellationToken.IsCancellationRequested)
{
await session.StopHostAsync();
}
}
}
public async Task <ExecutionResult> InitializeAsync()
{
try {
if (!Session.IsHostRunning)
{
var startupInfo = new RHostStartupInfo {
Name = "REPL",
RBasePath = _settings.RBasePath,
RHostCommandLineArguments = _settings.RCommandLineArguments,
CranMirrorName = _settings.CranMirror,
CodePage = _settings.RCodePage,
WorkingDirectory = _settings.WorkingDirectory,
TerminalWidth = _terminalWidth,
};
CurrentWindow.TextView.VisualElement.SizeChanged += VisualElement_SizeChanged;
await Session.StartHostAsync(startupInfo, new RSessionCallback(CurrentWindow, Session, _settings, _coreShell));
}
return(ExecutionResult.Success);
} catch (RHostBinaryMissingException) {
await _coreShell.ShowErrorMessageAsync(Resources.Error_Microsoft_R_Host_Missing);
return(ExecutionResult.Failure);
} catch (Exception) {
return(ExecutionResult.Failure);
}
}
private async Task <IReadOnlyList <RPackage> > GetPackagesAsync(Func <IRExpressionEvaluator, Task <JArray> > queryFunc)
{
// Fetching of installed and available packages is done in a
// separate package query session to avoid freezing the REPL.
try {
var startupInfo = new RHostStartupInfo {
CranMirrorName = _settings.CranMirror,
CodePage = _settings.RCodePage
};
using (var eval = await _sessionProvider.BeginEvaluationAsync(startupInfo)) {
// Get the repos and libpaths from the REPL session and set them
// in the package query session
var repositories = (await DeparseRepositoriesAsync());
if (repositories != null)
{
await WrapRException(eval.ExecuteAsync($"options(repos=eval(parse(text={repositories.ToRStringLiteral()})))"));
}
var libraries = (await DeparseLibrariesAsync());
if (libraries != null)
{
await WrapRException(eval.ExecuteAsync($".libPaths(eval(parse(text={libraries.ToRStringLiteral()})))"));
}
var result = await WrapRException(queryFunc(eval));
return(result.Select(p => p.ToObject <RPackage>()).ToList().AsReadOnly());
}
} catch (RHostDisconnectedException ex) {
throw new RPackageManagerException(Resources.PackageManager_TransportError, ex);
}
}
public async Task StartHostAsync(RHostStartupInfo startupInfo, int timeout = 3000)
{
if (Interlocked.CompareExchange(ref _initializationTcs, new TaskCompletionSource <object>(), null) != null)
{
throw new InvalidOperationException("Another instance of RHost is running for this RSession. Stop it before starting new one.");
}
await StartHostAsyncBackground(startupInfo, timeout);
}
public async Task EnsureHostStartedAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout = 3000)
{
_disposeToken.ThrowIfDisposed();
var lockToken = await _initializationLock.WaitAsync();
if (!lockToken.IsSet)
{
await StartHostAsyncBackground(startupInfo, callback, lockToken, timeout);
}
}
public async Task EnsureHostStartedAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout = 3000, CancellationToken cancellationToken = default(CancellationToken))
{
using (_disposeToken.Link(ref cancellationToken)) {
var lockToken = await _initializationLock.WaitAsync(cancellationToken);
if (!lockToken.IsSet)
{
await StartHostAsyncBackground(startupInfo, callback, lockToken, timeout, cancellationToken);
}
}
}
private async Task CreateAndRunHost(RHostStartupInfo startupInfo, int timeout)
{
try {
await _host.CreateAndRun(RInstallation.GetRInstallPath(startupInfo.RBasePath, new SupportedRVersionRange()), startupInfo.RHostDirectory, startupInfo.RHostCommandLineArguments, timeout);
} catch (OperationCanceledException oce) {
_initializationTcs.TrySetCanceled(oce.CancellationToken);
} catch (Exception ex) {
_initializationTcs.TrySetException(ex);
} finally {
Interlocked.Exchange(ref _initializationTcs, null);
}
}
public async Task EnsureHostStartedAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout = 3000)
{
var existingInitializationTcs = Interlocked.CompareExchange(ref _initializationTcs, new TaskCompletionSource <object>(), null);
if (existingInitializationTcs == null)
{
await StartHostAsyncBackground(startupInfo, callback, timeout);
}
else
{
await existingInitializationTcs.Task;
}
}
private async Task StartHostAsyncBackground(RHostStartupInfo startupInfo, int timeout)
{
await TaskUtilities.SwitchToBackgroundThread();
_host = new RHost(startupInfo != null ? startupInfo.Name : "Empty", this);
ClearPendingRequests();
var initializationTask = _initializationTcs.Task;
_hostRunTask = CreateAndRunHost(startupInfo, timeout);
ScheduleAfterHostStarted(startupInfo);
await initializationTask;
}
public async Task StartHostAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout = 3000, CancellationToken cancellationToken = default(CancellationToken))
{
using (_disposeToken.Link(ref cancellationToken)) {
var isStartedTask = _initializationLock.WaitAsync(cancellationToken);
if (isStartedTask.IsCompleted && !isStartedTask.Result.IsSet)
{
var lockToken = isStartedTask.Result;
await StartHostAsyncBackground(startupInfo, callback, lockToken, timeout, cancellationToken);
}
else
{
throw new InvalidOperationException("Another instance of RHost is running for this RSession. Stop it before starting new one.");
}
}
}
private async Task StartHostAsyncBackground(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout)
{
await TaskUtilities.SwitchToBackgroundThread();
_callback = callback;
_startupInfo = startupInfo;
ClearPendingRequests(new RHostDisconnectedException());
ScheduleAfterHostStarted(startupInfo);
var initializationTask = _initializationTcs.Task;
_hostRunTask = CreateAndRunHost(startupInfo, timeout);
await initializationTask;
}
private async Task CreateAndRunHost(RHostStartupInfo startupInfo, int timeout)
{
try {
_host = await BrokerConnector.ConnectAsync(startupInfo.Name, this, startupInfo.RHostCommandLineArguments, timeout);
await _host.Run();
} catch (OperationCanceledException oce) {
_initializationTcs.TrySetCanceled(oce);
} catch (MessageTransportException mte) {
_initializationTcs.TrySetCanceled(new RHostDisconnectedException(string.Empty, mte));
} catch (Exception ex) {
_initializationTcs.TrySetException(ex);
} finally {
Interlocked.Exchange(ref _initializationTcs, null);
}
}
private async Task StartHostAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout, bool throwIfStarted, CancellationToken cancellationToken)
{
using (_disposeToken.Link(ref cancellationToken)) {
await TaskUtilities.SwitchToBackgroundThread();
using (await _initializationLock.WaitAsync(cancellationToken)) {
if (_hostStartedTcs.Task.Status != TaskStatus.RanToCompletion || !_isHostRunning)
{
await StartHostAsyncBackground(startupInfo, callback, timeout, cancellationToken);
}
else if (throwIfStarted)
{
throw new InvalidOperationException("Another instance of RHost is running for this RSession. Stop it before starting new one.");
}
}
}
}
private async Task StartHostAsyncBackground(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout, CancellationToken cancellationToken)
{
TaskUtilities.AssertIsOnBackgroundThread();
_callback = callback;
_startupInfo = startupInfo ?? new RHostStartupInfo();
RHost host;
try {
var connectionInfo = new HostConnectionInfo(Name, this, _startupInfo.UseRHostCommandLineArguments, timeout);
host = await BrokerClient.ConnectAsync(connectionInfo, cancellationToken);
} catch (OperationCanceledException ex) {
_hostStartedTcs.TrySetCanceled(ex);
throw;
} catch (Exception ex) {
_hostStartedTcs.TrySetException(ex);
throw;
}
await StartHostAsyncBackground(host, cancellationToken);
}
private async Task StartHostAsyncBackground(RHostStartupInfo startupInfo, IRSessionCallback callback, IBinaryAsyncLockToken lockToken, int timeout)
{
await TaskUtilities.SwitchToBackgroundThread();
_callback = callback;
_startupInfo = startupInfo;
RHost host;
try {
host = await BrokerClient.ConnectAsync(startupInfo.Name, this, startupInfo.RHostCommandLineArguments, timeout);
} catch (OperationCanceledException ex) {
_initializationTcs.TrySetCanceled(ex);
lockToken.Reset();
throw;
} catch (Exception ex) {
_initializationTcs.TrySetException(ex);
lockToken.Reset();
throw;
}
await StartHostAsyncBackground(host, lockToken);
}
public async Task StartupOptions()
{
var session = new RSession(0, _testMethod.FileSystemSafeName, _fileSystem, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { });
var info = new RHostStartupInfo(string.Empty, null, 1251, 80, false, false, false, true);
await session.StartHostAsync(info, new RHostOptionsTestCallback(), HostStartTimeout);
var result = await session.EvaluateAsync("rtvs:::view_env$view_mode");
result.Result.ToObject <int>().Should().Be(1);
result = await session.EvaluateAsync("Sys.getlocale()");
result.Result.ToObject <string>().Should().Contain("1251");
result = await session.EvaluateAsync("as.list(getOption('repos'))");
var urls = result.Result.ToObject <IDictionary <string, string> >();
Uri.TryCreate(urls.First().Value, UriKind.Absolute, out Uri uri).Should().BeTrue();
uri.Host.Should().Be("test.cran.info");
}
private async Task <ExecutionResult> InitializeAsync(bool isResetting, string workingDirectory)
{
try {
if (!Session.IsHostRunning)
{
var startupInfo = new RHostStartupInfo(_settings.CranMirror, workingDirectory, _settings.RCodePage, _terminalWidth, !isResetting, true, true, _settings.GridDynamicEvaluation);
await Session.EnsureHostStartedAsync(startupInfo, new RSessionCallback(CurrentWindow, Session, _settings, _services, _fs));
}
return(ExecutionResult.Success);
} catch (ComponentBinaryMissingException cbmex) {
await _services.ShowErrorMessageAsync(cbmex.Message);
return(ExecutionResult.Failure);
} catch (RHostDisconnectedException ex) {
WriteRHostDisconnectedError(ex);
return(ExecutionResult.Success);
} catch (Exception ex) {
await _services.ShowErrorMessageAsync(ex.Message);
return(ExecutionResult.Failure);
}
}
public RSession(int id, string name, IBrokerClient brokerClient, IExclusiveReaderLock initializationLock, Action onDispose)
{
Id = id;
Name = name;
BrokerClient = brokerClient;
_onDispose = onDispose;
_disposeToken = DisposeToken.Create <RSession>();
_disableMutatingOnReadConsole = new CountdownDisposable(() => {
if (!_delayedMutatedOnReadConsole)
{
return;
}
_delayedMutatedOnReadConsole = false;
Task.Run(() => Mutated?.Invoke(this, EventArgs.Empty));
});
_initializationLock = initializationLock;
_stopHostLock = new BinaryAsyncLock(true);
_hostStartedTcs = new TaskCompletionSourceEx <object>();
_startupInfo = new RHostStartupInfo();
}
public async Task StartHostAsync(RHostStartupInfo startupInfo, int timeout = 3000) {
if (Interlocked.CompareExchange(ref _initializationTcs, new TaskCompletionSource<object>(), null) != null) {
throw new InvalidOperationException("Another instance of RHost is running for this RSession. Stop it before starting new one.");
}
await StartHostAsyncBackground(startupInfo, timeout);
}
public async Task EnsureHostStartedAsync(RHostStartupInfo startupInfo, int timeout = 3000) {
var existingInitializationTcs = Interlocked.CompareExchange(ref _initializationTcs, new TaskCompletionSource<object>(), null);
if (existingInitializationTcs == null) {
await StartHostAsyncBackground(startupInfo, timeout);
} else {
await existingInitializationTcs.Task;
}
}
private async Task AfterHostStarted(RSessionEvaluationSource evaluationSource, RHostStartupInfo startupInfo)
{
using (var evaluation = await evaluationSource.Task) {
// Load RTVS R package before doing anything in R since the calls
// below calls may depend on functions exposed from the RTVS package
await LoadRtvsPackage(evaluation);
if (startupInfo.WorkingDirectory != null)
{
await evaluation.SetWorkingDirectory(startupInfo.WorkingDirectory);
}
else
{
await evaluation.SetDefaultWorkingDirectory();
}
if (_hostClientApp != null)
{
await evaluation.SetVsGraphicsDevice();
string mirrorUrl = _hostClientApp.CranUrlFromName(startupInfo.CranMirrorName);
await evaluation.SetVsCranSelection(mirrorUrl);
await evaluation.SetVsHelpRedirection();
await evaluation.SetChangeDirectoryRedirection();
}
}
}
private async Task AfterHostStarted(RHostStartupInfo startupInfo)
{
var evaluator = new BeforeInitializedRExpressionEvaluator(this);
try {
// Load RTVS R package before doing anything in R since the calls
// below calls may depend on functions exposed from the RTVS package
var libPath = IsRemote ? "." : Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetAssemblyPath());
await LoadRtvsPackage(evaluator, libPath);
var wd = startupInfo.WorkingDirectory;
if (!IsRemote && !string.IsNullOrEmpty(wd) && wd.HasReadPermissions())
{
try {
await evaluator.SetWorkingDirectoryAsync(wd);
} catch (REvaluationException) {
await evaluator.SetDefaultWorkingDirectoryAsync();
}
}
else
{
await evaluator.SetDefaultWorkingDirectoryAsync();
}
var callback = _callback;
if (callback != null)
{
await evaluator.SetVsGraphicsDeviceAsync();
string mirrorUrl = callback.CranUrlFromName(startupInfo.CranMirrorName);
try {
await evaluator.SetVsCranSelectionAsync(mirrorUrl);
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationMirror, mirrorUrl, ex.Message);
}
try {
await evaluator.SetCodePageAsync(startupInfo.CodePage);
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationCodePage, startupInfo.CodePage, ex.Message);
}
try {
await evaluator.SetROptionsAsync();
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationOptions, ex.Message);
}
await evaluator.OverrideFunctionAsync("setwd", "base");
await evaluator.SetFunctionRedirectionAsync();
try {
await evaluator.OptionsSetWidthAsync(startupInfo.TerminalWidth);
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationOptions, ex.Message);
}
if (startupInfo.EnableAutosave)
{
try {
// Only enable autosave for this session after querying the user about any existing file.
// This way, if they happen to disconnect while still querying, we don't save the new empty
// session and overwrite the old file.
bool deleteExisting = await evaluator.QueryReloadAutosaveAsync();
await evaluator.EnableAutosaveAsync(deleteExisting);
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationAutosave, ex.Message);
}
}
Interactive?.Invoke(this, EventArgs.Empty);
}
_initializedTcs.SetResult(null);
} catch (Exception ex) when(!ex.IsCriticalException())
{
#if DEBUG
// Detailed exception information in REPL is not particularly useful to the end user.
await WriteErrorAsync(Resources.Error_SessionInitialization, ex);
#endif
if (!(ex is RHostDisconnectedException))
{
StopHostAsync().DoNotWait();
}
var oce = ex as OperationCanceledException;
if (oce != null)
{
_initializedTcs.SetCanceled(oce);
}
else
{
_initializedTcs.SetException(ex);
}
}
}
public Task StartHostAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout = 3000, CancellationToken cancellationToken = default(CancellationToken)) => StartHostAsync(startupInfo, callback, timeout, true, cancellationToken);
public Task StartHostAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout = 3000, CancellationToken cancellationToken = default(CancellationToken))
{
IsHostRunning = true;
Connected?.Invoke(this, new RConnectedEventArgs(string.Empty));
return(Task.CompletedTask);
}
public Task StartHostAsync(RHostStartupInfo startupInfo, int timeout = 3000) {
IsHostRunning = true;
Connected?.Invoke(this, EventArgs.Empty);
return Task.CompletedTask;
}
private async Task AfterHostStarted(RHostStartupInfo startupInfo)
{
var evaluator = new BeforeInitializedRExpressionEvaluator(this);
try {
await LoadRtvsPackage(evaluator, IsRemote);
var suggest_mro = await evaluator.EvaluateAsync <bool>("!exists('Revo.version')", REvaluationKind.Normal);
if (suggest_mro)
{
await WriteOutputAsync(Resources.Message_SuggestMRO);
}
var wd = startupInfo.WorkingDirectory;
if (!IsRemote && !string.IsNullOrEmpty(wd))
{
try {
await evaluator.SetWorkingDirectoryAsync(wd);
} catch (REvaluationException) {
await evaluator.SetDefaultWorkingDirectoryAsync();
}
}
else
{
await evaluator.SetDefaultWorkingDirectoryAsync();
}
if (!startupInfo.IsInteractive || IsRemote)
{
// If session is non-interactive (such as intellisense) or it is remote
// we need to set up UI suppression overrides.
try {
await SuppressUI(evaluator);
} catch (REvaluationException) { }
}
var callback = _callback;
if (callback != null)
{
await evaluator.SetVsGraphicsDeviceAsync();
string mirrorUrl = callback.CranUrlFromName(startupInfo.CranMirrorName);
try {
await evaluator.SetVsCranSelectionAsync(mirrorUrl);
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationMirror, mirrorUrl, ex.Message);
}
try {
await evaluator.SetCodePageAsync(startupInfo.CodePage);
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationCodePage, startupInfo.CodePage, ex.Message);
}
try {
await evaluator.SetROptionsAsync();
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationOptions, ex.Message);
}
await evaluator.OverrideFunctionAsync("setwd", "base");
await evaluator.SetFunctionRedirectionAsync();
await evaluator.SetGridEvalModeAsync(startupInfo.GridDynamicEvaluation);
try {
await evaluator.OptionsSetWidthAsync(startupInfo.TerminalWidth);
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationOptions, ex.Message);
}
if (startupInfo.EnableAutosave)
{
try {
// Only enable autosave for this session after querying the user about any existing file.
// This way, if they happen to disconnect while still querying, we don't save the new empty
// session and overwrite the old file.
bool deleteExisting = await evaluator.QueryReloadAutosaveAsync();
await evaluator.EnableAutosaveAsync(deleteExisting);
} catch (REvaluationException ex) {
await WriteErrorAsync(Resources.Error_SessionInitializationAutosave, ex.Message);
}
}
Interactive?.Invoke(this, EventArgs.Empty);
}
_initializedTcs.SetResult(null);
} catch (Exception ex) when(!ex.IsCriticalException())
{
#if DEBUG
// Detailed exception information in REPL is not particularly useful to the end user.
await WriteErrorAsync(Resources.Error_SessionInitialization, ex);
#endif
if (!(ex is RHostDisconnectedException))
{
StopHostAsync().DoNotWait();
}
if (ex is OperationCanceledException oce)
{
_initializedTcs.SetCanceled(oce);
}
else
{
_initializedTcs.SetException(ex);
}
}
}
public Task StartHostAsync(RHostStartupInfo startupInfo, int timeout = 3000)
{
IsHostRunning = true;
Connected?.Invoke(this, EventArgs.Empty);
return(Task.CompletedTask);
}
private async Task AfterHostStarted(RSessionEvaluationSource evaluationSource, RHostStartupInfo startupInfo)
{
using (var evaluation = await evaluationSource.Task) {
// Load RTVS R package before doing anything in R since the calls
// below calls may depend on functions exposed from the RTVS package
var libPath = BrokerConnector.IsRemote
? "."
: Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetAssemblyPath());
await LoadRtvsPackage(evaluation, libPath);
if (!IsRemote && startupInfo.WorkingDirectory != null)
{
await evaluation.SetWorkingDirectoryAsync(startupInfo.WorkingDirectory);
}
else
{
await evaluation.SetDefaultWorkingDirectoryAsync();
}
var callback = _callback;
if (callback != null)
{
await evaluation.SetVsGraphicsDeviceAsync();
string mirrorUrl = callback.CranUrlFromName(startupInfo.CranMirrorName);
await evaluation.SetVsCranSelectionAsync(mirrorUrl);
await evaluation.SetCodePageAsync(startupInfo.CodePage);
await evaluation.SetROptionsAsync();
await evaluation.OverrideFunctionAsync("setwd", "base");
await evaluation.SetFunctionRedirectionAsync();
await evaluation.OptionsSetWidthAsync(startupInfo.TerminalWidth);
}
}
}
private async Task AfterHostStarted(RSessionEvaluationSource evaluationSource, RHostStartupInfo startupInfo)
{
try {
using (var evaluation = await evaluationSource.Task) {
// Load RTVS R package before doing anything in R since the calls
// below calls may depend on functions exposed from the RTVS package
await LoadRtvsPackage(evaluation);
if (startupInfo.WorkingDirectory != null)
{
await evaluation.SetWorkingDirectoryAsync(startupInfo.WorkingDirectory);
}
else
{
await evaluation.SetDefaultWorkingDirectoryAsync();
}
var callback = _callback;
if (callback != null)
{
await evaluation.SetVsGraphicsDeviceAsync();
string mirrorUrl = callback.CranUrlFromName(startupInfo.CranMirrorName);
await evaluation.SetVsCranSelectionAsync(mirrorUrl);
await evaluation.SetCodePageAsync(startupInfo.CodePage);
await evaluation.SetROptionsAsync();
await evaluation.OverrideFunctionAsync("setwd", "base");
await evaluation.SetFunctionRedirectionAsync();
await evaluation.OptionsSetWidthAsync(startupInfo.TerminalWidth);
}
_afterHostStartedTcs.SetResult(null);
}
} catch (OperationCanceledException oce) {
_afterHostStartedTcs.TrySetCanceled(oce.CancellationToken);
} catch (Exception ex) {
_afterHostStartedTcs.TrySetException(ex);
}
}
private async Task StartHostAsyncBackground(RHostStartupInfo startupInfo, int timeout) {
await TaskUtilities.SwitchToBackgroundThread();
_host = new RHost(startupInfo != null ? startupInfo.Name : "Empty", this);
ClearPendingRequests();
var initializationTask = _initializationTcs.Task;
_hostRunTask = CreateAndRunHost(startupInfo, timeout);
ScheduleAfterHostStarted(startupInfo);
await initializationTask;
}
private void ScheduleAfterHostStarted(RHostStartupInfo startupInfo) {
var afterHostStartedEvaluationSource = new RSessionEvaluationSource(true, CancellationToken.None);
_pendingEvaluationSources.Post(afterHostStartedEvaluationSource);
AfterHostStarted(afterHostStartedEvaluationSource, startupInfo).DoNotWait();
}
private async Task CreateAndRunHost(RHostStartupInfo startupInfo, int timeout) {
try {
await _host.CreateAndRun(RInstallation.GetRInstallPath(startupInfo.RBasePath), startupInfo.RHostDirectory, startupInfo.RHostCommandLineArguments, timeout);
} catch (OperationCanceledException oce) {
_initializationTcs.TrySetCanceled(oce.CancellationToken);
} catch (Exception ex) {
_initializationTcs.TrySetException(ex);
} finally {
Interlocked.Exchange(ref _initializationTcs, null);
}
}
public Task EnsureHostStartedAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, IUIService ui, int timeout = 3000, CancellationToken cancellationToken = default) => StartHostAsync(startupInfo, callback, ui, timeout, false, cancellationToken);
private async Task AfterHostStarted(RSessionEvaluationSource evaluationSource, RHostStartupInfo startupInfo) {
using (var evaluation = await evaluationSource.Task) {
// Load RTVS R package before doing anything in R since the calls
// below calls may depend on functions exposed from the RTVS package
await LoadRtvsPackage(evaluation);
if (startupInfo.WorkingDirectory != null) {
await evaluation.SetWorkingDirectory(startupInfo.WorkingDirectory);
} else {
await evaluation.SetDefaultWorkingDirectory();
}
if (_hostClientApp != null) {
await evaluation.SetVsGraphicsDevice();
string mirrorUrl = _hostClientApp.CranUrlFromName(startupInfo.CranMirrorName);
await evaluation.SetVsCranSelection(mirrorUrl);
await evaluation.SetVsHelpRedirection();
await evaluation.SetChangeDirectoryRedirection();
}
}
}
public Task EnsureHostStartedAsync(RHostStartupInfo startupInfo, IRSessionCallback callback, int timeout = 3000, CancellationToken cancellationToken = default(CancellationToken)) {
IsHostRunning = true;
Connected?.Invoke(this, new RConnectedEventArgs(string.Empty));
return Task.CompletedTask;
}
