private async Task <PsesLanguageServer> CreateLanguageServerAsync(HostStartupInfo hostDetails)
        {
            _logger.Log(PsesLogLevel.Verbose, $"Creating LSP transport with endpoint {_config.LanguageServiceTransport.EndpointDetails}");
            (Stream inStream, Stream outStream) = await _config.LanguageServiceTransport.ConnectStreamsAsync().ConfigureAwait(false);

            _logger.Log(PsesLogLevel.Diagnostic, "Creating language server");
            return(_serverFactory.CreateLanguageServer(inStream, outStream, hostDetails));
        }
 private async Task RunTempDebugSessionAsync(HostStartupInfo hostDetails)
 {
     _logger.Log(PsesLogLevel.Diagnostic, "Running temp debug session");
     PsesDebugServer debugServer = await CreateDebugServerForTempSessionAsync(hostDetails).ConfigureAwait(false);
     _logger.Log(PsesLogLevel.Verbose, "Debug server created");
     await debugServer.StartAsync().ConfigureAwait(false);
     _logger.Log(PsesLogLevel.Verbose, "Debug server started");
     await debugServer.WaitForShutdown().ConfigureAwait(false);
 }
        /// <summary>
        /// Master method for instantiating, running and waiting for the LSP and debug servers at the heart of Editor Services.
        /// </summary>
        /// <returns>A task that ends when Editor Services shuts down.</returns>
        private async Task CreateEditorServicesAndRunUntilShutdown()
        {
            try
            {
                bool creatingLanguageServer = _config.LanguageServiceTransport != null;
                bool creatingDebugServer    = _config.DebugServiceTransport != null;
                bool isTempDebugSession     = creatingDebugServer && !creatingLanguageServer;

                // Set up information required to instantiate servers
                HostStartupInfo hostStartupInfo = CreateHostStartupInfo();

                // If we just want a temp debug session, run that and do nothing else
                if (isTempDebugSession)
                {
                    await RunTempDebugSessionAsync(hostStartupInfo).ConfigureAwait(false);

                    return;
                }

                // We want LSP and maybe debugging
                // To do that we:
                //  - Create the LSP server
                //  - Possibly kick off the debug server creation
                //  - Start the LSP server
                //  - Possibly start the debug server
                //  - Wait for the LSP server to finish

                // Unsubscribe the host logger here so that the integrated console is not polluted with input after the first prompt
                _logger.Log(PsesLogLevel.Verbose, "Starting server, deregistering host logger and registering shutdown listener");
                if (_loggersToUnsubscribe != null)
                {
                    foreach (IDisposable loggerToUnsubscribe in _loggersToUnsubscribe)
                    {
                        loggerToUnsubscribe.Dispose();
                    }
                }

                WriteStartupBanner();

                PsesLanguageServer languageServer = await CreateLanguageServerAsync(hostStartupInfo).ConfigureAwait(false);

                Task <PsesDebugServer> debugServerCreation = null;
                if (creatingDebugServer)
                {
                    debugServerCreation = CreateDebugServerWithLanguageServerAsync(languageServer, usePSReadLine: _config.ConsoleRepl == ConsoleReplKind.PSReadLine);
                }

                languageServer.StartAsync();

                if (creatingDebugServer)
                {
                    StartDebugServer(debugServerCreation);
                }

                await languageServer.WaitForShutdown().ConfigureAwait(false);
            }
            finally
            {
                // Resubscribe host logger to log shutdown events to the console
                _logger.Subscribe(new PSHostLogger(_config.PSHost.UI));
            }
        }
        private async Task <PsesDebugServer> CreateDebugServerForTempSessionAsync(HostStartupInfo hostDetails)
        {
            (Stream inStream, Stream outStream) = await _config.DebugServiceTransport.ConnectStreamsAsync().ConfigureAwait(false);

            return(_serverFactory.CreateDebugServerForTempSession(inStream, outStream, hostDetails));
        }