@invarn/cibuild 2.8.6 → 2.8.8

package/dist/src/yaml/steps/gradle-memory.js

@@ -19,13 +19,19 @@
  *  2. **Say so.** When a Gradle run exits 137 or its output says the daemon
  *     disappeared, print the kernel's out-of-memory lines and one sentence
  *     with the machine's memory and what the build asked for.
+ *  3. **Workers.** A heap cap does not bound what runs beside the heaps:
+ *     off-heap memory, and native compilers run in parallel. IacobIonut01/ReFra
+ *     was killed again at a capped -Xmx3712m, one JVM holding ~5.1 GiB
+ *     resident; its own CI also sets `org.gradle.workers.max=2`. A pipeline
+ *     may ask for a worker count, passed as `--max-workers=<n>`.
  *
  * Precedence, measured with Gradle 8.14.3 and 9.5.0 (daemon and --no-daemon):
  * `-Dorg.gradle.jvmargs` on the command line beats both the Gradle user
  * home's and the project's `gradle.properties` for the daemon's heap, and
  * `-P` beats `gradle.properties` for a Gradle property, which is how the
- * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs`. `GRADLE_OPTS` is not
- * used: it sizes the client JVM, not the daemon.
+ * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs`. `--max-workers` beats
+ * `org.gradle.workers.max` in both files (`gradle.startParameter.maxWorkerCount`).
+ * `GRADLE_OPTS` is not used: it sizes the client JVM, not the daemon.
  *
  * Written as shell functions so what ships is what the tests run. Its lines
  * start with "Gradle memory:", never with a step-progress marker.
@@ -204,6 +210,23 @@ cibuild_gradle_memory_plan() {
   CIBUILD_GRADLE_MEMORY_SENTENCE="$CIBUILD_GRADLE_MEMORY_SENTENCE This build ran them capped: $now."
 }
 
+# $1 the number of Gradle workers the pipeline asks for (may be empty). Adds
+# --max-workers to the plan's arguments; run after cibuild_gradle_memory_plan.
+# Sets CIBUILD_GRADLE_WORKERS_LINE (what to print; empty when nothing asked).
+cibuild_gradle_workers_plan() {
+  CIBUILD_GRADLE_WORKERS_LINE=""
+  [ -n "$1" ] || return 0
+  case "$1" in
+    *[!0-9]*|0*)
+      CIBUILD_GRADLE_WORKERS_LINE="Gradle memory: max_workers=$1 is not a positive whole number, so it is not passed and Gradle picks its own worker count."
+      return 0
+      ;;
+  esac
+  CIBUILD_GRADLE_MEMORY_ARGS+=("--max-workers=$1")
+  CIBUILD_GRADLE_WORKERS_LINE="Gradle memory: running with --max-workers=$1, as the pipeline asks (set on the command line, over any org.gradle.workers.max)."
+  CIBUILD_GRADLE_MEMORY_SENTENCE="$CIBUILD_GRADLE_MEMORY_SENTENCE Gradle ran with --max-workers=$1."
+}
+
 # The kernel's out-of-memory lines, if this user may read the kernel log.
 # Linux guests restrict dmesg to root by default; their build user has
 # non-interactive sudo, so that is the second try.
@@ -244,12 +267,15 @@ cibuild_gradle() {
   return "$rc"
 }
 
-# $1 JVM arguments the pipeline asks for (may be empty). Run in the Gradle
-# project directory, after GRADLE_CMD is chosen.
+# $1 JVM arguments the pipeline asks for, $2 the Gradle workers it asks for
+# (either may be empty). Run in the Gradle project directory, after GRADLE_CMD
+# is chosen.
 cibuild_gradle_memory_cap() {
   cibuild_gradle_memory_plan "$(cibuild_mem_mib || true)" "gradle.properties" \\
     "\${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties" "$1"
+  cibuild_gradle_workers_plan "$2"
   if [ -n "$CIBUILD_GRADLE_MEMORY_LINE" ]; then echo "$CIBUILD_GRADLE_MEMORY_LINE"; fi
+  if [ -n "$CIBUILD_GRADLE_WORKERS_LINE" ]; then echo "$CIBUILD_GRADLE_WORKERS_LINE"; fi
   CIBUILD_GRADLE_BIN="$GRADLE_CMD"
   GRADLE_CMD=cibuild_gradle
 }`;
@@ -260,9 +286,15 @@ cibuild_gradle_memory_cap() {
  *
  * `jvmargs` is what the pipeline asks for instead of the project's
  * `org.gradle.jvmargs` (a value the repository's own CI sets, say); the cap
- * still applies to it.
+ * still applies to it. `maxWorkers` is the worker count it asks for (the
+ * repository CI's `org.gradle.workers.max`), passed as `--max-workers`.
  */
-export function gradleMemoryCommands(jvmargs, escape) {
-    return ['', GRADLE_MEMORY_FUNCTIONS, '', `cibuild_gradle_memory_cap '${escape(jvmargs)}'`];
+export function gradleMemoryCommands(jvmargs, escape, maxWorkers = '') {
+    return [
+        '',
+        GRADLE_MEMORY_FUNCTIONS,
+        '',
+        `cibuild_gradle_memory_cap '${escape(jvmargs)}' '${escape(maxWorkers)}'`,
+    ];
 }
 //# sourceMappingURL=gradle-memory.js.map

package/dist/src/yaml/steps/gradle-memory.test.js

@@ -124,6 +124,52 @@ describe("cibuild_gradle_memory_plan", () => {
         ]);
     });
 });
+/** The plan, then the workers plan, as the step runs them. */
+function workersPlan(memMib, maxWorkers) {
+    const script = `${GRADLE_MEMORY_FUNCTIONS}
+cibuild_gradle_memory_plan "$1" gradle.properties "$2/gradle.properties" ""
+cibuild_gradle_workers_plan "$3"
+for a in "\${CIBUILD_GRADLE_MEMORY_ARGS[@]}"; do printf 'ARG %s\\n' "$a"; done
+printf 'LINE %s\\n' "$CIBUILD_GRADLE_WORKERS_LINE"
+printf 'SENTENCE %s\\n' "$CIBUILD_GRADLE_MEMORY_SENTENCE"`;
+    const out = execFileSync("bash", ["-c", script, "plan", memMib, join(dir, "no-user-home"), maxWorkers], {
+        cwd: dir,
+        encoding: "utf-8",
+    });
+    const lines = out.split("\n");
+    return {
+        args: lines.filter((l) => l.startsWith("ARG ")).map((l) => l.slice(4)),
+        line: (lines.find((l) => l.startsWith("LINE ")) ?? "").slice(5),
+        sentence: (lines.find((l) => l.startsWith("SENTENCE ")) ?? "").slice(9),
+    };
+}
+// ReFra was killed again with its heap capped: off-heap memory and parallel
+// native compilers are past what a heap cap bounds. Its CI also sets
+// org.gradle.workers.max=2, which the pipeline carries as max_workers.
+describe("cibuild_gradle_workers_plan", () => {
+    test("ReFra: the worker count goes after the heap cap, and the sentence names it", () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        const p = workersPlan(TEN_GIB, "2");
+        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3840m -Dfile.encoding=UTF-8", "--max-workers=2"]);
+        expect(p.line).toBe("Gradle memory: running with --max-workers=2, as the pipeline asks (set on the command line, over any org.gradle.workers.max).");
+        expect(p.sentence).toMatch(/This build ran them capped: Gradle -Xmx3840m, .* Gradle ran with --max-workers=2\.$/);
+    });
+    test("heaps that fit still get the worker count", () => {
+        const p = workersPlan(TEN_GIB, "4");
+        expect(p.args).toEqual(["--max-workers=4"]);
+    });
+    test("nothing asked, nothing passed or printed", () => {
+        const p = workersPlan(TEN_GIB, "");
+        expect(p.args).toEqual([]);
+        expect(p.line).toBe("");
+        expect(p.sentence).not.toContain("max-workers");
+    });
+    test.each(["0", "02", "-1", "two", "2 --offline"])("%s is not a worker count, and says so", (value) => {
+        const p = workersPlan(TEN_GIB, value);
+        expect(p.args).toEqual([]);
+        expect(p.line).toBe(`Gradle memory: max_workers=${value} is not a positive whole number, so it is not passed and Gradle picks its own worker count.`);
+    });
+});
 /** A directory standing in for PATH, with a fake `dmesg` that prints `oom`. */
 function fakeBin(oom) {
     const bin = join(dir, "bin");
@@ -173,6 +219,38 @@ describe("the Gradle steps", () => {
         const args = execFileSync("cat", [join(dir, "gradlew-args")], { encoding: "utf-8" }).trim().split("\n");
         expect(args).toEqual(["-Dorg.gradle.jvmargs=-Xmx256m -Dfile.encoding=UTF-8", "assembleDebug", "--stacktrace"]);
     });
+    test("the pipeline's max_workers reach Gradle after the heap arguments, before the task", async () => {
+        fakeGradlew("exit 0");
+        const step = await new GradleBuildStepExecutor().execute(
+        // YAML reads `max_workers: 2` as a number.
+        { gradle_task: "assembleDebug", gradle_options: "--stacktrace", jvmargs: "-Xmx256m", max_workers: 2 }, {}, testConfig);
+        const run = runStep(step.script, fakeBin(""));
+        expect(run.status).toBe(0);
+        expect(run.stdout).toContain("Gradle memory: running with --max-workers=2, as the pipeline asks");
+        const args = execFileSync("cat", [join(dir, "gradlew-args")], { encoding: "utf-8" }).trim().split("\n");
+        expect(args).toEqual(["-Dorg.gradle.jvmargs=-Xmx256m", "--max-workers=2", "assembleDebug", "--stacktrace"]);
+    });
+    test("a killed daemon's sentence names the worker count it ran with", async () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        fakeGradlew('echo "Gradle build daemon disappeared unexpectedly"\nexit 1');
+        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug", max_workers: "2" }, {}, testConfig);
+        const run = runStep(step.script, fakeBin(OOM_LINE));
+        expect(run.status).toBe(1);
+        // The test machine's own memory decides whether a cap applied, so only the
+        // sentence's end is asserted.
+        expect(run.stdout).toMatch(/^The build machine has .*asked for 16\.0 GiB .* Gradle ran with --max-workers=2\.$/m);
+    });
+    test("every Gradle step passes max_workers to the plan", async () => {
+        const steps = [
+            await new GradleBuildStepExecutor().execute({ max_workers: 3 }, {}, testConfig),
+            await new AndroidLintStepExecutor().execute({ max_workers: 3 }, {}, testConfig),
+            await new AndroidUnitTestStepExecutor().execute({ max_workers: 3 }, {}, testConfig),
+            await new AndroidBuildForUITestingStepExecutor().execute({ max_workers: 3 }, {}, testConfig),
+        ];
+        for (const step of steps) {
+            expect(step.script).toContain("cibuild_gradle_memory_cap '' '3'");
+        }
+    });
     test("every Gradle step runs through the plan, and every one is valid bash", async () => {
         const steps = [
             await new GradleBuildStepExecutor().execute({}, {}, testConfig),
@@ -182,7 +260,7 @@ describe("the Gradle steps", () => {
         ];
         for (const step of steps) {
             const script = step.script;
-            expect(script).toContain("cibuild_gradle_memory_cap ''");
+            expect(script).toContain("cibuild_gradle_memory_cap '' ''");
             execFileSync("bash", ["-n"], { input: script });
         }
     });

package/dist/src/yaml/steps/ios-deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ios-deps.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ios-deps.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAc,MAAM,wBAAwB,CAAC;AAMhF,MAAM,WAAW,sBAAsB;IACrC,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,qBAAa,4BAA6B,SAAQ,gBAAgB;IAChE,yBAAyB,CACvB,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAUpB,OAAO,CACX,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CAoJpB;AAMD,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,gBAAgB;IACxD,yBAAyB,CACvB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAUpB,OAAO,CACX,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CAyDpB"}
+{"version":3,"file":"ios-deps.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ios-deps.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAc,MAAM,wBAAwB,CAAC;AAMhF,MAAM,WAAW,sBAAsB;IACrC,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,qBAAa,4BAA6B,SAAQ,gBAAgB;IAChE,yBAAyB,CACvB,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAUpB,OAAO,CACX,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CAiLpB;AAMD,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,gBAAgB;IACxD,yBAAyB,CACvB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAUpB,OAAO,CACX,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CAyDpB"}

package/dist/src/yaml/steps/ios-deps.js

@@ -83,9 +83,14 @@ export class CocoapodsInstallStepExecutor extends BaseStepExecutor {
         //
         // Three moves, each conditional, so a machine missing a piece keeps the
         // old behaviour rather than failing on it:
-        //   - prefer an installed Homebrew Ruby. It is keg-only, so it is not on
-        //     PATH even where it is installed (Homebrew's cocoapods and fastlane
-        //     formulae depend on it), and the system 2.6 wins by default;
+        //   - run the Ruby the project names: Gemfile.lock's `RUBY VERSION`, then
+        //     `.ruby-version`. Only a named Ruby 3 or newer moves to Homebrew's
+        //     Ruby, which is keg-only, so not on PATH even where it is installed
+        //     (Homebrew's cocoapods and fastlane formulae depend on it). Anything
+        //     else, including a project that names none, stays on system Ruby 2.6.
+        //     Homebrew's is Ruby 4 on the mac image, and an old lockfile's gems do
+        //     not load there — rake 13.0.6 requires `ostruct`, no longer a default
+        //     gem — so "newest installed" is the wrong default;
         //   - point GEM_HOME at a writable directory outside the checkout, so both
         //     `gem install bundler` and `bundle install` can write without sudo,
         //     and put its bin directory first;
@@ -93,10 +98,34 @@ export class CocoapodsInstallStepExecutor extends BaseStepExecutor {
         //     `bundle _<version>_`, which is the form RubyGems accepts.
         commands.push('BUNDLE_CMD="bundle"');
         commands.push('if [ "$USE_BUNDLE_EXEC" = "true" ]; then');
-        commands.push('  if command -v brew &>/dev/null; then');
-        commands.push('    BREW_RUBY="$(brew --prefix --installed ruby 2>/dev/null || true)"');
-        commands.push('    if [ -n "$BREW_RUBY" ] && [ -x "$BREW_RUBY/bin/ruby" ]; then');
-        commands.push('      export PATH="$BREW_RUBY/bin:$PATH"');
+        commands.push('  WANTED_RUBY=""');
+        commands.push('  WANTED_FROM=""');
+        commands.push('  if [ -f "Gemfile.lock" ]; then');
+        commands.push('    WANTED_RUBY="$(awk \'/^RUBY VERSION/ { getline; sub(/^[[:space:]]*ruby[[:space:]]+/, ""); sub(/p[0-9]+.*$/, ""); gsub(/[[:space:]]/, ""); print; exit }\' Gemfile.lock)"');
+        commands.push('    [ -n "$WANTED_RUBY" ] && WANTED_FROM="Gemfile.lock RUBY VERSION"');
+        commands.push('  fi');
+        commands.push('  if [ -z "$WANTED_RUBY" ] && [ -f ".ruby-version" ]; then');
+        commands.push('    WANTED_RUBY="$(head -n 1 .ruby-version | tr -d \'[:space:]\')"');
+        commands.push('    WANTED_RUBY="${WANTED_RUBY#ruby-}"');
+        commands.push('    WANTED_FROM=".ruby-version"');
+        commands.push('  fi');
+        commands.push('  case "${WANTED_RUBY%%.*}" in');
+        commands.push('    \'\'|*[!0-9]*) WANTED_RUBY="" ;;');
+        commands.push('  esac');
+        commands.push('  if [ -z "$WANTED_RUBY" ]; then');
+        commands.push('    RUBY_REASON="system: lockfile names no Ruby"');
+        commands.push('  else');
+        commands.push('    RUBY_REASON="from $WANTED_FROM $WANTED_RUBY"');
+        commands.push('    if [ "${WANTED_RUBY%%.*}" -ge 3 ]; then');
+        commands.push('      BREW_RUBY=""');
+        commands.push('      if command -v brew &>/dev/null; then');
+        commands.push('        BREW_RUBY="$(brew --prefix --installed ruby 2>/dev/null || true)"');
+        commands.push('      fi');
+        commands.push('      if [ -n "$BREW_RUBY" ] && [ -x "$BREW_RUBY/bin/ruby" ]; then');
+        commands.push('        export PATH="$BREW_RUBY/bin:$PATH"');
+        commands.push('      else');
+        commands.push('        RUBY_REASON="$RUBY_REASON, but no Homebrew Ruby is installed"');
+        commands.push('      fi');
         commands.push('    fi');
         commands.push('  fi');
         commands.push('  if ! command -v bundle &>/dev/null && ! command -v gem &>/dev/null; then');
@@ -109,7 +138,7 @@ export class CocoapodsInstallStepExecutor extends BaseStepExecutor {
         commands.push('  mkdir -p "$GEM_HOME"');
         commands.push('  export PATH="$GEM_HOME/bin:$PATH"');
         commands.push('  RUBY_VERSION_USED="$(ruby -e \'print RUBY_VERSION\' 2>/dev/null || echo unknown)"');
-        commands.push('  echo "Ruby: $(command -v ruby || echo none) ($RUBY_VERSION_USED), GEM_HOME: $GEM_HOME"');
+        commands.push('  echo "Ruby: $(command -v ruby || echo none) ($RUBY_VERSION_USED), GEM_HOME: $GEM_HOME — $RUBY_REASON"');
         commands.push('  LOCKED_BUNDLER=""');
         commands.push('  if [ -f "Gemfile.lock" ]; then');
         commands.push('    LOCKED_BUNDLER="$(awk \'/^BUNDLED WITH/ { getline; gsub(/[[:space:]]/, ""); print; exit }\' Gemfile.lock)"');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invarn/cibuild",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",