feat: Implement --stayopen, fix up argument names, fire Disconnected pb msg

- Implement --stayopen, allowing servers to be reused
- Change CLI arguments for websocket and frontend pipe
- Add Ctrl-C exiting for --stayopen and regular CLI runs
- Fire ClientDisconnected pb msg on client disconnect or shutdown

Fixes #2
Fixes #3
Fixes #5
Fixes #6

Author: qdot

IntifaceCLI/Options.cs

@@ -20,22 +20,19 @@ class Options
         [Option("userdeviceconfig", HelpText = "User Device Configuration file")]
         public string UserDeviceConfigFile { get; set; }
 
-        [Option("websocketserver", HelpText = "Run websocket server")]
-        public bool UseWebsocketServer { get; set; }
-
-        [Option("websocketserverallinterfaces", Default = false, HelpText = "If passed, listen on all interfaces. Otherwise, only listen on 127.0.0.1.")]
+        [Option("wsallinterfaces", Default = false, HelpText = "If passed, websocket server listens on all interfaces. Otherwise, only listen on 127.0.0.1.")]
         public bool WebsocketServerAllInterfaces { get; set; }
 
-        [Option("insecureport", Default = 0, HelpText = "Insecure port for websocket servers.")]
+        [Option("wsinsecureport", Default = 0, HelpText = "Insecure port for websocket servers.")]
         public int WebsocketServerInsecurePort { get; set; }
 
-        [Option("secureport", Default = 0, HelpText = "Secure port for websocket servers. Requires certificate files also be passed.")]
+        [Option("wssecureport", Default = 0, HelpText = "Secure port for websocket servers. Requires certificate files also be passed.")]
         public int WebsocketServerSecurePort { get; set; }
 
-        [Option("certfile", HelpText = "Certificate file (in PEM format) for secure Websocket Server")]
+        [Option("wscertfile", HelpText = "Certificate file (in PEM format) for secure Websocket Server")]
         public string CertFile { get; set; }
 
-        [Option("privfile", HelpText = "Private Key file (in PEM format) for secure Websocket Server")]
+        [Option("wsprivfile", HelpText = "Private Key file (in PEM format) for secure Websocket Server")]
         public string PrivFile { get; set; }
 
         [Option("ipcserver", HelpText = "Run ipc server")]
@@ -44,8 +41,8 @@ class Options
         [Option("ipcpipe", Default = "ButtplugPipe", HelpText = "Pipe name for IPC Server")]
         public string IpcPipe { get; set; }
 
-        [Option("guipipe", Default = false, HelpText = "If passed, output protobufs for parent process, instead of strings.")]
-        public bool GuiPipe { get; set; }
+        [Option("frontendpipe", Default = false, HelpText = "If passed, output protobufs for parent process, instead of strings.")]
+        public bool FrontendPipe { get; set; }
 
         [Option("pingtime", Default = 0, HelpText = "Ping timeout maximum for server (in milliseconds")]
         public int PingTime { get; set; }

IntifaceCLI/ServerCLI.cs

@@ -1,31 +1,30 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using Buttplug.Core.Logging;
+using Buttplug.Core.Logging;
 using Buttplug.Devices.Configuration;
 using Buttplug.Server;
-using Buttplug.Server.Connectors.WebsocketServer;
 using Buttplug.Server.Connectors;
+using Buttplug.Server.Connectors.WebsocketServer;
 using Google.Protobuf;
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace IntifaceCLI
 {
-    class ServerCLI
+    internal class ServerCLI
     {
         private bool _useProtobufOutput;
-        public bool ServerReady { get; }
         private DeviceManager _deviceManager;
         private readonly Stream _stdout = Console.OpenStandardOutput();
-        private TaskCompletionSource<bool> _exitWait = new TaskCompletionSource<bool>();
-        private CancellationTokenSource _stdinTokenSource = new CancellationTokenSource();
+        private TaskCompletionSource<bool> _disconnectWait = new TaskCompletionSource<bool>();
+        private readonly CancellationTokenSource _stdinTokenSource = new CancellationTokenSource();
         private Task _stdioTask;
-
+        private bool _shouldExit;
 
         // Simple server that exposes device manager, since we'll need to chain device managers
         // through it for this. This is required because Windows 10 has problems disconnecting from
         // BLE devices without completely stopping and restarting processes. :(
-        class CLIServer : ButtplugServer
+        private class CLIServer : ButtplugServer
         {
             public DeviceManager DeviceManager => _deviceManager;
             public IButtplugLogManager LogManager => BpLogManager;
@@ -36,32 +35,37 @@ public CLIServer(string aServerName, uint aMaxPingTime, DeviceManager aDevMgr)
             }
         }
 
-
         public ServerCLI()
         {
-
+            Console.CancelKeyPress += (aObj, aEvent) =>
+            {
+                PrintProcessLog("Console exit called.");
+                _shouldExit = true;
+                _disconnectWait.SetResult(true);
+            };
         }
 
         private void ReadStdio()
         {
-            using (Stream stdin = Console.OpenStandardInput())
+            using (var stdin = Console.OpenStandardInput())
             {
                 // Largest message we can receive is 1mb, so just allocate that now.
                 var buf = new byte[1024768];
 
-                while (!_exitWait.Task.IsCompleted)
+                while (!_disconnectWait.Task.IsCompleted && !_shouldExit)
                 {
                     try
                     {
                         var msg = ServerControlMessage.Parser.ParseDelimitedFrom(stdin);
 
-                        if (msg == null || msg.Stop == null)
+                        if (msg?.Stop == null && !_shouldExit)
                         {
                             continue;
                         }
 
                         _stdinTokenSource.Cancel();
-                        _exitWait?.SetResult(true);
+                        _disconnectWait?.SetResult(true);
+                        _shouldExit = true;
                         break;
                     }
                     catch (InvalidProtocolBufferException)
@@ -97,15 +101,13 @@ private void PrintProcessLog(string aLogMsg)
 
         public void RunServer(Options aOptions)
         {
-            Console.CancelKeyPress += (obj, ev) => { _exitWait.SetResult(true); };
-
             if (aOptions.Version)
             {
                 Console.WriteLine("1");
                 return;
             }
 
-            _useProtobufOutput = aOptions.GuiPipe;
+            _useProtobufOutput = aOptions.FrontendPipe;
             if (_useProtobufOutput)
             {
                 _stdioTask = new Task(ReadStdio);
@@ -133,13 +135,7 @@ public void RunServer(Options aOptions)
                 DeviceConfigurationManager.Manager.LoadUserConfigurationFile(aOptions.UserDeviceConfigFile);
             }
 
-            if (aOptions.UseWebsocketServer && aOptions.UseIpcServer)
-            {
-                PrintProcessLog("ERROR: Can't run websocket server and IPC server at the same time!");
-                return;
-            }
-
-            if (!aOptions.UseWebsocketServer && !aOptions.UseIpcServer)
+            if (aOptions.WebsocketServerInsecurePort == 0 && aOptions.WebsocketServerSecurePort == 0 && !aOptions.UseIpcServer)
             {
                 PrintProcessLog("ERROR: Must specify either IPC server or Websocket server!");
                 return;
@@ -158,6 +154,8 @@ public void RunServer(Options aOptions)
             ButtplugServer ServerFactory()
             {
                 var server = new CLIServer(aOptions.ServerName, (uint)aOptions.PingTime, _deviceManager);
+
+                // Pull out the device manager for reuse later.
                 if (_deviceManager == null)
                 {
                     _deviceManager = server.DeviceManager;
@@ -171,44 +169,103 @@ ButtplugServer ServerFactory()
                     });
                 }
 
+                server.ClientConnected += (aObj, aEvent) =>
+                {
+                    if (_useProtobufOutput)
+                    {
+                        SendProcessMessage(new ServerProcessMessage
+                        {
+                            ClientConnected = new ServerProcessMessage.Types.ClientConnected
+                            {
+                                ClientName = server.ClientName
+                            }
+                        });
+                    }
+                    else
+                    {
+                        Console.WriteLine($"Client connected: {server.ClientName}");
+                    }
+                };
+
                 return server;
             }
 
-            var ipcServer = new ButtplugIPCServer();
-            var insecureWebsocketServer = new ButtplugWebsocketServer();
-            var secureWebsocketServer = new ButtplugWebsocketServer();
+            ButtplugIPCServer ipcServer = null;
+            ButtplugWebsocketServer insecureWebsocketServer = null;
+            ButtplugWebsocketServer secureWebsocketServer = null;
 
-            if (aOptions.UseWebsocketServer)
+            if (aOptions.WebsocketServerInsecurePort != 0)
             {
-                if (aOptions.WebsocketServerInsecurePort != 0)
-                {
-                    insecureWebsocketServer.StartServerAsync(ServerFactory, 1, aOptions.WebsocketServerInsecurePort, !aOptions.WebsocketServerAllInterfaces).Wait();
-                    insecureWebsocketServer.ConnectionClosed += (aSender, aArgs) => { _exitWait.SetResult(true); };
-                    PrintProcessLog("Insecure websocket Server now running...");
-                }
-                if (aOptions.WebsocketServerSecurePort != 0 && aOptions.CertFile != null && aOptions.PrivFile != null)
-                {
-                    secureWebsocketServer.StartServerAsync(ServerFactory, 1, aOptions.WebsocketServerSecurePort, !aOptions.WebsocketServerAllInterfaces, aOptions.CertFile, aOptions.PrivFile).Wait();
-                    secureWebsocketServer.ConnectionClosed += (aSender, aArgs) => { _exitWait.SetResult(true); };
-                    PrintProcessLog("Secure websocket Server now running...");
-                }
+                insecureWebsocketServer = new ButtplugWebsocketServer();
+                insecureWebsocketServer.StartServerAsync(ServerFactory, 1, aOptions.WebsocketServerInsecurePort,
+                    !aOptions.WebsocketServerAllInterfaces).Wait();
+                insecureWebsocketServer.ConnectionClosed += (aSender, aArgs) => { _disconnectWait.SetResult(true); };
+                PrintProcessLog("Insecure websocket Server now running...");
             }
-            else if (aOptions.UseIpcServer)
+
+            if (aOptions.WebsocketServerSecurePort != 0 && aOptions.CertFile != null &&
+                aOptions.PrivFile != null)
             {
+                secureWebsocketServer = new ButtplugWebsocketServer();
+                secureWebsocketServer.StartServerAsync(ServerFactory, 1, aOptions.WebsocketServerSecurePort,
+                    !aOptions.WebsocketServerAllInterfaces, aOptions.CertFile, aOptions.PrivFile).Wait();
+                secureWebsocketServer.ConnectionClosed += (aSender, aArgs) => { _disconnectWait.SetResult(true); };
+                PrintProcessLog("Secure websocket Server now running...");
+            }
+
+            if (aOptions.UseIpcServer)
+            {
+                ipcServer = new ButtplugIPCServer();
                 ipcServer.StartServer(ServerFactory, aOptions.IpcPipe);
-                ipcServer.ConnectionClosed += (aSender, aArgs) => { _exitWait.SetResult(true); };
+                ipcServer.ConnectionClosed += (aSender, aArgs) => { _disconnectWait.SetResult(true); };
                 PrintProcessLog("IPC Server now running...");
             }
 
-            // Now that all server possibilities are up and running, if we have
-            // a pipe, let the parent program know we've started.
+            // Now that all server possibilities are up and running, if we have a pipe, let the
+            // parent program know we've started.
             if (_useProtobufOutput)
             {
-                var msg = new ServerProcessMessage { ProcessStarted = new ServerProcessMessage.Types.ProcessStarted() };
+                var msg = new ServerProcessMessage
+                { ProcessStarted = new ServerProcessMessage.Types.ProcessStarted() };
                 SendProcessMessage(msg);
             }
+            else
+            {
+                Console.WriteLine("Server started, waiting for client connection.");
+            }
+
+            do
+            {
+                _disconnectWait.Task.Wait();
+
+                if (ipcServer != null && ipcServer.Connected)
+                {
+                    ipcServer?.Disconnect();
+                }
+
+                if (insecureWebsocketServer != null && insecureWebsocketServer.Connected)
+                {
+                    insecureWebsocketServer?.DisconnectAsync().Wait();
+                }
+
+                if (secureWebsocketServer != null && secureWebsocketServer.Connected)
+                {
+                    secureWebsocketServer?.DisconnectAsync().Wait();
+                }
+
+                if (_useProtobufOutput)
+                {
+                    var msg = new ServerProcessMessage
+                    { ClientDisconnected = new ServerProcessMessage.Types.ClientDisconnected() };
+                    SendProcessMessage(msg);
+                }
+                else
+                {
+                    Console.WriteLine("Client disconnected.");
+                }
+                _disconnectWait = new TaskCompletionSource<bool>();
+            } while (aOptions.StayOpen && !_shouldExit);
 
-            _exitWait.Task.Wait();
             if (!_useProtobufOutput)
             {
                 return;
@@ -218,10 +275,13 @@ ButtplugServer ServerFactory()
 
             if (_useProtobufOutput)
             {
-                var exitMsg = new ServerProcessMessage();
-                exitMsg.ProcessEnded = new ServerProcessMessage.Types.ProcessEnded();
+                var exitMsg = new ServerProcessMessage
+                {
+                    ProcessEnded = new ServerProcessMessage.Types.ProcessEnded()
+                };
                 SendProcessMessage(exitMsg);
             }
+
             _stdinTokenSource.Cancel();
         }
     }