EditorServiceHost: allow Tcp/NamedPipe/Stdio listeners (#629)

* EditorServiceHost: allow Tcp/NamedPipe/Stdio listeners

* update ps scripts

* fix script and test errors;

* update startup script: there can be only one service on the stdio
channel

* 1. handle file refresh where range info is absent; 2. listen to the named pipe on start.

* FileChange: Reloaded->IsReload

* Start-EditorServices.ps1: $env:PSMODULEPATH -> $env:PsModulePath

* Update Start-EditorServices.ps1

* update startup script.

* update startup script, fix tests

Author: Yatao Li

module/PowerShellEditorServices/PowerShellEditorServices.psm1

@@ -31,16 +31,21 @@ function Start-EditorServicesHost {
         [string]
         $HostVersion,
 
-        [Parameter(Mandatory=$true)]
-        [ValidateNotNullOrEmpty()]
         [int]
         $LanguageServicePort,
 
-        [Parameter(Mandatory=$true)]
-        [ValidateNotNullOrEmpty()]
         [int]
         $DebugServicePort,
 
+        [switch]
+        $Stdio,
+
+        [string]
+        $LanguageServiceNamedPipe,
+
+        [string]
+        $DebugServiceNamedPipe,
+
         [ValidateNotNullOrEmpty()]
         [string]
         $BundledModulesPath,
@@ -89,12 +94,39 @@ function Start-EditorServicesHost {
 
     $editorServicesHost.StartLogging($LogPath, $LogLevel);
 
-    if ($DebugServiceOnly.IsPresent) {
-        $editorServicesHost.StartDebugService($DebugServicePort, $profilePaths, $false);
+    $languageServiceConfig = New-Object Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportConfig
+    $debugServiceConfig    = New-Object Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportConfig
+
+    if ($Stdio.IsPresent) {
+        $languageServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Stdio
+        $debugServiceConfig.TransportType    = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Stdio
     }
-    else {
-        $editorServicesHost.StartLanguageService($LanguageServicePort, $profilePaths);
-        $editorServicesHost.StartDebugService($DebugServicePort, $profilePaths, $true);
+
+    if ($LanguageServicePort) {
+        $languageServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Tcp
+        $languageServiceConfig.Endpoint = "$LanguageServicePort"
+    }
+
+    if ($DebugServicePort) {
+        $debugServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Tcp
+        $debugServiceConfig.Endpoint = "$DebugServicePort"
+    }
+
+    if ($LanguageServiceNamedPipe) {
+        $languageServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::NamedPipe
+        $languageServiceConfig.Endpoint = "$LanguageServiceNamedPipe"
+    }
+
+    if ($DebugServiceNamedPipe) {
+        $debugServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::NamedPipe
+        $debugServiceConfig.Endpoint = "$DebugServiceNamedPipe"
+    }
+
+    if ($DebugServiceOnly.IsPresent) {
+        $editorServicesHost.StartDebugService($debugServiceConfig, $profilePaths, $false);
+    } else {
+        $editorServicesHost.StartLanguageService($languageServiceConfig, $profilePaths);
+        $editorServicesHost.StartDebugService($debugServiceConfig, $profilePaths, $true);
     }
 
     return $editorServicesHost

module/Start-EditorServices.ps1

@@ -68,7 +68,16 @@ param(
     $WaitForDebugger,
 
     [switch]
-    $ConfirmInstall
+    $ConfirmInstall,
+
+    [switch]
+    $Stdio,
+
+    [string]
+    $LanguageServicePipeName = $null,
+
+    [string]
+    $DebugServicePipeName = $null
 )
 
 $minPortNumber = 10000
@@ -271,16 +280,21 @@ try {
         Import-Module PowerShellEditorServices -Version $parsedVersion -ErrorAction Stop
     }
 
-    # Locate available port numbers for services
-    Log "Searching for available socket port for the language service"
-    $languageServicePort = Get-AvailablePort
+	# Locate available port numbers for services
+	# There could be only one service on Stdio channel
 
-    Log "Searching for available socket port for the debug service"
-    $debugServicePort = Get-AvailablePort
+	$languageServiceTransport = $null
+	$debugServiceTransport = $null
 
-    if (!$languageServicePort -or !$debugServicePort) {
-        ExitWithError "Failed to find an open socket port for either the language or debug service."
-    }
+	if ($Stdio.IsPresent -and -not $DebugServiceOnly.IsPresent) { $languageServiceTransport = "Stdio" }
+	elseif ($LanguageServicePipeName)                           { $languageServiceTransport = "NamedPipe"; $languageServicePipeName = "$LanguageServicePipeName" }
+	elseif ($languageServicePort = Get-AvailablePort)           { $languageServiceTransport = "Tcp" }
+	else                                                        { ExitWithError "Failed to find an open socket port for language service." }
+
+	if ($Stdio.IsPresent -and $DebugServiceOnly.IsPresent)      { $debugServiceTransport = "Stdio" }
+	elseif ($DebugServicePipeName)                              { $debugServiceTransport = "NamedPipe"; $debugServicePipeName = "$DebugServicePipeName" }
+	elseif ($debugServicePort = Get-AvailablePort)              { $debugServiceTransport = "Tcp" }
+	else                                                        { ExitWithError "Failed to find an open socket port for debug service." }
 
     if ($EnableConsoleRepl) {
         Write-Host "PowerShell Integrated Console`n"
@@ -298,6 +312,9 @@ try {
             -AdditionalModules $AdditionalModules `
             -LanguageServicePort $languageServicePort `
             -DebugServicePort $debugServicePort `
+            -LanguageServiceNamedPipe $LanguageServicePipeName `
+            -DebugServiceNamedPipe $DebugServicePipeName `
+            -Stdio:$Stdio.IsPresent`
             -BundledModulesPath $BundledModulesPath `
             -EnableConsoleRepl:$EnableConsoleRepl.IsPresent `
             -DebugServiceOnly:$DebugServiceOnly.IsPresent `
@@ -308,10 +325,15 @@ try {
 
     $resultDetails = @{
         "status" = "started";
-        "channel" = "tcp";
-        "languageServicePort" = $languageServicePort;
-        "debugServicePort" = $debugServicePort;
-    }
+        "languageServiceTransport" = $languageServiceTransport;
+        "debugServiceTransport" = $debugServiceTransport;
+    };
+
+    if ($languageServicePipeName) { $resultDetails["languageServicePipeName"] = "$languageServicePipeName" }
+    if ($debugServicePipeName)    { $resultDetails["debugServicePipeName"]    = "$debugServicePipeName" }
+
+    if ($languageServicePort)     { $resultDetails["languageServicePort"]     = $languageServicePort }
+    if ($debugServicePort)        { $resultDetails["debugServicePort"]        = $debugServicePort }
 
     # Notify the client that the services have started
     WriteSessionFile $resultDetails

src/PowerShellEditorServices.Host/EditorServicesHost.cs

@@ -29,6 +29,25 @@ public enum EditorServicesHostStatus
         Ended
     }
 
+    public enum EditorServiceTransportType
+    {
+        Tcp,
+        NamedPipe,
+        Stdio
+    }
+
+    public class EditorServiceTransportConfig
+    {
+        public EditorServiceTransportType TransportType { get; set; }
+        /// <summary>
+        /// Configures the endpoint of the transport.
+        /// For Tcp it's an integer specifying the port.
+        /// For Stdio it's ignored.
+        /// For NamedPipe it's the pipe name.
+        /// </summary>
+        public string Endpoint { get; set; }
+    }
+
     /// <summary>
     /// Provides a simplified interface for hosting the language and debug services
     /// over the named pipe server protocol.
@@ -48,8 +67,8 @@ public class EditorServicesHost
         private HashSet<string> featureFlags;
         private LanguageServer languageServer;
 
-        private TcpSocketServerListener languageServiceListener;
-        private TcpSocketServerListener debugServiceListener;
+        private IServerListener languageServiceListener;
+        private IServerListener debugServiceListener;
 
         private TaskCompletionSource<bool> serverCompletedTask;
 
@@ -164,29 +183,25 @@ public void StartLogging(string logFilePath, LogLevel logLevel)
         /// </summary>
         /// <param name="languageServicePort">The port number for the language service.</param>
         /// <param name="profilePaths">The object containing the profile paths to load for this session.</param>
-        public void StartLanguageService(int languageServicePort, ProfilePaths profilePaths)
+        public void StartLanguageService(EditorServiceTransportConfig config, ProfilePaths profilePaths)
         {
             this.profilePaths = profilePaths;
 
-            this.languageServiceListener =
-                new TcpSocketServerListener(
-                    MessageProtocolType.LanguageServer,
-                    languageServicePort,
-                    this.logger);
+            this.languageServiceListener = CreateServiceListener(MessageProtocolType.LanguageServer, config);
 
             this.languageServiceListener.ClientConnect += this.OnLanguageServiceClientConnect;
             this.languageServiceListener.Start();
 
             this.logger.Write(
                 LogLevel.Normal,
                 string.Format(
-                    "Language service started, listening on port {0}",
-                    languageServicePort));
+                    "Language service started, type = {0}, endpoint = {1}",
+                    config.TransportType, config.Endpoint));
         }
 
         private async void OnLanguageServiceClientConnect(
             object sender,
-            TcpSocketServerChannel serverChannel)
+            ChannelBase serverChannel)
         {
             MessageDispatcher messageDispatcher = new MessageDispatcher(this.logger);
 
@@ -238,27 +253,22 @@ await this.editorSession.PowerShellContext.ImportCommandsModule(
         /// </summary>
         /// <param name="debugServicePort">The port number for the debug service.</param>
         public void StartDebugService(
-            int debugServicePort,
+            EditorServiceTransportConfig config,
             ProfilePaths profilePaths,
             bool useExistingSession)
         {
-            this.debugServiceListener =
-                new TcpSocketServerListener(
-                    MessageProtocolType.DebugAdapter,
-                    debugServicePort,
-                    this.logger);
-
+            this.debugServiceListener = CreateServiceListener(MessageProtocolType.DebugAdapter, config);
             this.debugServiceListener.ClientConnect += OnDebugServiceClientConnect;
             this.debugServiceListener.Start();
 
             this.logger.Write(
                 LogLevel.Normal,
                 string.Format(
-                    "Debug service started, listening on port {0}",
-                    debugServicePort));
+                    "Debug service started, type = {0}, endpoint = {1}",
+                    config.TransportType, config.Endpoint));
         }
 
-        private void OnDebugServiceClientConnect(object sender, TcpSocketServerChannel serverChannel)
+        private void OnDebugServiceClientConnect(object sender, ChannelBase serverChannel)
         {
             MessageDispatcher messageDispatcher = new MessageDispatcher(this.logger);
 
@@ -441,6 +451,31 @@ private void CurrentDomain_UnhandledException(
                     e.ExceptionObject.ToString()));
         }
 #endif
+        private IServerListener CreateServiceListener(MessageProtocolType protocol, EditorServiceTransportConfig config)
+        {
+            switch (config.TransportType)
+            {
+                case EditorServiceTransportType.Tcp:
+                {
+                    return new TcpSocketServerListener(protocol, int.Parse(config.Endpoint), this.logger);
+                }
+
+                case EditorServiceTransportType.Stdio:
+                {
+                    return new StdioServerListener(protocol, this.logger);
+                }
+
+                case EditorServiceTransportType.NamedPipe:
+                {
+                    return new NamedPipeServerListener(protocol, config.Endpoint, this.logger);
+                }
+
+                default:
+                {
+                    throw new NotSupportedException();
+                }
+            }
+        }
 
         #endregion
     }

src/PowerShellEditorServices.Protocol/MessageProtocol/Channel/NamedPipeServerListener.cs

@@ -38,6 +38,7 @@ public override void Start()
                         1,
                         PipeTransmissionMode.Byte,
                         PipeOptions.Asynchronous);
+                ListenForConnection();
             }
             catch (IOException e)
             {

src/PowerShellEditorServices.Protocol/MessageProtocol/Channel/ServerListenerBase.cs

@@ -8,7 +8,7 @@
 
 namespace Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel
 {
-    public abstract class ServerListenerBase<TChannel>
+    public abstract class ServerListenerBase<TChannel> : IServerListener
         where TChannel : ChannelBase
     {
         private MessageProtocolType messageProtocolType;
@@ -22,12 +22,21 @@ public ServerListenerBase(MessageProtocolType messageProtocolType)
 
         public abstract void Stop();
 
-        public event EventHandler<TChannel> ClientConnect;
+        public event EventHandler<ChannelBase> ClientConnect;
 
         protected void OnClientConnect(TChannel channel)
         {
             channel.Start(this.messageProtocolType);
             this.ClientConnect?.Invoke(this, channel);
         }
     }
+
+    public interface IServerListener
+    {
+        void Start();
+
+        void Stop();
+
+        event EventHandler<ChannelBase> ClientConnect;
+    }
 }

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -1362,13 +1362,16 @@ private static FileChange GetFileChangeDetails(Range changeRange, string insertS
         {
             // The protocol's positions are zero-based so add 1 to all offsets
 
+            if (changeRange == null) return new FileChange { InsertString = insertString, IsReload = true };
+
             return new FileChange
             {
                 InsertString = insertString,
                 Line = changeRange.Start.Line + 1,
                 Offset = changeRange.Start.Character + 1,
                 EndLine = changeRange.End.Line + 1,
-                EndOffset = changeRange.End.Character + 1
+                EndOffset = changeRange.End.Character + 1,
+                IsReload = false
             };
         }
 

src/PowerShellEditorServices/Workspace/FileChange.cs

@@ -34,5 +34,12 @@ public class FileChange
         /// The 1-based column offset where the change ends.
         /// </summary>
         public int EndOffset { get; set; }
+
+        /// <summary>
+        /// Indicates that the InsertString is an overwrite
+        /// of the content, and all stale content and metadata
+        /// should be discarded.
+        /// </summary>
+        public bool IsReload { get; set; }
     }
 }