- Commands unavailable - target is offline +
+ Commands unavailable
+{commandCapabilityError}
$ {output.command}
- $ {output.command}
+ {output.output}
{output.output}
- diff --git a/frontend/src/components/TargetTable/TargetTable.css b/frontend/src/components/TargetTable/TargetTable.css index 3e4fb1d..db1451d 100644 --- a/frontend/src/components/TargetTable/TargetTable.css +++ b/frontend/src/components/TargetTable/TargetTable.css @@ -181,11 +181,6 @@ margin-bottom: 0; } -.command-transport-indicator { - margin-bottom: 0.75rem; - font-size: 0.875rem; -} - .commands-unavailable { padding: 1rem; border: 1px solid var(--color-border); From 7b4dd9196c2bc546fc92faa8cd35c6730ea79a38 Mon Sep 17 00:00:00 2001 From: Gerrri <28703799+Gerrri@users.noreply.github.com> Date: Thu, 26 Mar 2026 15:39:45 +0100 Subject: [PATCH 13/20] refactor(frontend): move clear action into terminal header --- .../components/CommandPanel/CommandPanel.css | 21 +++++----- .../components/CommandPanel/CommandPanel.tsx | 14 +------ .../components/CommandPanel/OutputViewer.tsx | 39 +++++++++++++++---- 3 files changed, 42 insertions(+), 32 deletions(-) diff --git a/frontend/src/components/CommandPanel/CommandPanel.css b/frontend/src/components/CommandPanel/CommandPanel.css index 9f168fb..040c171 100644 --- a/frontend/src/components/CommandPanel/CommandPanel.css +++ b/frontend/src/components/CommandPanel/CommandPanel.css @@ -14,17 +14,6 @@ min-height: 150px; } -.command-panel-header { - display: flex; - justify-content: space-between; - align-items: center; - margin-bottom: 1rem; -} - -.command-panel-header--actions { - justify-content: flex-end; -} - .btn-clear { padding: 0.25rem 0.75rem; font-size: 0.75rem; @@ -40,6 +29,16 @@ color: var(--color-text); } +.btn-clear-terminal { + border-color: #4b5563; + color: #d1d5db; +} + +.btn-clear-terminal:hover { + background-color: #374151; + color: #f9fafb; +} + /* Loading Spinner */ .loading-spinner { display: flex; diff --git a/frontend/src/components/CommandPanel/CommandPanel.tsx b/frontend/src/components/CommandPanel/CommandPanel.tsx index 6747e54..be81379 100644 --- a/frontend/src/components/CommandPanel/CommandPanel.tsx +++ b/frontend/src/components/CommandPanel/CommandPanel.tsx @@ -139,18 +139,6 @@ export function CommandPanel({ return (
No command output yet. Execute a command to see results.
++ No command output yet. Execute a command to see results. +
$ {output.command}
{preset.description}
- )}| Name | From a2138214e1776eb7b42abd460796690152046ba9 Mon Sep 17 00:00:00 2001 From: Gerrri <28703799+Gerrri@users.noreply.github.com> Date: Thu, 26 Mar 2026 16:21:09 +0100 Subject: [PATCH 15/20] chore(release): bump version to 0.1.5 --- backend/app/main.py | 2 +- frontend/package-lock.json | 4 ++-- frontend/package.json | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/backend/app/main.py b/backend/app/main.py index 7803572..2447e29 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -299,7 +299,7 @@ def create_app() -> FastAPI: app = FastAPI( title="Labgrid Dashboard API", description="REST API for Labgrid Dashboard - Monitor and interact with DUTs", - version="0.1.4", + version="0.1.5", lifespan=lifespan, ) diff --git a/frontend/package-lock.json b/frontend/package-lock.json index 4d6eb47..1e54241 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -1,12 +1,12 @@ { "name": "labgrid-dashboard-frontend", - "version": "0.1.4", + "version": "0.1.5", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "labgrid-dashboard-frontend", - "version": "0.1.4", + "version": "0.1.5", "dependencies": { "axios": "^1.7.0", "react": "^19.2.0", diff --git a/frontend/package.json b/frontend/package.json index 4eb7bf7..65bc7c1 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -1,7 +1,7 @@ { "name": "labgrid-dashboard-frontend", "private": true, - "version": "0.1.4", + "version": "0.1.5", "type": "module", "scripts": { "dev": "vite", From fc7df18299f367c79bac8117eb95c9575c4db93d Mon Sep 17 00:00:00 2001 From: Gerrri <28703799+Gerrri@users.noreply.github.com> Date: Thu, 26 Mar 2026 17:10:41 +0100 Subject: [PATCH 16/20] fix(backend): address review findings for scheduling and resources --- backend/app/services/exporter_ssh_runtime.py | 4 +- backend/app/services/labgrid_client.py | 95 +++++++++- backend/app/services/scheduler_service.py | 188 ++++++++++++++----- backend/tests/test_exporter_ssh_runtime.py | 12 +- backend/tests/test_labgrid_client.py | 59 ++++++ backend/tests/test_scheduler_service.py | 83 +++++++- 6 files changed, 386 insertions(+), 55 deletions(-) diff --git a/backend/app/services/exporter_ssh_runtime.py b/backend/app/services/exporter_ssh_runtime.py index 0cc1da5..be49797 100644 --- a/backend/app/services/exporter_ssh_runtime.py +++ b/backend/app/services/exporter_ssh_runtime.py @@ -542,7 +542,9 @@ def main(): raise SystemExit(255) rewritten_args = rewrite_password_args(sys.argv[1:]) - os.execv(sshpass, [sshpass, "-p", password, real_ssh, *rewritten_args]) + env = os.environ.copy() + env["SSHPASS"] = password + os.execvpe(sshpass, [sshpass, "-e", real_ssh, *rewritten_args], env) if __name__ == "__main__": diff --git a/backend/app/services/labgrid_client.py b/backend/app/services/labgrid_client.py index dbb5c2f..89e7e99 100644 --- a/backend/app/services/labgrid_client.py +++ b/backend/app/services/labgrid_client.py @@ -634,11 +634,42 @@ def _get_place_resource_entries( """Get all resource entries that belong to a coordinator place.""" place_data = self._places_cache.get(place_name, {}) exporters = self._get_place_exporters(place_name, place_data) + matched_resources = self._get_place_matched_resources(place_data) entries: List[Tuple[str, str, Dict[str, Any]]] = [] + seen_entries: set[Tuple[str, str]] = set() + if matched_resources: + for exporter_name, resource_key in matched_resources: + exporter_resources = self._resources_cache.get(exporter_name, {}) + if resource_key is None: + for res_type, res_data in exporter_resources.items(): + entry_key = (exporter_name, res_type) + if entry_key in seen_entries: + continue + seen_entries.add(entry_key) + entries.append((exporter_name, res_type, res_data)) + continue + + res_data = exporter_resources.get(resource_key) + if res_data is None: + continue + + entry_key = (exporter_name, resource_key) + if entry_key in seen_entries: + continue + seen_entries.add(entry_key) + entries.append((exporter_name, resource_key, res_data)) + + if entries: + return entries + for exporter_name in exporters: exporter_resources = self._resources_cache.get(exporter_name, {}) for res_type, res_data in exporter_resources.items(): + entry_key = (exporter_name, res_type) + if entry_key in seen_entries: + continue + seen_entries.add(entry_key) entries.append((exporter_name, res_type, res_data)) return entries @@ -668,10 +699,72 @@ def _get_place_exporters( return exporters + def _get_place_matched_resources( + self, place_data: Dict[str, Any] + ) -> List[Tuple[str, Optional[str]]]: + """Resolve exporter/resource pairs from coordinator match entries.""" + matches: List[Tuple[str, Optional[str]]] = [] + for match in place_data.get("matches", []): + resolved = self._extract_match_resource(match) + if resolved and resolved not in matches: + matches.append(resolved) + return matches + + def _extract_match_resource( + self, match: Any + ) -> Optional[Tuple[str, Optional[str]]]: + """Best-effort exporter/resource extraction from a labgrid match entry.""" + if isinstance(match, str): + parts = [part for part in match.split("/") if part] + if not parts: + return None + exporter_name = parts[0] + resource_key = "/".join(parts[1:]) or None + return (exporter_name, resource_key) + + exporter_name = self._extract_match_exporter(match) + if not exporter_name: + return None + + resource_key = self._extract_match_resource_key(match, exporter_name) + return (exporter_name, resource_key) + + def _extract_match_resource_key( + self, match: Any, exporter_name: str + ) -> Optional[str]: + """Extract the resource portion from a non-string match entry.""" + raw_resource: Optional[str] = None + + if isinstance(match, dict): + for key in ("resource", "resource_key", "path", "match"): + value = match.get(key) + if isinstance(value, str) and value: + raw_resource = value + break + elif isinstance(match, (list, tuple)): + for value in match: + if isinstance(value, str) and value.startswith(f"{exporter_name}/"): + raw_resource = value + break + else: + for attr in ("resource", "resource_key", "path", "match"): + value = getattr(match, attr, None) + if isinstance(value, str) and value: + raw_resource = value + break + + if not raw_resource: + return None + + if raw_resource.startswith(f"{exporter_name}/"): + raw_resource = raw_resource[len(exporter_name) + 1 :] + + return raw_resource.strip("/") or None + def _extract_match_exporter(self, match: Any) -> Optional[str]: """Best-effort exporter extraction from a labgrid place match entry.""" if isinstance(match, str): - return match + return match.split("/", 1)[0] if match else None if isinstance(match, dict): for key in ("exporter", "name"): diff --git a/backend/app/services/scheduler_service.py b/backend/app/services/scheduler_service.py index 1c8d520..f015284 100644 --- a/backend/app/services/scheduler_service.py +++ b/backend/app/services/scheduler_service.py @@ -10,9 +10,10 @@ import asyncio import logging +from dataclasses import dataclass from datetime import datetime, timezone from copy import deepcopy -from typing import Callable, Dict, List, Optional, Set +from typing import Callable, Dict, List, Optional, Set, Union from app.models.target import ScheduledCommand, ScheduledCommandOutput @@ -22,6 +23,15 @@ SCHEDULER_ERROR_BACKOFF_MAX = 60 +@dataclass(frozen=True) +class _ScheduledCommandRegistration: + """Internal scheduler registration for a preset-scoped command.""" + + key: str + preset_id: str + command: ScheduledCommand + + class SchedulerService: """Service for executing scheduled commands periodically with preset support.""" @@ -29,11 +39,12 @@ def __init__(self): """Initialize the scheduler service.""" # All unique scheduled commands from all presets (for display in UI) self._all_commands: List[ScheduledCommand] = [] + self._command_registrations: List[_ScheduledCommandRegistration] = [] # Scheduled commands per preset: preset_id -> List[ScheduledCommand] self._preset_commands: Dict[str, List[ScheduledCommand]] = {} - # Latest outputs: command_name -> target_name -> output + # Latest outputs keyed by internal registration key -> target_name -> output self._outputs: Dict[str, Dict[str, ScheduledCommandOutput]] = {} - # Running tasks for each command + # Running tasks keyed by internal registration key self._tasks: Dict[str, asyncio.Task] = {} # Callback for executing commands on targets self._execute_callback: Optional[Callable] = None @@ -58,12 +69,20 @@ def set_commands(self, commands: List[ScheduledCommand]) -> None: commands: List of scheduled commands to execute. """ self._all_commands = commands + self._command_registrations = [ + _ScheduledCommandRegistration( + key=cmd.name, + preset_id="basic", + command=cmd, + ) + for cmd in commands + ] # Treat all commands as belonging to a "basic" preset self._preset_commands = {"basic": commands} # Initialize output storage for each command - for cmd in commands: - if cmd.name not in self._outputs: - self._outputs[cmd.name] = {} + self._outputs = { + registration.key: {} for registration in self._command_registrations + } logger.info(f"Configured {len(commands)} scheduled commands (legacy mode)") def set_preset_commands( @@ -76,16 +95,27 @@ def set_preset_commands( """ self._preset_commands = preset_commands - # Build list of all unique commands for backwards compatibility + # Build registrations for every preset-scoped command while preserving + # a unique display-name list for the existing UI/API surface. seen_names: Set[str] = set() self._all_commands = [] - for commands in preset_commands.values(): - for cmd in commands: + self._command_registrations = [] + for preset_id, commands in preset_commands.items(): + for index, cmd in enumerate(commands): + self._command_registrations.append( + _ScheduledCommandRegistration( + key=self._build_registration_key(preset_id, cmd, index), + preset_id=preset_id, + command=cmd, + ) + ) if cmd.name not in seen_names: seen_names.add(cmd.name) self._all_commands.append(cmd) - if cmd.name not in self._outputs: - self._outputs[cmd.name] = {} + self._outputs = { + registration.key: self._outputs.get(registration.key, {}) + for registration in self._command_registrations + } total_commands = sum(len(cmds) for cmds in preset_commands.values()) logger.info( @@ -132,8 +162,8 @@ async def start(self) -> None: logger.info("Scheduler service starting...") # Start a task for each unique scheduled command - for cmd in self._all_commands: - await self._start_command_task(cmd) + for registration in self._command_registrations: + await self._start_command_task(registration) logger.info(f"Scheduler service started with {len(self._tasks)} tasks") @@ -183,33 +213,82 @@ def get_outputs_for_target( Dictionary of command_name -> output for the target. """ result = {} - for cmd_name, targets in self._outputs.items(): + active_preset_id = None + if self._get_target_preset_callback: + active_preset_id = self._get_target_preset_callback(target_name) + + for registration in self._command_registrations: + if ( + active_preset_id is not None + and registration.preset_id != active_preset_id + ): + continue + + targets = self._outputs.get(registration.key, {}) if target_name in targets: - result[cmd_name] = targets[target_name] + result[registration.command.name] = targets[target_name] return result def get_all_outputs(self) -> Dict[str, Dict[str, ScheduledCommandOutput]]: """Get all outputs for all commands and targets. Returns: - Nested dictionary: command_name -> target_name -> output + Nested dictionary keyed by internal scheduler command key. """ return deepcopy(self._outputs) - async def _start_command_task(self, cmd: ScheduledCommand) -> None: + def _build_registration_key( + self, + preset_id: str, + cmd: ScheduledCommand, + index: int, + ) -> str: + """Build a stable internal key for a preset-scoped scheduled command.""" + return f"{preset_id}:{index}:{cmd.name}" + + def _resolve_registration( + self, + command: Union[ScheduledCommand, _ScheduledCommandRegistration], + ) -> _ScheduledCommandRegistration: + """Resolve an internal registration for a scheduled command input.""" + if isinstance(command, _ScheduledCommandRegistration): + return command + + for registration in self._command_registrations: + if registration.command is command: + return registration + + return _ScheduledCommandRegistration( + key=command.name, + preset_id="basic", + command=command, + ) + + async def _start_command_task( + self, + command: Union[ScheduledCommand, _ScheduledCommandRegistration], + ) -> None: """Start the periodic execution task for a command.""" - if cmd.name in self._tasks: + registration = self._resolve_registration(command) + if registration.key in self._tasks: return # Already running - task = asyncio.create_task(self._run_command_loop(cmd)) - self._tasks[cmd.name] = task + task = asyncio.create_task(self._run_command_loop(registration)) + self._tasks[registration.key] = task logger.info( - f"Started scheduler task for '{cmd.name}' (interval: {cmd.interval_seconds}s)" + "Started scheduler task for '%s' in preset '%s' (interval: %ss)", + registration.command.name, + registration.preset_id, + registration.command.interval_seconds, ) - async def _run_command_loop(self, cmd: ScheduledCommand) -> None: + async def _run_command_loop( + self, + command: Union[ScheduledCommand, _ScheduledCommandRegistration], + ) -> None: """Run the periodic execution loop for a command.""" - logger.debug(f"Command loop started for '{cmd.name}'") + registration = self._resolve_registration(command) + logger.debug("Command loop started for '%s'", registration.command.name) retry_delay = SCHEDULER_ERROR_BACKOFF_INITIAL run_immediately = True @@ -218,19 +297,25 @@ async def _run_command_loop(self, cmd: ScheduledCommand) -> None: if run_immediately: run_immediately = False else: - await asyncio.sleep(cmd.interval_seconds) + await asyncio.sleep(registration.command.interval_seconds) if not self._running: break - await self._execute_on_targets_with_preset(cmd) + await self._execute_on_targets_with_preset(registration) retry_delay = SCHEDULER_ERROR_BACKOFF_INITIAL except asyncio.CancelledError: - logger.debug(f"Command loop cancelled for '{cmd.name}'") + logger.debug( + "Command loop cancelled for '%s'", registration.command.name + ) break except Exception as e: - logger.error(f"Error in command loop for '{cmd.name}': {e}") + logger.error( + "Error in command loop for '%s': %s", + registration.command.name, + e, + ) await asyncio.sleep(retry_delay) retry_delay = self._get_next_retry_delay(retry_delay) @@ -238,7 +323,10 @@ def _get_next_retry_delay(self, current_delay: int) -> int: """Compute the next retry delay with an exponential backoff cap.""" return min(current_delay * 2, SCHEDULER_ERROR_BACKOFF_MAX) - async def _execute_on_targets_with_preset(self, cmd: ScheduledCommand) -> None: + async def _execute_on_targets_with_preset( + self, + command: Union[ScheduledCommand, _ScheduledCommandRegistration], + ) -> None: """Execute a command on targets that have this command in their preset. Scheduled commands run on ALL targets except offline ones. @@ -248,8 +336,10 @@ async def _execute_on_targets_with_preset(self, cmd: ScheduledCommand) -> None: commands try to execute on the same target simultaneously. Args: - cmd: The scheduled command to execute. + command: The scheduled command or internal registration to execute. """ + registration = self._resolve_registration(command) + cmd = registration.command if not self._execute_callback or not self._get_targets_callback: logger.warning("Callbacks not configured, skipping execution") return @@ -272,7 +362,7 @@ async def _execute_on_targets_with_preset(self, cmd: ScheduledCommand) -> None: continue # Check if this command applies to this target's preset - if not self._should_execute_on_target(cmd, target.name): + if not self._should_execute_on_target(registration, target.name): logger.info( f"Skipping '{cmd.name}' on '{target.name}': command not in target's preset" ) @@ -317,9 +407,9 @@ async def _execute_on_targets_with_preset(self, cmd: ScheduledCommand) -> None: execution_transport=execution_transport, ) - if cmd.name not in self._outputs: - self._outputs[cmd.name] = {} - self._outputs[cmd.name][target.name] = scheduled_output + if registration.key not in self._outputs: + self._outputs[registration.key] = {} + self._outputs[registration.key][target.name] = scheduled_output # Notify listeners (e.g., WebSocket clients) if self._notify_callback: @@ -348,31 +438,27 @@ async def _execute_on_targets_with_preset(self, cmd: ScheduledCommand) -> None: ) def _should_execute_on_target( - self, cmd: ScheduledCommand, target_name: str + self, + command: Union[ScheduledCommand, _ScheduledCommandRegistration], + target_name: str, ) -> bool: """Check if a command should be executed on a target based on its preset. Args: - cmd: The scheduled command. + command: The scheduled command or internal registration. target_name: The target name. Returns: True if the command should be executed on the target. """ + registration = self._resolve_registration(command) # If no preset callback is configured, execute on all targets (legacy mode) if not self._get_target_preset_callback: return True # Get the target's preset preset_id = self._get_target_preset_callback(target_name) - - # Check if the command exists in this preset's scheduled commands - preset_commands = self._preset_commands.get(preset_id, []) - for preset_cmd in preset_commands: - if preset_cmd.name == cmd.name: - return True - - return False + return preset_id == registration.preset_id async def execute_now(self, command_name: str) -> bool: """Manually trigger immediate execution of a scheduled command. @@ -383,11 +469,17 @@ async def execute_now(self, command_name: str) -> bool: Returns: True if execution was triggered, False if command not found. """ - for cmd in self._all_commands: - if cmd.name == command_name: - await self._execute_on_targets_with_preset(cmd) - return True - return False + matched = [ + registration + for registration in self._command_registrations + if registration.command.name == command_name + ] + if not matched: + return False + + for registration in matched: + await self._execute_on_targets_with_preset(registration) + return True # Legacy method - kept for backwards compatibility async def _execute_on_all_targets(self, cmd: ScheduledCommand) -> None: diff --git a/backend/tests/test_exporter_ssh_runtime.py b/backend/tests/test_exporter_ssh_runtime.py index f046492..ed1461a 100644 --- a/backend/tests/test_exporter_ssh_runtime.py +++ b/backend/tests/test_exporter_ssh_runtime.py @@ -125,7 +125,10 @@ def test_exporter_ssh_wrapper_uses_sshpass_for_password_exporters( _write_executable( fake_bin / "sshpass", - "#!/bin/sh\nprintf '%s\\n' \"$@\"\n", + "#!/bin/sh\n" + "test -n \"$SSHPASS\" || exit 2\n" + "printf 'SSHPASS_SET\\n'\n" + "printf '%s\\n' \"$@\"\n", ) _write_executable( fake_bin / "ssh-real", @@ -158,8 +161,11 @@ def test_exporter_ssh_wrapper_uses_sshpass_for_password_exporters( ) output = result.stdout - assert "-p" in output - assert "s3cr3t" in output + output_lines = output.splitlines() + assert "SSHPASS_SET" in output + assert "-e" in output_lines + assert "-p" not in output_lines + assert all("s3cr3t" not in line for line in output_lines) assert "PasswordAuthentication=no" not in output assert "PasswordAuthentication=yes" in output assert "exporter-password" in output diff --git a/backend/tests/test_labgrid_client.py b/backend/tests/test_labgrid_client.py index b3c1c81..8b33431 100644 --- a/backend/tests/test_labgrid_client.py +++ b/backend/tests/test_labgrid_client.py @@ -367,6 +367,65 @@ async def test_get_places_uses_place_matches_for_resources( assert places[0].web_url == "http://example.invalid" assert places[0].resources[0].type == "NetworkSerialPort" + def test_get_place_resource_entries_only_returns_matched_resources( + self, connected_client: LabgridClient + ): + """Only resources matched to the place should be exposed for transport resolution.""" + connected_client._resources_cache = { + "exporter-shared": { + "console/NetworkSerialPort": { + "cls": "NetworkSerialPort", + "params": {"host": "192.168.1.100", "port": 5000}, + "acquired": None, + "avail": True, + }, + "ssh/NetworkService": { + "cls": "NetworkService", + "params": {"address": "192.168.1.100"}, + "acquired": None, + "avail": True, + }, + } + } + connected_client._places_cache = { + "place-serial": { + "name": "place-serial", + "acquired": None, + "comment": "", + "tags": {}, + "matches": ["exporter-shared/console/NetworkSerialPort"], + }, + "place-ssh": { + "name": "place-ssh", + "acquired": None, + "comment": "", + "tags": {}, + "matches": ["exporter-shared/ssh/NetworkService"], + }, + } + + serial_entries = connected_client.get_place_resource_entries("place-serial") + ssh_entries = connected_client.get_place_resource_entries("place-ssh") + + assert serial_entries == [ + ( + "exporter-shared", + "console/NetworkSerialPort", + connected_client._resources_cache["exporter-shared"][ + "console/NetworkSerialPort" + ], + ) + ] + assert ssh_entries == [ + ( + "exporter-shared", + "ssh/NetworkService", + connected_client._resources_cache["exporter-shared"][ + "ssh/NetworkService" + ], + ) + ] + @pytest.mark.asyncio async def test_refresh_cache_keeps_empty_params_resources_online( self, connected_client: LabgridClient diff --git a/backend/tests/test_scheduler_service.py b/backend/tests/test_scheduler_service.py index f93e73e..f1028bb 100644 --- a/backend/tests/test_scheduler_service.py +++ b/backend/tests/test_scheduler_service.py @@ -104,6 +104,7 @@ def test_init(self, scheduler): # Arrange & Act - created by fixture # Assert assert scheduler._all_commands == [] + assert scheduler._command_registrations == [] assert scheduler._preset_commands == {} assert scheduler._outputs == {} assert scheduler._tasks == {} @@ -121,6 +122,7 @@ def test_set_commands_legacy(self, scheduler, sample_commands): # Assert assert scheduler._all_commands == sample_commands + assert len(scheduler._command_registrations) == 2 assert scheduler._preset_commands == {"basic": sample_commands} assert "uptime" in scheduler._outputs assert "free" in scheduler._outputs @@ -158,8 +160,10 @@ def test_set_preset_commands(self, scheduler): # Assert assert scheduler._preset_commands == preset_commands assert len(scheduler._all_commands) == 2 # uptime and sensors (unique) - assert "uptime" in scheduler._outputs - assert "sensors" in scheduler._outputs + assert len(scheduler._command_registrations) == 3 + assert "basic:0:uptime" in scheduler._outputs + assert "advanced:0:uptime" in scheduler._outputs + assert "advanced:1:sensors" in scheduler._outputs def test_set_callbacks(self, scheduler): """Test setting callbacks.""" @@ -227,6 +231,22 @@ def test_get_commands_for_preset(self, scheduler): def test_get_outputs_for_target(self, scheduler): """Test getting outputs for a specific target.""" # Arrange + scheduler.set_commands( + [ + ScheduledCommand( + name="uptime", + command="uptime", + interval_seconds=5, + description="", + ), + ScheduledCommand( + name="free", + command="free -h", + interval_seconds=10, + description="", + ), + ] + ) scheduler._outputs = { "uptime": { "dut-1": ScheduledCommandOutput( @@ -481,6 +501,65 @@ async def test_execute_on_targets_with_preset_filtering( # dut-3 is offline anyway assert execute_callback.call_count == 2 + @pytest.mark.asyncio + async def test_execute_on_targets_supports_duplicate_command_names_across_presets( + self, scheduler + ): + """Different presets may reuse the same display name without collisions.""" + basic_cmd = ScheduledCommand( + name="Version", + command="cat /etc/version", + interval_seconds=5, + description="Basic version", + ) + advanced_cmd = ScheduledCommand( + name="Version", + command="cat /etc/os-release", + interval_seconds=30, + description="Advanced version", + ) + scheduler.set_preset_commands( + {"basic": [basic_cmd], "advanced": [advanced_cmd]} + ) + + targets = [ + Target(name="dut-basic", status="available", acquired_by=None, resources=[]), + Target( + name="dut-advanced", + status="available", + acquired_by=None, + resources=[], + ), + ] + execute_callback = AsyncMock( + side_effect=lambda target_name, command: (f"{target_name}:{command}", 0) + ) + scheduler.set_execute_callback(execute_callback) + scheduler.set_get_targets_callback(AsyncMock(return_value=targets)) + scheduler.set_get_target_preset_callback( + lambda name: "basic" if name == "dut-basic" else "advanced" + ) + + basic_registration, advanced_registration = scheduler._command_registrations + + await scheduler._execute_on_targets_with_preset(basic_registration) + await scheduler._execute_on_targets_with_preset(advanced_registration) + + assert execute_callback.await_args_list[0].args == ( + "dut-basic", + "cat /etc/version", + ) + assert execute_callback.await_args_list[1].args == ( + "dut-advanced", + "cat /etc/os-release", + ) + assert scheduler.get_outputs_for_target("dut-basic")["Version"].output == ( + "dut-basic:cat /etc/version" + ) + assert scheduler.get_outputs_for_target("dut-advanced")["Version"].output == ( + "dut-advanced:cat /etc/os-release" + ) + @pytest.mark.asyncio async def test_execute_on_targets_handles_execution_error( self, scheduler, sample_command, sample_target From 241b63ae81ad7d854a42ccc46bb4376caa0872d3 Mon Sep 17 00:00:00 2001 From: Gerrri <28703799+Gerrri@users.noreply.github.com> Date: Thu, 26 Mar 2026 17:12:27 +0100 Subject: [PATCH 17/20] chore(release): bump version to 0.1.6 --- backend/app/main.py | 2 +- frontend/package-lock.json | 4 ++-- frontend/package.json | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/backend/app/main.py b/backend/app/main.py index 2447e29..1e18d4f 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -299,7 +299,7 @@ def create_app() -> FastAPI: app = FastAPI( title="Labgrid Dashboard API", description="REST API for Labgrid Dashboard - Monitor and interact with DUTs", - version="0.1.5", + version="0.1.6", lifespan=lifespan, ) diff --git a/frontend/package-lock.json b/frontend/package-lock.json index 1e54241..5a5a902 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -1,12 +1,12 @@ { "name": "labgrid-dashboard-frontend", - "version": "0.1.5", + "version": "0.1.6", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "labgrid-dashboard-frontend", - "version": "0.1.5", + "version": "0.1.6", "dependencies": { "axios": "^1.7.0", "react": "^19.2.0", diff --git a/frontend/package.json b/frontend/package.json index 65bc7c1..13b8ca6 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -1,7 +1,7 @@ { "name": "labgrid-dashboard-frontend", "private": true, - "version": "0.1.5", + "version": "0.1.6", "type": "module", "scripts": { "dev": "vite", From 2bf2406aaa3ead60d0a97ed0a1e24a3a993fdab4 Mon Sep 17 00:00:00 2001 From: Gerrri <28703799+Gerrri@users.noreply.github.com> Date: Thu, 26 Mar 2026 20:19:14 +0100 Subject: [PATCH 18/20] fix(backend): validate scheduled commands and resolve wildcard matches --- README.md | 4 + backend/app/services/command_service.py | 26 +++ backend/app/services/labgrid_client.py | 157 ++++++++++++---- backend/commands.yaml | 20 +++ backend/tests/test_command_service_presets.py | 70 ++++++++ backend/tests/test_labgrid_client.py | 167 ++++++++++++++++++ 6 files changed, 412 insertions(+), 32 deletions(-) diff --git a/README.md b/README.md index 84816fd..1de1e52 100644 --- a/README.md +++ b/README.md @@ -409,6 +409,10 @@ presets: interval_seconds: 30 ``` +Scheduled command names must be unique within each preset. The scheduler uses the +display name as the column key in the UI, so duplicate names inside the same +preset are rejected during configuration loading. + **Preset Assignment:** - Targets are assigned to presets via the Settings icon (⚙️) in the expanded target view - Assignments are stored in `target_presets.json` diff --git a/backend/app/services/command_service.py b/backend/app/services/command_service.py index d625dbd..96392a9 100644 --- a/backend/app/services/command_service.py +++ b/backend/app/services/command_service.py @@ -108,6 +108,10 @@ def _load_presets_format(self, data: dict) -> None: ) for cmd in preset_data.get("scheduled_commands", []) ] + self._validate_unique_scheduled_command_names( + preset_id, + scheduled_commands, + ) auto_refresh = preset_data.get("auto_refresh_commands", []) command_execution = self._parse_command_execution_config( @@ -147,6 +151,27 @@ def _load_presets_format(self, data: dict) -> None: f"{total_scheduled} total scheduled commands" ) + def _validate_unique_scheduled_command_names( + self, + preset_id: str, + scheduled_commands: List[ScheduledCommand], + ) -> None: + """Reject duplicate scheduled command display names inside one preset.""" + seen_names: set[str] = set() + duplicate_names: set[str] = set() + + for command in scheduled_commands: + if command.name in seen_names: + duplicate_names.add(command.name) + seen_names.add(command.name) + + if duplicate_names: + duplicates = ", ".join(sorted(duplicate_names)) + raise ValueError( + "Duplicate scheduled command names are not allowed within " + f"preset '{preset_id}': {duplicates}" + ) + def _load_legacy_format(self, data: dict) -> None: """Load the legacy flat format (for backwards compatibility). @@ -173,6 +198,7 @@ def _load_legacy_format(self, data: dict) -> None: ) for cmd in data.get("scheduled_commands", []) ] + self._validate_unique_scheduled_command_names("basic", scheduled_commands) self._legacy_config = CommandsConfig( commands=commands, diff --git a/backend/app/services/labgrid_client.py b/backend/app/services/labgrid_client.py index 89e7e99..e72f8d7 100644 --- a/backend/app/services/labgrid_client.py +++ b/backend/app/services/labgrid_client.py @@ -10,6 +10,7 @@ import asyncio import contextlib +import fnmatch import logging import os import socket @@ -641,27 +642,21 @@ def _get_place_resource_entries( if matched_resources: for exporter_name, resource_key in matched_resources: exporter_resources = self._resources_cache.get(exporter_name, {}) - if resource_key is None: - for res_type, res_data in exporter_resources.items(): - entry_key = (exporter_name, res_type) - if entry_key in seen_entries: - continue - seen_entries.add(entry_key) - entries.append((exporter_name, res_type, res_data)) - continue - - res_data = exporter_resources.get(resource_key) - if res_data is None: - continue - - entry_key = (exporter_name, resource_key) - if entry_key in seen_entries: - continue - seen_entries.add(entry_key) - entries.append((exporter_name, resource_key, res_data)) - - if entries: - return entries + for resolved_key in self._resolve_matched_resource_keys( + exporter_resources, + resource_key, + ): + res_data = exporter_resources.get(resolved_key) + if res_data is None: + continue + + entry_key = (exporter_name, resolved_key) + if entry_key in seen_entries: + continue + seen_entries.add(entry_key) + entries.append((exporter_name, resolved_key, res_data)) + + return entries for exporter_name in exporters: exporter_resources = self._resources_cache.get(exporter_name, {}) @@ -715,18 +710,20 @@ def _extract_match_resource( ) -> Optional[Tuple[str, Optional[str]]]: """Best-effort exporter/resource extraction from a labgrid match entry.""" if isinstance(match, str): - parts = [part for part in match.split("/") if part] - if not parts: + exporter_name, resource_key = self._parse_string_match(match) + if not exporter_name: return None - exporter_name = parts[0] - resource_key = "/".join(parts[1:]) or None return (exporter_name, resource_key) exporter_name = self._extract_match_exporter(match) if not exporter_name: - return None + return self._parse_match_fallback(match) resource_key = self._extract_match_resource_key(match, exporter_name) + if resource_key is None: + fallback_exporter, fallback_resource_key = self._parse_match_fallback(match) + if fallback_exporter == exporter_name: + resource_key = fallback_resource_key return (exporter_name, resource_key) def _extract_match_resource_key( @@ -754,6 +751,9 @@ def _extract_match_resource_key( break if not raw_resource: + fallback_exporter, fallback_resource_key = self._parse_match_fallback(match) + if fallback_exporter == exporter_name: + return fallback_resource_key return None if raw_resource.startswith(f"{exporter_name}/"): @@ -764,27 +764,120 @@ def _extract_match_resource_key( def _extract_match_exporter(self, match: Any) -> Optional[str]: """Best-effort exporter extraction from a labgrid place match entry.""" if isinstance(match, str): - return match.split("/", 1)[0] if match else None + exporter_name, _ = self._parse_string_match(match) + return exporter_name if isinstance(match, dict): for key in ("exporter", "name"): value = match.get(key) - if isinstance(value, str): + if isinstance(value, str) and value and value != "*": return value - return None + fallback_exporter, _ = self._parse_match_fallback(match) + return fallback_exporter if isinstance(match, (list, tuple)): for value in match: if isinstance(value, str) and value in self._resources_cache: return value - return None + fallback_exporter, _ = self._parse_match_fallback(match) + return fallback_exporter for attr in ("exporter", "name"): value = getattr(match, attr, None) - if isinstance(value, str): + if isinstance(value, str) and value and value != "*": return value - return None + fallback_exporter, _ = self._parse_match_fallback(match) + return fallback_exporter + + def _parse_string_match(self, match: str) -> Tuple[Optional[str], Optional[str]]: + """Parse string-based labgrid matches, including wildcard variants.""" + parts = [part for part in match.split("/") if part] + if not parts: + return (None, None) + + exporter_index = self._find_exporter_index(parts) + if exporter_index is None: + return (None, None) + + exporter_name = parts[exporter_index] + resource_key = "/".join(parts[exporter_index + 1 :]).strip("/") or None + return (exporter_name, self._normalize_match_resource_pattern(resource_key)) + + def _parse_match_fallback( + self, match: Any + ) -> Tuple[Optional[str], Optional[str]]: + """Fallback parser for match objects whose useful data only exists in their repr().""" + for candidate in (str(match), repr(match)): + if not isinstance(candidate, str) or "/" not in candidate: + continue + + exporter_name, resource_key = self._parse_string_match(candidate) + if exporter_name: + return (exporter_name, resource_key) + + return (None, None) + + def _find_exporter_index(self, parts: List[str]) -> Optional[int]: + """Locate the exporter segment inside a match path.""" + for index, part in enumerate(parts): + if part in self._resources_cache: + return index + + non_wildcard_indices = [ + index for index, part in enumerate(parts) if part and part != "*" + ] + if not non_wildcard_indices: + return None + + if parts[0] == "*": + return non_wildcard_indices[0] + + return 0 + + def _normalize_match_resource_pattern( + self, resource_key: Optional[str] + ) -> Optional[str]: + """Normalize resource patterns from coordinator match strings.""" + if not resource_key: + return None + + normalized = resource_key.strip("/") + if normalized in {"", "*"}: + return None + + if normalized.startswith("default/"): + normalized = normalized[len("default/") :] + + return normalized or None + + def _resolve_matched_resource_keys( + self, + exporter_resources: Dict[str, Any], + resource_key: Optional[str], + ) -> List[str]: + """Resolve exact or wildcard resource patterns against cached resources.""" + if resource_key is None: + return list(exporter_resources.keys()) + + resolved_keys: List[str] = [] + for candidate_key in exporter_resources: + candidate_aliases = {candidate_key} + if "/" not in candidate_key: + candidate_aliases.add(f"default/{candidate_key}") + + if "*" in resource_key: + if any( + fnmatch.fnmatch(candidate_alias, resource_key) + for candidate_alias in candidate_aliases + ): + resolved_keys.append(candidate_key) + continue + + if resource_key in candidate_aliases: + resolved_keys.append(candidate_key) + + return resolved_keys async def acquire_target(self, place_name: str) -> bool: """Acquire a target for command execution. diff --git a/backend/commands.yaml b/backend/commands.yaml index 5305ae2..3cea1db 100644 --- a/backend/commands.yaml +++ b/backend/commands.yaml @@ -134,6 +134,11 @@ presets: - name: "System Time" command: "date" description: "Current system time" + scheduled_commands: + - name: "Uptime" + command: "uptime -p" + interval_seconds: 180 + description: "System uptime (updates every 3 minutes)" staging_serial_fallback: name: "Staging Serial With SSH Fallback" @@ -154,6 +159,11 @@ presets: - name: "System Time" command: "date" description: "Current system time" + scheduled_commands: + - name: "Uptime" + command: "uptime -p" + interval_seconds: 180 + description: "System uptime (updates every 3 minutes)" staging_ssh_key: name: "Staging SSH With Key" @@ -170,6 +180,11 @@ presets: - name: "System Time" command: "date" description: "Current system time" + scheduled_commands: + - name: "Uptime" + command: "uptime -p" + interval_seconds: 180 + description: "System uptime (updates every 3 minutes)" staging_ssh_password: name: "Staging SSH With Password" @@ -184,3 +199,8 @@ presets: - name: "System Time" command: "date" description: "Current system time" + scheduled_commands: + - name: "Uptime" + command: "uptime -p" + interval_seconds: 180 + description: "System uptime (updates every 3 minutes)" diff --git a/backend/tests/test_command_service_presets.py b/backend/tests/test_command_service_presets.py index 3ce7cf4..cfad5c3 100644 --- a/backend/tests/test_command_service_presets.py +++ b/backend/tests/test_command_service_presets.py @@ -191,6 +191,45 @@ def test_get_commands_for_preset(self, presets_yaml_content: str): finally: os.unlink(f.name) + def test_duplicate_scheduled_command_names_in_same_preset_are_rejected( + self, + caplog: pytest.LogCaptureFixture, + ): + """Duplicate scheduled command display names inside one preset should fail loading.""" + duplicate_yaml_content = """ +default_preset: basic + +presets: + basic: + name: "Basic" + description: "Standard Linux commands" + scheduled_commands: + - name: "Version" + command: "cat /etc/version" + interval_seconds: 60 + description: "OS version" + - name: "Version" + command: "cat /etc/os-release" + interval_seconds: 120 + description: "OS release" +""" + with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: + f.write(duplicate_yaml_content) + f.flush() + + try: + service = CommandService(commands_file=f.name) + service.load() + + assert service.get_presets() == [] + assert service.get_scheduled_commands() == [] + assert ( + "Duplicate scheduled command names are not allowed within preset" + in caplog.text + ) + finally: + os.unlink(f.name) + def test_get_scheduled_commands_for_preset(self, presets_yaml_content: str): """Test getting scheduled commands for a specific preset.""" with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: @@ -208,6 +247,37 @@ def test_get_scheduled_commands_for_preset(self, presets_yaml_content: str): finally: os.unlink(f.name) + def test_duplicate_scheduled_command_names_in_legacy_format_are_rejected( + self, + caplog: pytest.LogCaptureFixture, + ): + """Duplicate scheduled command display names should also fail in legacy mode.""" + duplicate_yaml_content = """ +scheduled_commands: + - name: "Version" + command: "cat /etc/version" + interval_seconds: 60 + - name: "Version" + command: "cat /etc/os-release" + interval_seconds: 120 +""" + with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: + f.write(duplicate_yaml_content) + f.flush() + + try: + service = CommandService(commands_file=f.name) + service.load() + + assert service.get_presets() == [] + assert service.get_scheduled_commands() == [] + assert ( + "Duplicate scheduled command names are not allowed within preset" + in caplog.text + ) + finally: + os.unlink(f.name) + def test_get_auto_refresh_commands_for_preset(self, presets_yaml_content: str): """Test getting auto-refresh commands for a specific preset.""" with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: diff --git a/backend/tests/test_labgrid_client.py b/backend/tests/test_labgrid_client.py index 8b33431..6d3570e 100644 --- a/backend/tests/test_labgrid_client.py +++ b/backend/tests/test_labgrid_client.py @@ -123,6 +123,20 @@ async def test_resolve_hostname_to_ip_returns_none_for_invalid( class TestLabgridClientWithMockedSession: """Test cases with mocked labgrid ClientSession.""" + class _WildcardMatch: + """Simple stand-in for labgrid ResourceMatch repr-based wildcard objects.""" + + exporter = "*" + name = None + + def __init__(self, pattern: str): + self._pattern = pattern + + def __str__(self) -> str: + return self._pattern + + __repr__ = __str__ + def _create_mock_resource_entry(self, cls_name, params, acquired, avail): """Create a mock ResourceEntry object that mimics labgrid's structure.""" mock_entry = MagicMock() @@ -426,6 +440,159 @@ def test_get_place_resource_entries_only_returns_matched_resources( ) ] + def test_get_place_resource_entries_resolve_wildcard_exporter_match( + self, connected_client: LabgridClient + ): + """Wildcard matches should still resolve the real exporter name.""" + connected_client._resources_cache = { + "exporter-shared": { + "console/NetworkSerialPort": { + "cls": "NetworkSerialPort", + "params": {"host": "192.168.1.100", "port": 5000}, + "acquired": None, + "avail": True, + }, + "ssh/NetworkService": { + "cls": "NetworkService", + "params": {"address": "192.168.1.100"}, + "acquired": None, + "avail": True, + }, + } + } + connected_client._places_cache = { + "custom-place": { + "name": "custom-place", + "acquired": None, + "comment": "", + "tags": {}, + "matches": ["*/exporter-shared/*"], + } + } + + entries = connected_client.get_place_resource_entries("custom-place") + + assert entries == [ + ( + "exporter-shared", + "console/NetworkSerialPort", + connected_client._resources_cache["exporter-shared"][ + "console/NetworkSerialPort" + ], + ), + ( + "exporter-shared", + "ssh/NetworkService", + connected_client._resources_cache["exporter-shared"][ + "ssh/NetworkService" + ], + ), + ] + + def test_get_place_resource_entries_resolve_specific_resource_with_wildcard_prefix( + self, connected_client: LabgridClient + ): + """Wildcard-prefixed specific matches should still scope to the exact resource.""" + connected_client._resources_cache = { + "exporter-shared": { + "console/NetworkSerialPort": { + "cls": "NetworkSerialPort", + "params": {"host": "192.168.1.100", "port": 5000}, + "acquired": None, + "avail": True, + }, + "ssh/NetworkService": { + "cls": "NetworkService", + "params": {"address": "192.168.1.100"}, + "acquired": None, + "avail": True, + }, + } + } + connected_client._places_cache = { + "custom-place": { + "name": "custom-place", + "acquired": None, + "comment": "", + "tags": {}, + "matches": ["*/exporter-shared/console/NetworkSerialPort"], + } + } + + entries = connected_client.get_place_resource_entries("custom-place") + + assert entries == [ + ( + "exporter-shared", + "console/NetworkSerialPort", + connected_client._resources_cache["exporter-shared"][ + "console/NetworkSerialPort" + ], + ) + ] + + def test_parse_string_match_resolves_staging_wildcard_exporter( + self, connected_client: LabgridClient + ): + """The staging match syntax */exporter/* should resolve exporter and wildcard resource.""" + connected_client._resources_cache = {"exporter-1": {}} + + exporter_name, resource_key = connected_client._parse_string_match( + "*/exporter-1/*" + ) + + assert exporter_name == "exporter-1" + assert resource_key is None + + def test_get_place_resource_entries_resolve_wildcard_match_objects( + self, connected_client: LabgridClient + ): + """ResourceMatch-like objects should fall back to their string representation.""" + connected_client._resources_cache = { + "exporter-shared": { + "console/NetworkSerialPort": { + "cls": "NetworkSerialPort", + "params": {"host": "192.168.1.100", "port": 5000}, + "acquired": None, + "avail": True, + }, + "ssh/NetworkService": { + "cls": "NetworkService", + "params": {"address": "192.168.1.100"}, + "acquired": None, + "avail": True, + }, + } + } + connected_client._places_cache = { + "custom-place": { + "name": "custom-place", + "acquired": None, + "comment": "", + "tags": {}, + "matches": [self._WildcardMatch("*/exporter-shared/*")], + } + } + + entries = connected_client.get_place_resource_entries("custom-place") + + assert entries == [ + ( + "exporter-shared", + "console/NetworkSerialPort", + connected_client._resources_cache["exporter-shared"][ + "console/NetworkSerialPort" + ], + ), + ( + "exporter-shared", + "ssh/NetworkService", + connected_client._resources_cache["exporter-shared"][ + "ssh/NetworkService" + ], + ), + ] + @pytest.mark.asyncio async def test_refresh_cache_keeps_empty_params_resources_online( self, connected_client: LabgridClient From 22f0537a96599e86720e157c6ecb764ef308752a Mon Sep 17 00:00:00 2001 From: Gerrri <28703799+Gerrri@users.noreply.github.com> Date: Thu, 26 Mar 2026 20:19:22 +0100 Subject: [PATCH 19/20] fix(frontend): stabilize staging dev server connections --- docker-compose.yml | 8 ++++++-- frontend/public/env-config.js | 1 + frontend/src/hooks/useWebSocket.ts | 16 ++++++++++++++-- frontend/vite.config.ts | 13 ++++++++++++- 4 files changed, 33 insertions(+), 5 deletions(-) create mode 100644 frontend/public/env-config.js diff --git a/docker-compose.yml b/docker-compose.yml index 95a7b65..13d351a 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -69,8 +69,12 @@ services: ports: - "3000:3000" environment: - - VITE_API_URL=http://localhost:8000 - - VITE_WS_URL=ws://localhost:8000/api/ws + - VITE_API_URL=/api + - VITE_WS_URL=/api/ws + - VITE_API_PROXY_TARGET=http://backend:8000 + - VITE_HMR_HOST=localhost + - VITE_HMR_CLIENT_PORT=3000 + - VITE_HMR_PROTOCOL=ws - CHOKIDAR_USEPOLLING=true depends_on: - backend diff --git a/frontend/public/env-config.js b/frontend/public/env-config.js new file mode 100644 index 0000000..a006be1 --- /dev/null +++ b/frontend/public/env-config.js @@ -0,0 +1 @@ +window.ENV = window.ENV || {}; diff --git a/frontend/src/hooks/useWebSocket.ts b/frontend/src/hooks/useWebSocket.ts index ec68ec8..e3fa532 100644 --- a/frontend/src/hooks/useWebSocket.ts +++ b/frontend/src/hooks/useWebSocket.ts @@ -37,6 +37,7 @@ export function useWebSocket(options: UseWebSocketOptions = {}): UseWebSocketRes const wsRef = useRef
|---|