appium-remote-debugger 14.0.2 → 14.0.4

package/lib/mixins/execute.js

@@ -12,7 +12,6 @@ import _ from 'lodash';
 import {
   getAppIdKey,
   getPageIdKey,
-  getPageLoading,
   getGarbageCollectOnExecute,
 } from './property-accessors';
 
@@ -31,7 +30,7 @@ const RPC_RESPONSE_TIMEOUT_MS = 5000;
 export async function executeAtom (atom, args = [], frames = []) {
   this.log.debug(`Executing atom '${atom}' with 'args=${JSON.stringify(args)}; frames=${frames}'`);
   const script = await getScriptForAtom(atom, args, frames);
-  const value = await this.execute(script, true);
+  const value = await this.execute(script);
   this.log.debug(`Received result for atom '${atom}' execution: ${_.truncate(simpleStringify(value), {length: RESPONSE_LOG_LENGTH})}`);
   return value;
 }
@@ -130,16 +129,11 @@ export async function executeAtomAsync (atom, args = [], frames = []) {
 /**
  * @this {RemoteDebugger}
  * @param {string} command
- * @param {boolean} [override]
+ * @param {boolean} [override] - Deprecated and unused
  * @returns {Promise<any>}
  */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function execute (command, override) {
-  // if the page is not loaded yet, wait for it
-  if (getPageLoading(this) && !override) {
-    this.log.debug('Trying to execute but page is not loaded.');
-    await this.waitForDom();
-  }
-
   const {appIdKey, pageIdKey} = checkParams({
     appIdKey: getAppIdKey(this),
     pageIdKey: getPageIdKey(this),

package/lib/mixins/navigate.js

@@ -73,12 +73,9 @@ export function isPageLoadingCompleted (readyState) {
  * @returns {Promise<void>}
  */
 export async function waitForDom (startPageLoadTimer) {
-  this.log.debug('Waiting for page readiness');
   const readinessTimeoutMs = this.pageLoadMs;
-  if (!_.isFunction(startPageLoadTimer?.getDuration)) {
-    this.log.debug(`Page load timer not a timer. Creating new timer`);
-    startPageLoadTimer = new timing.Timer().start();
-  }
+  this.log.debug(`Waiting up to ${readinessTimeoutMs}ms for the page to be ready`);
+  const timer = startPageLoadTimer ?? new timing.Timer().start();
 
   let isPageLoading = true;
   setPageLoading(this, true);
@@ -88,8 +85,7 @@ export async function waitForDom (startPageLoadTimer) {
     let retry = 0;
     while (isPageLoading) {
       // if we are ready, or we've spend too much time on this
-      // @ts-ignore startPageLoadTimer is defined here
-      const elapsedMs = startPageLoadTimer.getDuration().asMilliSeconds;
+      const elapsedMs = timer.getDuration().asMilliSeconds;
       // exponential retry
       const intervalMs = Math.min(
         PAGE_READINESS_CHECK_INTERVAL_MS * Math.pow(2, retry),
@@ -105,7 +101,8 @@ export async function waitForDom (startPageLoadTimer) {
         return;
       }
 
-      if (await this.checkPageIsReady()) {
+      const maxWaitMs = (readinessTimeoutMs - elapsedMs) * 0.95;
+      if (await this.checkPageIsReady(maxWaitMs)) {
         if (isPageLoading) {
           this.log.debug(`Page is ready in ${elapsedMs}ms`);
           isPageLoading = false;
@@ -113,7 +110,9 @@ export async function waitForDom (startPageLoadTimer) {
         return;
       }
       if (elapsedMs > readinessTimeoutMs) {
-        this.log.info(`Timed out after ${readinessTimeoutMs}ms of waiting for the page readiness. Continuing anyway`);
+        this.log.info(
+          `Timed out after ${readinessTimeoutMs}ms of waiting for the page readiness. Continuing anyway`
+        );
         isPageLoading = false;
         return;
       }
@@ -145,16 +144,21 @@ export async function checkPageIsReady (timeoutMs) {
   const readyCmd = 'document.readyState;';
   const actualTimeoutMs = timeoutMs ?? getPageReadyTimeout(this);
   try {
-    const readyState = await B.resolve(this.execute(readyCmd, true))
+    const readyState = await B.resolve(this.execute(readyCmd))
       .timeout(actualTimeoutMs);
-    this.log.debug(`Document readyState is '${readyState}'. ` +
-      `The pageLoadStrategy is '${getPageLoadStartegy(this) ?? PAGE_LOAD_STRATEGY.NORMAL}'`);
+    this.log.debug(
+      JSON.stringify({
+        readyState,
+        pageLoadStrategy: getPageLoadStartegy(this) ?? PAGE_LOAD_STRATEGY.NORMAL,
+      })
+    );
     return this.isPageLoadingCompleted(readyState);
   } catch (err) {
-    if (!(err instanceof BTimeoutError)) {
-      throw err;
+    if (err instanceof BTimeoutError) {
+      this.log.debug(`Page readiness check timed out after ${actualTimeoutMs}ms`);
+    } else {
+      this.log.warn(`Page readiness check has failed. Original error: ${err.message}`);
     }
-    this.log.debug(`Page readiness check timed out after ${actualTimeoutMs}ms`);
     return false;
   }
 }

package/lib/rpc/rpc-client.js

@@ -10,6 +10,9 @@ import AsyncLock from 'async-lock';
 
 const DATA_LOG_LENGTH = {length: 200};
 const MIN_WAIT_FOR_TARGET_TIMEOUT_MS = 30000;
+// Sometimes page initialization can take a long time, especially in slow CI environments,
+// although we still should not allow it to take forever
+const PAGE_INIT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
 const WAIT_FOR_TARGET_INTERVAL_MS = 100;
 const MIN_PLATFORM_FOR_TARGET_BASED = '12.2';
 // `Target.exists` protocol method was removed from WebKit in 13.4
@@ -409,7 +412,7 @@ export class RpcClient {
         messageHandled = false;
         // do not log receipts
         // @ts-ignore messageHandler must be defined
-        this.messageHandler.once(msgId.toString(), function (err) {
+        this.messageHandler.once(msgId.toString(), (err) => {
           if (err) {
             // we are not waiting for this, and if it errors it is most likely
             // a protocol change. Log and check during testing
@@ -426,7 +429,7 @@ export class RpcClient {
       // @ts-ignore messageHandler must be defined
       } else if (this.messageHandler.listeners(cmd.__selector).length) {
         // @ts-ignore messageHandler must be defined
-        this.messageHandler.prependOnceListener(cmd.__selector, function (err, ...args) {
+        this.messageHandler.prependOnceListener(cmd.__selector, (err, ...args) => {
           if (err) {
             return reject(err);
           }
@@ -436,7 +439,7 @@ export class RpcClient {
         });
       } else if (hasSocketData) {
         // @ts-ignore messageHandler must be defined
-        this.messageHandler.once(msgId.toString(), function (err, value) {
+        this.messageHandler.once(msgId.toString(), (err, value) => {
           if (err) {
             return reject(new Error(`Remote debugger error with code '${err.code}': ${err.message}`));
           }
@@ -521,52 +524,74 @@ export class RpcClient {
       return;
     }
 
+    const pageInitTimeoutMs = Math.max(this.pageLoadTimeoutMs ?? 0, PAGE_INIT_TIMEOUT_MS);
+    if (!_.isPlainObject(this.targets[appIdKey])) {
+      this.targets[appIdKey] = {
+        lock: new AsyncLock({maxOccupationTime: pageInitTimeoutMs}),
+      };
+    }
+    const timer = new timing.Timer().start();
+
     if (targetInfo.isProvisional) {
       log.debug(
-        `Provisional target created for app '${appIdKey}' and page '${pageIdKey}': '${targetInfo.targetId}'`
+        `Provisional target created for app '${appIdKey}' and page '${pageIdKey}': '${JSON.stringify(targetInfo)}'`
       );
-      if (!targetInfo.isPaused) {
-        return;
-      }
 
-      log.debug(`The target ${targetInfo.targetId}@${appIdKey} is paused`);
-      const appTargetsMap = this.targets[appIdKey];
-      if (appTargetsMap) {
-        await appTargetsMap.lock.acquire(toLockKey(appIdKey, pageIdKey), async () => {
+      try {
+        await this.targets[appIdKey].lock.acquire(targetInfo.targetId, async () => {
           try {
             await this._initializePage(appIdKey, pageIdKey, targetInfo.targetId);
           } finally {
-            await this._resumeTarget(appIdKey, pageIdKey, targetInfo.targetId);
+            if (targetInfo.isPaused) {
+              await this._resumeTarget(appIdKey, pageIdKey, targetInfo.targetId);
+            } else {
+              log.debug(
+                `Provisional target ${targetInfo.targetId}@${appIdKey} is not paused. This might be a problem`
+              );
+            }
           }
         });
+      } catch (e) {
+        log.warn(
+          `Cannot complete the initialization of the provisional target '${targetInfo.targetId}' ` +
+          `after ${timer.getDuration().asMilliSeconds}ms: ${e.message}`
+        );
       }
       return;
     }
 
     log.debug(`Target created for app '${appIdKey}' and page '${pageIdKey}': ${JSON.stringify(targetInfo)}`);
     if (_.has(this.targets[appIdKey], pageIdKey)) {
-      log.debug(`There is already a target for this app and page ('${this.targets[appIdKey][pageIdKey]}'). This might cause problems`);
+      log.debug(
+        `There is already a target for this app and page ('${this.targets[appIdKey][pageIdKey]}'). ` +
+        `This might cause problems`
+      );
     }
-    const lock = new AsyncLock();
-    this.targets[app] = this.targets[app] || { lock };
     this.targets[appIdKey][pageIdKey] = targetInfo.targetId;
 
-    await lock.acquire(toLockKey(appIdKey, pageIdKey), async () => {
-      try {
-        await this.send('Target.setPauseOnStart', {
-          pauseOnStart: true,
-          appIdKey,
-          pageIdKey,
-        });
-      } catch {}
-      try {
-        await this._initializePage(appIdKey, pageIdKey);
-      } finally {
-        if (targetInfo.isPaused) {
-          await this._resumeTarget(appIdKey, pageIdKey);
+    try {
+      await this.targets[appIdKey].lock.acquire(targetInfo.targetId, async () => {
+        try {
+          await this.send('Target.setPauseOnStart', {
+            pauseOnStart: true,
+            appIdKey,
+            pageIdKey,
+          });
+        } catch {}
+        try {
+          await this._initializePage(appIdKey, pageIdKey, targetInfo.targetId);
+        } finally {
+          if (targetInfo.isPaused) {
+            await this._resumeTarget(appIdKey, pageIdKey, targetInfo.targetId);
+          }
         }
-      }
-    });
+      });
+    } catch (e) {
+      log.warn(
+        `Cannot complete the initialization of the new target '${targetInfo.targetId}' ` +
+        `after ${timer.getDuration().asMilliSeconds}ms: ${e.message}`
+      );
+    }
   }
 
   /**
@@ -656,7 +681,7 @@ export class RpcClient {
     if (!appIdKey || !pageIdKey) {
       return;
     }
-    return (this.targets[appIdKey] || {})[pageIdKey];
+    return this.targets[appIdKey]?.[pageIdKey];
   }
 
   /**
@@ -715,6 +740,7 @@ export class RpcClient {
     };
 
     log.debug(`Initializing page '${pageIdKey}' for app '${appIdKey}'`);
+    const timer = new timing.Timer().start();
     if (!this.fullPageInitialization) {
       // The sequence of domains is important
       for (const domain of [
@@ -735,7 +761,10 @@ export class RpcClient {
           log.info(`Cannot enable domain '${domain}' during initialization: ${err.message}`);
         }
       }
-      log.debug(`Simple initialization of page '${pageIdKey}' for app '${appIdKey}' completed`);
+      log.debug(
+        `Simple initialization of page '${pageIdKey}' for app '${appIdKey}' completed ` +
+        `in ${timer.getDuration().asMilliSeconds}ms`
+      );
       return;
     }
 
@@ -817,7 +846,10 @@ export class RpcClient {
         log.info(`Cannot enable domain '${domain}' during full initialization: ${err.message}`);
       }
     }
-    log.debug(`Full initialization of page '${pageIdKey}' for app '${appIdKey}' completed`);
+    log.debug(
+      `Full initialization of page '${pageIdKey}' for app '${appIdKey}' completed ` +
+      `in ${timer.getDuration().asMilliSeconds}ms`
+    );
   }
 
   /**
@@ -904,7 +936,7 @@ export class RpcClient {
    *
    * @param {import('../types').AppIdKey} appIdKey
    * @param {import('../types').PageIdKey} pageIdKey
-   * @param {import('../types').TargetId} [targetId]
+   * @param {import('../types').TargetId} targetId
    * @returns {Promise<void>}
    */
   async _resumeTarget (appIdKey, pageIdKey, targetId) {
@@ -915,7 +947,9 @@ export class RpcClient {
         targetId,
       });
       log.debug(`Successfully resumed the target ${targetId}@${appIdKey}`);
-    } catch {}
+    } catch (e) {
+      log.warn(`Could not resume the target ${targetId}@${appIdKey}: ${e.message}`);
+    }
   }
 
   /**
@@ -928,29 +962,16 @@ export class RpcClient {
     if (!appTargetsMap) {
       throw new Error(`No targets found for app '${appIdKey}'`);
     }
-    /** @type {AsyncLock | undefined}  */
     const lock = appTargetsMap.lock;
-    if (lock?.isBusy()) {
-      const timer = new timing.Timer().start();
-      log.debug(`Waiting until page ${pageIdKey}@${appIdKey} is fully initialized`);
-      await lock.acquire(toLockKey(appIdKey, pageIdKey), async () => await B.delay(0));
-      log.debug(
-        `The initalization of the page ${pageIdKey}@${appIdKey} took ${timer.getDuration().asMilliSeconds}ms`
-      );
+    const timer = new timing.Timer().start();
+    await lock.acquire(appTargetsMap[pageIdKey], async () => await B.delay(0));
+    const durationMs = timer.getDuration().asMilliSeconds;
+    if (durationMs > 10) {
+      log.debug(`Waited ${durationMs}ms until the page ${pageIdKey}@${appIdKey} is initialized`);
     }
   }
 }
 
-/**
- *
- * @param {import('../types').AppIdKey} appIdKey
- * @param {import('../types').PageIdKey} pageIdKey
- * @returns {string}
- */
-export function toLockKey(appIdKey, pageIdKey) {
-  return `${appIdKey}-${pageIdKey}`;
-}
-
 export default RpcClient;
 
 /**
@@ -972,6 +993,6 @@ export default RpcClient;
  */
 
 /**
- * @typedef {PageDict & {provisional?: import('../types').ProvisionalTargetInfo, lock: import('async-lock').default}} PagesToTargets
+ * @typedef {PageDict & {provisional?: import('../types').ProvisionalTargetInfo, lock: AsyncLock}} PagesToTargets
  * @typedef {{[key: import('../types').AppIdKey]: PagesToTargets}} AppToTargetsMap
  */

package/package.json

@@ -4,7 +4,7 @@
   "keywords": [
     "appium"
   ],
-  "version": "14.0.2",
+  "version": "14.0.4",
   "author": "Appium Contributors",
   "license": "Apache-2.0",
   "repository": {