[Fact] // Bizarre behavior when using the built-in Pipe class: https://github.com/dotnet/corefx/issues/31696 public async Task CancelPendingRead() { var stream = new SimplexStream(); var reader = this.CreatePipeReader(stream, sizeHint: 50); ValueTask<ReadResult> readTask = reader.ReadAsync(this.TimeoutToken); reader.CancelPendingRead(); var readResult = await readTask.AsTask().WithCancellation(this.TimeoutToken); Assert.True(readResult.IsCanceled); ////reader.AdvanceTo(readResult.Buffer.End); // Verify we can read after that without cancellation. readTask = reader.ReadAsync(this.TimeoutToken); stream.Write(new byte[] { 1, 2, 3 }, 0, 3); await stream.FlushAsync(this.TimeoutToken); readResult = await readTask; Assert.False(readResult.IsCanceled); Assert.Equal(3, readResult.Buffer.Length); reader.AdvanceTo(readResult.Buffer.End); // Now cancel again readTask = reader.ReadAsync(this.TimeoutToken); reader.CancelPendingRead(); readResult = await readTask; Assert.True(readResult.IsCanceled); }
public async Task UsePipe_Stream_Disposal() { var ms = new SimplexStream(); IDuplexPipe pipe = ms.UsePipe(cancellationToken: this.TimeoutToken); pipe.Output.Complete(); pipe.Input.Complete(); await this.AssertStreamClosesAsync(ms); }
private Task CopyTo(SimplexStream stream) { var task = Task.Run(async delegate { Console.WriteLine("Starting Write!"); var destination = new FileStream("D:\\temp\\target.msi", FileMode.Create, FileAccess.Write); await stream.CopyToAsync(destination); }); return(task); }
public async Task Complete_CausesWriterCompletion() { var stream = new SimplexStream(); var reader = this.CreatePipeReader(stream); #pragma warning disable CS0618 // Type or member is obsolete Task writerCompletion = reader.WaitForWriterCompletionAsync(); #pragma warning restore CS0618 // Type or member is obsolete reader.Complete(); await writerCompletion.WithCancellation(this.TimeoutToken); }
private Task CopyFrom(SimplexStream stream) { var task = Task.Run(async delegate { Console.WriteLine("Starting Read!"); var source = new FileStream("C:\\temp\\LibreOffice_4.2.0_Win_x86.msi", FileMode.Open); await source.CopyToAsync(stream); stream.CompleteWriting(); }); return(task); }
public async Task UsePipe_Stream() { var ms = new SimplexStream(); IDuplexPipe pipe = ms.UsePipe(cancellationToken: this.TimeoutToken); await pipe.Output.WriteAsync(new byte[] { 1, 2, 3 }, this.TimeoutToken); var readResult = await pipe.Input.ReadAsync(this.TimeoutToken); Assert.Equal(3, readResult.Buffer.Length); pipe.Input.AdvanceTo(readResult.Buffer.End); }
public async Task Read_Cancelled_ReturnsNull_Async() { var stream = new SimplexStream(); using (var streamReader = new StreamReader(stream)) { var cts = new CancellationTokenSource(); var task = streamReader.ReadLineAsync(cts.Token); cts.Cancel(); Assert.Null(await task.ConfigureAwait(false)); } }
public async Task Copy() { var sourceStream = new SimplexStream(); var tc = CopyFrom(sourceStream); var targetStream = new SimplexStream(); var td = CopyTo(targetStream); Console.WriteLine("Copy in between"); await sourceStream.CopyToAsync(targetStream); targetStream.CompleteWriting(); await Task.WhenAll(tc, td); }
private static async IAsyncEnumerable <NotebookParserServerResponse> GetResponseObjectsEnumerable(string inputText) { using var input = new StringReader(inputText); var stream = new SimplexStream(); var output = new StreamWriter(stream); var server = new NotebookParserServer(input, output); var _ = Task.Run(() => server.RunAsync()); // start server listener in the background var outputReader = new StreamReader(stream); while (true) { var responseText = await outputReader.ReadLineAsync(); var responseObject = NotebookParserServerResponse.FromJson(responseText); yield return(responseObject); } }
public async Task ReadLine_HasData_ReturnsValue_Async() { var stream = new SimplexStream(); using (var streamReader = new StreamReader(stream)) using (var streamWriter = new StreamWriter(stream)) { var cts = new CancellationTokenSource(); var task = streamReader.ReadLineAsync(cts.Token); await streamWriter.WriteLineAsync("Hello, World!".ToCharArray(), default).ConfigureAwait(false); await streamWriter.FlushAsync().ConfigureAwait(false); Assert.Equal("Hello, World!", await task.ConfigureAwait(false)); } }
public async Task ReadAsyncAfterExamining() { byte[] expectedBuffer = this.GetRandomBuffer(2048); var stream = new SimplexStream(); stream.Write(expectedBuffer, 0, 50); await stream.FlushAsync(this.TimeoutToken); var reader = this.CreatePipeReader(stream, sizeHint: 50); byte[] actualBuffer = new byte[expectedBuffer.Length]; ReadResult result = await reader.ReadAsync(this.TimeoutToken); reader.AdvanceTo(result.Buffer.Start, result.Buffer.GetPosition(1)); // Since we didn't examine all the bytes already in the buffer, the next read should be synchronous, // and shouldn't give us any more buffer. ValueTask <ReadResult> resultTask = reader.ReadAsync(this.TimeoutToken); Assert.True(resultTask.IsCompleted); Assert.Equal(result.Buffer.Length, resultTask.Result.Buffer.Length); // Now examine everything, but don't consume it. We should get more. reader.AdvanceTo(resultTask.Result.Buffer.Start, resultTask.Result.Buffer.End); ValueTask <ReadResult> resultTask2 = reader.ReadAsync(this.TimeoutToken); Assert.False(resultTask2.IsCompleted); stream.Write(expectedBuffer, 50, 50); await stream.FlushAsync(this.TimeoutToken); var result2 = await resultTask2; Assert.True(result2.Buffer.Length > result.Buffer.Length); // Now consume everything and get even more. reader.AdvanceTo(result2.Buffer.End); stream.Write(expectedBuffer, 100, expectedBuffer.Length - 100); await stream.FlushAsync(this.TimeoutToken); ReadResult result3 = await reader.ReadAsync(this.TimeoutToken); Assert.True(result3.Buffer.Length > 0); }
public async Task WatchNamespacedObjectAsync_ClientCanStopLoop_Async() { using (var stream = new SimplexStream()) using (var writer = new StreamWriter(stream)) { var handler = new DummyHandler(); handler.Responses.Enqueue( new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = new WatchHttpContent( new StreamContent(stream)), }); Collection <(WatchEventType, V1Pod)> events = new Collection <(WatchEventType, V1Pod)>(); var protocol = new KubernetesProtocol(handler, this.loggerFactory.CreateLogger <KubernetesProtocol>(), this.loggerFactory); var cts = new CancellationTokenSource(); var watchTask = protocol.WatchNamespacedObjectAsync( new V1Pod() { Metadata = new V1ObjectMeta(name: "pod", namespaceProperty: "default", resourceVersion: "1"), }, protocol.ListNamespacedPodWithHttpMessagesAsync, (eventType, result) => { events.Add((eventType, result)); return(Task.FromResult(events.Count == 1 ? WatchResult.Continue : WatchResult.Stop)); }, cts.Token); Assert.True(!watchTask.IsCompleted); await writer.WriteAsync( JsonConvert.SerializeObject( new V1WatchEvent() { Type = nameof(WatchEventType.Deleted), ObjectProperty = new V1Pod() { Metadata = new V1ObjectMeta() { NamespaceProperty = "some-namespace", Name = "some-name", }, }, })); await writer.WriteAsync('\n').ConfigureAwait(false); await writer.FlushAsync().ConfigureAwait(false); Assert.True(!watchTask.IsCompleted); await writer.WriteAsync( JsonConvert.SerializeObject( new V1WatchEvent() { Type = nameof(WatchEventType.Deleted), ObjectProperty = new V1Pod() { Metadata = new V1ObjectMeta() { NamespaceProperty = "some-namespace2", Name = "some-name2", }, }, })); await writer.WriteAsync('\n').ConfigureAwait(false); await writer.FlushAsync().ConfigureAwait(false); var result = await watchTask; Assert.Equal(WatchExitReason.ClientDisconnected, result); Assert.Collection( events, e => { Assert.Equal(WatchEventType.Deleted, e.Item1); Assert.Equal("some-namespace", e.Item2.Metadata.NamespaceProperty); Assert.Equal("some-name", e.Item2.Metadata.Name); }, e => { Assert.Equal(WatchEventType.Deleted, e.Item1); Assert.Equal("some-namespace2", e.Item2.Metadata.NamespaceProperty); Assert.Equal("some-name2", e.Item2.Metadata.Name); }); } }
static void Main(string[] args) { FileDialogs.Init(); var serverStream = new SimplexStream(); var clientStream = new SimplexStream(); var encoding = new UTF8Encoding(false); var writer = new StreamWriter(serverStream, encoding); var formatter = new JsonMessageFormatter(encoding); Serializer.PrepareSerializer(formatter.JsonSerializer); var messageHandler = new NewLineDelimitedMessageHandler(clientStream, serverStream, formatter); var server = new FullServer(messageHandler); server.Workspace.SettingsService.RegisterSetting(DisplaySettingsNames.Theme, typeof(string), "xp/98.css"); server.Agent.IsReady += (o, e) => { if (args.Length == 1) { var _ = server.Workspace.ExecuteCommand("File.Open", args[0]); } }; // try to load settings string[] settingsLines = Array.Empty <string>(); var settingsFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".bcadconfig"); try { settingsLines = File.ReadAllLines(settingsFilePath); server.Workspace.SettingsService.LoadFromLines(settingsLines); server.Workspace.Update(isDirty: false); } catch { // don't really care if it failed } #if DEBUG var allowDebugging = true; var logVerbosity = 1; var clientArguments = new[] { "--", "debug" }; #else var allowDebugging = false; var logVerbosity = 0; var clientArguments = new[] { "--" }; #endif var window = new PhotinoWindow() .SetUseOsDefaultSize(true) .SetContextMenuEnabled(false) .Center() .SetDevToolsEnabled(allowDebugging) .SetResizable(true) .SetLogVerbosity(logVerbosity) .RegisterWebMessageReceivedHandler((object sender, string message) => { try { // forward JSON from client to server writer.WriteLine(message); writer.Flush(); } catch { // don't let this die } }); SetTitle(window, server.Workspace); window.RegisterCustomSchemeHandler("app", (object sender, string scheme, string url, out string contentType) => { contentType = "text/javascript"; var script = $"var clientArguments = [{string.Join(", ", clientArguments.Select(arg => $"\"{arg}\""))}];"; return(new MemoryStream(Encoding.UTF8.GetBytes(script))); }); var fileSystemService = new FileSystemService(action => { window.Invoke(action); }); server.Workspace.RegisterService(fileSystemService); server.Workspace.WorkspaceChanged += (sender, args) => SetTitle(window, server.Workspace); var doHardClose = false; window.WindowClosing += (sender, args) => { if (doHardClose) { // close immediately return(false); } if (server.Workspace.IsDirty) { var _ = Task.Run(async() => { var result = await server.Workspace.PromptForUnsavedChanges(); if (result != UnsavedChangesResult.Cancel) { doHardClose = true; window.Close(); } }); // don't close yet return(true); } return(false); }; var _ = Task.Run(async() => { var reader = new StreamReader(clientStream, encoding); while (true) { try { var line = await reader.ReadLineAsync(); window.SendWebMessage(line); } catch { // don't let this die } } }); server.Start(); var indexPath = Path.Combine(AppContext.BaseDirectory, "wwwroot", "index.html"); window.Load(indexPath); window.WaitForClose(); // try to save settings try { var newSettingsContents = server.Workspace.SettingsService.WriteWithLines(settingsLines); File.WriteAllText(settingsFilePath, newSettingsContents); } catch { // don't really care if it failed } }
public void DefaultCtor() { var stream = new SimplexStream(); stream.Dispose(); }