Remove the Release 1 pipeline files; point everything at Release 2

new_docker_build.sh and rpmbuild/make_rpm_ubuntu26.py (Release 1
validation-scope driver/producer) did not belong to this branch; their
functional callers are adapted to the Release 2 files:

- rpmbuild/make_rpm_ubuntu26_release2.py: PIPELINE_FILES now packages
  new_docker_build_release2.sh and make_rpm_ubuntu26_release2.py.
- jenkins-ci-rme/jenkins_builder_ubuntu26.sh: runs
  make_rpm_ubuntu26_release2.py with -DBUILD_RTI=ON and the Release 2
  target list (--build_targets; a full-tree build is not possible on
  this tree); staging tar also excludes ./build4*.
- jenkins-ci-rme/release-16-10-2026.sh (local dry run): calls
  new_docker_build_release2.sh; derives the pipeline root from the tree
  layout and exports MIGRATE_PIPELINE_ROOT; uses the prebuilt image when
  present, otherwise the driver installs deps in-container (the R1
  --build-prebuilt-image option does not exist in the R2 driver).
- jenkins-ci-rme/jenkins/Jenkinsfile: coverage stage runs the R2 driver
  with MIGRATE_PIPELINE_ROOT exported (wins over the checked-in .envrc,
  which carries a host-specific path).
- Doc/comment updates: Dockerfile header, install_arcgis.sh, publisher,
  Jenkinsfile descriptions, jenkins-ci-rme/README.md, README.md.

Remaining references to the old names are only in historical migration
reports, which are left as-is.

qt6-after/qt6-migrated-legatus/Dockerfile

@@ -1,8 +1,9 @@
-# Prebuilt build image for the release validation-scope branch
+# Prebuilt build image for the Release 2 branch
 # (Ubuntu 26.04 + Qt6 + all dependencies for the legatus release build).
 #
-# Built by new_docker_build.sh --build-prebuilt-image, which passes the
+# Build with (the APT package list mirrors the in-container install list of
-# package list and Qt settings as build args (see build_prebuilt_image()).
+# new_docker_build_release2.sh):
+#   docker build --build-arg APT_PACKAGES="<space-separated packages>" -t <image> .
 
 FROM ubuntu:26.04
 

qt6-after/qt6-migrated-legatus/README.md

@@ -205,7 +205,7 @@ scope again (Release configuration, Ninja, scoped target list) and produces
 | `qt6-release-sources_1.0-1_amd64.deb` | Release 2 scope sources (source files + CMakeLists under the release dirs) |
 | `qt6-release-ctest-runtime_1.0-1_amd64.deb` | Test executables under `/usr/lib/ctest/` (currently empty — the producer looks for a `build4/bin/` dir, which the driver's timestamped `build4_<ts>/` dirs do not match) |
 | `qt6-release-ctest-sources_1.0-1_amd64.deb` | Test sources (files with "test" in the name under release dirs) |
-| `qt6-release-build-pipeline_1.0-1_amd64.deb` | In-tree pipeline files (the producer's `PIPELINE_FILES`: `new_docker_build.sh`, `Dockerfile`, `jenkins-ci-rme/*`, `rpmbuild/make_rpm_ubuntu26.py`, `CMakeLists.txt`) under `/usr/src/pipeline/` |
+| `qt6-release-build-pipeline_1.0-1_amd64.deb` | In-tree pipeline files (the producer's `PIPELINE_FILES`: `new_docker_build_release2.sh`, `Dockerfile`, `jenkins-ci-rme/*`, `rpmbuild/make_rpm_ubuntu26_release2.py`, `CMakeLists.txt`) under `/usr/src/pipeline/` |
 
 (Version string = `--lts-version` + `-` + `--build-number`, default `1.0-1`.)
 

qt6-after/qt6-migrated-legatus/install_arcgis.sh

@@ -67,7 +67,7 @@ if [ -x "${CONFIGURE_SCRIPT}" ]; then
     # The -np flag skips postInstall.sh which integrates with Qt Creator
     # Remove -np if Qt Creator integration is needed.
     #
-    # configure.sh is mounted read-only (new_docker_build.sh mounts external:ro),
+    # configure.sh is mounted read-only (the build driver mounts external:ro),
     # so its `sed -i` on ideintegration/*.pri (Qt Creator IDE patching only) fails
     # with "Read-only file system" and exits 1. That step is NOT used by the CMake
     # build (which consumes ArcGISRuntime.cmake, not the .pri files), and the

qt6-after/qt6-migrated-legatus/jenkins-ci-rme/Jenkinsfile

@@ -8,9 +8,9 @@
 properties([
     disableConcurrentBuilds(),
     parameters([
-        choice(name: 'ProjectName', choices: ['guez'], description: 'LTS project flavor (passed to make_rpm_ubuntu26.py --project_name)'),
+        choice(name: 'ProjectName', choices: ['guez'], description: 'LTS project flavor (passed to make_rpm_ubuntu26_release2.py --project_name)'),
         string(name: 'OsVersions', defaultValue: '26.04', description: 'Comma-separated Ubuntu base versions, built sequentially'),
-        string(name: 'LtsVersion', defaultValue: '1.0', description: 'LTS version (major.minor) passed to make_rpm_ubuntu26.py --version'),
+        string(name: 'LtsVersion', defaultValue: '1.0', description: 'LTS version (major.minor) passed to make_rpm_ubuntu26_release2.py --version'),
         booleanParam(name: 'ClearWorkspace', defaultValue: false, description: 'Clear entire workspace used for build'),
         booleanParam(name: 'PublishArtifactRepo', defaultValue: true, description: 'Upload produced DEBs to the internal artifact repository'),
         booleanParam(name: 'RunCoverage', defaultValue: true, description: 'Build the release scope with -O0 --coverage, run ctest, collect the lcov report and archive it')

qt6-after/qt6-migrated-legatus/jenkins-ci-rme/README.md

@@ -1,4 +1,4 @@
-# jenkins-ci-rme — release pipeline for the Qt6 validation-scope branch
+# jenkins-ci-rme — release pipeline for the Qt6 Release 2 branch
 
 In-tree copy of the Jenkins CI flow, adapted so the release pipeline depends
 only on files inside this source tree:
@@ -7,9 +7,9 @@ only on files inside this source tree:
 |---|---|
 | `Jenkinsfile` | Jenkins entry point (job script path `jenkins-ci-rme/Jenkinsfile`): job properties/parameters, build node, checkout with submodules, then `load`s `jenkins-ci-rme/jenkins/Jenkinsfile` |
 | `jenkins/Jenkinsfile` | Build body (per OS version, sequentially): install the prebuilt image from `legatus-qt6_1.0.tar.gz` when missing, run the builder inside the container, coverage, publish the DEBs to the artifact repo |
-| `jenkins_builder_ubuntu26.sh` | Runs **inside** the build container: stages the workspace, runs the in-tree `rpmbuild/make_rpm_ubuntu26.py`, copies the DEBs to the packages-out mount |
+| `jenkins_builder_ubuntu26.sh` | Runs **inside** the build container: stages the workspace, runs the in-tree `rpmbuild/make_rpm_ubuntu26_release2.py` with the Release 2 target list, copies the DEBs to the packages-out mount |
 | `jenkins_publisher_ubuntu26.sh` | Runs on the Jenkins agent: uploads the DEBs from `${WORKSPACE}/rpms/${PROJECT}/${OS_VERSION}/` to the internal artifact repository |
-| `release-16-10-2026.sh` | Local driver: the same flow without Jenkins, through the in-tree `new_docker_build.sh` |
+| `release-16-10-2026.sh` | Local driver: the same flow without Jenkins, through the in-tree `new_docker_build_release2.sh` |
 
 ## Not included (superseded)
 
@@ -23,27 +23,29 @@ only on files inside this source tree:
 
 ## Adaptations vs. the outer-repo copy
 
-- Packaging uses the **in-tree** `rpmbuild/make_rpm_ubuntu26.py`
+- Packaging uses the **in-tree** `rpmbuild/make_rpm_ubuntu26_release2.py`
   (was `${WORKSPACE}/rpmbuild` from the outer repo)
 - The prebuilt build image `legatus-qt6:1.0` ships in the repo as
   `legatus-qt6_1.0.tar.gz` (repo root); Jenkins `docker load`s it only when
   the image is not installed on the agent yet, and never builds it
-- `MIGRATE_PIPELINE_ROOT` is no longer needed: `new_docker_build.sh`
+- `MIGRATE_PIPELINE_ROOT` is exported by the local dry run (derived from the
-  derives it from its own location
+  tree location); `new_docker_build_release2.sh` falls back to its own
+  location when it is not set
 - DEB output path: `${WORKSPACE}/rpms/${PROJECT}/${OS_VERSION}/` (Jenkins
   convention); the packages-out copy is skipped when that directory is the
-  make_rpm output dir (same device:inode guard as in `new_docker_build.sh`)
+  make_rpm output dir (same device:inode guard as in
+  `new_docker_build_release2.sh`)
 - Publisher uploads `${WORKSPACE}/rpms/${PROJECT}/${OS_VERSION}/` directly —
-  `make_rpm_ubuntu26.py` writes the DEBs there without a TDS subfolder
+  `make_rpm_ubuntu26_release2.py` writes the DEBs there without a TDS subfolder
 - The post-publish Cleanup stage was dropped: the DEBs are kept under
   `${WORKSPACE}/rpms/...` (the documented output location)
 
 ## Local run
 
 ```bash
-cd "DLBO Qt6"
+cd <pipeline root>/qt-migration-legatus/qt6-after/qt6-migrated-legatus
 bash ./jenkins-ci-rme/release-16-10-2026.sh
-# DEBs: <repo-root>/rpms/guez/26.04/
+# DEBs: <pipeline root>/rpms/guez/26.04/
 ```
 
 ## Jenkins setup

qt6-after/qt6-migrated-legatus/jenkins-ci-rme/jenkins/Jenkinsfile

@@ -1,6 +1,6 @@
 // Build body of the release pipeline for the Qt6-migrated legatus
-// validation-scope branch (story/release-validation-scope): TetraIF, Z,
+// Release 2 branch: AP3, AP4, AP9, TetraIF, tests (46 targets) ->
-// Lts/Common (+ Lts/Proxies/TrainingAreaBase) -> 5 release DEB packages.
+// 5 release DEB packages.
 //
 // Loaded by jenkins-ci-rme/Jenkinsfile inside the allocated node after the
 // checkout; job properties/parameters live there.
@@ -8,8 +8,8 @@
 // Workspace layout (checked out by Jenkins, DLBO Qt6 repo):
 //   <WORKSPACE>/
 //     jenkins-ci-rme/Jenkinsfile             (entry point)
-//     new_docker_build.sh            (local build driver)
+//     new_docker_build_release2.sh           (local build driver)
-//     rpmbuild/make_rpm_ubuntu26.py  (in-tree packaging)
+//     rpmbuild/make_rpm_ubuntu26_release2.py (in-tree packaging)
 //     jenkins-ci-rme/                        (this pipeline)
 //
 // The build container image is the prebuilt image shipped in the repo as
@@ -65,7 +65,10 @@ def buildOsVersion = { String osVersion ->
         // The driver (run on the agent, same pattern as the image-build
         // stage) builds the scope with -O0 --coverage, runs ctest and
         // collects the lcov report into the workspace mount.
-        sh "bash ./new_docker_build.sh --docker-image ${imageName} --run-coverage --coverage-output-dir ${WORKSPACE}/coverage/${project}/${osVersion}"
+        // MIGRATE_PIPELINE_ROOT must be exported: it points at the checkout
+        // root (the mounted pipeline root) and wins over the checked-in
+        // .envrc, which carries a host-specific path.
+        sh "export MIGRATE_PIPELINE_ROOT='${WORKSPACE}' && bash ./new_docker_build_release2.sh --use-prebuilt-image --docker-image ${imageName} --run-coverage --coverage-output-dir ${WORKSPACE}/coverage/${project}/${osVersion}"
         archiveArtifacts artifacts: "coverage/${project}/${osVersion}/**", allowEmptyArchive: true
     }
 

qt6-after/qt6-migrated-legatus/jenkins-ci-rme/jenkins_builder_ubuntu26.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 #
 # Build the LTS DEB packages for the Qt6-migrated legatus release
-# (validation scope: TetraIF, Z, Lts/Common + Lts/Proxies/TrainingAreaBase)
+# (Release 2 scope: AP3, AP4, AP9, TetraIF, tests - 46 targets)
 # for Ubuntu 26.04.
 #
 # Runs inside the prebuilt build container (built from the in-tree
@@ -42,6 +42,7 @@ mkdir -p "${STAGE_DIR}"
 tar --exclude='./rpms' --exclude='./.git' --exclude='./build' \
     --exclude='./deb_build_tmp' --exclude='./deb_stage' --exclude='./packages-out' \
     --exclude='./legatus-qt6_1.0.tar.gz' \
+    --exclude='./build4*' \
     -cf - -C "${WORKSPACE}" . | tar -xf - -C "${STAGE_DIR}"
 
 export VERSION_DATE
@@ -49,20 +50,26 @@ VERSION_DATE=$(date +%Y-%m-%d)
 
 # CMake project root inside the staged tree (the DLBO Qt6 repo root)
 SOURCE_DIR="${STAGE_DIR}"
-if [ ! -f "${SOURCE_DIR}/CMakeLists.txt" ] || [ ! -f "${SOURCE_DIR}/rpmbuild/make_rpm_ubuntu26.py" ]; then
+if [ ! -f "${SOURCE_DIR}/CMakeLists.txt" ] || [ ! -f "${SOURCE_DIR}/rpmbuild/make_rpm_ubuntu26_release2.py" ]; then
-    echo "ERROR: staged source incomplete under ${SOURCE_DIR} (CMakeLists.txt or rpmbuild/make_rpm_ubuntu26.py missing)" >&2
+    echo "ERROR: staged source incomplete under ${SOURCE_DIR} (CMakeLists.txt or rpmbuild/make_rpm_ubuntu26_release2.py missing)" >&2
     exit 1
 fi
 
+# Release 2 scope targets - mirrors the GROUP*_TARGETS arrays in
+# new_docker_build_release2.sh (keep in sync). A full-tree build is not
+# possible on the Release 2 tree, so the scoped list must be passed.
+RELEASE2_TARGETS=(ddscore ddsftccore ddsfts ddsgen ddsQoS ddsconnector NGLLogger nglapplication nglcompression nglcoreapplication ngldb nglguiapplication nglsettings nglsingleapplication nglsinglecoreapplication ngltools ngltranslator nglwidgets qtsingleapplication qtsinglecoreapplication wms_json_ds tcpserver LtsCoordinate LtsCoordTrans LtsSession LtsMultiMonitor DataPluginInterface GuiPluginInterface CoPrtCnv LogViewLogger LogView PrtCnvLib PrtCnv LtsLicence MockCoordTrans aes_crypt_test ngltools_qt_smoke lts_coord_trans_unit_test test_nglpdfwidget coprtcnv_unit_test logview_unit_test prtcnv_unit_test ddsview LogViewer sqlbrowser ngl_codegen)
+
 # Output is isolated per OS version so parallel OS builds of the same
 # project never collide
 cd "${SOURCE_DIR}/rpmbuild"
-python3 make_rpm_ubuntu26.py -c LTS \
+python3 make_rpm_ubuntu26_release2.py -c LTS \
     --project_name "${PROJECT}" \
     --version "${LTS_VERSION}" \
     --output_dir "${WORKSPACE}/rpms/${PROJECT}/${OS_VERSION}/" \
     --source_dir "${SOURCE_DIR}" \
-    --cmake_build_flags "-DUSE_IPO=ON -DUSE_UNITY_BUILD=ON -DGUEZ_MODE=${GUEZ_MODE} -DBUILD_WLS=ON -DPostgreSQL_TYPE_INCLUDE_DIR=/usr/include/postgresql/ -DRELEASE_BUILD=ON" \
+    --cmake_build_flags "-DUSE_IPO=ON -DUSE_UNITY_BUILD=ON -DGUEZ_MODE=${GUEZ_MODE} -DBUILD_WLS=ON -DPostgreSQL_TYPE_INCLUDE_DIR=/usr/include/postgresql/ -DBUILD_RTI=ON -DRELEASE_BUILD=ON" \
+    --build_targets "${RELEASE2_TARGETS[*]}" \
     --build_number "${BUILD_NUMBER:-1}" \
     --release_scope
 

qt6-after/qt6-migrated-legatus/jenkins-ci-rme/jenkins_publisher_ubuntu26.sh

@@ -6,7 +6,7 @@
 #   ${WORKSPACE}/url-${PROJECT}-${OS_VERSION}.txt        — browseable URL of the uploaded folder
 #   ${WORKSPACE}/tdsversion-${PROJECT}-${OS_VERSION}.txt — full version string (LTS-build)
 #
-# Adapted for the in-tree flow: make_rpm_ubuntu26.py writes the DEBs
+# Adapted for the in-tree flow: make_rpm_ubuntu26_release2.py writes the DEBs
 # directly under ${WORKSPACE}/rpms/${PROJECT}/${OS_VERSION}/ (no TDS
 # subfolder), so that directory is uploaded as-is.
 #

qt6-after/qt6-migrated-legatus/jenkins-ci-rme/release-16-10-2026.sh

@@ -1,27 +1,30 @@
 #!/usr/bin/env bash
 #
-# Local release pipeline for the Qt6-migrated legatus validation scope
+# Local release pipeline for the Qt6-migrated legatus Release 2 scope
-# (TetraIF, Z, Lts/Common + Lts/Proxies/TrainingAreaBase).
+# (AP3, AP4, AP9, TetraIF, tests - 46 targets).
 #
-# Runs the in-tree new_docker_build.sh:
+# Runs the in-tree new_docker_build_release2.sh:
-#   - builds the prebuilt Docker image from the in-tree Dockerfile when the
+#   - uses the prebuilt Docker image when present; otherwise the driver
-#     image is not present yet
+#     installs the dependencies in-container from the base image (slower)
 #   - builds the release scope, runs ctest and produces the release DEB
 #     packages with the in-tree rpmbuild script
 #   - collects the lcov code-coverage report (--run-coverage; set
 #     DRYRUN_COVERAGE=OFF to skip)
 #
-# The DEB packages land in ${WORKSPACE}/rpms/${PROJECT}/${OS_VERSION}/
+# The DEB packages land in ${MIGRATE_PIPELINE_ROOT}/rpms/${PROJECT}/${OS_VERSION}/
-# (Jenkins-style layout; locally WORKSPACE is the pipeline root).
+# (Jenkins-style layout; locally the pipeline root is the directory that
+# contains qt-migration-legatus/).
 #
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 LEGATUS_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
-PIPELINE_ROOT="${LEGATUS_ROOT}"
+# Tree layout: <pipeline root>/qt-migration-legatus/qt6-after/qt6-migrated-legatus
+PIPELINE_ROOT="$(cd "${LEGATUS_ROOT}/../../.." && pwd)"
 
 # Release build configuration (Jenkins-style variables)
 export WORKSPACE="${PIPELINE_ROOT}"
+export MIGRATE_PIPELINE_ROOT="${MIGRATE_PIPELINE_ROOT:-${PIPELINE_ROOT}}"
 export PROJECT="${PROJECT:-guez}"
 export OS_VERSION="${OS_VERSION:-26.04}"
 export LTS_VERSION="${LTS_VERSION:-1.0}"
@@ -45,15 +48,19 @@ log_info "Package output: ${WORKSPACE}/rpms/${PROJECT}/${OS_VERSION}/"
 
 cd "${LEGATUS_ROOT}"
 
-# Build the prebuilt image from the in-tree Dockerfile when not present yet
+# Use the prebuilt image when present; otherwise let the driver install the
-# (--build-prebuilt-image builds the image and exits)
+# dependencies in-container from the base image (slower, no image build).
-if ! docker image inspect "${DOCKER_IMAGE}" >/dev/null 2>&1; then
+PREBUILT_FLAG=()
-  log_info "Prebuilt image not found - building it from the in-tree Dockerfile..."
+if docker image inspect "${DOCKER_IMAGE}" >/dev/null 2>&1; then
-  bash ./new_docker_build.sh --build-prebuilt-image --docker-image "${DOCKER_IMAGE}"
+  PREBUILT_FLAG=(--use-prebuilt-image)
+  log_info "Using prebuilt image ${DOCKER_IMAGE}"
+else
+  log_info "Prebuilt image ${DOCKER_IMAGE} not found - the driver will install dependencies in-container"
 fi
 
 # Release scope build + ctest + DEB production (in-tree rpmbuild)
-bash ./new_docker_build.sh \
+bash ./new_docker_build_release2.sh \
+  "${PREBUILT_FLAG[@]}" \
   --docker-image "${DOCKER_IMAGE}" \
   --run-jenkins-builder \
   --package-output-dir "${WORKSPACE}/rpms/${PROJECT}/${OS_VERSION}/" \
@@ -66,7 +73,8 @@ bash ./new_docker_build.sh \
 # DRYRUN_COVERAGE=OFF for a fast local DEB-only run.
 DRYRUN_COVERAGE="${DRYRUN_COVERAGE:-ON}"
 if [[ "${DRYRUN_COVERAGE}" == "ON" ]]; then
-  bash ./new_docker_build.sh \
+  bash ./new_docker_build_release2.sh \
+    "${PREBUILT_FLAG[@]}" \
     --docker-image "${DOCKER_IMAGE}" \
     --run-coverage \
     --coverage-output-dir "${WORKSPACE}/coverage/${PROJECT}/${OS_VERSION}"

qt6-after/qt6-migrated-legatus/new_docker_build_release2.sh

@@ -9,7 +9,8 @@ set -euo pipefail
 # - AP4: DDS middleware (Core, DDSConnector, Routing, QosProfile, RTI layer)
 # - AP9: Tools and translations (DdsView, LogViewer, SqlBrowser, generators, lupdate)
 #
-# This script is derived from new_docker_build.sh but focused on Release 2 targets only.
+# This is the Release 2 scope driver (the full-tree driver of the earlier
+# validation scope has been removed from this branch).
 # -----------------------------------------------------------------------------
 
 usage() {
@@ -35,7 +36,7 @@ Prebuilt Docker image usage:
 
 Package production options (DEB):
   --run-jenkins-builder    Build the release DEB packages inside the container
-                           using the in-tree rpmbuild/make_rpm_ubuntu26.py
+                           using the in-tree rpmbuild/make_rpm_ubuntu26_release2.py
   --package-output-dir DIR Directory to mount for package output (default: ./packages-out)
   --lts-version VERSION    LTS version for package (default: 1.0)
   --project NAME           Project name for package (default: guez)

qt6-after/qt6-migrated-legatus/rpmbuild/make_rpm_ubuntu26.py

@@ -1,527 +0,0 @@
-#!/usr/bin/python3
-# -*- coding: utf-8 -*-
-"""
-DEB package builder for Ubuntu 26.04 - Qt6 Release
-Creates 5 separate DEB packages as per customer requirements:
-1. qt6-release-runtime - binaries and libraries from S
-2. qt6-release-sources - Qt6 C++ sources from S
-3. qt6-release-ctest-runtime - CTest executables
-4. qt6-release-ctest-sources - CTest source files
-5. qt6-release-build-pipeline - Dockerfiles, build scripts, CI/CD files
-"""
-
-import argparse
-import fnmatch
-import os
-import shutil
-import subprocess
-import sys
-from email.utils import formatdate
-
-SKIP_DIRS = {'build', 'cmake-build-debug', 'cmake-build-release', 'deb_build_tmp'}
-SOURCE_EXTENSIONS = ('.cpp', '.h', '.hpp', '.cc', '.cxx', '.hxx')
-PIPELINE_FILES = [
-    "new_docker_build.sh",
-    "Dockerfile",
-    "jenkins-ci-rme/Jenkinsfile",
-    "jenkins-ci-rme/jenkins/Jenkinsfile",
-    "jenkins-ci-rme/jenkins_builder_ubuntu26.sh",
-    "jenkins-ci-rme/jenkins_publisher_ubuntu26.sh",
-    "jenkins-ci-rme/release-16-10-2026.sh",
-    "rpmbuild/make_rpm_ubuntu26.py",
-    "CMakeLists.txt",
-]
-
-
-def verbose():
-    verb = os.getenv("EMERGE_VERBOSE")
-    if verb is not None and verb.isdigit() and int(verb) > 0:
-        return int(verb)
-    return 0
-
-
-def debug(message):
-    if verbose() >= 1:
-        print(f"debug: {message}")
-    return True
-
-
-def info(message):
-    print(f"info: {message}")
-    return True
-
-
-def warning(message):
-    print(f"warning: {message}")
-    return True
-
-
-def error(message):
-    die(message)
-
-
-def die(message):
-    print(f"emerge fatal error: {message}", file=sys.stderr)
-    sys.exit(1)
-
-
-def run(cmd, label, env=None):
-    """Run a shell command, print its output and die on failure."""
-    debug(f"Executing: {cmd}")
-    ret = subprocess.run(cmd, shell=True, env=env, capture_output=True, text=True)
-    if ret.returncode != 0:
-        print(ret.stdout)
-        print(ret.stderr)
-        die(f"{label} with code {ret.returncode}")
-
-
-def remove_directory(path):
-    if os.path.exists(path):
-        shutil.rmtree(path)
-
-
-def is_dds_file(filepath):
-    """True if the path is DDS-related and must be excluded."""
-    return 'dds' in filepath.lower()
-
-
-def prune_dirs(dirs, root, file_filter):
-    """Prune hidden/build dirs in-place (and dirs matching file_filter)."""
-    dirs[:] = [d for d in dirs
-               if not d.startswith('.')
-               and d not in SKIP_DIRS
-               and (file_filter is None or not file_filter(os.path.join(root, d)))]
-
-
-def copy_src_dir_to_dest_dir(src_dir, dest_dir, file_filter=None):
-    """Copy the source tree, skipping hidden/build dirs and filtered files."""
-    os.makedirs(dest_dir, exist_ok=True)
-    for root, dirs, files in os.walk(src_dir):
-        prune_dirs(dirs, root, file_filter)
-        for file in files:
-            src_file = os.path.join(root, file)
-            if file_filter and file_filter(src_file):
-                continue
-            dest_file = os.path.join(dest_dir, os.path.relpath(src_file, src_dir))
-            os.makedirs(os.path.dirname(dest_file), exist_ok=True)
-            shutil.copy2(src_file, dest_file)
-
-
-def find_test_module_source(pkg_dir, test_name, release_dirs):
-    """Module dir (relative to pkg_dir) whose CMakeLists defines test_name, or None."""
-    for rel_dir in release_dirs:
-        module_dir = os.path.join(pkg_dir, rel_dir)
-        if not os.path.exists(module_dir):
-            continue
-        for root, dirs, files in os.walk(module_dir):
-            prune_dirs(dirs, root, None)
-            if 'CMakeLists.txt' not in files:
-                continue
-            try:
-                with open(os.path.join(root, 'CMakeLists.txt')) as f:
-                    content = f.read()
-            except Exception:
-                continue
-            if f'ADD_EXECUTABLE({test_name}' in content or f'ADD_TEST(NAME {test_name}' in content:
-                return os.path.relpath(root, pkg_dir)
-    return None
-
-
-def find_test_executables(pkg_dir, release_dirs):
-    """(executable, module) pairs for the test executables in build4/bin/."""
-    test_executables = []
-    build_bin_dir = os.path.join(pkg_dir, "build4", "bin")
-    if not os.path.exists(build_bin_dir):
-        warning(f"Build bin directory not found: {build_bin_dir}")
-        return test_executables
-    for filename in os.listdir(build_bin_dir):
-        file_path = os.path.join(build_bin_dir, filename)
-        if not (os.path.isfile(file_path) and os.access(file_path, os.X_OK)):
-            continue
-        if 'test' not in filename.lower():
-            continue
-        module_path = find_test_module_source(pkg_dir, filename, release_dirs)
-        if module_path:
-            test_executables.append((file_path, module_path))
-            debug(f"  Found test executable: {filename} from {module_path}")
-        else:
-            debug(f"  Skipping test executable (no module found): {filename}")
-    return test_executables
-
-
-def find_test_sources(pkg_dir, release_dirs):
-    """Relative paths of test source files (name containing 'test', .cpp/.h)."""
-    test_sources = []
-    for rel_dir in release_dirs:
-        module_dir = os.path.join(pkg_dir, rel_dir)
-        if not os.path.exists(module_dir):
-            continue
-        for root, dirs, files in os.walk(module_dir):
-            prune_dirs(dirs, root, None)
-            for filename in files:
-                if 'test' in filename.lower() and filename.endswith(('.cpp', '.h')):
-                    file_path = os.path.join(root, filename)
-                    rel_path = os.path.relpath(file_path, pkg_dir)
-                    test_sources.append(rel_path)
-                    debug(f"  Found test source: {rel_path}")
-    return test_sources
-
-
-def write_deb_file(deb_dir, name, content, executable=False):
-    """Write a debian/* file and log its creation."""
-    path = os.path.join(deb_dir, name)
-    with open(path, "w") as f:
-        f.write(content)
-    if executable:
-        os.chmod(path, 0o755)
-    info(f"Created {path}")
-
-
-def create_debian_control(deb_dir, package_name, version, build_number, description,
-                          depends="", section="devel"):
-    write_deb_file(deb_dir, "control", f"""Source: {package_name}
-Section: {section}
-Priority: optional
-Maintainer: Legatus Team <team@legatus.example.com>
-Build-Depends: debhelper (>= 13), cmake, qt6-base-dev, qt6-tools-dev
-Standards-Version: 4.6.0
-
-Package: {package_name}
-Architecture: any
-Depends: ${{shlibs:Depends}}, ${{misc:Depends}}{", " + depends if depends else ""}
-Description: {description}
- Legatus Qt6 Release Package
- This package is part of the Legatus Qt6 migration release.
-""")
-
-
-def create_debian_changelog(deb_dir, package_name, version, build_number):
-    write_deb_file(deb_dir, "changelog", f"""{package_name} ({version}-{build_number}) unstable; urgency=medium
-
-  * Qt6 Release Build
-
- -- Legatus Team <team@legatus.example.com>  {formatdate(localtime=True)}
-""")
-
-
-def create_debian_rules(deb_dir, cmake_flags="", skip_tests=False):
-    test_override = """
-override_dh_auto_test:
-	# Tests skipped for this package type
-""" if skip_tests else ""
-    write_deb_file(deb_dir, "rules", f"""#!/usr/bin/make -f
-%:
-	dh $@ --buildsystem=cmake
-
-override_dh_auto_configure:
-	dh_auto_configure -- -DCMAKE_BUILD_TYPE=Release {cmake_flags}
-
-override_dh_auto_build:
-	dh_auto_build --parallel
-
-override_dh_auto_install:
-	dh_auto_install --destdir=debian/tmp
-{test_override}""", executable=True)
-
-
-def create_debian_rules_nobuild(deb_dir, skip_shlibdeps=False):
-    content = """#!/usr/bin/make -f
-%:
-	dh $@
-
-override_dh_auto_build:
-	# No build step needed - pre-built files only
-
-override_dh_auto_configure:
-	# No configure step needed - pre-built files only
-
-override_dh_auto_install:
-	dh_auto_install
-"""
-    if skip_shlibdeps:
-        content += """
-override_dh_shlibdeps:
-	# Skip shlibdeps for test executables - Qt6 deps are external system packages
-"""
-    write_deb_file(deb_dir, "rules", content, executable=True)
-
-
-def create_debian_install(deb_dir, install_lines):
-    install_file = os.path.join(deb_dir, "install")
-    with open(install_file, "w") as f:
-        for line in install_lines:
-            f.write(line + "\n")
-    info(f"Created {install_file} with {len(install_lines)} entries")
-
-
-def create_manifest(output_dir, package_name, pkg_dir):
-    """Write the manifest of package contents (from the DEB, or the pkg dir)."""
-    manifest_file = os.path.join(output_dir, "manifests", f"{package_name}.manifest")
-    os.makedirs(os.path.dirname(manifest_file), exist_ok=True)
-    deb_file = next((os.path.join(output_dir, f) for f in os.listdir(output_dir)
-                     if f.startswith(package_name) and f.endswith(".deb")), None)
-    manifest_lines = []
-    if deb_file and os.path.exists(deb_file):
-        result = subprocess.run(["dpkg-deb", "--contents", deb_file],
-                                capture_output=True, text=True)
-        if result.returncode == 0:
-            # dpkg-deb --contents: "-rw-r--r-- root/root 1234 2024-01-01 00:00 ./path"
-            for line in result.stdout.strip().split("\n"):
-                parts = line.split()
-                if len(parts) >= 6:
-                    file_path = parts[-1]
-                    if file_path.startswith("./"):
-                        file_path = file_path[2:]
-                    elif file_path.startswith("/"):
-                        file_path = file_path[1:]
-                    if file_path:
-                        manifest_lines.append(file_path)
-    elif os.path.exists(pkg_dir):
-        info(f"Warning: DEB file not found for {package_name}, scanning directory instead")
-        for root, dirs, files in os.walk(pkg_dir):
-            for file in files:
-                manifest_lines.append(os.path.relpath(os.path.join(root, file), pkg_dir))
-    manifest_lines.sort()
-    with open(manifest_file, "w") as f:
-        for line in manifest_lines:
-            f.write(line + "\n")
-    info(f"Created manifest: {manifest_file} ({len(manifest_lines)} entries)")
-    return manifest_lines
-
-
-def validate_package_contents(package_name, manifest_lines, allowed_patterns, forbidden_patterns=None):
-    """Validate package contents against the allowlist/forbidden list."""
-    errors = []
-    warnings = []
-    for file_path in manifest_lines:
-        if file_path.endswith('/'):
-            continue
-        if forbidden_patterns:
-            for pattern in forbidden_patterns:
-                if fnmatch.fnmatch(file_path, pattern):
-                    errors.append(f"FORBIDDEN file in {package_name}: {file_path} (matches {pattern})")
-        allowed = bool(allowed_patterns) and any(fnmatch.fnmatch(file_path, p) for p in allowed_patterns)
-        if not allowed and allowed_patterns:
-            warnings.append(f"Unexpected file in {package_name}: {file_path}")
-    for err in errors:
-        error(f"Validation error: {err}")
-    if errors:
-        return False
-    for warn in warnings:
-        warning(f"Validation warning: {warn}")
-    return True
-
-
-def build_deb(pkg_name, pkg_dir, output_dir, version, build_number,
-              cmake_flags="", nobuild=False, skip_tests=False, skip_shlibdeps=False,
-              install_lines=None, description="", section="devel", depends=""):
-    """Build one DEB package (with or without a cmake build) and move its artifacts."""
-    info(f"Building DEB package {'(no-build): ' if nobuild else ''}{pkg_name}")
-    deb_dir = os.path.join(pkg_dir, "debian")
-    os.makedirs(deb_dir)
-    create_debian_control(deb_dir, pkg_name, version, build_number, description, depends, section)
-    create_debian_changelog(deb_dir, pkg_name, version, build_number)
-    if nobuild:
-        create_debian_rules_nobuild(deb_dir, skip_shlibdeps=skip_shlibdeps)
-    else:
-        create_debian_rules(deb_dir, cmake_flags, skip_tests)
-    os.makedirs(os.path.join(deb_dir, "source"))
-    with open(os.path.join(deb_dir, "source", "format"), "w") as f:
-        f.write("3.0 (quilt)\n")
-    with open(os.path.join(deb_dir, "compat"), "w") as f:
-        f.write("13\n")
-    if install_lines:
-        create_debian_install(deb_dir, install_lines)
-
-    info(f"Running debuild for {pkg_name}...")
-    os.chdir(pkg_dir)
-    env = os.environ.copy()
-    env["DEB_BUILD_OPTIONS"] = "parallel=$(nproc)"
-    run("debuild -us -uc -b", f"debuild failed for {pkg_name}", env=env)
-
-    parent_dir = os.path.dirname(pkg_dir)
-    for f in os.listdir(parent_dir):
-        if f.endswith((".deb", ".dsc", ".changes", ".buildinfo")):
-            src = os.path.join(parent_dir, f)
-            dst = os.path.join(output_dir, f)
-            if os.path.exists(dst):
-                os.remove(dst)
-            shutil.move(src, output_dir)
-            info(f"Moved {f} to {output_dir}")
-    return True
-
-
-def source_install_lines(pkg_dir, release_dirs):
-    lines = []
-    for rel_dir in release_dirs:
-        src_dir = os.path.join(pkg_dir, rel_dir)
-        if not os.path.exists(src_dir):
-            continue
-        for root, dirs, files in os.walk(src_dir):
-            dirs[:] = [d for d in dirs if not d.startswith('.')]
-            for file in files:
-                if os.path.splitext(file)[1].lower() in SOURCE_EXTENSIONS or file == "CMakeLists.txt":
-                    rel_path = os.path.relpath(os.path.join(root, file), pkg_dir)
-                    lines.append(f"{rel_path} {os.path.join('usr/src', os.path.dirname(rel_path))}/")
-    return lines
-
-
-def ctest_runtime_install_lines(pkg_dir, release_dirs):
-    lines = []
-    for exe_path, module_path in find_test_executables(pkg_dir, release_dirs):
-        lines.append(f"{os.path.relpath(exe_path, pkg_dir)} usr/lib/ctest/")
-        info(f"  Including test executable: {os.path.basename(exe_path)} from {module_path}")
-    for ctest_file in ("build4/CTestTestfile.cmake", "build4/DartConfiguration.tcl", "build4/Testing/TAG"):
-        if os.path.exists(os.path.join(pkg_dir, ctest_file)):
-            lines.append(f"{ctest_file} usr/lib/ctest/")
-    return lines
-
-
-def test_sources_install_lines(pkg_dir, release_dirs):
-    return [f"{rel_path} {os.path.dirname(rel_path)}/" for rel_path in find_test_sources(pkg_dir, release_dirs)]
-
-
-def pipeline_install_lines(pkg_dir):
-    lines = []
-    for pipeline_file in PIPELINE_FILES:
-        if os.path.exists(os.path.join(pkg_dir, pipeline_file)):
-            lines.append(f"{pipeline_file} {os.path.join('usr/src/pipeline', os.path.dirname(pipeline_file))}/")
-            info(f"  Added pipeline file: {pipeline_file}")
-    return lines
-
-
-def build_nobuild_package(name, source_dir, build_base, output_dir, version, build_number,
-                          description, prepare, allowed_patterns, forbidden_patterns,
-                          file_filter=None, skip_shlibdeps=False, section="devel"):
-    """Stage the source tree, build a no-build DEB and validate its contents."""
-    info(f"\n=== Building {name} ===")
-    pkg_dir = os.path.join(build_base, f"{name}-{version}")
-    os.makedirs(pkg_dir)
-    copy_src_dir_to_dest_dir(source_dir, pkg_dir, file_filter=file_filter)
-    build_deb(pkg_name=name, pkg_dir=pkg_dir, output_dir=output_dir,
-              version=version, build_number=build_number, nobuild=True,
-              skip_shlibdeps=skip_shlibdeps, install_lines=prepare(pkg_dir),
-              description=description, section=section)
-    manifest = create_manifest(output_dir, name, pkg_dir)
-    validate_package_contents(name, manifest, allowed_patterns, forbidden_patterns)
-
-
-def build_all_debs(source_dir, output_dir, version, build_number, cmake_flags):
-    """Build the 5 DEB packages: build once from the source tree, then package."""
-    info("========================================")
-    info("Building 5 DEB packages for Qt6 Release")
-    info("========================================")
-    os.makedirs(output_dir, exist_ok=True)
-    os.makedirs(os.path.join(output_dir, "manifests"), exist_ok=True)
-    build_base = os.path.join(source_dir, "deb_build_tmp")
-    remove_directory(build_base)
-    os.makedirs(build_base)
-    release_dirs = ["TetraIF", "Z/src", "Lts/Common"]
-
-    # Step 1: build once from the full source tree
-    info("\n=== Step 1: Building from full source tree ===")
-    build_dir = os.path.join(source_dir, "build")
-    os.makedirs(build_dir, exist_ok=True)
-    os.chdir(build_dir)
-    info("Running CMake configuration...")
-    run(f"cmake -DCMAKE_BUILD_TYPE=Release {cmake_flags} ..", "CMake configuration failed")
-    info("Running build...")
-    run(f"make -j$(nproc)", "Build failed")
-    info("Build completed successfully")
-
-    # Package 1: qt6-release-runtime (binaries and libraries, built via debuild)
-    info("\n=== Building qt6-release-runtime ===")
-    pkg1_dir = os.path.join(build_base, f"qt6-release-runtime-{version}")
-    os.makedirs(pkg1_dir)
-    # FULL source tree (needed for debian/rules cmake reference)
-    copy_src_dir_to_dest_dir(source_dir, pkg1_dir)
-    # Install from all component install paths: ALL -> bin/, lib/ ; SV/ ; WS/
-    install_lines_1 = [
-        "usr/bin/* usr/bin/",
-        "usr/lib/*.so* usr/lib/",
-        "usr/SV/bin/* usr/bin/",
-        "usr/SV/lib/*.so* usr/lib/",
-        "usr/WS/bin/* usr/bin/",
-        "usr/WS/lib/*.so* usr/lib/",
-    ]
-    build_deb(pkg_name="qt6-release-runtime", pkg_dir=pkg1_dir, output_dir=output_dir,
-              version=version, build_number=build_number, cmake_flags=cmake_flags,
-              skip_tests=True, install_lines=install_lines_1,
-              description="Qt6 Release Runtime - binaries and libraries from release scope S",
-              section="libs")
-    manifest_1 = create_manifest(output_dir, "qt6-release-runtime", pkg1_dir)
-    validate_package_contents("qt6-release-runtime", manifest_1,
-        allowed_patterns=["usr/bin/*", "usr/lib/*", "usr/SV/*", "usr/WS/*", "usr/share/doc/*", "debian/*"],
-        forbidden_patterns=["*.cpp", "*.h", "*.hpp", "tests/*", "jenkins/*", "Dockerfile*"])
-
-    # Package 2: qt6-release-sources (release-scope sources, DDS excluded)
-    build_nobuild_package(
-        "qt6-release-sources", source_dir, build_base, output_dir, version, build_number,
-        description="Qt6 Release Sources - C++ source files from release scope S",
-        prepare=lambda pkg_dir: source_install_lines(pkg_dir, release_dirs),
-        allowed_patterns=["usr/src/*", "usr/share/doc/*", "debian/*"],
-        forbidden_patterns=["build/*", "tests/*", "jenkins/*"],
-        file_filter=is_dds_file)
-
-    # Package 3: qt6-release-ctest-runtime (test executables from release scope)
-    build_nobuild_package(
-        "qt6-release-ctest-runtime", source_dir, build_base, output_dir, version, build_number,
-        description="Qt6 Release CTest Runtime - executable test programs from release scope",
-        prepare=lambda pkg_dir: ctest_runtime_install_lines(pkg_dir, release_dirs),
-        allowed_patterns=["usr/lib/ctest/*", "usr/share/doc/*", "debian/*"],
-        forbidden_patterns=["*.cpp", "*.h", "jenkins/*"],
-        skip_shlibdeps=True)
-
-    # Package 4: qt6-release-ctest-sources (test source files from release scope)
-    build_nobuild_package(
-        "qt6-release-ctest-sources", source_dir, build_base, output_dir, version, build_number,
-        description="Qt6 Release CTest Sources - test source files from release scope",
-        prepare=lambda pkg_dir: test_sources_install_lines(pkg_dir, release_dirs),
-        allowed_patterns=["Lts/*", "TetraIF/*", "Z/*", "usr/share/doc/*", "debian/*"],
-        forbidden_patterns=["build/*", "jenkins/*"])
-
-    # Package 5: qt6-release-build-pipeline (Docker, Jenkins, CMake, packaging scripts)
-    build_nobuild_package(
-        "qt6-release-build-pipeline", source_dir, build_base, output_dir, version, build_number,
-        description="Qt6 Release Build Pipeline - Docker, Jenkins, CMake, and packaging scripts",
-        prepare=pipeline_install_lines,
-        allowed_patterns=["usr/src/pipeline/*", "usr/share/doc/*", "debian/*"],
-        forbidden_patterns=["*.cpp", "*.h", "tests/*"])
-
-    # Cleanup
-    os.chdir(source_dir)
-    remove_directory(build_base)
-
-    info("\n========================================")
-    info(f"DEB package build completed: {output_dir}")
-    info("Generated packages:")
-    for f in os.listdir(output_dir):
-        if f.endswith(".deb"):
-            info(f"  - {f}")
-    info("========================================")
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Build DEB packages for Legatus Qt6 Release")
-    parser.add_argument("-c", "--config", required=True, help="Config type (LTS)")
-    parser.add_argument("--project_name", required=True, help="Project name (qatar|ahtc|guez)")
-    parser.add_argument("--version", required=True, help="Version (Major.minor)")
-    parser.add_argument("--output_dir", required=True, help="Output directory for packages")
-    parser.add_argument("--source_dir", required=True, help="Source directory path")
-    parser.add_argument("--cmake_build_flags", default="", help="CMake build flags")
-    parser.add_argument("--build_number", default="1", help="Build number")
-    parser.add_argument("--release_scope", action="store_true", help="Only include release scope files")
-
-    args = parser.parse_args()
-    info(f"Building {args.config} package for {args.project_name} v{args.version}")
-    info(f"Output directory: {args.output_dir}")
-    info(f"Source directory: {args.source_dir}")
-    info(f"CMake flags: {args.cmake_build_flags}")
-    info(f"Release scope: {args.release_scope}")
-    build_all_debs(source_dir=args.source_dir, output_dir=args.output_dir,
-                   version=args.version, build_number=args.build_number,
-                   cmake_flags=args.cmake_build_flags)
-
-
-if __name__ == "__main__":
-    main()

qt6-after/qt6-migrated-legatus/rpmbuild/make_rpm_ubuntu26_release2.py

@@ -21,14 +21,14 @@ from email.utils import formatdate
 SKIP_DIRS = {'build', 'cmake-build-debug', 'cmake-build-release', 'deb_build_tmp'}
 SOURCE_EXTENSIONS = ('.cpp', '.h', '.hpp', '.cc', '.cxx', '.hxx')
 PIPELINE_FILES = [
-    "new_docker_build.sh",
+    "new_docker_build_release2.sh",
     "Dockerfile",
     "jenkins-ci-rme/Jenkinsfile",
     "jenkins-ci-rme/jenkins/Jenkinsfile",
     "jenkins-ci-rme/jenkins_builder_ubuntu26.sh",
     "jenkins-ci-rme/jenkins_publisher_ubuntu26.sh",
     "jenkins-ci-rme/release-16-10-2026.sh",
-    "rpmbuild/make_rpm_ubuntu26.py",
+    "rpmbuild/make_rpm_ubuntu26_release2.py",
     "CMakeLists.txt",
 ]