diff --git a/.github/ISSUE_TEMPLATE/release.md b/.github/ISSUE_TEMPLATE/release.md new file mode 100644 index 0000000000..31321fddbd --- /dev/null +++ b/.github/ISSUE_TEMPLATE/release.md @@ -0,0 +1,156 @@ +--- +name: Release issue template +about: Tracking issue for new releases +title: Cumulus {{ env.VERSION }} Release checklist +--- +# Release Checklist + +### Runtime Releases + +These checks should be performed on the codebase. + +- [ ] Verify [`spec_version`](#spec-version) has been incremented since the + last release for any native runtimes from any existing use on public + (non-private/test) networks. +- [ ] Verify previously [completed migrations](#old-migrations-removed) are + removed for any public (non-private/test) networks. + - No migrations added in the last release that would need to be removed. +- [ ] Verify pallet and [extrinsic ordering](#extrinsic-ordering) as well as `SignedExtension`s have stayed + the same. Bump `transaction_version` if not. +- [ ] Verify new extrinsics have been correctly whitelisted/blacklisted for + [proxy filters](#proxy-filtering). + - No new extrinsics. +- [ ] Verify [benchmarks](#benchmarks) have been updated for any modified + runtime logic. + - [ ] Verify the weights are up-to-date. +- [ ] Verify that the various pieces of XCM config are sane. + +The following checks can be performed after we have forked off to the release- +candidate branch or started an additional release candidate branch (rc-2, rc-3, etc) + +- [ ] Verify [new migrations](#new-migrations) complete successfully, and the + runtime state is correctly updated for any public (non-private/test) + networks. +- [ ] Run integration tests. + - [ ] Teleport Relay -> Statemin* and back. + - [ ] Create asset (if applicable), mint and transfer +- [ ] Push runtime upgrade to Westmint and verify network stability. + + +### All Releases + +- [ ] Check that the new polkadot-collator versions have [run on the network](#burn-in) + without issue. +- [ ] Check that a draft release has been created at + https://github.com/paritytech/cumulus/releases with relevant [release + notes](#release-notes). +- [ ] Check that [build artifacts](#build-artifacts) have been added to the + draft-release. + +--- + +## Notes + +### Burn In + +Ensure that Parity DevOps has run the new release on Westmint and Statemine collators for 12h prior to publishing the release. + +### Build Artifacts + +Add any necessary assets to the release. They should include: + +- Linux binary +- GPG signature of the Linux binary +- SHA256 of binary +- Source code +- Wasm binaries of any runtimes + +### Release notes + +The release notes should list: + +- The priority of the release (i.e., how quickly users should upgrade) - this is + based on the max priority of any *client* changes. +- Which native runtimes and their versions are included +- The proposal hashes of the runtimes as built with + [srtool](https://github.com/paritytech/srtool) +- Any changes in this release that are still awaiting audit + +The release notes may also list: + +- Free text at the beginning of the notes mentioning anything important + regarding this release +- Notable changes separated into sections. + +### Spec Version + +A runtime upgrade must bump the spec number. This may follow a pattern with the +client release (e.g. runtime v12 corresponds to v0.8.12, even if the current +runtime is not v11). + +### Runtime version bump between RCs + +The clients need to be aware of runtime changes. However, we do not want to bump the +`spec_version` for every single release candidate. Instead, we can bump the `impl` field of the version +to signal the change to the client. + +### Old Migrations Removed + +Previous `on_runtime_upgrade` functions from old upgrades should be removed. + +### New Migrations + +Ensure that any migrations that are required due to storage or logic changes +are included in the `on_runtime_upgrade` function of the appropriate pallets. + +### Extrinsic Ordering & Storage + +Offline signing libraries depend on a consistent ordering of call indices and +functions. Compare the metadata of the current and new runtimes and ensure that +the `module index, call index` tuples map to the same set of functions. It also checks if there have been any changes in `storage`. In case of a breaking change, increase `transaction_version`. + +To verify the order has not changed, manually start the following [Github Action](https://github.com/paritytech/cumulus/actions/workflows/extrinsic-ordering-check-from-bin.yml). It takes around a minute to run and will produce the report as artifact you need to manually check. + +To run it, in the _Run Workflow_ dropdown: +1. **Use workflow from**: to ignore, leave `master` as default +2. **The WebSocket url of the reference node**: + - Statemine: `wss://kusama-statemine-rpc.paritytech.net` + - Westmint: `wss://westmint-rpc.polkadot.io` +3. **A url to a Linux binary for the node containing the runtime to test**: Paste the URL of the latest release-candidate binary from the draft-release on Github. The binary has to previously be uploaded to S3 (Github url link to the binary is constantly changing) + - https://releases.parity.io/cumulus/statemine-v6.0.0-rc1/polkadot-collator +4. **The name of the chain under test. Usually, you would pass a local chain**: + - Statemine: `statemine-local` + - Westmint: `westmint-local` +5. Click **Run workflow** + +When the workflow is done, click on it and download the zip artifact, inside you'll find an `output.txt` file. The things to look for in the output are lines like: + +- `[Identity] idx 28 -> 25 (calls 15)` - indicates the index for Identity has changed +- `[+] Society, Recovery` - indicates the new version includes 2 additional modules/pallets. +- If no indices have changed, every modules line should look something like `[Identity] idx 25 (calls 15)` + +**Note**: Adding new functions to the runtime does not constitute a breaking change +as long as the indexes did not change. + +**Note**: Extrinsic function signatures changes (adding/removing & ordering arguments) are not caught by the job, so those changes should be reviewed "manually" + +### Proxy Filtering + +The runtime contains proxy filters that map proxy types to allowable calls. If +the new runtime contains any new calls, verify that the proxy filters are up to +date to include them. + +### Benchmarks + +Until #631 is done, running the benchmarks is a manual process: +1. Connect to the bechmarking machine +2. Make sure no one else is using the machine with `htop check` +3. Pull in the branch of Cumulus that has the version of Statemine you want to release +4. Recompile `cargo build --release --features runtime-benchmarks` +5. From the root directory run `nohup ./scripts/benchmarks.sh &` (it will take quite a few hours) +6. Checkout in your local machine to the branch of cumulus that has the version of Statemine you want to release +7. `scp` from the host to your local machine the weights for Statemine, Westmint and Statemint you'll find in: + - `/polkadot-parachains/statemine/src/weights` + - `/polkadot-parachains/westmint/src/weights` + - `/polkadot-parachains/statemint/src/weights` +8. Commit the changes in your local and create a PR diff --git a/.github/workflows/release-01_rc-automation.yml b/.github/workflows/release-01_rc-automation.yml new file mode 100644 index 0000000000..60beac022d --- /dev/null +++ b/.github/workflows/release-01_rc-automation.yml @@ -0,0 +1,61 @@ +name: Release-candidate automation +on: + push: + branches: + - release-**v[0-9]+.[0-9]+.[0-9]+ +jobs: + tag_rc: + runs-on: ubuntu-latest + steps: + - name: Checkout sources + uses: actions/checkout@v2 + with: + fetch-depth: 0 + - id: compute_tag + name: Compute next rc tag + shell: bash + run: | + # Get last rc tag if exists, else set it to {version}-rc1 + version=${GITHUB_REF#refs/heads/release-} + echo "$version" + echo "::set-output name=version::$version" + git tag -l + last_rc=$(git tag -l "$version-rc*" | sort -V | tail -n 1) + if [ -n "$last_rc" ]; then + suffix=$(echo "$last_rc" | grep -Eo '[0-9]+$') + echo $suffix + ((suffix++)) + echo $suffix + echo "::set-output name=new_tag::$version-rc$suffix" + echo "::set-output name=first_rc::false" + else + echo "::set-output name=new_tag::$version-rc1" + echo "::set-output name=first_rc::true" + fi + - name: Apply new tag + uses: tvdias/github-tagger@v0.0.2 + with: + # We can't use the normal GITHUB_TOKEN for the following reason: + # https://docs.github.com/en/actions/reference/events-that-trigger-workflows#triggering-new-workflows-using-a-personal-access-token + # RELEASE_BRANCH_TOKEN requires public_repo OAuth scope + repo-token: "${{ secrets.RELEASE_BRANCH_TOKEN }}" + tag: ${{ steps.compute_tag.outputs.new_tag }} + - id: create-issue + uses: JasonEtco/create-an-issue@v2 + # Only create the issue if it's the first release candidate + if: steps.compute_tag.outputs.first_rc == 'true' + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + VERSION: ${{ steps.compute_tag.outputs.version }} + with: + filename: .github/ISSUE_TEMPLATE/release.md + - name: Send Matrix message + uses: s3krit/matrix-message-action@v0.0.3 + if: steps.create-issue.outputs.url != '' + with: + room_id: ${{ secrets.INTERNAL_POLKADOT_MATRIX_ROOM_ID }} + access_token: ${{ secrets.MATRIX_ACCESS_TOKEN }} + server: "matrix.parity.io" + message: | + Release process for Cumulus ${{ steps.compute_tag.outputs.version }} has been started. + Tracking issue: ${{ steps.create-issue.outputs.url }}" diff --git a/.github/workflows/draft_release.yml b/.github/workflows/release-02_create-draft.yml similarity index 100% rename from .github/workflows/draft_release.yml rename to .github/workflows/release-02_create-draft.yml diff --git a/.github/workflows/release-bot.yml b/.github/workflows/release-99_bot-announce.yml similarity index 100% rename from .github/workflows/release-bot.yml rename to .github/workflows/release-99_bot-announce.yml diff --git a/pallets/xcmp-queue/src/lib.rs b/pallets/xcmp-queue/src/lib.rs index 92d8bb2b7e..4ef989dae4 100644 --- a/pallets/xcmp-queue/src/lib.rs +++ b/pallets/xcmp-queue/src/lib.rs @@ -382,7 +382,9 @@ impl Pallet { let weight = max_weight - weight_used; match Self::handle_xcm_message(sender, sent_at, xcm, weight) { Ok(used) => weight_used = weight_used.saturating_add(used), - Err(XcmError::WeightLimitReached(required)) if required <= max_weight => { + Err(XcmError::WeightLimitReached(required)) + if required <= max_weight => + { // That message didn't get processed this time because of being // too heavy. We leave it around for next time and bail. remaining_fragments = last_remaining_fragments;