Proto commits in AcademySoftwareFoundation/OpenCue

These 61 commits are when the Protocol Buffers files have changed:

2026-06-26

[cuebot] Defer release proc when host non-accessible (#2471) If a lostProc could not be confirmed to have been killed, don't release the frame to Waiting state. Wait for the host to have been confirmed dead to release the proc for booking. Flapping and genuinely-dead hosts are indistinguishable at kill time. If the kill could not confirm the frame is stopped and the host is not confirmed dead, releasing the frame now would re-book it onto a second host while this RQD keeps rendering. In that case we DEFER the release: the proc row and RUNNING frame are left intact (preserving the host<->frame link, which is otherwise lost once the proc is deleted) so the frame is reclaimed later, once the host is confirmed DOWN (clearDownProcs) or the frame completes naturally. A genuinely dead host (marked DOWN, or no longer Up) leaves no live RQD, so release is safe. See design/frame_double_booking_v2.md. ## LLM usage disclaimer Claude Code Opus was used to help investigating this issue <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit * **New Features** * Added a new system metric for “deferred release procs” (lost procs held back instead of released immediately). * Introduced `dispatcher.defer_release_on_failed_kill_enabled` (default: enabled) to defer releasing when the frame stop can’t be confirmed and the host isn’t confirmed dead. * **Bug Fixes** * Improved lost-proc release/deferral logic to reduce double-booking during frame-stop uncertainty and host flapping. * Adjusted cleared-proc metrics so deferred cases no longer inflate cleared counts. * Enhanced orphaned-proc/frame maintenance reporting and warnings when records are already missing. * **Tests** * Expanded lost-proc decision-path coverage. <!-- end of auto-generated comment: release notes by coderabbit.ai -->

The documentation is generated from this commit.

2026-06-23

[cuebot/cuegui] Feature add layer dispatchorder control (#2354) This PR just complement it: https://github.com/AcademySoftwareFoundation/OpenCue/pull/222 <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit * **New Features** * Added "Reorder Dispatch..." option to the layer context menu to set dispatch priority for one or multiple layers. * Exposed a layer dispatch-order API so layers can be reordered programmatically. * Added a Python SDK Layer method to update dispatch order from scripts. * **Chores** * Version bumped to 1.26 <!-- end of auto-generated comment: release notes by coderabbit.ai --> --------- Signed-off-by: Alexis Oblet <alexis@theyard-vfx.com> Signed-off-by: Alexis Oblet <aoblet@users.noreply.github.com> Signed-off-by: Filipe Lacerda <53842848+tifilipebr@users.noreply.github.com> Co-authored-by: Diego Tavares <dtavares@imageworks.com> Co-authored-by: Alexis Oblet <alexis@theyard-vfx.com> Co-authored-by: Alexis Oblet <aoblet@users.noreply.github.com>

2026-06-04

[scheduler] Resource accounting on Redis (#2323) ### Summary Moves the Rust scheduler's resource accounting off in-process `HashMap`s and into a shared Redis store, with Cuebot's release path teed into the same store. Architecture, schema, the `acct:seq` guard, failure modes, and trade-offs are documented in [docs/_docs/developer-guide/redis-accounting.md](docs/_docs/developer-guide/redis-accounting.md) — this description covers what shipped on the branch, not how it works. Branch also carries an earlier batch of perf/stability fixes ("Phase 1") that landed ahead of the accounting work. ### Phase 1 — perf and stability quick wins (pre-feature) - `2072e63a` Dispatch + cluster query perf: `LIMIT N` on `QUERY_PENDING_BY_SHOW_FACILITY_TAG`, EXISTS rewrite, new indexes (V40 migration), facility case-sensitivity fix, empty-cluster sleep 3s → 30s, host-cache refresh overlap guard. Net: ~10× drop in `QUERY_PENDING` rate, ~3–5× per-call cost reduction. - `b98b86fa` Drop tag chunk size defaults to more reasonable values. - `7e2a5941` New metric for cluster round-trip duration. - `06a18ecd` Wrap cluster loop in panic guard. - `05dd9b31` Wrap panic surface on resource-accounting logic. - `e1767b12` Fix permit-update being ignored. - `bc5cd975`, `941c59fe` Minor refactors + review fixes. - `7f2c5124` Merge `master` (carries RQD windows/system tweaks). ### Phase 2 — schema + show-management flag + Cuebot read-side - `388bbc4c` New `show.b_scheduler_managed` column (V42 migration), `ShowDao` flag lookup + cache, `ShowInterface.setSchedulerManaged` gRPC + pycue wrapper + `cueadmin -setSchedulerManaged`. Drops `dispatcher.exclusion_list` / `dispatcher.scheduler_manages_resources` from `opencue.properties`; `DispatcherDaoJdbc` and `WhiteboardDaoJdbc` switched to the new column. Updates the existing deploying-scheduler docs and a release post to reflect the new toggle. - `1087ae66` Version bump + rename V40 migration after the V42 ordering. ### Phase 3 — Cuebot Redis publisher + show-aware `unbookProc` - `d14e52e4` `AccountingRedisPublisher` interface + `LettuceAccountingRedisPublisher` (single Lua doing 5 × `HINCRBY` + `INCR acct:seq`). `ProcDaoJdbc.unbookProc` branches on the cached flag: scheduler-managed shows get `DELETE proc` + `afterCommit` publish, others keep today's behavior. Spring config wires the no-op vs real publisher on `accounting.redis.enabled`; startup guardrail logs the misconfigured-Cuebot WARN. Tests across `ProcDaoTests`, `ShowDaoTests`, and `LettuceAccountingRedisPublisherTests`. - `88495a1c` Add Lettuce dependency. ### Phase 4 — Rust scheduler accounting module - `9d480e08` New `crates/scheduler/src/accounting/` module replacing `ResourceAccountingService`: Redis client + Lua scripts (atomic check-and-modify with `force` rollback), 2-min recompute, 5-min limit reseed, blocking bootstrap, managed-shows cache, `BookingDelta` over 5 tables (`DispatchLayer` extended with `folder_id` / `dept_id`). Compensation rollback at the dispatcher actor switched to Lua force mode. `acct:seq` CAS guard on every reseed. New `redis_integration` test suite. - `d945f0d1` Fix centicore-vs-core unit handling at PG/Cuebot↔Redis boundaries (limit reseed, recompute, release publisher, `CoreSize`); test centicores in the Lettuce publisher tests; dispatcher actor cleanups. - `336a6696` Add GPU limit enforcement to the booking Lua + integration coverage. ### Phase 5 — docs + cleanup (this session) - `88f3732c` New `docs/_docs/developer-guide/redis-accounting.md` rewriting the surviving design content as a developer reference; re-points the four in-tree citations (`accounting/mod.rs`, `AccountingRedisPublisher.java`, `LettuceAccountingRedisPublisher.java`, `LettuceAccountingRedisPublisherTests.java`) to the new guide; deletes `design/SCHED_REDIS_DECISIONS.md` (history preserved in git). ### Test plan - [x] Cuebot: `./gradlew build` (embedded Postgres covers V42 migration, `ShowDao`, `ProcDao` branching, `LettuceAccountingRedisPublisher` Lua wiring, `ManageShow.setSchedulerManaged`). - [x] Rust: `cargo test -p scheduler` and `cargo test -p scheduler --features integration-tests` (covers the booking Lua, recompute, limit reseed, bootstrap, GPU limits, centicore conversion at boundaries). - [x] pycue: `cd pycue && pytest tests/wrappers/test_show.py` (new `setSchedulerManaged` wrapper). - [x] cueadmin: `cd cueadmin && pytest tests/test_common.py` (new subcommand). - [x] `./docs/build.sh` (new developer-guide entry renders, internal anchors resolve). - [x] Manual sandbox smoke: flip a show via `cueadmin -setSchedulerManaged true`, verify Cuebot `unbookProc` publishes to Redis (`redis-cli MONITOR`), let recompute run, flip back, confirm no negative `int_cores` persists past one recompute cycle. - [x] Deploy validation: confirm no Cuebot logs `cuebot_redis_publish_misconfigured` after enabling `accounting.redis.enabled=true` cluster-wide. ### Breaking changes - `dispatcher.exclusion_list` and `dispatcher.scheduler_manages_resources` removed from `opencue.properties`. Any show previously listed there must be migrated to `b_scheduler_managed=true` via `cueadmin -setSchedulerManaged true` during the upgrade. - Deployments wanting to keep the scheduler running must set `accounting.redis.enabled=true` on every Cuebot before flipping any show to scheduler-managed (see deployment invariant in the dev guide). ## LLM Usage disclaimer Claude Opus was used both in the planning and implementation phases of this PR. All code has been reviewed and tested manually. <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit * **New Features** * Per-show "scheduler-managed" toggle exposed in CLI, gRPC and Python APIs. * Redis-backed live accounting and booking for scheduler-managed shows; scheduler startup reseed/recompute loops. * **Bug Fixes / Behavior** * Cuebot dispatching and accounting now skip shows marked scheduler-managed; booking ownership moved to scheduler when enabled. * **Documentation** * Expanded developer and deployment guides with migration and operational workflows for Redis accounting. * **Chores** * Version bumped to 1.25; added Redis dependency and integration tests. <!-- end of auto-generated comment: release notes by coderabbit.ai --> --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2026-05-21

[cuegui/cuebot] Optimize CueMonitorTree (#2370) CueJobMonitorTree was fetching the same job data twice every 22s: once via cached getJobWhiteboard, then once per group via an uncached getJobs(id=...). On a show with N populated groups, one tick cost 1 + N gRPC round-trips and SQL executions. Changes: - Add `repeated Job inline_jobs = 18` to NestedGroup (strictly additive; `repeated string jobs` retained). Cuebot populates it from the existing GET_NESTED_GROUPS row data — the only column added to the SELECT is `str_loki_url`. Reuses WhiteboardDaoJdbc.JOB_MAPPER. - Bump whiteboard cache TTL 5s→10s and add per-show single-flight (synchronized-on-show), so concurrent clients share one SQL execution per TTL window. - cuegui: drop UPDATE_INTERVAL 22s→5s; override _update with a skip-if-running guard; rewrite _processUpdate as an incremental diff (takeChild only stale IDs, no clear()), so selection, scroll, and expansion survive add/remove/reparent. - cuegui: consume inline_jobs; fall back to opencue.api.getJobs against older Cuebot. ## LLM usage disclosure Claude Opus was used to implement this optimization <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit * **New Features** * Display inline job data within nested job groups. * **Performance** * Faster job tree refresh (22s → 5s). * Incremental tree updates to avoid full rebuilds. * Improved whiteboard caching with per-show refresh control and longer timeout. * **Bug Fixes** * Ensure work/task completion callbacks fire even on failure. * **Tests** * Added a test verifying inline jobs populate in nested groups. * **Chores** * Project version updated to 1.24. <!-- review_stack_entry_start --> [](https://app.coderabbit.ai/change-stack/AcademySoftwareFoundation/OpenCue/pull/2370?utm_source=github_walkthrough&utm_medium=github&utm_campaign=change_stack) <!-- review_stack_entry_end --> <!-- end of auto-generated comment: release notes by coderabbit.ai --> --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2026-05-20

[cuebot/proto/pycue/cuegui/docs] Add startTime() and stopTime() to Layer (#2338) ## Related Issues - https://github.com/AcademySoftwareFoundation/OpenCue/issues/2339 ## Summarize your change. [cuebot/proto/pycue/cuegui/docs] Add Layer startTime() and stopTime() Layer previously had no start/stop time accessors. Callers that needed the execution window for a layer had to fetch every frame and compute MIN/MAX client-side, which was wasteful in CueGUI (N extra RPCs per refresh for a job with N layers) and unavailable to tools that only queried layers. This change denormalizes layer timing onto `layer_stat` and exposes the values directly on the Layer API: - `Layer.startTime()` = `layer_stat.ts_started` (stamped on first entry to RUNNING) - `Layer.stopTime()` = `layer_stat.ts_stopped` (stamped on each exit from RUNNING, but surfaced as 0 until every frame on the layer has stopped) `stopTime()` remains `0` while any frame is still pending, running, or in DEPEND, mirroring `Job.stopTime()` so callers can use the same "is it done?" idiom consistently. Proto - Add `start_time` (field 24) and `stop_time` (field 25) to the `Layer` message. Cuebot - Add `ts_started` and `ts_stopped` (`TIMESTAMP WITH TIME ZONE`) to `layer_stat`. - Maintain both values through the existing `trigger__update_frame_status_counts` trigger (`AFTER UPDATE ON frame`): * entry to RUNNING stamps `ts_started` from `NEW.ts_started` via `COALESCE(...)` (first-writer-wins; retries do not update it) * exit from RUNNING stamps `ts_stopped` from `NEW.ts_stopped` (latest-writer-wins) - Copy timestamps from the updated frame row instead of sampling `current_timestamp`, ensuring `layer_stat.ts_stopped` exactly matches `MAX(frame.ts_stopped)`. - Preserve `COALESCE(..., current_timestamp)` as a fallback for callers that change state without explicitly updating timestamps. - Update `GET_LAYER` and `GET_LAYER_WITH_LIMITS` to read `layer_stat.ts_started` and `layer_stat.ts_stopped` directly, replacing two correlated frame-table aggregates per layer query. - Move "stopTime stays 0 until all frames are done" logic into `WhiteboardDaoJdbc.LAYER_MAPPER` using existing counters: `int_waiting_count + int_running_count + int_depend_count == 0` - Align layer timing behavior with existing denormalized `job.ts_started` / `job.ts_stopped`. - Add V43 migration to create and backfill both columns from existing frame aggregates, with no manual follow-up required. PyCue - Add `Layer.startTime(format=None)` and `Layer.stopTime(format=None)`, matching `Job.startTime()` formatting behavior. - Add unit tests for both epoch and formatted outputs. CueGUI - Add "Start Time" and "Stop Time" columns to `LayerMonitorTree`, alongside the existing "Eligible" column. Docs - Add `startTime` and `stopTime` to the Layer example payload in the REST API reference. - Document the new monitor-tree columns in the Cuetopia monitoring guide. VERSION.in - Bump version to 1.23.

[cuebot/proto/pycue/cuegui/docs] Add submissionTime() to Frame (#2337) ## Related Issues - https://github.com/AcademySoftwareFoundation/OpenCue/issues/2326 ## Summarize your change. Adds `submissionTime()` to `Frame`, exposing the parent job's submission timestamp directly on the frame object. This avoids requiring callers to fetch the parent job or overload `eligibleTime()` to infer submission time. `Frame.startTime()` represents when the frame began executing on a render host, not when the job was submitted. Since `Job.startTime()` and `Layer.startTime()` already serve as submission timestamps for those objects, only `Frame` needed this additional accessor. With `submissionTime()`, callers can now compute frame lifecycle timing directly from a single `Frame` object: - `blocked_by_depends = frame.eligibleTime() - frame.submissionTime()` - `blocked_by_pickup = frame.startTime() - frame.eligibleTime()` - `total_turnaround = frame.stopTime() - frame.submissionTime()` Proto files - Adds `submission_time` field to `Frame`. Cuebot - Updates `WhiteboardDaoJdbc.FRAME_MAPPER` to populate `submission_time` from the existing `job.ts_started` join (already aliased as `job_ts_started` for the `eligibleTime()` fallback). - No database migration is required, since the source column already exists. PyCue - Adds `Frame.submissionTime()`. - Includes a new unit test covering the Python wrapper. CueGUI - Adds a new "Submission Time" column to `FrameMonitorTree`, positioned next to the existing "Eligible Time" column. - Re-anchors the `*_COLUMN` visual-index constants in `FrameMonitorTree`, which had drifted from their intended columns over years of insertions (last touched in 2018). The new "Submission Time" column made the staleness visible by shifting `LASTLINE_COLUMN` further out of place: - `PROC_COLUMN`: 5 -> 6 (was pointing at GPUs; now correctly points to Host). - `CHECKPOINT_COLUMN`: 7 -> 8 (was pointing at Retries; now correctly points to the icon-only `_CheckpointEnabled` column where the checkmark decoration belongs). - `RUNTIME_COLUMN`: 9 -> 10 (was pointing at the hidden `_CheckpointEnabled`; now correctly points to Runtime). - `MEMORY_COLUMN`: 11 -> 12 (was pointing at LLU; now correctly points to Memory (RSS)). - `LASTLINE_COLUMN`: 15 -> 20 (was pointing at Remain; now correctly points to Last Line). - As a side effect, `redrawRunning()` now emits `dataChanged` over the correct Runtime -> Last Line range, restoring smooth repaints for Runtime/Memory/Last Line cells on running frames. The `PROC_COLUMN` foreground-color and alignment, plus the `CHECKPOINT_COLUMN` icon decoration, also land on the right cells now. - Adds a header comment noting these are visual indices that must be updated in lockstep when columns are inserted, removed, or reordered. Docs - Adds `submissionTime` to the Frame REST API reference schema and example payloads. - Updates the Cuetopia monitoring guide to document the new column. VERSION.in - Bumped up to 1.22

2026-05-15

[cuebot/proto/pycue/cuegui/docs] Add eligibleTime() to Job, Layer, and Frame (#2325) ## Related Issues - https://github.com/AcademySoftwareFoundation/OpenCue/issues/2319 ## Summarize your change. Exposes when an object became eligible to run (left DEPEND for WAITING, or the job's submission time when never blocked) so callers can measure how long a frame waited to be picked up by a render proc: wait_for_pickup = frame.startTime() - frame.eligibleTime() Proto files - Adds `eligible_time` field to Frame, Job, NestedJob, and Layer. Cuebot - V41 migration adds `ts_eligible` column to the frame, layer, and job tables. - `layer.ts_eligible` and `job.ts_eligible` default to `current_timestamp`; existing rows are backfilled from `job.ts_started`. - Extends the existing DEPEND -> WAITING trigger so it stamps `frame.ts_eligible` whenever a frame unblocks. - V42 migration adds a SETUP -> WAITING trigger to stamp `ts_eligible` on the path frames actually take through Cuebot (frames are inserted as SETUP and bulk-transitioned to WAITING by `JobManagerService.activateJob`, so V41's BEFORE INSERT trigger never fires in practice). - V42 also backfills `ts_eligible` for frames that already made the SETUP -> WAITING jump before this migration ran. - `WhiteboardDaoJdbc` and `NestedWhiteboardDaoJdbc` map the column into the proto's `eligible_time` via a `getEligibleTimeInEpoch` helper, falling back to the job's submission time when `ts_eligible` is NULL (frames still in DEPEND). PyCue - Adds `Frame.eligibleTime()`. - Adds `Job.eligibleTime(format=None)` and `Layer.eligibleTime(format=None)`, mirroring the format-string behavior of `Job.startTime()`. - Propagates `eligible_time` through `NestedJob.asJob()`. - New unit tests cover all four wrappers. CueGUI - Adds an "Eligible Time" column to `FrameMonitorTree`. - Adds an "Eligible" column to `JobMonitorTree` and `LayerMonitorTree`. - "Eligible" was chosen over "Available" because the latter can imply the object will run next, when other gates (resources, paused state, etc.) may still block dispatch. Docs - Adds `eligibleTime` to the Job and Frame REST API reference schemas and example payloads. - Documents the new monitor-tree columns in the Cuetopia monitoring guide.

2026-01-09

[cuebot/cuegui/pycue/rqd] Store PSS and MaxPSS (#2112) **Overview** Update modules to properly store PSS (Proportional Set Size) alongside RSS (Resident Set Size) for measuring process memory usage on Linux systems. **Key Differences:** - **RSS**: Total physical memory including full count of shared libraries (can be misleading) - **PSS**: Proportional share - shared pages divided by number of processes sharing them (more accurate) - **Source**: `/proc/[pid]/smaps_rollup` (Linux kernel 4.14+) provides pre-summed PSS values **Current State:** Rqd contains a config property to collect memory as either RSS or PSS. Information is saved on Cuebot and displayed as Rss. **Proposed Solution:** Rqd collects and reports both RSS and PSS. Cuebot stores both in the database. pycue and cuegui display both. Tasks: - [x] Update rqd to collect PSS - [x] Update proto and cuebot to store data on the database - [x] Update pycue and cuegui to display PSS - [x] Fix accidentally refformated python files

2025-12-15

[cuebot/pycue/proto/sandbox/docs] Add full event-driven monitoring stack, enhance metrics, dashboards, and documentation (#2086) **Link the Issue(s) this Pull Request is related to.** - https://github.com/AcademySoftwareFoundation/OpenCue/issues/2085 **Summarize your change.** [cuebot/pycue/proto/rust/sandbox/docs] Add event-driven monitoring stack for OpenCue Implement event-driven monitoring infrastructure enabling real-time and historical analysis of render farm activity. Adds a Kafka + Elasticsearch pipeline for collecting job, layer, frame, host, and proc lifecycle events, with Prometheus and Grafana integration for live dashboards and operational visibility. Proto & Event Model: - Define monitoring.proto with job/layer/frame/host/proc lifecycle events - Use proto composition pattern - embed Job, Layer, Frame, Host messages - Exclude HostReportEvent from pipeline (too high frequency for Kafka/ES) Cuebot Event Publishing: - Add KafkaEventPublisher for async event publishing to Kafka topics - Add KafkaAdminClient for topic creation with configurable partitions/retention - Add MonitoringEventBuilder as Spring-managed bean for event construction - Hook publishing into FrameCompleteHandler, HostReportHandler, DispatchSupportService, JobManagerSupport, DependManagerService - Publish pickup time tracking events (FRAME_STARTED, FRAME_DISPATCHED) - Add isFrameDispatchable() to DependDao for dependency checking Prometheus Metrics: - cue_frames_completed_total (with show, shot, state labels) - cue_jobs_completed_total (with show, shot, state labels) - cue_job_core_seconds histogram - cue_layer_max_runtime_seconds histogram - cue_layer_max_memory_bytes histogram Rust monitoring-indexer Service: - Add rust/crates/monitoring-indexer: standalone Kafka-to-Elasticsearch indexer - Async Kafka consumer with configurable batch processing - Elasticsearch bulk indexing with date-based indices and field mappings - Parallel event processing using rayon for CPU-bound operations - Index templates for all event types (job, layer, frame, host, proc) - Graceful handling of UnknownTopicOrPartition during startup gRPC & PyCue: - Add MonitoringInterface gRPC service - Implement pycue monitoring wrapper with historical data API methods Infrastructure (docker-compose.monitoring-full.yml): - Zookeeper, Kafka, Kafka UI - Elasticsearch, Kibana - Prometheus (with cuebot scrape config) - Grafana (with provisioned dashboard) - monitoring-indexer service Grafana Dashboard: - Frame completion rates by state (DEAD/red, SUCCEEDED/green, WAITING/yellow) - Job completion by show - Frame runtime and memory distribution - Job core seconds distribution - Pickup time metrics (FRAME_STARTED/FRAME_DISPATCHED) - Layer max runtime/memory panels Documentation: - Architecture, concepts, and pipeline explanation - Deployment and Quick Start guides - User and Developer guides - API Reference and tutorials - Elasticsearch query reference guide Utilities: - sandbox/monitor_events.py: Example Kafka consumer - sandbox/load_test_jobs.py: Test data generator with CLI args Configuration (opt-in, disabled by default): - monitoring.kafka.enabled, monitoring.kafka.bootstrap.servers - monitoring.kafka.topic.partitions, .replication.factor, .retention.ms - monitoring.elasticsearch.enabled, monitoring.elasticsearch.host --------- Signed-off-by: Ramon Figueiredo <ramon.fgrd@gmail.com>

2025-10-17

[cuebot/cuegui/pycue/cueadmin] Add cue filter actions for UTIL and PRE layers (#2050) **Link the Issue(s) this Pull Request is related to.** - https://github.com/AcademySoftwareFoundation/OpenCue/issues/2049 - #1800 **Summarize your change.** Add filter actions for UTIL and PRE layer types to match existing RENDER layer functionality. The following actions are now available: UTIL layer actions: - SET_ALL_UTIL_LAYER_TAGS - SET_ALL_UTIL_LAYER_MEMORY - SET_ALL_UTIL_LAYER_MIN_CORES - SET_ALL_UTIL_LAYER_MAX_CORES PRE layer actions: - SET_ALL_PRE_LAYER_TAGS - SET_ALL_PRE_LAYER_MEMORY - SET_ALL_PRE_LAYER_MIN_CORES - SET_ALL_PRE_LAYER_MAX_CORES Changes: - proto: Add 8 new ActionType enum values - pycue: Update Action wrapper to support new action types - cuebot: Add action handlers in FilterManagerService - cuegui: Update FilterDialog UI for new action types - cueadmin: Update ActionUtil to handle new action types

2025-10-02

[cuebot/pycue/cueadmin/docs] Add show archive automation feature (#2024) **Link the Issue(s) this Pull Request is related to.** - #1362 **Summarize your change.** Implement archive functionality to automate archiving inactive shows by creating aliases to target shows. This enables jobs submitted to archived shows to run on target show allocations. Changes: - Add Archive RPC method to `show.proto` - Implement `show.archive()` method in pycue - Add `-archive-show` command to `cueadmin` - Implement `archiveShow()` in `ShowDao` with database support - Add comprehensive unit tests for all layers - Update documentation (command reference, tutorials, glossary) - Bump version to 1.12

2025-06-20

Rust RQD (#1759) Introduce a Rust directory containing a Rust version of the RQD module and its dependencies. For more information about the workspace organization, see `Opencue/rust/OVERVIEW.md` Modules can be compiled for the desired OS with `cargo built -r`, this version supports both MacOS and Linux. Compiling at debug mode favours the Linux version build. Binaries can be found after compilation on the default directory (target/release). --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2025-06-17

Rust rqd (#1762) temporary branch for testing cicd pipeline changes on the rust_rqd PR prior to merging it to master.

2025-05-21

Split proto into it's own package and create packages for all python modules (#1681) Summary of changes : ### Proto split - Split proto files into it's own folder (proto) and package (opencue_proto) ### Packaging - Removed `build_proto.sh` script - Replace `setup.py` and `requirements.txt` with `pyproject.toml` with proper dependencies for testing, building and installation - Prefixed all packages with "opencue_" to not clash with pypi packages. - Uses versioningit for versiosing the packages. If current commit is tagged, it will use that as version name. Otherwise it will add how many commits since last tag and current commit hash. Eg. `1.4.11.post156+g23df172.d20250416` ### CI/CD - Change test workflow from using PYTHONPATH to use installed packages of dependencies. - Use pre-built packages (built with python 3.7) for use in CI/CI testing. (with workflow dependencies) - Added test for installing all packages using python 3.11 and python 3.12 (can easily add more) - Test packages using `python -m pytest ${package}` which uses definded test dirs in `pyproject.toml` --------- Signed-off-by: Jimmy Christensen <Lithorus@gmail.com> Co-authored-by: Robin (Ubisoft) <146888956+robin-ubisoft-helix@users.noreply.github.com>

2025-03-03

[cuegui] Add LockState Filter to "Monitor Hosts" window in CueCommander (#1679) - Add `LockStateSeq` message with `repeated LockState state` in `host.proto` and update HostSearchCriteria - Update `HostMonitor.py` to include the menu to filter by lock state - Update `HostSearch.java` to include lock state filtering - Add lock state handling in `_setOptions` function in `search.py` **Link the Issue(s) this Pull Request is related to.** https://github.com/AcademySoftwareFoundation/OpenCue/issues/1678

2025-02-15

[rqd] [cuegui] Add support for Loki for frame logs (#1577) **Link the Issue(s) this Pull Request is related to.** #1571 **Summarize your change.** This adds the ability to use loki as the backend for frame logs in rqd. It also adds a new plugin/widget in cuegui to read the logs from the loki server. This enables logs files to not be bound by a single namespace and also adds the potential to also store telemetry about the frame. This is still on an experimental stage and any inputs are appreciated. Screenshot of new widget :  The loki-urllib3-client python module is optional and if it's not detected, the cuegui widget will show and error message. Not yet implemented : - Search log - Timestamp in log view --------- Co-authored-by: Diego Tavares <dtavares@imageworks.com>

2025-01-23

[rqd] Add frame recovery logic for docker mode (#1614) Whenever RQD restarts it loses track of all the frames launched by it that haven't finished. This change adds a new configurable option to backup frame states to a file, that is used to recover the frame cache state and try to re-bind to the running frames. This first version only works on docker mode --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2024-11-20

[rqd/cuebot] Hard and Soft memory limits (#1589) Currently, frames are created with minimal requirements, but limits are not enforced. This PR implements soft and hard limits on RQD when running on docker mode. For more information about soft and hard limits [read](https://docs.docker.com/engine/containers/resource_constraints/). Limits are calculated using the minimum memory defined for the layer and a multiplier that can be tuned at Dispatcher.java. Ideally, these values should be extracted to opencue.properties, but they are being used in a static context, and interpreted before the file is actually read. --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2024-11-19

[cuegui/pycue] Fix Local Booking widget (#1581) This feature has been inactive on opencue since the beginning. Changes to port from Ice to Grpc were not properly tested and this widget never really worked. Local Rendering if a feature that allows users to claim the ownership of a host (their workstation) and assign a job to execute frames on that host. This is very useful in situations where the farm is busy but user workstations aren't. To access the feature, right-click on a job/layer and select "Use local cores..". On the opened widget, the user can select how much cores, memory and gpu to allocate to execute cue jobs. When confirmed, cuebot will start dispatching frames to that host. --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2024-11-15

[cuebot/rqd] Add feature to run frames on a containerized environment using docker (#1549) ### Motivation Running OpenCue In a multi operational system environment requires segregating the farm, which means hosts have to be assigned to one OS and cannot be shared between shows that have different OS requirements. This can be a challenge when sharing resources between shows is necessary. ### Proposed solution A new execution mode on **rqd** `runDocker` to live alongside `runLinux`, `runWindows`, and `runDarwin` (macOs). This mode will launch the frame command on a docker container based on the frame expected OS. With this, rqd is now able to run jobs from different OSs on the same host. But to make this possible, a rqd host needs to advertise itself not with its own OS code (defined by `SP_OS` on rqd.conf), but with all the OSs of images it is capable of executing. ### Configuration changes The following sections were added to rqd.conf: ```ini [docker.config] # Setting this to True requires all the additional "docker.[]" sections to be filled RUN_ON_DOCKER=True # This section is only required if RUN_ON_DOCKER=True # List of volume mounts following docker run's format, but replacing = with : [docker.mounts] TEMP=type:bind,source:/tmp,target:/tmp,bind-propagation:slave NET=type:bind,source:/net,target:/net,bind-propagation:slave # This section is only required if RUN_ON_DOCKER=True # - keys represent OSs this rqd is capable of executing jobs in # - values are docker image tags [docker.images] centos7=centos7.3:latest rocky9=rocky9.3:latest ``` In this case, the rqd host would advertise itself with `OS=centos7,rocky9`, and the dispatch logic has been changed accordingly to account for dispatching frames to nodes that support multiple OSs. Feature has been documented at https://github.com/AcademySoftwareFoundation/opencue.io/pull/302 --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2024-11-14

Rest gateway (#1355) ## Summarize your change Create a service to expose a REST endpoint for the grpc interface. The motivation behind having a REST endpoint is to create a web version of cuegui (coming soon). ## How does it work See the [module README](https://github.com/AcademySoftwareFoundation/OpenCue/blob/1f3229599a58af64aa9c7feda7657f8fece9c97d/rest_gateway/README.md) for a full documentation. --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com> Co-authored-by: Zachary Fong <zfong@imageworks.com> Co-authored-by: Ramon Figueiredo <rfigueiredo@imageworks.com>

2024-10-18

Update placeholder branch for containerized_rqd (#1550) Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2024-09-06

[cuebot/rqd] Prevent running frames on Swap memory (#1497) Improve logic previously implemented to handle Out-of-memory conditions to consider swap usage. When a host is using more than `dispatcher.oom_max_safe_used_physical_memory_threshold` if its physical memory and more than `dispatcher.oom_max_safe_used_swap_memory_threshold` of its swap memory, a logic that kills frames that are relying heavily on swap memory is triggered. This logic will automatically mark killed frames to be retried and possibly increase its parent layer memory requirements if it had been using more memory than initially reserved. Co-authored-by: Ramon Figueiredo <rfigueiredo@imageworks.com>

2024-08-12

[cueweb] CueWeb improvements and add unit testing (#1457) Features and improvements 1. CueWeb authorization updates - Modified CueWeb to include authorization headers in all HTTP requests to the gRPC REST gateway. - Added functionality to generate JWT tokens using a secret for inclusion in authorization headers. 2. Include unit testing - Introduced Jest tests for CueWeb to cover: Authentication middleware, error handling, and JWT creation. Co-authored-by: Zachary Fong <zfong@imageworks.com> Co-authored-by: Ramon Figueiredo <rfigueiredo@imageworks.com>

2024-08-09

Rest gateway (#1449) Merge changes from local fork into ASWF repo --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com>

2024-07-30

Add command to layerDetails (#1436) **Summarize your change.** This adds the layer `command` attribute to the layer details in the cuegui attribute widget.

Remove rqd restart feature (#1435) The feature was never really functional. Its implementation relied on a hardcoded path only valid for the init.d deployment of rqd, and even for this use case it didn't work as expected. For the three existing rqd deployment modes (docker, init.d and systemd) restarting should be accomplished by calling stop and start sequentially. Out of the three modes, only Docker is not handled by this PR, as it requires external control of the rqd service on docker, and service definitions are out of the scope of this repo.

2024-07-16

Implement feature to override frame state display text/color in UI (#1246) Implement feature to override frame state display text/color in UI The scheduled task to remove old jobs has been failing for jobs with frames that used the new override feature due to a foreign key not being handled at the delete trigger. --------- Authored-by: RosaBehrensCamp <rbehrens@imageworks.com> Signed-off-by: Diego Tavares <dtavares@imageworks.com> Co-authored-by: Diego Tavares <dtavares@imageworks.com>

2024-06-17

Subscribe to a job using email (#1368) Summarize your change. This change give users the ability to subscribe to a job through the API or using the GUI. An user subscribed to a job will receive the same emails as the owner of the job. Signed-off-by: Diego Tavares <dtavares@imageworks.com> Co-authored-by: Akim Ruslanov <aruslanov@imageworks.com>

Kill job reason (#1367) Adding requester information to JobKillRequest This feature requires more information from job kill actions requested through the API. Link the Issue(s) this Pull Request is related to. This feature is motivated by a situation where a script was misusing the API and calling kill on all the jobs for a show on a regular basis. Without this feature, finding where the requests were coming from was a big endeavor. Summarize your change. This change requires that a kill request also provide username, pid, host_kill and reason. --------- Signed-off-by: Diego Tavares <dtavares@imageworks.com> Co-authored-by: Roula O'Regan <roregan@imageworks.com>

2024-06-13

Fix Criteria.java query search parameters (#1369) Fix a bug in the overloaded method addPhraseRange for InRangeIntegerSearchCriterion. The method needs an extra search parameter and needs to call min/max and not value. Added two new parameters to the buildWhereClause for "greater than" and "lower than" memory proc searches. --------- Co-authored-by: Roula O'Regan <roregan@imageworks.com>

2022-07-13

Min mem increase (#1157) Added the ability for admins to set the minimum memory increase value on a service. OpenCue increases the minimum memory requirements every time a job is retried when it fails from running out of memory but the old memory increase (hardcoded to 2G) was causing some jobs to be retried many times before it finally succeeded.

[rqd] Core affinity for cache optimization (#1171) When possible, try to book frames from the same Layer on the same core to leverage shared cache

2022-06-04

Add layer max cores. (#1125)

2022-05-27

Improve view running procs (#1141) * Improve view running procs This changes the widget to only display info about the selected frame instead of all the running frames for the job. * pylint pass * pylint pass * Update VERSION.in Co-authored-by: Brian Cipriano <brian.cipriano@gmail.com> Co-authored-by: Brian Cipriano <brian.cipriano@gmail.com>

2022-05-10

Add more exit codes to Frame state waiting (#1131) * Add more exit codes to Frame state waiting When determining the frame state cuebot needs to make sure that certain exit statuses put the frame state back into waiting, this will help save time for users when a frame fails for host hardware issues. (cherry picked from commit cbeda9387b09a8713bb76d9075fdee72c3c795f1) * Add more exit codes to Frame state waiting * Removed unused method updateFrameHostDown * Removed deprecated oracle FrameDaoJdbc file * Remove log debugging from FrameCompleteHandler * Reverting, adding updateFrameHostDown FrameDao method * Verion bump, add missing interface checkRetries method Co-authored-by: Diego Tavares da Silva <dtavares@imageworks.com>

2022-04-28

Add Proc's child PIDs to Host report stats (#1130) * Add Proc's child PIDs to Host report stats Users require additional information about the running frame.data pid. For each parent process (frame.pid) add to report.proto the child process: name, rss, vsize, state, cmdline, pid. This additional info will get stored in the Proc table, while proc is running; users can view child proc stats via Cuegui and rqlog will output the highest recorded values for rss for each child pid. * Fix Proc Pylint errors * Add more exit codes to Frame state waiting When determining the frame state cuebot needs to make sure that certain exit statuses put the frame state back into waiting, this will help save time for users when a frame fails for host hardware issues. (cherry picked from commit cbeda9387b09a8713bb76d9075fdee72c3c795f1) * Add more exit codes to Frame state waiting * Removed unused method updateFrameHostDown * Removed deprecated oracle FrameDaoJdbc file * Remove log debugging from FrameCompleteHandler * Fixes to RQD and unittests * Remove unrelated changes from FrameDao * Fix pylint errors for rqmachine.py * Remove unrelated frame changes from pycue * Removing unrelated change from DispatchSupportService * Fix merged conflicts for ProcDaoTests

2022-01-17

Add Job.shutdownIfCompleted API method. (#1033)

2021-06-20

Add multiple GPU support #760 (#924)

2021-04-25

Add GetDefault and SetDefault to AllcationInterface (#939)

2021-04-04

Remove blackout (#946) * Remove blackout * Bump up version

2021-01-23

feat: Add timeout and LLU timeout (#761) Add support for layers to have timeout. If a frame goes past it's hard timeout it get's killed. LLU timeout is usually a lower value that check when the last log update has happend. if no update happens in the LLU window it's also killed. Closes #462

2020-02-24

Make UID optional in frame submission (#618)

2019-12-03

Fix passing message to kill frame (#546)

2019-10-02

Add basic limits functionality (#414) * Initial add of Limits to Layers. Allows users to specify arbitrary limits to job layers, to prevent running too many tasks. This is just the backend implementation, there will be separate commits for the front end and dispatcher updates. * Adding helper get limit names method to LayerDao, to make it easier to populate the Limit list on a returned layer object * cleanup * remove unnecessary import * initial add of limit client code * hooking up limit database queries * adding current_value to limit object * adding limits to pycue * update layer when properties change * adding current running column to LimitsWidget * Add functionality to edit limits on an existing layer * improving tests * fixing some layer tests * switch to use streams instead of loops

2019-09-19

Fixes for Layer.getFrames (#447) * Remove unnecessary layer clean logic * Allow getFrames to set limit value

2019-08-13

Add more MenuActions tests. (#410)

2019-05-18

Adding unittests for group and host wrappers. (#324) NestedGroup asGroup function now returns a Group wrapper object. Correctly labeling allocation id as id in Host SetAllocation call.

2019-05-07

CueAdmin code cleanup and test coverage. (#295)

2019-04-03

getJobWhiteboard returns groups only and a list of job ids (#264) * getJobWhiteboard returns groups only and a list of job ids, instead of all nested items. In response to Issue #251.

2019-03-13

Fixing subgroups for monitor cue plugin in cuegui (#236) * Fixing subgroups for monitor cue plugin in cuegui

2019-02-14

Clean up PyCue unit tests and enable them in the docker build. (#201)

2019-01-16

opencue python renaming (#109) * opencue python renaming

2019-01-14

Rqd cleanup & fixes (#98) * adding attrs so rqd doesnt need to overload the message object * grpc messages should not be overloaded and use snake case * switch syslog setup to to try to use /dev/log, if not available use localhost on all OSs.

2018-12-14

Move proto files to be a top-level directory. (#47)

2018-11-30

Migrate RQD to only use GRPC. (#32)

2018-11-28

Migrate Criterion usage to GRPC. (#30)

2018-11-16

grpc for spi_cue (#23) * grpc for spi-cue

2018-11-07

GRPC changes for cuebot (#15) * Switch the servants to GRPC and remove the ICE servants. * Rename the top level entity objects to clear up naming conflicts with rpc objects. The naming convention is now: Action : rpc object ActionEntity : Object that inherits from Entity ActionInterface: Interface to the Entity * Updates to the Whiteboard to work with the gRPC objects. * Move methods in CueStatic into object specific classes since they are all static now. * Enums are capital by convention

2018-10-16

Adding proto files for grpc (#11) * Adding protos for cuebot * gRPC setup for Allocations, Subscriptions, and Tasks * Update rqd and spi_cue to use new protos * Rename top level Allocation object to AllocationEntity and AllocationInterface

2018-10-03

Initial GRPC setup for cue3 (#3) This is an initial commit showing the general process of how we are adding in gRPC. - Add grpc servers to cue3bot and rqd - Add cue and rqd proto files in cue3bot/src/main/proto - Add grpc applicationContext to spring - Switch Facility to using gRPC - Update spi_cue to use gRPC and add tests * Cleaning up whitespace * remove todo question