Update the code base to use IFileSystem instead of fs and fs-extra. (#7915)

(for #6911)

This is a precursor to the actual fix. It ensures that we really do use the new FS API everywhere.

Author: ericsnowcurrently

src/client/common/editor.ts

@@ -1,10 +1,10 @@
 import { Diff, diff_match_patch } from 'diff-match-patch';
-import * as fs from 'fs-extra';
 import { injectable } from 'inversify';
 import * as md5 from 'md5';
 import { EOL } from 'os';
 import * as path from 'path';
 import { Position, Range, TextDocument, TextEdit, Uri, WorkspaceEdit } from 'vscode';
+import { IFileSystem } from './platform/types';
 import { IEditorUtils } from './types';
 
 // Code borrowed from goFormat.ts (Go Extension for VS Code)
@@ -80,7 +80,11 @@ export function getTextEditsFromPatch(before: string, patch: string): TextEdit[]
 
     return textEdits;
 }
-export function getWorkspaceEditsFromPatch(filePatches: string[], workspaceRoot?: string): WorkspaceEdit {
+export function getWorkspaceEditsFromPatch(
+    filePatches: string[],
+    fs: IFileSystem,
+    workspaceRoot?: string
+): WorkspaceEdit {
     const workspaceEdit = new WorkspaceEdit();
     filePatches.forEach(patch => {
         const indexOfAtAt = patch.indexOf('@@');
@@ -107,7 +111,7 @@ export function getWorkspaceEditsFromPatch(filePatches: string[], workspaceRoot?
 
         let fileName = fileNameLines[0].substring(fileNameLines[0].indexOf(' a') + 3).trim();
         fileName = workspaceRoot && !path.isAbsolute(fileName) ? path.resolve(workspaceRoot, fileName) : fileName;
-        if (!fs.existsSync(fileName)) {
+        if (!fs.fileExistsSync(fileName)) {
             return;
         }
 
@@ -123,7 +127,7 @@ export function getWorkspaceEditsFromPatch(filePatches: string[], workspaceRoot?
             throw new Error('Unable to parse Patch string');
         }
 
-        const fileSource = fs.readFileSync(fileName).toString('utf8');
+        const fileSource = fs.readFileSync(fileName);
         const fileUri = Uri.file(fileName);
 
         // Add line feeds and build the text edits
@@ -226,24 +230,25 @@ function getTextEditsInternal(before: string, diffs: [number, string][], startLi
     return edits;
 }
 
-export function getTempFileWithDocumentContents(document: TextDocument): Promise<string> {
-    return new Promise<string>((resolve, reject) => {
-        const ext = path.extname(document.uri.fsPath);
-        // Don't create file in temp folder since external utilities
-        // look into configuration files in the workspace and are not able
-        // to find custom rules if file is saved in a random disk location.
-        // This means temp file has to be created in the same folder
-        // as the original one and then removed.
-
-        // tslint:disable-next-line:no-require-imports
-        const fileName = `${document.uri.fsPath}.${md5(document.uri.fsPath)}${ext}`;
-        fs.writeFile(fileName, document.getText(), ex => {
-            if (ex) {
-                reject(`Failed to create a temporary file, ${ex.message}`);
-            }
-            resolve(fileName);
-        });
-    });
+export async function getTempFileWithDocumentContents(
+    document: TextDocument,
+    fs: IFileSystem
+): Promise<string> {
+    // Don't create file in temp folder since external utilities
+    // look into configuration files in the workspace and are not able
+    // to find custom rules if file is saved in a random disk location.
+    // This means temp file has to be created in the same folder
+    // as the original one and then removed.
+
+    const ext = path.extname(document.uri.fsPath);
+    const filename = `${document.uri.fsPath}.${md5(document.uri.fsPath)}${ext}`;
+    await (
+        fs.writeFile(filename, document.getText())
+            .catch(err => {
+                throw Error(`Failed to create a temporary file, ${err.message}`);
+            })
+    );
+    return filename;
 }
 
 /**

src/client/common/envFileParser.ts

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import * as fs from 'fs';
 import { injectable } from 'inversify';
 import * as path from 'path';
 import * as vscode from 'vscode';
@@ -10,15 +9,18 @@ import { IServiceContainer } from '../../ioc/types';
 import { sendTelemetryEvent } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
 import { STANDARD_OUTPUT_CHANNEL } from '../constants';
+import { IFileSystem } from '../platform/types';
 import { ITerminalServiceFactory } from '../terminal/types';
 import { ExecutionInfo, IConfigurationService, IOutputChannel } from '../types';
-import { noop } from '../utils/misc';
 
 @injectable()
 export abstract class ModuleInstaller {
     public abstract get name(): string;
     public abstract get displayName(): string
-    constructor(protected serviceContainer: IServiceContainer) { }
+    constructor(
+        protected serviceContainer: IServiceContainer
+    ) { }
+
     public async installModule(name: string, resource?: vscode.Uri): Promise<void> {
         sendTelemetryEvent(EventName.PYTHON_INSTALL_PACKAGE, undefined, { installer: this.displayName });
         const executionInfo = await this.getExecutionInfo(name, resource);
@@ -38,7 +40,10 @@ export abstract class ModuleInstaller {
             if (!currentInterpreter || currentInterpreter.type !== InterpreterType.Unknown) {
                 await terminalService.sendCommand(pythonPath, args);
             } else if (settings.globalModuleInstallation) {
-                if (await this.isPathWritableAsync(path.dirname(pythonPath))) {
+                const dirname = path.dirname(pythonPath);
+                const fs = this.serviceContainer.get<IFileSystem>(IFileSystem);
+                const isWritable = ! await fs.isDirReadonly(dirname);
+                if (isWritable) {
                     await terminalService.sendCommand(pythonPath, args);
                 } else {
                     this.elevatedInstall(pythonPath, args);
@@ -50,8 +55,10 @@ export abstract class ModuleInstaller {
             await terminalService.sendCommand(executionInfo.execPath!, executionInfoArgs);
         }
     }
+
     public abstract isSupported(resource?: vscode.Uri): Promise<boolean>;
     protected abstract getExecutionInfo(moduleName: string, resource?: vscode.Uri): Promise<ExecutionInfo>;
+
     private async processInstallArgs(args: string[], resource?: vscode.Uri): Promise<string[]> {
         const indexOfPylint = args.findIndex(arg => arg.toUpperCase() === 'PYLINT');
         if (indexOfPylint === -1) {
@@ -69,19 +76,6 @@ export abstract class ModuleInstaller {
         }
         return args;
     }
-    private async isPathWritableAsync(directoryPath: string): Promise<boolean> {
-        const filePath = `${directoryPath}${path.sep}___vscpTest___`;
-        return new Promise<boolean>(resolve => {
-            fs.open(filePath, fs.constants.O_CREAT | fs.constants.O_RDWR, (error, fd) => {
-                if (!error) {
-                    fs.close(fd, () => {
-                        fs.unlink(filePath, noop);
-                    });
-                }
-                return resolve(!error);
-            });
-        });
-    }
 
     private elevatedInstall(execPath: string, args: string[]) {
         const options = {

src/client/common/installer/moduleInstaller.ts

@@ -3,12 +3,11 @@
 
 'use strict';
 
-import { WriteStream } from 'fs';
 import { inject, injectable } from 'inversify';
 import * as requestTypes from 'request';
 import { Progress, ProgressLocation } from 'vscode';
 import { IApplicationShell } from '../application/types';
-import { IFileSystem } from '../platform/types';
+import { IFileSystem, WriteStream } from '../platform/types';
 import { DownloadOptions, IFileDownloader, IHttpClient } from '../types';
 import { Http } from '../utils/localize';
 import { noop } from '../utils/misc';