Use storageUri for session file

Note that we seemed to be unnecessarily writing a new debug session file
for the `RunCode` and `PesterTests` features; they work fine without
that logic as the debugger itself handles the session file.

Author: andyleejordan

src/features/DebugSession.ts

@@ -309,7 +309,7 @@ export class DebugSessionFeature extends LanguageClientConsumer
         // Create or show the interactive console
         vscode.commands.executeCommand("PowerShell.ShowSessionConsole", true);
 
-        const sessionFilePath = this.sessionManager.getDebugSessionFilePath();
+        const sessionFilePath = this.sessionManager.getNewSessionFilePath();
 
         if (config.createTemporaryIntegratedConsole) {
             this.tempDebugProcess = this.sessionManager.createDebugSessionProcess(sessionFilePath, settings);

src/features/PesterTests.ts

@@ -130,11 +130,6 @@ export class PesterTestsFeature implements vscode.Disposable {
         // TODO: #367 Check if "newSession" mode is configured
         await vscode.commands.executeCommand("PowerShell.ShowSessionConsole", true);
 
-        // Write out temporary debug session file
-        await this.sessionManager.writeSessionFile(
-            this.sessionManager.getDebugSessionFilePath(),
-            this.sessionManager.getSessionDetails());
-
         // TODO: Update to handle multiple root workspaces.
         //
         // Ensure the necessary script exists (for testing). The debugger will

src/features/RunCode.ts

@@ -43,11 +43,6 @@ export class RunCodeFeature implements vscode.Disposable {
         // TODO: #367: Check if "newSession" mode is configured
         await vscode.commands.executeCommand("PowerShell.ShowSessionConsole", true);
 
-        // Write out temporary debug session file
-        await this.sessionManager.writeSessionFile(
-            this.sessionManager.getDebugSessionFilePath(),
-            this.sessionManager.getSessionDetails());
-
         // TODO: Update to handle multiple root workspaces.
         await vscode.debug.startDebugging(vscode.workspace.workspaceFolders?.[0], launchConfig);
     }

src/process.ts

@@ -31,7 +31,7 @@ export class PowerShellProcess {
         private title: string,
         private log: Logger,
         private startPsesArgs: string,
-        private sessionFilePath: string,
+        private sessionFilePath: vscode.Uri,
         private sessionSettings: Settings.ISettings) {
 
         this.onExited = this.onExitedEmitter.event;
@@ -53,7 +53,7 @@ export class PowerShellProcess {
 
         this.startPsesArgs +=
             `-LogPath '${PowerShellProcess.escapeSingleQuotes(editorServicesLogPath.fsPath)}' ` +
-            `-SessionDetailsPath '${PowerShellProcess.escapeSingleQuotes(this.sessionFilePath)}' ` +
+        `-SessionDetailsPath '${PowerShellProcess.escapeSingleQuotes(this.sessionFilePath.fsPath)}' ` +
             `-FeatureFlags @(${featureFlags}) `;
 
         if (this.sessionSettings.integratedConsole.useLegacyReadLine) {
@@ -197,7 +197,7 @@ export class PowerShellProcess {
 
         // Check every 2 seconds
         for (let i = numOfTries; i > 0; i--) {
-            if (utils.checkIfFileExists(this.sessionFilePath)) {
+            if (utils.checkIfFileExists(this.sessionFilePath.fsPath)) {
                 this.log.write("Session file found");
                 const sessionDetails = SessionManager.readSessionFile(this.sessionFilePath);
                 SessionManager.deleteSessionFile(this.sessionFilePath);

src/session.ts

@@ -70,8 +70,7 @@ export class SessionManager implements Middleware {
     private languageServerClient: LanguageClient = undefined;
     private sessionSettings: Settings.ISettings = undefined;
     private sessionDetails: IEditorServicesSessionDetails;
-    private sessionsFolder = path.resolve(__dirname, "../sessions");
-    private sessionFilePathPrefix = path.resolve(this.sessionsFolder, "PSES-VSCode-" + process.env.VSCODE_PID);
+    private sessionsFolder: vscode.Uri;
     private bundledModulesPath: string;
     private started: boolean = false;
 
@@ -86,6 +85,12 @@ export class SessionManager implements Middleware {
         version: string,
         private telemetryReporter: TelemetryReporter) {
 
+        if (extensionContext.storageUri !== undefined) {
+            this.sessionsFolder = vscode.Uri.joinPath(extensionContext.storageUri, "sessions");
+        } else {
+            this.sessionsFolder = vscode.Uri.file(path.resolve(__dirname, "../sessions"));
+        }
+
         this.platformDetails = getPlatformDetails();
 
         this.HostName = hostName;
@@ -275,39 +280,35 @@ export class SessionManager implements Middleware {
         return this.versionDetails;
     }
 
-    private getSessionFilePath(uniqueId: number): string {
-        return `${this.sessionFilePathPrefix}-${uniqueId}`;
-    }
-
-    public getDebugSessionFilePath(): string {
-        return `${this.sessionFilePathPrefix}-Debug`;
+    public getNewSessionFilePath(): vscode.Uri {
+        const uniqueId: number = Math.floor(100000 + Math.random() * 900000);
+        return vscode.Uri.joinPath(this.sessionsFolder, "PSES-VSCode-" + process.env.VSCODE_PID + "-" + uniqueId + ".json");
     }
 
-    public async writeSessionFile(sessionFilePath: string, sessionDetails: IEditorServicesSessionDetails) {
-        await vscode.workspace.fs.createDirectory(vscode.Uri.file(this.sessionsFolder));
+    public async writeSessionFile(sessionFilePath: vscode.Uri, sessionDetails: IEditorServicesSessionDetails) {
+        await vscode.workspace.fs.createDirectory(this.sessionsFolder);
 
-        const writeStream = fs.createWriteStream(sessionFilePath);
+        const writeStream = fs.createWriteStream(sessionFilePath.fsPath);
         writeStream.write(JSON.stringify(sessionDetails));
         writeStream.close();
     }
 
-    public static readSessionFile(sessionFilePath: string): IEditorServicesSessionDetails {
+    public static readSessionFile(sessionFilePath: vscode.Uri): IEditorServicesSessionDetails {
         // TODO: Use vscode.workspace.fs.readFile instead of fs.readFileSync.
-        const fileContents = fs.readFileSync(sessionFilePath, "utf-8");
+        const fileContents = fs.readFileSync(sessionFilePath.fsPath, "utf-8");
         return JSON.parse(fileContents);
     }
 
-    public static async deleteSessionFile(sessionFilePath: string) {
+    public static async deleteSessionFile(sessionFilePath: vscode.Uri) {
         try {
-            await vscode.workspace.fs.delete(vscode.Uri.file(sessionFilePath));
-            // fs.unlinkSync(sessionFilePath);
+            await vscode.workspace.fs.delete(sessionFilePath);
         } catch (e) {
             // TODO: Be more specific about what we're catching
         }
     }
 
     public createDebugSessionProcess(
-        sessionPath: string,
+        sessionPath: vscode.Uri,
         sessionSettings: Settings.ISettings): PowerShellProcess {
 
         // NOTE: We only support one temporary integrated console at a time. To
@@ -492,9 +493,7 @@ export class SessionManager implements Middleware {
     private startPowerShell() {
         this.setSessionStatus("Starting...", SessionStatus.Initializing);
 
-        const sessionFilePath =
-            this.getSessionFilePath(
-                Math.floor(100000 + Math.random() * 900000));
+        const sessionFilePath = this.getNewSessionFilePath();
 
         this.languageServerProcess =
             new PowerShellProcess(

test/core/paths.test.ts

@@ -23,7 +23,7 @@ describe("Path assumptions", function () {
     });
 
     it("Creates the session folder at the correct path", function () {
-        assert(fs.existsSync(path.resolve(utils.rootPath, "sessions")));
+        assert(fs.existsSync(vscode.Uri.joinPath(storageUri, "sessions").fsPath));
     });
 
     it("Creates the log folder at the correct path", function () {