Skip to content

Lyo Release Process

Jump to bottom
Jad El-khoury edited this page Jun 29, 2023 · 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. Check for the date of the last release that passed a review (👁️ -marked) on https://projects.eclipse.org/projects/technology.lyo. Do the following steps only if more than 1 year passed since:
    1. 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.
    2. Generate IP Log. Will land at EMO/IP and an IPZilla ticket will be created automatically. Need to use the new "Eclipse Dash"
      Maven plugin.
    3. 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.
  4. Make a Beta release while you wait 2 weeks. Email lyo-dev.
  5. Make a candidate CR release after you get a GO decision for the release.
  6. Test and email CR info to lyo-dev and wait 24h. Also test that the refimpl works with the CR.
  7. When ready to make the final release, edit and update the release note (on https://projects.eclipse.org/projects/technology.lyo/) - iff necessary
    1. Only necessary, if - for example - you need to update the release date.
  8. Make a final release (See steps below)
  9. 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.
  5. if the release is Final, get at least one approval.
  6. Once reviewed & approved, merge the PR to master.
  7. Wait for the build to succeed on Eclipse Lyo Jenkins.
  8. Pull the latest master, and tag the release
    1. git tag v4.1.0.xx (previously, final releases were tagged without "final". In future, we should add "final" to the tag.)
    2. git push --tags
  9. Create a draft release note under https://github.com/eclipse/lyo/releases.
    1. if you are releasing a candidate, check the "Set as a pre-release" checkbox
    2. Set the appropriate tag under "choose a tag"
    3. Duplicate the relevant content from the ChangeLog, but also add a statement that "This content is a duplicate of the Change Log (make sure to point to the tagged revision, not to master)
    4. Once done, save by pressing “Save draft” (and not “publish release”)

Phase 1b: Testing on OSLC RefImpl

Steps:

  1. Go to the Refimpl Actions
  2. click run workflow
  3. wait for success.

Phase 1c: Promote to Maven Central

  1. Log in to https://oss.sonatype.org/#welcome (legacy host, Lyo is on the "legacy" host)
  2. go to Staging Repositories.
  3. Select the listed Lyo repository and click Close. This may take a few minutes. See OSSRH docs for more info.
  4. Click Release (you may need to refresh first (every few minutes)). In pop up window, leave Automatically Drop option ON unless you know what you are doing (the release action is irreversible anyway).
  5. Publish the previously saved draft (pre)release note under https://github.com/eclipse/lyo/releases
  6. Keep refreshing on sonatype from time to time (every few minutes). When the list becomes empty, the release is finished!
  7. 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. Push the changes to master for LyoDesigner
  4. 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