New TCP server architecture & logging infrastructure

Implements modular TCP server base (TcpServerBase) and specialized servers based on it (LogCollectorServer, PortCheckerServer).
Introduces the ILogProcessor interface for flexible log processing and helper classes (ActionLogProcessor, SimpleLogServer) for easy use.
Converted existing Listener.cs to trace logging and modern resource management.

Author: LoneWandererProductions

Communication/ActionLogProcessor.cs

@@ -0,0 +1,50 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Communication
+ * FILE:        ActionLogProcessor.cs
+ * PURPOSE:     Sample implementation of ILogProcessor that simply wraps an Action<string> delegate, 
+ *              allowing users to easily provide a lambda or method group for log processing without needing to create a full class that implements ILogProcessor.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+using System;
+using System.Threading.Tasks;
+using Communication.Interfaces;
+
+namespace Communication
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// Internal Helper Class to adapt the Action to the Interface
+    /// </summary>
+    /// <seealso cref="Interfaces.ILogProcessor" />
+    internal class ActionLogProcessor : ILogProcessor
+    {
+        /// <summary>
+        /// The action
+        /// </summary>
+        private readonly Action<string> _action;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ActionLogProcessor"/> class.
+        /// </summary>
+        /// <param name="action">The action.</param>
+        public ActionLogProcessor(Action<string> action)
+        {
+            _action = action;
+        }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Processes the received message (e.g., save to DB, log to file).
+        /// </summary>
+        /// <param name="message">The message received from the client.</param>
+        /// <returns>Message task.</returns>
+        public Task ProcessMessageAsync(string message)
+        {
+            // Run the user's lambda
+            _action(message);
+            return Task.CompletedTask;
+        }
+    }
+}

Communication/Interfaces/ILogProcessor.cs

@@ -0,0 +1,25 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Communication.Interfaces
+ * FILE:        ILogProcessor.cs
+ * PURPOSE:     Interface for processing incoming log messages.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+
+using System.Threading.Tasks;
+
+namespace Communication.Interfaces
+{
+    /// <summary>
+    ///     Interface for processing incoming log messages.
+    /// </summary>
+    public interface ILogProcessor
+    {
+        /// <summary>
+        ///     Processes the received message (e.g., save to DB, log to file).
+        /// </summary>
+        /// <param name="message">The message received from the client.</param>
+        Task ProcessMessageAsync(string message);
+    }
+}

Communication/Listener.cs

@@ -2,11 +2,12 @@
  * COPYRIGHT:   See COPYING in the top level directory
  * PROJECT:     Communication
  * FILE:        Listener.cs
- * PURPOSE:     Simple port checker.
+ * PURPOSE:     Simple port checker. Just listens to a port and answers with a fixed message.
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
 using System;
+using System.Diagnostics;
 using System.Net;
 using System.Net.Sockets;
 using System.Text;
@@ -53,7 +54,7 @@ public async Task StartListeningAsync(CancellationToken cancellationToken)
         {
             _isRunning = true;
             _tcpListener.Start();
-            Console.WriteLine(ComResource.MessageListening, _port);
+            Trace.WriteLine(ComResource.MessageListening, _port.ToString());
 
             try
             {
@@ -73,7 +74,7 @@ public async Task StartListeningAsync(CancellationToken cancellationToken)
             }
             catch (Exception ex)
             {
-                Console.WriteLine(ComResource.ErrorAcceptingCommunication, ex.Message);
+                Trace.WriteLine(ComResource.ErrorAcceptingCommunication, ex.Message);
             }
             finally
             {
@@ -88,7 +89,7 @@ public void StopListening()
         {
             _isRunning = false;
             _tcpListener.Stop();
-            Console.WriteLine(ComResource.ServerStatusStop);
+            Trace.WriteLine(ComResource.ServerStatusStop);
         }
 
         /// <summary>
@@ -100,7 +101,7 @@ private static async Task HandleClientAsync(TcpClient client)
             try
             {
                 using (client) // Ensures the client is closed
-                using (var stream = client.GetStream()) // Ensures the stream is closed
+                await using (var stream = client.GetStream()) // Ensures the stream is closed
                 {
                     byte[] buffer = Encoding.ASCII.GetBytes(ComResource.AnswerMessage);
 
@@ -113,7 +114,7 @@ private static async Task HandleClientAsync(TcpClient client)
             }
             catch (Exception ex)
             {
-                Console.WriteLine("Error handling client: " + ex.Message);
+                Trace.WriteLine("Error handling client: " + ex.Message);
             }
         }
     }

Communication/LogCollectorServer.cs

@@ -0,0 +1,62 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Communication
+ * FILE:        LogCollectorServer.cs
+ * PURPOSE:     Central log collector server that listens for incoming log messages and processes them using a provided ILogProcessor implementation.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Communication.Interfaces;
+
+namespace Communication
+{
+    /// <summary>
+    /// Connects and listens for logs continuously.
+    /// Central entry and processing point for logs, which can be extended to save logs to a database, write to files, or perform any other processing as needed.
+    /// </summary>
+    public class LogCollectorServer : TcpServerBase
+    {
+        /// <summary>
+        /// The log processor, which can be implemented to save logs to a database, write to a file, or perform any other processing as needed.
+        /// </summary>
+        private readonly ILogProcessor _processor;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LogCollectorServer"/> class.
+        /// </summary>
+        /// <param name="port">The port.</param>
+        /// <param name="processor">The processor.</param>
+        public LogCollectorServer(int port, ILogProcessor processor) : base(port)
+        {
+            _processor = processor;
+        }
+
+        /// <summary>
+        /// Handles the client asynchronous.
+        /// </summary>
+        /// <param name="client">The client.</param>
+        /// <param name="token">The token.</param>
+        protected override async Task HandleClientAsync(TcpClient client, CancellationToken token)
+        {
+            using (var stream = client.GetStream())
+            using (var reader = new StreamReader(stream, Encoding.UTF8))
+            {
+                string? line;
+                while ((line = await reader.ReadLineAsync()) != null)
+                {
+                    if (token.IsCancellationRequested) break;
+
+                    if (!string.IsNullOrWhiteSpace(line))
+                    {
+                        await _processor.ProcessMessageAsync(line);
+                    }
+                }
+            }
+        }
+    }
+}

Communication/PortCheckerServer.cs

@@ -0,0 +1,45 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Communication
+ * FILE:        PortCheckerServer.cs
+ * PURPOSE:     Connects, sends a message, and disconnects.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+using System.Diagnostics;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Communication
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// Connects, sends a message, and disconnects.
+    /// </summary>
+    public class PortCheckerServer : TcpServerBase
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PortCheckerServer"/> class.
+        /// </summary>
+        /// <param name="port">The port.</param>
+        public PortCheckerServer(int port) : base(port) { }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Handles the client asynchronous.
+        /// </summary>
+        /// <param name="client">The client.</param>
+        /// <param name="token">The token.</param>
+        protected override async Task HandleClientAsync(TcpClient client, CancellationToken token)
+        {
+            using (var stream = client.GetStream())
+            {
+                byte[] buffer = System.Text.Encoding.ASCII.GetBytes(ComResource.AnswerMessage);
+                await stream.WriteAsync(buffer, 0, buffer.Length, token);
+                await stream.FlushAsync(token);
+                Trace.WriteLine("Port check handled.");
+            }
+        }
+    }
+}

Communication/SimpleLogServer.cs

@@ -0,0 +1,95 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Communication
+ * FILE:        SimpleLogServer.cs
+ * PURPOSE:     Facade to simplify usage of LogCollectorServer for users who just want to provide a simple callback for log processing without needing to implement the ILogProcessor interface themselves.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Communication.Interfaces;
+
+namespace Communication
+{
+    /// <summary>
+    /// A "Stupid Simple" wrapper for the LogCollector.
+    /// No DI required. Just new it up and go.
+    /// </summary>
+    public class SimpleLogServer : IDisposable
+    {
+        /// <summary>
+        /// The internal server
+        /// </summary>
+        private readonly LogCollectorServer _internalServer;
+
+        /// <summary>
+        /// The CTS
+        /// </summary>
+        private readonly CancellationTokenSource _cts;
+
+        /// <summary>
+        /// The server task
+        /// </summary>
+        private Task _serverTask;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SimpleLogServer"/> class.
+        /// </summary>
+        /// <param name="port">The port.</param>
+        /// <param name="onLogReceived">The on log received.</param>
+        public SimpleLogServer(int port, Action<string> onLogReceived)
+            : this(port, new ActionLogProcessor(onLogReceived))
+        {
+            // This constructor just wraps the Action into our helper class
+            // and chains to Constructor 2.
+        }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SimpleLogServer"/> class.
+        /// </summary>
+        /// <param name="port">The port.</param>
+        /// <param name="processor">The processor.</param>
+        /// <exception cref="System.ArgumentNullException">processor</exception>
+        public SimpleLogServer(int port, ILogProcessor processor)
+        {
+            if (processor == null) throw new ArgumentNullException(nameof(processor));
+
+            _cts = new CancellationTokenSource();
+            _internalServer = new LogCollectorServer(port, processor);
+        }
+
+        /// <summary>
+        /// Starts this instance.
+        /// </summary>
+        public void Start()
+        {
+            if (_serverTask != null) return; // Already running
+
+            // Run the server in a background task so it doesn't block the main thread
+            _serverTask = Task.Run(() => _internalServer.StartAsync(_cts.Token));
+        }
+
+        /// <summary>
+        /// Stops this instance.
+        /// </summary>
+        public void Stop()
+        {
+            _cts.Cancel();
+            try
+            {
+                _serverTask?.Wait(); // Wait for it to finish cleaning up
+            }
+            catch (AggregateException) { /* Ignore cancellation errors */ }
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Stop();
+            _cts.Dispose();
+        }
+    }
+}