Debounce credential prompts and check profile locks in more places

packages/zowe-explorer-api/src/profiles/AuthHandler.ts

@@ -34,11 +34,14 @@ export type AuthPromptParams = {
     authMethods: IAuthMethods;
     // Error encountered from API call
     imperativeError: imperative.ImperativeError;
+    // Whether to show the dialog as a modal
+    useModal?: boolean;
 };
 
 export type ProfileLike = string | imperative.IProfileLoaded;
 export class AuthHandler {
-    private static profileLocks: Map<string, Mutex> = new Map();
+    private static authPromptLocks = new Map<string, Mutex>();
+    private static profileLocks = new Map<string, Mutex>();
     private static enabledProfileTypes: Set<string> = new Set(["zosmf"]);
 
     /**
@@ -78,6 +81,7 @@ export class AuthHandler {
      */
     public static unlockProfile(profile: ProfileLike, refreshResources?: boolean): void {
         const profileName = AuthHandler.getProfileName(profile);
+        this.authPromptLocks.get(profileName)?.release();
         const mutex = this.profileLocks.get(profileName);
         // If a mutex doesn't exist for this profile or the mutex is no longer locked, return
         if (mutex == null || !mutex.isLocked()) {
@@ -99,6 +103,26 @@ export class AuthHandler {
         }
     }
 
+    /**
+     * Determines whether to handle an authentication error for a given profile.
+     * This uses a mutex to prevent additional authentication prompts until the first prompt is resolved.
+     * @param profileName The name of the profile to check
+     * @returns {boolean} Whether to handle the authentication error
+     */
+    public static async shouldHandleAuthError(profileName: string): Promise<boolean> {
+        if (!this.authPromptLocks.has(profileName)) {
+            this.authPromptLocks.set(profileName, new Mutex());
+        }
+
+        const mutex = this.authPromptLocks.get(profileName);
+        if (mutex.isLocked()) {
+            return false;
+        }
+
+        await mutex.acquire();
+        return true;
+    }
+
     /**
      * Prompts the user to authenticate over SSO or a credential prompt in the event of an error.
      * @param profile The profile to authenticate
@@ -114,7 +138,7 @@ export class AuthHandler {
                 const message = "Log in to Authentication Service";
                 const userResp = await Gui.showMessage(params.errorCorrelation?.message ?? params.imperativeError.message, {
                     items: [message],
-                    vsCodeOpts: { modal: true },
+                    vsCodeOpts: { modal: params.useModal },
                 });
                 if (userResp === message && (await params.authMethods.ssoLogin(null, profileName))) {
                     // Unlock profile so it can be used again
@@ -129,7 +153,7 @@ export class AuthHandler {
         const checkCredsButton = "Update Credentials";
         const creds = await Gui.errorMessage(params.errorCorrelation?.message ?? params.imperativeError.message, {
             items: [checkCredsButton],
-            vsCodeOpts: { modal: true },
+            vsCodeOpts: { modal: params.useModal },
         }).then(async (selection) => {
             if (selection !== checkCredsButton) {
                 return;
@@ -194,7 +218,35 @@ export class AuthHandler {
             return;
         }
 
-        return this.profileLocks.get(profileName)?.waitForUnlock();
+        const mutex = this.profileLocks.get(profileName);
+        // If the mutex isn't locked, no need to wait
+        if (!mutex.isLocked()) {
+            return;
+        }
+
+        // Wait for the mutex to be unlocked with a timeout to prevent indefinite waiting
+        const timeoutMs = 30000; // 30 seconds timeout
+        const timeoutPromise = new Promise<void>((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Timeout waiting for profile ${profileName} to be unlocked`));
+            }, timeoutMs);
+        });
+
+        try {
+            await Promise.race([mutex.waitForUnlock(), timeoutPromise]);
+
+            // Add a small delay after unlock to ensure credentials are fully updated
+            // before allowing multiple requests to proceed
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        } catch (error) {
+            // If we hit the timeout, log it but don't throw to allow operation to continue
+            if (error instanceof Error && error.message.includes("Timeout waiting for profile")) {
+                // Log the timeout but continue - we'll use a no-op since we don't have access to the logger in the API
+                // This is acceptable since this is just a fallback for an edge case where the user did not respond to a credential prompt in time
+            } else {
+                throw error;
+            }
+        }
     }
 
     /**

packages/zowe-explorer/src/trees/dataset/DatasetFSProvider.ts

@@ -89,26 +89,38 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
         }
 
         ZoweLogger.trace(`[DatasetFSProvider] stat is locating resource ${uri.toString()}`);
+        const profile = Profiles.getInstance().loadNamedProfile(uriInfo.profile.name);
 
         // Locate the resource using the profile in the given URI.
         let resp;
         const isPdsMember = !FsDatasetsUtils.isPdsEntry(entry) && (entry as DsEntry).isMember;
         try {
+            // Wait for any ongoing authentication process to complete
+            await AuthHandler.waitForUnlock(uriInfo.profile);
+
+            // Check if the profile is locked (indicating an auth error is being handled)
+            // If it's locked, we should wait and not make additional requests
+            if (AuthHandler.isProfileLocked(uriInfo.profile)) {
+                ZoweLogger.debug(`[DatasetFSProvider] Profile ${uriInfo.profile.name} is locked, waiting for authentication`);
+                return entry;
+            }
+
             if (isPdsMember) {
                 // PDS member
                 const pds = this._lookupParentDirectory(uri);
-                resp = await ZoweExplorerApiRegister.getMvsApi(uriInfo.profile).allMembers(pds.name, { attributes: true });
+                resp = await ZoweExplorerApiRegister.getMvsApi(profile).allMembers(pds.name, { attributes: true });
             } else {
                 // Data Set
                 const dsPath = (entry.metadata as DsEntryMetadata).extensionRemovedFromPath();
-                resp = await ZoweExplorerApiRegister.getMvsApi(uriInfo.profile).dataSet(path.posix.basename(dsPath), {
+                resp = await ZoweExplorerApiRegister.getMvsApi(profile).dataSet(path.posix.basename(dsPath), {
                     attributes: true,
                 });
             }
         } catch (err) {
             if (err instanceof Error) {
                 ZoweLogger.error(err.message);
             }
+            await AuthUtils.handleProfileAuthOnError(err, profile);
             throw err;
         }
 
@@ -133,7 +145,18 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
     private async fetchEntriesForProfile(uri: vscode.Uri, uriInfo: UriFsInfo, pattern: string): Promise<FilterEntry> {
         const profileEntry = this._lookupAsDirectory(uri, false) as FilterEntry;
 
-        const mvsApi = ZoweExplorerApiRegister.getMvsApi(uriInfo.profile);
+        // Wait for any ongoing authentication process to complete
+        await AuthHandler.waitForUnlock(uriInfo.profile);
+
+        // Check if the profile is locked (indicating an auth error is being handled)
+        // If it's locked, we should wait and not make additional requests
+        if (AuthHandler.isProfileLocked(uriInfo.profile)) {
+            ZoweLogger.debug(`[DatasetFSProvider] Profile ${uriInfo.profile.name} is locked, waiting for authentication`);
+            return profileEntry;
+        }
+
+        const profile = Profiles.getInstance().loadNamedProfile(uriInfo.profile.name);
+        const mvsApi = ZoweExplorerApiRegister.getMvsApi(profile);
         const datasetResponses: IZosFilesResponse[] = [];
         const dsPatterns = [
             ...new Set(
@@ -153,6 +176,7 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
                 }
             }
         } catch (err) {
+            await AuthUtils.handleProfileAuthOnError(err, uriInfo.profile);
             this._handleError(err, {
                 additionalContext: vscode.l10n.t("Failed to list datasets"),
                 retry: {
@@ -196,8 +220,18 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
     private async fetchEntriesForDataset(entry: PdsEntry, uri: vscode.Uri, uriInfo: UriFsInfo): Promise<void> {
         let members: IZosFilesResponse;
         try {
+            // Wait for any ongoing authentication process to complete
             await AuthHandler.waitForUnlock(entry.metadata.profile);
-            members = await ZoweExplorerApiRegister.getMvsApi(uriInfo.profile).allMembers(path.posix.basename(uri.path));
+
+            // Check if the profile is locked (indicating an auth error is being handled)
+            // If it's locked, we should wait and not make additional requests
+            if (AuthHandler.isProfileLocked(entry.metadata.profile)) {
+                ZoweLogger.debug(`[DatasetFSProvider] Profile ${entry.metadata.profile.name} is locked, waiting for authentication`);
+                return;
+            }
+
+            const profile = Profiles.getInstance().loadNamedProfile(entry.metadata.profile.name);
+            members = await ZoweExplorerApiRegister.getMvsApi(profile).allMembers(path.posix.basename(uri.path));
         } catch (err) {
             await AuthUtils.handleProfileAuthOnError(err, uriInfo.profile);
             throw err;
@@ -230,10 +264,25 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
         // /DATA.SET/MEMBER
         const uriPath = uri.path.substring(uriInfo.slashAfterProfilePos + 1).split("/");
         const pdsMember = uriPath.length === 2;
+
+        // Wait for any ongoing authentication process to complete
+        await AuthHandler.waitForUnlock(uriInfo.profile);
+
+        // Check if the profile is locked (indicating an auth error is being handled)
+        // If it's locked, we should wait and not make additional requests
+        if (AuthHandler.isProfileLocked(uriInfo.profile)) {
+            ZoweLogger.debug(`[DatasetFSProvider] Profile ${uriInfo.profile.name} is locked, waiting for authentication`);
+            if (entryExists) {
+                return entry;
+            }
+            throw vscode.FileSystemError.FileNotFound(uri);
+        }
+
         if (!entryExists) {
             try {
+                const profile = Profiles.getInstance().loadNamedProfile(uriInfo.profile.name);
                 if (pdsMember) {
-                    const resp = await ZoweExplorerApiRegister.getMvsApi(uriInfo.profile).allMembers(uriPath[0]);
+                    const resp = await ZoweExplorerApiRegister.getMvsApi(profile).allMembers(uriPath[0]);
                     entryIsDir = false;
                     const memberName = path.parse(uriPath[1]).name;
                     if (
@@ -244,7 +293,7 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
                         throw vscode.FileSystemError.FileNotFound(uri);
                     }
                 } else {
-                    const resp = await ZoweExplorerApiRegister.getMvsApi(uriInfo.profile).dataSet(uriPath[0], {
+                    const resp = await ZoweExplorerApiRegister.getMvsApi(profile).dataSet(uriPath[0], {
                         attributes: true,
                     });
                     if (resp.success && resp.apiResponse?.items?.length > 0) {
@@ -257,6 +306,7 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
                 if (err instanceof Error) {
                     ZoweLogger.error(err.message);
                 }
+                await AuthUtils.handleProfileAuthOnError(err, uriInfo.profile);
                 throw err;
             }
         }
@@ -382,14 +432,23 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
         let dsEntry = this._lookupAsFile(uri, { silent: true }) as DsEntry | undefined;
         const bufBuilder = new BufferBuilder();
         const metadata = dsEntry?.metadata ?? this._getInfoFromUri(uri);
-        const profile = Profiles.getInstance().loadNamedProfile(dsEntry?.metadata.profile.name);
+        const profile = Profiles.getInstance().loadNamedProfile(metadata.profile.name);
         const profileEncoding = dsEntry?.encoding ? null : profile.profile?.encoding; // use profile encoding rather than metadata encoding
         try {
+            // Wait for any ongoing authentication process to complete
             await AuthHandler.waitForUnlock(metadata.profile);
-            const resp = await ZoweExplorerApiRegister.getMvsApi(metadata.profile).getContents(metadata.dsName, {
+
+            // Check if the profile is locked (indicating an auth error is being handled)
+            // If it's locked, we should wait and not make additional requests
+            if (AuthHandler.isProfileLocked(metadata.profile)) {
+                ZoweLogger.debug(`[DatasetFSProvider] Profile ${metadata.profile.name} is locked, waiting for authentication`);
+                return null;
+            }
+
+            const resp = await ZoweExplorerApiRegister.getMvsApi(profile).getContents(metadata.dsName, {
                 binary: dsEntry?.encoding?.kind === "binary",
                 encoding: dsEntry?.encoding?.kind === "other" ? dsEntry?.encoding.codepage : profileEncoding,
-                responseTimeout: metadata.profile.profile?.responseTimeout,
+                responseTimeout: profile.profile?.responseTimeout,
                 returnEtag: true,
                 stream: bufBuilder,
             });