@azure/msal-node-extensions 1.0.0-alpha.2 → 1.0.0-alpha.20

package/src/lock/CrossPlatformLock.ts

@@ -1,82 +1,89 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { promises as fs } from "fs"
-import { pid } from "process";
-import { CrossPlatformLockOptions } from "./CrossPlatformLockOptions";
-import { Constants } from "../utils/Constants";
-import { PersistenceError } from "../error/PersistenceError";
-import { Logger } from "@azure/msal-common";
-
-/**
- * Cross-process lock that works on all platforms.
- */
-export class CrossPlatformLock {
-
-    private readonly lockFilePath: string;
-    private lockFileHandle: fs.FileHandle;
-    private readonly retryNumber: number;
-    private readonly retryDelay: number;
-
-    private logger: Logger;
-
-    constructor(lockFilePath: string, logger: Logger, lockOptions?: CrossPlatformLockOptions) {
-        this.lockFilePath = lockFilePath;
-        this.retryNumber = lockOptions ? lockOptions.retryNumber : 500;
-        this.retryDelay = lockOptions ? lockOptions.retryDelay : 100;
-        this.logger = logger;
-    }
-
-    /**
-     * Locks cache from read or writes by creating file with same path and name as
-     * cache file but with .lockfile extension. If another process has already created
-     * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
-     */
-    public async lock(): Promise<void> {
-        for (let tryCount = 0; tryCount < this.retryNumber; tryCount++) {
-            try {
-                this.logger.info(`Pid ${pid} trying to acquire lock`);
-                this.lockFileHandle = await fs.open(this.lockFilePath, "wx+");
-
-                this.logger.info(`Pid ${pid} acquired lock`);
-                await this.lockFileHandle.write(pid.toString());
-                return;
-            } catch (err) {
-                if (err.code == Constants.EEXIST_ERROR) {
-                    this.logger.info(err);
-                    await this.sleep(this.retryDelay);
-                } else {
-                    throw PersistenceError.createCrossPlatformLockError(err.code, err.message);
-                }
-            }
-        }
-        throw PersistenceError.createCrossPlatformLockError(
-            "Exceeded retry options",
-            "Not able to acquire lock. Exceeded amount of retries set in options");
-    }
-
-    /**
-     * unlocks cache file by deleting .lockfile.
-     */
-    public async unlock(): Promise<void> {
-        try {
-            // delete lock file
-            await fs.unlink(this.lockFilePath);
-            await this.lockFileHandle.close();
-        } catch (err) {
-            if (err.code == Constants.ENOENT_ERROR) {
-                this.logger.warning("Tried to unlock but Lockfile does not exist");
-            } else {
-                throw PersistenceError.createCrossPlatformLockError(err.code, err.message);
-            }
-        }
-    }
-
-    private sleep(ms): Promise<void> {
-        return new Promise((resolve) => {
-            setTimeout(resolve, ms);
-        });
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "fs";
+import { pid } from "process";
+import { CrossPlatformLockOptions } from "./CrossPlatformLockOptions";
+import { Constants } from "../utils/Constants";
+import { PersistenceError } from "../error/PersistenceError";
+import { Logger } from "@azure/msal-common";
+
+/**
+ * Cross-process lock that works on all platforms.
+ */
+export class CrossPlatformLock {
+
+    private readonly lockFilePath: string;
+    private lockFileHandle: fs.FileHandle;
+    private readonly retryNumber: number;
+    private readonly retryDelay: number;
+
+    private logger: Logger;
+
+    constructor(lockFilePath: string, logger: Logger, lockOptions?: CrossPlatformLockOptions) {
+        this.lockFilePath = lockFilePath;
+        this.retryNumber = lockOptions ? lockOptions.retryNumber : 500;
+        this.retryDelay = lockOptions ? lockOptions.retryDelay : 100;
+        this.logger = logger;
+    }
+
+    /**
+     * Locks cache from read or writes by creating file with same path and name as
+     * cache file but with .lockfile extension. If another process has already created
+     * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
+     */
+    public async lock(): Promise<void> {
+        for (let tryCount = 0; tryCount < this.retryNumber; tryCount++) {
+            try {
+                this.logger.info(`Pid ${pid} trying to acquire lock`);
+                this.lockFileHandle = await fs.open(this.lockFilePath, "wx+");
+
+                this.logger.info(`Pid ${pid} acquired lock`);
+                await this.lockFileHandle.write(pid.toString());
+                return;
+            } catch (err) {
+                if (err.code === Constants.EEXIST_ERROR || err.code === Constants.EPERM_ERROR) {
+                    this.logger.info(err);
+                    await this.sleep(this.retryDelay);
+                } else {
+                    this.logger.error(`${pid} was not able to acquire lock. Ran into error: ${err.message}`);
+                    throw PersistenceError.createCrossPlatformLockError(err.message);
+                }
+            }
+        }
+        this.logger.error(`${pid} was not able to acquire lock. Exceeded amount of retries set in the options`);
+        throw PersistenceError.createCrossPlatformLockError(
+            "Not able to acquire lock. Exceeded amount of retries set in options");
+    }
+
+    /**
+     * unlocks cache file by deleting .lockfile.
+     */
+    public async unlock(): Promise<void> {
+        try {
+            if(this.lockFileHandle){
+                // if we have a file handle to the .lockfile, delete lock file
+                await fs.unlink(this.lockFilePath);
+                await this.lockFileHandle.close();
+                this.logger.info("lockfile deleted");
+            } else {
+                this.logger.warning("lockfile handle does not exist, so lockfile could not be deleted");
+            }
+        } catch (err) {
+            if (err.code === Constants.ENOENT_ERROR) {
+                this.logger.info("Tried to unlock but lockfile does not exist");
+            } else {
+                this.logger.error(`${pid} was not able to release lock. Ran into error: ${err.message}`);
+                throw PersistenceError.createCrossPlatformLockError(err.message);
+            }
+        }
+    }
+
+    private sleep(ms): Promise<void> {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+}

package/src/lock/CrossPlatformLockOptions.ts

@@ -1,15 +1,15 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Options for CrossPlatform lock.
- *
- * retryNumber: Numbers of times we should try to acquire a lock. Defaults to 500.
- * retryDelay: Time to wait before trying to retry a lock acquisition. Defaults to 100 ms.
- */
-export type CrossPlatformLockOptions = {
-    retryNumber: number;
-    retryDelay: number;
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Options for CrossPlatform lock.
+ *
+ * retryNumber: Numbers of times we should try to acquire a lock. Defaults to 500.
+ * retryDelay: Time to wait before trying to retry a lock acquisition. Defaults to 100 ms.
+ */
+export type CrossPlatformLockOptions = {
+    retryNumber: number;
+    retryDelay: number;
+};

package/src/persistence/BasePersistence.ts

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { PersistenceError } from "../error/PersistenceError";
+import { Constants } from "../utils/Constants";
+import { IPersistence } from "./IPersistence";
+
+export abstract class BasePersistence {
+    public abstract createForPersistenceValidation(): Promise<IPersistence>; 
+
+    public async verifyPersistence(): Promise<boolean> {
+        // We are using a different location for the test to avoid overriding the functional cache
+        const persistenceValidator = await this.createForPersistenceValidation();
+
+        try {
+            await persistenceValidator.save(Constants.PERSISTENCE_TEST_DATA);
+
+            const retrievedDummyData = await persistenceValidator.load();
+
+            if (!retrievedDummyData) {
+                throw PersistenceError.createCachePersistenceError(
+                    "Persistence check failed. Data was written but it could not be read. " +
+                    "Possible cause: on Linux, LibSecret is installed but D-Bus isn't running because it cannot be started over SSH."
+                );
+            }
+
+            if (retrievedDummyData !== Constants.PERSISTENCE_TEST_DATA) {
+                throw PersistenceError.createCachePersistenceError(
+                    `Persistence check failed. Data written ${Constants.PERSISTENCE_TEST_DATA} is different from data read ${retrievedDummyData}`
+                );
+            }
+            await persistenceValidator.delete();
+            return true;
+        } catch (e) {
+            throw PersistenceError.createCachePersistenceError(`Verifing persistence failed with the error: ${e}`);
+        }
+    }
+
+}

package/src/persistence/DataProtectionScope.ts

@@ -1,20 +1,20 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Specifies the scope of the data protection - either the current user or the local
- * machine.
- *
- * You do not need a key to protect or unprotect the data.
- * If you set the Scope to CurrentUser, only applications running on your credentials can
- * unprotect the data; however, that means that any application running on your credentials
- * can access the protected data. If you set the Scope to LocalMachine, any full-trust
- * application on the computer can unprotect, access, and modify the data.
- *
- */
-export enum DataProtectionScope {
-    CurrentUser = "CurrentUser",
-    LocalMachine = "LocalMachine",
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Specifies the scope of the data protection - either the current user or the local
+ * machine.
+ *
+ * You do not need a key to protect or unprotect the data.
+ * If you set the Scope to CurrentUser, only applications running on your credentials can
+ * unprotect the data; however, that means that any application running on your credentials
+ * can access the protected data. If you set the Scope to LocalMachine, any full-trust
+ * application on the computer can unprotect, access, and modify the data.
+ *
+ */
+export enum DataProtectionScope {
+    CurrentUser = "CurrentUser",
+    LocalMachine = "LocalMachine",
+}

package/src/persistence/FilePersistence.ts

@@ -1,134 +1,140 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { promises as fs } from "fs"
-import { dirname } from "path";
-import { IPersistence } from "./IPersistence";
-import { Constants } from "../utils/Constants";
-import { PersistenceError } from "../error/PersistenceError";
-import { Logger, LoggerOptions, LogLevel } from "@azure/msal-common";
-
-/**
- * Reads and writes data to file specified by file location. File contents are not
- * encrypted.
- *
- * If file or directory has not been created, it FilePersistence.create() will create
- * file and any directories in the path recursively.
- */
-export class FilePersistence implements IPersistence {
-
-    private filePath: string;
-    private logger: Logger;
-
-    public static async create(fileLocation: string, loggerOptions?: LoggerOptions): Promise<FilePersistence> {
-        const filePersistence = new FilePersistence();
-        filePersistence.filePath = fileLocation;
-        filePersistence.logger = new Logger(loggerOptions || FilePersistence.createDefaultLoggerOptions());
-        await filePersistence.createCacheFile();
-        return filePersistence;
-    }
-
-    public async save(contents: string): Promise<void> {
-        try {
-            await fs.writeFile(this.getFilePath(), contents, "utf-8");
-        } catch (err) {
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    public async saveBuffer(contents: Uint8Array): Promise<void> {
-        try {
-            await fs.writeFile(this.getFilePath(), contents);
-        } catch (err) {
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    public async load(): Promise<string> {
-        try {
-            return await fs.readFile(this.getFilePath(), "utf-8");
-        } catch (err) {
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    };
-
-    public async loadBuffer(): Promise<Uint8Array> {
-        try {
-            return await fs.readFile(this.getFilePath());
-        } catch (err) {
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    };
-
-    public async delete(): Promise<boolean> {
-        try {
-            await fs.unlink(this.getFilePath());
-            return true;
-        } catch (err) {
-            if (err.code == Constants.ENOENT_ERROR) {
-                // file does not exist, so it was not deleted
-                this.logger.warning("Cache file does not exist, so it could not be deleted");
-                return false;
-            }
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    public getFilePath(): string {
-        return this.filePath;
-    }
-
-    public async reloadNecessary(lastSync: number): Promise<boolean> {
-        return lastSync < await this.timeLastModified();
-    }
-
-    public getLogger(): Logger {
-        return this.logger;
-    }
-
-    private static createDefaultLoggerOptions(): LoggerOptions {
-        return {
-            loggerCallback: () => {
-                // allow users to not set loggerCallback
-            },
-            piiLoggingEnabled: false,
-            logLevel: LogLevel.Info
-        }
-    }
-
-    private async timeLastModified(): Promise<number> {
-        try {
-            const stats = await fs.stat(this.filePath);
-            return stats.mtime.getTime();
-        } catch (err) {
-            if (err.code == Constants.ENOENT_ERROR) {
-                // file does not exist, so it's never been modified
-                this.logger.verbose("Cache file does not exist");
-                return 0;
-            }
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    private async createCacheFile(): Promise<void> {
-        await this.createFileDirectory();
-        // File is created only if it does not exist
-        const fileHandle = await fs.open(this.filePath, "a");
-        await fileHandle.close();
-        this.logger.info(`File created at ${this.filePath}`);
-    }
-
-    private async createFileDirectory(): Promise<void> {
-        try {
-            await fs.mkdir(dirname(this.filePath), {recursive: true});
-        } catch (err) {
-            if (err.code == Constants.EEXIST_ERROR) {
-                this.logger.info(`Directory ${dirname(this.filePath)}  already exists`);
-            } else {
-                throw PersistenceError.createFileSystemError(err.code, err.message);
-            }
-        }
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "fs";
+import { dirname } from "path";
+import { IPersistence } from "./IPersistence";
+import { Constants } from "../utils/Constants";
+import { PersistenceError } from "../error/PersistenceError";
+import { Logger, LoggerOptions, LogLevel } from "@azure/msal-common";
+import { BasePersistence } from "./BasePersistence";
+
+/**
+ * Reads and writes data to file specified by file location. File contents are not
+ * encrypted.
+ *
+ * If file or directory has not been created, it FilePersistence.create() will create
+ * file and any directories in the path recursively.
+ */
+export class FilePersistence extends BasePersistence implements IPersistence {
+
+    private filePath: string;
+    private logger: Logger;
+
+    public static async create(fileLocation: string, loggerOptions?: LoggerOptions): Promise<FilePersistence> {
+        const filePersistence = new FilePersistence();
+        filePersistence.filePath = fileLocation;
+        filePersistence.logger = new Logger(loggerOptions || FilePersistence.createDefaultLoggerOptions());
+        await filePersistence.createCacheFile();
+        return filePersistence;
+    }
+
+    public async save(contents: string): Promise<void> {
+        try {
+            await fs.writeFile(this.getFilePath(), contents, "utf-8");
+        } catch (err) {
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public async saveBuffer(contents: Uint8Array): Promise<void> {
+        try {
+            await fs.writeFile(this.getFilePath(), contents);
+        } catch (err) {
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public async load(): Promise<string | null> {
+        try {
+            return await fs.readFile(this.getFilePath(), "utf-8");
+        } catch (err) {
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public async loadBuffer(): Promise<Uint8Array> {
+        try {
+            return await fs.readFile(this.getFilePath());
+        } catch (err) {
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public async delete(): Promise<boolean> {
+        try {
+            await fs.unlink(this.getFilePath());
+            return true;
+        } catch (err) {
+            if (err.code === Constants.ENOENT_ERROR) {
+                // file does not exist, so it was not deleted
+                this.logger.warning("Cache file does not exist, so it could not be deleted");
+                return false;
+            }
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public getFilePath(): string {
+        return this.filePath;
+    }
+
+    public async reloadNecessary(lastSync: number): Promise<boolean> {
+        return lastSync < await this.timeLastModified();
+    }
+
+    public getLogger(): Logger {
+        return this.logger;
+    }
+
+    public createForPersistenceValidation(): Promise<FilePersistence> {
+        const testCacheFileLocation = `${dirname(this.filePath)}/test.cache`;
+        return FilePersistence.create(testCacheFileLocation);
+    }
+
+    private static createDefaultLoggerOptions(): LoggerOptions {
+        return {
+            loggerCallback: () => {
+                // allow users to not set loggerCallback
+            },
+            piiLoggingEnabled: false,
+            logLevel: LogLevel.Info
+        };
+    }
+
+    private async timeLastModified(): Promise<number> {
+        try {
+            const stats = await fs.stat(this.filePath);
+            return stats.mtime.getTime();
+        } catch (err) {
+            if (err.code === Constants.ENOENT_ERROR) {
+                // file does not exist, so it's never been modified
+                this.logger.verbose("Cache file does not exist");
+                return 0;
+            }
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    private async createCacheFile(): Promise<void> {
+        await this.createFileDirectory();
+        // File is created only if it does not exist
+        const fileHandle = await fs.open(this.filePath, "a");
+        await fileHandle.close();
+        this.logger.info(`File created at ${this.filePath}`);
+    }
+
+    private async createFileDirectory(): Promise<void> {
+        try {
+            await fs.mkdir(dirname(this.filePath), {recursive: true});
+        } catch (err) {
+            if (err.code === Constants.EEXIST_ERROR) {
+                this.logger.info(`Directory ${dirname(this.filePath)}  already exists`);
+            } else {
+                throw PersistenceError.createFileSystemError(err.code, err.message);
+            }
+        }
+    }
+}