More cleanups of the managed side of terminal drivers.

Author: alexrp

src/core/Terminal.cs

@@ -1,5 +1,4 @@
-using Vezel.Cathode.Terminals.Unix;
-using Vezel.Cathode.Terminals.Windows;
+using Vezel.Cathode.Terminals;
 
 namespace Vezel.Cathode;
 

src/core/Terminals/NativeTerminalReader.cs

@@ -2,7 +2,7 @@
 
 namespace Vezel.Cathode.Terminals;
 
-internal abstract class NativeTerminalReader : TerminalReader
+internal sealed class NativeTerminalReader : TerminalReader
 {
     // Note that the buffer size used affects how many characters the Windows console host will allow the user to type
     // in a single line (in cooked mode).
@@ -20,10 +20,20 @@ internal abstract class NativeTerminalReader : TerminalReader
 
     public override sealed bool IsInteractive { get; }
 
-    protected NativeTerminalReader(NativeVirtualTerminal terminal, nuint handle)
+    private readonly SemaphoreSlim _semaphore;
+
+    private readonly Action<nuint, CancellationToken>? _cancellationHook;
+
+    public NativeTerminalReader(
+        NativeVirtualTerminal terminal,
+        nuint handle,
+        SemaphoreSlim semaphore,
+        Action<nuint, CancellationToken>? cancellationHook)
     {
         Terminal = terminal;
         Handle = handle;
+        _semaphore = semaphore;
+        _cancellationHook = cancellationHook;
         Stream = new SynchronizedStream(new TerminalInputStream(this));
         TextReader =
             new SynchronizedTextReader(
@@ -32,15 +42,34 @@ protected NativeTerminalReader(NativeVirtualTerminal terminal, nuint handle)
         IsInteractive = TerminalInterop.IsInteractive(handle);
     }
 
-    protected abstract int ReadPartialNative(scoped Span<byte> buffer, CancellationToken cancellationToken);
+    private unsafe int ReadPartialNative(scoped Span<byte> buffer, CancellationToken cancellationToken)
+    {
+        using var guard = Terminal.Control.Guard();
+
+        // If the descriptor is invalid, just present the illusion to the user that it has been redirected to /dev/null
+        // or something along those lines, i.e. return EOF.
+        if (buffer is [] || !IsValid)
+            return 0;
+
+        using (_semaphore.Enter(cancellationToken))
+        {
+            _cancellationHook?.Invoke(Handle, cancellationToken);
+
+            int progress;
+
+            fixed (byte* p = buffer)
+                TerminalInterop.Read(Handle, p, buffer.Length, &progress).ThrowIfError();
+
+            return progress;
+        }
+    }
 
-    protected override sealed int ReadPartialCore(scoped Span<byte> buffer)
+    protected override int ReadPartialCore(scoped Span<byte> buffer)
     {
         return ReadPartialNative(buffer, default);
     }
 
-    protected override sealed ValueTask<int> ReadPartialCoreAsync(
-        Memory<byte> buffer, CancellationToken cancellationToken)
+    protected override ValueTask<int> ReadPartialCoreAsync(Memory<byte> buffer, CancellationToken cancellationToken)
     {
         // We currently have no native async support.
         return cancellationToken.IsCancellationRequested

src/core/Terminals/NativeTerminalWriter.cs

@@ -2,7 +2,7 @@
 
 namespace Vezel.Cathode.Terminals;
 
-internal abstract class NativeTerminalWriter : TerminalWriter
+internal sealed class NativeTerminalWriter : TerminalWriter
 {
     // Unlike NativeTerminalReader, the buffer size here is arbitrary and only has performance implications.
     private const int WriteBufferSize = 256;
@@ -19,10 +19,20 @@ internal abstract class NativeTerminalWriter : TerminalWriter
 
     public override sealed bool IsInteractive { get; }
 
-    protected NativeTerminalWriter(NativeVirtualTerminal terminal, nuint handle)
+    private readonly SemaphoreSlim _semaphore;
+
+    private readonly Action<nuint, CancellationToken>? _cancellationHook;
+
+    public NativeTerminalWriter(
+        NativeVirtualTerminal terminal,
+        nuint handle,
+        SemaphoreSlim semaphore,
+        Action<nuint, CancellationToken>? cancellationHook)
     {
         Terminal = terminal;
         Handle = handle;
+        _semaphore = semaphore;
+        _cancellationHook = cancellationHook;
         Stream = new SynchronizedStream(new TerminalOutputStream(this));
         TextWriter =
             new SynchronizedTextWriter(new StreamWriter(Stream, Cathode.Terminal.Encoding, WriteBufferSize, true)
@@ -33,14 +43,34 @@ protected NativeTerminalWriter(NativeVirtualTerminal terminal, nuint handle)
         IsInteractive = TerminalInterop.IsInteractive(handle);
     }
 
-    protected abstract int WritePartialNative(scoped ReadOnlySpan<byte> buffer, CancellationToken cancellationToken);
+    private unsafe int WritePartialNative(scoped ReadOnlySpan<byte> buffer, CancellationToken cancellationToken)
+    {
+        using var guard = Terminal.Control.Guard();
+
+        // If the descriptor is invalid, just present the illusion to the user that it has been redirected to /dev/null
+        // or something along those lines, i.e. pretend we wrote everything.
+        if (buffer is [] || !IsValid)
+            return buffer.Length;
+
+        using (_semaphore.Enter(cancellationToken))
+        {
+            _cancellationHook?.Invoke(Handle, cancellationToken);
+
+            int progress;
+
+            fixed (byte* p = buffer)
+                TerminalInterop.Write(Handle, p, buffer.Length, &progress).ThrowIfError();
+
+            return progress;
+        }
+    }
 
-    protected override sealed int WritePartialCore(scoped ReadOnlySpan<byte> buffer)
+    protected override int WritePartialCore(scoped ReadOnlySpan<byte> buffer)
     {
         return WritePartialNative(buffer, default);
     }
 
-    protected override sealed ValueTask<int> WritePartialCoreAsync(
+    protected override ValueTask<int> WritePartialCoreAsync(
         ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
     {
         // We currently have no native async support.

src/core/Terminals/Unix/UnixTerminalReader.cs

@@ -1,6 +1,6 @@
 using Vezel.Cathode.Native;
 
-namespace Vezel.Cathode.Terminals.Unix;
+namespace Vezel.Cathode.Terminals;
 
 [SuppressMessage("", "CA1001")]
 internal sealed class UnixCancellationPipe

src/core/Terminals/Unix/UnixTerminalWriter.cs

@@ -1,4 +1,4 @@
-namespace Vezel.Cathode.Terminals.Unix;
+namespace Vezel.Cathode.Terminals;
 
 internal sealed class UnixVirtualTerminal : NativeVirtualTerminal
 {
@@ -57,13 +57,17 @@ void HandleSignal(PosixSignalContext context)
         _sigChld = PosixSignalRegistration.Create(PosixSignal.SIGCHLD, HandleSignal);
     }
 
-    protected override UnixTerminalReader CreateReader(nuint handle, SemaphoreSlim semaphore)
+    protected override NativeTerminalReader CreateReader(nuint handle, SemaphoreSlim semaphore)
     {
-        return new(this, handle, semaphore);
+        var pipe = new UnixCancellationPipe(write: false);
+
+        return new(this, handle, semaphore, cancellationHook: pipe.PollWithCancellation);
     }
 
-    protected override UnixTerminalWriter CreateWriter(nuint handle, SemaphoreSlim semaphore)
+    protected override NativeTerminalWriter CreateWriter(nuint handle, SemaphoreSlim semaphore)
     {
-        return new(this, handle, semaphore);
+        var pipe = new UnixCancellationPipe(write: true);
+
+        return new(this, handle, semaphore, cancellationHook: pipe.PollWithCancellation);
     }
 }

…e/Terminals/Unix/UnixCancellationPipe.cs …c/core/Terminals/UnixCancellationPipe.cssrc/core/Terminals/Unix/UnixCancellationPipe.cs renamed to src/core/Terminals/UnixCancellationPipe.cs src/core/Terminals/Unix/UnixCancellationPipe.cs renamed to src/core/Terminals/UnixCancellationPipe.cs

@@ -1,4 +1,4 @@
-namespace Vezel.Cathode.Terminals.Windows;
+namespace Vezel.Cathode.Terminals;
 
 internal sealed class WindowsVirtualTerminal : NativeVirtualTerminal
 {
@@ -20,13 +20,13 @@ private WindowsVirtualTerminal()
     {
     }
 
-    protected override WindowsTerminalReader CreateReader(nuint handle, SemaphoreSlim semaphore)
+    protected override NativeTerminalReader CreateReader(nuint handle, SemaphoreSlim semaphore)
     {
-        return new(this, handle, semaphore);
+        return new(this, handle, semaphore, cancellationHook: null);
     }
 
-    protected override WindowsTerminalWriter CreateWriter(nuint handle, SemaphoreSlim semaphore)
+    protected override NativeTerminalWriter CreateWriter(nuint handle, SemaphoreSlim semaphore)
     {
-        return new(this, handle, semaphore);
+        return new(this, handle, semaphore, cancellationHook: null);
     }
 }