wehub-resource-sync
591 lines
23 KiB
YAML
591 lines
23 KiB
YAML
name: Release
|
|
run-name: Release (${{ inputs.release-type }})
|
|
|
|
on:
|
|
workflow_dispatch:
|
|
inputs:
|
|
release-type:
|
|
description: "What kind of release is this?"
|
|
type: choice
|
|
options:
|
|
- alpha
|
|
- rc
|
|
- final
|
|
required: true
|
|
publish-crates:
|
|
description: "Publish crates (ignored for non-alpha release)"
|
|
type: boolean
|
|
required: false
|
|
default: true
|
|
|
|
concurrency:
|
|
group: ${{ github.ref_name }}
|
|
cancel-in-progress: true
|
|
|
|
defaults:
|
|
run:
|
|
shell: bash --noprofile --norc -euo pipefail {0}
|
|
|
|
# wants to push commits and create a PR
|
|
permissions:
|
|
contents: write # Allow pushing commits
|
|
pull-requests: write # Allow creating PRs
|
|
packages: read # Allow reading packages
|
|
id-token: "write"
|
|
|
|
jobs:
|
|
# Re-entrancy:
|
|
# - `version` is re-entrant because it doesn't commit/create PR if the version doesn't change,
|
|
# and the version doesn't change if we're already on the final version specified by the branch name.
|
|
# - `update-docs` is re-entrant because it overwrites history of the `gh-pages` branch, so any
|
|
# previous partial update will just be overwritten by the next successful run.
|
|
# - `publish-crates` is re-entrant because the `crates.py` script correctly handles publish failures
|
|
# by first checking if a crate has already been published before attempting to publish it.
|
|
# - `build-and-publish-wheels` is re-entrant because all the uploaded artifacts will be overwritten
|
|
# by any subsequent runs, and the final upload to PyPI has the `--skip-existing` flag, which ignores
|
|
# any wheels already uploaded.
|
|
# - `build-and-publish-web` is re-entrant for the same reason as `build-and-publish-wheels`,
|
|
# except that uploads are done to GCS instead of PyPI.
|
|
|
|
checks:
|
|
timeout-minutes: 60
|
|
name: "Checks"
|
|
runs-on: ubuntu-latest
|
|
|
|
steps:
|
|
- name: Checkout repository
|
|
uses: actions/checkout@v4
|
|
|
|
- name: Setup Python
|
|
uses: actions/setup-python@v5
|
|
with:
|
|
python-version: 3.11
|
|
|
|
- name: Check links for `?speculative-link`
|
|
# This checks that we have no links with `?speculative-link` in its query params.
|
|
# We use those markers to get our link checker to ignore links to unreleased docs.
|
|
#
|
|
# NOTE: For alpha releases, we won't fully publish all our docs,
|
|
# so we skip the check here, because we won't be able to
|
|
# remove the markers yet.
|
|
run: |
|
|
if [ ${{ inputs.release-type }} != "alpha" ]; then
|
|
python3 scripts/ci/check_speculative_links.py
|
|
fi
|
|
|
|
# NOTE: When updating this job, also remember to update `post-release-version-bump`.
|
|
version:
|
|
name: "Versioning"
|
|
runs-on: ubuntu-latest
|
|
outputs:
|
|
previous: ${{ steps.versioning.outputs.previous }}
|
|
current: ${{ steps.versioning.outputs.current }}
|
|
final: ${{ steps.versioning.outputs.final }}
|
|
git_tag: ${{ steps.versioning.outputs.git_tag }}
|
|
# will be set to `github.sha` if the pull request already exists
|
|
# this is the last (and not merge) commit in the release branch
|
|
release-commit: ${{ steps.commit.outputs.version_bump_commit_sha || github.sha }}
|
|
|
|
steps:
|
|
- name: Checkout repository
|
|
uses: actions/checkout@v4
|
|
with:
|
|
fetch-depth: 0
|
|
token: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
|
|
- uses: actions/setup-node@v4
|
|
with:
|
|
node-version: "22.x"
|
|
|
|
- uses: prefix-dev/setup-pixi@v0.10.0
|
|
with:
|
|
pixi-version: v0.71.3
|
|
|
|
- name: Update crate versions
|
|
id: versioning
|
|
run: |
|
|
echo Check that the release version matches expected format…
|
|
pixi run python scripts/ci/crates.py check-git-branch-name
|
|
|
|
echo Parse the release version from the branch name…
|
|
# `prepare-release-0.8.1-alpha.N` -> `0.8.1`
|
|
release_version=$(pixi run python scripts/ci/crates.py get-version --from git --finalize)
|
|
|
|
echo "release_version: $release_version"
|
|
|
|
echo Store version before the update, so we can later detect if it changed…
|
|
previous=$(pixi run python scripts/ci/crates.py get-version)
|
|
|
|
echo If the version minus prerelease/build metadata is not the same as the release version, then update it.…
|
|
if [ $(pixi run python scripts/ci/crates.py get-version --finalize) != $release_version ]; then
|
|
pixi run python scripts/ci/crates.py version --exact $release_version
|
|
fi
|
|
|
|
echo If this is an 'rc', additionally set add '-rc.N'. This will also bump the 'N' if '-rc.N' is already set…
|
|
if [ ${{ inputs.release-type }} = "rc" ]; then
|
|
pixi run python scripts/ci/crates.py version --bump prerelease --pre-id=rc
|
|
fi
|
|
|
|
echo If this is an 'alpha', set the version to whatever is in the git branch name.…
|
|
if [ ${{ inputs.release-type }} = "alpha" ]; then
|
|
pixi run python scripts/ci/crates.py version --exact $(pixi run python scripts/ci/crates.py get-version --from git)
|
|
fi
|
|
|
|
echo If this is a 'final', set the version to the final release version…
|
|
if [ ${{ inputs.release-type }} = "final" ]; then
|
|
pixi run python scripts/ci/crates.py version --exact $release_version
|
|
fi
|
|
|
|
echo Store version after the update, and the expected "final" release version…
|
|
current=$(pixi run python scripts/ci/crates.py get-version)
|
|
final=$(pixi run python scripts/ci/crates.py get-version --finalize)
|
|
|
|
echo Output everything for use in other steps…
|
|
echo "previous=$previous"
|
|
echo "current=$current"
|
|
echo "final=$final"
|
|
|
|
echo "previous=$previous" >> "$GITHUB_OUTPUT"
|
|
echo "current=$current" >> "$GITHUB_OUTPUT"
|
|
echo "final=$final" >> "$GITHUB_OUTPUT"
|
|
|
|
# Pick what version we use for creating a github tag.
|
|
if [ ${{ inputs.release-type }} = "final" ]; then
|
|
git_tag=$final
|
|
else
|
|
git_tag=$current
|
|
fi
|
|
|
|
# Verify that it wasn't created yet.
|
|
if [ $(git tag -l "$git_tag") ]; then
|
|
echo "Error: Version tag $git_tag already exists!"
|
|
exit 1
|
|
fi
|
|
echo "git_tag=$git_tag" >> "$GITHUB_OUTPUT"
|
|
|
|
- name: Update rerun_py & rerun_c version
|
|
run: |
|
|
pixi run python scripts/ci/update_rerun_py_and_c_version.py "${{ steps.versioning.outputs.current }}"
|
|
|
|
- name: Update rerun_notebook package version
|
|
run: |
|
|
pixi run python scripts/ci/update_rerun_notebook_version.py "${{ steps.versioning.outputs.current }}"
|
|
|
|
- name: Update JS package versions
|
|
run: |
|
|
pixi run node rerun_js/scripts/version.mjs "${{ steps.versioning.outputs.current }}"
|
|
|
|
- run: pixi run toml-fmt
|
|
|
|
# We must re-sync uv after bumping the version
|
|
- run: pixi run uv lock
|
|
|
|
- name: Commit new version
|
|
id: commit
|
|
if: steps.versioning.outputs.previous != steps.versioning.outputs.current
|
|
run: |
|
|
git pull
|
|
git config --global user.name "rerun-bot"
|
|
git config --global user.email "bot@rerun.io"
|
|
git commit -am "Bump versions to ${{ steps.versioning.outputs.current }}"
|
|
git push
|
|
echo "version_bump_commit_sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
|
|
|
|
- name: Create pull request
|
|
env:
|
|
GH_TOKEN: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
run: |
|
|
pr=$(gh pr view --json headRefName 2>/dev/null || echo "{}")
|
|
if echo "$pr" | jq -e '.headRefName' >/dev/null 2>&1; then
|
|
echo "PR already exists"
|
|
exit 0
|
|
fi
|
|
|
|
echo "PR does not exist, creating…"
|
|
|
|
cat <<'EOF' > pr-body.txt
|
|
### Next steps
|
|
- Test the release
|
|
- For alpha releases:
|
|
- [ ] If a GH release should be published for this alpha (give extra love to alphas deployed to Rerun Hub or when external testing is required):
|
|
- [ ] Create the GitHub release manually from the UI
|
|
- [ ] Stretch goal: generate a raw changelog and add it to the GH release with this disclaimer:
|
|
**DISCLAIMER**: This is an unreviewed, automatically generated changelog. We only provide fully reviewed changelogs for final releases.
|
|
- [ ] Merge or close the release PR
|
|
- **IFF** the release job succeeds and the link checker is happy, you may merge the PR.
|
|
- Otherwise, close the PR without merging. Cherrypick any interesting commit to `main`, but *not* the version bump one (it would introduce bad links).
|
|
- For non-alpha releases:
|
|
- For any added commits, run the release workflow in 'rc' mode again
|
|
- After testing, _ensure that this PR is mergeable to `main`_, then run the release workflow in 'final' mode
|
|
- Once the final release workflow finishes it will create a GitHub release for you. Then:
|
|
- [ ] Sanity check the build artifacts:
|
|
- [ ] pip install: does it install and run?
|
|
- [ ] cargo install of cli tool: does it install and run?
|
|
- [ ] C++ SDK zip: does it contain rerun_c for all platforms?
|
|
- [ ] Web Viewer: does it run and connect to Rerun Hub servers?
|
|
- [ ] Edit and publish the GitHub release:
|
|
- Do NOT create a GitHub release draft yourself! Let the release job do it.
|
|
- Populate the release with the changelog and a nice header video/picture
|
|
- Make sure `Set as latest release` is checked
|
|
- Click `Publish release`
|
|
- Once published, the release assets will sync to it automatically.
|
|
- [ ] Update the [google colab notebooks](https://colab.research.google.com/drive/1R9I7s4o6wydQC_zkybqaSRFTtlEaked_) to install this version and re-execute the notebook.
|
|
- [ ] Verify the auto-triggered [gradio-rerun-viewer release workflow](https://github.com/rerun-io/gradio-rerun-viewer/actions/workflows/auto_release_on_rerun.yml) succeeded (dispatched from `on_gh_release.yml` for final releases)
|
|
- [ ] Create a new branch from the prepare-release branch, rebase that one on main and sync it to reality so it can be merged.
|
|
- [ ] (A few hours later) Check on the [conda feedstock PR](https://github.com/conda-forge/rerun-sdk-feedstock/pulls) (ping Antoine and/or Nick if necessary)
|
|
|
|
- [ ] Tests
|
|
- [ ] Windows
|
|
- [ ] Linux
|
|
- [ ] MacOS
|
|
EOF
|
|
|
|
gh pr create \
|
|
--base main \
|
|
--head $(git branch --show-current) \
|
|
--title "Release ${{ (inputs.release-type == 'alpha' && steps.versioning.outputs.current) || steps.versioning.outputs.final }}" \
|
|
--label "⛴ release" \
|
|
--label "exclude from changelog" \
|
|
--fill \
|
|
--body-file pr-body.txt
|
|
|
|
uv-lock-check:
|
|
name: "Check uv.lock"
|
|
needs: [version]
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- name: Checkout repository
|
|
uses: actions/checkout@v4
|
|
with:
|
|
ref: ${{ needs.version.outputs.release-commit }}
|
|
|
|
- uses: prefix-dev/setup-pixi@v0.10.0
|
|
with:
|
|
pixi-version: v0.71.3
|
|
|
|
- name: Check uv.lock is up-to-date
|
|
run: pixi run uv-lock-check
|
|
|
|
update-docs:
|
|
name: "Update Docs"
|
|
needs: [version, publish-web]
|
|
uses: ./.github/workflows/reusable_deploy_docs.yml
|
|
with:
|
|
CONCURRENCY: ${{ github.ref_name }}
|
|
PY_DOCS_VERSION_NAME: ${{ inputs.release-type == 'final' && needs.version.outputs.final || 'dev' }}
|
|
CPP_DOCS_VERSION_NAME: ${{ inputs.release-type == 'final' && 'stable' || 'dev' }}
|
|
JS_DOCS_VERSION_NAME: ${{ inputs.release-type == 'final' && needs.version.outputs.final || 'dev' }}
|
|
MARKDOWN_DOCS_VERSION_NAME: ${{ inputs.release-type == 'final' && needs.version.outputs.final || 'dev' }}
|
|
RELEASE_COMMIT: ${{ needs.version.outputs.release-commit }}
|
|
RELEASE_VERSION: ${{ needs.version.outputs.final }}
|
|
UPDATE_LATEST: ${{ inputs.release-type == 'final' }}
|
|
secrets: inherit
|
|
|
|
publish-crates:
|
|
name: "Publish Crates"
|
|
if: inputs.release-type != 'alpha' || inputs.publish-crates
|
|
needs: [version, uv-lock-check]
|
|
uses: ./.github/workflows/reusable_release_crates.yml
|
|
with:
|
|
CONCURRENCY: ${{ github.ref_name }}
|
|
RELEASE_COMMIT: ${{ needs.version.outputs.release-commit }}
|
|
secrets: inherit
|
|
|
|
publish-rerun_c:
|
|
name: "Build and Publish C/C++ SDKs"
|
|
needs: [version, uv-lock-check]
|
|
uses: ./.github/workflows/reusable_publish_rerun_c.yml
|
|
with:
|
|
release-version: ${{ needs.version.outputs.current }}
|
|
release-commit: ${{ needs.version.outputs.release-commit }}
|
|
concurrency: ${{ github.ref_name }}
|
|
secrets: inherit
|
|
|
|
publish-rerun-cli:
|
|
name: "Publish rerun-cli"
|
|
needs: [version, uv-lock-check]
|
|
uses: ./.github/workflows/reusable_publish_rerun_cli.yml
|
|
with:
|
|
release-version: ${{ needs.version.outputs.current }}
|
|
release-commit: ${{ needs.version.outputs.release-commit }}
|
|
concurrency: ${{ github.ref_name }}
|
|
secrets: inherit
|
|
|
|
publish-wheels:
|
|
name: "Build and Publish Wheels"
|
|
needs: [version, publish-rerun-cli]
|
|
uses: ./.github/workflows/reusable_publish_wheels.yml
|
|
with:
|
|
release-version: ${{ needs.version.outputs.current }}
|
|
concurrency: ${{ github.ref_name }}
|
|
release-commit: ${{ needs.version.outputs.release-commit }}
|
|
secrets: inherit
|
|
|
|
web-test:
|
|
name: "Web tests"
|
|
needs: [version]
|
|
uses: ./.github/workflows/reusable_web_test.yml
|
|
with:
|
|
CONCURRENCY: ${{ github.ref_name }}
|
|
REF: ${{ needs.version.outputs.release-commit }}
|
|
secrets: inherit
|
|
|
|
publish-web:
|
|
name: "Build and Publish Web"
|
|
needs: [version, publish-wheels, web-test]
|
|
uses: ./.github/workflows/reusable_publish_web.yml
|
|
with:
|
|
release-version: ${{ needs.version.outputs.current }}
|
|
release-commit: ${{ needs.version.outputs.release-commit }}
|
|
concurrency: ${{ github.ref_name }}
|
|
wheel-artifact-name: linux-x64-wheel
|
|
update-latest: ${{ inputs.release-type == 'final' }}
|
|
secrets: inherit
|
|
|
|
publish-js:
|
|
name: "Publish JS"
|
|
needs: [version, uv-lock-check]
|
|
uses: ./.github/workflows/reusable_publish_js.yml
|
|
with:
|
|
release-version: ${{ needs.version.outputs.current }}
|
|
release-commit: ${{ needs.version.outputs.release-commit }}
|
|
concurrency: ${{ github.ref_name }}
|
|
secrets: inherit
|
|
|
|
# Force-pushes `latest` and `docs-latest` to the contents of the release branch.
|
|
# The push to `docs-latest` also triggers a re-deploy of `rerun.io`.
|
|
update-latest-branch:
|
|
name: "Update Latest Branch"
|
|
if: inputs.release-type == 'final' && !cancelled() && !failure()
|
|
needs:
|
|
[
|
|
version,
|
|
update-docs,
|
|
publish-crates,
|
|
publish-wheels,
|
|
publish-web,
|
|
publish-rerun_c,
|
|
publish-rerun-cli,
|
|
publish-js,
|
|
]
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- name: Checkout repository
|
|
uses: actions/checkout@v4
|
|
with:
|
|
fetch-depth: 0
|
|
token: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
ref: ${{ needs.version.outputs.release-commit }}
|
|
|
|
- name: Update latest branch
|
|
run: |
|
|
git config --global user.name "rerun-bot"
|
|
git config --global user.email "bot@rerun.io"
|
|
git fetch
|
|
git checkout ${{ github.ref_name }}
|
|
git push --force origin refs/heads/${{ github.ref_name }}:refs/heads/latest
|
|
git push --force origin refs/heads/${{ github.ref_name }}:refs/heads/docs-latest
|
|
|
|
tag-release:
|
|
name: "Tag Release"
|
|
if: ${{ !cancelled() && !failure() }}
|
|
needs:
|
|
[
|
|
version,
|
|
update-docs,
|
|
publish-crates,
|
|
publish-wheels,
|
|
publish-web,
|
|
publish-rerun_c,
|
|
publish-rerun-cli,
|
|
publish-js,
|
|
]
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- name: Checkout repository
|
|
uses: actions/checkout@v4
|
|
with:
|
|
fetch-depth: 0
|
|
token: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
|
|
- name: Release tag
|
|
env:
|
|
GH_TOKEN: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
run: |
|
|
version="${{ needs.version.outputs.git_tag }}"
|
|
commit="${{ needs.version.outputs.release-commit }}"
|
|
|
|
git tag $version $commit
|
|
git push origin $version
|
|
|
|
- name: Create GH release
|
|
if: inputs.release-type == 'rc' || inputs.release-type == 'final'
|
|
env:
|
|
GH_TOKEN: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
run: |
|
|
version="${{ needs.version.outputs.git_tag }}"
|
|
commit="${{ needs.version.outputs.release-commit }}"
|
|
|
|
if [ ${{ inputs.release-type }} = "final" ]; then
|
|
pre_arg=""
|
|
else
|
|
pre_arg="--prerelease"
|
|
fi
|
|
|
|
gh release create $version --verify-tag --draft --title $version $pre_arg
|
|
|
|
- name: Create comment
|
|
if: inputs.release-type == 'rc' || inputs.release-type == 'final'
|
|
# GitHub API is very unreliable. We don't want to fail the entire workflow just because we couldn't post a comment.
|
|
continue-on-error: true
|
|
env:
|
|
GH_TOKEN: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
run: |
|
|
pr_number=$(gh pr view --json number | jq '.number')
|
|
version="${{ needs.version.outputs.final }}"
|
|
|
|
cat <<EOF > comment-body.txt
|
|
The GitHub release draft for $version can be found in the [release list](https://github.com/rerun-io/rerun/releases).
|
|
|
|
Add a description, changelog, and a nice header video/picture, then click 'Publish release'.
|
|
EOF
|
|
|
|
gh pr comment $pr_number --body-file comment-body.txt
|
|
|
|
# Bump versions to next minor+alpha after the release has finished,
|
|
# so that the release PR can be merged.
|
|
post-release-version-bump:
|
|
name: "Post-Release Version Bump"
|
|
# We don't need to bump versions for `rc` releases, because we don't merge those.
|
|
if: (inputs.release-type == 'alpha' || inputs.release-type == 'final') && !cancelled() && !failure()
|
|
needs:
|
|
[
|
|
version,
|
|
update-docs,
|
|
publish-crates,
|
|
publish-wheels,
|
|
publish-web,
|
|
publish-rerun_c,
|
|
publish-rerun-cli,
|
|
publish-js,
|
|
]
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- name: Checkout repository
|
|
uses: actions/checkout@v4
|
|
with:
|
|
fetch-depth: 0
|
|
token: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
|
|
- uses: actions/setup-node@v4
|
|
with:
|
|
node-version: "22.x"
|
|
|
|
- uses: prefix-dev/setup-pixi@v0.10.0
|
|
with:
|
|
pixi-version: v0.71.3
|
|
|
|
- name: git config
|
|
run: |
|
|
git config --global user.name "rerun-bot"
|
|
git config --global user.email "bot@rerun.io"
|
|
git checkout ${{ github.ref_name }}
|
|
git pull --rebase
|
|
|
|
- name: Update crate versions
|
|
id: crates
|
|
run: |
|
|
pixi run python scripts/ci/crates.py version --bump auto
|
|
version="$(pixi run python scripts/ci/crates.py get-version)"
|
|
echo "version=$version" >> "$GITHUB_OUTPUT"
|
|
|
|
- name: Update rerun_notebook package version
|
|
run: |
|
|
pixi run python scripts/ci/update_rerun_notebook_version.py "${{ steps.crates.outputs.version }}"
|
|
|
|
- name: Update JS package versions
|
|
run: |
|
|
pixi run node rerun_js/scripts/version.mjs "${{ steps.crates.outputs.version }}"
|
|
|
|
- name: Update rerun_py & rerun_c version
|
|
run: |
|
|
pixi run python scripts/ci/update_rerun_py_and_c_version.py "${{ steps.crates.outputs.version }}"
|
|
|
|
- run: pixi run toml-fmt
|
|
|
|
# We must re-sync uv after bumping the version
|
|
- run: pixi run uv lock
|
|
|
|
- name: Commit new version
|
|
run: |
|
|
git commit -am "Bump versions to ${{ steps.crates.outputs.version }}"
|
|
git push
|
|
|
|
comment-artifact-links:
|
|
name: "Link to artifacts"
|
|
if: ${{ !cancelled() && !failure() }}
|
|
needs:
|
|
[
|
|
version,
|
|
update-docs,
|
|
publish-crates,
|
|
publish-wheels,
|
|
publish-web,
|
|
publish-rerun_c,
|
|
publish-rerun-cli,
|
|
publish-js,
|
|
]
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- name: Checkout repository
|
|
uses: actions/checkout@v4
|
|
with:
|
|
fetch-depth: 0
|
|
token: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
|
|
- name: Create comment
|
|
# GitHub API is very unreliable. We don't want to fail the entire workflow just because we couldn't post a comment.
|
|
continue-on-error: true
|
|
env:
|
|
GH_TOKEN: ${{ secrets.RERUN_BOT_TOKEN }}
|
|
run: |
|
|
pr_number=$(gh pr view --json number | jq '.number')
|
|
echo "pr_number: $pr_number"
|
|
short_commit_hash=$(echo ${{ needs.version.outputs.release-commit }} | cut -c1-7)
|
|
|
|
if [ ${{ inputs.release-type }} = "final" ]; then
|
|
web_app_link="https://rerun.io/viewer/version/${{ needs.version.outputs.final }}"
|
|
rerun_io_docs_link="https://rerun.io/docs"
|
|
py_docs_link="https://ref.rerun.io/docs/python/${{ needs.version.outputs.final }}"
|
|
else
|
|
web_app_link="https://rerun.io/viewer/commit/$short_commit_hash"
|
|
rerun_io_docs_link="https://rerun.io/preview/$short_commit_hash/docs"
|
|
py_docs_link="https://ref.rerun.io/docs/python/dev"
|
|
fi
|
|
wheels_link="https://pypi.org/project/rerun-sdk/${{ needs.version.outputs.current }}"
|
|
crates_link="https://crates.io/crates/rerun/${{ needs.version.outputs.current }}"
|
|
npm_link="https://www.npmjs.com/package/@rerun-io/web-viewer/v/${{ needs.version.outputs.current }}"
|
|
rs_docs_link="https://docs.rs/rerun/${{ needs.version.outputs.current }}"
|
|
cpp_sdk_zip_link="https://build.rerun.io/commit/$short_commit_hash/rerun_cpp_sdk.zip"
|
|
|
|
pip_install="pip install rerun-sdk==${{ needs.version.outputs.current }}"
|
|
cargo_install="cargo install rerun-cli@${{ needs.version.outputs.current }} --locked"
|
|
npm_install="npm install @rerun-io/web-viewer@${{ needs.version.outputs.current }}"
|
|
|
|
cat <<EOF > comment-body.txt
|
|
Version ${{ needs.version.outputs.current }} published successfully.
|
|
|
|
| artifact | install |
|
|
| --------------------------------- | -------------- |
|
|
| [web app]($web_app_link) | |
|
|
| [wheels]($wheels_link) | $pip_install |
|
|
| [crates]($crates_link) | $cargo_install |
|
|
| [npm]($npm_link) | $npm_install |
|
|
| [docs]($rerun_io_docs_link) | |
|
|
| [py docs]($py_docs_link) | |
|
|
| [rs docs]($rs_docs_link) | |
|
|
| [cpp_sdk zip]($cpp_sdk_zip_link) | |
|
|
EOF
|
|
|
|
gh pr comment $pr_number --body-file comment-body.txt
|