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); }