@limrun/appium-xcuitest-driver 10.4.3-lim.1

package/lib/device-connections-factory.js

@@ -0,0 +1,269 @@
+import _ from 'lodash';
+import net from 'net';
+import B from 'bluebird';
+import {logger, util, timing} from 'appium/support';
+import {utilities} from 'appium-ios-device';
+import {checkPortStatus} from 'portscanner';
+import {waitForCondition} from 'asyncbox';
+
+const LOCALHOST = '127.0.0.1';
+
+class iProxy {
+  constructor(udid, localport, deviceport) {
+    this.localport = parseInt(localport, 10);
+    this.deviceport = parseInt(deviceport, 10);
+    this.udid = udid;
+    this.localServer = null;
+    this.log = logger.getLogger(`iProxy@${udid.substring(0, 8)}:${this.localport}`);
+  }
+
+  async start() {
+    if (this.localServer) {
+      return;
+    }
+
+    this.localServer = net.createServer(async (localSocket) => {
+      let remoteSocket;
+      try {
+        // We can only connect to the remote socket after the local socket connection succeeds
+        remoteSocket = await utilities.connectPort(this.udid, this.deviceport);
+      } catch (e) {
+        this.log.debug(e.message);
+        localSocket.destroy();
+        return;
+      }
+
+      const destroyCommChannel = () => {
+        remoteSocket.unpipe(localSocket);
+        localSocket.unpipe(remoteSocket);
+      };
+      remoteSocket.once('close', () => {
+        destroyCommChannel();
+        localSocket.destroy();
+      });
+      // not all remote socket errors are critical for the user
+      remoteSocket.on('error', (e) => this.log.debug(e));
+      localSocket.once('end', destroyCommChannel);
+      localSocket.once('close', () => {
+        destroyCommChannel();
+        remoteSocket.destroy();
+      });
+      localSocket.on('error', (e) => this.log.warn(e.message));
+      localSocket.pipe(remoteSocket);
+      remoteSocket.pipe(localSocket);
+    });
+    const listeningPromise = new B((resolve, reject) => {
+      /** @type {net.Server} */ (this.localServer).once('listening', resolve);
+      /** @type {net.Server} */ (this.localServer).once('error', reject);
+    });
+    this.localServer.listen(this.localport);
+    try {
+      await listeningPromise;
+    } catch (e) {
+      this.localServer = null;
+      throw e;
+    }
+    this.localServer.on('error', (e) => this.log.warn(e.message));
+    this.localServer.once('close', (e) => {
+      if (e) {
+        this.log.info(`The connection has been closed with error ${e.message}`);
+      } else {
+        this.log.info(`The connection has been closed`);
+      }
+      this.localServer = null;
+    });
+
+    this.onBeforeProcessExit = this._closeLocalServer.bind(this);
+    // Make sure we free up the socket on process exit
+    process.on('beforeExit', this.onBeforeProcessExit);
+  }
+
+  _closeLocalServer() {
+    if (!this.localServer) {
+      return;
+    }
+
+    this.log.debug(`Closing the connection`);
+    this.localServer.close();
+    this.localServer = null;
+  }
+
+  stop() {
+    if (this.onBeforeProcessExit) {
+      process.off('beforeExit', this.onBeforeProcessExit);
+      this.onBeforeProcessExit = null;
+    }
+
+    this._closeLocalServer();
+  }
+}
+
+const log = logger.getLogger('DevCon Factory');
+const PORT_CLOSE_TIMEOUT = 15 * 1000; // 15 seconds
+const SPLITTER = ':';
+
+class DeviceConnectionsFactory {
+  constructor() {
+    this._connectionsMapping = {};
+  }
+
+  _udidAsToken(udid) {
+    return `${util.hasValue(udid) ? udid : ''}${SPLITTER}`;
+  }
+
+  _portAsToken(port) {
+    return `${SPLITTER}${util.hasValue(port) ? port : ''}`;
+  }
+
+  _toKey(udid = null, port = null) {
+    return `${util.hasValue(udid) ? udid : ''}${SPLITTER}${util.hasValue(port) ? port : ''}`;
+  }
+
+  _releaseProxiedConnections(connectionKeys) {
+    const keys = connectionKeys.filter((k) => _.has(this._connectionsMapping[k], 'iproxy'));
+    for (const key of keys) {
+      log.info(`Releasing the listener for '${key}'`);
+      try {
+        this._connectionsMapping[key].iproxy.stop();
+      } catch (e) {
+        log.debug(e);
+      }
+    }
+    return keys;
+  }
+
+  listConnections(udid = null, port = null, strict = false) {
+    if (!udid && !port) {
+      return [];
+    }
+
+    // `this._connectionMapping` keys have format `udid:port`
+    // the `strict` argument enforces to match keys having both `udid` and `port`
+    // if they are defined
+    // while in non-strict mode keys having any of these are going to be matched
+    return _.keys(this._connectionsMapping).filter((key) =>
+      strict && udid && port
+        ? key === this._toKey(udid, port)
+        : (udid && key.startsWith(this._udidAsToken(udid))) ||
+          (port && key.endsWith(this._portAsToken(port))),
+    );
+  }
+
+  async requestConnection(udid, port, options = {}) {
+    if (!udid || !port) {
+      log.warn('Did not know how to request the connection:');
+      if (!udid) {
+        log.warn('- Device UDID is unset');
+      }
+      if (!port) {
+        log.warn('- The local port number is unset');
+      }
+      return;
+    }
+
+    const {usePortForwarding, devicePort} = options;
+
+    log.info(
+      `Requesting connection for device ${udid} on local port ${port}` +
+        (devicePort ? `, device port ${devicePort}` : ''),
+    );
+    log.debug(`Cached connections count: ${_.size(this._connectionsMapping)}`);
+    const connectionsOnPort = this.listConnections(null, port);
+    if (!_.isEmpty(connectionsOnPort)) {
+      log.info(`Found cached connections on port #${port}: ${JSON.stringify(connectionsOnPort)}`);
+    }
+
+    if (usePortForwarding) {
+      let isPortBusy = (await checkPortStatus(port, LOCALHOST)) === 'open';
+      if (isPortBusy) {
+        log.warn(`Port #${port} is busy. Did you quit the previous driver session(s) properly?`);
+        if (!_.isEmpty(connectionsOnPort)) {
+          log.info('Trying to release the port');
+          for (const key of this._releaseProxiedConnections(connectionsOnPort)) {
+            delete this._connectionsMapping[key];
+          }
+          const timer = new timing.Timer().start();
+          try {
+            await waitForCondition(
+              async () => {
+                try {
+                  if ((await checkPortStatus(port, LOCALHOST)) !== 'open') {
+                    log.info(
+                      `Port #${port} has been successfully released after ` +
+                        `${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
+                    );
+                    isPortBusy = false;
+                    return true;
+                  }
+                } catch {}
+                return false;
+              },
+              {
+                waitMs: PORT_CLOSE_TIMEOUT,
+                intervalMs: 300,
+              },
+            );
+          } catch {
+            log.warn(
+              `Did not know how to release port #${port} in ` +
+                `${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
+            );
+          }
+        }
+      }
+
+      if (isPortBusy) {
+        throw new Error(
+          `The port #${port} is occupied by an other process. ` +
+            `You can either quit that process or select another free port.`,
+        );
+      }
+    }
+    const currentKey = this._toKey(udid, port);
+    if (usePortForwarding) {
+      const iproxy = new iProxy(udid, port, devicePort);
+      try {
+        await iproxy.start();
+        this._connectionsMapping[currentKey] = {iproxy};
+      } catch (e) {
+        try {
+          iproxy.stop();
+        } catch (e1) {
+          log.debug(e1);
+        }
+        throw e;
+      }
+    } else {
+      this._connectionsMapping[currentKey] = {};
+    }
+    log.info(`Successfully requested the connection for ${currentKey}`);
+  }
+
+  releaseConnection(udid = null, port = null) {
+    if (!udid && !port) {
+      log.warn(
+        'Neither device UDID nor local port is set. ' +
+          'Did not know how to release the connection',
+      );
+      return;
+    }
+    log.info(`Releasing connections for ${udid || 'any'} device on ${port || 'any'} port number`);
+
+    const keys = this.listConnections(udid, port, true);
+    if (_.isEmpty(keys)) {
+      log.info('No cached connections have been found');
+      return;
+    }
+    log.info(`Found cached connections to release: ${JSON.stringify(keys)}`);
+    this._releaseProxiedConnections(keys);
+    for (const key of keys) {
+      delete this._connectionsMapping[key];
+    }
+    log.debug(`Cached connections count: ${_.size(this._connectionsMapping)}`);
+  }
+}
+
+const DEVICE_CONNECTIONS_FACTORY = new DeviceConnectionsFactory();
+
+export {DEVICE_CONNECTIONS_FACTORY, DeviceConnectionsFactory};
+export default DEVICE_CONNECTIONS_FACTORY;

package/lib/device-log/helpers.ts

@@ -0,0 +1,40 @@
+import type { LogEntry } from '../commands/types';
+import { fs } from 'appium/support';
+import { createInterface } from 'node:readline';
+import _ from 'lodash';
+
+export const DEFAULT_LOG_LEVEL = 'ALL';
+export const MAX_JSON_LOG_LENGTH = 200;
+export const MAX_BUFFERED_EVENTS_COUNT = 5000;
+
+export function toLogEntry(message: string, timestamp: number, level: string = DEFAULT_LOG_LEVEL): LogEntry {
+  return {
+    timestamp,
+    level,
+    message,
+  };
+}
+
+export interface GrepOptions {
+  caseInsensitive?: boolean;
+}
+
+export async function grepFile(
+  fullPath: string,
+  str: string,
+  opts: GrepOptions = {}
+): Promise<boolean> {
+  const input = fs.createReadStream(fullPath);
+  const rl = createInterface({input});
+  return await new Promise((resolve, reject) => {
+    input.once('error', reject);
+    rl.on('line', (line) => {
+      if (opts.caseInsensitive && _.toLower(line).includes(_.toLower(str))
+          || !opts.caseInsensitive && line.includes(str)) {
+        resolve(true);
+        input.close();
+      }
+    });
+    input.once('end', () => resolve(false));
+  });
+}

package/lib/device-log/ios-crash-log.ts

@@ -0,0 +1,166 @@
+import {fs, tempDir, util} from 'appium/support';
+import B from 'bluebird';
+import path from 'path';
+import _ from 'lodash';
+import {Pyidevice} from '../real-device-clients/py-ios-device-client';
+import {IOSLog} from './ios-log';
+import { toLogEntry, grepFile } from './helpers';
+import type { AppiumLogger } from '@appium/types';
+import type { BaseDeviceClient } from '../real-device-clients/base-device-client';
+import type { Simulator } from '@limrun/appium-ios-simulator';
+import type { LogEntry } from '../commands/types';
+
+// The file format has been changed from '.crash' to '.ips' since Monterey.
+const CRASH_REPORTS_GLOB_PATTERN = '**/*.@(crash|ips)';
+// The size of a single diagnostic report might be hundreds of kilobytes.
+// Thus we do not want to store too many items in the memory at once.
+const MAX_RECENT_ITEMS = 20;
+
+type TSerializedEntry = [string, number];
+
+export interface IOSCrashLogOptions {
+  /** UDID of a real device */
+  udid?: string;
+  /** Simulator instance */
+  sim?: Simulator;
+  log: AppiumLogger;
+}
+
+export class IOSCrashLog extends IOSLog<TSerializedEntry, TSerializedEntry> {
+  private readonly _udid: string | undefined;
+  private readonly _realDeviceClient: BaseDeviceClient | null;
+  private readonly _logDir: string | null;
+  private readonly _sim: Simulator | undefined;
+  private _recentCrashFiles: string[];
+  private _started: boolean;
+
+  constructor(opts: IOSCrashLogOptions) {
+    super({
+      log: opts.log,
+      maxBufferSize: MAX_RECENT_ITEMS,
+    });
+    this._udid = opts.udid;
+    this._sim = opts.sim;
+    this._realDeviceClient = this._isRealDevice()
+      ? new Pyidevice({
+        udid: this._udid as string,
+        log: opts.log,
+      })
+      : null;
+    this._logDir = this._isRealDevice()
+      ? null
+      : path.resolve(process.env.HOME || '/', 'Library', 'Logs', 'DiagnosticReports');
+    this._recentCrashFiles = [];
+    this._started = false;
+  }
+
+  override async startCapture(): Promise<void> {
+    this._recentCrashFiles = await this._listCrashFiles(false);
+    this._started = true;
+  }
+
+  override async stopCapture(): Promise<void> {
+    this._started = false;
+  }
+
+  override get isCapturing(): boolean {
+    return this._started;
+  }
+
+  override async getLogs(): Promise<LogEntry[]> {
+    const crashFiles = (await this._listCrashFiles(true)).slice(-MAX_RECENT_ITEMS);
+    const diffFiles = _.difference(crashFiles, this._recentCrashFiles);
+    if (_.isEmpty(diffFiles)) {
+      return [];
+    }
+
+    this.log.debug(`Found ${util.pluralize('fresh crash report', diffFiles.length, true)}`);
+    await this._serializeCrashes(diffFiles);
+    this._recentCrashFiles = crashFiles;
+    return super.getLogs();
+  }
+
+  protected override _serializeEntry(value: TSerializedEntry): TSerializedEntry {
+    return value;
+  }
+
+  protected override _deserializeEntry(value: TSerializedEntry): LogEntry {
+    const [message, timestamp] = value;
+    return toLogEntry(message, timestamp);
+  }
+
+  private async _serializeCrashes(paths: string[]): Promise<void> {
+    const tmpRoot = await tempDir.openDir();
+    try {
+      for (const filePath of paths) {
+        let fullPath = filePath;
+        if (this._isRealDevice()) {
+          const fileName = filePath;
+          try {
+            await (this._realDeviceClient as BaseDeviceClient).exportCrash(fileName, tmpRoot);
+          } catch (e) {
+            this.log.warn(
+              `Cannot export the crash report '${fileName}'. Skipping it. ` +
+              `Original error: ${e.message}`,
+            );
+            return;
+          }
+          fullPath = path.join(tmpRoot, fileName);
+        }
+        const {ctime} = await fs.stat(fullPath);
+        this.broadcast([await fs.readFile(fullPath, 'utf8'), ctime.getTime()]);
+      }
+    } finally {
+      await fs.rimraf(tmpRoot);
+    }
+  }
+
+  private async _gatherFromRealDevice(strict: boolean): Promise<string[]> {
+    if (!this._realDeviceClient) {
+      return [];
+    }
+    if (!await this._realDeviceClient.assertExists(strict)) {
+      this.log.info(
+        `The ${_.toLower(this._realDeviceClient.constructor.name)} tool is not present in PATH. ` +
+        `Skipping crash logs collection for real devices.`
+      );
+      return [];
+    }
+
+    return await this._realDeviceClient.listCrashes();
+  }
+
+  private async _gatherFromSimulator(): Promise<string[]> {
+    if (!this._logDir || !this._sim || !(await fs.exists(this._logDir))) {
+      this.log.debug(`Crash reports root '${this._logDir}' does not exist. Got nothing to gather.`);
+      return [];
+    }
+
+    const foundFiles = await fs.glob(CRASH_REPORTS_GLOB_PATTERN, {
+      cwd: this._logDir,
+      absolute: true,
+    });
+    const simUdid = (this._sim as Simulator).udid;
+    // For Simulator only include files, that contain current UDID
+    return await B.filter(foundFiles, async (filePath) => {
+      try {
+        return await grepFile(filePath, simUdid, {caseInsensitive: true});
+      } catch (err) {
+        this.log.warn(err);
+        return false;
+      }
+    });
+  }
+
+  private async _listCrashFiles(strict: boolean): Promise<string[]> {
+    return this._isRealDevice()
+      ? await this._gatherFromRealDevice(strict)
+      : await this._gatherFromSimulator();
+  }
+
+  private _isRealDevice(): boolean {
+    return Boolean(this._udid);
+  }
+}
+
+export default IOSCrashLog;

package/lib/device-log/ios-device-log.ts

@@ -0,0 +1,51 @@
+import {services} from 'appium-ios-device';
+import { LineConsumingLog } from './line-consuming-log';
+import type { AppiumLogger } from '@appium/types';
+
+export interface IOSDeviceLogOpts {
+  udid: string;
+  showLogs?: boolean;
+  log: AppiumLogger;
+}
+
+export class IOSDeviceLog extends LineConsumingLog {
+  private readonly udid: string;
+  private readonly showLogs: boolean;
+  private service: any | null;
+
+  constructor(opts: IOSDeviceLogOpts) {
+    super({log: opts.log});
+    this.udid = opts.udid;
+    this.showLogs = !!opts.showLogs;
+    this.service = null;
+  }
+
+  override async startCapture(): Promise<void> {
+    if (this.service) {
+      return;
+    }
+    this.service = await services.startSyslogService(this.udid);
+    this.service.start(this.onLog.bind(this));
+  }
+
+  override get isCapturing(): boolean {
+    return !!this.service;
+  }
+
+  override async stopCapture(): Promise<void> {
+    if (!this.service) {
+      return;
+    }
+    this.service.close();
+    this.service = null;
+  }
+
+  private onLog(logLine: string): void {
+    this.broadcast(logLine);
+    if (this.showLogs) {
+      this.log.info(`[IOS_SYSLOG_ROW] ${logLine}`);
+    }
+  }
+}
+
+export default IOSDeviceLog;

package/lib/device-log/ios-log.ts

@@ -0,0 +1,70 @@
+import {EventEmitter} from 'events';
+import { LRUCache } from 'lru-cache';
+import type { LogEntry } from '../commands/types';
+import type { AppiumLogger } from '@appium/types';
+import {logger} from 'appium/support';
+
+// We keep only the most recent log entries to avoid out of memory error
+const MAX_LOG_ENTRIES_COUNT = 10000;
+
+export interface IOSLogOptions {
+  maxBufferSize?: number;
+  log?: AppiumLogger;
+}
+
+export abstract class IOSLog<
+  TRawEntry,
+  TSerializedEntry extends object
+> extends EventEmitter {
+  private maxBufferSize: number;
+  private logs: LRUCache<number, TSerializedEntry>;
+  private _log: AppiumLogger;
+
+  constructor(opts: IOSLogOptions = {}) {
+    super();
+    this.maxBufferSize = opts.maxBufferSize ?? MAX_LOG_ENTRIES_COUNT;
+    this.logs = new LRUCache({
+      max: this.maxBufferSize,
+    });
+    this._log = opts.log ?? logger.getLogger(this.constructor.name);
+  }
+
+  abstract startCapture(): Promise<void>;
+  abstract stopCapture(): Promise<void>;
+  abstract get isCapturing(): boolean;
+
+  get log(): AppiumLogger {
+    return this._log;
+  }
+
+  async getLogs(): Promise<LogEntry[]> {
+    const result: LogEntry[] = [];
+    for (const value of this.logs.rvalues()) {
+      result.push(this._deserializeEntry(value as TSerializedEntry));
+    }
+    this._clearEntries();
+    return result;
+  }
+
+  protected abstract _serializeEntry(value: TRawEntry): TSerializedEntry;
+  protected abstract _deserializeEntry(value: TSerializedEntry): LogEntry;
+
+  protected _clearEntries() {
+    this.logs.clear();
+  }
+
+  protected broadcast(entry: TRawEntry): void {
+    let recentIndex = -1;
+    for (const key of this.logs.keys()) {
+      recentIndex = key;
+      break;
+    }
+    const serializedEntry = this._serializeEntry(entry);
+    this.logs.set(++recentIndex, serializedEntry);
+    if (this.listenerCount('output')) {
+      this.emit('output', this._deserializeEntry(serializedEntry));
+    }
+  }
+}
+
+export default IOSLog;

package/lib/device-log/ios-performance-log.ts

@@ -0,0 +1,50 @@
+import _ from 'lodash';
+import type { AppiumLogger } from '@appium/types';
+import { MAX_JSON_LOG_LENGTH, MAX_BUFFERED_EVENTS_COUNT } from './helpers';
+import { LineConsumingLog } from './line-consuming-log';
+
+type PerformanceLogEntry = object;
+export interface IOSPerformanceLogOptions {
+  remoteDebugger: any;
+  maxEvents?: number;
+  log: AppiumLogger;
+}
+
+export class IOSPerformanceLog extends LineConsumingLog {
+  private readonly remoteDebugger: any;
+  private _started: boolean;
+
+  constructor(opts: IOSPerformanceLogOptions) {
+    super({
+      maxBufferSize: opts.maxEvents ?? MAX_BUFFERED_EVENTS_COUNT,
+      log: opts.log,
+    });
+    this.remoteDebugger = opts.remoteDebugger;
+    this._started = false;
+  }
+
+  override async startCapture(): Promise<void> {
+    this.log.debug('Starting performance (Timeline) log capture');
+    this._clearEntries();
+    await this.remoteDebugger.startTimeline(this.onTimelineEvent.bind(this));
+    this._started = true;
+  }
+
+  override async stopCapture(): Promise<void> {
+    this.log.debug('Stopping performance (Timeline) log capture');
+    await this.remoteDebugger.stopTimeline();
+    this._started = false;
+  }
+
+  override get isCapturing(): boolean {
+    return this._started;
+  }
+
+  private onTimelineEvent(event: PerformanceLogEntry): void {
+    const serializedEntry = JSON.stringify(event);
+    this.broadcast(serializedEntry);
+    this.log.debug(`Received Timeline event: ${_.truncate(serializedEntry, {length: MAX_JSON_LOG_LENGTH})}`);
+  }
+}
+
+export default IOSPerformanceLog;