Add input prompt message types to protocol

This change adds input prompt messages types to the language server
protocol.  It also converts the existing choice prompt message types from
events to requests since we now have server-to-client request support.

Author: daviwil

src/PowerShellEditorServices.Protocol/Messages/PromptEvents.cs

@@ -7,11 +7,11 @@
 
 namespace Microsoft.PowerShell.EditorServices.Protocol.Messages
 {
-    public class ShowChoicePromptNotification
+    public class ShowChoicePromptRequest
     {
         public static readonly
-            EventType<ShowChoicePromptNotification> Type =
-            EventType<ShowChoicePromptNotification>.Create("powerShell/showChoicePrompt");
+            RequestType<ShowChoicePromptRequest, ShowChoicePromptResponse> Type =
+            RequestType<ShowChoicePromptRequest, ShowChoicePromptResponse>.Create("powerShell/showChoicePrompt");
 
         public string Caption { get; set; }
 
@@ -22,15 +22,35 @@ public static readonly
         public int DefaultChoice { get; set; }
     }
 
-    public class CompleteChoicePromptNotification
+    public class ShowChoicePromptResponse
+    {
+        public bool PromptCancelled { get; set; }
+
+        public string ChosenItem { get; set; }
+    }
+
+    public class ShowInputPromptRequest
     {
         public static readonly
-            EventType<CompleteChoicePromptNotification> Type =
-            EventType<CompleteChoicePromptNotification>.Create("powerShell/completeChoicePrompt");
+            RequestType<ShowInputPromptRequest, ShowInputPromptResponse> Type =
+            RequestType<ShowInputPromptRequest, ShowInputPromptResponse>.Create("powerShell/showInputPrompt");
+
+        /// <summary>
+        /// Gets or sets the name of the field.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the descriptive label for the field.
+        /// </summary>
+        public string Label { get; set; }
+    }
 
+    public class ShowInputPromptResponse
+    {
         public bool PromptCancelled { get; set; }
 
-        public string ChosenItem { get; set; }
+        public string ResponseText { get; set; }
     }
 }
 

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -73,8 +73,6 @@ protected override void Initialize()
             this.SetRequestHandler(FindModuleRequest.Type, this.HandleFindModuleRequest);
             this.SetRequestHandler(InstallModuleRequest.Type, this.HandleInstallModuleRequest);
 
-            this.SetEventHandler(CompleteChoicePromptNotification.Type, this.HandleCompleteChoicePromptNotification);
-
             this.SetRequestHandler(DebugAdapterMessages.EvaluateRequest.Type, this.HandleEvaluateRequest);
         }
 
@@ -216,25 +214,6 @@ private async Task HandleFindModuleRequest(
             await requestContext.SendResult(moduleList);
         }
 
-        protected Task HandleCompleteChoicePromptNotification(
-            CompleteChoicePromptNotification completeChoicePromptParams,
-            EventContext eventContext)
-        {
-            if (!completeChoicePromptParams.PromptCancelled)
-            {
-                this.editorSession.ConsoleService.ReceiveInputString(
-                    completeChoicePromptParams.ChosenItem,
-                    false);
-            }
-            else
-            {
-                // Cancel the current prompt
-                this.editorSession.ConsoleService.SendControlC();
-            }
-
-            return Task.FromResult(true);
-        }
-
         protected Task HandleDidOpenTextDocumentNotification(
             DidOpenTextDocumentNotification openParams,
             EventContext eventContext)

src/PowerShellEditorServices.Protocol/Server/PromptHandlers.cs

@@ -6,49 +6,182 @@
 using System;
 using Microsoft.PowerShell.EditorServices.Console;
 using Microsoft.PowerShell.EditorServices.Protocol.Messages;
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+using Microsoft.PowerShell.EditorServices.Utility;
+using System.Threading.Tasks;
 
 namespace Microsoft.PowerShell.EditorServices.Protocol.Server
 {
     internal class ProtocolPromptHandlerContext : IPromptHandlerContext
     {
-        private IEventWriter eventWriter;
+        private IMessageSender messageSender;
+        private ConsoleService consoleService;
 
-        public ProtocolPromptHandlerContext(IEventWriter eventWriter)
+        public ProtocolPromptHandlerContext(
+            IMessageSender messageSender,
+            ConsoleService consoleService)
         {
-            this.eventWriter = eventWriter;
+            this.messageSender = messageSender;
+            this.consoleService = consoleService;
         }
 
         public ChoicePromptHandler GetChoicePromptHandler()
         {
-            return new ProtocolChoicePromptHandler(this.eventWriter);
+            return new ProtocolChoicePromptHandler(
+                this.messageSender,
+                this.consoleService);
         }
 
         public InputPromptHandler GetInputPromptHandler()
         {
-            throw new NotImplementedException();
+            return new ProtocolInputPromptHandler(
+                this.messageSender,
+                this.consoleService);
         }
     }
 
     internal class ProtocolChoicePromptHandler : ChoicePromptHandler
     {
-        private IEventWriter eventWriter;
+        private IMessageSender messageSender;
+        private ConsoleService consoleService;
 
-        public ProtocolChoicePromptHandler(IEventWriter eventWriter)
+        public ProtocolChoicePromptHandler(
+            IMessageSender messageSender,
+            ConsoleService consoleService)
         {
-            this.eventWriter = eventWriter;
+            this.messageSender = messageSender;
+            this.consoleService = consoleService;
         }
 
         protected override void ShowPrompt(PromptStyle promptStyle)
         {
-            eventWriter.SendEvent(
-                ShowChoicePromptNotification.Type,
-                new ShowChoicePromptNotification
+            messageSender
+                .SendRequest(
+                    ShowChoicePromptRequest.Type,
+                    new ShowChoicePromptRequest
+                    {
+                        Caption = this.Caption,
+                        Message = this.Message,
+                        Choices = this.Choices,
+                        DefaultChoice = this.DefaultChoice
+                    }, true)
+                .ContinueWith(HandlePromptResponse)
+                .ConfigureAwait(false);
+        }
+
+        private void HandlePromptResponse(
+            Task<ShowChoicePromptResponse> responseTask)
+        {
+            if (responseTask.IsCompleted)
+            {
+                ShowChoicePromptResponse response = responseTask.Result;
+
+                if (!response.PromptCancelled)
                 {
-                    Caption = this.Caption,
-                    Message = this.Message,
-                    Choices = this.Choices,
-                    DefaultChoice = this.DefaultChoice
-                }).ConfigureAwait(false);
+                    this.consoleService.ReceivePromptResponse(
+                        response.ChosenItem,
+                        false);
+                }
+                else
+                {
+                    // Cancel the current prompt
+                    this.consoleService.SendControlC();
+                }
+            }
+            else
+            {
+                if (responseTask.IsFaulted)
+                {
+                    // Log the error
+                    Logger.Write(
+                        LogLevel.Error,
+                        "ShowChoicePrompt request failed with error:\r\n{0}",
+                        responseTask.Exception.ToString());
+                }
+
+                // Cancel the current prompt
+                this.consoleService.SendControlC();
+            }
+        }
+    }
+
+    internal class ProtocolInputPromptHandler : ConsoleInputPromptHandler
+    {
+        private IMessageSender messageSender;
+        private ConsoleService consoleService;
+
+        public ProtocolInputPromptHandler(
+            IMessageSender messageSender,
+            ConsoleService consoleService)
+                : base(consoleService)
+        {
+            this.messageSender = messageSender;
+            this.consoleService = consoleService;
+        }
+
+        protected override void ShowErrorMessage(Exception e)
+        {
+            // Use default behavior for writing the error message
+            base.ShowErrorMessage(e);
+        }
+
+        protected override void ShowPromptMessage(string caption, string message)
+        {
+            // Use default behavior for writing the prompt message
+            base.ShowPromptMessage(caption, message);
+        }
+
+        protected override void ShowFieldPrompt(FieldDetails fieldDetails)
+        {
+            // Write the prompt to the console first so that there's a record
+            // of it occurring
+            base.ShowFieldPrompt(fieldDetails);
+
+            messageSender
+                .SendRequest(
+                    ShowInputPromptRequest.Type,
+                    new ShowInputPromptRequest
+                    {
+                        Name = fieldDetails.Name,
+                        Label = fieldDetails.Label
+                    }, true)
+                .ContinueWith(HandlePromptResponse)
+                .ConfigureAwait(false);
+        }
+
+        private void HandlePromptResponse(
+            Task<ShowInputPromptResponse> responseTask)
+        {
+            if (responseTask.IsCompleted)
+            {
+                ShowInputPromptResponse response = responseTask.Result;
+
+                if (!response.PromptCancelled)
+                {
+                    this.consoleService.ReceivePromptResponse(
+                        response.ResponseText,
+                        true);
+                }
+                else
+                {
+                    // Cancel the current prompt
+                    this.consoleService.SendControlC();
+                }
+            }
+            else
+            {
+                if (responseTask.IsFaulted)
+                {
+                    // Log the error
+                    Logger.Write(
+                        LogLevel.Error,
+                        "ShowInputPrompt request failed with error:\r\n{0}",
+                        responseTask.Exception.ToString());
+                }
+
+                // Cancel the current prompt
+                this.consoleService.SendControlC();
+            }
         }
     }
 }