feat(client): Implement RDM messages support in high level client

Author: pacmancoder

dotnet/Devolutions.NowClient.Cli/Program.cs

@@ -51,7 +51,7 @@ static async Task<int> Main(params string[] args)
         {
             repeat = true;
 
-            Console.Write("Operation (msg/run/pwsh/logoff/lock/exit): ");
+            Console.Write("Operation (msg/run/pwsh/logoff/lock/rdm-run/rdm-version/exit): ");
             var operation = Console.ReadLine()?.Trim().ToLowerInvariant() ?? string.Empty;
 
             switch (operation)
@@ -104,6 +104,12 @@ static async Task<int> Main(params string[] args)
                     await client.SessionLock();
                     Console.WriteLine("OK");
                     break;
+                case "rdm-run":
+                    await ExecuteRdmRunCommand(client);
+                    break;
+                case "rdm-version":
+                    await ExecuteRdmVersionCommand(client);
+                    break;
                 case "exit":
                     Console.WriteLine("Exiting...");
                     repeat = false;
@@ -244,4 +250,71 @@ private static async Task ExecutePowerShellCommand(NowClient client, string comm
             throw;
         }
     }
+
+    /// <summary>
+    /// Executes the RDM run command - starts an RDM application.
+    /// </summary>
+    private static async Task ExecuteRdmRunCommand(NowClient client)
+    {
+        try
+        {
+            // Check if RDM is available
+            Console.WriteLine("Checking RDM availability...");
+            var isAvailable = await client.IsRdmAppAvailable();
+            if (!isAvailable)
+            {
+                Console.WriteLine("RDM is not available on this system.");
+                return;
+            }
+
+            // Start RDM application
+            Console.WriteLine("Starting RDM application...");
+            var startParams = new RdmStartParams();
+
+            await client.RdmStart(startParams);
+            Console.WriteLine("RDM application started successfully.");
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error executing RDM run command: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Executes the RDM version command - displays RDM version information.
+    /// </summary>
+    private static async Task ExecuteRdmVersionCommand(NowClient client)
+    {
+        try
+        {
+            // Check if RDM is available
+            var isAvailable = await client.IsRdmAppAvailable();
+            if (!isAvailable)
+            {
+                Console.WriteLine("RDM is not available on this system.");
+                return;
+            }
+
+            Console.WriteLine("RDM is available.");
+
+            // Get and display version information
+            var rdmVersion = await client.GetRdmVersion();
+            if (rdmVersion != null)
+            {
+                Console.WriteLine($"RDM Version: {rdmVersion.Version}");
+                if (!string.IsNullOrEmpty(rdmVersion.Extra))
+                {
+                    Console.WriteLine($"Extra information: {rdmVersion.Extra}");
+                }
+            }
+            else
+            {
+                Console.WriteLine("Could not retrieve RDM version information.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error executing RDM version command: {ex.Message}");
+        }
+    }
 }

dotnet/Devolutions.NowClient/src/NowClient.cs

@@ -2,6 +2,7 @@
 using System.Threading.Channels;
 
 using Devolutions.NowClient.Worker;
+using Devolutions.NowProto;
 using Devolutions.NowProto.Capabilities;
 using Devolutions.NowProto.Messages;
 
@@ -64,7 +65,9 @@ public static async Task<NowClient> Connect(INowTransport transportImpl)
                 }
             });
 
-            return new NowClient(capabilities, workerTask, clientChannel.Writer);
+            var client = new NowClient(capabilities, workerTask, clientChannel.Writer);
+
+            return client;
         }
 
         /// <summary>
@@ -336,6 +339,157 @@ public async Task ForceTermiate()
             await _commandWriter.WriteAsync(new CommandChannelClose());
         }
 
+        // RDM Methods
+
+        /// <summary>
+        /// Sets the callback for RDM application notifications.
+        /// </summary>
+        public async Task SetRdmAppNotifyHandler(RdmAppNotifyHandler? handler)
+        {
+            ThrowIfWorkerTerminated();
+
+            await _commandWriter.WriteAsync(new CommandSetRdmAppNotifyHandler(handler));
+        }
+
+        private bool _rdmCapabilitiesSent = false;
+        private RdmCapabilityInfo? _rdmCapabilities = null;
+
+        /// <summary>
+        /// Performs RDM capabilities exchange with the server.
+        /// This method is automatically called before any RDM app or session operations if not already called.
+        /// </summary>
+        public async Task RdmSync()
+        {
+            ThrowIfWorkerTerminated();
+
+            var clientTimestamp = DateTimeOffset.UtcNow;
+            var message = new NowMsgRdmCapabilities.Builder(
+                (ulong)clientTimestamp.ToUnixTimeSeconds(),
+                ""
+            ).Build();
+
+            var responseHandler = new TaskCompletionSource<NowMsgRdmCapabilities>();
+            var command = new CommandRdmCapabilities(message, responseHandler);
+
+            await _commandWriter.WriteAsync(command);
+
+            var response = await responseHandler.Task.WaitAsync(TimeSpan.FromSeconds(10));
+
+            _rdmCapabilities = new RdmCapabilityInfo
+            {
+                IsAppAvailable = response.IsAppAvailable,
+                RdmVersion = response.RdmVersion,
+                VersionExtra = response.VersionExtra,
+                ServerTimestamp = DateTimeOffset.FromUnixTimeSeconds((long)response.Timestamp),
+            };
+
+            _rdmCapabilitiesSent = true;
+        }
+
+        /// <summary>
+        /// Checks if RDM application is available on the server.
+        /// Automatically performs capabilities exchange if not already done.
+        /// </summary>
+        public async Task<bool> IsRdmAppAvailable()
+        {
+            await EnsureRdmCapabilitiesSent();
+
+            return _rdmCapabilities?.IsAppAvailable ?? false;
+        }
+
+        /// <summary>
+        /// Gets the RDM version information from the server.
+        /// Automatically performs capabilities exchange if not already done.
+        /// </summary>
+        public async Task<RdmVersion?> GetRdmVersion()
+        {
+            await EnsureRdmCapabilitiesSent();
+
+            if (_rdmCapabilities == null || !_rdmCapabilities.IsAppAvailable)
+                return null;
+
+            return new RdmVersion(_rdmCapabilities.RdmVersion,
+                string.IsNullOrEmpty(_rdmCapabilities.VersionExtra) ? null : _rdmCapabilities.VersionExtra);
+        }
+
+        /// <summary>
+        /// Starts the RDM application on the server.
+        /// Automatically performs capabilities exchange if not already done.
+        /// </summary>
+        public async Task RdmStart(RdmStartParams? startParams = null)
+        {
+            ThrowIfWorkerTerminated();
+            await EnsureRdmCapabilitiesSent();
+
+            var parameters = startParams ?? new RdmStartParams();
+            var builder = new NowMsgRdmAppStart.Builder()
+                .Timeout((uint)parameters.Timeout.TotalSeconds);
+
+            if (parameters.LaunchFlags.HasFlag(NowRdmLaunchFlags.JumpMode))
+                builder = builder.WithJumpMode();
+            if (parameters.LaunchFlags.HasFlag(NowRdmLaunchFlags.Maximized))
+                builder = builder.WithMaximized();
+            if (parameters.LaunchFlags.HasFlag(NowRdmLaunchFlags.Fullscreen))
+                builder = builder.WithFullscreen();
+
+            var message = builder.Build();
+            var command = new CommandRdmAppStart(message);
+
+            await _commandWriter.WriteAsync(command);
+        }
+
+        /// <summary>
+        /// Sends an action command to the RDM application.
+        /// Automatically performs capabilities exchange if not already done.
+        /// </summary>
+        public async Task RdmAction(NowRdmAppAction action, string actionData = "")
+        {
+            ThrowIfWorkerTerminated();
+            await EnsureRdmCapabilitiesSent();
+
+            var message = new NowMsgRdmAppAction(action, actionData);
+            var command = new CommandRdmAppAction(message);
+
+            await _commandWriter.WriteAsync(command);
+        }
+
+        /// <summary>
+        /// Starts a new RDM session.
+        /// Automatically performs capabilities exchange if not already done.
+        /// </summary>
+        public async Task<RdmSession> RdmSessionStart(RdmSessionStartParams sessionParams)
+        {
+            ThrowIfWorkerTerminated();
+            await EnsureRdmCapabilitiesSent();
+
+            var message = new NowMsgRdmSessionStart(sessionParams.SessionId, sessionParams.ConnectionId, sessionParams.ConnectionData);
+            var session = new RdmSession(sessionParams.SessionId, _commandWriter, sessionParams.NotifyHandler);
+            var command = new CommandRdmSessionStart(message, session);
+
+            await _commandWriter.WriteAsync(command);
+
+            return session;
+        }
+
+        /// <summary>
+        /// Ensures that RDM capabilities have been exchanged with the server.
+        /// </summary>
+        private async Task EnsureRdmCapabilitiesSent()
+        {
+            if (!_rdmCapabilitiesSent)
+            {
+                // Check if server version supports RDM functionality
+                if (Capabilities.Version < MIN_RDM_ENABLED_VERSION)
+                {
+                    throw new NowClientException(
+                        $"RDM functionality requires NOW-proto server version {MIN_RDM_ENABLED_VERSION.Major}.{MIN_RDM_ENABLED_VERSION.Minor} or higher. " +
+                        $"Current server version is {Capabilities.Version.Major}.{Capabilities.Version.Minor}.");
+                }
+
+                await RdmSync();
+            }
+        }
+
         private static void ThrowCapabilitiesError(string capability)
         {
             throw new NowClientException($"{capability} is not supported by server.");
@@ -351,18 +505,24 @@ private void ThrowIfWorkerTerminated()
 
         private NowClient(
             NowMsgChannelCapset capabilities,
-            Task runnerTask,
+            Task workerTask,
             ChannelWriter<IClientCommand> commandWriter
         )
         {
             this.Capabilities = capabilities;
-            this._runnerTask = runnerTask;
+            this._runnerTask = workerTask;
             this._commandWriter = commandWriter;
         }
 
         private const int TimeoutConnectSeconds = 10;
         private const int IoChannelCapacity = 1024;
 
+        /// <summary>
+        /// Minimum NOW-proto server version required for RDM functionality.
+        /// RDM features were introduced in version 1.3, so servers with version 1.2 and below are not supported.
+        /// </summary>
+        private static readonly NowProtoVersion MIN_RDM_ENABLED_VERSION = new(1, 3);
+
         /// <summary>
         /// Check if the NOW-proto channel has been terminated.
         /// </summary>