From a63561b581daa3f27cc5a2191f115883e5d90008 Mon Sep 17 00:00:00 2001 From: mlischetti Date: Wed, 29 Jul 2026 10:36:46 -0300 Subject: [PATCH 1/4] Add CI artifact naming convention design spec Design for a single human-readable naming convention across the customer-downloadable CI artifacts and tagged release assets, grounded in the current build state (Linux + Windows, x86_64). Fixes OS-casing drift, adds a runtime-derived arch token, clarifies base names (dw-cli, dataweave-node, dwlib), documents the Python wheel PEP 427 exception, and folds in release.yml alignment plus the wheel file-path fix. macOS/arm64 builds noted as out of scope. Co-Authored-By: Claude Opus 4.8 (1M context) --- ...28-ci-artifact-naming-convention-design.md | 213 ++++++++++++++++++ 1 file changed, 213 insertions(+) create mode 100644 docs/superpowers/specs/2026-07-28-ci-artifact-naming-convention-design.md diff --git a/docs/superpowers/specs/2026-07-28-ci-artifact-naming-convention-design.md b/docs/superpowers/specs/2026-07-28-ci-artifact-naming-convention-design.md new file mode 100644 index 0000000..bbae3aa --- /dev/null +++ b/docs/superpowers/specs/2026-07-28-ci-artifact-naming-convention-design.md @@ -0,0 +1,213 @@ +# CI Artifact Naming Convention — Design + +**Status:** Draft (brainstorming output, pending review) +**Date:** 2026-07-28 +**Scope:** Naming/labeling only — no new build targets. + +## Goal + +Give the customer-downloadable artifacts — both the CI-run artifacts +(`main.yml`/`ci.yml`) and the tagged release assets (`release.yml`) — a single, +human-readable naming convention that is consistent across all families and +honestly reflects the **current** build state (Linux + Windows, x86_64 only). + +## Problem + +The artifacts from a master CI run +([run 30393123015](https://github.com/mulesoft/data-weave-cli/actions/runs/30393123015)) +are named three different ways: + +| Artifact (today) | OS token | Arch? | Issues | +|---|---|---|---| +| `native-cli-100.100.100-native-distro-linux.zip` | `linux` (lower) | ❌ | "native" appears twice; jargony | +| `native-cli-100.100.100-native-distro-windows.zip` | `windows` (lower) | ❌ | same | +| `dataweave-native-0.0.1-Linux.tgz` | `Linux` (upper) | ❌ | never says "node"; ambiguous vs Python | +| `dataweave-native-0.0.1-Windows.tgz` | `Windows` (upper) | ❌ | same | +| `dwlib-100.100.100-Linux` | `Linux` (upper) | ❌ | no arch | +| `dwlib-100.100.100-Windows` | `Windows` (upper) | ❌ | no arch | +| `dataweave_native-0.0.1-py3-none-manylinux2014_x86_64.whl` | in platform tag | ✅ `x86_64` | fine (auto-generated) | +| `dataweave_native-0.0.1-py3-none-win_amd64.whl` | in platform tag | ✅ `amd64` | fine (auto-generated) | + +Three distinct inconsistencies: + +1. **OS casing** — `Linux`/`Windows` (from `${{ runner.os }}`) vs + `linux`/`windows` (from `${{ matrix.script_name }}`), in the same run. +2. **Architecture** — present only on the Python wheels (setuptools generates + the platform tag automatically); absent everywhere else, even though every + artifact today is x86_64. +3. **Base-name clarity** — `native-cli-…-native-distro` repeats "native"; the + Node `.tgz` gives no signal it's the Node package (vs the Python one); + `dwlib` is opaque outside its FFI audience. + +## Current build state (ground truth) + +- **OSes:** Linux + Windows. **No macOS build** despite the code producing a + `.dylib` (the CI matrix is `mulesoft-ubuntu` + `mulesoft-windows` only). +- **Architecture:** x86_64 only, on both OSes (confirmed by the wheel platform + tags `manylinux2014_x86_64` / `win_amd64`). No arm64 / Apple Silicon. + +So every artifact today is effectively `linux-x86_64` or `windows-x86_64` — the +arch simply isn't in most of the names. + +## Artifact families and their purpose + +| Base name (proposed) | What it is | Consumer | +|---|---|---| +| `dw-cli` | the `dw` command-line executable distribution (zip) | end users running `dw` in a terminal | +| `dataweave-node` | the Node.js binding, an npm package (`.tgz`) | Node developers (`npm install`) | +| `dwlib` | the raw shared library (`.so`/`.dll`/`.dylib`) + `.h` header | C/FFI integrators; underpins the bindings | +| `dataweave_native` (wheel) | the Python binding wheel | Python developers (`pip install`) | + +## The convention + +Every artifact follows one grammar: + +``` +---. +``` + +- **``** — lowercase: `linux` | `windows` (future: `macos`) +- **``** — lowercase, derived at runtime, not hardcoded: `x86_64` today + (future: `arm64`) +- **``** — unchanged per family: `100.100.100` for CLI/dwlib, `0.0.1` + for the Node package + +### Base-name renames + +| Today | Proposed | Rationale | +|---|---|---| +| `native-cli-…-native-distro-.zip` | `dw-cli-100.100.100--.zip` | drops the double "native"; `dw-cli` names the actual `dw` executable | +| `dataweave-native-0.0.1-.tgz` | `dataweave-node-0.0.1--.tgz` | "node" disambiguates from the Python package | +| `dwlib-100.100.100-` | `dwlib-100.100.100--` | base kept for its FFI audience; casing + arch fixed | +| `dataweave_native-…-.whl` | **unchanged** | see exception below | + +### Python wheel — deliberate exception + +The wheel name (`dataweave_native-0.0.1-py3-none-manylinux2014_x86_64.whl`) is +generated by setuptools and **must** stay PEP 427-compliant +(`{name}-{version}-{python}-{abi}-{platform}.whl`) or `pip install` and platform +resolution break. It already carries the architecture in its platform tag, so it +needs no change. It is documented here as the one family that intentionally does +not follow the `-` grammar. + +### Result — 8 artifacts + +``` +dw-cli-100.100.100-linux-x86_64.zip +dw-cli-100.100.100-windows-x86_64.zip +dataweave-node-0.0.1-linux-x86_64.tgz +dataweave-node-0.0.1-windows-x86_64.tgz +dwlib-100.100.100-linux-x86_64 +dwlib-100.100.100-windows-x86_64 +dataweave_native-0.0.1-py3-none-manylinux2014_x86_64.whl (exception) +dataweave_native-0.0.1-py3-none-win_amd64.whl (exception) +``` + +## Implementation notes (where each rename actually happens) + +A prior change set three of the four upload steps to +`actions/upload-artifact` with `archive: false`. Under `archive: false` the +`name:` input is **ignored** — the artifact name is the uploaded **file's own +name**. So renaming those three is not a CI-label tweak; it means renaming the +produced *file*. + +- **`dw-cli` (CLI distro)** — rename the zip the Gradle `native-cli:distro` + task produces (the file basename currently + `native-cli--native-distro-.zip`). This is the file whose + name the upload step points at. +- **`dataweave-node` (Node tgz)** — the "Stage OS-qualified Node package" step + copies the `npm pack` output to an OS-qualified name; change that copy target + to `dataweave-node-0.0.1--.tgz`. `npm pack` still emits its own + fixed name; the staging copy is what gets uploaded. +- **`dwlib`** — this step still uses `name:` (it uploads multiple files — + `.so`/`.dll`/`.dylib` + `.h` — so it stays archived, and under `archive: true` + `name:` is honored). Its label is changed directly on the `name:` input; no + file rename needed. +- **Python wheel** — no change. + +### Deriving the tokens + +- **OS:** use a lowercase token. Prefer the existing `matrix.script_name` + (`linux`/`windows`) so casing is consistent by construction, rather than + `${{ runner.os }}` (`Linux`/`Windows`). +- **Arch:** derive at runtime from `uname -m` (all steps already run under + `shell: bash`), normalizing to `x86_64`. Deriving rather than hardcoding keeps + the names correct automatically if an arm64 runner is ever added. On the + current x86_64 runners this resolves to `x86_64` on Linux; Windows is + normalized to `x86_64`. + +## `release.yml` alignment (in scope) + +`release.yml` publishes the same four families as GitHub **release assets** on +`v*` tags, via `svenstaro/upload-release-action`. That action honors +`asset_name:` and does no zipping, so aligning it is **cheaper than the CI +side**: every rename is a single `asset_name:` string edit — no Gradle changes, +no file renames, and none of the `archive: false` subtlety. + +Same convention applies: **OS lowercase** (switch `${{ runner.os }}` → +`${{ matrix.script_name }}`) and **arch runtime-derived** (add one +`echo "ARCH=$(uname -m)" >> $GITHUB_ENV` step, reference `${{ env.ARCH }}`). + +### Asset renames + +| Asset | Current `asset_name` | Spec-aligned | +|---|---|---| +| CLI distro | `dw-${VER}-${runner.os}` (missing `.zip`) | `dw-cli-${VER}-${os}-${arch}.zip` | +| Node tgz | `dw-node-package-${VER}-${runner.os}.tgz` | `dataweave-node-0.0.1-${os}-${arch}.tgz` | +| dwlib `.so` | `dwlib-${VER}-${runner.os}.so` | `dwlib-${VER}-${os}-${arch}.so` | +| dwlib `.dll` | `dwlib-${VER}-${runner.os}.dll` | `dwlib-${VER}-${os}-${arch}.dll` | +| dwlib `.h` | `dwlib-${VER}.h` | **unchanged** (header is os/arch-independent) | +| Python wheel | `dw-python-wheel-${VER}-${runner.os}.whl` | keep the wheel's own PEP 427 name (drop `asset_name:`) | + +### Two deliberate divergences from the CI naming + +- **dwlib ships as separate release assets** (`.so`/`.dll`/`.h`, each its own + asset), whereas CI bundles them into one archived `dwlib-…` artifact. Release + dwlib assets therefore carry their file extension — correct for individual + assets, not an inconsistency. +- **The wheel is the same PEP 427 exception, for a sharper reason here.** Today + the asset is renamed to `dw-python-wheel-….whl`; if a user runs `pip install` + on that downloaded file, pip validates the filename against PEP 427 and the + non-compliant name breaks the install / platform resolution. The asset must + keep the wheel's real name (`dataweave_native-0.0.1-py3-none-.whl`) + — simplest is to drop `asset_name:` and let the action use the file's own + name. + +### Pre-existing bug to fix in the same pass + +- **Wheel file path (line ~95): `…-py3-none-any.whl`.** The build produces a + *platform-tagged* wheel (`manylinux2014_x86_64` / `win_amd64`), not + `-any.whl`, so this `file:` path does not match the produced file and the + upload step fails to locate it. Change the glob to match the real platform tag + (e.g. `…-py3-none-*.whl`). (The stray `I` typo on the CLI-distro `tag:` line + has already been fixed separately.) + +## Blast radius + +- **CI artifact labels change** in the Actions UI and in the downloaded + filenames. Anyone with a hardcoded reference to an old name (scripts, docs) + must update. +- **Release asset names change** on the next `v*` tag. Same caveat — hardcoded + references to old release-asset names must update. +- **No runtime/API/binding-code impact** — this is packaging/labeling only. + +## Out of scope (noted as future work) + +- **macOS build** — the code produces a `.dylib`, but no macOS runner is in the + CI matrix, so no macOS artifact ships. Adding one is a separate effort. +- **arm64 / Apple Silicon builds** — no arm64 runner today. The convention is + arm64-ready (arch is derived, not hardcoded), but no such artifact is + produced yet. + +## Success criteria + +- All CI artifacts (except the documented wheel exception) match + `---.`. +- OS token is lowercase everywhere. +- Architecture appears in every artifact name. +- Base names read clearly to a customer: `dw-cli`, `dataweave-node`, `dwlib`. +- `pip install` of the wheel and `npm install` of the tgz still work unchanged. +- **Release assets** (`release.yml`) follow the same convention, with the + documented divergences (per-file dwlib assets, PEP 427 wheel name). +- The `release.yml` wheel `file:` path matches the produced platform-tagged + wheel (no more `-any.whl` mismatch). From 949c79c5acba7d9d8ef41adad24b0803c6a0de9e Mon Sep 17 00:00:00 2001 From: mlischetti Date: Wed, 29 Jul 2026 10:05:11 -0300 Subject: [PATCH 2/4] Add artifact-name validation + apply convention to main.yml --- .github/workflows/main.yml | 22 +++++++++++--- scripts/check-artifact-names.sh | 54 +++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+), 4 deletions(-) create mode 100755 scripts/check-artifact-names.sh diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index a0aa711..37ee664 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -108,6 +108,20 @@ jobs: cd native-lib/node && npm run test:tck shell: bash + # Derive lowercase OS + runtime arch tokens for artifact names. + # OS comes from matrix.script_name (linux/windows); arch from uname -m + # (x86_64 today; stays correct if an arm64 runner is ever added). + - name: Derive platform tokens + run: echo "ARCH=$(uname -m)" >> "$GITHUB_ENV" + shell: bash + + # archive:false makes the artifact name equal the uploaded file name. + # Copy the Gradle-named distro zip to the convention name so the CLI + # artifact reads dw-cli---.zip. + - name: Stage renamed CLI distro + run: cp "native-cli/build/distributions/native-cli-${{env.NATIVE_VERSION}}-native-distro-${{ matrix.script_name }}.zip" "native-cli/build/distributions/dw-cli-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }}.zip" + shell: bash + # Upload the artifact file - name: Upload generated script uses: actions/upload-artifact@v7.0.1 @@ -116,7 +130,7 @@ jobs: # .zip) and names the artifact after the file — which already carries # ${matrix.script_name}, so the matrix legs don't collide. No `name:`: # it would be ignored under archive:false. - path: native-cli/build/distributions/native-cli-${{env.NATIVE_VERSION}}-native-distro-${{ matrix.script_name }}.zip + path: native-cli/build/distributions/dw-cli-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }}.zip archive: false # Upload the Python wheel @@ -135,14 +149,14 @@ jobs: # `name:` input is ignored), so copy to an OS-qualified name first to keep # the matrix legs from colliding. - name: Stage OS-qualified Node package - run: cp native-lib/node/dataweave-native-0.0.1.tgz "native-lib/node/dataweave-native-0.0.1-${{ runner.os }}.tgz" + run: cp native-lib/node/dataweave-native-0.0.1.tgz "native-lib/node/dataweave-node-0.0.1-${{ matrix.script_name }}-${{ env.ARCH }}.tgz" shell: bash # Upload the Node.js package - name: Upload Node package uses: actions/upload-artifact@v7.0.1 with: - path: native-lib/node/dataweave-native-0.0.1-${{ runner.os }}.tgz + path: native-lib/node/dataweave-node-0.0.1-${{ matrix.script_name }}-${{ env.ARCH }}.tgz # Single .tgz (already gzip-compressed); skip the redundant outer zip # (v7+ feature). archive:false ignores `name:` and uses the file name, # which the copy above made OS-unique. @@ -154,7 +168,7 @@ jobs: - name: Upload native shared library uses: actions/upload-artifact@v7.0.1 with: - name: dwlib-${{env.NATIVE_VERSION}}-${{runner.os}} + name: dwlib-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }} path: | native-lib/python/src/dataweave/native/dwlib.dylib native-lib/python/src/dataweave/native/dwlib.so diff --git a/scripts/check-artifact-names.sh b/scripts/check-artifact-names.sh new file mode 100755 index 0000000..fe0cebe --- /dev/null +++ b/scripts/check-artifact-names.sh @@ -0,0 +1,54 @@ +#!/usr/bin/env bash +# Validates that a GitHub Actions workflow uses the DataWeave CLI artifact +# naming convention: ---., os lowercase via +# matrix.script_name, arch via `uname -m`. Also a regression guard against +# the OS-casing drift (${{ runner.os }}) that motivated the convention. +# +# Usage: scripts/check-artifact-names.sh +set -euo pipefail + +file="${1:-}" +if [[ -z "$file" || ! -f "$file" ]]; then + echo "usage: $0 " >&2 + exit 2 +fi + +fail() { echo "FAIL [$file]: $1" >&2; exit 1; } + +# (a) YAML must be well-formed. Ruby stdlib is present on the runners and macOS. +ruby -ryaml -e 'YAML.load_file(ARGV[0])' "$file" >/dev/null 2>&1 \ + || fail "not well-formed YAML" + +# present : require a literal substring to appear. +present() { grep -qF -- "$1" "$file" || fail "$2"; } +# absent : require a literal substring to NOT appear. +absent() { grep -qF -- "$1" "$file" && fail "$2" || true; } +# no_runner_os_in_names: the casing invariant. `${{ runner.os }}` must not +# appear in artifact/asset NAMES, but legitimate `if: runner.os == '...'` +# job conditionals (release.yml gates .so vs .dll by OS) must survive. So: +# find runner.os lines, drop the `if:` conditional lines, fail if any remain. +no_runner_os_in_names() { + if grep -n 'runner.os' "$file" | grep -v 'if:' | grep -q .; then + fail "uses \${{ runner.os }} in a name (use matrix.script_name); see: $(grep -n 'runner.os' "$file" | grep -v 'if:' | head -1)" + fi +} + +check_ci_file() { + no_runner_os_in_names + present 'ARCH=$(uname -m)' "missing arch derivation (ARCH=\$(uname -m))" + present 'env.ARCH' "artifact names do not reference env.ARCH" + present 'dw-cli-' "missing dw-cli- artifact base name" + present 'dataweave-node-' "missing dataweave-node- artifact base name" + echo "OK [$file]: CI-artifact naming convention" +} + +check_release_file() { + # Filled in by Task 3. + echo "OK [$file]: release checks not yet implemented" +} + +case "$(basename "$file")" in + main.yml|ci.yml) check_ci_file ;; + release.yml) check_release_file ;; + *) echo "usage: $0 must target main.yml, ci.yml, or release.yml" >&2; exit 2 ;; +esac From ab7b27bb409483bcac6ad0f1be429a596108669a Mon Sep 17 00:00:00 2001 From: mlischetti Date: Wed, 29 Jul 2026 10:10:57 -0300 Subject: [PATCH 3/4] Apply artifact naming convention to ci.yml --- .github/workflows/ci.yml | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index bb4e9a2..2848cb8 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -71,6 +71,20 @@ jobs: run: ./gradlew --stacktrace --no-problems-report native-lib:nodeTest shell: bash + # Derive lowercase OS + runtime arch tokens for artifact names. + # OS comes from matrix.script_name (linux/windows); arch from uname -m + # (x86_64 today; stays correct if an arm64 runner is ever added). + - name: Derive platform tokens + run: echo "ARCH=$(uname -m)" >> "$GITHUB_ENV" + shell: bash + + # archive:false makes the artifact name equal the uploaded file name. + # Copy the Gradle-named distro zip to the convention name so the CLI + # artifact reads dw-cli---.zip. + - name: Stage renamed CLI distro + run: cp "native-cli/build/distributions/native-cli-${{env.NATIVE_VERSION}}-native-distro-${{ matrix.script_name }}.zip" "native-cli/build/distributions/dw-cli-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }}.zip" + shell: bash + # Upload the artifact file - name: Upload generated script uses: actions/upload-artifact@v7.0.1 @@ -79,7 +93,7 @@ jobs: # .zip) and names the artifact after the file — which already carries # ${matrix.script_name}, so the matrix legs don't collide. No `name:`: # it would be ignored under archive:false. - path: native-cli/build/distributions/native-cli-${{env.NATIVE_VERSION}}-native-distro-${{ matrix.script_name }}.zip + path: native-cli/build/distributions/dw-cli-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }}.zip archive: false # Upload the Python wheel @@ -98,14 +112,14 @@ jobs: # `name:` input is ignored), so copy to an OS-qualified name first to keep # the matrix legs from colliding. - name: Stage OS-qualified Node package - run: cp native-lib/node/dataweave-native-0.0.1.tgz "native-lib/node/dataweave-native-0.0.1-${{ runner.os }}.tgz" + run: cp native-lib/node/dataweave-native-0.0.1.tgz "native-lib/node/dataweave-node-0.0.1-${{ matrix.script_name }}-${{ env.ARCH }}.tgz" shell: bash # Upload the Node.js package - name: Upload Node package uses: actions/upload-artifact@v7.0.1 with: - path: native-lib/node/dataweave-native-0.0.1-${{ runner.os }}.tgz + path: native-lib/node/dataweave-node-0.0.1-${{ matrix.script_name }}-${{ env.ARCH }}.tgz # Single .tgz (already gzip-compressed); skip the redundant outer zip # (v7+ feature). archive:false ignores `name:` and uses the file name, # which the copy above made OS-unique. @@ -117,7 +131,7 @@ jobs: - name: Upload native shared library uses: actions/upload-artifact@v7.0.1 with: - name: dwlib-${{env.NATIVE_VERSION}}-${{runner.os}} + name: dwlib-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }} path: | native-lib/python/src/dataweave/native/dwlib.dylib native-lib/python/src/dataweave/native/dwlib.so From 8d4972f07c1089ce5530aff74e504ec53a205d42 Mon Sep 17 00:00:00 2001 From: mlischetti Date: Wed, 29 Jul 2026 10:17:33 -0300 Subject: [PATCH 4/4] Apply artifact naming convention to release.yml + fix wheel upload glob --- .github/workflows/release.yml | 13 +++++++------ scripts/check-artifact-names.sh | 12 ++++++++++-- 2 files changed, 17 insertions(+), 8 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 50b8344..f0f8c35 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -38,6 +38,7 @@ jobs: - name: Guess Extension Version run: | echo "NATIVE_VERSION=$(echo '${{github.ref}}' | sed -e 's,.*/v\(.*\),\1,')" >> $GITHUB_ENV + echo "ARCH=$(uname -m)" >> $GITHUB_ENV shell: bash # Runs a single command using the runners shell @@ -83,7 +84,7 @@ jobs: with: repo_token: ${{ secrets.GITHUB_TOKEN }} file: native-cli/build/distributions/native-cli-${{env.NATIVE_VERSION}}-native-distro-${{ matrix.script_name }}.zip - asset_name: dw-${{env.NATIVE_VERSION}}-${{runner.os}} + asset_name: dw-cli-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }}.zip tag: ${{ github.ref }} overwrite: true @@ -92,8 +93,8 @@ jobs: uses: svenstaro/upload-release-action@v2 with: repo_token: ${{ secrets.GITHUB_TOKEN }} - file: native-lib/python/dist/dataweave_native-0.0.1-py3-none-any.whl - asset_name: dw-python-wheel-${{env.NATIVE_VERSION}}-${{runner.os}}.whl + file: native-lib/python/dist/dataweave_native-0.0.1-py3-none-*.whl + file_glob: true tag: ${{ github.ref }} overwrite: true @@ -103,7 +104,7 @@ jobs: with: repo_token: ${{ secrets.GITHUB_TOKEN }} file: native-lib/node/dataweave-native-0.0.1.tgz - asset_name: dw-node-package-${{env.NATIVE_VERSION}}-${{runner.os}}.tgz + asset_name: dataweave-node-0.0.1-${{ matrix.script_name }}-${{ env.ARCH }}.tgz tag: ${{ github.ref }} overwrite: true @@ -114,7 +115,7 @@ jobs: with: repo_token: ${{ secrets.GITHUB_TOKEN }} file: native-lib/python/src/dataweave/native/dwlib.so - asset_name: dwlib-${{env.NATIVE_VERSION}}-${{runner.os}}.so + asset_name: dwlib-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }}.so tag: ${{ github.ref }} overwrite: true @@ -124,7 +125,7 @@ jobs: with: repo_token: ${{ secrets.GITHUB_TOKEN }} file: native-lib/python/src/dataweave/native/dwlib.dll - asset_name: dwlib-${{env.NATIVE_VERSION}}-${{runner.os}}.dll + asset_name: dwlib-${{env.NATIVE_VERSION}}-${{ matrix.script_name }}-${{ env.ARCH }}.dll tag: ${{ github.ref }} overwrite: true diff --git a/scripts/check-artifact-names.sh b/scripts/check-artifact-names.sh index fe0cebe..bf20456 100755 --- a/scripts/check-artifact-names.sh +++ b/scripts/check-artifact-names.sh @@ -43,8 +43,16 @@ check_ci_file() { } check_release_file() { - # Filled in by Task 3. - echo "OK [$file]: release checks not yet implemented" + no_runner_os_in_names + present 'ARCH=$(uname -m)' "missing arch derivation (ARCH=\$(uname -m))" + present 'env.ARCH' "asset names do not reference env.ARCH" + present 'dw-cli-' "missing dw-cli- asset base name" + present 'dataweave-node-' "missing dataweave-node- asset base name" + present 'file_glob: true' "wheel upload missing file_glob: true (needed for the * glob)" + absent 'dw-python-wheel' "stale dw-python-wheel asset name still present" + absent 'dw-node-package' "stale dw-node-package asset name still present" + absent '-py3-none-any.whl' "wheel file path still hardcodes -any.whl (should match the platform tag)" + echo "OK [$file]: release naming convention" } case "$(basename "$file")" in