This is an automated email from the ASF dual-hosted git repository.

github-merge-queue[bot] pushed a commit to branch 
gh-readonly-queue/master/pr-20476-c2c6bfb83e158c53e7a3c3052b28cf6a179f4107
in repository https://gitbox.apache.org/repos/asf/hudi.git

commit fb6cd1083292d40310ee341b773574afbd5b834f
Author: voonhous <[email protected]>
AuthorDate: Thu Nov 12 02:39:25 2026 +0000

    chore(ci): run fork PRs' Java CI on the contributor's fork (#20476)
    
    * chore(ci): run Java CI through one merge-queue-ready workflow
    
    Prepares Java CI for a GitHub merge queue (#20471, #19612). The queue
    itself is enabled later through .asf.yaml.
    
    - New ci.yml owns the triggers (pull_request, merge_group, push,
      workflow_dispatch) and calls bot.yml and java_ci_engines.yml as
      reusable workflows. Its Required Checks job reports on every PR and
      queue run, and fails unless both called workflows succeed.
    - Only push keeps the path filter: a required check must report on
      every PR, and a selector job would add a second runner wait.
    - Concurrency moves to ci.yml. Pushes are keyed by SHA so queue merge
      bursts never replace a pending master run; only PR runs cancel.
    - Codecov steps skip merge_group runs, which would file coverage under
      master for commits that may never land.
    - validate_source.yml also reports on merge_group, and never cancels
      queue runs.
    
    * chore(ci): run fork PRs' Java CI on the contributor's fork
    
    Second part of #20471, following apache/arrow-rs. Fork PRs to master
    run the Java CI suites on the fork's own runners when the contributor
    pushes; the upstream PR run skips them, and the merge queue runs them
    on ASF runners before merge.
    
    - ci.yml runs on every branch push. Upstream it skips pushes to
      branches other than master, release-* and branch-0.x, and skips both
      suites on fork PRs to master. Release-branch PRs keep upstream
      testing. Fork pushes cancel the older run of the same branch.
    - Required Checks accepts skipped suites only on a fork PR to master,
      and links the fork run from the job summary.
    - New fork_ci_status.yml, adapted from arrow-rs: posts the fork run's
      result on the PR as the informational CI (fork) check.
    - Node tests of the bridge script and of ci.yml's routing run in
      validate-pr-and-source.
    - .github/workflows/README.md gains "Pull requests from forks".
    
    * chore(ci): keep Java CI as two merge-queue-ready workflows
    
    Review on #20473: one ci.yml run holding both workflows puts every
    Java CI job into a single workflow run, 18 jobs at once today and 23
    after #19892, past the ASF Actions policy limit of 20 (15
    recommended) jobs running at once per workflow.
    
    - Drop ci.yml. bot.yml and java_ci_engines.yml are top-level again,
      with the merge_group trigger, the push-only path filter and the
      SHA-keyed push concurrency that ci.yml had.
    - Each ends with its own aggregate job, "Java CI result" and
      "Java CI Engines result", which fails on any failed, cancelled or
      skipped job. Each workflow runs at most 9 jobs at once.
    - README badges point at the two workflows again.
    
    * chore(ci): route fork PRs in both Java CI workflows
    
    Follows #20473 keeping bot.yml and java_ci_engines.yml as separate
    workflows (ASF per-workflow job limit). The fork routing that lived in
    ci.yml moves into both files.
    
    - Both run on every branch push; upstream they skip pushes to branches
      other than master, release-* and branch-0.x, and skip every test job
      on fork PRs to master. The route condition is written once per file
      as a YAML anchor and reused on each test job.
    - Each aggregate job accepts skipped jobs only on a fork PR to master
      and links the fork's run of its workflow.
    - fork_ci_status.yml mirrors both fork runs into one CI (fork) check;
      the worse result wins, and a missing or disabled workflow on the
      fork asks the contributor to enable Actions.
    - Node tests cover the routing of every test job in both files and the
      two-run combination (58 tests).
    
    * chore(ci): re-run fork CI
    
    * chore(ci): re-run fork CI
---
 .github/ci/scripts/test-fork-ci-status.cjs | 540 +++++++++++++++++++++++++++++
 .github/workflows/README.md                |  19 +-
 .github/workflows/bot.yml                  |  81 ++++-
 .github/workflows/fork_ci_status.yml       | 268 ++++++++++++++
 .github/workflows/java_ci_engines.yml      |  77 +++-
 .github/workflows/validate_source.yml      |  21 ++
 6 files changed, 975 insertions(+), 31 deletions(-)

diff --git a/.github/ci/scripts/test-fork-ci-status.cjs 
b/.github/ci/scripts/test-fork-ci-status.cjs
new file mode 100644
index 000000000000..746f7e5b6c45
--- /dev/null
+++ b/.github/ci/scripts/test-fork-ci-status.cjs
@@ -0,0 +1,540 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Adapted from apache/arrow-rs .github/ci/scripts/test-fork-ci-status.cjs.
+const assert = require('node:assert/strict');
+const { execFileSync } = require('node:child_process');
+const { readFileSync } = require('node:fs');
+const path = require('node:path');
+const { test } = require('node:test');
+
+function workflow(name) {
+  return JSON.parse(execFileSync('python3', [
+    '-c', 'import json, sys, yaml; 
print(json.dumps(yaml.safe_load(sys.stdin)))',
+  ], {
+    input: readFileSync(path.join(__dirname, '../../workflows', name)),
+    encoding: 'utf8',
+  }));
+}
+const bridgeWorkflow = workflow('fork_ci_status.yml');
+// The two Java CI workflows the bridge mirrors, each with the id of its 
aggregate job.
+const javaCi = [
+  { file: 'bot.yml', name: 'Java CI', aggregate: 'java-ci-result' },
+  { file: 'java_ci_engines.yml', name: 'Java CI Engines', aggregate: 
'java-ci-engines-result' },
+].map((item) => ({ ...item, workflow: workflow(item.file) }));
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+const bridge = new AsyncFunction('github', 'context', 'core', 'Date',
+  bridgeWorkflow.jobs.bridge.steps[0].with.script);
+const now = Date.UTC(2026, 9, 20, 12);
+class Clock extends Date { static now() { return now; } }
+const sha = 'a'.repeat(40);
+const pr = {
+  number: 10, state: 'open', updated_at: new Date(now).toISOString(),
+  head: {
+    sha, ref: 'feature',
+    repo: { owner: { login: 'contributor' }, name: 'hudi', full_name: 
'contributor/hudi' },
+  },
+  base: { ref: 'master' },
+};
+const run = (id = 1, extra = {}) => ({
+  id, event: 'push', head_sha: sha, head_branch: 'feature', run_attempt: 1,
+  status: 'completed', conclusion: 'success',
+  html_url: 'https://github.com/contributor/hudi/actions/runs/' + id,
+  ...extra,
+});
+
+// runs and workflowState describe bot.yml; java_ci_engines.yml has the same 
unless engineRuns or
+// engineWorkflowState says otherwise.
+async function execute({
+  event = 'schedule', checks = [], runs = [run()], workflowState = 'active',
+  engineRuns = runs, engineWorkflowState = workflowState,
+  recent = [pr], slice = [pr], candidates = [pr], repo = 'hudi',
+  owner = 'apache', runError, count = 1, notification = {}, checkErrors = {},
+} = {}) {
+  const writes = [], calls = [], failures = [];
+  let sweepPage;
+  const github = { rest: { checks: {}, actions: {}, pulls: {} } };
+  const byWorkflow = (id, bot, engines) => {
+    assert.ok(['bot.yml', 'java_ci_engines.yml'].includes(id), id);
+    return id === 'bot.yml' ? bot : engines;
+  };
+  github.rest.checks.listForRef = async () => {};
+  github.rest.pulls.list = async (params) => {
+    calls.push(['pulls', params]);
+    if (params.per_page === 1) return {
+      data: count ? [pr] : [],
+      headers: count ? { link: 
'<https://api.github.com/pulls?per_page=1&page=' + count + '>; rel="last"' } : 
{},
+    };
+    assert.equal(params.per_page, 25);
+    sweepPage = params.page;
+    return { data: slice };
+  };
+  github.rest.actions.listWorkflowRuns = async (params) => {
+    calls.push(['runs', params]);
+    assert.equal(params.owner, 'contributor');
+    assert.equal(params.head_sha, sha);
+    assert.equal(params.branch, 'feature');
+    if (runError) throw Object.assign(new Error('API failure'), { status: 
runError });
+    return { data: { workflow_runs: byWorkflow(params.workflow_id, runs, 
engineRuns) } };
+  };
+  github.rest.actions.getWorkflow = async (params) => {
+    const state = byWorkflow(params.workflow_id, workflowState, 
engineWorkflowState);
+    if (state === null) throw Object.assign(new Error('Not Found'), { status: 
404 });
+    return { data: { state } };
+  };
+  github.rest.checks.create = async (payload) => writes.push({ method: 
'create', ...payload });
+  github.rest.checks.update = async (payload) => writes.push({ method: 
'update', ...payload });
+  github.paginate = async (fn, params) => {
+    if (fn === github.rest.checks.listForRef) {
+      calls.push(['checks', params]);
+      if (checkErrors[params.ref]) throw new Error(checkErrors[params.ref]);
+      return checks;
+    }
+    assert.equal(fn, github.rest.pulls.list);
+    assert.equal(params.head, 'contributor:feature');
+    return candidates;
+  };
+  github.paginate.iterator = async function* () {
+    for (let i = 0; i < recent.length; i += 100) yield { data: recent.slice(i, 
i + 100) };
+  };
+  await bridge(github, {
+    repo: { owner, repo }, eventName: event,
+    payload: { workflow_run: {
+      event: 'pull_request', head_sha: sha, head_branch: 'feature',
+      head_repository: pr.head.repo, pull_requests: [], ...notification,
+    } },
+  }, { info: () => {}, setFailed: (message) => failures.push(message) }, 
Clock);
+  return { writes, calls, sweepPage, failures };
+}
+async function existing(runValue = run()) {
+  const { writes } = await execute({ runs: [runValue] });
+  return {
+    id: 100, app: { slug: 'github-actions' }, external_id: 'hudi-fork-ci:10',
+    ...writes[0], conclusion: writes[0].conclusion || null,
+  };
+}
+
+test('CI completion discovers a fork PR even when the event PR list is empty', 
async () => {
+  const { writes } = await execute({ event: 'workflow_run' });
+  assert.equal(writes.length, 1);
+  assert.equal(writes[0].head_sha, sha);
+  assert.equal(writes[0].name, 'CI (fork)');
+  assert.equal(writes[0].conclusion, 'success');
+  assert.equal(writes[0].details_url, run().html_url);
+});
+test('notifications ignore stale branch heads, release PRs, closed PRs and 
deleted forks', async () => {
+  for (const candidate of [
+    { ...pr, head: { ...pr.head, sha: 'b'.repeat(40) } },
+    { ...pr, base: { ref: 'release-1.2' } },
+    { ...pr, state: 'closed' },
+    { ...pr, head: { ...pr.head, repo: null } },
+  ]) {
+    assert.deepEqual((await execute({ event: 'workflow_run', candidates: 
[candidate] })).writes, []);
+  }
+});
+test('upstream pushes and merge-queue completions cannot create fork checks', 
async () => {
+  for (const event of ['push', 'merge_group']) {
+    assert.deepEqual((await execute({ event: 'workflow_run', notification: { 
event } })).writes, []);
+  }
+});
+test('the bridge does nothing when copied into a fork', async () => {
+  const result = await execute({ owner: 'contributor' });
+  assert.deepEqual(result.calls, []);
+  assert.deepEqual(result.writes, []);
+});
+test('only runs for the exact branch head on push/manual events are mirrored', 
async () => {
+  const result = await execute({ runs: [
+    run(8, { head_sha: 'b'.repeat(40) }),
+    run(7, { head_branch: 'other' }),
+    run(6, { event: 'pull_request' }),
+    run(5, { event: 'workflow_dispatch' }),
+    run(1),
+  ] });
+  assert.equal(result.writes[0].details_url, run(5).html_url);
+});
+for (const [state, expected] of [
+  ['active', 'neutral'], ['disabled_fork', 'action_required'], [null, 
'action_required'],
+]) {
+  test('missing run reports workflow state ' + state, async () => {
+    const { writes } = await execute({ runs: [], workflowState: state });
+    assert.equal(writes[0].conclusion, expected);
+    assert.match(writes[0].output.summary, /Enable workflows/);
+    assert.match(writes[0].output.summary, /only docs or images is skipped by 
the path filter/);
+    assert.deepEqual(JSON.parse(writes[0].output.text).runs.map((item) => 
item.run_id), [null, null]);
+  });
+}
+test('a missing workflow endpoint is handled as missing CI', async () => {
+  const { writes } = await execute({ runError: 404, workflowState: null });
+  assert.equal(writes[0].conclusion, 'action_required');
+});
+test('permission, rate limit and server errors are not reported as missing 
CI', async () => {
+  for (const runError of [403, 429, 500]) {
+    const result = await execute({ runError });
+    assert.deepEqual(result.writes, []);
+    assert.deepEqual(result.failures, ['#10: API failure']);
+    await assert.rejects(execute({ event: 'workflow_run', runError }), /API 
failure/);
+  }
+});
+for (const conclusion of ['failure', 'cancelled', 'timed_out', 
'startup_failure', 'stale']) {
+  test('mirrors ' + conclusion + ' without reporting success', async () => {
+    const { writes } = await execute({ runs: [run(1, { conclusion })] });
+    assert.equal(writes[0].conclusion,
+      ['startup_failure', 'stale'].includes(conclusion) ? 'failure' : 
conclusion);
+  });
+}
+test('a stale run updates an existing check with failure, not the reserved 
conclusion', async () => {
+  const { writes } = await execute({
+    checks: [await existing()], runs: [run(1, { conclusion: 'stale' })],
+  });
+  assert.equal(writes[0].method, 'update');
+  assert.equal(writes[0].conclusion, 'failure');
+});
+for (const source of ['recent', 'slice']) {
+  test('the sweep continues after errors in the ' + source + ' PRs and reports 
every failure', async () => {
+    const broken = ['b', 'c'].map((letter, index) => ({
+      ...pr, number: 20 + index, head: { ...pr.head, sha: letter.repeat(40) },
+    }));
+    const result = await execute({
+      recent: [], slice: [], [source]: [...broken, pr], count: 3,
+      checkErrors: {
+        [broken[0].head.sha]: 'First API failure',
+        [broken[1].head.sha]: 'Second API failure',
+      },
+    });
+    assert.equal(result.writes.length, 1);
+    assert.equal(result.writes[0].external_id, 'hudi-fork-ci:10');
+    assert.equal(result.writes[0].conclusion, 'success');
+    assert.deepEqual(result.failures, ['#20: First API failure\n#21: Second 
API failure']);
+  });
+}
+test('a rerun of the same workflow run updates the existing check', async () 
=> {
+  const check = await existing(run(1, { conclusion: 'failure' }));
+  const { writes } = await execute({ checks: [check], runs: [run(1, { 
run_attempt: 2 })] });
+  assert.equal(writes[0].method, 'update');
+  assert.equal(writes[0].check_run_id, 100);
+  assert.equal(writes[0].conclusion, 'success');
+  assert.deepEqual(JSON.parse(writes[0].output.text).runs.map((item) => 
item.run_attempt), [2, 2]);
+});
+test('a manual run can replace a failed push run', async () => {
+  const check = await existing(run(1, { conclusion: 'failure' }));
+  const { writes } = await execute({
+    checks: [check], runs: [run(2, { event: 'workflow_dispatch' }), run(1)],
+  });
+  assert.equal(writes[0].details_url, run(2).html_url);
+});
+test('a deleted run clears its stale success result', async () => {
+  const { writes } = await execute({ checks: [await existing()], runs: [] });
+  assert.equal(writes[0].method, 'update');
+  assert.equal(writes[0].conclusion, 'neutral');
+});
+test('unchanged results do not consume check write requests', async () => {
+  const check = await existing();
+  // GitHub can replace details_url with the check's own URL.
+  for (const details_url of [check.details_url, 
'https://github.com/apache/hudi/runs/100']) {
+    assert.deepEqual((await execute({ checks: [{ ...check, details_url }] 
})).writes, []);
+  }
+});
+test('a same-name check from another app or PR is not overwritten', async () 
=> {
+  const check = await existing();
+  for (const foreign of [
+    { ...check, app: { slug: 'other-app' } },
+    { ...check, external_id: 'hudi-fork-ci:20' },
+  ]) {
+    assert.equal((await execute({ checks: [foreign] })).writes[0].method, 
'create');
+  }
+});
+test('recent completed checks wait for the rotating sweep', async () => {
+  const { writes, calls } = await execute({ checks: [await existing()], slice: 
[] });
+  assert.deepEqual(writes, []);
+  assert.equal(calls.filter(([kind]) => kind === 'runs').length, 0);
+});
+test('late runs are recovered outside the sweep slice', async () => {
+  const missing = await execute({ runs: [] });
+  const check = { ...await existing(), ...missing.writes[0] };
+  const { writes } = await execute({ checks: [check], slice: [] });
+  assert.equal(writes[0].conclusion, 'success');
+});
+for (const status of ['queued', 'in_progress']) {
+  test('polls recent ' + status + ' runs outside the sweep slice', async () => 
{
+    const check = await existing(run(1, { status, conclusion: null }));
+    const { writes } = await execute({ checks: [check], slice: [] });
+    assert.equal(writes[0].conclusion, 'success');
+  });
+}
+test('the sweep reaches old PRs beyond 500 open PRs', async () => {
+  const old = { ...pr, updated_at: new Date(now - 24 * 3600 * 
1000).toISOString() };
+  const { writes, sweepPage } = await execute({ count: 600, recent: [old], 
slice: [old] });
+  assert.equal(sweepPage, Math.floor(now / (15 * 60 * 1000)) % 24 + 1);
+  assert.equal(writes.length, 1);
+});
+test('an active PR appearing in both lists is polled once', async () => {
+  const { calls } = await execute();
+  assert.deepEqual(calls.filter(([kind]) => kind === 'runs').map(([, params]) 
=> params.workflow_id),
+    ['bot.yml', 'java_ci_engines.yml']);
+});
+test('no open PRs means no fork API calls', async () => {
+  const result = await execute({ count: 0 });
+  assert.equal(result.calls.length, 1);
+  assert.deepEqual(result.writes, []);
+});
+
+// One check combines the fork's runs of both workflows.
+const runUrl = (id) => 'https://github.com/contributor/hudi/actions/runs/' + 
id;
+test('two successful runs report success, link both and record both', async () 
=> {
+  const { writes } = await execute({ runs: [run(1)], engineRuns: [run(2, { 
run_attempt: 3 })] });
+  assert.equal(writes[0].status, 'completed');
+  assert.equal(writes[0].conclusion, 'success');
+  assert.equal(writes[0].details_url, runUrl(1));
+  assert.ok(writes[0].output.summary.includes('- [Java CI](' + runUrl(1) + '): 
success'));
+  assert.ok(writes[0].output.summary.includes('- [Java CI Engines](' + 
runUrl(2) + '): success'));
+  assert.deepEqual(JSON.parse(writes[0].output.text).runs, [
+    { workflow: 'bot.yml', run_id: 1, run_attempt: 1 },
+    { workflow: 'java_ci_engines.yml', run_id: 2, run_attempt: 3 },
+  ]);
+});
+test('one failed run fails the combined check, whichever workflow it is', 
async () => {
+  for (const [bot, engines] of [['failure', 'success'], ['success', 
'failure']]) {
+    const { writes } = await execute({
+      runs: [run(1, { conclusion: bot })], engineRuns: [run(2, { conclusion: 
engines })],
+    });
+    assert.equal(writes[0].conclusion, 'failure', bot + ',' + engines);
+    assert.equal(writes[0].details_url, runUrl(1));
+  }
+});
+test('the worst conclusion of the two runs wins', async () => {
+  const order = ['failure', 'timed_out', 'cancelled', 'action_required', 
'neutral', 'skipped', 'success'];
+  for (const [index, worse] of order.entries()) {
+    for (const better of order.slice(index)) {
+      for (const [bot, engines] of [[worse, better], [better, worse]]) {
+        const { writes } = await execute({
+          runs: [run(1, { conclusion: bot })], engineRuns: [run(2, { 
conclusion: engines })],
+        });
+        assert.equal(writes[0].conclusion, worse, bot + ',' + engines);
+      }
+    }
+  }
+});
+test('the combined check stays in progress until both runs complete', async () 
=> {
+  for (const status of ['queued', 'in_progress']) {
+    for (const [bot, engines] of [
+      [run(1), run(2, { status, conclusion: null })],
+      [run(1, { status, conclusion: null }), run(2, { conclusion: 'failure' 
})],
+    ]) {
+      const { writes } = await execute({ runs: [bot], engineRuns: [engines] });
+      assert.equal(writes[0].status, 'in_progress');
+      assert.equal(writes[0].conclusion, undefined);
+      assert.match(writes[0].output.summary, new RegExp(': ' + status + '$', 
'm'));
+    }
+  }
+  const check = await existing(run(1, { status: 'in_progress', conclusion: 
null }));
+  const { writes } = await execute({ checks: [check], slice: [], runs: 
[run(1)], engineRuns: [run(2)] });
+  assert.equal(writes[0].status, 'completed');
+  assert.equal(writes[0].conclusion, 'success');
+});
+test('a missing run of one workflow reports no fork CI run and links the other 
run', async () => {
+  const { writes } = await execute({ runs: [run(1, { conclusion: 'failure' 
})], engineRuns: [] });
+  assert.equal(writes[0].conclusion, 'neutral');
+  assert.equal(writes[0].output.title, 'No fork CI run for this commit');
+  assert.match(writes[0].output.summary, /^No Java CI Engines run was found 
for /);
+  assert.ok(writes[0].output.summary.includes('- [Java CI](' + runUrl(1) + '): 
failure'));
+  assert.match(writes[0].output.summary, /only docs or images is skipped by 
the path filter/);
+  assert.equal(writes[0].details_url, runUrl(1));
+  assert.deepEqual(JSON.parse(writes[0].output.text).runs.map((item) => 
item.run_id), [1, null]);
+});
+test('a completed check missing one run keeps being polled outside the sweep 
slice', async () => {
+  const missing = await execute({ engineRuns: [] });
+  const check = { ...await existing(), ...missing.writes[0] };
+  const { writes } = await execute({ checks: [check], slice: [], engineRuns: 
[run(2)] });
+  assert.equal(writes[0].conclusion, 'success');
+});
+test('one disabled or missing workflow asks the contributor to enable CI', 
async () => {
+  for (const options of [
+    { engineRuns: [], engineWorkflowState: 'disabled_manually' },
+    { engineRuns: [], engineWorkflowState: null },
+    { runs: [], engineRuns: [run(2)], workflowState: 'disabled_fork', 
engineWorkflowState: 'active' },
+  ]) {
+    const { writes } = await execute(options);
+    assert.equal(writes[0].conclusion, 'action_required', 
JSON.stringify(options));
+    assert.equal(writes[0].output.title, 'Enable CI on your fork');
+    assert.equal(writes[0].details_url, 
'https://github.com/contributor/hudi/actions');
+  }
+});
+test('a rerun of one workflow updates the combined check', async () => {
+  const check = await existing();
+  const { writes } = await execute({
+    checks: [check], engineRuns: [run(1, { run_attempt: 2, conclusion: 
'failure' })],
+  });
+  assert.equal(writes[0].method, 'update');
+  assert.equal(writes[0].conclusion, 'failure');
+  assert.deepEqual(JSON.parse(writes[0].output.text).runs.map((item) => 
item.run_attempt), [1, 2]);
+});
+
+
+// Evaluates the bot.yml and java_ci_engines.yml expressions as JavaScript, 
which shares their
+// syntax for the operators used there. needs.*.result becomes the list of the 
job results.
+function evaluate(expression, scope) {
+  const body = expression.replace(/needs\.\*\.result/g, 
'Object.values(needs).map((job) => job.result)');
+  return new Function(...Object.keys(scope), 'return (' + body + 
');')(...Object.values(scope));
+}
+function interpolate(value, scope) {
+  const whole = /^\s*\$\{\{((?:(?!\}\})[\s\S])*)\}\}\s*$/.exec(value);
+  if (whole) return evaluate(whole[1], scope);
+  return value.replace(/\$\{\{((?:(?!\}\})[\s\S])*)\}\}/g, (_, expression) => 
evaluate(expression, scope));
+}
+const functions = {
+  always: () => true,
+  startsWith: (text, prefix) => text.startsWith(prefix),
+  contains: (list, item) => list.includes(item),
+};
+const withName = (ci, github) => ({ ...github, workflow: ci.name });
+const group = (ci, github) => interpolate(ci.workflow.concurrency.group, { 
github: withName(ci, github) });
+const cancels = (ci, github) => 
interpolate(ci.workflow.concurrency['cancel-in-progress'], { github: 
withName(ci, github) });
+const jobIf = (ci, job, github) => interpolate(ci.workflow.jobs[job].if, { 
github: withName(ci, github), ...functions });
+const testJobs = (ci) => Object.keys(ci.workflow.jobs).filter((job) => job !== 
ci.aggregate);
+// GitHub expressions resolve absent properties to an empty string.
+function context({
+  event_name, repository = 'apache/hudi', ref = 'refs/heads/feature', sha = 
'first',
+  number = '', head = '', base_ref = '',
+}) {
+  return {
+    event_name, repository, ref, sha, base_ref,
+    event: { pull_request: { number, head: { repo: { full_name: head } } } },
+  };
+}
+const forkPr = context({
+  event_name: 'pull_request', ref: 'refs/pull/1/merge', number: 1, head: 
'contributor/hudi', base_ref: 'master',
+});
+const upstreamPr = { ...forkPr, event: { pull_request: { number: 1, head: { 
repo: { full_name: 'apache/hudi' } } } } };
+const queue = context({ event_name: 'merge_group', ref: 
'refs/heads/gh-readonly-queue/master/pr-1-first' });
+const forkPush = context({ event_name: 'push', repository: 'contributor/hudi' 
});
+const upstreamPush = (branch) => context({ event_name: 'push', ref: 
'refs/heads/' + branch });
+
+const FORK_PR = "github.event_name == 'pull_request' && 
github.event.pull_request.head.repo.full_name != github.repository && 
github.base_ref == 'master'";
+const UPSTREAM_OTHER_PUSH = "github.event_name == 'push' && github.repository 
== 'apache/hudi' && github.ref != 'refs/heads/master' && 
!startsWith(github.ref, 'refs/heads/release-') && github.ref != 
'refs/heads/branch-0.x'";
+// PyYAML resolves the `*route` aliases, so every test job shows the expanded 
condition.
+test('every test job carries the route condition, and the aggregate job does 
not', () => {
+  for (const ci of javaCi) {
+    const jobs = testJobs(ci);
+    assert.ok(jobs.length > 1, ci.file);
+    for (const job of jobs) {
+      assert.equal(ci.workflow.jobs[job].if, '${{ !(' + FORK_PR + ') && !(' + 
UPSTREAM_OTHER_PUSH + ') }}', ci.file + ' ' + job);
+    }
+    const aggregate = ci.workflow.jobs[ci.aggregate];
+    assert.equal(aggregate.if, '${{ always() && !(' + UPSTREAM_OTHER_PUSH + ') 
}}', ci.file);
+    assert.equal(aggregate.env.FORK_PR, '${{ ' + FORK_PR + ' }}', ci.file);
+    // A test job missing from needs would never fail the aggregate.
+    assert.deepEqual([...aggregate.needs].sort(), [...jobs].sort(), ci.file);
+  }
+});
+
+// [case, context, whether the test jobs run, whether the aggregate job runs]
+for (const [name, github, tests, aggregate] of [
+  ['fork PR to master', forkPr, false, true],
+  ['fork PR to release-1.2', { ...forkPr, base_ref: 'release-1.2' }, true, 
true],
+  ['fork PR to branch-0.x', { ...forkPr, base_ref: 'branch-0.x' }, true, true],
+  ['same-repository PR to master', upstreamPr, true, true],
+  ['merge queue', queue, true, true],
+  // Only the event_name guard keeps a queue run from matching FORK_PR if 
base_ref were set.
+  ['merge queue with a base_ref', { ...queue, base_ref: 'master' }, true, 
true],
+  ['upstream push to master', upstreamPush('master'), true, true],
+  ['upstream push to release-1.2', upstreamPush('release-1.2'), true, true],
+  ['upstream push to branch-0.x', upstreamPush('branch-0.x'), true, true],
+  ['upstream push to another branch', upstreamPush('feature'), false, false],
+  ['fork push to any branch', forkPush, true, true],
+  ['manual run on an upstream branch', context({ event_name: 
'workflow_dispatch' }), true, true],
+]) {
+  test('routes ' + name, () => {
+    for (const ci of javaCi) {
+      for (const job of testJobs(ci)) assert.equal(jobIf(ci, job, github), 
tests, ci.file + ' ' + job);
+      assert.equal(jobIf(ci, ci.aggregate, github), aggregate, ci.file + ' ' + 
ci.aggregate);
+    }
+  });
+}
+function aggregateFails(ci, github, results) {
+  const job = ci.workflow.jobs[ci.aggregate];
+  const env = { FORK_PR: String(interpolate(job.env.FORK_PR, { github })) };
+  const step = job.steps.find((item) => item.name === 'Fail unless every job 
succeeded');
+  const needs = Object.fromEntries(results.map((result, index) => ['job-' + 
index, { result }]));
+  return interpolate(step.if, { github, env, needs, ...functions });
+}
+test('the aggregate jobs accept skipped test jobs only on fork PRs to master', 
() => {
+  for (const ci of javaCi) {
+    assert.equal(aggregateFails(ci, forkPr, ['skipped', 'skipped', 
'skipped']), false, ci.file);
+    for (const results of [['skipped', 'failure'], ['cancelled', 'skipped'], 
['success', 'skipped'], ['success', 'success']]) {
+      assert.equal(aggregateFails(ci, forkPr, results), true, ci.file + ' ' + 
results.join());
+    }
+    for (const github of [upstreamPr, queue, forkPush, upstreamPush('master'), 
{ ...forkPr, base_ref: 'release-1.2' }]) {
+      assert.equal(aggregateFails(ci, github, ['success', 'success', 
'success']), false, ci.file);
+      for (const results of [['skipped', 'skipped'], ['success', 'skipped'], 
['failure', 'success'], ['success', 'cancelled']]) {
+        assert.equal(aggregateFails(ci, github, results), true, ci.file + ' ' 
+ results.join());
+      }
+    }
+  }
+});
+test('each aggregate job links the fork run of its own workflow on fork PRs', 
() => {
+  for (const ci of javaCi) {
+    const step = ci.workflow.jobs[ci.aggregate].steps.find((item) => item.name 
=== 'Link to fork CI');
+    assert.equal(evaluate(step.if, { env: { FORK_PR: 'true' } }), true);
+    assert.equal(evaluate(step.if, { env: { FORK_PR: 'false' } }), false);
+    assert.ok(step.run.includes('/actions/workflows/' + ci.file + ')'), 
ci.file);
+    assert.doesNotMatch(step.run, /\$\{\{/, ci.file);
+  }
+});
+
+test('successive fork pushes share a cancellation group, separate branches do 
not', () => {
+  for (const ci of javaCi) {
+    assert.equal(cancels(ci, forkPush), true);
+    assert.equal(group(ci, forkPush), group(ci, { ...forkPush, sha: 'second' 
}));
+    assert.notEqual(group(ci, forkPush), group(ci, { ...forkPush, ref: 
'refs/heads/other' }));
+  }
+});
+test('the two workflows never share a concurrency group', () => {
+  for (const github of [forkPush, forkPr, queue, upstreamPush('master')]) {
+    assert.notEqual(group(javaCi[0], github), group(javaCi[1], github));
+  }
+});
+// Unlike arrow-rs, event_name keeps manual runs apart from push runs, on 
forks as upstream.
+test('fork manual runs neither replace nor cancel push runs', () => {
+  for (const ci of javaCi) {
+    const manual = { ...forkPush, event_name: 'workflow_dispatch' };
+    assert.equal(cancels(ci, manual), false);
+    assert.notEqual(group(ci, forkPush), group(ci, manual));
+    assert.notEqual(group(ci, manual), group(ci, { ...manual, ref: 
'refs/heads/other' }));
+    assert.notEqual(group(ci, manual), group(ci, forkPr));
+  }
+});
+test('upstream pushes and merge queue runs remain separate per commit and 
never cancel', () => {
+  for (const ci of javaCi) {
+    const push = upstreamPush('master');
+    assert.equal(cancels(ci, push), false);
+    assert.notEqual(group(ci, push), group(ci, { ...push, sha: 'second' }));
+    // Each queue entry has a ref of its own, which names the PR and the 
commit.
+    assert.equal(cancels(ci, queue), false);
+    assert.notEqual(group(ci, queue), group(ci, {
+      ...queue, ref: 'refs/heads/gh-readonly-queue/master/pr-2-second', sha: 
'second',
+    }));
+    for (const event_name of ['workflow_dispatch', 'merge_group']) {
+      assert.notEqual(group(ci, push), group(ci, { ...push, event_name }));
+    }
+  }
+});
+test('same-named branches from different fork PRs cannot cancel each other', 
() => {
+  for (const ci of javaCi) {
+    assert.equal(cancels(ci, forkPr), true);
+    assert.notEqual(group(ci, forkPr), group(ci, { ...forkPr, event: { 
pull_request: { number: 2 } } }));
+  }
+});
diff --git a/.github/workflows/README.md b/.github/workflows/README.md
index 6f687a5eb2ea..ad9d1fc3962b 100644
--- a/.github/workflows/README.md
+++ b/.github/workflows/README.md
@@ -3,6 +3,19 @@
 When updating the pr template, you must consider if updates need to be made to 
scripts/pr_compliance.py
 
 ## What are the files in workflows?
-- bot.yml: Java CI. Spark lanes (JDK 11 on Spark 3.5, JDK 17 on Spark 4.2). 
Runs on PRs, merge-queue groups and pushes to master, release-* and branch-0.x; 
only push runs are path-filtered. No job depends on another, except the final 
`Java CI result` job, which aggregates the rest and reports on every PR and 
merge-queue run, so it can be required once the merge queue is enabled in 
.asf.yaml. Dropped lanes are commented in place and marked `[CI-TRIM]`
-- java_ci_engines.yml: Java CI Engines. Flink, bundle validation and 
integration tests. Same triggers and layout rules as bot.yml; its aggregate job 
is `Java CI Engines result`. The two are separate workflows because the ASF 
GitHub Actions policy caps the jobs running at once in one workflow at 20, and 
a single workflow for both would exceed it
-- validate_source.yml: PR and Source Validation. One job, 
`validate-pr-and-source`, the only required status check: it checks the PR 
description with scripts/pr_compliance.py, runs that script's own tests, 
validates the PR title, rejects commits with a Claude co-author trailer, and 
runs the source release checks (RAT, binary files, copyright). Never 
path-filtered, because a required check must report on every PR. Also runs on 
merge-queue groups, where only the source release checks apply
+- bot.yml: Java CI. Spark lanes (JDK 11 on Spark 3.5, JDK 17 on Spark 4.2). 
Runs on PRs, merge-queue groups and branch pushes; only push runs are 
path-filtered. Forks run it on every branch push; upstream it skips every job 
on pushes to branches other than master, release-* and branch-0.x, and every 
job but the aggregate on PRs from forks to master (see [Pull requests from 
forks](#pull-requests-from-forks)). No job depends on another, except the final 
`Java CI result` job, which aggregat [...]
+- java_ci_engines.yml: Java CI Engines. Flink, bundle validation and 
integration tests. Same triggers, fork routing and layout rules as bot.yml; its 
aggregate job is `Java CI Engines result`. The two are separate workflows 
because the ASF GitHub Actions policy caps the jobs running at once in one 
workflow at 20, and a single workflow for both would exceed it
+- fork_ci_status.yml: Fork CI status. Mirrors the fork's bot.yml and 
java_ci_engines.yml runs for the head commit of each open fork PR to master 
onto the PR as one informational `CI (fork)` check, which reports the worse of 
the two results. Runs when an upstream Java CI or Java CI Engines run completes 
and every 15 minutes for late runs and reruns. It never checks out PR code. Its 
tests, .github/ci/scripts/test-fork-ci-status.cjs, also cover the routing and 
concurrency of bot.yml and jav [...]
+- validate_source.yml: PR and Source Validation. One job, 
`validate-pr-and-source`, the only required status check: it checks the PR 
description with scripts/pr_compliance.py, runs that script's own tests and the 
fork_ci_status.yml tests, validates the PR title, rejects commits with a Claude 
co-author trailer, and runs the source release checks (RAT, binary files, 
copyright). Never path-filtered, because a required check must report on every 
PR. Also runs on merge-queue groups, where onl [...]
+
+## Pull requests from forks
+
+To reduce load on ASF's shared runners, pull requests from forks to `master` 
run the Java CI suites on your fork using your fork's GitHub runners, with 
lightweight checks upstream. To enable Actions in your fork:
+
+1. Open the Actions tab in your fork and enable workflows before pushing.
+2. Sync your fork and rebase your branch onto upstream `master` to include the 
current CI workflows.
+3. Push your branch.
+
+Each push runs two workflows on your fork, `Java CI` and `Java CI Engines`, 
and both appear in your fork's Actions tab. View results and rerun failed jobs 
there; the PR's `CI (fork)` check combines both runs and may lag. A push that 
changes only docs or images creates no fork run, because both workflows 
path-filter push events.
+
+The `CI (fork)` check links to the fork runs and is informational. When your 
PR is approved and added to the merge queue, both workflows run using ASF's 
runners against the proposed merge with `master`. Release-branch PRs, and PRs 
from branches pushed to apache/hudi itself, keep upstream testing.
diff --git a/.github/workflows/bot.yml b/.github/workflows/bot.yml
index 858cc3b798b6..8383f28e25cc 100644
--- a/.github/workflows/bot.yml
+++ b/.github/workflows/bot.yml
@@ -6,16 +6,21 @@ name: Java CI
 # decision now costs nothing. The filter applies to push only: pull_request 
and merge_group runs
 # must always report the aggregate check at the end of this file, and a 
required check whose
 # workflow the filter skipped never reports, so it would stay pending forever. 
A docs-only PR
-# therefore runs the full suite.
+# therefore runs the full suite; a fork PR to master runs it in the merge 
queue.
 # yml/yaml files are deliberately NOT ignored, unlike the old filter: 
docker/compose/*.yml drives
 # the integration tests, several modules keep yml test resources, and the 
workflow files themselves
 # need CI to run when they change.
+#
+# Push covers every branch because forks run the full suite on their own 
runners for each branch
+# push; see "Pull requests from forks" in README.md. Upstream pushes to 
branches other than master,
+# release-* and branch-0.x skip every job: their PRs test them. Merge-queue 
branches
+# (gh-readonly-queue/...) are validated by merge_group, not push: a skipped 
aggregate job on a
+# queue-branch push would report success and could satisfy the gate early.
 on:
   push:
-    branches:
-      - master
-      - 'release-*'
-      - branch-0.x
+    branches-ignore:
+      - asf-site
+      - 'gh-readonly-queue/**'
     paths:
       - '**'
       # Listed explicitly so the filter does not depend on '**' matching 
dot-prefixed paths.
@@ -38,12 +43,14 @@ on:
     types: [checks_requested]
 
 # A group holds one running and one pending run, and a newer pending run 
replaces the older one
-# even when cancel-in-progress is false. Pushes are therefore keyed by SHA, so 
a burst of queue
-# merges to master never replaces a pending master run. merge_group refs are 
unique per queue
-# entry and only pull_request runs cancel in progress, so queue runs are never 
cancelled.
+# even when cancel-in-progress is false. Pushes to apache/hudi are therefore 
keyed by SHA, so a
+# burst of queue merges to master never replaces a pending master run. Pushes 
on a fork are keyed
+# by branch and cancel in progress, so a new push to a PR branch replaces the 
run of the older
+# head instead of spending fork runner time on it. merge_group refs are unique 
per queue entry
+# and merge_group runs never cancel in progress, so queue runs are never 
cancelled.
 concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name }}-${{ 
github.event.pull_request.number || (github.event_name == 'push' && github.sha) 
|| github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ 
github.event.pull_request.number || (github.event_name == 'push' && 
github.repository == 'apache/hudi' && github.sha) || github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' || 
(github.event_name == 'push' && github.repository != 'apache/hudi') }}
 
 env:
   # The retry/timeout knobs below are maven-resolver (aether.*) properties. 
Maven 3.9 resolves
@@ -59,6 +66,22 @@ env:
   SCALA_TEST_DML_FILTER: -DwildcardSuites=org.apache.spark.sql.hudi.dml
   SCALA_TEST_OTHERS_FILTER: 
-DwildcardSuites=org.apache.hudi,org.apache.spark.hudi,org.apache.spark.sql.avro,org.apache.spark.sql.execution,org.apache.spark.sql.hive,org.apache.spark.sql.hudi.analysis,org.apache.spark.sql.hudi.blob,org.apache.spark.sql.hudi.catalog,org.apache.spark.sql.hudi.command,org.apache.spark.sql.hudi.common,org.apache.spark.sql.hudi.ddl,org.apache.spark.sql.hudi.procedure,org.apache.spark.sql.hudi.feature
 
+# Two conditions route the jobs. GitHub expressions cannot be named, so the 
first test job spells
+# them out in full under the YAML anchor `route`, every other test job reuses 
it through the alias
+# `*route`, and the aggregate job at the end spells out the parts it needs.
+#
+# FORK_PR, a pull request from a fork to master:
+#   github.event_name == 'pull_request' && 
github.event.pull_request.head.repo.full_name != github.repository && 
github.base_ref == 'master'
+# Its test jobs already run on the fork's runners when the contributor pushes 
the branch, and
+# fork_ci_status.yml mirrors that run, together with the fork's 
java_ci_engines.yml run, onto the PR as the
+# informational `CI (fork)` check. The merge queue then runs them on ASF 
runners against the
+# proposed merge with master. The event_name guard matters: on merge_group the 
pull_request fields
+# are empty strings, and an empty head repository differs from 
github.repository. Fork PRs to
+# release-* and branch-0.x keep upstream testing, since only master merges 
through the queue.
+#
+# UPSTREAM_OTHER_PUSH, a push to apache/hudi other than to master, release-* 
or branch-0.x:
+#   github.event_name == 'push' && github.repository == 'apache/hudi' && 
github.ref != 'refs/heads/master' && !startsWith(github.ref, 
'refs/heads/release-') && github.ref != 'refs/heads/branch-0.x'
+# Such branches back same-repository PRs, which test them through pull_request.
 jobs:
   # hudi-cli rides along with hudi-spark-client here rather than joining the 
catch-all
   # module lists in test-common-and-other-modules: its functional suite starts 
a
@@ -67,6 +90,7 @@ jobs:
   # this job's build instead of paying for a second one. It stays listed in 
the catch-all
   # job's UT_MODULES/FT_MODULES exclusions so the tests are not run twice.
   test-spark-client-and-hadoop-common:
+    if: &route ${{ !(github.event_name == 'pull_request' && 
github.event.pull_request.head.repo.full_name != github.repository && 
github.base_ref == 'master') && !(github.event_name == 'push' && 
github.repository == 'apache/hudi' && github.ref != 'refs/heads/master' && 
!startsWith(github.ref, 'refs/heads/release-') && github.ref != 
'refs/heads/branch-0.x') }}
     runs-on: ubuntu-24.04
     timeout-minutes: 75
     strategy:
@@ -143,6 +167,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
 
   test-utilities:
+    if: *route
     runs-on: ubuntu-24.04
     timeout-minutes: 60
     strategy:
@@ -195,6 +220,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
 
   test-common-and-other-modules:
+    if: *route
     runs-on: ubuntu-24.04
     timeout-minutes: 90
     strategy:
@@ -585,6 +611,7 @@ jobs:
 #          token: ${{ secrets.CODECOV_TOKEN }}
 
   test-hudi-hadoop-mr-and-hudi-java-client:
+    if: *route
     runs-on: ubuntu-24.04
     timeout-minutes: 40
     strategy:
@@ -630,6 +657,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
 
   test-spark-java17-java-tests-part1:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -687,6 +715,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
 
   test-spark-java17-java-tests-part2:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -754,6 +783,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
 
   test-spark-java17-java-tests-part3:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -815,6 +845,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
 
   test-spark-java17-scala-dml-tests:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -876,6 +907,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
 
   test-spark-java17-scala-other-tests:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -982,11 +1014,14 @@ jobs:
   # failed or cancelled one. Each workflow has its own check rather than one 
for both, because the
   # ASF GitHub Actions policy caps the jobs running at once in one workflow at 
20 (15 recommended),
   # and a single run of both workflows would exceed it. Adding or resharding a 
job means adding its
-  # id to `needs` below, and nothing else.
+  # id to `needs` below and `if: *route` to the job, and nothing else. The one 
exception to the
+  # skipped-job rule is FORK_PR, where every test job skips on purpose and the 
merge queue runs
+  # them before merge. UPSTREAM_OTHER_PUSH skips this job too, since nothing 
ran that it could
+  # aggregate.
   java-ci-result:
     name: Java CI result
     runs-on: ubuntu-slim
-    if: always()
+    if: ${{ always() && !(github.event_name == 'push' && github.repository == 
'apache/hudi' && github.ref != 'refs/heads/master' && !startsWith(github.ref, 
'refs/heads/release-') && github.ref != 'refs/heads/branch-0.x') }}
     permissions: {}
     needs:
       - test-spark-client-and-hadoop-common
@@ -998,13 +1033,31 @@ jobs:
       - test-spark-java17-java-tests-part3
       - test-spark-java17-scala-dml-tests
       - test-spark-java17-scala-other-tests
+    env:
+      FORK_PR: ${{ github.event_name == 'pull_request' && 
github.event.pull_request.head.repo.full_name != github.repository && 
github.base_ref == 'master' }}
     steps:
       - name: Summarize job results
         env:
           NEEDS: ${{ toJSON(needs) }}
         run: echo "$NEEDS"
+      # The upstream run of a fork PR tests nothing, so point the contributor 
at the fork run.
+      - name: Link to fork CI
+        if: env.FORK_PR == 'true'
+        env:
+          FORK_REPOSITORY: ${{ github.event.pull_request.head.repo.full_name }}
+          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          {
+            printf 'Full test results: [Java CI on 
%s](https://github.com/%s/actions/workflows/bot.yml).\n\n' "$FORK_REPOSITORY" 
"$FORK_REPOSITORY"
+            printf 'Look for commit `%s`. Enable Actions in your fork and push 
your branch if no run exists.\n\n' "$PR_HEAD_SHA"
+            printf 'This upstream PR run skips the Java CI test jobs. The 
merge queue runs them on ASF runners before merge.\n'
+          } >> "$GITHUB_STEP_SUMMARY"
       - name: Fail unless every job succeeded
-        if: contains(needs.*.result, 'failure') || contains(needs.*.result, 
'cancelled') || contains(needs.*.result, 'skipped')
+        if: >-
+          ${{ env.FORK_PR == 'true' && (contains(needs.*.result, 'success') || 
contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled'))
+          || env.FORK_PR != 'true' && (contains(needs.*.result, 'failure') || 
contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped')) }}
+        env:
+          REQUIREMENT: ${{ env.FORK_PR == 'true' && 'Every job in Java CI must 
be skipped on a fork PR to master.' || 'Every job in Java CI must succeed.' }}
         run: |
-          echo "::error::Every job in Java CI must succeed. The summary step 
above lists each result."
+          echo "::error::$REQUIREMENT The summary step above lists each 
result."
           exit 1
diff --git a/.github/workflows/fork_ci_status.yml 
b/.github/workflows/fork_ci_status.yml
new file mode 100644
index 000000000000..cd1886201656
--- /dev/null
+++ b/.github/workflows/fork_ci_status.yml
@@ -0,0 +1,268 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Adapted from apache/arrow-rs .github/workflows/fork_ci_status.yml.
+# Mirror fork results as the informational CI (fork) check after upstream PR CI
+# completes and through scheduled polling for late runs and reruns. The fork's
+# Java CI (bot.yml) and Java CI Engines (java_ci_engines.yml) runs for the PR
+# head combine into that one check, which reports the worse result. Read fork
+# runs and write upstream checks using reviewed default-branch code.
+# No checkout, artifacts, or code from the pull request are used here.
+# Test with Python 3.11+, PyYAML, and Node.js 24:
+#   node --test .github/ci/scripts/test-fork-ci-status.cjs
+# Tests mock GitHub APIs. End-to-end testing requires a test repository with
+# the upstream guards adapted and this workflow installed on its default 
branch.
+name: Fork CI status
+
+on:
+  workflow_run:
+    workflows: [Java CI, Java CI Engines]
+    types: [completed]
+  schedule:
+    - cron: '7,22,37,52 * * * *'
+  workflow_dispatch:
+
+permissions:
+  actions: read
+  checks: write
+  pull-requests: read
+
+# Like DataFusion, group notifications separately from scheduled/manual sweeps.
+# workflow_run identifies the fork and branch rather than the PR number. Both
+# upstream workflows notify for the same branch, and either notification syncs
+# the whole combined check, so the later one may cancel the earlier.
+concurrency:
+  group: ${{ github.workflow }}-${{ 
github.event.workflow_run.head_repository.full_name || 'update' }}-${{ 
github.event.workflow_run.head_branch }}
+  cancel-in-progress: ${{ github.event_name == 'workflow_run' }}
+
+jobs:
+  bridge:
+    if: github.repository == 'apache/hudi' && (github.event_name != 
'workflow_run' || github.event.workflow_run.event == 'pull_request')
+    name: Mirror the fork run
+    runs-on: ubuntu-slim
+    timeout-minutes: 10
+    steps:
+      - name: Create or update the check
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3  
# v9.0.0
+        with:
+          script: |
+            // Adapted from apache/datafusion#25591. Fork results are 
informational:
+            // contributors control their workflows; only upstream merge-queue 
CI gates merging.
+            const CHECK = 'CI (fork)';
+            // Java CI is split across two workflows to stay under the ASF 
limit on jobs running
+            // at once per workflow. The check combines them, and its details 
link the first.
+            const WORKFLOWS = [
+              { file: 'bot.yml', name: 'Java CI' },
+              { file: 'java_ci_engines.yml', name: 'Java CI Engines' },
+            ];
+            const upstream = { owner: context.repo.owner, repo: 
context.repo.repo };
+            const repository = upstream.owner + '/' + upstream.repo;
+            const GUIDE = 
'https://github.com/apache/hudi/blob/master/.github/workflows/README.md#pull-requests-from-forks';
+            const SWEEP_SIZE = 25;
+            const listing = { ...upstream, state: 'open', base: 'master', 
sort: 'updated', direction: 'desc' };
+            const isForkPr = (pr) => pr.state === 'open' && pr.head.repo &&
+              pr.head.repo.full_name.toLowerCase() !== 
repository.toLowerCase() && pr.base.ref === 'master';
+            const externalId = (pr) => 'hudi-fork-ci:' + pr.number;
+            // The check conclusions, worst first: the combined check reports 
the worst of its runs.
+            // Run conclusions a check cannot take, such as stale or 
startup_failure, count as failure.
+            const CONCLUSIONS = [
+              'failure', 'timed_out', 'cancelled', 'action_required', 
'neutral', 'skipped', 'success',
+            ];
+            const conclusionOf = (run) => CONCLUSIONS.includes(run.conclusion) 
? run.conclusion : 'failure';
+            const UPDATE_NOTE =
+              'This check is informational: the contributor controls the fork 
workflow. ' +
+              'The upstream merge queue runs the required CI checks on the 
proposed merge result. ' +
+              'Active or missing runs on recently updated PRs are polled every 
15 minutes; ' +
+              'a rotating sweep also discovers reruns on older PRs. Scheduled 
updates may be delayed.';
+
+            // An absent workflow/run is expected on a fork with Actions 
disabled. Other
+            // API errors must fail the bridge rather than falsely reporting 
missing CI.
+            async function optional(request) {
+              try {
+                return (await request()).data;
+              } catch (error) {
+                if (error.status === 404) return null;
+                throw error;
+              }
+            }
+
+            async function syncCheck(pr, includeCompleted = true) {
+              if (!isForkPr(pr)) return;
+              const fork = { owner: pr.head.repo.owner.login, repo: 
pr.head.repo.name };
+              const sha = pr.head.sha;
+              const checks = await 
github.paginate(github.rest.checks.listForRef, {
+                ...upstream, ref: sha, check_name: CHECK, per_page: 100,
+              });
+              const check = checks.find((item) =>
+                item.app?.slug === 'github-actions' && item.external_id === 
externalId(pr));
+              let previous = {};
+              try { previous = JSON.parse(check?.output?.text || '{}'); } 
catch {}
+              // A missing run must keep being polled, even though its check 
is completed.
+              if (!includeCompleted && check?.status === 'completed' &&
+                  previous.runs?.every((item) => item.run_id)) return;
+
+              // Ignore PR merge-ref runs. The named workflows on push/manual
+              // events test the branch head; contributors still control their 
code.
+              const runs = [];
+              for (const workflow of WORKFLOWS) {
+                const data = await optional(() => 
github.rest.actions.listWorkflowRuns({
+                  ...fork, workflow_id: workflow.file, head_sha: sha, branch: 
pr.head.ref, per_page: 100,
+                }));
+                runs.push((data?.workflow_runs || []).filter((item) =>
+                  item.head_sha === sha && item.head_branch === pr.head.ref &&
+                  ['push', 'workflow_dispatch'].includes(item.event)
+                ).sort((a, b) => b.id - a.id)[0]);
+              }
+              const runList = WORKFLOWS.map((workflow, index) => {
+                const item = runs[index];
+                if (!item) return '- ' + workflow.name + ': no run';
+                return '- [' + workflow.name + '](' + item.html_url + '): ' +
+                  (item.status === 'completed' ? conclusionOf(item) : 
item.status);
+              }).join('\n');
+              const text = JSON.stringify({
+                head_sha: sha,
+                runs: WORKFLOWS.map((workflow, index) => ({
+                  workflow: workflow.file,
+                  run_id: runs[index]?.id ?? null,
+                  run_attempt: runs[index]?.run_attempt ?? null,
+                })),
+              });
+              let payload;
+              if (runs.every(Boolean)) {
+                // The check stays in progress until every run completes, then 
takes the worst result.
+                const completed = runs.every((item) => item.status === 
'completed');
+                const conclusion = CONCLUSIONS.find((value) => 
runs.some((item) => conclusionOf(item) === value));
+                payload = {
+                  status: completed ? 'completed' : 'in_progress',
+                  ...(completed ? { conclusion } : {}),
+                  details_url: runs[0].html_url,
+                  output: {
+                    title: 'Fork CI: ' + (completed ? conclusion : 
'in_progress'),
+                    summary: [
+                      'Fork CI on ' + pr.head.repo.full_name + ' for ' + sha + 
':\n' + runList,
+                      'Rerun failed checks in the fork. A green fork run tests 
the branch head, not its merge with master.',
+                      UPDATE_NOTE,
+                    ].join('\n\n'),
+                    text,
+                  },
+                };
+              } else {
+                // One missing or disabled workflow is enough to need the 
contributor's action.
+                const states = [];
+                for (const workflow of WORKFLOWS) {
+                  states.push(await optional(() => 
github.rest.actions.getWorkflow({
+                    ...fork, workflow_id: workflow.file,
+                  })));
+                }
+                const disabled = states.some((workflow) => !workflow || 
workflow.state.startsWith('disabled'));
+                const missing = WORKFLOWS.filter((workflow, index) => 
!runs[index]).map((workflow) => workflow.name);
+                const actions = 'https://github.com/' + pr.head.repo.full_name 
+ '/actions';
+                payload = {
+                  status: 'completed',
+                  conclusion: disabled ? 'action_required' : 'neutral',
+                  details_url: disabled ? actions : 
(runs.find(Boolean)?.html_url || actions),
+                  output: {
+                    title: disabled ? 'Enable CI on your fork' : 'No fork CI 
run for this commit',
+                    summary: [
+                      'No ' + missing.join(' or ') + ' run was found for ' + 
sha + ' on ' + pr.head.repo.full_name + '.',
+                      ...(runs.some(Boolean) ? [runList] : []),
+                      'Enable workflows in the Actions tab of your fork, 
sync/rebase onto master to include the fork CI workflows, ' +
+                      'then push your branch. A newly pushed run may take a 
moment to appear.',
+                      'A push that changes only docs or images is skipped by 
the path filters of bot.yml and java_ci_engines.yml, ' +
+                      'so no run exists for such a commit.',
+                      UPDATE_NOTE,
+                      '[Fork CI setup](' + GUIDE + ')',
+                    ].join('\n\n'),
+                    text,
+                  },
+                };
+              }
+              if (check && check.status === payload.status &&
+                  check.conclusion === (payload.conclusion || null) &&
+                  check.output?.text === payload.output.text &&
+                  check.output?.summary === payload.output.summary) return;
+              if (check) {
+                await github.rest.checks.update({ ...upstream, check_run_id: 
check.id, ...payload });
+              } else {
+                await github.rest.checks.create({
+                  ...upstream, name: CHECK, head_sha: sha, external_id: 
externalId(pr), ...payload,
+                });
+              }
+              core.info('#' + pr.number + ': ' + (payload.conclusion || 
payload.status));
+            }
+
+            async function notify() {
+              const run = context.payload.workflow_run;
+              if (run.event !== 'pull_request' || !run.head_repository ||
+                  run.head_repository.full_name.toLowerCase() === 
repository.toLowerCase()) return;
+              // GitHub can leave workflow_run.pull_requests empty for fork 
PRs. Resolve
+              // from the API instead, and recheck the current head to ignore 
stale runs.
+              const prs = await github.paginate(github.rest.pulls.list, {
+                ...listing, head: run.head_repository.owner.login + ':' + 
run.head_branch, per_page: 100,
+              });
+              for (const pr of prs) {
+                if (pr.head.sha === run.head_sha &&
+                    pr.head.repo?.full_name.toLowerCase() === 
run.head_repository.full_name.toLowerCase()) {
+                  await syncCheck(pr);
+                }
+              }
+            }
+
+            async function update() {
+              const errors = [];
+              // A failed update must not prevent unrelated PRs from being 
refreshed.
+              async function syncPr(pr, includeCompleted) {
+                try {
+                  await syncCheck(pr, includeCompleted);
+                } catch (error) {
+                  errors.push('#' + pr.number + ': ' + error.message);
+                }
+              }
+              const count = await github.rest.pulls.list({ ...listing, 
per_page: 1 });
+              const last = 
/[?&]page=(\d+)>;\s*rel="last"/.exec(count.headers.link || '');
+              const total = last ? Number(last[1]) : count.data.length;
+              if (!total) return;
+              const slices = Math.ceil(total / SWEEP_SIZE);
+              const slot = Math.floor(Date.now() / (15 * 60 * 1000));
+              const { data: slice } = await github.rest.pulls.list({
+                ...listing, per_page: SWEEP_SIZE, page: (slot % slices) + 1,
+              });
+              const sweepNumbers = new Set(slice.map((pr) => pr.number));
+              const seen = new Set();
+              const cutoff = Date.now() - 6 * 3600 * 1000;
+              // Poll active and missing checks on recently updated PRs, and 
completed
+              // checks only in the rotating slice. This bounds expensive fork 
API calls.
+              const pages = github.paginate.iterator(github.rest.pulls.list, { 
...listing, per_page: 100 });
+              for await (const page of pages) {
+                let stale = false;
+                for (const pr of page.data) {
+                  if (new Date(pr.updated_at).getTime() < cutoff) { stale = 
true; break; }
+                  seen.add(pr.number);
+                  await syncPr(pr, sweepNumbers.has(pr.number));
+                }
+                if (stale) break;
+              }
+              for (const pr of slice) {
+                if (!seen.has(pr.number)) await syncPr(pr);
+              }
+              if (errors.length) core.setFailed(errors.join('\n'));
+            }
+
+            if (repository === 'apache/hudi') {
+              if (context.eventName === 'workflow_run') await notify();
+              else await update();
+            }
diff --git a/.github/workflows/java_ci_engines.yml 
b/.github/workflows/java_ci_engines.yml
index 21a1ff200ebd..6e5d81fd7fa6 100644
--- a/.github/workflows/java_ci_engines.yml
+++ b/.github/workflows/java_ci_engines.yml
@@ -6,16 +6,21 @@ name: Java CI Engines
 # decision now costs nothing. The filter applies to push only: pull_request 
and merge_group runs
 # must always report the aggregate check at the end of this file, and a 
required check whose
 # workflow the filter skipped never reports, so it would stay pending forever. 
A docs-only PR
-# therefore runs the full suite.
+# therefore runs the full suite; a fork PR to master runs it in the merge 
queue.
 # yml/yaml files are deliberately NOT ignored, unlike the old filter: 
docker/compose/*.yml drives
 # the integration tests, several modules keep yml test resources, and the 
workflow files themselves
 # need CI to run when they change.
+#
+# Push covers every branch because forks run the full suite on their own 
runners for each branch
+# push; see "Pull requests from forks" in README.md. Upstream pushes to 
branches other than master,
+# release-* and branch-0.x skip every job: their PRs test them. Merge-queue 
branches
+# (gh-readonly-queue/...) are validated by merge_group, not push: a skipped 
aggregate job on a
+# queue-branch push would report success and could satisfy the gate early.
 on:
   push:
-    branches:
-      - master
-      - 'release-*'
-      - branch-0.x
+    branches-ignore:
+      - asf-site
+      - 'gh-readonly-queue/**'
     paths:
       - '**'
       # Listed explicitly so the filter does not depend on '**' matching 
dot-prefixed paths.
@@ -38,12 +43,14 @@ on:
     types: [checks_requested]
 
 # A group holds one running and one pending run, and a newer pending run 
replaces the older one
-# even when cancel-in-progress is false. Pushes are therefore keyed by SHA, so 
a burst of queue
-# merges to master never replaces a pending master run. merge_group refs are 
unique per queue
-# entry and only pull_request runs cancel in progress, so queue runs are never 
cancelled.
+# even when cancel-in-progress is false. Pushes to apache/hudi are therefore 
keyed by SHA, so a
+# burst of queue merges to master never replaces a pending master run. Pushes 
on a fork are keyed
+# by branch and cancel in progress, so a new push to a PR branch replaces the 
run of the older
+# head instead of spending fork runner time on it. merge_group refs are unique 
per queue entry
+# and merge_group runs never cancel in progress, so queue runs are never 
cancelled.
 concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name }}-${{ 
github.event.pull_request.number || (github.event_name == 'push' && github.sha) 
|| github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ 
github.event.pull_request.number || (github.event_name == 'push' && 
github.repository == 'apache/hudi' && github.sha) || github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' || 
(github.event_name == 'push' && github.repository != 'apache/hudi') }}
 
 env:
   # The retry/timeout knobs below are maven-resolver (aether.*) properties. 
Maven 3.9 resolves
@@ -56,8 +63,25 @@ env:
   FLINK_IT_FILTER1: -Dit.test=ITTestHoodieDataSource
   FLINK_IT_FILTER2: -Dit.test=!ITTestHoodieDataSource
 
+# Two conditions route the jobs. GitHub expressions cannot be named, so the 
first test job spells
+# them out in full under the YAML anchor `route`, every other test job reuses 
it through the alias
+# `*route`, and the aggregate job at the end spells out the parts it needs.
+#
+# FORK_PR, a pull request from a fork to master:
+#   github.event_name == 'pull_request' && 
github.event.pull_request.head.repo.full_name != github.repository && 
github.base_ref == 'master'
+# Its test jobs already run on the fork's runners when the contributor pushes 
the branch, and
+# fork_ci_status.yml mirrors that run, together with the fork's bot.yml run, 
onto the PR as the
+# informational `CI (fork)` check. The merge queue then runs them on ASF 
runners against the
+# proposed merge with master. The event_name guard matters: on merge_group the 
pull_request fields
+# are empty strings, and an empty head repository differs from 
github.repository. Fork PRs to
+# release-* and branch-0.x keep upstream testing, since only master merges 
through the queue.
+#
+# UPSTREAM_OTHER_PUSH, a push to apache/hudi other than to master, release-* 
or branch-0.x:
+#   github.event_name == 'push' && github.repository == 'apache/hudi' && 
github.ref != 'refs/heads/master' && !startsWith(github.ref, 
'refs/heads/release-') && github.ref != 'refs/heads/branch-0.x'
+# Such branches back same-repository PRs, which test them through pull_request.
 jobs:
   test-flink-1:
+    if: &route ${{ !(github.event_name == 'pull_request' && 
github.event.pull_request.head.repo.full_name != github.repository && 
github.base_ref == 'master') && !(github.event_name == 'push' && 
github.repository == 'apache/hudi' && github.ref != 'refs/heads/master' && 
!startsWith(github.ref, 'refs/heads/release-') && github.ref != 
'refs/heads/branch-0.x') }}
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -129,6 +153,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
 
   test-flink-2:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -225,6 +250,7 @@ jobs:
 #          ./packaging/bundle-validation/run_docker_java17.sh
 
   validate-bundles:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -316,6 +342,7 @@ jobs:
           ./packaging/bundle-validation/ci_run.sh hudi_docker_java17 
$HUDI_VERSION openjdk17
 
   validate-bundle-spark4:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -427,6 +454,7 @@ jobs:
 #          ./packaging/bundle-validation/ci_run.sh hudi_docker_java17 
$HUDI_VERSION openjdk17
 
   integration-tests:
+    if: *route
     runs-on: ubuntu-24.04
     strategy:
       matrix:
@@ -630,11 +658,14 @@ jobs:
   # failed or cancelled one. Each workflow has its own check rather than one 
for both, because the
   # ASF GitHub Actions policy caps the jobs running at once in one workflow at 
20 (15 recommended),
   # and a single run of both workflows would exceed it. Adding or resharding a 
job means adding its
-  # id to `needs` below, and nothing else.
+  # id to `needs` below and `if: *route` to the job, and nothing else. The one 
exception to the
+  # skipped-job rule is FORK_PR, where every test job skips on purpose and the 
merge queue runs
+  # them before merge. UPSTREAM_OTHER_PUSH skips this job too, since nothing 
ran that it could
+  # aggregate.
   java-ci-engines-result:
     name: Java CI Engines result
     runs-on: ubuntu-slim
-    if: always()
+    if: ${{ always() && !(github.event_name == 'push' && github.repository == 
'apache/hudi' && github.ref != 'refs/heads/master' && !startsWith(github.ref, 
'refs/heads/release-') && github.ref != 'refs/heads/branch-0.x') }}
     permissions: {}
     needs:
       - test-flink-1
@@ -642,13 +673,31 @@ jobs:
       - validate-bundles
       - validate-bundle-spark4
       - integration-tests
+    env:
+      FORK_PR: ${{ github.event_name == 'pull_request' && 
github.event.pull_request.head.repo.full_name != github.repository && 
github.base_ref == 'master' }}
     steps:
       - name: Summarize job results
         env:
           NEEDS: ${{ toJSON(needs) }}
         run: echo "$NEEDS"
+      # The upstream run of a fork PR tests nothing, so point the contributor 
at the fork run.
+      - name: Link to fork CI
+        if: env.FORK_PR == 'true'
+        env:
+          FORK_REPOSITORY: ${{ github.event.pull_request.head.repo.full_name }}
+          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          {
+            printf 'Full test results: [Java CI Engines on 
%s](https://github.com/%s/actions/workflows/java_ci_engines.yml).\n\n' 
"$FORK_REPOSITORY" "$FORK_REPOSITORY"
+            printf 'Look for commit `%s`. Enable Actions in your fork and push 
your branch if no run exists.\n\n' "$PR_HEAD_SHA"
+            printf 'This upstream PR run skips the Java CI Engines test jobs. 
The merge queue runs them on ASF runners before merge.\n'
+          } >> "$GITHUB_STEP_SUMMARY"
       - name: Fail unless every job succeeded
-        if: contains(needs.*.result, 'failure') || contains(needs.*.result, 
'cancelled') || contains(needs.*.result, 'skipped')
+        if: >-
+          ${{ env.FORK_PR == 'true' && (contains(needs.*.result, 'success') || 
contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled'))
+          || env.FORK_PR != 'true' && (contains(needs.*.result, 'failure') || 
contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped')) }}
+        env:
+          REQUIREMENT: ${{ env.FORK_PR == 'true' && 'Every job in Java CI 
Engines must be skipped on a fork PR to master.' || 'Every job in Java CI 
Engines must succeed.' }}
         run: |
-          echo "::error::Every job in Java CI Engines must succeed. The 
summary step above lists each result."
+          echo "::error::$REQUIREMENT The summary step above lists each 
result."
           exit 1
diff --git a/.github/workflows/validate_source.yml 
b/.github/workflows/validate_source.yml
index 17c4e710bcbe..2c35e6e26984 100644
--- a/.github/workflows/validate_source.yml
+++ b/.github/workflows/validate_source.yml
@@ -69,6 +69,27 @@ jobs:
             exit 1
           fi
 
+      # Seconds of node tests of the fork CI status bridge and of the bot.yml 
and
+      # java_ci_engines.yml routing they check, so they run on every PR 
instead of path-filtering on
+      # the three workflow files. Unlike the PR metadata checks they need no 
PR data, so they also
+      # run on merge-queue groups and pushes. The tests read the workflow 
files through PyYAML. A
+      # pip install into the runner's system Python can be refused (PEP 668), 
so the step gets its
+      # own Python.
+      - name: Set up Python for the fork_ci_status.yml tests
+        if: ${{ !cancelled() }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Test fork_ci_status.yml
+        if: ${{ !cancelled() }}
+        run: |
+          for attempt in 1 2 3; do
+            python3 -m pip install PyYAML==6.0.3 && break
+            if [ "$attempt" -eq 3 ]; then exit 1; fi
+            sleep 5
+          done
+          node --test .github/ci/scripts/test-fork-ci-status.cjs
+
       - name: Check for legacy PR title format using JIRA or MINOR
         id: check-legacy-format
         if: ${{ !cancelled() && env.CHECK_PR_METADATA == 'true' }}

Reply via email to