~ knotless Search/
↑↓ move↵ open⇧↵ all results

geesawra.industries/old-fella

Old people's social media app

0
1
main
157 lines · 8.0 KB Raw History
#!/usr/bin/env python3
"""Record a Release build while XCTest scrolls the iPhone feed."""

import argparse
import os
from pathlib import Path
import signal
import subprocess
import sys
import time
import uuid


def stop(process, timeout=60):
    if process is None or process.poll() is not None:
        return
    os.killpg(process.pid, signal.SIGINT)
    try:
        process.wait(timeout=timeout)
    except subprocess.TimeoutExpired:
        os.killpg(process.pid, signal.SIGTERM)
        try:
            process.wait(timeout=5)
        except subprocess.TimeoutExpired:
            os.killpg(process.pid, signal.SIGKILL)
            process.wait()


def interrupted(_signal, _frame):
    raise KeyboardInterrupt


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("device")
    parser.add_argument("seconds", type=int, choices=range(5, 301), metavar="SECONDS")
    parser.add_argument("template", choices=["Animation Hitches", "Time Profiler", "SwiftUI"])
    args = parser.parse_args()
    feed = os.environ.get("OLDFELLA_PROFILE_FEED", "live")
    if feed not in ("live", "rich"):
        parser.error("OLDFELLA_PROFILE_FEED must be live or rich.")
    direction = os.environ.get("OLDFELLA_PROFILE_DIRECTION", "alternating")
    if direction not in ("alternating", "forward", "manual"):
        parser.error("OLDFELLA_PROFILE_DIRECTION must be alternating, forward, or manual.")
    root = Path(__file__).resolve().parent.parent
    directory = root / ".build" / "profiles"
    directory.mkdir(parents=True, exist_ok=True)
    prefix = directory / f"scroll-{time.strftime('%Y%m%d-%H%M%S')}-{os.getpid()}"
    trace_path = prefix.with_suffix(".trace")
    result_path = prefix.with_suffix(".xcresult")
    trace_log_path = prefix.with_suffix(".trace.log")
    test_log_path = prefix.with_suffix(".test.log")
    notification = f"com.oldfella.profiling.ready.{uuid.uuid4().hex}"
    ready = recorder = driver = None
    try:
        with trace_log_path.open("w") as trace_log, test_log_path.open("w") as test_log:
            environment = os.environ.copy()
            environment.update({
                "TEST_RUNNER_OLDFELLA_DEVICE_SCROLL_PROFILE": "1",
                "TEST_RUNNER_OLDFELLA_PROFILE_SECONDS": str(args.seconds),
                "TEST_RUNNER_OLDFELLA_PROFILE_FEED": feed,
                "TEST_RUNNER_OLDFELLA_PROFILE_DIRECTION": direction,
                "TEST_RUNNER_OLDFELLA_PROFILE_START_NOTIFICATION": notification,
                "NSUnbufferedIO": "YES",
            })
            driver = subprocess.Popen([
                "xcodebuild", "-scheme", "OldFellaScrollProfile", "-configuration", "Release",
                "-destination", f"platform=iOS,id={args.device}",
                "-only-testing:OldFellaUITests/DeviceScrollProfile/testScrollFeed",
                "-parallel-testing-enabled", "NO", "-enableCodeCoverage", "NO",
                "-collect-test-diagnostics", "never", "-resultBundlePath", str(result_path),
                "test-without-building",
            ], cwd=root, env=environment, stdout=test_log, stderr=subprocess.STDOUT, start_new_session=True)
            print(f"XCTest is opening the {feed} feed and testing the swipe controls. Leave the phone untouched.", flush=True)
            print(f"Driver log: {test_log_path}", flush=True)
            deadline = time.monotonic() + 120
            while "OLDFELLA_PROFILE_READY" not in test_log_path.read_text():
                if driver.poll() is not None:
                    raise RuntimeError(f"The scrolling driver stopped before it was ready. Read {test_log_path}.")
                if time.monotonic() >= deadline:
                    raise RuntimeError(f"The feed did not become ready within 120 seconds. Read {test_log_path}.")
                time.sleep(0.2)
            ready = subprocess.Popen(["/usr/bin/notifyutil", "-1", notification], start_new_session=True)
            recorder = subprocess.Popen([
                "xcrun", "xctrace", "record", "--template", args.template,
                "--instrument", "Hitches", "--instrument", "Points of Interest",
                "--device", args.device, "--all-processes",
                "--time-limit", f"{args.seconds + 120}s", "--output", str(trace_path),
                "--notify-tracing-started", notification,
            ], stdout=trace_log, stderr=subprocess.STDOUT, start_new_session=True)
            print(f"Waiting for Instruments. Recorder log: {trace_log_path}", flush=True)
            deadline = time.monotonic() + 60
            while ready.poll() is None:
                if recorder.poll() is not None:
                    raise RuntimeError(f"The recorder stopped before it was ready. Read {trace_log_path}.")
                if time.monotonic() >= deadline:
                    raise RuntimeError(f"The recorder did not become ready within 60 seconds. Read {trace_log_path}.")
                time.sleep(0.1)
            if ready.returncode != 0:
                raise RuntimeError("The recording notification failed.")
            subprocess.run([
                "xcrun", "devicectl", "device", "notification", "post", "--device", args.device,
                "--name", notification, "--timeout", "15",
            ], timeout=20, check=True)
            print(f"Recording {direction} scrolling for about {args.seconds} seconds.", flush=True)
            deadline = time.monotonic() + args.seconds + 45
            while "OLDFELLA_PROFILE_FINISHED" not in test_log_path.read_text():
                if driver.poll() is not None:
                    raise RuntimeError(f"The scrolling driver stopped before finishing. Read {test_log_path}.")
                if recorder.poll() is not None:
                    raise RuntimeError(f"The recorder stopped during scrolling. Read {trace_log_path}.")
                if time.monotonic() >= deadline:
                    raise RuntimeError(f"The scrolling driver timed out. Read {test_log_path}.")
                time.sleep(0.2)
            print("Scrolling ended. Saving Instruments data before closing the app.", flush=True)
            stop(recorder, timeout=180)
            if recorder.returncode != 0:
                raise RuntimeError(f"The recorder failed to save the trace. Read {trace_log_path}.")
            subprocess.run([
                "xcrun", "devicectl", "device", "notification", "post", "--device", args.device,
                "--name", notification + ".finished", "--timeout", "15",
            ], timeout=20, check=True)
            status = driver.wait(timeout=60)
            if status != 0:
                raise RuntimeError(f"The scrolling driver failed. Read {test_log_path}.")
            if "OLDFELLA_SCROLL_END" not in test_log_path.read_text():
                raise RuntimeError("XCTest did not finish the scrolling interval. Do not use this trace as a measurement.")
        print(f"Saved the trace: {trace_path}", flush=True)
        print(f"Saved the driver result: {result_path}", flush=True)
        print("Filter the trace to OldFella within the OldFellaScrollProfile interval. Launch and loading are outside that interval.", flush=True)
    finally:
        stop(driver, timeout=15)
        stop(recorder)
        stop(ready, timeout=5)
        restored = subprocess.run([
            "xcrun", "devicectl", "device", "process", "launch", "--device", args.device,
            "--timeout", "30", "--terminate-existing", "industries.geesawra.oldfella",
        ], timeout=40, check=False)
        if restored.returncode == 0:
            print("Relaunched Old Fella without the keep-awake argument.", flush=True)
        else:
            print("The normal launch failed. Reopen Old Fella. Its keep-awake mode also ends after ten minutes.", file=sys.stderr)
    subprocess.run([
        sys.executable, str(root / "scripts" / "summarize-scroll.py"),
        str(trace_path), "--seconds", str(args.seconds),
    ], check=True)


if __name__ == "__main__":
    signal.signal(signal.SIGTERM, interrupted)
    try:
        main()
    except (RuntimeError, subprocess.SubprocessError) as error:
        print(str(error), file=sys.stderr)
        sys.exit(1)
    except KeyboardInterrupt:
        sys.exit(130)