Startup task tweaks (#1203)

rjmholt · web-flow · commit 00a4d2ae1ba4 · 2020-02-25T16:43:31.000-08:00
* Improve startup task dispose
* Add more logging
diff --git a/src/PowerShellEditorServices.Hosting/Commands/StartEditorServicesCommand.cs b/src/PowerShellEditorServices.Hosting/Commands/StartEditorServicesCommand.cs
@@ -238,7 +238,8 @@ protected override void EndProcessing()
                 using (var psesLoader = EditorServicesLoader.Create(_logger, editorServicesConfig, sessionFileWriter, _loggerUnsubscribers))
                 {
                     _logger.Log(PsesLogLevel.Verbose, "Loading EditorServices");
-                    psesLoader.LoadAndRunEditorServicesAsync().Wait();
+                    // Start editor services and wait here until it shuts down
+                    psesLoader.LoadAndRunEditorServicesAsync().GetAwaiter().GetResult();
                 }
             }
             catch (Exception e)
@@ -432,20 +433,20 @@ private ITransportConfig GetLanguageServiceTransport()
 
             if (Stdio)
             {
-                return new StdioTransportConfig();
+                return new StdioTransportConfig(_logger);
             }
 
             if (LanguageServiceInPipeName != null && LanguageServiceOutPipeName != null)
             {
-                return SimplexNamedPipeTransportConfig.Create(LanguageServiceInPipeName, LanguageServiceOutPipeName);
+                return SimplexNamedPipeTransportConfig.Create(_logger, LanguageServiceInPipeName, LanguageServiceOutPipeName);
             }
 
             if (SplitInOutPipes)
             {
-                return SimplexNamedPipeTransportConfig.Create(LanguageServicePipeName);
+                return SimplexNamedPipeTransportConfig.Create(_logger, LanguageServicePipeName);
             }
 
-            return DuplexNamedPipeTransportConfig.Create(LanguageServicePipeName);
+            return DuplexNamedPipeTransportConfig.Create(_logger, LanguageServicePipeName);
         }
 
         private ITransportConfig GetDebugServiceTransport()
@@ -456,7 +457,7 @@ private ITransportConfig GetDebugServiceTransport()
             {
                 if (DebugServiceOnly)
                 {
-                    return new StdioTransportConfig();
+                    return new StdioTransportConfig(_logger);
                 }
 
                 _logger.Log(PsesLogLevel.Diagnostic, "No debug transport: Transport is Stdio with debug disabled");
@@ -465,15 +466,15 @@ private ITransportConfig GetDebugServiceTransport()
 
             if (DebugServiceInPipeName != null && DebugServiceOutPipeName != null)
             {
-                return SimplexNamedPipeTransportConfig.Create(DebugServiceInPipeName, DebugServiceOutPipeName);
+                return SimplexNamedPipeTransportConfig.Create(_logger, DebugServiceInPipeName, DebugServiceOutPipeName);
             }
 
             if (SplitInOutPipes)
             {
-                return SimplexNamedPipeTransportConfig.Create(DebugServicePipeName);
+                return SimplexNamedPipeTransportConfig.Create(_logger, DebugServicePipeName);
             }
 
-            return DuplexNamedPipeTransportConfig.Create(DebugServicePipeName);
+            return DuplexNamedPipeTransportConfig.Create(_logger, DebugServicePipeName);
         }
 
         private enum ProfileHostKind
diff --git a/src/PowerShellEditorServices.Hosting/Configuration/HostLogger.cs b/src/PowerShellEditorServices.Hosting/Configuration/HostLogger.cs
@@ -363,7 +363,7 @@ private void RunWriter()
                     _fileWriter.WriteLine(logMessage);
                 }
             }
-            catch (TaskCanceledException)
+            catch (OperationCanceledException)
             {
             }
         }
diff --git a/src/PowerShellEditorServices.Hosting/Configuration/TransportConfig.cs b/src/PowerShellEditorServices.Hosting/Configuration/TransportConfig.cs
@@ -43,6 +43,13 @@ public interface ITransportConfig
     /// </summary>
     public sealed class StdioTransportConfig : ITransportConfig
     {
+        private readonly HostLogger _logger;
+
+        public StdioTransportConfig(HostLogger logger)
+        {
+            _logger = logger;
+        }
+
         public string EndpointDetails => "<stdio>";
 
         public string SessionFileTransportName => "Stdio";
@@ -51,6 +58,7 @@ public sealed class StdioTransportConfig : ITransportConfig
 
         public Task<(Stream inStream, Stream outStream)> ConnectStreamsAsync()
         {
+            _logger.Log(PsesLogLevel.Diagnostic, "Connecting stdio streams");
             return Task.FromResult((Console.OpenStandardInput(), Console.OpenStandardOutput()));
         }
     }
@@ -64,29 +72,32 @@ public sealed class DuplexNamedPipeTransportConfig : ITransportConfig
         /// Create a duplex named pipe transport config with an automatically generated pipe name.
         /// </summary>
         /// <returns>A new duplex named pipe transport configuration.</returns>
-        public static DuplexNamedPipeTransportConfig Create()
+        public static DuplexNamedPipeTransportConfig Create(HostLogger logger)
         {
-            return new DuplexNamedPipeTransportConfig(NamedPipeUtils.GenerateValidNamedPipeName());
+            return new DuplexNamedPipeTransportConfig(logger, NamedPipeUtils.GenerateValidNamedPipeName());
         }
 
         /// <summary>
         /// Create a duplex named pipe transport config with the given pipe name.
         /// </summary>
         /// <returns>A new duplex named pipe transport configuration.</returns>
-        public static DuplexNamedPipeTransportConfig Create(string pipeName)
+        public static DuplexNamedPipeTransportConfig Create(HostLogger logger, string pipeName)
         {
             if (pipeName == null)
             {
-                return DuplexNamedPipeTransportConfig.Create();
+                return DuplexNamedPipeTransportConfig.Create(logger);
             }
 
-            return new DuplexNamedPipeTransportConfig(pipeName);
+            return new DuplexNamedPipeTransportConfig(logger, pipeName);
         }
 
+        private readonly HostLogger _logger;
+
         private readonly string _pipeName;
 
-        private DuplexNamedPipeTransportConfig(string pipeName)
+        private DuplexNamedPipeTransportConfig(HostLogger logger, string pipeName)
         {
+            _logger = logger;
             _pipeName = pipeName;
             SessionFileEntries = new Dictionary<string, object>{ { "PipeName", NamedPipeUtils.GetNamedPipePath(pipeName) } };
         }
@@ -99,8 +110,11 @@ private DuplexNamedPipeTransportConfig(string pipeName)
 
         public async Task<(Stream inStream, Stream outStream)> ConnectStreamsAsync()
         {
+            _logger.Log(PsesLogLevel.Diagnostic, "Creating named pipe");
             NamedPipeServerStream namedPipe = NamedPipeUtils.CreateNamedPipe(_pipeName, PipeDirection.InOut);
+            _logger.Log(PsesLogLevel.Diagnostic, "Waiting for named pipe connection");
             await namedPipe.WaitForConnectionAsync().ConfigureAwait(false);
+            _logger.Log(PsesLogLevel.Diagnostic, "Named pipe connected");
             return (namedPipe, namedPipe);
         }
     }
@@ -117,42 +131,44 @@ public sealed class SimplexNamedPipeTransportConfig : ITransportConfig
         /// Create a pair of simplex named pipes using generated names.
         /// </summary>
         /// <returns>A new simplex named pipe transport config.</returns>
-        public static SimplexNamedPipeTransportConfig Create()
+        public static SimplexNamedPipeTransportConfig Create(HostLogger logger)
         {
-            return SimplexNamedPipeTransportConfig.Create(NamedPipeUtils.GenerateValidNamedPipeName(new[] { InPipePrefix, OutPipePrefix }));
+            return SimplexNamedPipeTransportConfig.Create(logger, NamedPipeUtils.GenerateValidNamedPipeName(new[] { InPipePrefix, OutPipePrefix }));
         }
 
         /// <summary>
         /// Create a pair of simplex named pipes using the given name as a base.
         /// </summary>
         /// <returns>A new simplex named pipe transport config.</returns>
-        public static SimplexNamedPipeTransportConfig Create(string pipeNameBase)
+        public static SimplexNamedPipeTransportConfig Create(HostLogger logger, string pipeNameBase)
         {
             if (pipeNameBase == null)
             {
-                return SimplexNamedPipeTransportConfig.Create();
+                return SimplexNamedPipeTransportConfig.Create(logger);
             }
 
             string inPipeName = $"{InPipePrefix}_{pipeNameBase}";
             string outPipeName = $"{OutPipePrefix}_{pipeNameBase}";
 
-            return SimplexNamedPipeTransportConfig.Create(inPipeName, outPipeName);
+            return SimplexNamedPipeTransportConfig.Create(logger, inPipeName, outPipeName);
         }
 
         /// <summary>
         /// Create a pair of simplex named pipes using the given names.
         /// </summary>
         /// <returns>A new simplex named pipe transport config.</returns>
-        public static SimplexNamedPipeTransportConfig Create(string inPipeName, string outPipeName)
+        public static SimplexNamedPipeTransportConfig Create(HostLogger logger, string inPipeName, string outPipeName)
         {
-            return new SimplexNamedPipeTransportConfig(inPipeName, outPipeName);
+            return new SimplexNamedPipeTransportConfig(logger, inPipeName, outPipeName);
         }
 
+        private readonly HostLogger _logger;
         private readonly string _inPipeName;
         private readonly string _outPipeName;
 
-        private SimplexNamedPipeTransportConfig(string inPipeName, string outPipeName)
+        private SimplexNamedPipeTransportConfig(HostLogger logger, string inPipeName, string outPipeName)
         {
+            _logger = logger;
             _inPipeName = inPipeName;
             _outPipeName = outPipeName;
 
@@ -171,14 +187,18 @@ private SimplexNamedPipeTransportConfig(string inPipeName, string outPipeName)
 
         public async Task<(Stream inStream, Stream outStream)> ConnectStreamsAsync()
         {
+            _logger.Log(PsesLogLevel.Diagnostic, "Starting in pipe connection");
             NamedPipeServerStream inPipe = NamedPipeUtils.CreateNamedPipe(_inPipeName, PipeDirection.InOut);
             Task inPipeConnected = inPipe.WaitForConnectionAsync();
 
+            _logger.Log(PsesLogLevel.Diagnostic, "Starting out pipe connection");
             NamedPipeServerStream outPipe = NamedPipeUtils.CreateNamedPipe(_outPipeName, PipeDirection.Out);
             Task outPipeConnected = outPipe.WaitForConnectionAsync();
 
+            _logger.Log(PsesLogLevel.Diagnostic, "Wating for pipe connections");
             await Task.WhenAll(inPipeConnected, outPipeConnected).ConfigureAwait(false);
 
+            _logger.Log(PsesLogLevel.Diagnostic, "Simplex named pipe transport connected");
             return (inPipe, outPipe);
         }
     }
diff --git a/src/PowerShellEditorServices.Hosting/EditorServicesLoader.cs b/src/PowerShellEditorServices.Hosting/EditorServicesLoader.cs
@@ -160,6 +160,8 @@ public static EditorServicesLoader Create(
 
         private readonly IReadOnlyCollection<IDisposable> _loggersToUnsubscribe;
 
+        private EditorServicesRunner _editorServicesRunner;
+
         private EditorServicesLoader(
             HostLogger logger,
             EditorServicesConfig hostConfig,
@@ -177,7 +179,7 @@ private EditorServicesLoader(
         /// This method's returned task will end when Editor Services shuts down.
         /// </summary>
         /// <returns></returns>
-        public async Task LoadAndRunEditorServicesAsync()
+        public Task LoadAndRunEditorServicesAsync()
         {
             // Log important host information here
             LogHostInformation();
@@ -200,22 +202,27 @@ public async Task LoadAndRunEditorServicesAsync()
             LoadEditorServices();
 
             _logger.Log(PsesLogLevel.Verbose, "Starting EditorServices");
-            using (var editorServicesRunner = new EditorServicesRunner(_logger, _hostConfig, _sessionFileWriter, _loggersToUnsubscribe))
-            {
-                // The trigger method for Editor Services
-                // We will wait here until Editor Services shuts down
-                await editorServicesRunner.RunUntilShutdown().ConfigureAwait(false);
-            }
+
+            _editorServicesRunner = new EditorServicesRunner(_logger, _hostConfig, _sessionFileWriter, _loggersToUnsubscribe);
+
+            // The trigger method for Editor Services
+            return Task.Run(_editorServicesRunner.RunUntilShutdown);
         }
 
         public void Dispose()
         {
-            // TODO: Remove assembly resolve events
-            //       This is not high priority, since the PSES process shouldn't be reused
+            _logger.Log(PsesLogLevel.Diagnostic, "Loader disposed");
+            _editorServicesRunner?.Dispose();
+
+            // TODO:
+            // Remove assembly resolve events
+            // This is not high priority, since the PSES process shouldn't be reused
         }
 
         private void LoadEditorServices()
         {
+            // This must be in its own method, since the actual load happens when the calling method is called
+            // The call within this method is therefore a total no-op
             EditorServicesLoading.LoadEditorServicesForHost();
         }
 
diff --git a/src/PowerShellEditorServices.Hosting/Internal/EditorServicesRunner.cs b/src/PowerShellEditorServices.Hosting/Internal/EditorServicesRunner.cs
@@ -47,7 +47,7 @@ public EditorServicesRunner(
         /// Start and run Editor Services and then wait for shutdown.
         /// </summary>
         /// <returns>A task that ends when Editor Services shuts down.</returns>
-        public async Task RunUntilShutdown()
+        public Task RunUntilShutdown()
         {
             // Start Editor Services
             Task runAndAwaitShutdown = CreateEditorServicesAndRunUntilShutdown();
@@ -57,7 +57,8 @@ public async Task RunUntilShutdown()
             _sessionFileWriter.WriteSessionStarted(_config.LanguageServiceTransport, _config.DebugServiceTransport);
 
             // Finally, wait for Editor Services to shut down
-            await runAndAwaitShutdown.ConfigureAwait(false);
+            _logger.Log(PsesLogLevel.Diagnostic, "Waiting on PSES run/shutdown");
+            return runAndAwaitShutdown;
         }
 
         public void Dispose()
@@ -73,6 +74,8 @@ private async Task CreateEditorServicesAndRunUntilShutdown()
         {
             try
             {
+                _logger.Log(PsesLogLevel.Diagnostic, "Creating/running editor services");
+
                 bool creatingLanguageServer = _config.LanguageServiceTransport != null;
                 bool creatingDebugServer = _config.DebugServiceTransport != null;
                 bool isTempDebugSession = creatingDebugServer && !creatingLanguageServer;

Original file line number	Diff line number	Diff line change
`@@ -238,7 +238,8 @@ protected override void EndProcessing()`
`238`	`238`	`using (var psesLoader = EditorServicesLoader.Create(_logger, editorServicesConfig, sessionFileWriter, _loggerUnsubscribers))`
`239`	`239`	`{`
`240`	`240`	`_logger.Log(PsesLogLevel.Verbose, "Loading EditorServices");`
`241`		`- psesLoader.LoadAndRunEditorServicesAsync().Wait();`
	`241`	`+ // Start editor services and wait here until it shuts down`
	`242`	`+ psesLoader.LoadAndRunEditorServicesAsync().GetAwaiter().GetResult();`
`242`	`243`	`}`
`243`	`244`	`}`
`244`	`245`	`catch (Exception e)`
`@@ -432,20 +433,20 @@ private ITransportConfig GetLanguageServiceTransport()`
`432`	`433`
`433`	`434`	`if (Stdio)`
`434`	`435`	`{`
`435`		`- return new StdioTransportConfig();`
	`436`	`+ return new StdioTransportConfig(_logger);`
`436`	`437`	`}`
`437`	`438`
`438`	`439`	`if (LanguageServiceInPipeName != null && LanguageServiceOutPipeName != null)`
`439`	`440`	`{`
`440`		`- return SimplexNamedPipeTransportConfig.Create(LanguageServiceInPipeName, LanguageServiceOutPipeName);`
	`441`	`+ return SimplexNamedPipeTransportConfig.Create(_logger, LanguageServiceInPipeName, LanguageServiceOutPipeName);`
`441`	`442`	`}`
`442`	`443`
`443`	`444`	`if (SplitInOutPipes)`
`444`	`445`	`{`
`445`		`- return SimplexNamedPipeTransportConfig.Create(LanguageServicePipeName);`
	`446`	`+ return SimplexNamedPipeTransportConfig.Create(_logger, LanguageServicePipeName);`
`446`	`447`	`}`
`447`	`448`
`448`		`- return DuplexNamedPipeTransportConfig.Create(LanguageServicePipeName);`
	`449`	`+ return DuplexNamedPipeTransportConfig.Create(_logger, LanguageServicePipeName);`
`449`	`450`	`}`
`450`	`451`
`451`	`452`	`private ITransportConfig GetDebugServiceTransport()`
`@@ -456,7 +457,7 @@ private ITransportConfig GetDebugServiceTransport()`
`456`	`457`	`{`
`457`	`458`	`if (DebugServiceOnly)`
`458`	`459`	`{`
`459`		`- return new StdioTransportConfig();`
	`460`	`+ return new StdioTransportConfig(_logger);`
`460`	`461`	`}`
`461`	`462`
`462`	`463`	`_logger.Log(PsesLogLevel.Diagnostic, "No debug transport: Transport is Stdio with debug disabled");`
`@@ -465,15 +466,15 @@ private ITransportConfig GetDebugServiceTransport()`
`465`	`466`
`466`	`467`	`if (DebugServiceInPipeName != null && DebugServiceOutPipeName != null)`
`467`	`468`	`{`
`468`		`- return SimplexNamedPipeTransportConfig.Create(DebugServiceInPipeName, DebugServiceOutPipeName);`
	`469`	`+ return SimplexNamedPipeTransportConfig.Create(_logger, DebugServiceInPipeName, DebugServiceOutPipeName);`
`469`	`470`	`}`
`470`	`471`
`471`	`472`	`if (SplitInOutPipes)`
`472`	`473`	`{`
`473`		`- return SimplexNamedPipeTransportConfig.Create(DebugServicePipeName);`
	`474`	`+ return SimplexNamedPipeTransportConfig.Create(_logger, DebugServicePipeName);`
`474`	`475`	`}`
`475`	`476`
`476`		`- return DuplexNamedPipeTransportConfig.Create(DebugServicePipeName);`
	`477`	`+ return DuplexNamedPipeTransportConfig.Create(_logger, DebugServicePipeName);`
`477`	`478`	`}`
`478`	`479`
`479`	`480`	`private enum ProfileHostKind`
Original file line number	Diff line number	Diff line change
`@@ -363,7 +363,7 @@ private void RunWriter()`
`363`	`363`	`_fileWriter.WriteLine(logMessage);`
`364`	`364`	`}`
`365`	`365`	`}`
`366`		`- catch (TaskCanceledException)`
	`366`	`+ catch (OperationCanceledException)`
`367`	`367`	`{`
`368`	`368`	`}`
`369`	`369`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,13 @@ public interface ITransportConfig`
`43`	`43`	`/// </summary>`
`44`	`44`	`public sealed class StdioTransportConfig : ITransportConfig`
`45`	`45`	`{`
	`46`	`+ private readonly HostLogger _logger;`
	`47`	`+`
	`48`	`+ public StdioTransportConfig(HostLogger logger)`
	`49`	`+ {`
	`50`	`+ _logger = logger;`
	`51`	`+ }`
	`52`	`+`
`46`	`53`	`public string EndpointDetails => "<stdio>";`
`47`	`54`
`48`	`55`	`public string SessionFileTransportName => "Stdio";`
`@@ -51,6 +58,7 @@ public sealed class StdioTransportConfig : ITransportConfig`
`51`	`58`
`52`	`59`	`public Task<(Stream inStream, Stream outStream)> ConnectStreamsAsync()`
`53`	`60`	`{`
	`61`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Connecting stdio streams");`
`54`	`62`	`return Task.FromResult((Console.OpenStandardInput(), Console.OpenStandardOutput()));`
`55`	`63`	`}`
`56`	`64`	`}`
`@@ -64,29 +72,32 @@ public sealed class DuplexNamedPipeTransportConfig : ITransportConfig`
`64`	`72`	`/// Create a duplex named pipe transport config with an automatically generated pipe name.`
`65`	`73`	`/// </summary>`
`66`	`74`	`/// <returns>A new duplex named pipe transport configuration.</returns>`
`67`		`- public static DuplexNamedPipeTransportConfig Create()`
	`75`	`+ public static DuplexNamedPipeTransportConfig Create(HostLogger logger)`
`68`	`76`	`{`
`69`		`- return new DuplexNamedPipeTransportConfig(NamedPipeUtils.GenerateValidNamedPipeName());`
	`77`	`+ return new DuplexNamedPipeTransportConfig(logger, NamedPipeUtils.GenerateValidNamedPipeName());`
`70`	`78`	`}`
`71`	`79`
`72`	`80`	`/// <summary>`
`73`	`81`	`/// Create a duplex named pipe transport config with the given pipe name.`
`74`	`82`	`/// </summary>`
`75`	`83`	`/// <returns>A new duplex named pipe transport configuration.</returns>`
`76`		`- public static DuplexNamedPipeTransportConfig Create(string pipeName)`
	`84`	`+ public static DuplexNamedPipeTransportConfig Create(HostLogger logger, string pipeName)`
`77`	`85`	`{`
`78`	`86`	`if (pipeName == null)`
`79`	`87`	`{`
`80`		`- return DuplexNamedPipeTransportConfig.Create();`
	`88`	`+ return DuplexNamedPipeTransportConfig.Create(logger);`
`81`	`89`	`}`
`82`	`90`
`83`		`- return new DuplexNamedPipeTransportConfig(pipeName);`
	`91`	`+ return new DuplexNamedPipeTransportConfig(logger, pipeName);`
`84`	`92`	`}`
`85`	`93`
	`94`	`+ private readonly HostLogger _logger;`
	`95`	`+`
`86`	`96`	`private readonly string _pipeName;`
`87`	`97`
`88`		`- private DuplexNamedPipeTransportConfig(string pipeName)`
	`98`	`+ private DuplexNamedPipeTransportConfig(HostLogger logger, string pipeName)`
`89`	`99`	`{`
	`100`	`+ _logger = logger;`
`90`	`101`	`_pipeName = pipeName;`
`91`	`102`	`SessionFileEntries = new Dictionary<string, object>{ { "PipeName", NamedPipeUtils.GetNamedPipePath(pipeName) } };`
`92`	`103`	`}`
`@@ -99,8 +110,11 @@ private DuplexNamedPipeTransportConfig(string pipeName)`
`99`	`110`
`100`	`111`	`public async Task<(Stream inStream, Stream outStream)> ConnectStreamsAsync()`
`101`	`112`	`{`
	`113`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Creating named pipe");`
`102`	`114`	`NamedPipeServerStream namedPipe = NamedPipeUtils.CreateNamedPipe(_pipeName, PipeDirection.InOut);`
	`115`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Waiting for named pipe connection");`
`103`	`116`	`await namedPipe.WaitForConnectionAsync().ConfigureAwait(false);`
	`117`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Named pipe connected");`
`104`	`118`	`return (namedPipe, namedPipe);`
`105`	`119`	`}`
`106`	`120`	`}`
`@@ -117,42 +131,44 @@ public sealed class SimplexNamedPipeTransportConfig : ITransportConfig`
`117`	`131`	`/// Create a pair of simplex named pipes using generated names.`
`118`	`132`	`/// </summary>`
`119`	`133`	`/// <returns>A new simplex named pipe transport config.</returns>`
`120`		`- public static SimplexNamedPipeTransportConfig Create()`
	`134`	`+ public static SimplexNamedPipeTransportConfig Create(HostLogger logger)`
`121`	`135`	`{`
`122`		`- return SimplexNamedPipeTransportConfig.Create(NamedPipeUtils.GenerateValidNamedPipeName(new[] { InPipePrefix, OutPipePrefix }));`
	`136`	`+ return SimplexNamedPipeTransportConfig.Create(logger, NamedPipeUtils.GenerateValidNamedPipeName(new[] { InPipePrefix, OutPipePrefix }));`
`123`	`137`	`}`
`124`	`138`
`125`	`139`	`/// <summary>`
`126`	`140`	`/// Create a pair of simplex named pipes using the given name as a base.`
`127`	`141`	`/// </summary>`
`128`	`142`	`/// <returns>A new simplex named pipe transport config.</returns>`
`129`		`- public static SimplexNamedPipeTransportConfig Create(string pipeNameBase)`
	`143`	`+ public static SimplexNamedPipeTransportConfig Create(HostLogger logger, string pipeNameBase)`
`130`	`144`	`{`
`131`	`145`	`if (pipeNameBase == null)`
`132`	`146`	`{`
`133`		`- return SimplexNamedPipeTransportConfig.Create();`
	`147`	`+ return SimplexNamedPipeTransportConfig.Create(logger);`
`134`	`148`	`}`
`135`	`149`
`136`	`150`	`string inPipeName = $"{InPipePrefix}_{pipeNameBase}";`
`137`	`151`	`string outPipeName = $"{OutPipePrefix}_{pipeNameBase}";`
`138`	`152`
`139`		`- return SimplexNamedPipeTransportConfig.Create(inPipeName, outPipeName);`
	`153`	`+ return SimplexNamedPipeTransportConfig.Create(logger, inPipeName, outPipeName);`
`140`	`154`	`}`
`141`	`155`
`142`	`156`	`/// <summary>`
`143`	`157`	`/// Create a pair of simplex named pipes using the given names.`
`144`	`158`	`/// </summary>`
`145`	`159`	`/// <returns>A new simplex named pipe transport config.</returns>`
`146`		`- public static SimplexNamedPipeTransportConfig Create(string inPipeName, string outPipeName)`
	`160`	`+ public static SimplexNamedPipeTransportConfig Create(HostLogger logger, string inPipeName, string outPipeName)`
`147`	`161`	`{`
`148`		`- return new SimplexNamedPipeTransportConfig(inPipeName, outPipeName);`
	`162`	`+ return new SimplexNamedPipeTransportConfig(logger, inPipeName, outPipeName);`
`149`	`163`	`}`
`150`	`164`
	`165`	`+ private readonly HostLogger _logger;`
`151`	`166`	`private readonly string _inPipeName;`
`152`	`167`	`private readonly string _outPipeName;`
`153`	`168`
`154`		`- private SimplexNamedPipeTransportConfig(string inPipeName, string outPipeName)`
	`169`	`+ private SimplexNamedPipeTransportConfig(HostLogger logger, string inPipeName, string outPipeName)`
`155`	`170`	`{`
	`171`	`+ _logger = logger;`
`156`	`172`	`_inPipeName = inPipeName;`
`157`	`173`	`_outPipeName = outPipeName;`
`158`	`174`
`@@ -171,14 +187,18 @@ private SimplexNamedPipeTransportConfig(string inPipeName, string outPipeName)`
`171`	`187`
`172`	`188`	`public async Task<(Stream inStream, Stream outStream)> ConnectStreamsAsync()`
`173`	`189`	`{`
	`190`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Starting in pipe connection");`
`174`	`191`	`NamedPipeServerStream inPipe = NamedPipeUtils.CreateNamedPipe(_inPipeName, PipeDirection.InOut);`
`175`	`192`	`Task inPipeConnected = inPipe.WaitForConnectionAsync();`
`176`	`193`
	`194`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Starting out pipe connection");`
`177`	`195`	`NamedPipeServerStream outPipe = NamedPipeUtils.CreateNamedPipe(_outPipeName, PipeDirection.Out);`
`178`	`196`	`Task outPipeConnected = outPipe.WaitForConnectionAsync();`
`179`	`197`
	`198`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Wating for pipe connections");`
`180`	`199`	`await Task.WhenAll(inPipeConnected, outPipeConnected).ConfigureAwait(false);`
`181`	`200`
	`201`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Simplex named pipe transport connected");`
`182`	`202`	`return (inPipe, outPipe);`
`183`	`203`	`}`
`184`	`204`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public EditorServicesRunner(`
`47`	`47`	`/// Start and run Editor Services and then wait for shutdown.`
`48`	`48`	`/// </summary>`
`49`	`49`	`/// <returns>A task that ends when Editor Services shuts down.</returns>`
`50`		`- public async Task RunUntilShutdown()`
	`50`	`+ public Task RunUntilShutdown()`
`51`	`51`	`{`
`52`	`52`	`// Start Editor Services`
`53`	`53`	`Task runAndAwaitShutdown = CreateEditorServicesAndRunUntilShutdown();`
`@@ -57,7 +57,8 @@ public async Task RunUntilShutdown()`
`57`	`57`	`_sessionFileWriter.WriteSessionStarted(_config.LanguageServiceTransport, _config.DebugServiceTransport);`
`58`	`58`
`59`	`59`	`// Finally, wait for Editor Services to shut down`
`60`		`- await runAndAwaitShutdown.ConfigureAwait(false);`
	`60`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Waiting on PSES run/shutdown");`
	`61`	`+ return runAndAwaitShutdown;`
`61`	`62`	`}`
`62`	`63`
`63`	`64`	`public void Dispose()`
`@@ -73,6 +74,8 @@ private async Task CreateEditorServicesAndRunUntilShutdown()`
`73`	`74`	`{`
`74`	`75`	`try`
`75`	`76`	`{`
	`77`	`+ _logger.Log(PsesLogLevel.Diagnostic, "Creating/running editor services");`
	`78`	`+`
`76`	`79`	`bool creatingLanguageServer = _config.LanguageServiceTransport != null;`
`77`	`80`	`bool creatingDebugServer = _config.DebugServiceTransport != null;`
`78`	`81`	`bool isTempDebugSession = creatingDebugServer && !creatingLanguageServer;`