Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Auto-run minor release builds on a cron (#73173)

Nemanja Glumac1cb49ebc3c91
diff --git a/.github/workflows/build-for-release.yml b/.github/workflows/build-for-release.yml
index 19108ce20c0..663c4980298 100644
--- a/.github/workflows/build-for-release.yml
+++ b/.github/workflows/build-for-release.yml
@@ -64,7 +64,6 @@ jobs:
}
});
-
check-version:
runs-on: ${{ vars.DEFAULT_RUNNER_KEY }}
timeout-minutes: 10
@@ -183,6 +182,49 @@ jobs:
build_process,
};
+ manage-milestones:
+ # Close the milestone we're about to ship and open the next one BEFORE building,
+ # so any PRs that merge while the build is in flight are tagged with the next
+ # milestone (not the one about to be released). Gated on the preflight checks
+ # so a bad version/commit input doesn't rotate the milestone spuriously.
+ runs-on: ${{ vars.DEFAULT_RUNNER_KEY }}
+ needs: [check-version, check-commit]
+ timeout-minutes: 15
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ sparse-checkout: |
+ release
+ .github
+ - name: Prepare release scripts
+ uses: ./.github/actions/prepare-release-scripts
+ - name: Update milestones
+ uses: actions/github-script@v7
+ with:
+ script: | # js
+ const { closeMilestone, openNextMilestones, isPreReleaseVersion } = require('${{ github.workspace }}/release/dist/index.cjs');
+
+ const version = '${{ inputs.version }}';
+
+ if (isPreReleaseVersion(version)) {
+ console.log("This is a prerelease version, skipping milestone management");
+ return;
+ }
+
+ await closeMilestone({
+ github,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ version,
+ }).catch(console.error);
+
+ await openNextMilestones({
+ github,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ version,
+ }).catch(console.error);
+
build-uberjar-for-release:
needs: [check-version, check-commit, get-build-requirements]
runs-on: ${{ vars.DEFAULT_RUNNER_KEY }}
diff --git a/.github/workflows/release-minor.yml b/.github/workflows/release-minor.yml
new file mode 100644
index 00000000000..514bbf665c9
--- /dev/null
+++ b/.github/workflows/release-minor.yml
@@ -0,0 +1,129 @@
+name: Release 1c - Auto Minor
+run-name: Minor Release ${{ inputs.version }}
+
+on:
+ workflow_dispatch:
+ inputs:
+ version:
+ description: "Major Metabase version (e.g. 45, 52, 68)"
+ type: number
+ required: true
+ override_sha:
+ description: DANGEROUSLY allow releasing from this commit sha, regardless of the state of CI (can be empty)
+ type: string
+ required: false
+ default: ""
+ schedule:
+ - cron: "0 13 * * 2" # every Tuesday at 13:00 UTC (9am EST / 8am EDT)
+
+jobs:
+ auto-minor-trigger:
+ # don't run this workflow on a cron for forks
+ if: ${{ github.event_name != 'schedule' || (github.repository == 'metabase/metabase' && vars.ENABLE_AUTO_MINOR == 'true') }}
+ runs-on: ${{ vars.DEFAULT_RUNNER_KEY }}
+ timeout-minutes: 5
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ sparse-checkout: |
+ release
+ .github
+ - name: Prepare release scripts
+ uses: ./.github/actions/prepare-release-scripts
+ - name: Trigger auto-minor
+ uses: actions/github-script@v7
+ env:
+ SLACK_RELEASE_CHANNEL: ${{ vars.SLACK_RELEASE_CHANNEL }}
+ SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
+ with:
+ script: | # js
+ const {
+ getLatestGreenCommit,
+ getNextMinorVersion,
+ hasCommitBeenReleased,
+ sendAutoMinorFailureMessage,
+ } = require('${{ github.workspace }}/release/dist/index.cjs');
+
+ const currentRelease = Number('${{ vars.CURRENT_VERSION }}');
+ const lastRelease = currentRelease - 1;
+ const AUTO_RELEASE_VERSIONS = [lastRelease, currentRelease];
+
+ async function releaseMinorFor(majorVersion, overrideSha) {
+ const nextMinor = await getNextMinorVersion({
+ github,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ majorVersion,
+ });
+
+ const releaseCommit = overrideSha || await getLatestGreenCommit({
+ github,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ branch: `release-x.${majorVersion}.x`,
+ });
+
+ const hasBeenReleased = await hasCommitBeenReleased({
+ github,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ ref: releaseCommit,
+ majorVersion: Number(majorVersion),
+ });
+
+ console.log(
+ { nextMinor, releaseCommit, hasBeenReleased }
+ );
+
+ if (nextMinor && releaseCommit && !hasBeenReleased) {
+ await github.rest.actions.createWorkflowDispatch({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ workflow_id: 'build-for-release.yml',
+ ref: 'refs/heads/master',
+ inputs: {
+ commit: releaseCommit,
+ version: nextMinor,
+ }
+ }).catch(console.error);
+ return;
+ }
+
+ const reason = !nextMinor
+ ? 'no-next-minor'
+ : !releaseCommit
+ ? 'no-green-commit'
+ : 'already-released';
+
+ console.error(`Auto-minor skipped for v${majorVersion}: ${reason}`);
+
+ await sendAutoMinorFailureMessage({
+ channelName: '${{ vars.SLACK_RELEASE_CHANNEL }}',
+ majorVersion,
+ reason,
+ runId: '${{ github.run_id }}',
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ }).catch(console.error);
+ }
+
+ if (context.eventName === 'workflow_dispatch') {
+ const inputVersion = Number(context.payload.inputs.version);
+
+ if (typeof inputVersion !== 'number') {
+ console.log('Invalid version number', inputVersion);
+ throw new Error(`Invalid version number: ${inputVersion}`);
+ }
+
+ // only allow overriding the commit SHA for workflow_dispatch events with a provided sha
+ const overrideSha = String(context.payload?.inputs?.override_sha ?? '').trim();
+ const isValidOverride = overrideSha.length === 40;
+
+ if (!isValidOverride && overrideSha.length > 0) {
+ throw new Error(`Invalid override SHA provided: ${overrideSha}`);
+ }
+
+ await releaseMinorFor(inputVersion, isValidOverride ? overrideSha : undefined);
+ } else { // scheduled release of AUTO_RELEASE_VERSIONS
+ await Promise.all(AUTO_RELEASE_VERSIONS.map(version => releaseMinorFor(version)));
+ }
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 6927a1af5c0..bab316b4da1 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -595,43 +595,3 @@ jobs:
runId: '${{ github.run_id }}',
channelName: '${{ vars.SLACK_RELEASE_CHANNEL }}',
}).catch(console.error);
-
- manage-milestones:
- if: ${{ !inputs.auto }}
- runs-on: ${{ vars.DEFAULT_RUNNER_KEY }}
- needs: [draft-release-notes, publish-version-info] # this will ensure that the milestone stays open until the release notes are published
- timeout-minutes: 15
- steps:
- - uses: actions/checkout@v4
- with:
- sparse-checkout: |
- release
- .github
- - name: Prepare release scripts
- uses: ./.github/actions/prepare-release-scripts
- - name: Update milestones
- uses: actions/github-script@v7
- with:
- script: | # js
- const { closeMilestone, openNextMilestones, isPreReleaseVersion } = require('${{ github.workspace }}/release/dist/index.cjs');
-
- const version = '${{ inputs.version }}';
-
- if (isPreReleaseVersion(version)) {
- console.log("This is a prerelease version, skipping milestone management");
- return;
- }
-
- await closeMilestone({
- github,
- owner: context.repo.owner,
- repo: context.repo.repo,
- version,
- }).catch(console.error);
-
- await openNextMilestones({
- github,
- owner: context.repo.owner,
- repo: context.repo.repo,
- version,
- }).catch(console.error);
diff --git a/release/src/slack.ts b/release/src/slack.ts
index 91b548331b6..60559727f7d 100644
--- a/release/src/slack.ts
+++ b/release/src/slack.ts
@@ -319,6 +319,46 @@ export async function sendAutoPatchFailureMessage(
});
}
+export type AutoMinorSkipReason =
+ | "no-next-minor"
+ | "no-green-commit"
+ | "already-released";
+
+type AutoMinorSkipArgs = {
+ majorVersion: number;
+ reason: AutoMinorSkipReason;
+ runId: string;
+ owner: string;
+ repo: string;
+};
+
+export function buildAutoMinorSkipMessage({
+ majorVersion,
+ reason,
+ runId,
+ owner,
+ repo,
+}: AutoMinorSkipArgs): string {
+ const runLink = githubRunLink("workflow run", runId, owner, repo);
+
+ const messageByReason: Record<AutoMinorSkipReason, string> = {
+ "no-green-commit": `:x: Auto-minor for *v${majorVersion}* skipped: no commit found suitable for the release. ${runLink}`,
+ "no-next-minor": `:information_source: Auto-minor for *v${majorVersion}* skipped: no gold release yet — cut it manually. ${runLink}`,
+ "already-released": `:information_source: Auto-minor for *v${majorVersion}* skipped: latest green commit has already been released — nothing new to ship. ${runLink}`,
+ };
+
+ return messageByReason[reason];
+}
+
+export async function sendAutoMinorFailureMessage(
+ args: AutoMinorSkipArgs & { channelName: string },
+) {
+ return sendSlackMessage({
+ channelName: args.channelName,
+ message: buildAutoMinorSkipMessage(args),
+ });
+}
+
export async function sendPreReleaseMessage({
github,
owner,
diff --git a/release/src/slack.unit.spec.ts b/release/src/slack.unit.spec.ts
index 895adfbf3ce..d039998d724 100644
--- a/release/src/slack.unit.spec.ts
+++ b/release/src/slack.unit.spec.ts
@@ -1,4 +1,4 @@
-import { buildAutoPatchSkipMessage } from "./slack";
+import { buildAutoMinorSkipMessage, buildAutoPatchSkipMessage } from "./slack";
describe("buildAutoPatchSkipMessage", () => {
const baseArgs = {
@@ -49,3 +49,54 @@ describe("buildAutoPatchSkipMessage", () => {
expect(message).not.toContain("v54");
});
});
+
+describe("buildAutoMinorSkipMessage", () => {
+ const baseArgs = {
+ majorVersion: 54,
+ runId: "12345",
+ owner: "metabase",
+ repo: "metabase",
+ };
+
+ const runLink = "<https://github.com/metabase/metabase/actions/runs/12345|workflow run>";
+
+ it("uses a failure emoji for no-green-commit", () => {
+ const message = buildAutoMinorSkipMessage({ ...baseArgs, reason: "no-green-commit" });
+
+ expect(message).toContain(":x:");
+ expect(message).toContain("v54");
+ expect(message).toContain("no commit found suitable for the release");
+ expect(message).toContain(runLink);
+ });
+
+ it("uses an info emoji for no-next-minor (gold release happens manually)", () => {
+ const message = buildAutoMinorSkipMessage({ ...baseArgs, reason: "no-next-minor" });
+
+ expect(message).toContain(":information_source:");
+ expect(message).not.toContain(":x:");
+ expect(message).toContain("v54");
+ expect(message).toContain("no gold release yet");
+ expect(message).toContain(runLink);
+ });
+
+ it("uses an info emoji (not a failure emoji) for already-released", () => {
+ const message = buildAutoMinorSkipMessage({ ...baseArgs, reason: "already-released" });
+
+ expect(message).toContain(":information_source:");
+ expect(message).not.toContain(":x:");
+ expect(message).toContain("v54");
+ expect(message).toContain("nothing new to ship");
+ expect(message).toContain(runLink);
+ });
+
+ it("uses the provided major version in the message", () => {
+ const message = buildAutoMinorSkipMessage({
+ ...baseArgs,
+ majorVersion: 53,
+ reason: "no-next-minor",
+ });
+
+ expect(message).toContain("v53");
+ expect(message).not.toContain("v54");
+ });
+});
diff --git a/release/src/version-helpers.ts b/release/src/version-helpers.ts
index 1c0c79ab535..d46f5875fa0 100644
--- a/release/src/version-helpers.ts
+++ b/release/src/version-helpers.ts
@@ -433,9 +433,54 @@ export const getNextPatchVersion = async ({
ignorePreReleases: false,
});
- const nextPatch = findNextPatchVersion(lastRelease);
+ if (!lastRelease) {
+ return undefined;
+ }
+
+ return findNextPatchVersion(lastRelease);
+};
+
+export const findNextMinorVersion = (version: string) => {
+ if (!isValidVersionString(version)) {
+ throw new Error(`Invalid version string: ${version}`);
+ }
+
+ if (isPreReleaseVersion(version)) {
+ throw new Error(
+ `Auto-minor releases are not supported for pre-release versions: ${version}`,
+ );
+ }
+
+ const [major, minor] = version
+ .replace(/(v1|v0)\./, "")
+ .split(".")
+ .map(Number);
+
+ return `v0.${major}.${(minor || 0) + 1}`;
+};
+
+export const getNextMinorVersion = async ({
+ github,
+ owner,
+ repo,
+ majorVersion,
+}: GithubProps & { majorVersion: number }) => {
+ const lastRelease = await getLastReleaseTag({
+ github,
+ owner,
+ repo,
+ version: `v0.${majorVersion.toString()}.0`,
+ ignorePatches: true,
+ ignorePreReleases: true,
+ });
+
+ // No stable release yet for this major (e.g. only vX.NN.0-beta has shipped).
+ // The gold release is cut manually — skip rather than crash the cron.
+ if (!lastRelease) {
+ return undefined;
+ }
- return nextPatch;
+ return findNextMinorVersion(lastRelease);
};
type SdkVersionInfo = {
diff --git a/release/src/version-helpers.unit.spec.ts b/release/src/version-helpers.unit.spec.ts
index 25592da4985..64e1a0bd1e5 100644
--- a/release/src/version-helpers.unit.spec.ts
+++ b/release/src/version-helpers.unit.spec.ts
@@ -1,6 +1,7 @@
import type { Tag } from "./types";
import {
filterOutNonSupportedPrereleaseIdentifier,
+ findNextMinorVersion,
findNextPatchVersion,
getBuildRequirements,
getDotXs,
@@ -664,6 +665,33 @@ describe("version-helpers", () => {
});
});
+ describe("findNextMinorVersion", () => {
+ it.each([
+ ["v1.50.0", "v0.50.1"],
+ ["v0.50.0", "v0.50.1"],
+ ["v1.50.1", "v0.50.2"],
+ ["v0.50.9", "v0.50.10"],
+ ["v1.50.99", "v0.50.100"],
+ ["v1.23.0", "v0.23.1"],
+ ])("%s -> %s", (input, expected) => {
+ expect(findNextMinorVersion(input)).toBe(expected);
+ });
+
+ it("should throw an error for invalid versions", () => {
+ expect(() => findNextMinorVersion("foo")).toThrow();
+ expect(() => findNextMinorVersion("v2.75")).toThrow();
+ expect(() => findNextMinorVersion("v0.75.0-gamma")).toThrow();
+ expect(() => findNextMinorVersion("v0.75")).toThrow();
+ expect(() => findNextMinorVersion("v0.75.f")).toThrow();
+ });
+
+ it("should throw for pre-release versions (auto-minor only runs post-gold)", () => {
+ expect(() => findNextMinorVersion("v0.50.1-beta")).toThrow();
+ expect(() => findNextMinorVersion("v1.50.0-RC")).toThrow();
+ expect(() => findNextMinorVersion("v0.50.2-alpha")).toThrow();
+ });
+ });
+
describe("getMajorVersionNumberFromReleaseBranch", () => {
it("should resolve major version from a common release branch", () => {
expect(getMajorVersionNumberFromReleaseBranch("release-x.51.x")).toEqual(