Establishing and validating Jenkins based CI for the repository

VidyaChhabria · VidyaChhabria · commit f869d9987314 · 2025-10-26T18:11:45.000-07:00
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
@@ -0,0 +1,84 @@
+name: Jenkins CI Regression
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  trigger-jenkins:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Trigger Jenkins Job
+        id: trigger
+        run: |
+          echo "🚀 Triggering Jenkins job..."
+          # Send trigger and extract the queue URL from the Location header
+          QUEUE_URL=$(curl -s -X POST -D - \
+            -u "${{ secrets.JENKINS_USER }}:${{ secrets.JENKINS_TOKEN }}" \
+            "${{ secrets.JENKINS_URL }}/job/${{ secrets.JENKINS_JOB }}/build?token=${{ secrets.JENKINS_TRIGGER }}" \
+            | grep -i Location | awk '{print $2}' | tr -d '\r\n')
+          
+          echo "Queue URL: $QUEUE_URL"
+          echo "queue_url=${QUEUE_URL}" >> $GITHUB_OUTPUT
+
+      - name: Wait for Jenkins to Start (Get Build Number)
+        id: wait_for_start
+        run: |
+          echo "⏳ Waiting for Jenkins to assign build number..."
+          ATTEMPTS=0
+          BUILD_NUMBER=""
+          QUEUE_URL="${{ steps.trigger.outputs.queue_url }}api/json"
+
+          until [ -n "$BUILD_NUMBER" ] && [ "$BUILD_NUMBER" != "null" ]; do
+            sleep 10
+            ATTEMPTS=$((ATTEMPTS + 1))
+            BUILD_NUMBER=$(curl -s -u "${{ secrets.JENKINS_USER }}:${{ secrets.JENKINS_TOKEN }}" "$QUEUE_URL" | jq -r '.executable.number')
+            echo "[$ATTEMPTS] Build number: $BUILD_NUMBER"
+            if [ $ATTEMPTS -gt 30 ]; then
+              echo "❌ Timed out waiting for Jenkins to start."
+              exit 1
+            fi
+          done
+
+          BUILD_URL="${{ secrets.JENKINS_URL }}/job/${{ secrets.JENKINS_JOB }}/${BUILD_NUMBER}/"
+          echo "✅ Jenkins build started: #$BUILD_NUMBER"
+          echo "🔗 Jenkins console: ${BUILD_URL}console"
+          echo "build_number=$BUILD_NUMBER" >> $GITHUB_OUTPUT
+          echo "build_url=$BUILD_URL" >> $GITHUB_OUTPUT
+
+      - name: Wait for Jenkins Build to Finish
+        id: wait_for_finish
+        run: |
+          echo "⏳ Polling Jenkins for build completion..."
+          ATTEMPTS=0
+          BUILD_STATUS="PENDING"
+          BUILD_NUMBER="${{ steps.wait_for_start.outputs.build_number }}"
+          BUILD_URL="${{ steps.wait_for_start.outputs.build_url }}"
+
+          until [ "$BUILD_STATUS" = "SUCCESS" ] || [ "$BUILD_STATUS" = "FAILURE" ]; do
+            sleep 30
+            ATTEMPTS=$((ATTEMPTS + 1))
+            BUILD_STATUS=$(curl -s -u "${{ secrets.JENKINS_USER }}:${{ secrets.JENKINS_TOKEN }}" \
+              "${BUILD_URL}api/json" | jq -r '.result')
+            echo "[$ATTEMPTS] Jenkins build status: $BUILD_STATUS"
+            if [ $ATTEMPTS -gt 60 ]; then
+              echo "❌ Timed out after 30 minutes waiting for Jenkins build #$BUILD_NUMBER"
+              exit 1
+            fi
+          done
+
+          echo "🏁 Final Jenkins status for build #$BUILD_NUMBER: $BUILD_STATUS"
+          echo "status=$BUILD_STATUS" >> $GITHUB_OUTPUT
+
+      - name: Mark Failed if Jenkins Failed
+        if: steps.wait_for_finish.outputs.status == 'FAILURE'
+        run: |
+          echo "❌ Jenkins build failed."
+          exit 1
+
+      - name: Jenkins Build Successful
+        if: steps.wait_for_finish.outputs.status == 'SUCCESS'
+        run: |
+          echo "✅ Jenkins Regression Passed Successfully"
+          echo "🔗 Build link: ${{ steps.wait_for_start.outputs.build_url }}"
diff --git a/.gitignore b/.gitignore
@@ -1 +1,2 @@
 run/*
+rdf.test/*
diff --git a/.gitmodules b/.gitmodules
@@ -3,4 +3,4 @@
 	url = https://github.com/The-OpenROAD-Project/OpenROAD-flow-scripts.git
 [submodule "tools/global_place/DG-RePlAce-AutoDMP"]
 	path = tools/global_place/DG-RePlAce-AutoDMP
-	url = git@github.com:ABKGroup/DG-RePlAce-AutoDMP.git
+	url = https://github.com/ABKGroup/DG-RePlAce-AutoDMP.git
diff --git a/Jenkinsfile b/Jenkinsfile
@@ -0,0 +1,42 @@
+pipeline {
+    agent any
+
+    stages {
+        stage('Workspace Cleanup') {
+            steps {
+                cleanWs()
+            }
+        }
+
+        stage('Checkout') {
+            steps {
+                checkout scm
+            }
+        }
+
+        stage('Run Regression (Docker)') {
+            steps {
+                script {
+                    docker.image('rdf-openroad-ci').inside('--user root:root --rm') {
+                        withEnv([
+                            'RDF_INSTALL_ROOT=/opt/Robust-Design-Flow',
+                            'PYTHONUNBUFFERED=1',
+                            'XDG_RUNTIME_DIR=/tmp/runtime-root'
+                        ]) {
+                            // sh 'git config --global --add safe.directory "$(pwd)"'
+                            // sh 'git submodule update --init --recursive'
+                            sh 'python3 tests/run_regression.py'
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            junit allowEmptyResults: true, testResults: 'rdf.test/logs/*.xml'
+            archiveArtifacts artifacts: 'rdf.test/**', allowEmptyArchive: true
+        }
+    }
+}
diff --git a/README.md b/README.md
@@ -18,6 +18,29 @@ We currently support an academic point tool-based configurable flow that is wrap
 #### Build RDF
 RDF depends on [OpenROAD-flow-scripts](https://github.com/The-OpenROAD-Project/OpenROAD-flow-scripts). Please refer build instructions from ORFS repository and [documentation](https://openroad-flow-scripts.readthedocs.io/en/latest/index2.html). Once ORFS is built, follow the instructions below to run RDF.
 
+#### Containerised Setup (Recommended)
+
+Build the provided Docker image from the repository root:
+
+```bash
+docker build -t rdf-openroad-ci -f docker/Dockerfile .
+```
+
+Run the regression inside the container (the current repository is mounted at
+`/workspace`):
+
+```bash
+docker run --rm -it \
+  -v "$PWD":/workspace \
+  rdf-openroad-ci \
+  bash -lc "python3 tests/run_regression.py"
+```
+
+The same image can be used by Jenkins (see `Jenkinsfile`) to keep the CI tool
+chain reproducible. When running against a prebuilt installation (e.g.
+`/opt/Robust-Design-Flow`), set `RDF_INSTALL_ROOT` to that path; otherwise the
+scripts default to the current working copy.
+
 #### Academic Point Tool-Based Configurable Flow
 
 The academic point-tool-based flow is a conventional RDF flow that uses a flow configuration file in YAML format. An example RDF flow configuration file is shown below ([Example](./scripts/sample_run.yml)).
diff --git a/docker/Dockerfile b/docker/Dockerfile
@@ -0,0 +1,54 @@
+FROM ubuntu:24.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV SUDO_USER=root
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    ninja-build \
+    git \
+    sudo \
+    curl \
+    python3 \
+    python3-pip \
+    tcl-dev \
+    swig \
+    flex \
+    bison \
+    libboost-all-dev \
+    libgflags-dev \
+    libeigen3-dev \
+    libspdlog-dev \
+    libyaml-cpp-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /opt
+
+RUN git clone --recursive https://github.com/ieee-ceda-datc/Robust-Design-Flow.git
+
+RUN git -C Robust-Design-Flow submodule sync --recursive \
+    && git -C Robust-Design-Flow submodule update --init --recursive
+
+WORKDIR /opt/Robust-Design-Flow/tools/OpenROAD-flow-scripts
+
+RUN ./setup.sh
+RUN ./build_openroad.sh --local
+
+
+
+ENV PATH="/opt/Robust-Design-Flow/tools/OpenROAD-flow-scripts/tools/install/OpenROAD/bin:\
+/opt/Robust-Design-Flow/tools/OpenROAD-flow-scripts/tools/install/yosys/bin:${PATH}"
+
+ENV LD_LIBRARY_PATH="/opt/Robust-Design-Flow/tools/OpenROAD-flow-scripts/tools/install/OpenROAD/lib:\
+/opt/Robust-Design-Flow/tools/OpenROAD-flow-scripts/dependencies/lib"
+
+
+ENV XDG_RUNTIME_DIR=/tmp/runtime-root
+
+RUN python3 -m pip install --no-cache-dir --break-system-packages \
+    unittest-xml-reporting \
+    pyyaml
+
+WORKDIR /workspace
+
diff --git a/scripts/robust_design_flow.py b/scripts/robust_design_flow.py
@@ -146,7 +146,7 @@ def create_def_verilog(self, stage, base_cmd):
 
     def create_odb(self, stage, base_cmd):
         create_odb_cmd = base_cmd + " compile_odb " + \
-                            f" RUN_SCRIPT={self.src_dir/'create_odb.tcl'} " +\
+                            f" RUN_SCRIPT={self.scripts_dir/'create_odb.tcl'} " +\
                             f" RDF_ODB_FILE={stage} " +\
                             f" RDF_DEF_FILE={stage}.def "
         return [create_odb_cmd]
@@ -217,10 +217,33 @@ def process_inputs(self):
         job_id.mkdir()
         self.workdir  = job_id
     
-        self.src_dir = Path(__file__).resolve().parent
-        self.orfs_dir = self.src_dir/"../tools/OpenROAD-flow-scripts"
-        self.orfs_flow = self.orfs_dir/"flow"
-        self.rdf_make = self.src_dir/"Makefile"
+        workspace_root = Path(__file__).resolve().parent.parent
+
+        install_root_env = os.environ.get("RDF_INSTALL_ROOT")
+        if install_root_env:
+            candidate = Path(install_root_env).expanduser().resolve()
+            if not candidate.exists():
+                self.logger.warning(
+                    "RDF_INSTALL_ROOT=%s not found. Falling back to workspace copy.",
+                    install_root_env,
+                )
+                candidate = workspace_root
+        else:
+            candidate = workspace_root
+
+        self.install_root = candidate
+        self.workspace_scripts = workspace_root / "scripts"
+        self.install_scripts = self.install_root / "scripts"
+
+        preferred_scripts = self.workspace_scripts if self.workspace_scripts.exists() else self.install_scripts
+        self.scripts_dir = preferred_scripts
+
+        self.orfs_dir = self.install_root / "tools/OpenROAD-flow-scripts"
+        self.orfs_flow = self.orfs_dir / "flow"
+        if (self.install_scripts / "Makefile").exists():
+            self.rdf_make = self.install_scripts / "Makefile"
+        else:
+            self.rdf_make = self.workspace_scripts / "Makefile"
         # self.orfs_make = self.orfs_flow/"Makefile"
         self.orfs_platform = args.platform 
         self.orfs_design = args.design
diff --git a/tests/README.md b/tests/README.md
@@ -1,50 +1,61 @@
 # RDF Test Harness
 
-This folder contains an end-to-end regression for the Robust Design Flow (RDF).
-The test runs the full OpenROAD flow on the `gcd` design for the Nangate45
-platform and compares the resulting report artifacts against the goldens in
+This directory exercises the Robust Design Flow (RDF) end-to-end on the `gcd`
+design (Nangate45) and compares the reported metrics against the goldens in
 `tests/golden/`.
 
-## Prerequisites
+## Recommended: Run in Docker
 
-- OpenROAD-flow-scripts and its toolchain must be built (see the repository
-  `README.md` for build instructions).
-- `make`, `python3`, and all runtime dependencies required by ORFS must be on
-  your `PATH`.
+Build the container image (from the repository root):
 
-## Running the Regression
+```bash
+docker build -t rdf-openroad-ci -f docker/Dockerfile .
+```
 
-From the repository root:
+Run the regression inside the image, mounting your working copy at
+`/workspace`:
 
 ```bash
-python3 -m unittest discover -s tests
+docker run --rm -it \
+  -v "$PWD":/workspace \
+  rdf-openroad-ci \
+  bash -lc "python3 tests/run_regression.py"
 ```
 
-This takes about a minute and streams the full flow output to the terminal so
-you can watch each stage execute. Temporary results live in `rdf.test/` while
- the test runs and are cleaned up automatically afterward.
+This matches the Jenkins CI environment and prints the full flow log.
 
 ## Updating Golden Artifacts
 
-If the flow metrics legitimately change (e.g., due to tool updates):
+When tool updates legitimately change the reported metrics:
 
-1. Run the flow manually to generate fresh artifacts:
+1. Regenerate the reports in Docker:
    ```bash
-   python3 scripts/robust_design_flow.py -t -r -y -v \
-     -c scripts/sample_run.yml -d gcd -n nangate45
+   docker run --rm -it \
+     -v "$PWD":/workspace \
+     rdf-openroad-ci \
+     bash -lc "python3 scripts/robust_design_flow.py -t -r -y -v \\
+       -c scripts/sample_run.yml -d gcd -n nangate45"
    ```
-2. Copy the new report files into the golden directory:
+2. Copy the updated files back onto the host:
    ```bash
    cp rdf.test/logs/nangate45/gcd/base/6_report.log tests/golden/6_report.log.ok
    cp rdf.test/logs/nangate45/gcd/base/6_report.json tests/golden/6_report.json.ok
    ```
-3. Remove `rdf.test/` when done: `rm -rf rdf.test`.
-4. Re-run the regression to confirm parity.
-
-## Troubleshooting
-
-- If the test fails because `make` or OpenROAD is not found, verify that the
-  ORFS environment setup scripts have been sourced.
-- To inspect a failing run, comment out the `tearDown` cleanup in
-  `tests/test_robust_design_flow.py` so the `rdf.test/` directory is preserved
-  for manual inspection.
+3. Clean up the temporary workspace:
+   ```bash
+   rm -rf rdf.test
+   ```
+4. Re-run `python3 tests/run_regression.py` (or the Docker command above) to
+   confirm parity.
+
+## Tips
+
+- The test fixture removes `rdf.test/` after each run. Comment out
+  `tearDown()` in `tests/test_robust_design_flow.py` if you need to inspect the
+  intermediate flow outputs while debugging.
+- To use a prebuilt installation located elsewhere (for example
+  `/opt/Robust-Design-Flow` on Jenkins), set `RDF_INSTALL_ROOT` before running
+  the regression. When unset, the scripts default to the current working copy.
+- If you choose to run natively (outside Docker), ensure OpenROAD-flow-scripts
+  is built, the toolchain is on `PATH`, and Python has `unittest-xml-reporting`
+  and `PyYAML` installed.
diff --git a/tests/golden/6_report.log.ok b/tests/golden/6_report.log.ok
@@ -3,12 +3,12 @@ Features included (+) or not (-): +GPU +GUI +Python
 This program is licensed under the BSD-3 license. See the LICENSE file for details.
 Components of this program may be licensed under more restrictive licenses which must be honored.
 [INFO ORD-0030] Using 72 thread(s).
-read_liberty /rdf_projects/vachhabr/datc/Robust-Design-Flow/scripts//../tools/OpenROAD-flow-scripts/flow/platforms/nangate45/lib/NangateOpenCellLibrary_typical.lib
+read_liberty <REPO>/scripts//../tools/OpenROAD-flow-scripts/flow/platforms/nangate45/lib/NangateOpenCellLibrary_typical.lib
 read_db rdf.test/results/nangate45/gcd/base/6_1_fill.odb
 Deleted 0 routing obstructions
 [INFO RCX-0431] Defined process_corner X with ext_model_index 0
 [INFO RCX-0029] Defined extraction corner X
-[INFO RCX-0435] Reading extraction model file /rdf_projects/vachhabr/datc/Robust-Design-Flow/scripts//../tools/OpenROAD-flow-scripts/flow/platforms/nangate45/rcx_patterns.rules ...
+[INFO RCX-0435] Reading extraction model file <REPO>/scripts//../tools/OpenROAD-flow-scripts/flow/platforms/nangate45/rcx_patterns.rules ...
 [INFO RCX-0436] RC segment generation gcd (max_merge_res 50.0) ...
 [INFO RCX-0040] Final 1679 rc segments
 [INFO RCX-0439] Coupling Cap extraction gcd ...
diff --git a/tests/run_regression.py b/tests/run_regression.py
diff --git a/tests/test_robust_design_flow.py b/tests/test_robust_design_flow.py
