Skip to content

Lyo Release Process

Jump to bottom
Jad El-khoury edited this page Nov 9, 2022 · 41 revisions

The plan is to make two releases: one candidate and one final. Suggested version qualifiers are suggested below (Maven version sort reference):

Stage SDK version Designer version
devel 4.0.0-SNAPSHOT 4.0.0.qualifier
alpha/beta 4.0.0.alpha 4.0.0.alpha
candidate 4.0.0.CR 4.0.0.CR
final (release) 4.0.0.Final 4.0.0.Final
devel-next 4.1.0-SNAPSHOT 4.1.0.qualifier

NB! Make sure to always to a Git revert after you made a candidate (or alpha/beta/milestone) release. This avoids double deploy of non-SNAPSHOT artifacts that can break the Jenkins build.

Admin & overall process

  1. Check the handbook and determine the next available Wednesday slot (should conclude on the 1st or 3rd Wed of the month) for the release.
  2. When making a CR, create a release. Paste the CHANGELOG into he Description under the Basic tab; select Type A diligence.
  3. (skip until 2022-12-01) Request release review by sending an email to the EMO (use a "Schedule a review for this release" link to create an email from template!). Will land at EMO and they will create a Gitlab ticket.
  4. (skip until 2022-12-01) Generate IP Log. Will land at EMO/IP and an IPZilla ticket will be created automatically.
  5. (skip until 2022-12-01) Request a release approval from the PMC once you have a Gitlab link and (preferable, but not strictly necessary) an approval of the IP log. It's just an email, and having the links to the release entry, Gitlab and IPzilla tickets should be enough.
  6. Make a Beta release while you wait 2 weeks. Email lyo-dev.
  7. Make a candidate CR release after you get a GO decision for the release.
  8. Test and email CR info to lyo-dev and wait 24h. Also test that the refimpl works with the CR.
  9. When ready to make the final release, edit and update the release note if necessary (for example, to update the release date).
  10. Make a final release (See steps below)
  11. Announce on lyo-dev, oslc-op, and the OSLC Forum.

Part 1: SDK libraries to Maven Central

Minor releases on Eclipse require release review. Make sure to schedule one ASAP, they only take place twice a month.

Phase 1a: New version, Git push, and Eclise Maven release deploy

  1. Make sure you are on master and the repo is clean and pulled.
  2. mvn versions:set -DnewVersion=4.1.0.xx
  3. If the release is a Final one, edit the CHANGELOG.md and replace [Unreleased] with [#.#.#]
  4. Push to a new branch and create a PR. Get at least one approval if the release is Final.
  5. We need to wait for the build to succeed on Eclipse Lyo Jenkins.
  6. Tag the release
    1. git tag v4.1.0.xx
    2. git push --tags
  7. Create a draft release note (draft pre-release if you are releasing a candidate) under https://github.com/eclipse/lyo/releases. Add a CHANGELOG link in the description (make sure to point to the tagged revision, not to master):

Phase 1b: Testing on OSLC RefImpl

Note: this a test of the SDK and not the Designer. We are not re-generating the OSLC Server code using the Designer Generator at this stage.

NB! Make sure to test without having any entries for the lyo-releases repository in the POM files. Also, it is recommended to run rm -rf ~/.m2/repository/org/eclipse/lyo to be 100% sure that the packages will load from Maven Central and that no modules like parent are forgotten.

Steps:

  1. In the src/pom.xml, update the version.lyo and version.lyo.oslc-ui values.
  2. Run mvn clean package inside the /src dir.
  3. Build and start 4 Docker images by running docker-compose up --build from the /src dir.
  4. In another terminal, run java -jar client-toolchain/target/client-toolchain-0.0.1-SNAPSHOT-jar-with-dependencies.jar from the /src dir to populate servers with data.
  5. Test manually that the linking across adaptors and the Query Capability works.

Phase 1c: Promote to Maven Central (ask Andrew)

Only Andrew has the credentials to OSSRH. They don't support 2FA, so it's not optimal to share the credentials from the security PoV.

  1. Only Andrew: Log in to https://oss.sonatype.org/#welcome (legacy host, Lyo is on the "legacy" host) and go to Staging Repositories. Ask Andrew for
  2. Click Close. This may take a few minutes. See OSSRH docs for more info.
  3. Click Release (you may need to refresh first). Leave Automatically Drop option ON unless you know what you are doing (the release action is irreversible anyway).
  4. Publish the previously saved draft (pre)release note under https://github.com/eclipse/lyo/releases
  5. Keep refreshing from time to time. When the list becomes empty, the release is finished! Visit https://repo1.maven.org/maven2/org/eclipse/lyo/oslc4j/core/oslc4j-core/ to check if the artifacts were promoted to Maven Central from OSSRH already (this usually takes around 2hrs).

Phase 1d: Bring the master branch back to the SNAPSHOT state

Once you have confirmed that the release build has concluded, you can do these steps, no need to wait for the Maven Central promotion.

if you released a milestone build, revert the release comment to go back to the snapshot version:

git checkout master
git pull
git revert --no-commit HEAD
git commit -m "Continue the SNAPSHOT development"
git push

If you released a final release, use versions:set to set the next planned version with the SNAPSHOT modifier, e.g. for 4.1.0 release:

git checkout master
git pull
mvn versions:set -DnewVersion=4.2.0-SNAPSHOT
# Edit the `CHANGELOG.md` and add the `[Unreleased]` template from the bottom of the file to the top
git commit -m "Continue the SNAPSHOT development"
git push

Part 2: Lyo Designer

Notes relating to the dependencies between Lyo Designer and the Lyo SDK:

  1. the OSGI bundles module (org.eclipse.lyo.oslc4j.plugins) depend on a specific version of the Lyo SDK. This is set with <properties>...<lyo.version>...</lyo.version></properties>
  2. Lyo Designer (org.eclipse.lyo.tools.toolchain.design) proposes a default version of the Lyo SDK for newly created models. This can be see in the 4+ places in the file description/ToolChainModel.odesign, by searching for featureName="lyoVersion" valueExpression=...

Before starting the release process for Lyo Designer

  1. Finalize the release process of the Lyo SDK.
  2. Update the above modules, to refer to the released Final version of the Lyo SDK.
  3. Start the release process for LyoDesigner

Links:

Stable:

You will need to run the steps below twice. First to release a candidate (eg. 4.0.0.CR), and then - if all goes well - make a final release (4.0.0.Final). The same steps apply for both phases, except for the choice of version number. The final step has a variation, which is detailed below.

  1. Switch to the master branch of LyoDesigner and do a git pull.
  2. Create a new branch for the release.
  3. Run on the command line (cd to lyo.designer folder first):
    mvn -f pom.xml org.eclipse.tycho:tycho-versions-plugin:set-version -DnewVersion='<versionNumner>' -DforceStdout -B
    1. Set to, e.g., 4.0.0.CR or 4.0.0.Final
    2. That is, make sure to add .Final to a final version. Otherwise update will not work.
  4. For the org.eclipse.lyo.oslc4j.plugins artifact, manually update the artifact version. (this is not updated via the Tycho plugin above)
  5. Run the following commands in bash to verify a clean version update. Besides test plugins, there should be no artefact that refers to a qualifier nor SNAPSHOT version:
    1. grep --exclude-dir=.git --exclude-dir=target --exclude-dir=bin -rE "qualifier" . 2>/dev/null
    2. grep --exclude-dir=.git --exclude-dir=target --exclude-dir=bin -rE "SNAPSHOT" . 2>/dev/null
  6. Push the branch and make a pull request.
  7. Merge. This will trigger the CI build to create artefacts on edge. (might want to go to https://ci.eclipse.org/lyo/job/lyo-designer-master/ and manually start the build to make it faster)
  8. Once edge is built, download/update and test LyoDesigner.
    1. Does it work in general?
    2. Does it generate code as expected?
    3. Does it have the correct plugin versions? Select Help > About Lyo Designer > Installation Details and then check the versions of Installed Software.
    4. In a generated OSLC Server, make sure that the generated Application class has the right version ID, e.g. Generated by Lyo Designer 4.0.0.CR and DOES NOT include a timestamp. Timestamp is a sign of a .qualifier version in OSGI manifests.
  9. run the release job https://ci.eclipse.org/lyo/job/lyo-designer-release/build?delay=0sec to copy artefacts from edge to stable THis will prompt you for the version id. (e.g., 4.0.0.CR or 4.0.0.Final).
  10. Once stable is built, run the promote job https://ci.eclipse.org/lyo/job/lyo-designer-promote/. THis will prompt you for the version id. (e.g., 4.0.0.CR or 4.0.0.Final)
  11. Bring the master branch to a SNAPSHOT/qualifier state. This steps differs depending on whether you just made a Candidate (e.g., alpha1, beta1, CR) or Final release.
    • If you made a Candidate release
      1. Do a Git revert and push this commit.
      2. Go to Step 1 above to do the final release
    • If you made a Final release, push the changes below directly to master
      1. Bump the version number up a bit: mvn -f pom.xml org.eclipse.tycho:tycho-versions-plugin:set-version -DnewVersion='<versionNumber>' -DforceStdout -B. Set the <versionNumber> to something such as 4.0.1-SNAPSHOT or 4.1.0-SNAPSHOT.
      2. For the org.eclipse.lyo.oslc4j.plugins artifact, manually update the artifact version. (this is not updated via the Tycho plugin above)
      3. For the org.eclipse.lyo.oslc4j.plugins artifact, manually change the Lyo version from which the plugins are to be made. (preferably, the same version as what was just been bumped to). <lyo.version>4.1.0-SNAPSHOT</lyo.version>
      4. Commit and push the changes to master.
      5. The new snapshot will be built and released to "edge"
      6. You are done!
Clone this wiki locally