Enable GZ_ENABLE_RELOCATABLE_INSTALL in CI for gz-cmake3

.github/workflows/ci.yaml

@@ -9,47 +9,48 @@ jobs:
     name: Diff for DSL code
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Idenfify files changed in this PR
         id: files
         run: |
             git diff --name-only origin/${{ github.base_ref }}...origin/${{ github.head_ref }}
-            echo "::set-output name=changed-files::$(git diff --name-only origin/${{ github.base_ref }}...origin/${{ github.head_ref }}| tr '\n' ' ')"
+            echo "changed-files=$(git diff --name-only origin/${{ github.base_ref }}...origin/${{ github.head_ref }}| tr '\n' ' ')"  >> $GITHUB_OUTPUT
       - name: Run testing on changed config files
         id: dsl_check
         run: |
           for changed_file in ${{ steps.files.outputs.changed-files }}; do
             if [[ ${changed_file} != ${changed_file/dsl\/*} ]]; then
               echo "+ Detected at leat one config file: ${changed_file}."
-              echo "::set-output name=run_job::true"
+              echo "run_job=true" >> $GITHUB_OUTPUT
               break
             else
-              echo "::set-output name=run_job::false"
+              echo "run_job=false" >> $GITHUB_OUTPUT
             fi
           done
       - name: Checkout
         if: steps.dsl_check.outputs.run_job == 'true'
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 2
       - uses: actions/setup-java@v3
         if: steps.dsl_check.outputs.run_job == 'true'
         with:
           distribution: 'temurin'
           java-version: '11'
-      - name: Download job dsl jar
+      - name: Download and setup job dsl jar
         if: steps.dsl_check.outputs.run_job == 'true'
-        run: curl -sSL https://repo.jenkins-ci.org/public/org/jenkins-ci/plugins/job-dsl-core/1.77/job-dsl-core-1.77-standalone.jar -o jobdsl.jar
+        run: ./jenkins-scripts/dsl/tools/setup_local_generation.bash
+
       - name: Generate all DSL files
         if: steps.dsl_check.outputs.run_job == 'true'
         run: |
           # simulate token for brew_release
           sudo mkdir -p /var/lib/jenkins/ && sudo touch /var/lib/jenkins/remote_token
           sudo chown -R ${USER} /var/lib/jenkins
           cd jenkins-scripts/dsl
-          java -jar ../../jobdsl.jar *.dsl
+          java -jar tools/jobdsl.jar *.dsl
           # export files for later diff
           mkdir /tmp/pr_xml_configuration
           mv *.xml /tmp/pr_xml_configuration/
@@ -59,7 +60,7 @@ jobs:
           git clean -f -e jobdsl.jar
           git checkout master
           cd jenkins-scripts/dsl
-          java -jar ../../jobdsl.jar *.dsl
+          java -jar tools/jobdsl.jar *.dsl
           mkdir /tmp/current_xml_configuration
           mv *.xml /tmp/current_xml_configuration/
       - name: Generating diffs

.gitignore

@@ -1 +1,2 @@
 .pyc
+jenkins-scripts/dsl/tools/*.jar

bloom/ros_gazebo_pkgs/release-bloom.py → bloom/release-bloom.py

@@ -1,21 +1,22 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 from __future__ import print_function
+import argparse
 import subprocess
 import sys
-import urllib
-import argparse
+import urllib.request
+import urllib.parse
 
-USAGE = 'release-bloom.py <package> <version> <upstream_release_repo> <ros_distro> [--ignition-version version_name] <jenkinstoken>'
+USAGE = 'release-bloom.py <package> <version> <upstream_release_repo> <ros_distro> <jenkinstoken>'
 JENKINS_URL = 'http://build.osrfoundation.org'
 JOB_NAME_PATTERN = '%s-bloom-debbuilder'
 
 UBUNTU_ARCHS = ['amd64']
-# not releasing for precise by default
-UBUNTU_DISTROS_IN_ROS = {'melodic': ['bionic'],
-                         'noetic': ['focal']}
+UBUNTU_DISTROS_IN_ROS = {'noetic': ['focal']}
 UBUNTU_DISTROS_IN_ROS2 = {'foxy': ['focal'],
-                          'rolling': ['focal']}
+                          'humble': ['jammy'],
+                          'iron': ['jammy'],
+                          'rolling': ['jammy']}
 DRY_RUN = False
 
 def parse_args(argv):
@@ -34,9 +35,6 @@ def parse_args(argv):
                         help='Release version suffix; usually 1 (e.g., 1')
     parser.add_argument('--upload-to-repo', dest='upload_to_repository', default="stable",
                         help='OSRF repo to upload: stable | prerelease | nightly')
-    parser.add_argument('--ignition-version', action='store', default=None,
-                        help='Gazebo version to use in the binary packages')
-
     args = parser.parse_args()
     DRY_RUN = args.dry_run
     return args
@@ -77,13 +75,10 @@ def call_jenkins_jobs(argv):
         params['ROS2'] = True
         ubuntu_per_ros_distro = UBUNTU_DISTROS_IN_ROS2
 
-    if args.ignition_version:
-        params['IGNITION_VERSION'] = args.ignition_version
-
     if not args.release_version:
         args.release_version = 0
     params['RELEASE_VERSION'] = args.release_version
-    params_query = urllib.urlencode(params)
+    params_query = urllib.parse.urlencode(params)
     base_url = '%s/job/%s/buildWithParameters?%s' % \
                (JENKINS_URL, JOB_NAME_PATTERN % (args.package), params_query)
 
@@ -93,7 +88,7 @@ def call_jenkins_jobs(argv):
                   (base_url, arch, ubuntu_distro, args.ros_distro)
             print('Accessing: %s' % (url))
             if not DRY_RUN:
-                urllib.urlopen(url)
+                urllib.request.urlopen(url)
 
 
 if __name__ == '__main__':

bloom/ros_gazebo_pkgs/ros_gazebo_pkgs-release.py.bash

@@ -14,5 +14,5 @@ if [[ ${1%-*} != "${1}" ]]; then
 fi
 
 for p in gazebo-dev gazebo-msgs gazebo-plugins gazebo-ros gazebo-ros-control gazebo-ros-pkgs; do
-    ./release-bloom.py ${p} $(for i in $@; do echo -n "$i "; done)
+    ../release-bloom.py ${p} $(for i in $@; do echo -n "$i "; done)
 done

bloom/ros_gz/Dockerfile

@@ -0,0 +1,31 @@
+ARG ROS_DISTRO=humble
+
+FROM ros:$ROS_DISTRO-ros-base
+
+ENV LANG C
+ENV LC_ALL C
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \
+      coreutils \
+      dpkg-dev \
+      python3-bloom \
+      wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install osrf-rosdep for Garden
+RUN sudo bash -c \
+  'wget https://raw.githubusercontent.com/osrf/osrf-rosdep/master/gz/00-gazebo.list -O /etc/ros/rosdep/sources.list.d/00-gazebo.list'
+# Replace Fortress with Garden to make bloom to work
+# since it does not support arbitrary environemnt variables
+RUN sudo bash -c \
+  'wget https://raw.githubusercontent.com/osrf/osrf-rosdep/master/gz/replace_fortress_with_garden/00-replace-gz-fortress-with-garden.list -O /etc/ros/rosdep/sources.list.d/00-replace-gz-fortress-with-garden.list'
+
+# Not for using bloom but useful for rosdep calls
+ENV GZ_VERSION=garden
+ENV IGNITION_VERSION=garden
+
+WORKDIR /tmp
+COPY _check_metadata.bash .
+COPY _rosdep_wrapper.bash .
+ENTRYPOINT ["/tmp/_rosdep_wrapper.bash"]

bloom/ros_gz/README.md

@@ -0,0 +1,109 @@
+# Release new version of Gazebo unofficial wrappers
+
+1. Background
+   * Upstream versions released using this tutorial
+2. Initial setup
+   * Create the alternative -release repository
+   * Create a custom track in tracks.yaml
+3. Run a new release
+   * Prerequisites
+   * Bloom a new release 
+
+## 1. Background
+
+Each ROS release defines one version of Gazebo supported officially through
+all the ROS packages. The different combinations of ROS <-> Gazebo can be
+found in the [REP-3](http://www.ros.org/reps/rep-2000.html). Some examples:
+
+ * ROS 2 Foxy: Citadel
+ * ROS 2 Humble: Fortress
+
+Some use cases require the use of alternative combinations of ROS and Gazebo
+versions. The `ros_gz` code is usually prepared to be compatible with
+different versions of Gazebo, especially the latest ones.
+
+Although using the officially supported version is the recommended way
+specially for non experienced users, some use cases might need to use a
+newer version of Gazebo than the one selected in REP-2000.
+
+### Upstream versions released using this tutorial
+
+The `gbp -release repository` hosts the latest version released by the
+maintainers of `ros_gz`. When using these instructions to release a new custom
+version the version of `ros_gz` released will be the latest one existing in the
+official `gbp -release repository`. The version would be the same but the
+release number will start on 1000.
+
+## 2. Initial setup 
+
+To release a modified version of `ros_gz` which supports a different major
+version of gazebo, before running bloom some actions need to be taken:
+
+### 2.1 Create the alternative -release repository
+
+For a new official wrappers the notation used below correspond to `ros_ign-release`:
+
+ 1. Fork (manually or using gh) current gbp repository:
+    https://github.com/ros2-gbp/ros_ign-release
+
+ 1. Clone the new repo, go to the directory and run rename-gazebo-ros-pkgs.bash
+    - Usage: `$ rename-ros_gz-pkgs.bash <desired_gz_version> <space separted list of rosdistros to release>`
+    - Example: `$ rename-ros_gz-pkgs.bash garden humble`
+
+
+### 2.2 Create a custom track in tracks.yml
+
+Copy the existing ROS 2 yaml track information and rename it to `${ros2}_gz${version}`.
+For example, the `humble` track to be used as base for Garden would be `humble_gzgarden`.
+
+New versioning requires bumping to large numbers. Set:
+
+```
+    release_inc: '1000'
+```
+
+Debian, rhel and fedora generators can be removed.
+
+## 3. Run a new release
+
+To execute a new release of the ros_gz unofficial wrappers there are mainly two
+steps to do: use bloom to generate new metadata in the -release repo fork and
+use ros_gz-release.py script to trigger the builds builds.osrfoundation.org.
+
+The new version will be the latest one released in the rosdistro index of the
+official ros_gz packages.
+
+### Prerequisites
+
+The host system to release should have `docker` and `rocker` installed.
+
+### 3.1 Bloom a new release
+
+Blooming a new release of the ros_gz unofficial wrappers requires some changes
+to be done in the releasing enviroment affecting the rosdep rules. To facilitate
+this, there is a `Dockerfile` that provides the needed modifications and a script
+that encapsulates the bloom arguments to be passed and the use of this enviroment.
+
+```
+./bloom_from_special_env.bash
+```
+
+The script will create the docker enviroment with the rosdep modifications needed
+and invoke rocker with `--home` and `--user` flags to pass the credentials and
+customatizations needed for the bloom call. It will run the `bloom-release` command
+with the arguments required for the ros_gz wrappers.
+
+### 3.2 Launching jobs in the osrf buildfarm
+
+The previous step generates the metadata needed to build the debians but there is
+a final step to call the jobs inside the buildfarm that will create the debians.
+
+To do so, for simulating the calls to be done to the buildfarm:
+
+```
+./ros_gz-release.py.bash <version-without-revision> <release-repo> <ros_distro> <token> --dry-run -r <revision>
+# Example for 0.244.11-1001 version for ROS Humble in ros_ign-release
+./ros_gz-release.py.bash 0.244.11 https://github.com/gazebo-release/ros_ign-release humble foo --dry-run -r 1001
+```
+
+For releasing directly, just remove the `--dry-run` argument.

bloom/ros_gz/_check_metadata.bash

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -e
+
+
+if [[ $# -lt 2 ]]; then
+  echo "Usage: $0 <RELEASE_REPO_URL> <ROS_DISTRO>"
+  exit 1
+fi
+
+RELEASE_REPO_URL=${1}
+ROS_DISTRO=${2}
+
+TMP_DIR=$(mktemp -d) 
+git clone "${RELEASE_REPO_URL}" "${TMP_DIR}"
+pushd "${TMP_DIR}" 2> /dev/null || exit
+cd "${TMP_DIR}" || exit
+DEBIAN_LATEST_TAG=$(git for-each-ref --sort=creatordate --format '%(refname)' refs/tags | \
+          grep "debian/ros-${ROS_DISTRO}" | \
+          tail -1 | sed 's:refs/tags/::')
+git checkout "${DEBIAN_LATEST_TAG}"
+dpkg-parsechangelog -SSource 
+if ! dpkg-parsechangelog -SSource | grep -q 'gzgarden' > /dev/null; then
+  echo "Latest changelog entry does not have gzgarden name"
+  echo "in the repo tag ${DEBIAN_LATEST_TAG} for repo ${RELEASE_REPO_URL}"
+  echo "Maybe the rename in the bloom templates was not done."
+  exit 1
+fi
+popd 2>/dev/null || exit

bloom/ros_gz/_rosdep_wrapper.bash

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -e
+
+rosdep update
+
+exec "$@"

bloom/ros_gz/bloom_from_special_env.bash

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+if [[ $# -lt 1 ]]; then
+  echo "Usage: $0 <ros_distro>"
+  exit 1
+fi
+
+ROS_DISTRO=${1}
+# Might be used with testing proposes to change gbp-release repo
+GBP_ORG=${GBP_ORG:-gazebo-release}
+RELEASE_REPO_URL=https://github.com/${GBP_ORG}/ros_ign-release
+
+if ! command rocker --version &> /dev/null
+then
+  echo "Please install the rocker app https://github.com/osrf/rocker"
+  exit 1
+fi
+
+# TODO: update URL for the release repo
+BLOOM_CMD="/usr/bin/bloom-release --no-pull-request \
+   --rosdistro ${ROS_DISTRO}\
+   --track ${ROS_DISTRO}_gzgarden \
+   --override-release-repository-url \
+   ${RELEASE_REPO_URL} ros_gz"
+
+TAG_NAME=${TAG_NAME:-ros_gz-${ROS_DISTRO}-fortress-garden-release}
+
+echo " * Build the docker release environment"
+docker build . -t "${TAG_NAME}" --build-arg ROS_DISTRO="${ROS_DISTRO}"
+echo " * Using rocker to enter in the release environment"
+rocker --home --user "${TAG_NAME}" "${BLOOM_CMD}"
+echo " * Exit the docker release environment"
+echo " * Restoring the rosdep cache in the user"
+rosdep update
+echo " * Running safety check in generated metadata"
+docker run "${TAG_NAME}" /tmp/_check_metadata.bash "${RELEASE_REPO_URL}" "${ROS_DISTRO}"