snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

e2e-tests/playwright/script/resolve_upgrade_matrix.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+// Resolves the rolling-upgrade matrix for CI: last 3 minor releases + any active Extended
+// Support release. Prints JSON objects with docker tags and ESR metadata, e.g.
+// [{"dockerTag":"release-11.9",...}] — or `[]` when no supported from-versions remain (CI posts
+// e2e-test/playwright-full/{edition}/upgrade-from-none and skips workers).
+//
+// Current version + last-3 come from this local checkout's version.go. Support-end dates and ESR
+// status are fetched live from master, since those lapse with calendar time.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const RELEASES_MDX_URL =
+    'https://raw.githubusercontent.com/mattermost/mattermost/refs/heads/master/docs/main/product-overview/mattermost-server-releases.mdx';
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+const VERSION_GO_PATH = path.resolve(currentDir, '../../../server/public/model/version.go');
+
+// Named (not inline) so referencing `.test()` below is unambiguous to both eslint and Prettier.
+const RELEASE_ROW_PATTERN = /^\|\s*v\d+\.\d+\s/;
+const CELL_SEPARATOR_PATTERN = /(?<!\\)\|/;
+
+function toMinor(version) {
+    const [major, minor] = version.split('.');
+    return `${major}.${minor}`;
+}
+
+/** Numeric major.minor ordering — string compare would sort 11.9 after 11.10. */
+function compareMinor(a, b) {
+    const [aMajor, aMinor] = a.split('.').map(Number);
+    const [bMajor, bMinor] = b.split('.').map(Number);
+    return aMajor - bMajor || aMinor - bMinor;
+}
+
+/** Maps a release patch version to the registry's floating minor tag. */
+function toDockerImageTag(patchVersion) {
+    const [major, minor] = patchVersion.split('.');
+    return `release-${major}.${minor}`;
+}
+
+/** GitHub commit-status / dashboard label for a matrix entry. */
+export function upgradeMatrixContextLabel(entry) {
+    return entry.isESR ? `${entry.dockerTag}-esr` : entry.dockerTag;
+}
+
+/** Reads current + last-3-minor versions from the local checkout's version.go. */
+function readLocalVersions() {
+    const source = fs.readFileSync(VERSION_GO_PATH, 'utf-8');
+    const block = source.match(/var versions = \[\]string\{([^}]*)\}/);
+    if (!block) {
+        throw new Error(`Could not find "var versions = []string{...}" block in ${VERSION_GO_PATH}`);
+    }
+    const versions = [...block[1].matchAll(/"([\d.]+)"/g)].map((m) => m[1]);
+
+    // Release branches list every hotfix of their own minor first ("11.9.2", "11.9.1", "11.9.0",
+    // "11.8.0", ...), so collapse to unique minors before slicing. Taking the raw entries would
+    // make lastThree on release-11.9 read 11.9, 11.9, 11.8 — offering the branch its own version
+    // as an upgrade source and dropping a genuinely older one.
+    const minors = [...new Set(versions.map(toMinor))];
+    if (minors.length < 4) {
+        throw new Error(`Expected at least 4 distinct minors in ${VERSION_GO_PATH}, found ${minors.length}`);
+    }
+    return {
+        current: minors[0],
+        lastThree: minors.slice(1, 4),
+    };
+}
+
+/** Fetches and parses the releases table's rows into {minor, patch, supportEnds, isESR}. */
+async function fetchReleaseRows() {
+    const response = await fetch(RELEASES_MDX_URL);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${RELEASES_MDX_URL}: ${response.status} ${response.statusText}`);
+    }
+    const mdx = await response.text();
+
+    const rows = [];
+    for (const line of mdx.split('\n')) {
+        if (!RELEASE_ROW_PATTERN.test(line)) {
+            continue;
+        }
+
+        // Cell separators are unescaped `|`; the first cell's own markdown link text contains
+        // escaped `\|` between [Download]/[Changelog]/SBOM links, which CELL_SEPARATOR_PATTERN's
+        // lookbehind skips.
+        const rawCells = line.split(CELL_SEPARATOR_PATTERN);
+        const cells = rawCells.map((cell) => cell.trim()).filter(Boolean);
+        if (cells.length < 3) {
+            continue;
+        }
+
+        const [releaseCell, , supportEndsCell] = cells;
+
+        const minorMatch = releaseCell.match(/^v(\d+\.\d+)/);
+        const patchMatch = releaseCell.match(/releases\.mattermost\.com\/(\d+\.\d+\.\d+)\//);
+        const dateMatch = supportEndsCell.match(/(\d{4}-\d{2}-\d{2})/);
+        if (!minorMatch || !patchMatch || !dateMatch) {
+            continue;
+        }
+
+        rows.push({
+            minor: minorMatch[1],
+            patch: patchMatch[1],
+            supportEnds: new Date(dateMatch[1]),
+            isESR: supportEndsCell.includes('[EXTENDED]'),
+        });
+    }
+    return rows;
+}
+
+export async function resolveUpgradeMatrix(now = new Date()) {
+    const {current, lastThree} = readLocalVersions();
+    const rows = await fetchReleaseRows();
+
+    const active = rows.filter((row) => row.supportEnds > now);
+
+    // Only strictly older minors are upgrade sources. The ESR clause below is otherwise unbounded:
+    // cutting release-11.7 while 11.7 is the active ESR would put 11.7 in its own matrix, which is
+    // a no-op upgrade rather than coverage.
+    const older = active.filter((row) => compareMinor(row.minor, current) < 0);
+    const matrix = older.filter((row) => lastThree.includes(row.minor) || row.isESR);
+
+    const seenMinors = new Set();
+    const entries = [];
+    for (const row of matrix) {
+        if (seenMinors.has(row.minor)) {
+            continue;
+        }
+        seenMinors.add(row.minor);
+        const dockerTag = toDockerImageTag(row.patch);
+        entries.push({
+            dockerTag,
+            minor: row.minor,
+            patch: row.patch,
+            isESR: row.isESR,
+            contextLabel: upgradeMatrixContextLabel({dockerTag, isESR: row.isESR}),
+        });
+    }
+    return entries;
+}
+
+async function main() {
+    const entries = await resolveUpgradeMatrix();
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify(entries));
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error(String(error));
+
+        // Rethrow (not process.exit()) — an unhandled rejection still exits non-zero, which is
+        // all CI/local invocations need to fail loudly.
+        throw error;
+    });
+}