[cuebot] Fix issue on getWhatDependsOn(Frame) (#2278)

.github/workflows/rust-pipeline.yml

@@ -8,47 +8,98 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
+  # Incremental compilation hurts CI clean builds (extra disk I/O, larger
+  # target dirs, no benefit since each runner is ephemeral) — turn it off.
+  CARGO_INCREMENTAL: 0
+  # Be more tolerant of registry hiccups on Windows.
+  CARGO_NET_RETRY: 10
+  RUSTUP_MAX_RETRIES: 10
+  # CI never runs a debugger, so full debug symbols (`debug=2`) are wasted
+  # compile + link time. `line-tables-only` keeps panic backtraces (file:line)
+  # so test failures stay readable, while cutting most debuginfo generation.
+  # Set via env (CI-only) rather than Cargo.toml so local dev keeps full symbols.
+  # Applies to every job, Windows included. `test` inherits from `dev`, but we
+  # set both explicitly so the override sticks regardless of inheritance.
+  CARGO_PROFILE_DEV_DEBUG: line-tables-only
+  CARGO_PROFILE_TEST_DEBUG: line-tables-only
 
 jobs:
   build:
     runs-on: ubuntu-22.04
+    timeout-minutes: 45
 
     steps:
       - uses: actions/checkout@v4
       - name: Install X11 dev libs
         run: |
-          sudo apt-get update && sudo apt-get install -y libx11-dev protobuf-compiler libcurl4-openssl-dev
+          # `mold` is a fast linker — cuts a large slice off Rust link time
+          # (609 deps to link). Invoked below via `mold -run`, which redirects
+          # the linker through LD_PRELOAD, so it needs no .cargo/config.toml
+          # (which would force mold on every local dev too) and works with the
+          # runner's default gcc regardless of version.
+          sudo apt-get update && sudo apt-get install -y libx11-dev protobuf-compiler libcurl4-openssl-dev mold
           curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rust-install.sh
           bash ./rust-install.sh -y
-      - name: Build
+      - name: Cache cargo deps
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: rust
+          cache-on-failure: true
+      # Build + test share a SINGLE (debug) profile so artifacts are reused —
+      # previously `cargo build --release` then `cargo test` compiled the whole
+      # workspace + all deps twice (release then debug), roughly doubling the
+      # job. CI only needs to prove it compiles and passes tests, which debug
+      # does. `--no-run` splits compile-vs-run timing; `--verbose` dropped to
+      # cut log I/O.
+      - name: Build tests
         run: |
           cd rust
-          cargo build --release --verbose
+          mold -run cargo test --no-run
       - name: Run tests
         run: |
           cd rust
-          cargo test --verbose
+          cargo test
 
   clippy:
     runs-on: ubuntu-22.04
+    timeout-minutes: 30
 
     steps:
       - uses: actions/checkout@v4
       - name: Install X11 dev libs
         run: |
-          sudo apt-get update && sudo apt-get install -y libx11-dev protobuf-compiler libcurl4-openssl-dev
+          sudo apt-get update && sudo apt-get install -y libx11-dev protobuf-compiler libcurl4-openssl-dev mold
           curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rust-install.sh
           bash ./rust-install.sh -y
+      - name: Cache cargo deps
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: rust
+          cache-on-failure: true
       - name: Run Clippy
         run: |
           cd rust
-          cargo clippy --verbose
+          mold -run cargo clippy --verbose
 
   windows-clippy:
     runs-on: windows-latest
+    timeout-minutes: 45
 
     steps:
       - uses: actions/checkout@v4
+      - name: Speed up Windows build (exclude build dirs from Defender)
+        shell: pwsh
+        run: |
+          # Real-time AV scanning of every compiler artifact (rustc writes
+          # thousands of .rlib/.o/.exe files) is the dominant hidden cost on
+          # Windows Rust CI. Exclude the workspace + cargo dirs and disable
+          # realtime monitoring outright — typically a 30-50% speedup. All
+          # calls are best-effort (Tamper Protection may block some).
+          Set-MpPreference -DisableRealtimeMonitoring $true -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionPath "$env:GITHUB_WORKSPACE" -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionPath "$env:USERPROFILE\.cargo" -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionProcess "cargo.exe" -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionProcess "rustc.exe" -ErrorAction SilentlyContinue
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -57,21 +108,49 @@ jobs:
         run: choco install protoc -y
       - name: Export PROTOC path
         run: echo "PROTOC=C:\ProgramData\chocolatey\bin\protoc.exe" >> $env:GITHUB_ENV
+      - name: Cache cargo deps
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: rust
+          cache-on-failure: true
       - name: Run Clippy
         working-directory: rust
-        run: cargo clippy -p rqd --verbose
+        run: cargo clippy -p rqd
 
   windows-tests:
     runs-on: windows-latest
+    timeout-minutes: 60
 
     steps:
       - uses: actions/checkout@v4
+      - name: Speed up Windows build (exclude build dirs from Defender)
+        shell: pwsh
+        run: |
+          # See windows-clippy for rationale — AV scanning dominates Windows
+          # Rust CI time; excluding build dirs is a 30-50% win. Best-effort.
+          Set-MpPreference -DisableRealtimeMonitoring $true -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionPath "$env:GITHUB_WORKSPACE" -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionPath "$env:USERPROFILE\.cargo" -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionProcess "cargo.exe" -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionProcess "rustc.exe" -ErrorAction SilentlyContinue
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
       - name: Install Protobuf
         run: choco install protoc -y
       - name: Export PROTOC path
         run: echo "PROTOC=C:\ProgramData\chocolatey\bin\protoc.exe" >> $env:GITHUB_ENV
+      - name: Cache cargo deps
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: rust
+          cache-on-failure: true
+      # Build tests first so we see compile-vs-run timing separately and the
+      # cache is populated even if a test later fails. `--verbose` is dropped
+      # — log volume noticeably slows Windows runners and the failure output
+      # is enough for triage.
+      - name: Build tests
+        working-directory: rust
+        run: cargo test -p rqd --no-run
       - name: Run tests
         working-directory: rust
-        run: cargo test -p rqd --verbose
+        run: cargo test -p rqd

.github/workflows/scheduler-stress-pipeline.yml

@@ -0,0 +1,154 @@
+name: OpenCue Scheduler Stress Pipeline
+
+# Runs the scheduler booking + accounting stress suite
+# (rust/crates/scheduler/tests/stress_tests.rs): a full pipeline::run against a
+# seeded farm, with an end-of-run audit that cross-checks the in-memory
+# accounting store against SUM(proc) in Postgres and asserts cap enforcement.
+#
+# When it runs — and when it deliberately doesn't:
+#   - Pull requests: only when the scheduler crate, its proto dependency, the
+#     DB migrations, or this workflow change. The suite needs a migrated
+#     Postgres and takes several minutes — running it for Python/CueGUI/docs
+#     changes would burn runner time for zero signal.
+#   - Nightly on master: catches drift from changes that slipped past the
+#     paths filter (e.g. shared workspace dependencies) and gives a daily
+#     throughput data point under fixed scale.
+#   - Manually (workflow_dispatch): for benchmarking a branch at custom scale.
+#
+# What is a gate vs. what is informational:
+#   - The job FAILS on correctness regressions: accounting drift between the
+#     in-memory store and Postgres, cap breaches (subscription burst / job
+#     max-cores), booking
+#     liveness (<90% drain, no saturation rejections), or leftover test data.
+#   - The throughput numbers (frames/s) are reported in the step summary but
+#     are NOT asserted on: shared runners are too noisy for perf gating. For
+#     real benchmarking run the suite locally in release mode (see
+#     docs/_docs/developer-guide/scheduler-stress-testing.md).
+
+on:
+  pull_request:
+    branches: ["master"]
+    paths:
+      - "rust/crates/scheduler/**"
+      - "rust/crates/opencue-proto/**"
+      - "rust/Cargo.toml"
+      - "cuebot/src/main/resources/conf/ddl/postgres/migrations/**"
+      - ".github/workflows/scheduler-stress-pipeline.yml"
+  schedule:
+    # Nightly on master. Odd minute to avoid the top-of-hour scheduling rush.
+    - cron: "23 9 * * *"
+  workflow_dispatch:
+    inputs:
+      stress_jobs:
+        description: "Drain-phase job count (default 300)"
+        required: false
+      stress_hosts:
+        description: "Drain-phase host count (default 1200)"
+        required: false
+      stress_frames_per_layer:
+        description: "Drain-phase frames per layer (default 5)"
+        required: false
+      stress_timeout_secs:
+        description: "Per-phase hard timeout in seconds (default 600)"
+        required: false
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  RUSTUP_MAX_RETRIES: 10
+
+jobs:
+  stress:
+    runs-on: ubuntu-22.04
+    timeout-minutes: 45
+
+    # The suite's Postgres service. Accounting state lives in-process inside the
+    # test itself, so nothing else needs to be provisioned here.
+    services:
+      postgres:
+        image: postgres:15.1
+        env:
+          POSTGRES_USER: cuebot
+          POSTGRES_PASSWORD: cuebot_password
+          POSTGRES_DB: cuebot
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U cuebot -d cuebot"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 10
+
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          # The suite only reads the repo (no git push), so don't leave the
+          # token on disk for later steps.
+          persist-credentials: false
+
+      - name: Install build dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y libx11-dev protobuf-compiler libcurl4-openssl-dev postgresql-client
+          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rust-install.sh
+          bash ./rust-install.sh -y
+
+      - name: Cache cargo deps
+        uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+        with:
+          workspaces: rust
+          cache-on-failure: true
+
+      # Plain psql instead of the sandbox Flyway image: the migrations are
+      # versioned plain-SQL files, so applying them in numeric order is exactly
+      # what Flyway would do, without building a JDK image first.
+      - name: Apply database migrations
+        working-directory: cuebot/src/main/resources/conf/ddl/postgres/migrations
+        env:
+          PGPASSWORD: cuebot_password
+        run: |
+          for f in $(ls V*.sql | sort -t V -k2 -n); do
+            echo "== $f"
+            psql -q -v ON_ERROR_STOP=1 -h localhost -U cuebot -d cuebot -f "$f"
+          done
+
+      - name: Run stress suite
+        working-directory: rust
+        shell: bash
+        env:
+          STRESS_JOBS: ${{ inputs.stress_jobs }}
+          STRESS_HOSTS: ${{ inputs.stress_hosts }}
+          STRESS_FRAMES_PER_LAYER: ${{ inputs.stress_frames_per_layer }}
+          STRESS_TIMEOUT_SECS: ${{ inputs.stress_timeout_secs }}
+        run: |
+          cargo test -p scheduler --features stress-tests --test stress_tests -- --nocapture 2>&1 | tee stress-output.log
+
+      - name: Publish phase report
+        if: always()
+        working-directory: rust
+        shell: bash
+        run: |
+          if [ -f stress-output.log ] && grep -q "^================ phase" stress-output.log; then
+            {
+              echo "## Scheduler stress suite"
+              echo '```'
+              sed -n '/^================ phase/,$p' stress-output.log | sed -n '1,80p'
+              echo '```'
+              echo "_Throughput numbers are informational; only the accounting/enforcement assertions gate this job._"
+            } >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "## Scheduler stress suite: no phase report produced (failed before the run?)" >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+      - name: Upload full output
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: scheduler-stress-output
+          path: rust/stress-output.log
+          if-no-files-found: ignore
+          retention-days: 30

.github/workflows/testing-pipeline.yml

@@ -411,7 +411,9 @@ jobs:
       - name: Build CueWeb Docker image
         working-directory: cueweb
         run: |
-          docker buildx build . -f Dockerfile -t opencue/cueweb:test --load
+          docker buildx build . -f Dockerfile -t opencue/cueweb:test --load \
+            --build-context project_root=.. \
+            --build-arg NEXT_PUBLIC_GIT_SHA=$(git rev-parse --short HEAD)
           echo "CueWeb Docker image built successfully"
 
   build_rest_gateway: