public async Task CreateGetDestroyBlobs() { byte[] data1 = new byte[] { 0, 1, 2, 3, 4, 5 }; byte[] data2 = new byte[] { 10, 11, 12, 13, 14, 15 }; byte[] data3 = new byte[] { 20, 21, 22, 23, 24, 25 }; var dataSet = new byte[][] { data1, data2, data3 }; using (DataTransferSession dts = new DataTransferSession(_session, null)) { var blob1 = await dts.SendBytesAsync(data1); var blob2 = await dts.SendBytesAsync(data2); var blob3 = await dts.SendBytesAsync(data3); blob1.Id.Should().BeGreaterThan(0); blob2.Id.Should().BeGreaterThan(0); blob3.Id.Should().BeGreaterThan(0); blob1.Id.Should().NotBe(blob2.Id); blob2.Id.Should().NotBe(blob3.Id); blob3.Id.Should().NotBe(blob1.Id); var blobIds = new IRBlobInfo[] { blob1, blob2, blob3 }; for (int i = 0; i < blobIds.Length; ++i) { var blob = await dts.FetchBytesAsync(blobIds[i], false); blob.Should().Equal(dataSet[i]); } } }
public async Task <string> EditFileAsync(string content, string fileName, CancellationToken cancellationToken = default(CancellationToken)) { TaskUtilities.AssertIsOnBackgroundThread(); var editor = _coreShell.GetService <IFileEditor>(); if (!string.IsNullOrEmpty(content)) { return(await editor.EditFileAsync(content, null, cancellationToken)); } if (!string.IsNullOrEmpty(fileName)) { 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)); return(await editor.EditFileAsync(null, fileName, cancellationToken)); } catch (OperationCanceledException) { } } } return(await editor.EditFileAsync(null, fileName, cancellationToken)); } return(string.Empty); }
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.GlobalServices.GetService <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 CopyFileAsync(string path, HttpListenerContext context, CancellationToken ct) { using (DataTransferSession dts = new DataTransferSession(_session, FileSystem)) { await dts.CopyToFileStreamAsync(path, context.Response.OutputStream, true, null, ct); } context.Response.OutputStream.Close(); }
public async Task CompressedBlob() { var createResult = await _session.EvaluateAsync("rtvs:::create_blob(raw(1000000))", REvaluationKind.Normal); createResult.Result.Should().NotBeNull(); var createCompressedResult = await _session.EvaluateAsync("rtvs:::create_compressed_blob(raw(1000000))", REvaluationKind.Normal); createCompressedResult.Result.Should().NotBeNull(); var blobId = ((JValue)createResult.Result).Value <ulong>(); var blobId2 = ((JValue)createCompressedResult.Result).Value <ulong>(); using (DataTransferSession dts = new DataTransferSession(_session, new WindowsFileSystem())) { var expectedData = await dts.FetchBytesAsync(new RBlobInfo(blobId), true, null, CancellationToken.None); var compressedData = await dts.FetchBytesAsync(new RBlobInfo(blobId2), true, null, CancellationToken.None); compressedData.Length.Should().BeLessThan(expectedData.Length); var actualData = await dts.FetchAndDecompressBytesAsync(new RBlobInfo(blobId2), true, null, CancellationToken.None); actualData.Should().Equal(expectedData); } }
public async Task <string> FetchFileAsync(string remoteFileName, ulong remoteBlobId, string localPath, CancellationToken cancellationToken) { await _coreShell.SwitchToMainThreadAsync(cancellationToken); if (!string.IsNullOrEmpty(localPath)) { if (_fileSystem.DirectoryExists(localPath)) { localPath = Path.Combine(localPath, remoteFileName); } } else { localPath = _fileSystem.GetDownloadsPath(remoteFileName); } try { var message = Resources.Progress_FetchingFile.FormatInvariant(remoteFileName); _coreShell.ProgressDialog.Show(async(progress, ct) => { using (DataTransferSession dts = new DataTransferSession(_session, _fileSystem)) { await dts.FetchAndDecompressFileAsync(remoteBlobId, localPath, progress, message, cancellationToken); } }, message); } catch (Exception ex) { _coreShell.ShowErrorMessage(Resources.Error_UnableToTransferFile.FormatInvariant(localPath, ex.Message)); return(string.Empty); } return(localPath); }
private async Task SendProjectAsync(EnvDTE.Project project, string remotePath, string filterString, CancellationToken cancellationToken) { Console.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)); Console.WriteLine(Resources.Info_RemoteDestination.FormatInvariant(remotePath)); Console.WriteLine(Resources.Info_FileTransferFilter.FormatInvariant(filterString)); Console.WriteLine(Resources.Info_CompressingFiles); var compressedFilePath = FileSystem.CompressDirectory(projectDir, matcher, new Progress <string>((p) => { Console.WriteLine(Resources.Info_LocalFilePath.FormatInvariant(p)); string dest = p.MakeRelativePath(projectDir).ProjectRelativePathToRemoteProjectPath(remotePath, projectName); Console.WriteLine(Resources.Info_RemoteFilePath.FormatInvariant(dest)); }), CancellationToken.None); using (var fts = new DataTransferSession(Session, FileSystem)) { Console.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); } Console.WriteLine(Resources.Info_TransferringFilesDone); }
public async Task CreateGetDestroyBlobs() { byte[] data1 = new byte[] { 0, 1, 2, 3, 4, 5 }; byte[] data2 = new byte[] { 10, 11, 12, 13, 14, 15 }; byte[] data3 = new byte[] { 20, 21, 22, 23, 24, 25 }; var dataSet = new byte[][] { data1, data2, data3 }; using (DataTransferSession dts = new DataTransferSession(_session, null)) { var blob1 = await dts.SendBytesAsync(data1, true, null, CancellationToken.None); var blob2 = await dts.SendBytesAsync(data2, true, null, CancellationToken.None); var blob3 = await dts.SendBytesAsync(data3, true, null, CancellationToken.None); blob1.Id.Should().BeGreaterThan(0); blob2.Id.Should().BeGreaterThan(0); blob3.Id.Should().BeGreaterThan(0); blob1.Id.Should().NotBe(blob2.Id); blob2.Id.Should().NotBe(blob3.Id); blob3.Id.Should().NotBe(blob1.Id); var blobIds = new IRBlobInfo[] { blob1, blob2, blob3 }; for (int i = 0; i < blobIds.Length; ++i) { var blob = await dts.FetchBytesAsync(blobIds[i], false, null, CancellationToken.None); blob.Should().Equal(dataSet[i]); } } }
public async Task CreateBlob_DisconnectedFromTheStart() { using (var session = new RSession(0, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { })) { var data = new byte[] { 1, 2, 3, 4, 5 }; using (DataTransferSession dts = new DataTransferSession(session, null)) { Func<Task> f = () => dts.SendBytesAsync(data, false, null, CancellationToken.None); await f.ShouldThrowAsync<RHostDisconnectedException>(); } } }
public async Task CreateBlob_DisconnectedFromTheStart() { using (var session = new RSession(0, _brokerClient, () => { })) { var data = new byte[] { 1, 2, 3, 4, 5 }; using (DataTransferSession dts = new DataTransferSession(session, null)) { Func <Task> f = () => dts.SendBytesAsync(data, false); await f.ShouldThrowAsync <RHostDisconnectedException>(); } } }
private async Task RMarkdownRenderAsync(IRSession session, IFileSystem fs, string inputFilePath, string outputFilePath, string format, int codePage) { using (var fts = new DataTransferSession(session, fs)) { var rmd = await fts.SendFileAsync(inputFilePath); var publishResult = await session.EvaluateAsync <ulong>($"rtvs:::rmarkdown_publish(blob_id = {rmd.Id}, output_format = {format.ToRStringLiteral()}, encoding = 'cp{codePage}')", REvaluationKind.Normal); await fts.FetchFileAsync(new RBlobInfo(publishResult), outputFilePath); } }
public async Task CreateBlob_DisconnectedFromTheStart() { using (var session = new RSession(0, _testMethod.FileSystemSafeName, _fileSystem, _brokerClient, new AsyncReaderWriterLock().CreateExclusiveReaderLock(), () => { })) { var data = new byte[] { 1, 2, 3, 4, 5 }; using (DataTransferSession dts = new DataTransferSession(session, null)) { Func <Task> f = () => dts.SendBytesAsync(data, false, null, CancellationToken.None); await f.ShouldThrowAsync <RHostDisconnectedException>(); } } }
private async Task ExportToImageAsync(IRSession session, string format, string filePath, int widthInPixels, int heightInPixels, int resolution) { string script = String.Format(@" device_id <- rtvs:::graphics.ide.getactivedeviceid() rtvs:::export_to_image(device_id, rtvs:::graphics.ide.getactiveplotid(device_id), {0}, {1}, {2}, {3}) ", format, widthInPixels, heightInPixels, resolution); var blobid = await session.EvaluateAsync <ulong>(script, REvaluationKind.Normal); using (DataTransferSession dts = new DataTransferSession(session, new FileSystem())) { await dts.FetchFileAsync(new RBlobInfo(blobid), filePath, true, null, CancellationToken.None); } }
public async Task CreateBlob_DisconnectedDuringCreate() { var data = new byte[25 * 1024 * 1024]; // try to send a massive blob ManualResetEvent testStarted = new ManualResetEvent(false); using (DataTransferSession dts = new DataTransferSession(_session, null)) { Func<Task> f = () => dts.SendBytesAsync(data, false, null, CancellationToken.None); var assertion = f.ShouldThrowAsync<RHostDisconnectedException>(); await Task.Delay(100); await _session.StopHostAsync(); await assertion; } }
private async Task ExportAsync(string outputFilePath, Task <ulong> exportTask) { try { var result = await exportTask; using (DataTransferSession dts = new DataTransferSession(InteractiveWorkflow.RSession, _fileSystem)) { await dts.FetchFileAsync(new RBlobInfo(result), outputFilePath); } } 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); } }
public async Task CreateBlob_DisconnectedDuringCreate() { var data = new byte[25 * 1024 * 1024]; // try to send a massive blob using (DataTransferSession dts = new DataTransferSession(_session, null)) { Func <Task> f = () => dts.SendBytesAsync(data, false, null, CancellationToken.None); var assertion = f.ShouldThrowAsync <RHostDisconnectedException>(); await Task.Delay(100); await _session.StopHostAsync(); await assertion; } }
private async Task <IEnumerable <string> > ExportToPdfAsync(string[] inputs, string filePath, int width, int height) { var app = new RHostClientTestApp { PlotHandler = OnPlot, PlotDeviceCreateHandler = OnDeviceCreate, PlotDeviceDestroyHandler = OnDeviceDestroy }; using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) { await sessionProvider.TrySwitchBrokerAsync(nameof(IdeGraphicsDeviceTest)); var session = sessionProvider.GetOrCreate(Guid.NewGuid()); await session.StartHostAsync(new RHostStartupInfo { Name = _testMethod.Name }, app, 50000); foreach (var input in inputs) { using (var interaction = await session.BeginInteractionAsync()) { await interaction.RespondAsync(input.EnsureLineBreak()); } } string script = String.Format(@" device_id <- rtvs:::graphics.ide.getactivedeviceid() rtvs:::export_to_pdf(device_id, rtvs:::graphics.ide.getactiveplotid(device_id), {0}, {1}) ", width, height); var blobid = await session.EvaluateAsync <ulong>(script, REvaluationKind.Normal); using (DataTransferSession dts = new DataTransferSession(session, new FileSystem())) { await dts.FetchFileAsync(new RBlobInfo(blobid), filePath); } await session.StopHostAsync(); } // Ensure that all plot files created by the graphics device have been deleted foreach (var plot in OriginalPlotMessages) { File.Exists(plot.FilePath).Should().BeFalse(); } return(PlotFilePaths.AsReadOnly()); }
private async Task RMarkdownRenderAsync(IRSession session, string inputFilePath, string outputFilePath, string format, int codePage, IServiceContainer services) { using (var fts = new DataTransferSession(session, services.FileSystem())) { var statusBar = services.GetService <IStatusBar>(); using (var progress = await statusBar.ShowProgressAsync(3)) { // TODO: cancellation handling progress.Report(new StatusBarProgressData(Resources.Info_MarkdownSendingInputFile.FormatInvariant(Path.GetFileName(inputFilePath)), 0)); var rmd = await fts.SendFileAsync(inputFilePath, true, null, CancellationToken.None); progress.Report(new StatusBarProgressData(Resources.Info_MarkdownPublishingFile.FormatInvariant(Path.GetFileName(inputFilePath)), 1)); var publishResult = await session.EvaluateAsync <ulong>($"rtvs:::rmarkdown_publish(blob_id = {rmd.Id}, output_format = {format.ToRStringLiteral()}, encoding = 'cp{codePage}')", REvaluationKind.Normal); progress.Report(new StatusBarProgressData(Resources.Info_MarkdownGetOutputFile.FormatInvariant(Path.GetFileName(outputFilePath)), 2)); await fts.FetchFileAsync(new RBlobInfo(publishResult), outputFilePath, true, null, CancellationToken.None); progress.Report(new StatusBarProgressData(Resources.Info_MarkdownPublishComplete.FormatInvariant(Path.GetFileName(outputFilePath)), 3)); } } }
public async Task GetBlob_CanceledDuringGet() { var cts = new CancellationTokenSource(); var data = new byte[1024 * 1024]; IRBlobInfo blob = null; using (DataTransferSession dts = new DataTransferSession(_session, null)) { blob = await dts.SendBytesAsync(data, false, null, CancellationToken.None); } Func <Task> f = async() => { while (true) { await _session.BlobReadAllAsync(blob.Id, ct : cts.Token); } }; var assertion = f.ShouldThrowAsync <OperationCanceledException>(); cts.CancelAfter(1); await assertion; }
public async Task ViewFile(string fileName, string tabName, bool deleteFile, CancellationToken cancellationToken = default(CancellationToken)) { var viewer = _coreShell.GetService <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 static async Task CreateCsvAndStartProcess(IREvaluationResultInfo result, IRSession session, string fileName, IFileSystem fileSystem, IProgress <ProgressDialogData> progress) { await TaskUtilities.SwitchToBackgroundThread(); var sep = CultureInfo.CurrentCulture.TextInfo.ListSeparator; var dec = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator; using (var e = await session.BeginEvaluationAsync()) { var csvDataBlobId = await e.EvaluateAsync <ulong>($"rtvs:::export_to_csv({result.Expression}, sep={sep.ToRStringLiteral()}, dec={dec.ToRStringLiteral()})", REvaluationKind.Normal); using (DataTransferSession dts = new DataTransferSession(session, fileSystem)) { var total = await session.GetBlobSizeAsync(csvDataBlobId, CancellationToken.None); progress.Report(new ProgressDialogData(0, statusBarText: Resources.Status_WritingCSV, waitMessage: Resources.Status_WritingCSV)); await dts.FetchFileAsync(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)); })); progress.Report(new ProgressDialogData(100, statusBarText: Resources.Status_WritingCSV, waitMessage: Resources.Status_WritingCSV)); } } }
public async Task GetBlob_DisconnectedDuringGet() { var data = new byte[1024 * 1024]; IRBlobInfo blob = null; using (DataTransferSession dts = new DataTransferSession(_session, null)) { blob = await dts.SendBytesAsync(data, false, null, CancellationToken.None); } using (RBlobStream blobStream = await RBlobStream.OpenAsync(blob, _session)) { Func <Task> f = async() => { using (MemoryStream ms = new MemoryStream()) { await blobStream.CopyToAsync(ms, 1024); } }; await Task.Delay(100); await _session.StopHostAsync(); await f.ShouldThrowAsync <RHostDisconnectedException>(); } }
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); }
private static async Task CreateCsvAndStartProcess( IREvaluationResultInfo result, IRSession session, ICoreShell coreShell, string fileName, IFileSystem fileSystem, IProgress <ProgressDialogData> progress, CancellationToken cancellationToken) { await TaskUtilities.SwitchToBackgroundThread(); var sep = CultureInfo.CurrentCulture.TextInfo.ListSeparator; var dec = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator; try { 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)) { await dts.FetchAndDecompressFileAsync(csvDataBlobId, fileName, progress, Resources.Status_WritingCSV, cancellationToken); } } catch (RException) { await coreShell.ShowErrorMessageAsync(Resources.Error_CannotExportToCsv, cancellationToken); } }
public async Task CompressedZeroSizedBlob() { var createResult = await _session.EvaluateAsync("rtvs:::create_blob(raw())", REvaluationKind.Normal); createResult.Result.Should().NotBeNull(); var createCompressedResult = await _session.EvaluateAsync("rtvs:::create_compressed_blob(raw())", REvaluationKind.Normal); createCompressedResult.Result.Should().NotBeNull(); var blobId = ((JValue)createResult.Result).Value<ulong>(); var blobId2 = ((JValue)createCompressedResult.Result).Value<ulong>(); using (DataTransferSession dts = new DataTransferSession(_session, new FileSystem())) { var expectedData = await dts.FetchBytesAsync(new RBlobInfo(blobId), true, null, CancellationToken.None); var actualData = await dts.FetchAndDecompressBytesAsync(new RBlobInfo(blobId2), true, null, CancellationToken.None); actualData.Should().Equal(expectedData); } }
private async Task SendToRemoteWorkerAsync(IEnumerable <string> files, string projectDir, string projectName, string remotePath, IProgress <ProgressDialogData> progress, CancellationToken ct) { await TaskUtilities.SwitchToBackgroundThread(); var workflow = _interactiveWorkflowProvider.GetOrCreate(); IConsole console = new InteractiveWindowConsole(workflow); try { var session = workflow.RSession; int count = 0; int total = files.Count(); progress.Report(new ProgressDialogData(0, Resources.Info_CompressingFiles)); if (ct.IsCancellationRequested) { return; } List <string> paths = new List <string>(); // Compression phase : 1 of 3 phases. string compressedFilePath = string.Empty; compressedFilePath = _fs.CompressFiles(files, projectDir, new Progress <string>((p) => { Interlocked.Increment(ref count); int step = (count * 100 / total) / 3; // divide by 3, this is for compression phase. progress.Report(new ProgressDialogData(step, Resources.Info_CompressingFile.FormatInvariant(Path.GetFileName(p), _fs.FileSize(p)))); string dest = p.MakeRelativePath(projectDir).ProjectRelativePathToRemoteProjectPath(remotePath, projectName); paths.Add($"{Resources.Info_LocalFilePath.FormatInvariant(p)}{Environment.NewLine}{Resources.Info_RemoteFilePath.FormatInvariant(dest)}"); }), ct); if (ct.IsCancellationRequested) { return; } using (var fts = new DataTransferSession(session, _fs)) { long size = _fs.FileSize(compressedFilePath); // Transfer phase: 2 of 3 phases var remoteFile = await fts.SendFileAsync(compressedFilePath, true, new Progress <long>((b) => { int step = 33; // start with 33% to indicate compression phase is done. step += (int)((((double)b / (double)size) * 100) / 3); // divide by 3, this is for transfer phase. progress.Report(new ProgressDialogData(step, Resources.Info_TransferringFilesWithSize.FormatInvariant(b, size))); }), ct); if (ct.IsCancellationRequested) { return; } // Extract phase: 3 of 3 phases // start with 66% completion to indicate compression and transfer phases are done. progress.Report(new ProgressDialogData(66, Resources.Info_ExtractingFilesInRHost)); await session.EvaluateAsync <string>($"rtvs:::save_to_project_folder({remoteFile.Id}, {projectName.ToRStringLiteral()}, '{remotePath.ToRPath()}')", REvaluationKind.Normal, ct); progress.Report(new ProgressDialogData(100, Resources.Info_TransferringFilesDone)); paths.ForEach((s) => console.WriteLine(s)); } } catch (TaskCanceledException) { console.WriteErrorLine(Resources.Info_FileTransferCanceled); } catch (RHostDisconnectedException rhdex) { console.WriteErrorLine(Resources.Error_CannotTransferNoRSession.FormatInvariant(rhdex.Message)); } catch (Exception ex) when(ex is UnauthorizedAccessException || ex is IOException) { _ui.ShowErrorMessage(Resources.Error_CannotTransferFile.FormatInvariant(ex.Message)); } }
public async Task GetBlob_DisconnectedDuringGet() { var data = new byte[1024 * 1024]; IRBlobInfo blob = null; using (DataTransferSession dts = new DataTransferSession(_session, null)) { blob = await dts.SendBytesAsync(data, false, null, CancellationToken.None); } using (RBlobStream blobStream = await RBlobStream.OpenAsync(blob, _session)) { Func<Task> f = async () => { using (MemoryStream ms = new MemoryStream()) { await blobStream.CopyToAsync(ms, 1024); } }; await Task.Delay(100); await _session.StopHostAsync(); await f.ShouldThrowAsync<RHostDisconnectedException>(); } }
private async Task ExportToImageAsync(IRSession session, string format, string filePath, int widthInPixels,int heightInPixels, int resolution) { string script = String.Format(@" device_id <- rtvs:::graphics.ide.getactivedeviceid() rtvs:::export_to_image(device_id, rtvs:::graphics.ide.getactiveplotid(device_id), {0}, {1}, {2}, {3}) ", format, widthInPixels, heightInPixels, resolution); var blobid = await session.EvaluateAsync<ulong>(script, REvaluationKind.Normal); using(DataTransferSession dts = new DataTransferSession(session, new FileSystem())) { await dts.FetchFileAsync(new RBlobInfo(blobid), filePath, true, null, CancellationToken.None); } }
public async Task GetBlob_CanceledDuringGet() { var cts = new CancellationTokenSource(); var data = new byte[1024 * 1024]; IRBlobInfo blob = null; using (DataTransferSession dts = new DataTransferSession(_session, null)) { blob = await dts.SendBytesAsync(data, false, null, CancellationToken.None); } Func<Task> f = async () => { while (true) { await _session.BlobReadAllAsync(blob.Id, ct: cts.Token); } }; var assertion = f.ShouldThrowAsync<OperationCanceledException>(); cts.CancelAfter(1); await assertion; }
private async Task<IEnumerable<string>> ExportToPdfAsync(string[] inputs, string filePath, int width, int height) { var app = new RHostClientTestApp { PlotHandler = OnPlot, PlotDeviceCreateHandler = OnDeviceCreate, PlotDeviceDestroyHandler = OnDeviceDestroy }; using (var sessionProvider = new RSessionProvider(TestCoreServices.CreateReal())) { await sessionProvider.TrySwitchBrokerAsync(nameof(IdeGraphicsDeviceTest)); var session = sessionProvider.GetOrCreate(Guid.NewGuid()); await session.StartHostAsync(new RHostStartupInfo { Name = _testMethod.Name }, app, 50000); foreach (var input in inputs) { using (var interaction = await session.BeginInteractionAsync()) { await interaction.RespondAsync(input.EnsureLineBreak()); } } string script = String.Format(@" device_id <- rtvs:::graphics.ide.getactivedeviceid() rtvs:::export_to_pdf(device_id, rtvs:::graphics.ide.getactiveplotid(device_id), {0}, {1}) ", width, height); var blobid = await session.EvaluateAsync<ulong>(script, REvaluationKind.Normal); using (DataTransferSession dts = new DataTransferSession(session, new FileSystem())) { await dts.FetchFileAsync(new RBlobInfo(blobid), filePath, true, null, CancellationToken.None); } await session.StopHostAsync(); } // Ensure that all plot files created by the graphics device have been deleted foreach (var plot in OriginalPlotMessages) { File.Exists(plot.FilePath).Should().BeFalse(); } return PlotFilePaths.AsReadOnly(); }
private async Task <bool> SendToRemoteWorkerAsync(IEnumerable <string> files, string projectDir, string projectName, string remotePath, IVsStatusbar statusBar) { 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); })); statusBar.SetText(Resources.Info_ExtractingFilesInRHost); await session.EvaluateAsync <string>($"rtvs:::save_to_project_folder({remoteFile.Id}, {projectName.ToRStringLiteral()}, '{remotePath.ToRPath()}')", REvaluationKind.Normal); _appShell.DispatchOnUIThread(() => { outputWindow.WriteLine(Resources.Info_TransferringFilesDone); }); } } catch (UnauthorizedAccessException uaex) { _appShell.ShowErrorMessage(string.Format(CultureInfo.InvariantCulture, Resources.Error_CannotTransferFile, uaex.Message)); } catch (IOException ioex) { _appShell.ShowErrorMessage(string.Format(CultureInfo.InvariantCulture, Resources.Error_CannotTransferFile, ioex.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); }