Add RemoteFileManager to manage remote files

daviwil · daviwil · commit 22f17e3bceeb · 2017-01-09T14:23:18.000-08:00
This change adds a new RemoteFileManager class which manages files which
are opened when a remote session is active.  It handles the gathering of
remote file contents and mapping remote files paths to a local cache.  It
also keeps track of the remote files which were opened in the editor and
closes them once the remote session has been exited.
diff --git a/src/PowerShellEditorServices.Channel.WebSocket/WebsocketServerChannel.cs b/src/PowerShellEditorServices.Channel.WebSocket/WebsocketServerChannel.cs
@@ -151,7 +151,7 @@ public class DebugAdapterWebSocketConnection : EditorServiceWebSocketConnection
     {
         public DebugAdapterWebSocketConnection()
         {
-            Server = new DebugAdapter(null, null, Channel);
+            Server = new DebugAdapter(null, null, Channel, null);
         }
     }
 }
diff --git a/src/PowerShellEditorServices.Host/EditorServicesHost.cs b/src/PowerShellEditorServices.Host/EditorServicesHost.cs
@@ -164,7 +164,8 @@ public void StartDebugService(int debugServicePort, ProfilePaths profilePaths)
                 new DebugAdapter(
                     hostDetails,
                     profilePaths,
-                    new TcpSocketServerChannel(debugServicePort));
+                    new TcpSocketServerChannel(debugServicePort),
+                    this.languageServer?.EditorOperations);
 
             this.debugAdapter.SessionEnded +=
                 (obj, args) =>
diff --git a/src/PowerShellEditorServices.Protocol/LanguageServer/EditorCommands.cs b/src/PowerShellEditorServices.Protocol/LanguageServer/EditorCommands.cs
@@ -108,6 +108,13 @@ public static readonly
             RequestType<string, EditorCommandResponse>.Create("editor/openFile");
     }
 
+    public class CloseFileRequest
+    {
+        public static readonly
+            RequestType<string, EditorCommandResponse> Type =
+            RequestType<string, EditorCommandResponse>.Create("editor/closeFile");
+    }
+
     public class ShowInformationMessageRequest
     {
         public static readonly
diff --git a/src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs b/src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs
@@ -4,6 +4,7 @@
 //
 
 using Microsoft.PowerShell.EditorServices.Debugging;
+using Microsoft.PowerShell.EditorServices.Extensions;
 using Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel;
@@ -23,21 +24,26 @@ public class DebugAdapter : DebugAdapterBase
     {
         private EditorSession editorSession;
         private OutputDebouncer outputDebouncer;
+
         private bool noDebug;
         private bool waitingForAttach;
         private string scriptPathToLaunch;
         private string arguments;
 
         public DebugAdapter(HostDetails hostDetails, ProfilePaths profilePaths)
-            : this(hostDetails, profilePaths, new StdioServerChannel())
+            : this(hostDetails, profilePaths, new StdioServerChannel(), null)
         {
         }
 
-        public DebugAdapter(HostDetails hostDetails, ProfilePaths profilePaths, ChannelBase serverChannel)
+        public DebugAdapter(
+            HostDetails hostDetails,
+            ProfilePaths profilePaths,
+            ChannelBase serverChannel,
+            IEditorOperations editorOperations)
             : base(serverChannel)
         {
             this.editorSession = new EditorSession();
-            this.editorSession.StartDebugSession(hostDetails, profilePaths);
+            this.editorSession.StartDebugSession(hostDetails, profilePaths, editorOperations);
             this.editorSession.PowerShellContext.RunspaceChanged += this.powerShellContext_RunspaceChanged;
             this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
             this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
@@ -184,7 +190,7 @@ protected async Task HandleLaunchRequest(
 
             // If no script is being launched, execute an empty script to
             // cause the prompt string to be evaluated and displayed
-            if (!string.IsNullOrEmpty(this.scriptPathToLaunch))
+            if (string.IsNullOrEmpty(this.scriptPathToLaunch))
             {
                 await this.editorSession.PowerShellContext.ExecuteScriptString(
                     "", false, true);
diff --git a/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs b/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
@@ -32,9 +32,15 @@ public class LanguageServer : LanguageServerBase
         private OutputDebouncer outputDebouncer;
         private LanguageServerEditorOperations editorOperations;
         private LanguageServerSettings currentSettings = new LanguageServerSettings();
+
         private Dictionary<string, Dictionary<string, MarkerCorrection>> codeActionsPerFile =
             new Dictionary<string, Dictionary<string, MarkerCorrection>>();
 
+        public IEditorOperations EditorOperations
+        {
+            get { return this.editorOperations; }
+        }
+
         /// <param name="hostDetails">
         /// Provides details about the host application.
         /// </param>
diff --git a/src/PowerShellEditorServices.Protocol/Server/LanguageServerEditorOperations.cs b/src/PowerShellEditorServices.Protocol/Server/LanguageServerEditorOperations.cs
@@ -110,6 +110,15 @@ public Task OpenFile(string filePath)
                     true);
         }
 
+        public Task CloseFile(string filePath)
+        {
+            return
+                this.messageSender.SendRequest(
+                    CloseFileRequest.Type,
+                    filePath,
+                    true);
+        }
+
         public string GetWorkspacePath()
         {
             return this.editorSession.Workspace.WorkspacePath;
diff --git a/src/PowerShellEditorServices/Debugging/DebugService.cs b/src/PowerShellEditorServices/Debugging/DebugService.cs
@@ -28,14 +28,12 @@ public class DebugService
         private const string PsesGlobalVariableNamePrefix = "__psEditorServices_";
 
         private PowerShellContext powerShellContext;
+        private RemoteFileManager remoteFileManager;
 
         // TODO: This needs to be managed per nested session
         private Dictionary<string, List<Breakpoint>> breakpointsPerFile = 
             new Dictionary<string, List<Breakpoint>>();
 
-        private Dictionary<RunspaceDetails, Dictionary<string, string>> remoteFileMappings =
-            new Dictionary<RunspaceDetails, Dictionary<string, string>>();
-
         private int nextVariableId;
         private List<VariableDetailsBase> variables;
         private VariableContainerDetails globalScopeVariables;
@@ -56,12 +54,31 @@ public class DebugService
         /// The PowerShellContext to use for all debugging operations.
         /// </param>
         public DebugService(PowerShellContext powerShellContext)
+            : this(powerShellContext, null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the DebugService class and uses
+        /// the given PowerShellContext for all future operations.
+        /// </summary>
+        /// <param name="powerShellContext">
+        /// The PowerShellContext to use for all debugging operations.
+        /// </param>
+        /// <param name="remoteFileManager">
+        /// A RemoteFileManager instance to use for accessing files in remote sessions.
+        /// </param>
+        public DebugService(
+            PowerShellContext powerShellContext,
+            RemoteFileManager remoteFileManager)
         {
-            Validate.IsNotNull("powerShellContext", powerShellContext);
+            Validate.IsNotNull(nameof(powerShellContext), powerShellContext);
 
             this.powerShellContext = powerShellContext;
             this.powerShellContext.DebuggerStop += this.OnDebuggerStop;
             this.powerShellContext.BreakpointUpdated += this.OnBreakpointUpdated;
+
+            this.remoteFileManager = remoteFileManager;
         }
 
         #endregion
@@ -91,12 +108,13 @@ public async Task<BreakpointDetails[]> SetLineBreakpoints(
             {
                 // Make sure we're using the remote script path
                 string scriptPath = scriptFile.FilePath;
-                if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote)
+                if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
+                    this.remoteFileManager != null)
                 {
                     string mappedPath =
-                        this.GetRemotePathMapping(
-                            this.powerShellContext.CurrentRunspace,
-                            scriptPath);
+                        this.remoteFileManager.GetMappedPath(
+                            scriptPath,
+                            this.powerShellContext.CurrentRunspace);
 
                     if (mappedPath == null)
                     {
@@ -764,13 +782,14 @@ private async Task FetchStackFrames()
                     StackFrameDetails.Create(callStackFrames[i], autoVariables, localVariables);
 
                 string stackFrameScriptPath = this.stackFrameDetails[i].ScriptPath;
-                if (this.powerShellContext.CurrentRunspace.Location == Session.RunspaceLocation.Remote &&
+                if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
+                    this.remoteFileManager != null &&
                     !string.Equals(stackFrameScriptPath, StackFrameDetails.NoFileScriptPath))
                 {
                     this.stackFrameDetails[i].ScriptPath =
-                        Workspace.MapRemotePathToLocal(
+                        this.remoteFileManager.GetMappedPath(
                             stackFrameScriptPath,
-                            this.powerShellContext.CurrentRunspace.ConnectionString);
+                            this.powerShellContext.CurrentRunspace);
                 }
             }
         }
@@ -960,34 +979,6 @@ private string FormatInvalidBreakpointConditionMessage(string condition, string
             return $"'{condition}' is not a valid PowerShell expression. {message}";
         }
 
-        private void AddRemotePathMapping(RunspaceDetails runspaceDetails, string remotePath, string localPath)
-        {
-            Dictionary<string, string> runspaceMappings = null;
-
-            if (!this.remoteFileMappings.TryGetValue(runspaceDetails, out runspaceMappings))
-            {
-                runspaceMappings = new Dictionary<string, string>();
-                this.remoteFileMappings.Add(runspaceDetails, runspaceMappings);
-            }
-
-            // Add mappings in both directions
-            runspaceMappings[localPath.ToLower()] = remotePath;
-            runspaceMappings[remotePath.ToLower()] = localPath;
-        }
-
-        private string GetRemotePathMapping(RunspaceDetails runspaceDetails, string localPath)
-        {
-            string remotePath = null;
-            Dictionary<string, string> runspaceMappings = null;
-
-            if (this.remoteFileMappings.TryGetValue(runspaceDetails, out runspaceMappings))
-            {
-                runspaceMappings.TryGetValue(localPath.ToLower(), out remotePath);
-            }
-
-            return remotePath;
-        }
-
         #endregion
 
         #region Events
@@ -1003,56 +994,14 @@ private async void OnDebuggerStop(object sender, DebuggerStopEventArgs e)
             await this.FetchStackFramesAndVariables();
 
             // If this is a remote connection, get the file content
-            string localScriptPath = null;
-            if (this.powerShellContext.CurrentRunspace.Location == Session.RunspaceLocation.Remote)
+            string localScriptPath = e.InvocationInfo.ScriptName;
+            if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
+                this.remoteFileManager != null)
             {
-                string remoteScriptPath = e.InvocationInfo.ScriptName;
-                if (!string.IsNullOrEmpty(remoteScriptPath))
-                {
-                    localScriptPath =
-                        Workspace.MapRemotePathToLocal(
-                            remoteScriptPath,
-                            this.powerShellContext.CurrentRunspace.ConnectionString);
-
-                    // TODO: Catch filesystem exceptions!
-
-                    // Does the local file already exist?
-                    if (!File.Exists(localScriptPath))
-                    {
-                        // Load the file contents from the remote machine and create the buffer
-                        PSCommand command = new PSCommand();
-                        command.AddCommand("Microsoft.PowerShell.Management\\Get-Content");
-                        command.AddParameter("Path", remoteScriptPath);
-                        command.AddParameter("Raw");
-                        command.AddParameter("Encoding", "Byte");
-
-                        byte[] fileContent =
-                            (await this.powerShellContext.ExecuteCommand<byte[]>(command, false, false))
-                                .FirstOrDefault();
-
-                        if (fileContent != null)
-                        {
-                            File.WriteAllBytes(localScriptPath, fileContent);
-                        }
-                        else
-                        {
-                            Logger.Write(
-                                LogLevel.Warning,
-                                $"Could not load contents of remote file '{remoteScriptPath}'");
-                        }
-
-                        // Add the file mapping so that breakpoints can be passed through
-                        // to the real file in the remote session
-                        this.AddRemotePathMapping(
-                            this.powerShellContext.CurrentRunspace,
-                            remoteScriptPath,
-                            localScriptPath);
-                        this.AddRemotePathMapping(
-                            this.powerShellContext.CurrentRunspace,
-                            localScriptPath,
-                            remoteScriptPath);
-                    }
-                }
+                localScriptPath =
+                    await this.remoteFileManager.FetchRemoteFile(
+                        e.InvocationInfo.ScriptName,
+                        this.powerShellContext.CurrentRunspace);
             }
 
             // Notify the host that the debugger is stopped
@@ -1082,12 +1031,13 @@ private void OnBreakpointUpdated(object sender, BreakpointUpdatedEventArgs e)
                 List<Breakpoint> breakpoints;
 
                 string scriptPath = lineBreakpoint.Script;
-                if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote)
+                if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
+                    this.remoteFileManager != null)
                 {
                     string mappedPath =
-                        this.GetRemotePathMapping(
-                            this.powerShellContext.CurrentRunspace,
-                            scriptPath);
+                        this.remoteFileManager.GetMappedPath(
+                            scriptPath,
+                            this.powerShellContext.CurrentRunspace);
 
                     if (mappedPath == null)
                     {
diff --git a/src/PowerShellEditorServices/Extensions/IEditorOperations.cs b/src/PowerShellEditorServices/Extensions/IEditorOperations.cs
@@ -41,6 +41,13 @@ public interface IEditorOperations
         /// <returns>A Task that can be tracked for completion.</returns>
         Task OpenFile(string filePath);
 
+        /// <summary>
+        /// Causes a file to be closed in the editor.
+        /// </summary>
+        /// <param name="filePath">The path of the file to be closed.</param>
+        /// <returns>A Task that can be tracked for completion.</returns>
+        Task CloseFile(string filePath);
+
         /// <summary>
         /// Inserts text into the specified range for the file at the specified path.
         /// </summary>
diff --git a/src/PowerShellEditorServices/Nano.PowerShellEditorServices.csproj b/src/PowerShellEditorServices/Nano.PowerShellEditorServices.csproj
@@ -110,6 +110,7 @@
     <Compile Include="Session\PowerShellVersionDetails.cs" />
     <Compile Include="Session\ProfilePaths.cs" />
     <Compile Include="Session\ProgressDetails.cs" />
+    <Compile Include="Session\RemoteFileManager.cs" />
     <Compile Include="Session\RunspaceHandle.cs" />
     <Compile Include="Session\SessionPSHost.cs" />
     <Compile Include="Session\SessionPSHostRawUserInterface.cs" />
diff --git a/src/PowerShellEditorServices/PowerShellEditorServices.csproj b/src/PowerShellEditorServices/PowerShellEditorServices.csproj
@@ -144,6 +144,7 @@
     <Compile Include="Workspace\FileChange.cs" />
     <Compile Include="Workspace\BufferPosition.cs" />
     <Compile Include="Workspace\FilePosition.cs" />
+    <Compile Include="Session\RemoteFileManager.cs" />
     <Compile Include="Workspace\ScriptFile.cs" />
     <Compile Include="Workspace\ScriptFileMarker.cs" />
     <Compile Include="Workspace\ScriptRegion.cs" />
diff --git a/src/PowerShellEditorServices/Session/EditorSession.cs b/src/PowerShellEditorServices/Session/EditorSession.cs
@@ -100,12 +100,21 @@ public void StartSession(HostDetails hostDetails, ProfilePaths profilePaths)
         /// <param name="profilePaths">
         /// An object containing the profile paths for the session.
         /// </param>
-        public void StartDebugSession(HostDetails hostDetails, ProfilePaths profilePaths)
+        /// <param name="editorOperations">
+        /// An IEditorOperations implementation used to interact with the editor.
+        /// </param>
+        public void StartDebugSession(
+            HostDetails hostDetails,
+            ProfilePaths profilePaths,
+            IEditorOperations editorOperations)
         {
             // Initialize all services
             this.PowerShellContext = new PowerShellContext(hostDetails, profilePaths);
-            this.DebugService = new DebugService(this.PowerShellContext);
             this.ConsoleService = new ConsoleService(this.PowerShellContext);
+            this.DebugService =
+                new DebugService(
+                    this.PowerShellContext,
+                    new RemoteFileManager(this.PowerShellContext, editorOperations));
 
             // Create a workspace to contain open files
             this.Workspace = new Workspace(this.PowerShellContext.LocalPowerShellVersion.Version);
diff --git a/src/PowerShellEditorServices/Session/PowerShellContext.cs b/src/PowerShellEditorServices/Session/PowerShellContext.cs
@@ -786,6 +786,13 @@ public void Dispose()
                 {
                     RunspaceDetails poppedRunspace = this.runspaceStack.Pop();
                     this.CloseRunspace(poppedRunspace);
+
+                    this.OnRunspaceChanged(
+                        this,
+                        new RunspaceChangedEventArgs(
+                            RunspaceChangeAction.Shutdown,
+                            poppedRunspace,
+                            null));
                 }
             }
 
diff --git a/src/PowerShellEditorServices/Session/RemoteFileManager.cs b/src/PowerShellEditorServices/Session/RemoteFileManager.cs
diff --git a/src/PowerShellEditorServices/Session/RunspaceChangedEventArgs.cs b/src/PowerShellEditorServices/Session/RunspaceChangedEventArgs.cs
diff --git a/src/PowerShellEditorServices/Workspace/Workspace.cs b/src/PowerShellEditorServices/Workspace/Workspace.cs
diff --git a/test/PowerShellEditorServices.Test/Extensions/ExtensionServiceTests.cs b/test/PowerShellEditorServices.Test/Extensions/ExtensionServiceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ public class DebugAdapterWebSocketConnection : EditorServiceWebSocketConnection`
`151`	`151`	`{`
`152`	`152`	`public DebugAdapterWebSocketConnection()`
`153`	`153`	`{`
`154`		`- Server = new DebugAdapter(null, null, Channel);`
	`154`	`+ Server = new DebugAdapter(null, null, Channel, null);`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,6 +108,13 @@ public static readonly`
`108`	`108`	`RequestType<string, EditorCommandResponse>.Create("editor/openFile");`
`109`	`109`	`}`
`110`	`110`
	`111`	`+ public class CloseFileRequest`
	`112`	`+ {`
	`113`	`+ public static readonly`
	`114`	`+ RequestType<string, EditorCommandResponse> Type =`
	`115`	`+ RequestType<string, EditorCommandResponse>.Create("editor/closeFile");`
	`116`	`+ }`
	`117`	`+`
`111`	`118`	`public class ShowInformationMessageRequest`
`112`	`119`	`{`
`113`	`120`	`public static readonly`