private async Task RMarkdownRenderAsync(IRSession session, IFileSystem fs, string inputFilePath, string outputFilePath, string format, int codePage, IApplicationShell appShell) {
using (var fts = new DataTransferSession(session, fs)) {
string currentStatusText = string.Empty;
uint cookie = 0;
IVsStatusbar statusBar = null;
appShell.DispatchOnUIThread(() => {
statusBar = appShell.GetGlobalService<IVsStatusbar>(typeof(SVsStatusbar));
statusBar.GetText(out currentStatusText);
statusBar.Progress(ref cookie, 1, "", 0, 0);
});
try {
// TODO: progress and cancellation handling
appShell.DispatchOnUIThread(() => { statusBar?.Progress(ref cookie, 1, Resources.Info_MarkdownSendingInputFile.FormatInvariant(Path.GetFileName(inputFilePath)), 0, 3); });
var rmd = await fts.SendFileAsync(inputFilePath, true, null, CancellationToken.None);
appShell.DispatchOnUIThread(() => { statusBar?.Progress(ref cookie, 1, Resources.Info_MarkdownPublishingFile.FormatInvariant(Path.GetFileName(inputFilePath)), 1, 3); });
var publishResult = await session.EvaluateAsync<ulong>($"rtvs:::rmarkdown_publish(blob_id = {rmd.Id}, output_format = {format.ToRStringLiteral()}, encoding = 'cp{codePage}')", REvaluationKind.Normal);
appShell.DispatchOnUIThread(() => { statusBar?.Progress(ref cookie, 1, Resources.Info_MarkdownGetOutputFile.FormatInvariant(Path.GetFileName(outputFilePath)), 2, 3); });
await fts.FetchFileAsync(new RBlobInfo(publishResult), outputFilePath, true, null, CancellationToken.None);
appShell.DispatchOnUIThread(() => { statusBar?.Progress(ref cookie, 1, Resources.Info_MarkdownPublishComplete.FormatInvariant(Path.GetFileName(outputFilePath)), 3, 3); });
} finally {
appShell.DispatchOnUIThread(() => {
statusBar?.Progress(ref cookie, 0, "", 0, 0);
statusBar?.SetText(currentStatusText);
});
}
}
}
private async Task<bool> SendToRemoteWorkerAsync(IEnumerable<string> files, string projectDir, string projectName, string remotePath, IVsStatusbar statusBar, CancellationToken cancellationToken) {
await TaskUtilities.SwitchToBackgroundThread();
string currentStatusText;
statusBar.GetText(out currentStatusText);
var workflow = _interactiveWorkflowProvider.GetOrCreate();
var outputWindow = workflow.ActiveWindow.InteractiveWindow;
uint cookie = 0;
try {
var session = workflow.RSession;
statusBar.SetText(Resources.Info_CompressingFiles);
statusBar.Progress(ref cookie, 1, "", 0, 0);
int count = 0;
uint total = (uint)files.Count() * 2; // for compressing and sending
string compressedFilePath = string.Empty;
await Task.Run(() => {
compressedFilePath = _fs.CompressFiles(files, projectDir, new Progress<string>((p) => {
Interlocked.Increment(ref count);
statusBar.Progress(ref cookie, 1, string.Format(Resources.Info_CompressingFile, Path.GetFileName(p)), (uint)count, total);
string dest = p.MakeRelativePath(projectDir).ProjectRelativePathToRemoteProjectPath(remotePath, projectName);
_appShell.DispatchOnUIThread(() => {
outputWindow.WriteLine(string.Format(Resources.Info_LocalFilePath, p));
outputWindow.WriteLine(string.Format(Resources.Info_RemoteFilePath, dest));
});
}), CancellationToken.None);
statusBar.Progress(ref cookie, 0, "", 0, 0);
});
using (var fts = new DataTransferSession(session, _fs)) {
cookie = 0;
statusBar.SetText(Resources.Info_TransferringFiles);
total = (uint)_fs.FileSize(compressedFilePath);
var remoteFile = await fts.SendFileAsync(compressedFilePath, true, new Progress<long>((b) => {
statusBar.Progress(ref cookie, 1, Resources.Info_TransferringFiles, (uint)b, total);
}), cancellationToken);
statusBar.SetText(Resources.Info_ExtractingFilesInRHost);
await session.EvaluateAsync<string>($"rtvs:::save_to_project_folder({remoteFile.Id}, {projectName.ToRStringLiteral()}, '{remotePath.ToRPath()}')", REvaluationKind.Normal, cancellationToken);
_appShell.DispatchOnUIThread(() => {
outputWindow.WriteLine(Resources.Info_TransferringFilesDone);
});
}
} catch(Exception ex) when (ex is UnauthorizedAccessException || ex is IOException) {
_appShell.ShowErrorMessage(Resources.Error_CannotTransferFile.FormatInvariant(ex.Message));
} catch (RHostDisconnectedException rhdex) {
_appShell.DispatchOnUIThread(() => {
outputWindow.WriteErrorLine(Resources.Error_CannotTransferNoRSession.FormatInvariant(rhdex.Message));
});
} finally {
statusBar.Progress(ref cookie, 0, "", 0, 0);
statusBar.SetText(currentStatusText);
}
return true;
}
public async Task<CommandResult> InvokeAsync() {
string filePath = GetFilePath();
if (filePath == null) {
return CommandResult.NotSupported;
}
var textView = GetActiveTextView();
var activeWindow = _interactiveWorkflow.ActiveWindow;
if (textView == null || activeWindow == null) {
return CommandResult.NotSupported;
}
_interactiveWorkflow.Shell.SaveFileIfDirty(filePath);
activeWindow.Container.Show(focus: false, immediate: false);
var session = _interactiveWorkflow.RSession;
if (session.IsRemote) {
using (DataTransferSession dts = new DataTransferSession(_interactiveWorkflow.RSession, new FileSystem())) {
// TODO: add progress indication and cancellation
string remotePath = await dts.CopyFileToRemoteTempAsync(filePath, true, null, CancellationToken.None);
await _interactiveWorkflow.Operations.SourceFileAsync(remotePath, _echo, textView.TextBuffer.GetEncoding());
}
} else {
await _interactiveWorkflow.Operations.SourceFileAsync(filePath, _echo, textView.TextBuffer.GetEncoding());
}
return CommandResult.Executed;
}
public async Task ViewFile(string fileName, string tabName, bool deleteFile, CancellationToken cancellationToken = default(CancellationToken)) {
var viewer = _coreShell.ExportProvider.GetExportedValue<IObjectViewer>();
var task = Task.CompletedTask;
if (_session.IsRemote) {
using (var dts = new DataTransferSession(_session, _fileSystem)) {
// TODO: handle progress for large files
try {
await dts.FetchFileToLocalTempAsync(fileName.ToRPath(), null, cancellationToken);
fileName = _fileSystem.GetDownloadsPath(Path.GetFileName(fileName));
await viewer?.ViewFile(fileName, tabName, deleteFile, cancellationToken);
} catch (REvaluationException) { } catch (RHostDisconnectedException) { }
}
} else {
await viewer?.ViewFile(fileName, tabName, deleteFile, cancellationToken);
}
}
private async Task ExportAsync(string outputFilePath, Task<ulong> exportTask) {
try {
var result = await exportTask;
using(DataTransferSession dts = new DataTransferSession(InteractiveWorkflow.RSession, _fileSystem)) {
// TODO: add progress indication and cancellation
await dts.FetchFileAsync(new RBlobInfo(result), outputFilePath, true, null, CancellationToken.None);
}
} catch (IOException ex) {
throw new RPlotManagerException(ex.Message, ex);
} catch (RException ex) {
throw new RPlotManagerException(string.Format(CultureInfo.InvariantCulture, Resources.Plots_EvalError, ex.Message), ex);
}
}
private static async Task CreateCsvAndStartProcess(
IREvaluationResultInfo result,
IRSession session,
string fileName,
IFileSystem fileSystem,
IProgress<ProgressDialogData> progress,
CancellationToken cancellationToken) {
await TaskUtilities.SwitchToBackgroundThread();
var sep = CultureInfo.CurrentCulture.TextInfo.ListSeparator;
var dec = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
var csvDataBlobId = await session.EvaluateAsync<ulong>($"rtvs:::export_to_csv({result.Expression}, sep={sep.ToRStringLiteral()}, dec={dec.ToRStringLiteral()})", REvaluationKind.Normal, cancellationToken);
using (DataTransferSession dts = new DataTransferSession(session, fileSystem)) {
var total = await session.GetBlobSizeAsync(csvDataBlobId, cancellationToken);
progress.Report(new ProgressDialogData(0, statusBarText: Resources.Status_WritingCSV, waitMessage: Resources.Status_WritingCSV));
await dts.FetchAndDecompressFileAsync(new RBlobInfo(csvDataBlobId), fileName, true, new Progress<long>(b => {
var step = (int)(b * 100 / total);
progress.Report(new ProgressDialogData(step, statusBarText: Resources.Status_WritingCSV, waitMessage: Resources.Status_WritingCSV));
}), cancellationToken);
progress.Report(new ProgressDialogData(100, statusBarText: Resources.Status_WritingCSV, waitMessage: Resources.Status_WritingCSV));
}
}
private async Task SendProjectAsync(EnvDTE.Project project, string remotePath, string filterString, CancellationToken cancellationToken) {
ProgressOutputWriter.WriteLine(Resources.Info_PreparingProjectForTransfer);
var projectDir = Path.GetDirectoryName(project.FullName);
var projectName = Path.GetFileNameWithoutExtension(project.FullName);
string[] filterSplitter = { ";" };
Matcher matcher = new Matcher(StringComparison.InvariantCultureIgnoreCase);
matcher.AddIncludePatterns(filterString.Split(filterSplitter, StringSplitOptions.RemoveEmptyEntries));
ProgressOutputWriter.WriteLine(Resources.Info_RemoteDestination.FormatInvariant(remotePath));
ProgressOutputWriter.WriteLine(Resources.Info_FileTransferFilter.FormatInvariant(filterString));
ProgressOutputWriter.WriteLine(Resources.Info_CompressingFiles);
var compressedFilePath = FileSystem.CompressDirectory(projectDir, matcher, new Progress<string>((p) => {
ProgressOutputWriter.WriteLine(Resources.Info_LocalFilePath.FormatInvariant(p));
string dest = p.MakeRelativePath(projectDir).ProjectRelativePathToRemoteProjectPath(remotePath, projectName);
ProgressOutputWriter.WriteLine(Resources.Info_RemoteFilePath.FormatInvariant(dest));
}), CancellationToken.None);
using (var fts = new DataTransferSession(Session, FileSystem)) {
ProgressOutputWriter.WriteLine(Resources.Info_TransferringFiles);
var remoteFile = await fts.SendFileAsync(compressedFilePath, true, null, cancellationToken);
await Session.EvaluateAsync<string>($"rtvs:::save_to_project_folder({remoteFile.Id}, {projectName.ToRStringLiteral()}, '{remotePath.ToRPath()}')", REvaluationKind.Normal, cancellationToken);
}
ProgressOutputWriter.WriteLine(Resources.Info_TransferringFilesDone);
}