diff --git a/app/queue-server/README.md b/app/queue-server/README.md index 61578f6029..d71f867837 100644 --- a/app/queue-server/README.md +++ b/app/queue-server/README.md @@ -1,100 +1,110 @@ -# Java Bluesky Interface (JBI) +# Phoebus Queue Server Application -Prototype Java client for the [Bluesky QueueServer](https://blueskyproject.io/bluesky-queueserver/) REST API. -It includes: +A JavaFX-based client for the [Bluesky QueueServer](https://blueskyproject.io/bluesky-queueserver/) that provides a graphical interface for managing experiment queues, monitoring status, and editing plans at beamlines and scientific facilities. -* **BlueskyHttpClient** – thread-safe singleton with rate-limiting, automatic retries and JUL logging -* **BlueskyService** – one blocking call per API route -* **CLI / REPL** – *testing utilities only* -* **JavaFX UI** – the part you actually launch in normal use +## Features ---- +### Queue Management +- **View & Edit Queue**: See all queued plans with parameters, reorder items via drag-and-drop +- **Execute Plans**: Start, stop, pause, resume, and abort plan execution +- **Real-time Status**: Live updates via WebSocket connections showing queue state, running plans, and RE Manager status +- **History View**: Browse completed plans with execution results and metadata -## Prerequisites +### Plan Editing +- **Interactive Plan Editor**: Create and modify plans with type-safe parameter editing +- **Python Type Support**: Full support for Python types (strings, lists, dicts, booleans, numbers) +- **Schema Validation**: Parameters validated against plan schemas from the Queue Server +- **Live Preview**: See plan parameters as they will be sent to the server -* Java 17 -* Maven -* Running Bluesky HTTP Server at `http://localhost:60610` - *single-user API key `a` assumed below* +### Plan Viewer +- **Plan Details**: View plan parameters, metadata, and execution results +- **Parameter Display**: All parameters shown with correct Python syntax and types +- **Copy to Queue**: Duplicate plans with one click -```bash -# 1) Start RE Manager -start-re-manager --use-ipython-kernel=ON --zmq-publish-console=ON +### Console Monitor +- **Live Console Output**: Real-time streaming of Queue Server console output +- **WebSocket Support**: Efficient streaming via WebSocket connections (fallback to HTTP polling) +- **Autoscroll**: Automatically scroll to latest output with toggle control + +## Quick Start + +### Prerequisites -# 2) Start HTTP Server -QSERVER_HTTP_SERVER_SINGLE_USER_API_KEY=a \ - uvicorn --host localhost --port 60610 bluesky_httpserver.server:app -```` +- **Java 17** or later +- **Maven** (for building from source) +- **Bluesky Queue Server** running and accessible ---- +### Starting a Local Queue Server -## Configure +Use the provided Docker setup for local development: ```bash -export BLUESKY_API_KEY=a +cd services/bluesky-services +docker-compose --profile container-redis up -d ``` ---- +This starts: +- Bluesky Queue Server (RE Manager) on ports 60615/60625 +- HTTP Server REST API on port 60610 +- Redis database on port 6380 -## Build & run +For details, see [services/bluesky-services/README.md](../../services/bluesky-services/README.md) -```bash -mvn clean javafx:run -``` +### Configuration -### Verbose logging +Set environment variables to connect to your Queue Server: ```bash -mvn -Djava.util.logging.config.file=src/main/resources/logging.properties javafx:run -``` +# Queue Server HTTP address (default: http://localhost:60610) +export QSERVER_HTTP_SERVER_URI=http://localhost:60610 ---- +# API Key authentication +export QSERVER_HTTP_SERVER_API_KEY=a -## CLI / REPL (testing only) +# Or use a file containing the API key +export QSERVER_HTTP_SERVER_API_KEYFILE=~/.phoebus/qserver_api_key.txt +``` -| Tool | Start (quiet) | Start with request tracing (`FINE`) | -| -------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | -| **CLI** | `mvn -q -Dexec.mainClass=util.org.phoebus.applications.queueserver.RunEngineCli -Dexec.args="STATUS" exec:java` | `mvn -Djava.util.logging.config.file=src/main/resources/logging.properties -q -Dexec.mainClass=util.org.phoebus.applications.queueserver.RunEngineCli -Dexec.args="STATUS" exec:java` | -| **REPL** | `mvn -q -Dexec.mainClass=util.org.phoebus.applications.queueserver.RunEngineRepl exec:java` | `mvn -Djava.util.logging.config.file=src/main/resources/logging.properties -q -Dexec.mainClass=util.org.phoebus.applications.queueserver.RunEngineRepl -Dexec.args="STATUS" exec:java` | +### Building & Running -*CLI examples* +#### As Part of Phoebus ```bash -# list endpoints -mvn -q -Dexec.mainClass=com.jbi.util.RunEngineClili -Dexec.args="list" exec:java - -# start the queue -mvn -q -Dexec.mainClass=com.jbi.util.RunEngineClili -Dexec.args="QUEUE_START" exec:java +# From phoebus root directory +mvn clean install -DskipTests +cd phoebus-product/target +./phoebus ``` -`ENDPOINT [body]` accepts a JSON literal, `@file.json`, or `@-` for stdin. +Then open **Applications → Queue Server** from the menu. ---- +#### Standalone Build -## How logging works +```bash +# From queue-server directory +cd app/queue-server +mvn clean install +``` -* Logger name: **`com.jbi.bluesky`** -* Levels +## Configuration Options - * `INFO` – API errors - * `WARNING` – transport retries - * `FINE` – each HTTP call + latency -* Enable by passing JVM flag - `-Djava.util.logging.config.file=src/main/resources/logging.properties` +Configuration via **Edit → Preferences → Queue Server** or environment variables: ---- +| Preference | Environment Variable | Default | Description | +|-------------------|-----------------------------------|--------------------------|---------------------------------------| +| `queue_server_url`| `QSERVER_HTTP_SERVER_URI` | `http://localhost:60610` | Queue Server HTTP address | +| `api_key` | `QSERVER_HTTP_SERVER_API_KEY` | *(none)* | API key for authentication | +| `api_key_file` | `QSERVER_HTTP_SERVER_API_KEYFILE` | *(none)* | Path to file containing API key | +| `use_websockets` | *(none)* | `true` | Use WebSockets for streaming data | +| `connectTimeout` | *(none)* | `5000` | HTTP connection timeout (ms) | +| `debug` | *(none)* | `false` | Enable HTTP request/response logging | -## Tuning +## Contributing -```java -// rate limit (req/sec) -BlueskyHttpClient.initialize("http://localhost:60610", - System.getenv("BLUESKY_API_KEY"), - 3.0); +When making changes: -// retry/back-off -// edit src/main/java/com/jbi/util/HttpSupport.java -MAX_RETRIES = 5; -INITIAL_BACKOFF_MS = 500; -BACKOFF_MULTIPLIER = 1.5; -``` +1. Ensure proper Python type handling in parameter editor +2. Test with both WebSocket and HTTP fallback modes +3. Verify API key authentication works +4. Update documentation for new features +5. Follow existing code style and patterns \ No newline at end of file diff --git a/app/queue-server/edit-control/pom.xml b/app/queue-server/edit-control/pom.xml new file mode 100644 index 0000000000..2173bd29a1 --- /dev/null +++ b/app/queue-server/edit-control/pom.xml @@ -0,0 +1,31 @@ + + 4.0.0 + + org.phoebus + app-queue-server + 5.0.3-SNAPSHOT + + app-queue-server-edit-control + ${project.groupId}:${project.artifactId} + + + + org.phoebus + app-queue-server-network + ${project.version} + + + org.phoebus + core-framework + ${project.version} + + + org.phoebus + core-ui + ${project.version} + + + diff --git a/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlApp.java b/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlApp.java new file mode 100644 index 0000000000..e471c9c19f --- /dev/null +++ b/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlApp.java @@ -0,0 +1,88 @@ +package org.phoebus.applications.queueserver.editcontrol; + +import java.net.URL; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.logging.Level; +import java.util.logging.Logger; + +import org.phoebus.applications.queueserver.Preferences; +import org.phoebus.applications.queueserver.client.RunEngineHttpClient; +import org.phoebus.applications.queueserver.util.AppLifecycle; +import org.phoebus.applications.queueserver.util.PythonParameterConverter; +import org.phoebus.applications.queueserver.view.ViewFactory; +import javafx.scene.Parent; + +import org.phoebus.framework.spi.AppInstance; +import org.phoebus.framework.spi.AppResourceDescriptor; +import org.phoebus.framework.workbench.ApplicationService; +import org.phoebus.ui.docking.DockItem; +import org.phoebus.ui.docking.DockPane; + +@SuppressWarnings("nls") +public final class QueueEditControlApp implements AppResourceDescriptor { + + public static final Logger logger = Logger.getLogger(QueueEditControlApp.class.getPackageName()); + + public static final String NAME = "queue_edit_control"; + private static final String DISPLAY_NAME = "Edit & Control Queue"; + + static { + PythonParameterConverter.initializeInBackground(); + } + + @Override public String getName() { return NAME; } + @Override public String getDisplayName() { return DISPLAY_NAME; } + + @Override public URL getIconURL() { + return getClass().getResource("/icons/bluesky.png"); + } + + @Override public AppInstance create() { + initializeHttpClient(); + AppLifecycle.registerApp(); + + Parent root = ViewFactory.EDIT_AND_CONTROL_QUEUE.get(); + QueueEditControlInstance inst = new QueueEditControlInstance(this, root); + + DockItem tab = new DockItem(inst, root); + tab.addClosedNotification(AppLifecycle::unregisterApp); + DockPane.getActiveDockPane().addTab(tab); + + return inst; + } + + @Override public AppInstance create(java.net.URI resource) { + return ApplicationService.createInstance(NAME); + } + + private static void initializeHttpClient() { + String serverUrl = Preferences.queue_server_url; + if (serverUrl == null || serverUrl.trim().isEmpty() || serverUrl.startsWith("$(")) { + serverUrl = "http://localhost:60610"; + logger.log(Level.INFO, "Using default Queue Server URL: " + serverUrl); + } + String apiKey = resolveApiKey(); + RunEngineHttpClient.initialize(serverUrl, apiKey); + } + + private static String resolveApiKey() { + String apiKey = Preferences.api_key; + if (apiKey != null && !apiKey.trim().isEmpty() && !apiKey.startsWith("$(")) { + return apiKey.trim(); + } + String keyFilePath = Preferences.api_key_file; + if (keyFilePath != null && !keyFilePath.trim().isEmpty() && !keyFilePath.startsWith("$(")) { + try { + Path path = Paths.get(keyFilePath.trim()); + if (Files.exists(path)) { + return Files.readString(path).trim(); + } + } catch (Exception e) { + logger.log(Level.WARNING, "Failed to read API key from file: " + keyFilePath, e); + } + } + return null; + } +} diff --git a/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlInstance.java b/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlInstance.java new file mode 100644 index 0000000000..9a1c2158cc --- /dev/null +++ b/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlInstance.java @@ -0,0 +1,23 @@ +package org.phoebus.applications.queueserver.editcontrol; + +import javafx.scene.Node; +import org.phoebus.framework.persistence.Memento; +import org.phoebus.framework.spi.AppDescriptor; +import org.phoebus.framework.spi.AppInstance; + +final class QueueEditControlInstance implements AppInstance { + + private final AppDescriptor desc; + private final Node view; + + QueueEditControlInstance(AppDescriptor desc, Node view) { + this.desc = desc; + this.view = view; + } + + @Override public AppDescriptor getAppDescriptor() { return desc; } + public Node create() { return view; } + + @Override public void restore(Memento m) { /* nothing */ } + @Override public void save (Memento m) { /* nothing */ } +} diff --git a/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlMenuEntry.java b/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlMenuEntry.java new file mode 100644 index 0000000000..c911cfeebb --- /dev/null +++ b/app/queue-server/edit-control/src/main/java/org/phoebus/applications/queueserver/editcontrol/QueueEditControlMenuEntry.java @@ -0,0 +1,20 @@ +package org.phoebus.applications.queueserver.editcontrol; + +import org.phoebus.applications.queueserver.Messages; +import org.phoebus.framework.workbench.ApplicationService; +import org.phoebus.ui.javafx.ImageCache; +import org.phoebus.ui.spi.MenuEntry; +import javafx.scene.image.Image; + +public final class QueueEditControlMenuEntry implements MenuEntry { + + @Override public String getName() { return Messages.EditControlQueue; } + @Override public Image getIcon() { return ImageCache.getImage( + QueueEditControlApp.class, "/icons/bluesky.png"); } + @Override public String getMenuPath() { return Messages.EditControlQueueMenuPath; } + + @Override public Void call() throws Exception { + ApplicationService.createInstance(QueueEditControlApp.NAME); + return null; + } +} diff --git a/app/queue-server/edit-control/src/main/resources/META-INF/services/org.phoebus.framework.spi.AppDescriptor b/app/queue-server/edit-control/src/main/resources/META-INF/services/org.phoebus.framework.spi.AppDescriptor new file mode 100644 index 0000000000..f32744d870 --- /dev/null +++ b/app/queue-server/edit-control/src/main/resources/META-INF/services/org.phoebus.framework.spi.AppDescriptor @@ -0,0 +1 @@ +org.phoebus.applications.queueserver.editcontrol.QueueEditControlApp diff --git a/app/queue-server/edit-control/src/main/resources/META-INF/services/org.phoebus.ui.spi.MenuEntry b/app/queue-server/edit-control/src/main/resources/META-INF/services/org.phoebus.ui.spi.MenuEntry new file mode 100644 index 0000000000..231f980f59 --- /dev/null +++ b/app/queue-server/edit-control/src/main/resources/META-INF/services/org.phoebus.ui.spi.MenuEntry @@ -0,0 +1 @@ +org.phoebus.applications.queueserver.editcontrol.QueueEditControlMenuEntry diff --git a/app/queue-server/monitor/pom.xml b/app/queue-server/monitor/pom.xml new file mode 100644 index 0000000000..96323c6d6e --- /dev/null +++ b/app/queue-server/monitor/pom.xml @@ -0,0 +1,31 @@ + + 4.0.0 + + org.phoebus + app-queue-server + 5.0.3-SNAPSHOT + + app-queue-server-monitor + ${project.groupId}:${project.artifactId} + + + + org.phoebus + app-queue-server-network + ${project.version} + + + org.phoebus + core-framework + ${project.version} + + + org.phoebus + core-ui + ${project.version} + + + diff --git a/app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorApp.java b/app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorApp.java new file mode 100644 index 0000000000..1fab4629d5 --- /dev/null +++ b/app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorApp.java @@ -0,0 +1,88 @@ +package org.phoebus.applications.queueserver.monitor; + +import java.net.URL; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.logging.Level; +import java.util.logging.Logger; + +import org.phoebus.applications.queueserver.Preferences; +import org.phoebus.applications.queueserver.client.RunEngineHttpClient; +import org.phoebus.applications.queueserver.util.AppLifecycle; +import org.phoebus.applications.queueserver.util.PythonParameterConverter; +import org.phoebus.applications.queueserver.view.ViewFactory; +import javafx.scene.Parent; + +import org.phoebus.framework.spi.AppInstance; +import org.phoebus.framework.spi.AppResourceDescriptor; +import org.phoebus.framework.workbench.ApplicationService; +import org.phoebus.ui.docking.DockItem; +import org.phoebus.ui.docking.DockPane; + +@SuppressWarnings("nls") +public final class QueueMonitorApp implements AppResourceDescriptor { + + public static final Logger logger = Logger.getLogger(QueueMonitorApp.class.getPackageName()); + + public static final String NAME = "queue_monitor"; + private static final String DISPLAY_NAME = "Queue Monitor"; + + static { + PythonParameterConverter.initializeInBackground(); + } + + @Override public String getName() { return NAME; } + @Override public String getDisplayName() { return DISPLAY_NAME; } + + @Override public URL getIconURL() { + return getClass().getResource("/icons/bluesky.png"); + } + + @Override public AppInstance create() { + initializeHttpClient(); + AppLifecycle.registerApp(); + + Parent root = ViewFactory.MONITOR_QUEUE.get(); + QueueMonitorInstance inst = new QueueMonitorInstance(this, root); + + DockItem tab = new DockItem(inst, root); + tab.addClosedNotification(AppLifecycle::unregisterApp); + DockPane.getActiveDockPane().addTab(tab); + + return inst; + } + + @Override public AppInstance create(java.net.URI resource) { + return ApplicationService.createInstance(NAME); + } + + private static void initializeHttpClient() { + String serverUrl = Preferences.queue_server_url; + if (serverUrl == null || serverUrl.trim().isEmpty() || serverUrl.startsWith("$(")) { + serverUrl = "http://localhost:60610"; + logger.log(Level.INFO, "Using default Queue Server URL: " + serverUrl); + } + String apiKey = resolveApiKey(); + RunEngineHttpClient.initialize(serverUrl, apiKey); + } + + private static String resolveApiKey() { + String apiKey = Preferences.api_key; + if (apiKey != null && !apiKey.trim().isEmpty() && !apiKey.startsWith("$(")) { + return apiKey.trim(); + } + String keyFilePath = Preferences.api_key_file; + if (keyFilePath != null && !keyFilePath.trim().isEmpty() && !keyFilePath.startsWith("$(")) { + try { + Path path = Paths.get(keyFilePath.trim()); + if (Files.exists(path)) { + return Files.readString(path).trim(); + } + } catch (Exception e) { + logger.log(Level.WARNING, "Failed to read API key from file: " + keyFilePath, e); + } + } + return null; + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/QueueServerInstance.java b/app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorInstance.java similarity index 76% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/QueueServerInstance.java rename to app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorInstance.java index b522eea5c1..f7ab5aa5f6 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/QueueServerInstance.java +++ b/app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorInstance.java @@ -1,16 +1,16 @@ -package org.phoebus.applications.queueserver; +package org.phoebus.applications.queueserver.monitor; import javafx.scene.Node; import org.phoebus.framework.persistence.Memento; import org.phoebus.framework.spi.AppDescriptor; import org.phoebus.framework.spi.AppInstance; -final class QueueServerInstance implements AppInstance { +final class QueueMonitorInstance implements AppInstance { private final AppDescriptor desc; private final Node view; - QueueServerInstance(AppDescriptor desc, Node view) { + QueueMonitorInstance(AppDescriptor desc, Node view) { this.desc = desc; this.view = view; } @@ -20,4 +20,4 @@ final class QueueServerInstance implements AppInstance { @Override public void restore(Memento m) { /* nothing */ } @Override public void save (Memento m) { /* nothing */ } -} \ No newline at end of file +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/QueueServerMenuEntry.java b/app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorMenuEntry.java similarity index 57% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/QueueServerMenuEntry.java rename to app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorMenuEntry.java index 06f99e5266..63e0859bc2 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/QueueServerMenuEntry.java +++ b/app/queue-server/monitor/src/main/java/org/phoebus/applications/queueserver/monitor/QueueMonitorMenuEntry.java @@ -1,20 +1,20 @@ -package org.phoebus.applications.queueserver; +package org.phoebus.applications.queueserver.monitor; +import org.phoebus.applications.queueserver.Messages; import org.phoebus.framework.workbench.ApplicationService; import org.phoebus.ui.javafx.ImageCache; import org.phoebus.ui.spi.MenuEntry; import javafx.scene.image.Image; -public final class QueueServerMenuEntry implements MenuEntry { +public final class QueueMonitorMenuEntry implements MenuEntry { - @Override public String getName() { return Messages.QueueServer; } + @Override public String getName() { return Messages.QueueMonitor; } @Override public Image getIcon() { return ImageCache.getImage( - QueueServerApp.class, - "/icons/bluesky.png"); } // same icon as descriptor - @Override public String getMenuPath() { return Messages.QueueServerMenuPath; } + QueueMonitorApp.class, "/icons/bluesky.png"); } + @Override public String getMenuPath() { return Messages.QueueMonitorMenuPath; } @Override public Void call() throws Exception { - ApplicationService.createInstance(QueueServerApp.NAME); + ApplicationService.createInstance(QueueMonitorApp.NAME); return null; } } diff --git a/app/queue-server/monitor/src/main/resources/META-INF/services/org.phoebus.framework.spi.AppDescriptor b/app/queue-server/monitor/src/main/resources/META-INF/services/org.phoebus.framework.spi.AppDescriptor new file mode 100644 index 0000000000..9f6da18f43 --- /dev/null +++ b/app/queue-server/monitor/src/main/resources/META-INF/services/org.phoebus.framework.spi.AppDescriptor @@ -0,0 +1 @@ +org.phoebus.applications.queueserver.monitor.QueueMonitorApp diff --git a/app/queue-server/monitor/src/main/resources/META-INF/services/org.phoebus.ui.spi.MenuEntry b/app/queue-server/monitor/src/main/resources/META-INF/services/org.phoebus.ui.spi.MenuEntry new file mode 100644 index 0000000000..e080c12294 --- /dev/null +++ b/app/queue-server/monitor/src/main/resources/META-INF/services/org.phoebus.ui.spi.MenuEntry @@ -0,0 +1 @@ +org.phoebus.applications.queueserver.monitor.QueueMonitorMenuEntry diff --git a/app/queue-server/network/pom.xml b/app/queue-server/network/pom.xml new file mode 100644 index 0000000000..7e1294b774 --- /dev/null +++ b/app/queue-server/network/pom.xml @@ -0,0 +1,73 @@ + + 4.0.0 + + org.phoebus + app-queue-server + 5.0.3-SNAPSHOT + + app-queue-server-network + ${project.groupId}:${project.artifactId} + + + + org.phoebus + core-framework + ${project.version} + + + org.phoebus + core-ui + ${project.version} + + + org.phoebus + core-types + ${project.version} + + + com.fasterxml.jackson.dataformat + jackson-dataformat-yaml + 2.19.1 + + + org.python + jython-standalone + ${jython.version} + + + org.apache.poi + poi + + + com.zaxxer + SparseBitSet + + + org.slf4j + slf4j-api + + + org.slf4j + jcl-over-slf4j + + + commons-codec + commons-codec + + + org.apache.commons + commons-collections4 + + + org.apache.commons + commons-math3 + + + 5.0.0 + compile + + + diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/Messages.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/Messages.java similarity index 60% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/Messages.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/Messages.java index 25fe16fb50..91c76efff5 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/Messages.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/Messages.java @@ -2,13 +2,15 @@ import org.phoebus.framework.nls.NLS; -/** Externalised strings for Queue-Monitor plug-in */ +/** Externalised strings for Queue Server plug-ins */ @SuppressWarnings("nls") public final class Messages { // ---------- keep alphabetically sorted ---------- - public static String QueueServer; // display name - public static String QueueServerMenuPath; // menu path + public static String EditControlQueue; + public static String EditControlQueueMenuPath; + public static String QueueMonitor; + public static String QueueMonitorMenuPath; // ----------------------------------------------- static { NLS.initializeMessages(Messages.class); } diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/Preferences.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/Preferences.java similarity index 77% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/Preferences.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/Preferences.java index 750f96e81f..af6a18160a 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/Preferences.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/Preferences.java @@ -15,12 +15,21 @@ public class Preferences { @Preference public static String api_key; + @Preference + public static String api_key_file; + @Preference public static boolean debug; @Preference public static int connectTimeout; + @Preference + public static boolean use_websockets; + + @Preference + public static int update_interval_ms; + static { AnnotatedPreferences.initialize(Preferences.class, "/queueserver_preferences.properties"); diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputText.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputText.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputText.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputText.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputUid.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputUid.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputUid.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputUid.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputUpdate.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputUpdate.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputUpdate.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputUpdate.java diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputWsMessage.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputWsMessage.java new file mode 100644 index 0000000000..80c8c15206 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/ConsoleOutputWsMessage.java @@ -0,0 +1,19 @@ +package org.phoebus.applications.queueserver.api; + +import com.fasterxml.jackson.annotation.JsonProperty; + +/** + * WebSocket message from /console_output/ws endpoint. + * Format: {"time": timestamp, "msg": text} + */ +public record ConsoleOutputWsMessage( + @JsonProperty("time") double time, + @JsonProperty("msg") String msg +) { + /** + * Get timestamp as milliseconds since epoch. + */ + public long timestampMillis() { + return (long) (time * 1000); + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/Envelope.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/Envelope.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/Envelope.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/Envelope.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/EverythingElse.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/EverythingElse.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/EverythingElse.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/EverythingElse.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/HistoryGetPayload.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/HistoryGetPayload.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/HistoryGetPayload.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/HistoryGetPayload.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/NoBody.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/NoBody.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/NoBody.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/NoBody.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueGetPayload.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueGetPayload.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueGetPayload.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueGetPayload.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItem.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItem.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItem.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItem.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAdd.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAdd.java similarity index 74% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAdd.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAdd.java index e05828db9d..2efca787ac 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAdd.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAdd.java @@ -10,7 +10,13 @@ public record QueueItemAdd( @JsonProperty("item") Item item, String user, - @JsonProperty("user_group") String userGroup) { + @JsonProperty("user_group") String userGroup, + @JsonProperty("after_uid") String afterUid) { + + /** Convenience constructor – adds to end of queue. */ + public QueueItemAdd(Item item, String user, String userGroup) { + this(item, user, userGroup, null); + } @JsonInclude(JsonInclude.Include.NON_NULL) public record Item( diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAddBatch.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAddBatch.java new file mode 100644 index 0000000000..dfbb9d6113 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemAddBatch.java @@ -0,0 +1,19 @@ +package org.phoebus.applications.queueserver.api; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.List; + +@JsonInclude(JsonInclude.Include.NON_NULL) +public record QueueItemAddBatch( + + @JsonProperty("items") List items, + @JsonProperty("user") String user, + @JsonProperty("user_group") String userGroup, + @JsonProperty("after_uid") String afterUid +) { + /** Convenience constructor – adds to end of queue. */ + public QueueItemAddBatch(List items, String user, String userGroup) { + this(items, user, userGroup, null); + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItemMove.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemMove.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItemMove.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemMove.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItemMoveBatch.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemMoveBatch.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/QueueItemMoveBatch.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/QueueItemMoveBatch.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/StatusResponse.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/StatusResponse.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/api/StatusResponse.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/StatusResponse.java diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/StatusWsMessage.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/StatusWsMessage.java new file mode 100644 index 0000000000..1e22d0e8a3 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/StatusWsMessage.java @@ -0,0 +1,30 @@ +package org.phoebus.applications.queueserver.api; + +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.Map; + +/** + * WebSocket message from /status/ws endpoint. + * Format: {"time": timestamp, "msg": {"status": {...}}} + */ +public record StatusWsMessage( + @JsonProperty("time") double time, + @JsonProperty("msg") Map msg +) { + /** + * Get timestamp as milliseconds since epoch. + */ + public long timestampMillis() { + return (long) (time * 1000); + } + + /** + * Get the status payload from the message. + * Returns null if not present. + */ + @SuppressWarnings("unchecked") + public Map status() { + if (msg == null) return null; + return (Map) msg.get("status"); + } +} diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/SystemInfoWsMessage.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/SystemInfoWsMessage.java new file mode 100644 index 0000000000..7efe0bda63 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/api/SystemInfoWsMessage.java @@ -0,0 +1,31 @@ +package org.phoebus.applications.queueserver.api; + +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.Map; + +/** + * WebSocket message from /info/ws endpoint. + * Format: {"time": timestamp, "msg": {msg-class: msg-content}} + * Currently includes status messages and may include additional system info in the future. + */ +public record SystemInfoWsMessage( + @JsonProperty("time") double time, + @JsonProperty("msg") Map msg +) { + /** + * Get timestamp as milliseconds since epoch. + */ + public long timestampMillis() { + return (long) (time * 1000); + } + + /** + * Get the status payload if this is a status message. + * Returns null if not a status message. + */ + @SuppressWarnings("unchecked") + public Map status() { + if (msg == null) return null; + return (Map) msg.get("status"); + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/ApiEndpoint.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/ApiEndpoint.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/ApiEndpoint.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/ApiEndpoint.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/Endpoint.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/Endpoint.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/Endpoint.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/Endpoint.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/HttpMethod.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/HttpMethod.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/HttpMethod.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/HttpMethod.java diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/QueueServerWebSocket.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/QueueServerWebSocket.java new file mode 100644 index 0000000000..ec40457c90 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/QueueServerWebSocket.java @@ -0,0 +1,200 @@ +package org.phoebus.applications.queueserver.client; + +import com.fasterxml.jackson.databind.ObjectMapper; + +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.WebSocket; +import java.nio.ByteBuffer; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Consumer; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Generic WebSocket client for Queue Server streaming endpoints. + * Connects to a WebSocket, parses JSON messages to the specified type, and notifies listeners. + * + * @param the message type (e.g., ConsoleOutputWsMessage, StatusWsMessage) + */ +public final class QueueServerWebSocket implements AutoCloseable { + + private static final Logger logger = Logger.getLogger(QueueServerWebSocket.class.getPackageName()); + private static final ObjectMapper JSON = new ObjectMapper(); + + private final String wsUrl; + private final String authHeader; + private final Class messageType; + private final List> listeners = new CopyOnWriteArrayList<>(); + private final AtomicBoolean active = new AtomicBoolean(false); + + private WebSocket webSocket; + private final StringBuilder messageBuffer = new StringBuilder(); + + /** + * Create a new WebSocket client. + * + * @param wsUrl the WebSocket URL (e.g., "ws://localhost:60610/api/console_output/ws") + * @param apiKey the API key for authentication + * @param messageType the class of the message type to parse + */ + public QueueServerWebSocket(String wsUrl, String apiKey, Class messageType) { + this.wsUrl = wsUrl; + this.authHeader = "ApiKey " + apiKey; + this.messageType = messageType; + } + + /** + * Add a listener that will be called when messages are received. + * + * @param listener the listener to add + */ + public void addListener(Consumer listener) { + listeners.add(listener); + } + + /** + * Remove a listener. + * + * @param listener the listener to remove + */ + public void removeListener(Consumer listener) { + listeners.remove(listener); + } + + /** + * Connect to the WebSocket and start receiving messages. + */ + public void connect() { + if (active.getAndSet(true)) { + logger.log(Level.WARNING, "WebSocket already connected: " + wsUrl); + return; + } + + logger.log(Level.FINE, "Connecting to WebSocket: " + wsUrl); + + HttpClient client = HttpClient.newHttpClient(); + CompletableFuture wsFuture = client.newWebSocketBuilder() + .header("Authorization", authHeader) + .buildAsync(URI.create(wsUrl), new WebSocketListener()); + + wsFuture.whenComplete((ws, ex) -> { + if (ex != null) { + logger.log(Level.FINE, "Failed to connect to WebSocket: " + wsUrl + " (" + ex.getMessage() + ")"); + active.set(false); + } else { + this.webSocket = ws; + logger.log(Level.FINE, "WebSocket connected: " + wsUrl); + } + }); + } + + /** + * Disconnect from the WebSocket. + */ + public void disconnect() { + if (!active.getAndSet(false)) { + return; + } + + logger.log(Level.FINE, "Disconnecting from WebSocket: " + wsUrl); + + if (webSocket != null) { + webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "Client closing"); + webSocket = null; + } + } + + /** + * Check if the WebSocket is currently connected. + */ + public boolean isConnected() { + return active.get() && webSocket != null && !webSocket.isInputClosed(); + } + + @Override + public void close() { + disconnect(); + } + + /** + * WebSocket listener implementation. + */ + private class WebSocketListener implements WebSocket.Listener { + + @Override + public void onOpen(WebSocket webSocket) { + logger.log(Level.FINE, "WebSocket opened: " + wsUrl); + webSocket.request(1); + } + + @Override + public CompletionStage onText(WebSocket webSocket, CharSequence data, boolean last) { + messageBuffer.append(data); + + if (last) { + String fullMessage = messageBuffer.toString(); + messageBuffer.setLength(0); + + try { + T message = JSON.readValue(fullMessage, messageType); + notifyListeners(message); + } catch (Exception e) { + logger.log(Level.WARNING, "Failed to parse WebSocket message: " + fullMessage, e); + } + } + + webSocket.request(1); + return null; + } + + @Override + public CompletionStage onBinary(WebSocket webSocket, ByteBuffer data, boolean last) { + // Not expected for Queue Server WebSockets + webSocket.request(1); + return null; + } + + @Override + public CompletionStage onPing(WebSocket webSocket, ByteBuffer message) { + webSocket.request(1); + return null; + } + + @Override + public CompletionStage onPong(WebSocket webSocket, ByteBuffer message) { + webSocket.request(1); + return null; + } + + @Override + public CompletionStage onClose(WebSocket webSocket, int statusCode, String reason) { + logger.log(Level.FINE, "WebSocket closed: " + wsUrl + " (" + statusCode + ": " + reason + ")"); + active.set(false); + return null; + } + + @Override + public void onError(WebSocket webSocket, Throwable error) { + logger.log(Level.SEVERE, "WebSocket error: " + wsUrl, error); + active.set(false); + } + } + + /** + * Notify all listeners with the received message. + */ + private void notifyListeners(T message) { + for (Consumer listener : listeners) { + try { + listener.accept(message); + } catch (Exception e) { + logger.log(Level.SEVERE, "Error in WebSocket listener", e); + } + } + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/RunEngineHttpClient.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/RunEngineHttpClient.java similarity index 96% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/RunEngineHttpClient.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/RunEngineHttpClient.java index b58da4ed1a..45871e5166 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/RunEngineHttpClient.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/RunEngineHttpClient.java @@ -48,7 +48,7 @@ public static RunEngineHttpClient get() { private final String base; private final String apiKey; private final RateLimiter limiter; - private static final Logger LOG = HttpSupport.LOG; + private static final Logger logger = HttpSupport.logger; private RunEngineHttpClient(String baseUrl, String apiKey, double permitsPerSecond) { this.http = HttpClient.newBuilder() @@ -118,14 +118,14 @@ private T executeWithRetry(HttpRequest req, ApiEndpoint ep, limiter.acquire(); long t0 = System.nanoTime(); try { - LOG.log(Level.FINEST, ep + " attempt " + attempt); + logger.log(Level.FINEST, ep + " attempt " + attempt); HttpResponse rsp = http.send(req, HttpResponse.BodyHandlers.ofString()); - LOG.log(Level.FINEST, ep + " " + rsp.statusCode() + " " + HttpSupport.elapsed(t0) + " ms"); + logger.log(Level.FINEST, ep + " " + rsp.statusCode() + " " + HttpSupport.elapsed(t0) + " ms"); check(rsp, ep); return reader.apply(rsp); } catch (java.io.IOException ex) { if (!HttpSupport.isRetryable(req) || attempt >= HttpSupport.MAX_RETRIES) throw ex; - LOG.log(Level.WARNING, ep + " transport error (" + ex.getClass().getSimpleName() + + logger.log(Level.FINE, ep + " transport error (" + ex.getClass().getSimpleName() + "), retry in " + back + " ms (attempt " + attempt + ")"); Thread.sleep(back); back = Math.round(back * HttpSupport.BACKOFF_MULTIPLIER); diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/RunEngineService.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/RunEngineService.java similarity index 77% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/RunEngineService.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/RunEngineService.java index 5e42902b49..bc5252115d 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/client/RunEngineService.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/client/RunEngineService.java @@ -29,13 +29,13 @@ public final class RunEngineService { private final RunEngineHttpClient http = RunEngineHttpClient.get(); - private static final Logger LOG = Logger.getLogger(RunEngineService.class.getName()); + private static final Logger logger = Logger.getLogger(RunEngineService.class.getPackageName()); /* ---- Ping & status --------------------------------------------------- */ public Envelope ping() throws Exception { return http.call(ApiEndpoint.PING, NoBody.INSTANCE); } public StatusResponse status() throws Exception { - LOG.log(Level.FINEST, "Fetching status"); + logger.log(Level.FINEST, "Fetching status"); return http.send(ApiEndpoint.STATUS, NoBody.INSTANCE, StatusResponse.class); } public Envelope configGet() throws Exception { return http.call(ApiEndpoint.CONFIG_GET, NoBody.INSTANCE); } @@ -67,14 +67,25 @@ public HistoryGetPayload historyGetTyped() throws Exception { public Envelope queueItemAdd(QueueItem item, String user, - String group) throws Exception { + String group, + String afterUid) throws Exception { - QueueItemAdd req = new QueueItemAdd(QueueItemAdd.Item.from(item), user, group); + QueueItemAdd req = new QueueItemAdd(QueueItemAdd.Item.from(item), user, group, afterUid); return queueItemAdd(req); } + public Envelope queueItemAdd(QueueItem item, + String user, + String group) throws Exception { + return queueItemAdd(item, user, group, null); + } + public Envelope queueItemAdd(QueueItem item) throws Exception { - return queueItemAdd(item, "GUI Client", "primary"); + return queueItemAdd(item, "GUI Client", "primary", null); + } + + public Envelope queueItemAdd(QueueItem item, String afterUid) throws Exception { + return queueItemAdd(item, "GUI Client", "primary", afterUid); } /* ---- move helpers --------------------------------------------------- */ @@ -95,26 +106,41 @@ public void moveBatch(List uids, String ref, boolean before) throws Exce : QueueItemMoveBatch.after (uids, ref)); } + /* ---- UID-returning add helpers -------------------------------------- */ + + /** Add a single item and return the server-assigned UID. */ + @SuppressWarnings("unchecked") + public String addItemGetUid(Object body) throws Exception { + Map response = http.send(ApiEndpoint.QUEUE_ITEM_ADD, body); + if (Boolean.TRUE.equals(response.get("success"))) { + Map item = (Map) response.get("item"); + if (item != null) return (String) item.get("item_uid"); + } + throw new RuntimeException("Failed to add item: " + response.get("msg")); + } + + /** Add a batch of items and return the server-assigned UIDs. */ + @SuppressWarnings("unchecked") + public List addBatchGetUids(Object body) throws Exception { + Map response = http.send(ApiEndpoint.QUEUE_ITEM_ADD_BATCH, body); + if (Boolean.TRUE.equals(response.get("success"))) { + List> items = (List>) response.get("items"); + if (items != null) { + return items.stream() + .map(i -> (String) i.get("item_uid")) + .filter(java.util.Objects::nonNull) + .toList(); + } + } + throw new RuntimeException("Failed to add batch: " + response.get("msg")); + } + /* ---- duplicate helper ---------------------------------------------- */ - public String addAfter(QueueItem item, String afterUid) throws Exception { + public void addAfter(QueueItem item, String afterUid) throws Exception { QueueItemAdd req = new QueueItemAdd(QueueItemAdd.Item.from(item), - "GUI Client", "primary"); - Map body = Map.of( - "item", req.item(), - "after_uid", afterUid, - "user", req.user(), - "user_group", req.userGroup()); - - Envelope env = queueItemAdd(body); - - Object payload = env.payload(); - if (payload instanceof Map p && - p.get("item") instanceof Map m && - m.get("item_uid") != null) { - return m.get("item_uid").toString(); - } - return null; + "GUI Client", "primary", afterUid); + queueItemAdd(req); } /* ---- batch-add helpers --------------------------------------------- */ @@ -168,7 +194,7 @@ public Envelope queueItemUpdate(QueueItem item) throws Exception { /* ───────── Console monitor ───────── */ public InputStream streamConsoleOutput() throws Exception { - LOG.info("Opening console output stream"); + logger.log(Level.FINE, "Opening console output stream"); HttpRequest req = HttpRequest.newBuilder() .uri(URI.create(http.getBaseUrl() + ApiEndpoint.STREAM_CONSOLE_OUTPUT.endpoint().path())) .header("Authorization", "ApiKey " + http.getApiKey()) @@ -178,10 +204,10 @@ public InputStream streamConsoleOutput() throws Exception { HttpResponse rsp = http.httpClient().send(req, HttpResponse.BodyHandlers.ofInputStream()); if (rsp.statusCode() < 200 || rsp.statusCode() >= 300) { - LOG.log(Level.WARNING, "Console stream failed with HTTP " + rsp.statusCode()); + logger.log(Level.WARNING, "Console stream failed with HTTP " + rsp.statusCode()); throw new IOException("console stream - HTTP " + rsp.statusCode()); } - LOG.info("Console output stream opened successfully"); + logger.log(Level.FINE, "Console output stream opened successfully"); return rsp.body(); } @@ -251,7 +277,7 @@ public Envelope rePause(String option) throws Exception { public Envelope plansAllowed() throws Exception { return http.call(ApiEndpoint.PLANS_ALLOWED, NoBody.INSTANCE); } public Map plansAllowedRaw() throws Exception { - LOG.log(Level.FINE, "Fetching plans allowed (raw)"); + logger.log(Level.FINE, "Fetching plans allowed (raw)"); return http.send(ApiEndpoint.PLANS_ALLOWED, NoBody.INSTANCE); } public Envelope devicesAllowed() throws Exception { return http.call(ApiEndpoint.DEVICES_ALLOWED, NoBody.INSTANCE); } @@ -292,4 +318,44 @@ public Map plansAllowedRaw() throws Exception { public Envelope whoAmI() throws Exception { return http.call(ApiEndpoint.WHOAMI, NoBody.INSTANCE); } public Envelope apiScopes() throws Exception { return http.call(ApiEndpoint.API_SCOPES, NoBody.INSTANCE); } public Envelope logout() throws Exception { return http.call(ApiEndpoint.LOGOUT, NoBody.INSTANCE); } + + /* ---- WebSockets ------------------------------------------------------ */ + + /** + * Create a WebSocket connection to the console output stream. + * Messages are streamed in real-time as {"time": timestamp, "msg": text}. + * + * @return a WebSocket client that can be connected and listened to + */ + public QueueServerWebSocket createConsoleOutputWebSocket() { + String wsUrl = http.getBaseUrl().replace("http://", "ws://").replace("https://", "wss://") + + "/api/console_output/ws"; + return new QueueServerWebSocket<>(wsUrl, http.getApiKey(), ConsoleOutputWsMessage.class); + } + + /** + * Create a WebSocket connection to the status stream. + * Status messages are sent each time status is updated at RE Manager or at least once per second. + * Messages are formatted as {"time": timestamp, "msg": {"status": {...}}}. + * + * @return a WebSocket client that can be connected and listened to + */ + public QueueServerWebSocket createStatusWebSocket() { + String wsUrl = http.getBaseUrl().replace("http://", "ws://").replace("https://", "wss://") + + "/api/status/ws"; + return new QueueServerWebSocket<>(wsUrl, http.getApiKey(), StatusWsMessage.class); + } + + /** + * Create a WebSocket connection to the system info stream. + * Info stream includes status messages and potentially other system messages. + * Messages are formatted as {"time": timestamp, "msg": {msg-class: msg-content}}. + * + * @return a WebSocket client that can be connected and listened to + */ + public QueueServerWebSocket createSystemInfoWebSocket() { + String wsUrl = http.getBaseUrl().replace("http://", "ws://").replace("https://", "wss://") + + "/api/info/ws"; + return new QueueServerWebSocket<>(wsUrl, http.getApiKey(), SystemInfoWsMessage.class); + } } \ No newline at end of file diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/EditAndControlQueueController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/EditAndControlQueueController.java similarity index 86% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/EditAndControlQueueController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/EditAndControlQueueController.java index e0d5b09707..8fb4e4342a 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/EditAndControlQueueController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/EditAndControlQueueController.java @@ -18,11 +18,11 @@ public class EditAndControlQueueController implements Initializable { @FXML private AnchorPane planQueueContainer; @FXML private AnchorPane planHistoryContainer; - private static final Logger LOG = Logger.getLogger(EditAndControlQueueController.class.getName()); + private static final Logger logger = Logger.getLogger(EditAndControlQueueController.class.getPackageName()); @Override public void initialize(URL url, ResourceBundle resourceBundle) { - LOG.info("Initializing EditAndControlQueueController"); + logger.log(Level.FINE, "Initializing EditAndControlQueueController"); loadInto(runningPlanContainer, "/org/phoebus/applications/queueserver/view/ReRunningPlan.fxml", new ReRunningPlanController(false)); loadInto(planQueueContainer, "/org/phoebus/applications/queueserver/view/RePlanQueue.fxml", new RePlanQueueController(false)); loadInto(planHistoryContainer, "/org/phoebus/applications/queueserver/view/RePlanHistory.fxml", new RePlanHistoryController(false)); @@ -40,7 +40,7 @@ private void loadInto(AnchorPane container, String fxml, Object controller) { AnchorPane.setLeftAnchor(view, 0.0); AnchorPane.setRightAnchor(view, 0.0); } catch (IOException e) { - LOG.log(Level.SEVERE, "Failed to load FXML: " + fxml, e); + logger.log(Level.SEVERE, "Failed to load FXML: " + fxml, e); } } diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/MonitorQueueController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/MonitorQueueController.java similarity index 89% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/MonitorQueueController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/MonitorQueueController.java index de3d6ccef2..45f72f556d 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/MonitorQueueController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/MonitorQueueController.java @@ -25,7 +25,7 @@ public class MonitorQueueController implements Initializable { @FXML private VBox stack; private final Map savedHeights = new HashMap<>(); - private static final Logger LOG = Logger.getLogger(MonitorQueueController.class.getName()); + private static final Logger logger = Logger.getLogger(MonitorQueueController.class.getPackageName()); private static final String BAR_NORMAL = "-fx-background-color: linear-gradient(to bottom, derive(-fx-base,15%) 0%, derive(-fx-base,-5%) 100%);" + @@ -34,7 +34,7 @@ public class MonitorQueueController implements Initializable { @Override public void initialize(URL url, ResourceBundle resourceBundle) { - LOG.info("Initializing MonitorQueueController"); + logger.log(Level.FINE, "Initializing MonitorQueueController"); loadInto(runningPlanContainer, "/org/phoebus/applications/queueserver/view/ReRunningPlan.fxml", new ReRunningPlanController(true)); loadInto(planQueueContainer, "/org/phoebus/applications/queueserver/view/RePlanQueue.fxml", new RePlanQueueController(true)); loadInto(planHistoryContainer, "/org/phoebus/applications/queueserver/view/RePlanHistory.fxml", new RePlanHistoryController(true)); @@ -76,7 +76,7 @@ private void loadInto(AnchorPane container, String fxml, Object controller) { AnchorPane.setLeftAnchor(view, 0.0); AnchorPane.setRightAnchor(view, 0.0); } catch (IOException e) { - LOG.log(Level.SEVERE, "Failed to load FXML: " + fxml, e); + logger.log(Level.SEVERE, "Failed to load FXML: " + fxml, e); } } @@ -95,7 +95,10 @@ private void addDragBars(TitledPane[] panes) { bar.setOnMouseEntered(e -> bar.setCursor(Cursor.V_RESIZE)); - bar.setOnMousePressed(e -> bar.setUserData(new double[]{ e.getScreenY() })); + bar.setOnMousePressed(e -> { + double localY = stack.sceneToLocal(e.getSceneX(), e.getSceneY()).getY(); + bar.setUserData(new double[]{ localY }); + }); bar.setOnMouseDragged(e -> { @@ -105,7 +108,8 @@ private void addDragBars(TitledPane[] panes) { double[] d = (double[]) bar.getUserData(); double lastY = d[0]; // reference from previous event - double dy = e.getScreenY() - lastY; // incremental movement + double localY = stack.sceneToLocal(e.getSceneX(), e.getSceneY()).getY(); + double dy = localY - lastY; // incremental movement if (Math.abs(dy) < 0.1) return; // jitter guard /* title-bar heights so we never hide headers */ @@ -133,7 +137,7 @@ private void addDragBars(TitledPane[] panes) { savedHeights.put(lower, newLow); } - d[0] = e.getScreenY(); // update reference point + d[0] = localY; // update reference point }); diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReConsoleMonitorController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReConsoleMonitorController.java new file mode 100644 index 0000000000..39e94ad6ea --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReConsoleMonitorController.java @@ -0,0 +1,532 @@ +package org.phoebus.applications.queueserver.controller; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.phoebus.applications.queueserver.Preferences; +import org.phoebus.applications.queueserver.api.ConsoleOutputUpdate; +import org.phoebus.applications.queueserver.api.ConsoleOutputWsMessage; +import org.phoebus.applications.queueserver.client.QueueServerWebSocket; +import org.phoebus.applications.queueserver.client.RunEngineService; +import org.phoebus.applications.queueserver.util.AppLifecycle; +import org.phoebus.applications.queueserver.util.PollCenter; +import org.phoebus.applications.queueserver.util.StatusBus; +import javafx.application.Platform; +import javafx.beans.value.ObservableValue; +import javafx.concurrent.Task; +import javafx.fxml.FXML; +import javafx.fxml.Initializable; +import javafx.scene.control.*; +import javafx.util.StringConverter; +import javafx.util.converter.IntegerStringConverter; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.time.Instant; +import java.util.*; +import java.util.concurrent.*; + +public final class ReConsoleMonitorController implements Initializable { + + @FXML private CheckBox autoscrollChk; + @FXML private Button clearBtn; + @FXML private TextField maxLinesField; + @FXML private TextArea textArea; + + private static final double EPS = 0.5; + private ScrollBar vBar; + + private static final int MIN_LINES = 10, MAX_LINES = 10_000, + BACKLOG = 1_000, CHUNK = 32_768; + + private int maxLines = 1_000; + private final ConsoleTextBuffer textBuf = new ConsoleTextBuffer(MAX_LINES); + + private final RunEngineService svc = new RunEngineService(); + private final ExecutorService io = + Executors.newSingleThreadExecutor(r -> new Thread(r,"console-reader")); + private static final ObjectMapper JSON = new ObjectMapper(); + + private volatile boolean stop = true; + private volatile String lastUid = "ALL"; + private Instant lastLine = Instant.EPOCH; + + private ScheduledFuture pollTask; + private volatile long lastProgrammaticScroll = 0; + private final StringBuilder wsTextBuffer = new StringBuilder(); + private final Object wsTextLock = new Object(); + + private QueueServerWebSocket consoleWs; + private volatile boolean isRunning = false; + private javafx.beans.value.ChangeListener statusListener; + + @Override public void initialize(URL url, ResourceBundle rb) { + // Register shutdown callback for app lifecycle management + AppLifecycle.registerShutdown(this::shutdown); + + textArea.setEditable(false); + textArea.setStyle("-fx-font-family: monospace"); + + // Add visual indicator when autoscroll is unchecked + autoscrollChk.selectedProperty().addListener((obs, wasSelected, isSelected) -> { + if (isSelected) { + // Checked - normal appearance + autoscrollChk.setStyle(""); + } else { + // Unchecked - red bold text to make it obvious + autoscrollChk.setStyle("-fx-text-fill: red; -fx-font-weight: bold;"); + } + }); + // Set initial style based on current state + if (!autoscrollChk.isSelected()) { + autoscrollChk.setStyle("-fx-text-fill: red; -fx-font-weight: bold;"); + } + + // Detect ANY user scroll interaction - mouse wheel, touchpad, scrollbar drag + textArea.setOnScroll(event -> { + // Any scroll event disables autoscroll + if (autoscrollChk.isSelected()) { + autoscrollChk.setSelected(false); + } + }); + + textArea.sceneProperty().addListener((o,ov,nv)->{ + if(nv==null)return; + Platform.runLater(()->{ + vBar =(ScrollBar)textArea.lookup(".scroll-bar:vertical"); + if(vBar!=null){ + vBar.valueProperty().addListener(this::scrollbarChanged); + + // Detect when user clicks anywhere on scrollbar + vBar.setOnMousePressed(event -> { + if (autoscrollChk.isSelected()) { + autoscrollChk.setSelected(false); + } + }); + + // Detect when user drags the scrollbar + vBar.setOnMouseDragged(event -> { + if (autoscrollChk.isSelected()) { + autoscrollChk.setSelected(false); + } + }); + } + }); + }); + + StringConverter cv = new IntegerStringConverter(); + TextFormatter tf = new TextFormatter<>(cv, maxLines, + c->c.getControlNewText().matches("\\d*")?c:null); + maxLinesField.setTextFormatter(tf); + + tf.valueProperty().addListener((o,ov,nv)->{ + maxLines = clamp(nv==null?MIN_LINES:nv); + maxLinesField.setText(String.valueOf(maxLines)); + render(); + }); + maxLinesField.focusedProperty().addListener((o,ov,nv)->{ + if(!nv) maxLinesField.setText(String.valueOf(maxLines)); + }); + + clearBtn.setOnAction(e->{ synchronized(textBuf){ textBuf.clear(); } render(); }); + + // Only start/stop on null <-> non-null transitions, not on every status change + statusListener = (o,oldS,newS)-> { + boolean wasConnected = oldS != null; + boolean isConnected = newS != null; + + // Only act on state transitions + if (wasConnected != isConnected) { + java.util.logging.Logger.getLogger(getClass().getPackageName()) + .log(java.util.logging.Level.FINE, + "Console monitor state transition: wasConnected=" + wasConnected + + ", isConnected=" + isConnected); + Platform.runLater(()-> { + if (isConnected) start(); + else stop(); + }); + } + }; + StatusBus.addListener(statusListener); + } + + public void shutdown(){ + // Remove status listener first to prevent any further callbacks + if (statusListener != null) { + StatusBus.removeListener(statusListener); + statusListener = null; + } + stop(); + if (consoleWs != null) { + consoleWs.close(); + } + io.shutdownNow(); + } + + private void start(){ + // Prevent starting if already running + if(isRunning) { + java.util.logging.Logger.getLogger(getClass().getPackageName()) + .log(java.util.logging.Level.FINE, "Console monitor start() called but already running, ignoring"); + return; + } + + if(pollTask!=null || (consoleWs != null && consoleWs.isConnected())) { + java.util.logging.Logger.getLogger(getClass().getPackageName()) + .log(java.util.logging.Level.FINE, "Console monitor start() called but already have active connections, ignoring"); + return; + } + + java.util.logging.Logger.getLogger(getClass().getPackageName()) + .log(java.util.logging.Level.FINE, "Console monitor starting"); + stop=false; synchronized(textBuf){ textBuf.clear(); } lastUid="ALL"; + synchronized (wsTextLock) { + wsTextBuffer.setLength(0); + } + + isRunning = true; + + // Load backlog in background thread to avoid blocking JavaFX thread + io.submit(this::loadBacklog); + + if (Preferences.use_websockets) { + startWebSocket(); + } else { + startStream(); + pollTask = PollCenter.everyMs(Preferences.update_interval_ms, this::poll); + } + } + + private void stop(){ + if(!isRunning) { + java.util.logging.Logger.getLogger(getClass().getPackageName()) + .log(java.util.logging.Level.FINE, "Console monitor stop() called but not running, ignoring"); + return; // Already stopped + } + + java.util.logging.Logger.getLogger(getClass().getPackageName()) + .log(java.util.logging.Level.FINE, "Console monitor stopping"); + + if(pollTask!=null){ pollTask.cancel(true); pollTask=null; } + if(consoleWs != null) { consoleWs.disconnect(); } + synchronized (wsTextLock) { + wsTextBuffer.setLength(0); + } + stop=true; + isRunning = false; + // Don't clear textBuf - keep last console output visible for users + } + + private void loadBacklog(){ + try{ + // These HTTP calls run in background thread (io executor) + String t = svc.consoleOutput(BACKLOG).text(); + String uid = svc.consoleOutputUid().uid(); + + // Process text in background thread (expensive string parsing) + if(!t.isEmpty()) { + synchronized (textBuf) { + textBuf.addMessage(t); + } + } + + // Update UI on JavaFX thread (just rendering) + Platform.runLater(() -> { + lastUid = uid; + render(); + + // Force scroll to bottom on initial load if autoscroll is enabled + // Multiple runLaters to ensure UI is fully laid out and text is rendered + if (autoscrollChk.isSelected()) { + Platform.runLater(() -> { + Platform.runLater(() -> { + Platform.runLater(() -> { + lastProgrammaticScroll = System.currentTimeMillis(); + textArea.positionCaret(textArea.getLength()); + textArea.setScrollTop(Double.MAX_VALUE); + if (vBar != null) { + vBar.setValue(vBar.getMax()); + } + }); + }); + }); + } + }); + }catch(Exception ignore){} + } + + private void startWebSocket(){ + consoleWs = svc.createConsoleOutputWebSocket(); + + // Buffer incoming WebSocket messages without immediately updating UI + consoleWs.addListener(msg -> { + String text = msg.msg(); + if (text != null && !text.isEmpty()) { + synchronized (wsTextLock) { + wsTextBuffer.append(text); + } + } + }); + + consoleWs.connect(); + + // Schedule throttled UI updates at the configured interval + pollTask = PollCenter.everyMs(Preferences.update_interval_ms, () -> { + String bufferedText; + synchronized (wsTextLock) { + if (wsTextBuffer.length() == 0) { + return; // Nothing to render + } + bufferedText = wsTextBuffer.toString(); + wsTextBuffer.setLength(0); + } + + Platform.runLater(() -> { + synchronized (textBuf) { + textBuf.addMessage(bufferedText); + } + render(); + lastLine = Instant.now(); + }); + }); + } + + private void startStream(){ + Task job = new Task<>(){ + @Override protected Void call(){ + try(var br = new BufferedReader( + new InputStreamReader(svc.streamConsoleOutput(), + StandardCharsets.UTF_8))){ + StringBuilder chunk = new StringBuilder(CHUNK); + for(String ln; !stop && (ln=br.readLine())!=null; ){ + if(!ln.isBlank()) + chunk.append(JSON.readTree(ln).path("msg").asText()); + if(chunk.length()>CHUNK){ + String out=chunk.toString(); chunk.setLength(0); + Platform.runLater(()->{ synchronized(textBuf){ textBuf.addMessage(out); } render(); }); + } + } + if(chunk.length()>0) + Platform.runLater(()->{ synchronized(textBuf){ textBuf.addMessage(chunk.toString()); } render(); }); + }catch(Exception ignore){} + return null; + } + }; + io.submit(job); + } + + private void poll(){ + if(stop||Instant.now().minusMillis(Preferences.update_interval_ms).isBefore(lastLine))return; + try{ + ConsoleOutputUpdate u = svc.consoleOutputUpdate(lastUid); + if(u.consoleOutputMsgs()!=null){ + StringBuilder sb=new StringBuilder(); + for(Map m:u.consoleOutputMsgs()) + sb.append((String)m.get("msg")); + if(sb.length()!=0){ synchronized(textBuf){ textBuf.addMessage(sb.toString()); } render(); } + } + lastUid=u.lastMsgUid(); + }catch(Exception ignore){} + } + + private void render() { + + final boolean wantBottom = autoscrollChk.isSelected(); + + int keepCaret = textArea.getCaretPosition(); + double keepScrollY = textArea.getScrollTop(); + + String text; + synchronized (textBuf) { + text = textBuf.tail(maxLines); + } + textArea.replaceText(0, textArea.getLength(), text); + + if (wantBottom) { + lastProgrammaticScroll = System.currentTimeMillis(); + Platform.runLater(() -> { + lastProgrammaticScroll = System.currentTimeMillis(); + textArea.positionCaret(textArea.getLength()); + textArea.setScrollTop(Double.MAX_VALUE); + if (vBar != null) vBar.setValue(vBar.getMax()); + }); + } else { + lastProgrammaticScroll = System.currentTimeMillis(); + textArea.positionCaret(Math.min(keepCaret, textArea.getLength())); + double y = keepScrollY; + Platform.runLater(() -> { + lastProgrammaticScroll = System.currentTimeMillis(); + textArea.setScrollTop(y); + }); + } + + lastLine = Instant.now(); + } + + private void scrollbarChanged(ObservableValue obs, + Number oldVal, Number newVal) { + + if (vBar == null) return; + + // If autoscroll is on, check if user scrolled away from bottom + if (autoscrollChk.isSelected()) { + // Ignore scroll events that happen within 100ms of programmatic scrolling + long timeSinceProgrammaticScroll = System.currentTimeMillis() - lastProgrammaticScroll; + if (timeSinceProgrammaticScroll < 100) { + return; // Too soon after programmatic scroll, ignore + } + + // Check if we're not at the bottom anymore (with small tolerance) + boolean atBottom = (vBar.getMax() - newVal.doubleValue()) < 2.0; + + // If not at bottom, user must have scrolled up - uncheck autoscroll + if (!atBottom) { + autoscrollChk.setSelected(false); + } + } + } + + private static int clamp(int v){ return Math.max(MIN_LINES,Math.min(MAX_LINES,v)); } + + private static final class ConsoleTextBuffer { + + private final int hardLimit; + private final List buf = new ArrayList<>(); + + private int line = 0; + private int pos = 0; + + private static final String NL = "\n"; + private static final String CR = "\r"; + private static final String UP_ONE_LINE = "\u001b[A"; // ESC[A + + ConsoleTextBuffer(int hardLimit) { + this.hardLimit = Math.max(hardLimit, 0); + } + + void clear() { + buf.clear(); + line = pos = 0; + } + + void addMessage(String msg) { + while (!msg.isEmpty()) { + // Find next control sequence + int nlIdx = msg.indexOf(NL); + int crIdx = msg.indexOf(CR); + int upIdx = msg.indexOf(UP_ONE_LINE); + + int next = minPos(nlIdx, crIdx, upIdx); + if (next < 0) next = msg.length(); + + // ---------------------------------------------------- + // FRAGMENT: plain text until control char + // ---------------------------------------------------- + if (next != 0) { + String frag = msg.substring(0, next); + msg = msg.substring(next); + + // Ensure we have at least one line + if (buf.isEmpty()) { + buf.add(""); + } + + ensureLineExists(line); + + // Extend current line with spaces if cursor is past EOL + int lineLen = buf.get(line).length(); + if (lineLen < pos) { + buf.set(line, buf.get(line) + " ".repeat(pos - lineLen)); + } + + // Insert/overwrite fragment at current position + String currentLine = buf.get(line); + String before = currentLine.substring(0, Math.min(pos, currentLine.length())); + String after = currentLine.substring(Math.min(pos + frag.length(), currentLine.length())); + buf.set(line, before + frag + after); + + pos += frag.length(); + continue; + } + + // ---------------------------------------------------- + // CONTROL SEQUENCES + // ---------------------------------------------------- + + if (nlIdx == 0) { + // Newline: move to next line + line++; + if (line >= buf.size()) { + buf.add(""); + } + pos = 0; + msg = msg.substring(NL.length()); + } + else if (crIdx == 0) { + // Carriage return: move to beginning of current line + pos = 0; + msg = msg.substring(CR.length()); + } + else if (upIdx == 0) { + // Move up one line + if (line > 0) { + line--; + } + pos = 0; + msg = msg.substring(UP_ONE_LINE.length()); + } + else { + // Shouldn't happen, but handle gracefully + if (!msg.isEmpty()) { + ensureLineExists(line); + buf.set(line, buf.get(line) + msg.charAt(0)); + pos++; + msg = msg.substring(1); + } + } + } + trim(); + } + + String tail(int n) { + if (n <= 0) return ""; + + // Remove trailing empty line if present + int visible = buf.size(); + if (visible > 0 && buf.get(visible - 1).isEmpty()) { + visible--; + } + + int start = Math.max(0, visible - n); + StringBuilder out = new StringBuilder(); + for (int i = start; i < visible; i++) { + out.append(buf.get(i)); + if (i + 1 < visible) out.append('\n'); + } + return out.toString(); + } + + private void ensureLineExists(int idx) { + while (buf.size() <= idx) { + buf.add(""); + } + } + + private void trim() { + // Keep some buffer beyond hardLimit to avoid constant trimming + int maxAllowed = hardLimit + 100; + while (buf.size() > maxAllowed) { + buf.remove(0); + line = Math.max(0, line - 1); + } + } + + private static int minPos(int... p) { + int m = Integer.MAX_VALUE; + for (int v : p) { + if (v >= 0 && v < m) m = v; + } + return m == Integer.MAX_VALUE ? -1 : m; + } + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReEnvironmentControlsController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReEnvironmentControlsController.java similarity index 80% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReEnvironmentControlsController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReEnvironmentControlsController.java index be72dfceb5..a5d9df3bc2 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReEnvironmentControlsController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReEnvironmentControlsController.java @@ -14,6 +14,7 @@ import java.net.URL; import java.util.Map; import java.util.ResourceBundle; +import java.util.logging.Level; import java.util.logging.Logger; public final class ReEnvironmentControlsController implements Initializable { @@ -23,10 +24,12 @@ public final class ReEnvironmentControlsController implements Initializable { @FXML private Button destroyBtn; private final RunEngineService svc = new RunEngineService(); - private final Logger LOG = Logger.getLogger(getClass().getName()); + private static final Logger logger = Logger.getLogger(ReEnvironmentControlsController.class.getPackageName()); @Override public void initialize(URL url, ResourceBundle rb) { - StatusBus.latest().addListener(this::onStatus); + StatusBus.addListener(this::onStatus); + // Check current value in case status was already set before listener added + refreshButtons(StatusBus.latest().get()); } private void onStatus(ObservableValue src, Object oldV, Object newV) { @@ -57,12 +60,12 @@ private void refreshButtons(Object statusObj) { @FXML private void open() { try { svc.environmentOpen(); } - catch (Exception ex) { LOG.warning("environmentOpen: " + ex); } + catch (Exception ex) { logger.log(Level.WARNING, "environmentOpen: " + ex); } } @FXML private void close() { try { svc.environmentClose(); } - catch (Exception ex) { LOG.warning("environmentClose: " + ex); } + catch (Exception ex) { logger.log(Level.WARNING, "environmentClose: " + ex); } } @FXML private void destroy() { @@ -75,9 +78,9 @@ private void refreshButtons(Object statusObj) { if (response == ButtonType.OK) { try { svc.environmentDestroy(); - LOG.info("Environment destroyed successfully"); + logger.log(Level.FINE, "Environment destroyed successfully"); } catch (Exception ex) { - LOG.warning("environmentDestroy: " + ex); + logger.log(Level.WARNING, "environmentDestroy: " + ex); } } }); diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReExecutionControlsController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReExecutionControlsController.java similarity index 91% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReExecutionControlsController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReExecutionControlsController.java index b8ab0f162a..83e20c3f79 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReExecutionControlsController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReExecutionControlsController.java @@ -12,6 +12,7 @@ import java.net.URL; import java.util.Map; import java.util.ResourceBundle; +import java.util.logging.Level; import java.util.logging.Logger; public final class ReExecutionControlsController implements Initializable { @@ -20,11 +21,13 @@ public final class ReExecutionControlsController implements Initializable { stopBtn, abortBtn, haltBtn; private final RunEngineService svc = new RunEngineService(); - private final Logger LOG = Logger.getLogger(getClass().getName()); + private static final Logger logger = Logger.getLogger(ReExecutionControlsController.class.getPackageName()); @Override public void initialize(URL url, ResourceBundle rb) { - StatusBus.latest().addListener(this::onStatus); + StatusBus.addListener(this::onStatus); + // Check current value in case status was already set before listener added + refreshButtons(StatusBus.latest().get()); pauseDefBtn.setOnAction(e -> call("rePause deferred", () -> { @@ -109,6 +112,6 @@ else if (statusObj instanceof Map m) { private void call(String label, Runnable r) { try { r.run(); } - catch (Exception ex) { LOG.warning(label + ": " + ex); } + catch (Exception ex) { logger.log(Level.WARNING, label + ": " + ex); } } } diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReManagerConnectionController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReManagerConnectionController.java new file mode 100644 index 0000000000..f6b96a55b3 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReManagerConnectionController.java @@ -0,0 +1,78 @@ +package org.phoebus.applications.queueserver.controller; + +import org.phoebus.applications.queueserver.util.ConnectionManager; +import org.phoebus.applications.queueserver.util.ConnectionManager.ConnectionState; +import javafx.fxml.FXML; +import javafx.scene.control.Label; +import javafx.scene.control.ToggleButton; + +/** + * Thin UI controller for the connection manager widget. + * All connection logic lives in {@link ConnectionManager}. + * Multiple instances of this controller (one per app) share the same + * ConnectionManager singleton, so connecting in one app connects both. + */ +public final class ReManagerConnectionController { + + @FXML private ToggleButton autoConnectToggle; + @FXML private Label connectionStatusLabel; + + private final ConnectionManager cm = ConnectionManager.getInstance(); + + @FXML + public void initialize() { + // Reflect current state immediately + updateUI(cm.getState()); + autoConnectToggle.setSelected(cm.isAutoConnect()); + + // Listen for shared state changes + cm.stateProperty().addListener((obs, oldState, newState) -> updateUI(newState)); + + // Auto-connect on startup if toggle is selected and not yet connected + if (autoConnectToggle.isSelected() + && cm.getState() == ConnectionState.DISCONNECTED) { + cm.start(); + } + } + + @FXML + private void toggleConnection() { + if (autoConnectToggle.isSelected()) { + cm.start(); + } else { + cm.stop(); + } + } + + private void updateUI(ConnectionState state) { + autoConnectToggle.setSelected(state != ConnectionState.DISCONNECTED); + + switch (state) { + case DISCONNECTED -> { + connectionStatusLabel.setText("OFFLINE"); + connectionStatusLabel.setStyle("-fx-text-fill: grey;"); + autoConnectToggle.setText("Connect"); + } + case CONNECTING -> { + connectionStatusLabel.setText("CONNECTING"); + connectionStatusLabel.setStyle("-fx-text-fill: grey;"); + autoConnectToggle.setText("Disconnect"); + } + case NETWORK_ERROR -> { + connectionStatusLabel.setText("NETWORK"); + connectionStatusLabel.setStyle("-fx-text-fill: #00008B;"); + autoConnectToggle.setText("Disconnect"); + } + case NO_STATUS -> { + connectionStatusLabel.setText("STATUS"); + connectionStatusLabel.setStyle("-fx-text-fill: red;"); + autoConnectToggle.setText("Disconnect"); + } + case CONNECTED -> { + connectionStatusLabel.setText("CONNECTED"); + connectionStatusLabel.setStyle("-fx-text-fill: green;"); + autoConnectToggle.setText("Disconnect"); + } + } + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanEditorController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanEditorController.java similarity index 77% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanEditorController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanEditorController.java index 587a979aa1..d1fc80df11 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanEditorController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanEditorController.java @@ -4,9 +4,13 @@ import org.apache.poi.ss.usermodel.DateUtil; import org.phoebus.applications.queueserver.api.*; import org.phoebus.applications.queueserver.client.RunEngineService; +import org.phoebus.applications.queueserver.util.PlansCache; +import org.phoebus.applications.queueserver.util.QueueItemSelectionEvent; +import org.phoebus.applications.queueserver.util.StatusBus; import org.phoebus.applications.queueserver.view.PlanEditEvent; import org.phoebus.applications.queueserver.view.TabSwitchEvent; import org.phoebus.applications.queueserver.view.ItemUpdateEvent; +import org.phoebus.applications.queueserver.util.PythonParameterConverter; import com.fasterxml.jackson.databind.ObjectMapper; import javafx.application.Platform; import javafx.geometry.Insets; @@ -50,7 +54,7 @@ public class RePlanEditorController implements Initializable { @FXML private TableColumn valueCol; private final RunEngineService svc = new RunEngineService(); - private static final Logger LOG = Logger.getLogger(RePlanEditorController.class.getName()); + private static final Logger logger = Logger.getLogger(RePlanEditorController.class.getPackageName()); private final ObservableList parameterRows = FXCollections.observableArrayList(); private final Map> allowedPlans = new HashMap<>(); private final Map> allowedInstructions = new HashMap<>(); @@ -64,6 +68,20 @@ public class RePlanEditorController implements Initializable { // Store original parameter values for reset functionality private final Map originalParameterValues = new HashMap<>(); + /** + * Get the Python converter for use in background threads ONLY. + * Uses the shared singleton instance. + * NEVER call this from JavaFX thread - it will cause UI freezes. + */ + private PythonParameterConverter getPythonConverter() { + PythonParameterConverter converter = PythonParameterConverter.getShared(); + if (converter == null) { + // Shared init not done yet - create inline (rare fallback) + converter = new PythonParameterConverter(); + } + return converter; + } + private class EditableTableCell extends TableCell { private TextField textField; @@ -88,9 +106,12 @@ protected void updateItem(String item, boolean empty) { setText(getString()); setGraphic(null); - // Style based on enabled state and add tooltip + // Style based on enabled state and validation + // NOTE: Use simple UI validation here - never call Python converter from JavaFX thread if (!row.isEnabled()) { setStyle("-fx-text-fill: grey;"); + } else if (!row.isValidForUI()) { + setStyle("-fx-text-fill: red;"); } else { setStyle(""); } @@ -132,15 +153,20 @@ public void commitEdit(String newValue) { ParameterRow row = getTableRow().getItem(); if (row != null) { row.setValue(newValue); + + // Update cell color based on Python validation + updateValidationColor(row); + switchToEditingMode(); updateButtonStates(); - // Update cell color based on validation - updateValidationColor(row); } } private void updateValidationColor(ParameterRow row) { - if (row.validate()) { + // NOTE: Use simple UI validation here - never call Python converter from JavaFX thread + if (!row.isEnabled()) { + setStyle("-fx-text-fill: grey;"); + } else if (row.isValidForUI()) { setStyle(""); } else { setStyle("-fx-text-fill: red;"); @@ -208,69 +234,30 @@ public ParameterRow(String name, boolean enabled, String value, String descripti public boolean isOptional() { return isOptional.get(); } public Object getDefaultValue() { return defaultValue; } - public Object getParsedValue() { - if (!enabled.get()) return defaultValue; + /** + * Simple UI validation that doesn't use Python converter. + * Only checks if required parameters have values. + * Use this for UI feedback (cell colors, button states). + */ + public boolean isValidForUI() { + if (!enabled.get()) { + return true; // Disabled parameters are always valid + } String valueStr = value.get(); if (valueStr == null || valueStr.trim().isEmpty()) { - return defaultValue; + return isOptional.get(); // Empty is valid only if optional } - try { - return parseLiteralValue(valueStr); - } catch (Exception e) { - return valueStr; - } + return true; // Has a value, assume valid for UI purposes } - private Object parseLiteralValue(String valueStr) throws Exception { - valueStr = valueStr.trim(); - - // Handle None/null - if ("None".equals(valueStr) || "null".equals(valueStr)) { - return null; - } - - // Handle booleans - if ("True".equals(valueStr) || "true".equals(valueStr)) { - return true; - } - if ("False".equals(valueStr) || "false".equals(valueStr)) { - return false; - } - - // Handle strings (quoted) - if ((valueStr.startsWith("'") && valueStr.endsWith("'")) || - (valueStr.startsWith("\"") && valueStr.endsWith("\""))) { - return valueStr.substring(1, valueStr.length() - 1); - } - - // Handle numbers - try { - if (valueStr.contains(".")) { - return Double.parseDouble(valueStr); - } else { - return Long.parseLong(valueStr); - } - } catch (NumberFormatException e) { - // Continue to other parsing attempts - } - - // Handle lists and dicts using JSON parsing (similar to Python's literal_eval) - if (valueStr.startsWith("[") || valueStr.startsWith("{")) { - try { - ObjectMapper mapper = new ObjectMapper(); - return mapper.readValue(valueStr, Object.class); - } catch (Exception e) { - // Fall back to string if JSON parsing fails - } - } - - // Default to string - return valueStr; - } - - public boolean validate() { + /** + * Full validation using Python converter. + * NEVER call this from JavaFX thread - it will cause UI freezes! + * Only use in background threads before submitting to API. + */ + public boolean validate(PythonParameterConverter converter) { if (!enabled.get()) { return true; // Disabled parameters are always valid } @@ -280,8 +267,18 @@ public boolean validate() { return isOptional.get(); } + // Validate using Python converter try { - getParsedValue(); + List testParams = List.of( + new PythonParameterConverter.ParameterInfo( + getName(), + valueStr, + true, + isOptional.get(), + getDefaultValue() + ) + ); + converter.convertParameters(testParams); return true; } catch (Exception e) { return false; @@ -298,17 +295,64 @@ public boolean isEditable() { public void initialize(URL location, ResourceBundle resources) { initializeTable(); initializeControls(); - loadAllowedPlansAndInstructions(); + initializeAllowedInstructions(); + + // Use shared plans cache - copy to local map when loaded + if (PlansCache.isLoaded()) { + allowedPlans.clear(); + allowedPlans.putAll(PlansCache.get()); + } + + // Listen for plans cache updates + PlansCache.addListener((o, oldV, newV) -> { + Platform.runLater(() -> { + allowedPlans.clear(); + if (newV != null) { + allowedPlans.putAll(newV); + } + }); + }); + + // Listen for status changes to update button states and clear on disconnect + StatusBus.addListener((o, oldV, newV) -> { + // Clear the editor state when disconnected + if (newV == null) { + Platform.runLater(this::cancelEdit); + } + Platform.runLater(this::updateButtonStates); + }); // Listen for edit requests from plan viewer PlanEditEvent.getInstance().addListener(this::editItem); } + private void initializeAllowedInstructions() { + Map queueStopInstr = new HashMap<>(); + queueStopInstr.put("name", "queue_stop"); + queueStopInstr.put("description", "Stop execution of the queue."); + queueStopInstr.put("parameters", List.of()); + allowedInstructions.put("queue_stop", queueStopInstr); + } + private void initializeTable() { paramCol.setCellValueFactory(new PropertyValueFactory<>("name")); chkCol.setCellValueFactory(new PropertyValueFactory<>("enabled")); valueCol.setCellValueFactory(new PropertyValueFactory<>("value")); + // Fix paramCol and chkCol widths - not resizable + paramCol.setMinWidth(120); + paramCol.setPrefWidth(120); + paramCol.setMaxWidth(120); + paramCol.setResizable(false); + + chkCol.setMinWidth(30); + chkCol.setPrefWidth(30); + chkCol.setMaxWidth(30); + chkCol.setResizable(false); + + // valueCol fills remaining space + valueCol.setMinWidth(50); + // Add tooltips to parameter names paramCol.setCellFactory(column -> { TableCell cell = new TableCell() { @@ -352,6 +396,7 @@ protected void updateItem(String item, boolean empty) { row.setEnabled(isChecked); // If unchecked, reset to default value; if checked and no value, set default + // NOTE: Use simple string conversion here - never call Python converter from JavaFX thread if (!isChecked) { Object defaultValue = row.getDefaultValue(); row.setValue(defaultValue != null ? String.valueOf(defaultValue) : ""); @@ -363,11 +408,13 @@ protected void updateItem(String item, boolean empty) { switchToEditingMode(); updateButtonStates(); - autoResizeColumns(); }); table.setItems(parameterRows); table.setEditable(true); + + // Make Value column fill remaining space + table.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY); } private void initializeControls() { @@ -379,6 +426,13 @@ private void initializeControls() { // Setup ChoiceBox to auto-size to fit content exactly setupChoiceBoxAutoSizing(); + // Lazy populate when user opens the dropdown (avoids UI freeze during connection) + choiceBox.setOnShowing(event -> { + if (choiceBox.getItems().isEmpty() && !allowedPlans.isEmpty()) { + populateChoiceBox(planRadBtn.isSelected()); + } + }); + choiceBox.getSelectionModel().selectedItemProperty().addListener((obs, oldVal, newVal) -> { if (newVal != null) { loadParametersForSelection(newVal); @@ -413,48 +467,6 @@ private void initializeControls() { updateButtonStates(); } - private void loadAllowedPlansAndInstructions() { - new Thread(() -> { - try { - // Load plans from API - use raw Map instead of Envelope since response structure doesn't match - Map responseMap = svc.plansAllowedRaw(); - - if (responseMap != null && Boolean.TRUE.equals(responseMap.get("success"))) { - allowedPlans.clear(); - - if (responseMap.containsKey("plans_allowed")) { - Map plansData = (Map) responseMap.get("plans_allowed"); - - // Convert each plan entry to Map - for (Map.Entry entry : plansData.entrySet()) { - String planName = entry.getKey(); - Map planInfo = (Map) entry.getValue(); - allowedPlans.put(planName, planInfo); - } - } else { - LOG.log(Level.WARNING, "No 'plans_allowed' key in response. Keys: " + responseMap.keySet()); - } - } else { - LOG.log(Level.WARNING, "Plans response failed. Response: " + responseMap); - } - - allowedInstructions.clear(); - Map queueStopInstr = new HashMap<>(); - queueStopInstr.put("name", "queue_stop"); - queueStopInstr.put("description", "Stop execution of the queue."); - queueStopInstr.put("parameters", List.of()); - allowedInstructions.put("queue_stop", queueStopInstr); - - Platform.runLater(() -> { - populateChoiceBox(planRadBtn.isSelected()); - }); - - } catch (Exception e) { - LOG.log(Level.WARNING, "Failed to load plans", e); - } - }).start(); - } - private void populateChoiceBox(boolean isPlans) { choiceBox.getItems().clear(); parameterRows.clear(); @@ -541,13 +553,12 @@ private void loadParametersForSelection(String selectedName) { if (currentKwargs.containsKey(paramName)) { Object value = currentKwargs.get(paramName); - currentValue = value != null ? String.valueOf(value) : ""; + currentValue = value != null ? PythonParameterConverter.toPythonRepr(value) : ""; isEnabled = true; } else if (defaultValue != null) { + // Use simple string conversion - Python parsing will happen in background thread later + // NOTE: Never call Python converter from JavaFX thread to avoid UI freezes currentValue = String.valueOf(defaultValue); - if (!isEditMode) { - currentValue += " (default)"; - } } ParameterRow row = new ParameterRow(paramName, isEnabled, currentValue, description, isOptional, defaultValue); @@ -559,7 +570,6 @@ private void loadParametersForSelection(String selectedName) { } updateButtonStates(); - autoResizeColumns(); } private void addMetadataAndResults(QueueItem item) { @@ -620,29 +630,11 @@ private String formatResultValue(Object value) { return String.valueOf(value); } - private void autoResizeColumns() { - table.setColumnResizePolicy(TableView.UNCONSTRAINED_RESIZE_POLICY); - for (TableColumn col : table.getColumns()) { - - Text tmp = new Text(col.getText()); - double max = tmp.getLayoutBounds().getWidth(); - - for (int i = 0; i < parameterRows.size(); i++) { - Object cell = col.getCellData(i); - if (cell != null) { - tmp = new Text(cell.toString()); - double w = tmp.getLayoutBounds().getWidth(); - if (w > max) max = w; - } - } - col.setPrefWidth(max + 14); - } - } - private boolean areParametersValid() { + // NOTE: Use simple UI validation here - never call Python converter from JavaFX thread boolean allValid = true; for (ParameterRow row : parameterRows) { - boolean rowValid = row.validate(); + boolean rowValid = row.isValidForUI(); if (!rowValid) { allValid = false; } @@ -661,28 +653,56 @@ private void updateRowValidationStyle(ParameterRow row, boolean isValid) { } private void updateButtonStates() { + StatusResponse status = StatusBus.latest().get(); + boolean isConnected = status != null; + boolean hasSelectedPlan = choiceBox.getSelectionModel().getSelectedItem() != null; boolean isValid = areParametersValid(); - boolean isConnected = true; // Assume connected for now - could check StatusBus later this.editorStateValid = isValid; - planRadBtn.setDisable(isEditMode); - instrRadBtn.setDisable(isEditMode); - choiceBox.setDisable(isEditMode); + // Disable controls when not connected (environment open not required) + table.setDisable(!isConnected); + planRadBtn.setDisable(!isConnected || isEditMode); + instrRadBtn.setDisable(!isConnected || isEditMode); + choiceBox.setDisable(!isConnected || isEditMode); - addBtn.setDisable(!hasSelectedPlan || !isValid || !isConnected); + addBtn.setDisable(!isConnected || !hasSelectedPlan || !isValid); - saveBtn.setDisable(!isEditMode || !hasSelectedPlan || !isValid || !isConnected || + saveBtn.setDisable(!isConnected || !isEditMode || !hasSelectedPlan || !isValid || !"QUEUE ITEM".equals(currentItemSource)); batchBtn.setDisable(!isConnected); - resetBtn.setDisable(!isEditMode); - cancelBtn.setDisable(!isEditMode); + resetBtn.setDisable(!isConnected || !isEditMode); + cancelBtn.setDisable(!isConnected || !isEditMode); + } + + /** + * Build kwargs map using Python-based type conversion. + * All type conversion is handled by Python script using ast.literal_eval. + */ + private Map buildKwargsWithPython() { + List paramInfos = new ArrayList<>(); + + for (ParameterRow row : parameterRows) { + PythonParameterConverter.ParameterInfo paramInfo = + new PythonParameterConverter.ParameterInfo( + row.getName(), + row.getValue(), + row.isEnabled(), + row.isOptional(), + row.getDefaultValue() + ); + paramInfos.add(paramInfo); + } + + // Use Python to convert parameters - no Java fallback + return getPythonConverter().convertParameters(paramInfos); } private void addItemToQueue() { if (!areParametersValid()) { + showValidationError("Some parameters have invalid values. Please check the red fields."); return; } @@ -693,63 +713,81 @@ private void addItemToQueue() { } String itemType = planRadBtn.isSelected() ? "plan" : "instruction"; - Map kwargs = new HashMap<>(); - - for (ParameterRow row : parameterRows) { - if (row.isEnabled()) { - kwargs.put(row.getName(), row.getParsedValue()); - } - } - - QueueItem item = new QueueItem( - itemType, - selectedName, - List.of(), - kwargs, - null, - currentUser, - currentUserGroup, - null - ); - QueueItemAdd request = new QueueItemAdd( - new QueueItemAdd.Item(item.itemType(), item.name(), item.args(), item.kwargs()), - currentUser, - currentUserGroup - ); + // Capture insert position before starting background thread + String afterUid = QueueItemSelectionEvent.getInstance().getLastSelectedUid(); new Thread(() -> { try { - var response = svc.queueItemAdd(request); + // Use Python-based parameter conversion (in background thread to avoid blocking UI) + Map kwargs = buildKwargsWithPython(); + + QueueItem item = new QueueItem( + itemType, + selectedName, + List.of(), + kwargs, + null, + currentUser, + currentUserGroup, + null + ); + + QueueItemAdd request = new QueueItemAdd( + new QueueItemAdd.Item(item.itemType(), item.name(), item.args(), item.kwargs()), + currentUser, + currentUserGroup, + afterUid + ); + + String newUid = svc.addItemGetUid(request); + QueueItemSelectionEvent.getInstance().requestSelectByUids(List.of(newUid)); Platform.runLater(() -> { - if (response.success()) { - // Clear parameters but preserve radio button selection - parameterRows.clear(); - choiceBox.getSelectionModel().clearSelection(); - // Don't reset radio button - keep current selection - populateChoiceBox(planRadBtn.isSelected()); - // Switch to view tab - TabSwitchEvent.getInstance().switchToTab("Plan Viewer"); - exitEditMode(); - showItemPreview(); - } + // Clear parameters but preserve radio button selection + parameterRows.clear(); + choiceBox.getSelectionModel().clearSelection(); + // Don't reset radio button - keep current selection + populateChoiceBox(planRadBtn.isSelected()); + // Switch to view tab + TabSwitchEvent.getInstance().switchToTab("Plan Viewer"); + exitEditMode(); + showItemPreview(); }); } catch (Exception e) { - e.printStackTrace(); + logger.log(Level.WARNING, "Failed to add item to queue", e); + Platform.runLater(() -> { + String errorMsg = e.getMessage(); + if (errorMsg == null || errorMsg.isEmpty()) { + errorMsg = e.getClass().getSimpleName(); + } + showValidationError("Failed to add item to queue: " + errorMsg); + }); } }).start(); } catch (Exception e) { - e.printStackTrace(); + logger.log(Level.SEVERE, "Failed to add item to queue", e); + Platform.runLater(() -> { + showValidationError("Failed to add item: " + e.getMessage()); + }); } } + private void showValidationError(String message) { + Alert alert = new Alert(Alert.AlertType.ERROR); + alert.setTitle("Validation Error"); + alert.setHeaderText(null); + alert.setContentText(message); + alert.showAndWait(); + } + private void saveItem() { if (!isEditMode || currentItem == null) { return; } if (!areParametersValid()) { + showValidationError("Some parameters have invalid values. Please check the red fields."); return; } @@ -760,27 +798,27 @@ private void saveItem() { } String itemType = planRadBtn.isSelected() ? "plan" : "instruction"; - Map kwargs = new HashMap<>(); - - for (ParameterRow row : parameterRows) { - if (row.isEnabled()) { - kwargs.put(row.getName(), row.getParsedValue()); - } - } - - QueueItem updatedItem = new QueueItem( - itemType, - selectedName, - List.of(), - kwargs, - currentItem.itemUid(), - currentItem.user(), - currentItem.userGroup(), - currentItem.result() - ); + String itemUid = currentItem.itemUid(); + String user = currentItem.user(); + String userGroup = currentItem.userGroup(); + Map result = currentItem.result(); new Thread(() -> { try { + // Use Python-based parameter conversion (in background thread to avoid blocking UI) + Map kwargs = buildKwargsWithPython(); + + QueueItem updatedItem = new QueueItem( + itemType, + selectedName, + List.of(), + kwargs, + itemUid, + user, + userGroup, + result + ); + var response = svc.queueItemUpdate(updatedItem); Platform.runLater(() -> { if (response.success()) { @@ -795,16 +833,26 @@ private void saveItem() { exitEditMode(); showItemPreview(); } else { - LOG.log(Level.WARNING, "Save failed: " + response.msg()); + showValidationError("Failed to save item: " + response.msg()); } }); } catch (Exception e) { - LOG.log(Level.WARNING, "Save error", e); + logger.log(Level.WARNING, "Failed to save item", e); + Platform.runLater(() -> { + String errorMsg = e.getMessage(); + if (errorMsg == null || errorMsg.isEmpty()) { + errorMsg = e.getClass().getSimpleName(); + } + showValidationError("Failed to save item: " + errorMsg); + }); } }).start(); } catch (Exception e) { - e.printStackTrace(); + logger.log(Level.SEVERE, "Failed to save item", e); + Platform.runLater(() -> { + showValidationError("Failed to save item: " + e.getMessage()); + }); } } @@ -823,35 +871,28 @@ private void resetParametersToDefaults() { if (originalParameterValues.containsKey(paramName)) { // Restore original value Object originalValue = originalParameterValues.get(paramName); - row.setValue(originalValue != null ? String.valueOf(originalValue) : ""); + row.setValue(originalValue != null ? PythonParameterConverter.toPythonRepr(originalValue) : ""); row.setEnabled(true); } else { // Parameter was not in original item, reset to default + // NOTE: Use simple string conversion - never call Python converter from JavaFX thread Object defaultValue = row.getDefaultValue(); - if (defaultValue != null) { - row.setValue(String.valueOf(defaultValue)); - } else { - row.setValue(""); - } + row.setValue(defaultValue != null ? String.valueOf(defaultValue) : ""); row.setEnabled(!row.isOptional()); } } } else { // Reset to default values for new items + // NOTE: Use simple string conversion - never call Python converter from JavaFX thread for (ParameterRow row : parameterRows) { Object defaultValue = row.getDefaultValue(); - if (defaultValue != null) { - row.setValue(String.valueOf(defaultValue)); - } else { - row.setValue(""); - } + row.setValue(defaultValue != null ? String.valueOf(defaultValue) : ""); // Reset enabled state based on whether parameter is optional row.setEnabled(!row.isOptional()); } } // Keep edit mode active after reset - don't exit edit mode updateButtonStates(); - autoResizeColumns(); } private void cancelEdit() { @@ -923,6 +964,9 @@ private void openBatchUpload() { } private void processBatchFile(String filePath, String fileType) { + // Capture insert position before starting background thread + String afterUid = QueueItemSelectionEvent.getInstance().getLastSelectedUid(); + new Thread(() -> { try { List items = new ArrayList<>(); @@ -936,23 +980,16 @@ private void processBatchFile(String filePath, String fileType) { if (!items.isEmpty()) { final int itemCount = items.size(); - QueueItemAddBatch batchRequest = new QueueItemAddBatch(items, currentUser, currentUserGroup); - var response = svc.queueItemAddBatch(batchRequest); + QueueItemAddBatch batchRequest = new QueueItemAddBatch(items, currentUser, currentUserGroup, afterUid); + List newUids = svc.addBatchGetUids(batchRequest); + QueueItemSelectionEvent.getInstance().requestSelectByUids(newUids); Platform.runLater(() -> { - if (response.success()) { - Alert alert = new Alert(Alert.AlertType.INFORMATION); - alert.setTitle("Batch Upload Success"); - alert.setHeaderText(null); - alert.setContentText("Successfully added " + itemCount + " items to queue."); - alert.showAndWait(); - } else { - Alert alert = new Alert(Alert.AlertType.ERROR); - alert.setTitle("Batch Upload Failed"); - alert.setHeaderText(null); - alert.setContentText("Failed to add items to queue: " + response.msg()); - alert.showAndWait(); - } + Alert alert = new Alert(Alert.AlertType.INFORMATION); + alert.setTitle("Batch Upload Success"); + alert.setHeaderText(null); + alert.setContentText("Successfully added " + itemCount + " items to queue."); + alert.showAndWait(); }); } else { Platform.runLater(() -> { @@ -965,7 +1002,7 @@ private void processBatchFile(String filePath, String fileType) { } } catch (Exception e) { - LOG.log(Level.WARNING, "Batch file processing error", e); + logger.log(Level.WARNING, "Batch file processing error", e); Platform.runLater(() -> { Alert alert = new Alert(Alert.AlertType.ERROR); alert.setTitle("Error"); diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanHistoryController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanHistoryController.java similarity index 58% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanHistoryController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanHistoryController.java index c2a1e161c9..10f7ed7ec8 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanHistoryController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanHistoryController.java @@ -7,6 +7,9 @@ import org.phoebus.applications.queueserver.api.QueueItemAddBatch; import org.phoebus.applications.queueserver.api.StatusResponse; import org.phoebus.applications.queueserver.client.RunEngineService; +import org.phoebus.applications.queueserver.util.PlansCache; +import org.phoebus.applications.queueserver.util.PythonParameterConverter; +import org.phoebus.applications.queueserver.util.QueueItemSelectionEvent; import org.phoebus.applications.queueserver.util.StatusBus; import javafx.application.Platform; import javafx.beans.property.ReadOnlyObjectWrapper; @@ -29,6 +32,7 @@ import java.time.ZoneId; import java.time.format.DateTimeFormatter; import java.util.*; +import java.util.logging.Level; import java.util.logging.Logger; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -46,14 +50,19 @@ public final class RePlanHistoryController implements Initializable { private final RunEngineService svc = new RunEngineService(); private final ObservableListrows = FXCollections.observableArrayList(); private final Map uid2item = new HashMap<>(); + private final Map> allowedPlans = new HashMap<>(); + private final Map> allowedInstructions = new HashMap<>(); private List stickySel = List.of(); private boolean ignoreSel = false; - private static final Logger LOG = - Logger.getLogger(RePlanHistoryController.class.getName()); + private static final Logger logger = + Logger.getLogger(RePlanHistoryController.class.getPackageName()); private final boolean viewOnly; + // Drag-to-select state + private int dragStartRow = -1; + public RePlanHistoryController() { this(false); // default to editable } @@ -102,48 +111,153 @@ public RePlanHistoryController(boolean viewOnly) { List.copyOf(table.getSelectionModel().getSelectedIndices()); }); + initializeAllowedInstructions(); + + if (PlansCache.isLoaded()) { + allowedPlans.clear(); + allowedPlans.putAll(PlansCache.get()); + } + PlansCache.addListener((o2, oldP, newP) -> { + Platform.runLater(() -> { + allowedPlans.clear(); + if (newP != null) allowedPlans.putAll(newP); + }); + }); + ChangeListener l = - (o,oldV,nv) -> Platform.runLater(() -> refresh(nv)); - StatusBus.latest().addListener(l); + (o,oldV,nv) -> { + // Run refresh in background thread to avoid blocking UI + new Thread(() -> refresh(nv)).start(); + }; + StatusBus.addListener(l); + + // Add drag-to-select functionality + setupDragSelection(); - refresh(StatusBus.latest().get()); + // Run initial refresh in background thread + new Thread(() -> refresh(StatusBus.latest().get())).start(); + } + + /** + * Sets up drag-to-select functionality for the table. + * Users can click and drag to select multiple rows. + */ + private void setupDragSelection() { + table.setOnMousePressed(event -> { + int index = getRowIndexAt(event.getY()); + if (index >= 0 && index < rows.size()) { + dragStartRow = index; + // Don't consume - let normal click work + } else { + dragStartRow = -1; + } + }); + + table.setOnMouseDragged(event -> { + if (dragStartRow >= 0) { + int currentIndex = getRowIndexAt(event.getY()); + if (currentIndex >= 0 && currentIndex < rows.size()) { + selectRange(dragStartRow, currentIndex); + } + event.consume(); // Prevent default drag behavior + } + }); + + table.setOnMouseReleased(event -> { + dragStartRow = -1; + }); + } + + /** + * Gets the row index at the specified Y coordinate relative to the table. + */ + private int getRowIndexAt(double y) { + // Get the fixed cell size or estimate + if (rows.isEmpty()) return -1; + + // Look through visible rows + for (javafx.scene.Node node : table.lookupAll(".table-row-cell")) { + if (node instanceof TableRow) { + @SuppressWarnings("unchecked") + TableRow row = (TableRow) node; + + // Convert to table's coordinate space + javafx.geometry.Bounds boundsInTable = table.sceneToLocal( + row.localToScene(row.getBoundsInLocal()) + ); + + if (y >= boundsInTable.getMinY() && y <= boundsInTable.getMaxY()) { + return row.getIndex(); + } + } + } + return -1; + } + + /** + * Selects all rows between start and end indices (inclusive). + */ + private void selectRange(int start, int end) { + table.getSelectionModel().clearSelection(); + int from = Math.min(start, end); + int to = Math.max(start, end); + for (int i = from; i <= to; i++) { + table.getSelectionModel().select(i); + } } private void refresh(StatusResponse st) { if (st == null) { - ignoreSel = true; rows.clear(); uid2item.clear(); ignoreSel = false; - updateButtonStates(); return; + // Don't clear history - keep last data visible for users + // Just update button states (will be disabled via StatusBus) + Platform.runLater(this::updateButtonStates); + return; } try { + // Blocking HTTP call - runs on background thread HistoryGetPayload hp = svc.historyGetTyped(); // typed DTO - ignoreSel = true; - rebuildRows(hp.items()); - ignoreSel = false; - restoreSelection(stickySel); - } catch (Exception ex) { - LOG.warning("History refresh failed: "+ex.getMessage()); - } - } + List items = hp.items(); - private void rebuildRows(List items) { - rows.clear(); uid2item.clear(); - if (items == null) { updateButtonStates(); return; } - - for (QueueItem qi : items) { - rows.add(new Row( - qi.itemUid(), - qi.itemType(), - qi.name(), - exitStatus(qi), - fmtParams(qi), - qi.user(), - qi.userGroup())); - uid2item.put(qi.itemUid(), qi); + if (items == null) { + Platform.runLater(() -> { + rows.clear(); + uid2item.clear(); + updateButtonStates(); + }); + return; + } + + // Build rows in background thread (expensive fmtParams processing) + List newRows = new ArrayList<>(items.size()); + Map newUidMap = new HashMap<>(); + for (QueueItem qi : items) { + newRows.add(new Row( + qi.itemUid(), + qi.itemType(), + qi.name(), + exitStatus(qi), + fmtParams(qi), + qi.user(), + qi.userGroup())); + newUidMap.put(qi.itemUid(), qi); + } + + // UI updates on FX thread + Platform.runLater(() -> { + ignoreSel = true; + rows.setAll(newRows); + uid2item.clear(); + uid2item.putAll(newUidMap); + autoResizeColumns(); + ignoreSel = false; + restoreSelection(stickySel); + updateButtonStates(); + }); + } catch (Exception ex) { + logger.log(Level.FINE, "History refresh failed: " + ex.getMessage()); } - autoResizeColumns(); - updateButtonStates(); } private void hookButtons() { @@ -167,6 +281,9 @@ private void copySelectedToQueue() { var sel = table.getSelectionModel().getSelectedIndices(); if (sel.isEmpty()) return; + // Capture insert position before starting background thread + String afterUid = QueueItemSelectionEvent.getInstance().getLastSelectedUid(); + List clones = sel.stream() .map(rows::get) .map(r -> uid2item.get(r.uid)) @@ -183,18 +300,21 @@ private void copySelectedToQueue() { )) .toList(); - try { - QueueItemAddBatch req = - new QueueItemAddBatch(clones, "GUI Client", "primary"); - svc.queueItemAddBatch(req); // service takes DTO, not Map - } catch (Exception ex) { - LOG.warning("Copy-to-Queue failed: "+ex.getMessage()); - } + new Thread(() -> { + try { + QueueItemAddBatch req = + new QueueItemAddBatch(clones, "GUI Client", "primary", afterUid); + List newUids = svc.addBatchGetUids(req); + QueueItemSelectionEvent.getInstance().requestSelectByUids(newUids); + } catch (Exception ex) { + logger.log(Level.WARNING, "Copy-to-Queue failed", ex); + } + }).start(); } private void clearHistory() { try { svc.historyClear(); } - catch (Exception ex) { LOG.warning("Clear-history failed: "+ex.getMessage()); } + catch (Exception ex) { logger.log(Level.WARNING, "Clear-history failed", ex); } } private void exportHistory(PlanHistorySaver.Format fmt, String ext) { @@ -209,15 +329,16 @@ private void exportHistory(PlanHistorySaver.Format fmt, String ext) { HistoryGetPayload hp = svc.historyGetTyped(); List items = hp.items(); PlanHistorySaver.save(items, f, fmt); - LOG.info(() -> "Exported plan history → " + f); + logger.log(Level.FINE, () -> "Exported plan history → " + f); } catch (Exception e) { - LOG.warning("Export history failed: " + e.getMessage()); + logger.log(Level.WARNING, "Export history failed", e); } }); } private void updateButtonStates() { - boolean connected = StatusBus.latest().get() != null; + StatusResponse status = StatusBus.latest().get(); + boolean connected = status != null; boolean hasSel = !table.getSelectionModel().getSelectedIndices().isEmpty(); if (viewOnly) { @@ -225,8 +346,10 @@ private void updateButtonStates() { clearBtn.setDisable(true); deselectBtn.setDisable(!hasSel); } else { + // Only require server connection (not environment open) copyBtn.setDisable(!(connected && hasSel)); clearBtn.setDisable(!(connected && !rows.isEmpty())); + // Deselect and export always enabled when there's data deselectBtn.setDisable(!hasSel); } } @@ -266,17 +389,56 @@ private void restoreSelection(Collection idx) { private static String firstLetter(String s){ return (s==null||s.isBlank())?"":s.substring(0,1).toUpperCase(); } - private static String fmtParams(QueueItem q){ + private void initializeAllowedInstructions() { + Map queueStopInstr = new HashMap<>(); + queueStopInstr.put("name", "queue_stop"); + queueStopInstr.put("description", "Stop execution of the queue."); + queueStopInstr.put("parameters", List.of()); + allowedInstructions.put("queue_stop", queueStopInstr); + } + + @SuppressWarnings("unchecked") + private String fmtParams(QueueItem q){ String a = Optional.ofNullable(q.args()).orElse(List.of()) - .stream().map(Object::toString).collect(Collectors.joining(", ")); - String k = Optional.ofNullable(q.kwargs()).orElse(Map.of()) - .entrySet().stream() - .map(e -> e.getKey()+": "+e.getValue()) + .stream().map(PythonParameterConverter::toPythonRepr) .collect(Collectors.joining(", ")); + + Map itemInfo = null; + if ("plan".equals(q.itemType())) { + itemInfo = allowedPlans.get(q.name()); + } else if ("instruction".equals(q.itemType())) { + itemInfo = allowedInstructions.get(q.name()); + } + + String k; + if (itemInfo != null) { + List> parameters = + (List>) itemInfo.get("parameters"); + if (parameters != null) { + Map kwargs = Optional.ofNullable(q.kwargs()).orElse(Map.of()); + k = parameters.stream() + .map(p -> (String) p.get("name")) + .filter(kwargs::containsKey) + .map(name -> name + ": " + PythonParameterConverter.toPythonRepr(kwargs.get(name))) + .collect(Collectors.joining(", ")); + } else { + k = formatKwargsDefault(q.kwargs()); + } + } else { + k = formatKwargsDefault(q.kwargs()); + } + return Stream.of(a,k).filter(s->!s.isEmpty()) .collect(Collectors.joining(", ")); } + private static String formatKwargsDefault(Map kwargs) { + return Optional.ofNullable(kwargs).orElse(Map.of()) + .entrySet().stream() + .map(e -> e.getKey() + ": " + PythonParameterConverter.toPythonRepr(e.getValue())) + .collect(Collectors.joining(", ")); + } + private static String exitStatus(QueueItem q){ Map res = q.result(); diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanManagerController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanManagerController.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanManagerController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanManagerController.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanQueueController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanQueueController.java similarity index 59% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanQueueController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanQueueController.java index b1c2183264..6549edd67a 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanQueueController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanQueueController.java @@ -5,8 +5,10 @@ import org.phoebus.applications.queueserver.api.QueueItem; import org.phoebus.applications.queueserver.api.StatusResponse; import org.phoebus.applications.queueserver.client.RunEngineService; +import org.phoebus.applications.queueserver.util.PlansCache; import org.phoebus.applications.queueserver.util.StatusBus; import org.phoebus.applications.queueserver.util.QueueItemSelectionEvent; +import org.phoebus.applications.queueserver.util.PythonParameterConverter; import javafx.application.Platform; import javafx.beans.property.ReadOnlyObjectWrapper; import javafx.beans.property.ReadOnlyStringWrapper; @@ -22,6 +24,8 @@ import java.net.URL; import java.util.*; +import java.util.concurrent.atomic.AtomicLong; +import java.util.logging.Level; import java.util.logging.Logger; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -39,11 +43,14 @@ public final class RePlanQueueController implements Initializable { private final RunEngineService svc = new RunEngineService(); private final ObservableList rows = FXCollections.observableArrayList(); private final Map uid2item = new HashMap<>(); + private final Map> allowedPlans = new HashMap<>(); + private final Map> allowedInstructions = new HashMap<>(); private List stickySel = List.of(); // last user selection private boolean ignoreSticky= false; // guard while we rebuild + private final AtomicLong refreshSeq = new AtomicLong(); // discard stale bg refreshes - private static final Logger LOG = - Logger.getLogger(RePlanQueueController.class.getName()); + private static final Logger logger = + Logger.getLogger(RePlanQueueController.class.getPackageName()); private final boolean viewOnly; @@ -105,39 +112,114 @@ public RePlanQueueController(boolean viewOnly) { } }); - ChangeListener poll = - (o,oldV,newV) -> Platform.runLater(() -> refresh(newV, List.of())); - StatusBus.latest().addListener(poll); + initializeAllowedInstructions(); + + // Use shared plans cache - copy to local map when loaded + if (PlansCache.isLoaded()) { + allowedPlans.clear(); + allowedPlans.putAll(PlansCache.get()); + } + + // Listen for plans cache updates + PlansCache.addListener((o, oldV, newV) -> { + Platform.runLater(() -> { + allowedPlans.clear(); + if (newV != null) { + allowedPlans.putAll(newV); + } + }); + }); - refresh(StatusBus.latest().get(), List.of()); + // Listen for status changes to refresh queue + ChangeListener poll = + (o,oldV,newV) -> { + long seq = refreshSeq.incrementAndGet(); + new Thread(() -> bgRefresh(newV, seq)).start(); + }; + StatusBus.addListener(poll); + + // Initial refresh on background thread + long seq = refreshSeq.incrementAndGet(); + new Thread(() -> bgRefresh(StatusBus.latest().get(), seq)).start(); } - private void refresh(StatusResponse st, Collection explicitFocus) { + private void initializeAllowedInstructions() { + Map queueStopInstr = new HashMap<>(); + queueStopInstr.put("name", "queue_stop"); + queueStopInstr.put("description", "Stop execution of the queue."); + queueStopInstr.put("parameters", List.of()); + allowedInstructions.put("queue_stop", queueStopInstr); + } + /** + * Background refresh: fetches queue data on a worker thread, then applies + * it on the FX thread. Uses a generation counter ({@code seq}) so that + * out-of-order responses are silently discarded – only the latest data is + * ever applied to the UI. + */ + private void bgRefresh(StatusResponse st, long seq) { if (st == null) { - ignoreSticky = true; - rows.clear(); uid2item.clear(); - ignoreSticky = false; - updateButtonStates(); + Platform.runLater(() -> { + if (seq < refreshSeq.get()) return; + updateButtonStates(); + }); return; } try { QueueGetPayload qp = svc.queueGetTyped(); - ignoreSticky = true; - rebuildRows(qp.queue()); - ignoreSticky = false; + Platform.runLater(() -> { + if (seq < refreshSeq.get()) return; // stale – discard + applyQueueData(qp, List.of(), st); + }); + } catch (Exception ex) { + logger.log(Level.FINE, "Queue refresh failed: " + ex.getMessage()); + } + } - List focus = explicitFocus.isEmpty() ? stickySel - : List.copyOf(explicitFocus); - applyFocus(focus); - stickySel = focus; + /** Applies fetched queue data to the UI. Must be called on the FX thread. */ + private void applyQueueData(QueueGetPayload qp, Collection explicitFocus, + StatusResponse st) { + QueueItemSelectionEvent selEvent = QueueItemSelectionEvent.getInstance(); + + ignoreSticky = true; + rebuildRows(qp.queue()); + ignoreSticky = false; + + List focus; + List pendingUids = selEvent.getPendingSelectUids(); + if (pendingUids != null) { + // We have exact UIDs to select (from a successful add/copy response) + List found = pendingUids.stream() + .filter(uid2item::containsKey) + .toList(); + if (!found.isEmpty()) { + focus = found; + selEvent.clearPendingSelect(); + } else { + // UIDs not yet in this refresh's data – keep for next cycle + focus = explicitFocus.isEmpty() ? stickySel + : List.copyOf(explicitFocus); + } + } else if (!explicitFocus.isEmpty()) { + focus = List.copyOf(explicitFocus); + } else { + focus = stickySel; + } - loopBtn.setSelected(Optional.ofNullable(st.planQueueMode()) - .map(StatusResponse.PlanQueueMode::loop) - .orElse(false)); - } catch (Exception ex) { - LOG.warning("Queue refresh failed: " + ex.getMessage()); + applyFocus(focus); + + // applyFocus suppresses intermediate notifications, so update + // stickySel and notify once here. + if (table.getSelectionModel().getSelectedItems().isEmpty()) { + stickySel = List.of(); + } else { + stickySel = selectedUids(); } + notifySelectionChange(); + + loopBtn.setSelected(Optional.ofNullable(st.planQueueMode()) + .map(StatusResponse.PlanQueueMode::loop) + .orElse(false)); } private void rebuildRows(List items) { @@ -146,7 +228,7 @@ private void rebuildRows(List items) { for (QueueItem q : items) { rows.add(new Row(q.itemUid(), q.itemType(), q.name(), - fmtParams(q), q.user(), q.userGroup())); + fmtParams(q, q.itemType(), q.name()), q.user(), q.userGroup())); uid2item.put(q.itemUid(), q); } updateButtonStates(); @@ -178,6 +260,9 @@ private void applyFocus(Collection uids) { var sm = table.getSelectionModel(); var fm = table.getFocusModel(); + + // Suppress intermediate listener notifications during clear+select + ignoreSticky = true; sm.clearSelection(); int first = -1; @@ -187,10 +272,26 @@ private void applyFocus(Collection uids) { if (first == -1) first = i; } } - if (first != -1) table.requestFocus(); + ignoreSticky = false; + + if (first != -1) { + final int scrollIdx = first; + table.scrollTo(scrollIdx); + // Defer focus to next pulse for reliable visual highlight + Platform.runLater(() -> table.requestFocus()); + } } private void refreshLater(Collection focus) { - Platform.runLater(() -> refresh(StatusBus.latest().get(), focus)); + // Invalidate any pending background Platform.runLater blocks + refreshSeq.incrementAndGet(); + StatusResponse st = StatusBus.latest().get(); + if (st == null) { updateButtonStates(); return; } + try { + QueueGetPayload qp = svc.queueGetTyped(); + applyQueueData(qp, focus, st); + } catch (Exception ex) { + logger.log(Level.FINE, "Queue refresh (explicit) failed: " + ex.getMessage()); + } } @@ -224,7 +325,7 @@ private void moveRelative(int delta) { List focus = selectedUids(); try { sendMove(focus, rows.get(ref).uid(), delta<0); refreshLater(focus); } - catch (Exception ex) { LOG.warning("Move failed: "+ex.getMessage()); } + catch (Exception ex) { logger.log(Level.WARNING, "Move failed: "+ex.getMessage()); } } private void moveAbsolute(int targetRow) { if (rows.isEmpty()) return; @@ -236,7 +337,7 @@ private void moveAbsolute(int targetRow) { boolean before = targetRow < selRows.get(0); List focus = selectedUids(); try { sendMove(focus, rows.get(targetRow).uid(), before); refreshLater(focus); } - catch (Exception ex) { LOG.warning("Move-abs failed: "+ex.getMessage()); } + catch (Exception ex) { logger.log(Level.WARNING, "Move-abs failed: "+ex.getMessage()); } } private void deleteSelected() { @@ -249,7 +350,7 @@ private void deleteSelected() { try { svc.queueItemRemoveBatch(Map.of("uids", selectedUids())); refreshLater(nextFocus==null? List.of() : List.of(nextFocus)); - } catch (Exception ex) { LOG.warning("Delete failed: "+ex.getMessage()); } + } catch (Exception ex) { logger.log(Level.WARNING, "Delete failed: "+ex.getMessage()); } } private void duplicateSelected() { @@ -265,11 +366,14 @@ private void duplicateSelected() { if (orig == null) return; try { svc.addAfter(orig, orig.itemUid()); } // server returns nothing we need catch (Exception ex) { // log but continue - LOG.warning("Duplicate RPC failed: "+ex.getMessage()); + logger.log(Level.WARNING, "Duplicate RPC failed: "+ex.getMessage()); } }); try { + // Invalidate pending background refreshes so they don't overwrite our selection + refreshSeq.incrementAndGet(); + QueueGetPayload qp = svc.queueGetTyped(); List afterList = qp.queue().stream() .map(QueueItem::itemUid).toList(); @@ -281,21 +385,25 @@ private void duplicateSelected() { rebuildRows(qp.queue()); ignoreSticky = false; - if (!added.isEmpty()) applyFocus(List.of(added.get(0))); // first clone - stickySel = added.isEmpty() ? stickySel : List.of(added.get(0)); + if (!added.isEmpty()) { + applyFocus(added); + stickySel = added; + notifySelectionChange(); + } } catch (Exception ex) { - LOG.warning("Refresh after duplicate failed: "+ex.getMessage()); + logger.log(Level.WARNING, "Refresh after duplicate failed: "+ex.getMessage()); } } private void clearQueue() { try { svc.queueClear(); } - catch (Exception ex) { LOG.warning("Clear failed: "+ex.getMessage()); } } + catch (Exception ex) { logger.log(Level.WARNING, "Clear failed: "+ex.getMessage()); } } private void setLoopMode(boolean loop){ try { svc.queueModeSet(Map.of("loop",loop)); } - catch (Exception ex){ LOG.warning("Loop-set failed: "+ex.getMessage()); } } + catch (Exception ex){ logger.log(Level.WARNING, "Loop-set failed: "+ex.getMessage()); } } private void updateButtonStates() { - boolean connected = StatusBus.latest().get()!=null; + StatusResponse status = StatusBus.latest().get(); + boolean connected = status != null; var sel = table.getSelectionModel().getSelectedIndices(); boolean hasSel = !table.getSelectionModel().getSelectedIndices().isEmpty(); @@ -313,6 +421,7 @@ private void updateButtonStates() { loopBtn.setDisable(true); deselectBtn.setDisable(!hasSel); } else { + // Only require server connection (not environment open) upBtn.setDisable(!(connected && hasSel && !atTop)); downBtn.setDisable(!(connected && hasSel && !atBot)); topBtn.setDisable(upBtn.isDisable()); @@ -321,6 +430,7 @@ private void updateButtonStates() { duplicateBtn.setDisable(deleteBtn.isDisable()); clearBtn.setDisable(!(connected && !rows.isEmpty())); loopBtn.setDisable(!connected); + // Deselect always enabled when there's a selection deselectBtn.setDisable(!hasSel); } } @@ -358,17 +468,51 @@ private List selectedUids() { private static String firstLetter(String s) { return (s == null || s.isBlank()) ? "" : s.substring(0, 1).toUpperCase(); } - private static String fmtParams(QueueItem q) { + private String fmtParams(QueueItem q, String itemType, String itemName) { + // Format args first String a = Optional.ofNullable(q.args()).orElse(List.of()) - .stream().map(Object::toString) - .collect(Collectors.joining(", ")); - String k = Optional.ofNullable(q.kwargs()).orElse(Map.of()) - .entrySet().stream() - .map(e -> e.getKey() + ": " + e.getValue()) + .stream().map(PythonParameterConverter::toPythonRepr) .collect(Collectors.joining(", ")); + + // Get the plan/instruction definition to determine parameter order + Map itemInfo = null; + if ("plan".equals(itemType)) { + itemInfo = allowedPlans.get(itemName); + } else if ("instruction".equals(itemType)) { + itemInfo = allowedInstructions.get(itemName); + } + + // Format kwargs in schema order if available + String k; + if (itemInfo != null) { + List> parameters = (List>) itemInfo.get("parameters"); + if (parameters != null) { + Map kwargs = Optional.ofNullable(q.kwargs()).orElse(Map.of()); + // Format kwargs in the order they appear in the schema + k = parameters.stream() + .map(paramInfo -> (String) paramInfo.get("name")) + .filter(kwargs::containsKey) + .map(paramName -> paramName + ": " + PythonParameterConverter.toPythonRepr(kwargs.get(paramName))) + .collect(Collectors.joining(", ")); + } else { + // No parameters defined, use default formatting + k = formatKwargsDefault(q.kwargs()); + } + } else { + // Plan/instruction not found in schema, use default formatting + k = formatKwargsDefault(q.kwargs()); + } + return Stream.of(a, k).filter(s -> !s.isEmpty()) .collect(Collectors.joining(", ")); } + + private String formatKwargsDefault(Map kwargs) { + return Optional.ofNullable(kwargs).orElse(Map.of()) + .entrySet().stream() + .map(e -> e.getKey() + ": " + PythonParameterConverter.toPythonRepr(e.getValue())) + .collect(Collectors.joining(", ")); + } private record Row(String uid, String itemType, String name, String params, String user, String group) {} @@ -382,6 +526,16 @@ private void notifySelectionChange() { selectedItem = uid2item.get(selectedRow.uid()); } - QueueItemSelectionEvent.getInstance().notifySelectionChanged(selectedItem); + // Track the last selected UID for insert-after operations + // For multi-select, use the last item in the batch + String lastUid = null; + if (!selectedItems.isEmpty()) { + Row lastRow = selectedItems.get(selectedItems.size() - 1); + lastUid = lastRow.uid(); + } + + QueueItemSelectionEvent event = QueueItemSelectionEvent.getInstance(); + event.setLastSelectedUid(lastUid); + event.notifySelectionChanged(selectedItem); } } \ No newline at end of file diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanViewerController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanViewerController.java similarity index 64% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanViewerController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanViewerController.java index 1d738c0727..68c535a66f 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/RePlanViewerController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/RePlanViewerController.java @@ -2,7 +2,10 @@ import org.phoebus.applications.queueserver.api.*; import org.phoebus.applications.queueserver.client.RunEngineService; +import org.phoebus.applications.queueserver.util.PlansCache; import org.phoebus.applications.queueserver.util.QueueItemSelectionEvent; +import org.phoebus.applications.queueserver.util.PythonParameterConverter; +import org.phoebus.applications.queueserver.util.StatusBus; import org.phoebus.applications.queueserver.view.PlanEditEvent; import org.phoebus.applications.queueserver.view.TabSwitchEvent; import org.phoebus.applications.queueserver.view.ItemUpdateEvent; @@ -16,7 +19,6 @@ import javafx.scene.control.*; import javafx.scene.control.cell.CheckBoxTableCell; import javafx.scene.control.cell.PropertyValueFactory; -import javafx.scene.text.Text; import java.net.URL; import java.util.*; @@ -34,11 +36,20 @@ public class RePlanViewerController implements Initializable { @FXML private Button copyBtn, editBtn; private final RunEngineService svc = new RunEngineService(); - private static final Logger LOG = Logger.getLogger(RePlanViewerController.class.getName()); + private static final Logger logger = Logger.getLogger(RePlanViewerController.class.getPackageName()); private final ObservableList parameterRows = FXCollections.observableArrayList(); private final Map> allowedPlans = new HashMap<>(); private final Map> allowedInstructions = new HashMap<>(); + private PythonParameterConverter getPythonConverter() { + PythonParameterConverter converter = PythonParameterConverter.getShared(); + if (converter == null) { + // Shared init not done yet - create inline (rare fallback) + converter = new PythonParameterConverter(); + } + return converter; + } + private QueueItem currentQueueItem; private String queueItemName = "-"; private String queueItemType = null; @@ -85,18 +96,65 @@ public ParameterRow(String name, boolean enabled, String value, String descripti public void initialize(URL location, ResourceBundle resources) { initializeTable(); initializeControls(); - loadAllowedPlansAndInstructions(); + initializeAllowedInstructions(); + + // Use shared plans cache - copy to local map when loaded + if (PlansCache.isLoaded()) { + allowedPlans.clear(); + allowedPlans.putAll(PlansCache.get()); + } + + // Listen for plans cache updates + PlansCache.addListener((o, oldV, newV) -> { + Platform.runLater(() -> { + allowedPlans.clear(); + if (newV != null) { + allowedPlans.putAll(newV); + } + }); + }); + + // Listen for status changes to update widget state and clear on disconnect + StatusBus.addListener((o, oldV, newV) -> { + // Clear the displayed item when disconnected + if (newV == null) { + Platform.runLater(() -> showItem(null)); + } + Platform.runLater(this::updateWidgetState); + }); QueueItemSelectionEvent.getInstance().addListener(this::showItem); ItemUpdateEvent.getInstance().addListener(this::handleItemUpdate); } + private void initializeAllowedInstructions() { + Map queueStopInstr = new HashMap<>(); + queueStopInstr.put("name", "queue_stop"); + queueStopInstr.put("description", "Stop execution of the queue."); + queueStopInstr.put("parameters", List.of()); + allowedInstructions.put("queue_stop", queueStopInstr); + } + private void initializeTable() { paramCol.setCellValueFactory(new PropertyValueFactory<>("name")); chkCol.setCellValueFactory(new PropertyValueFactory<>("enabled")); valueCol.setCellValueFactory(new PropertyValueFactory<>("value")); + // Fix paramCol and chkCol widths - not resizable + paramCol.setMinWidth(120); + paramCol.setPrefWidth(120); + paramCol.setMaxWidth(120); + paramCol.setResizable(false); + + chkCol.setMinWidth(30); + chkCol.setPrefWidth(30); + chkCol.setMaxWidth(30); + chkCol.setResizable(false); + + // valueCol fills remaining space + valueCol.setMinWidth(50); + paramCol.setCellFactory(column -> { TableCell cell = new TableCell() { @Override @@ -158,6 +216,9 @@ protected void updateItem(String item, boolean empty) { table.setItems(parameterRows); table.setEditable(false); // Viewer is read-only + + // Use constrained resize so valueCol fills remaining space + table.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY); } private void initializeControls() { @@ -176,39 +237,14 @@ private void initializeControls() { updateWidgetState(); } - private void loadAllowedPlansAndInstructions() { - new Thread(() -> { - try { - Map responseMap = svc.plansAllowedRaw(); - - if (responseMap != null && Boolean.TRUE.equals(responseMap.get("success"))) { - allowedPlans.clear(); - if (responseMap.containsKey("plans_allowed")) { - Map plansData = (Map) responseMap.get("plans_allowed"); - for (Map.Entry entry : plansData.entrySet()) { - String planName = entry.getKey(); - Map planInfo = (Map) entry.getValue(); - allowedPlans.put(planName, planInfo); - } - } - } - - allowedInstructions.clear(); - Map queueStopInstr = new HashMap<>(); - queueStopInstr.put("name", "queue_stop"); - queueStopInstr.put("description", "Stop execution of the queue."); - queueStopInstr.put("parameters", List.of()); - allowedInstructions.put("queue_stop", queueStopInstr); - - Platform.runLater(() -> updateWidgetState()); - - } catch (Exception e) { - LOG.log(Level.WARNING, "Failed to load plans", e); - } - }).start(); - } - public void showItem(QueueItem item) { + // Skip if same state (avoid unnecessary refresh/flash) + if (item == null && currentQueueItem == null) return; + if (item != null && currentQueueItem != null && + item.itemUid() != null && item.itemUid().equals(currentQueueItem.itemUid())) { + return; + } + currentQueueItem = item; String defaultName = "-"; @@ -250,9 +286,8 @@ private void setItemDescriptionTooltip() { } private void loadParametersForItem(QueueItem item) { - parameterRows.clear(); - if (item == null) { + parameterRows.clear(); return; } @@ -270,52 +305,66 @@ private void loadParametersForItem(QueueItem item) { Map itemKwargs = item.kwargs() != null ? item.kwargs() : new HashMap<>(); - for (Map paramInfo : parameters) { - String paramName = (String) paramInfo.get("name"); - String description = (String) paramInfo.get("description"); - if (description == null || description.isEmpty()) { - description = "Description for parameter '" + paramName + "' was not found..."; - } - Object defaultValue = paramInfo.get("default"); - boolean isOptional = defaultValue != null || "VAR_POSITIONAL".equals(paramInfo.get("kind")) || - "VAR_KEYWORD".equals(paramInfo.get("kind")); - - String currentValue = ""; - boolean isEnabled = false; - - if (itemKwargs.containsKey(paramName)) { - Object value = itemKwargs.get(paramName); - currentValue = value != null ? String.valueOf(value) : ""; - isEnabled = true; - } else if (defaultValue != null) { - currentValue = String.valueOf(defaultValue) + " (default)"; - isEnabled = false; - } + // Process parameters in background thread to avoid blocking UI with Python parsing + final List> finalParameters = parameters; + final Map finalItemInfo = itemInfo; + new Thread(() -> { + List newRows = new ArrayList<>(); - boolean shouldShow = detailedView || isEnabled; + for (Map paramInfo : finalParameters) { + String paramName = (String) paramInfo.get("name"); + String description = (String) paramInfo.get("description"); + if (description == null || description.isEmpty()) { + description = "Description for parameter '" + paramName + "' was not found..."; + } + Object defaultValue = paramInfo.get("default"); + boolean isOptional = defaultValue != null || "VAR_POSITIONAL".equals(paramInfo.get("kind")) || + "VAR_KEYWORD".equals(paramInfo.get("kind")); + + String currentValue = ""; + boolean isEnabled = false; + + if (itemKwargs.containsKey(paramName)) { + Object value = itemKwargs.get(paramName); + currentValue = value != null ? PythonParameterConverter.toPythonRepr(value) : ""; + isEnabled = true; + } else if (defaultValue != null) { + // Use normalizeAndRepr for defaults - they might be strings that need parsing + currentValue = getPythonConverter().normalizeAndRepr(defaultValue); + isEnabled = false; + } + + boolean shouldShow = detailedView || isEnabled; - if (shouldShow) { - ParameterRow row = new ParameterRow(paramName, isEnabled, currentValue, description, isOptional, defaultValue); - parameterRows.add(row); + if (shouldShow) { + ParameterRow row = new ParameterRow(paramName, isEnabled, currentValue, description, isOptional, defaultValue); + newRows.add(row); + } } - } - addMetadataAndResults(item); + // Add metadata rows in background too + List metadataRows = buildMetadataRows(item); - autoResizeColumns(); + // Update UI on FX thread + Platform.runLater(() -> { + parameterRows.setAll(newRows); + parameterRows.addAll(metadataRows); + }); + }).start(); } - private void addMetadataAndResults(QueueItem item) { + private List buildMetadataRows(QueueItem item) { + List rows = new ArrayList<>(); if (item.result() == null) { - return; + return rows; } Map result = item.result(); - + if (!result.isEmpty()) { - ParameterRow separator = new ParameterRow("--- Metadata & Results ---", false, "", + ParameterRow separator = new ParameterRow("--- Metadata & Results ---", false, "", "Execution metadata and results", false, null); - parameterRows.add(separator); + rows.add(separator); } for (Map.Entry entry : result.entrySet()) { @@ -323,66 +372,58 @@ private void addMetadataAndResults(QueueItem item) { Object value = entry.getValue(); String displayValue = formatResultValue(value); String description = "Result field: " + key; - + ParameterRow row = new ParameterRow(key, true, displayValue, description, false, null); - parameterRows.add(row); + rows.add(row); } + return rows; } private String formatResultValue(Object value) { if (value == null) { - return "null"; + return "None"; } - + if (value instanceof Map) { Map map = (Map) value; if (map.isEmpty()) { return "{}"; } + // For small maps, show the full Python repr + if (map.size() <= 3) { + return PythonParameterConverter.toPythonRepr(value); + } return "Map (" + map.size() + " entries)"; } - + if (value instanceof List) { List list = (List) value; if (list.isEmpty()) { return "[]"; } + // For small lists, show the full Python repr + if (list.size() <= 5) { + return PythonParameterConverter.toPythonRepr(value); + } return "List (" + list.size() + " items)"; } - + if (value instanceof String) { String str = (String) value; if (str.length() > 100) { - return str.substring(0, 97) + "..."; + return "'" + str.substring(0, 97) + "...'"; } - return str; + return PythonParameterConverter.toPythonRepr(value); } - - return String.valueOf(value); - } - private void autoResizeColumns() { - table.setColumnResizePolicy(TableView.UNCONSTRAINED_RESIZE_POLICY); - for (TableColumn col : table.getColumns()) { - Text tmp = new Text(col.getText()); - double max = tmp.getLayoutBounds().getWidth(); - - for (int i = 0; i < parameterRows.size(); i++) { - Object cell = col.getCellData(i); - if (cell != null) { - tmp = new Text(cell.toString()); - double w = tmp.getLayoutBounds().getWidth(); - if (w > max) max = w; - } - } - col.setPrefWidth(max + 14); - } + return PythonParameterConverter.toPythonRepr(value); } private void updateWidgetState() { - boolean isItemAllowed = false; - boolean isConnected = true; // Assume connected for now + StatusResponse status = StatusBus.latest().get(); + boolean isConnected = status != null; + boolean isItemAllowed = false; if (queueItemType != null && queueItemName != null && !"-".equals(queueItemName)) { if ("plan".equals(queueItemType)) { isItemAllowed = allowedPlans.get(queueItemName) != null; @@ -391,9 +432,11 @@ private void updateWidgetState() { } } - copyBtn.setDisable(!isItemAllowed || !isConnected); - - editBtn.setDisable(!isItemAllowed); + // Disable controls when not connected (environment open not required) + table.setDisable(!isConnected); + paramChk.setDisable(!isConnected); + copyBtn.setDisable(!isConnected || !isItemAllowed); + editBtn.setDisable(!isConnected || !isItemAllowed); } private void copyToQueue() { @@ -401,41 +444,35 @@ private void copyToQueue() { return; } - try { - // Create a copy of the current item for adding to queue - QueueItem itemCopy = new QueueItem( - currentQueueItem.itemType(), - currentQueueItem.name(), - currentQueueItem.args() != null ? currentQueueItem.args() : List.of(), - currentQueueItem.kwargs() != null ? currentQueueItem.kwargs() : new HashMap<>(), - null, // New item, no UID - currentUser, - currentUserGroup, - null // No result for new item - ); - - QueueItemAdd request = new QueueItemAdd( - new QueueItemAdd.Item(itemCopy.itemType(), itemCopy.name(), itemCopy.args(), itemCopy.kwargs()), - currentUser, - currentUserGroup - ); - - new Thread(() -> { - try { - var response = svc.queueItemAdd(request); - Platform.runLater(() -> { - if (!response.success()) { - LOG.log(Level.WARNING, "Copy to queue failed", response.msg()); - } - }); - } catch (Exception e) { - LOG.log(Level.WARNING, "Copy to queue error", e); - } - }).start(); + // Capture insert position before starting background thread + String afterUid = QueueItemSelectionEvent.getInstance().getLastSelectedUid(); + + QueueItem itemCopy = new QueueItem( + currentQueueItem.itemType(), + currentQueueItem.name(), + currentQueueItem.args() != null ? currentQueueItem.args() : List.of(), + currentQueueItem.kwargs() != null ? currentQueueItem.kwargs() : new HashMap<>(), + null, + currentUser, + currentUserGroup, + null + ); + + QueueItemAdd request = new QueueItemAdd( + new QueueItemAdd.Item(itemCopy.itemType(), itemCopy.name(), itemCopy.args(), itemCopy.kwargs()), + currentUser, + currentUserGroup, + afterUid + ); - } catch (Exception e) { - LOG.log(Level.WARNING, "Copy to queue error", e); - } + new Thread(() -> { + try { + String newUid = svc.addItemGetUid(request); + QueueItemSelectionEvent.getInstance().requestSelectByUids(List.of(newUid)); + } catch (Exception e) { + logger.log(Level.WARNING, "Copy to queue error", e); + } + }).start(); } private void editCurrentItem() { diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReQueueControlsController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReQueueControlsController.java similarity index 91% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReQueueControlsController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReQueueControlsController.java index 4b0e931b89..124238a063 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReQueueControlsController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReQueueControlsController.java @@ -14,6 +14,7 @@ import java.net.URL; import java.util.Map; import java.util.ResourceBundle; +import java.util.logging.Level; import java.util.logging.Logger; public final class ReQueueControlsController implements Initializable { @@ -24,14 +25,16 @@ public final class ReQueueControlsController implements Initializable { @FXML private Button stopBtn; // text toggles “Stop” / “Cancel Stop” private final RunEngineService svc = new RunEngineService(); - private final Logger LOG = Logger.getLogger(getClass().getName()); + private static final Logger logger = Logger.getLogger(ReQueueControlsController.class.getPackageName()); private volatile boolean autoEnabledSrv = false; // what server says now private volatile boolean stopPendingSrv = false; // ditto @Override public void initialize(URL url, ResourceBundle rb) { - StatusBus.latest().addListener(this::onStatus); + StatusBus.addListener(this::onStatus); + // Check current value in case status was already set before listener added + refreshButtons(StatusBus.latest().get()); startBtn.setOnAction(e -> runSafely("queueStart", () -> { try { @@ -124,6 +127,6 @@ else if (statusObj instanceof Map m) { private void runSafely(String what, Runnable r) { try { r.run(); } - catch (Exception ex) { LOG.warning(what + ": " + ex); } + catch (Exception ex) { logger.log(Level.WARNING, what + ": " + ex); } } } diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReRunningPlanController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReRunningPlanController.java similarity index 69% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReRunningPlanController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReRunningPlanController.java index 1abc67183d..fd233ba405 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReRunningPlanController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReRunningPlanController.java @@ -2,8 +2,10 @@ import org.phoebus.applications.queueserver.api.QueueGetPayload; import org.phoebus.applications.queueserver.api.QueueItem; +import org.phoebus.applications.queueserver.api.QueueItemAdd; import org.phoebus.applications.queueserver.api.StatusResponse; import org.phoebus.applications.queueserver.client.RunEngineService; +import org.phoebus.applications.queueserver.util.QueueItemSelectionEvent; import org.phoebus.applications.queueserver.util.StatusBus; import javafx.beans.value.ChangeListener; import javafx.fxml.FXML; @@ -25,9 +27,10 @@ public final class ReRunningPlanController implements Initializable { @FXML private TextArea planTextArea; private final RunEngineService svc = new RunEngineService(); - private static final Logger LOG = Logger.getLogger(ReRunningPlanController.class.getName()); + private static final Logger logger = Logger.getLogger(ReRunningPlanController.class.getPackageName()); private String lastRunningUid = ""; + private QueueItem cachedRunningItem = null; private final boolean viewOnly; @@ -51,15 +54,17 @@ public ReRunningPlanController(boolean viewOnly) { render(StatusBus.latest().get()); ChangeListener statusL = (obs, o, n) -> render(n); - StatusBus.latest().addListener(statusL); + StatusBus.addListener(statusL); } private void render(StatusResponse st) { if (st == null) { - planTextArea.clear(); - lastRunningUid = ""; - copyBtn.setDisable(true); - updateBtn.setDisable(true); + // Don't clear running plan - keep last data visible for users + // Disable buttons when there's no status (disconnected or status error) + if (!viewOnly) { + copyBtn.setDisable(true); + updateBtn.setDisable(true); + } return; } @@ -82,19 +87,21 @@ private void render(StatusResponse st) { if (uid == null) { // nothing running planTextArea.clear(); lastRunningUid = ""; + cachedRunningItem = null; return; } - QueueItem runningItem; - if (!uid.equals(lastRunningUid)) { // new plan started - runningItem = fetchRunningItem(); + // Fetch running item only if it's a new plan + if (!uid.equals(lastRunningUid)) { + cachedRunningItem = fetchRunningItem(); lastRunningUid = uid; - } else { - runningItem = null; // keep previous text, only update run-list } + + // Always fetch the latest run list List> runList = fetchRunList(); - planTextArea.setText(format(runningItem, runList)); + // Use cached running item to keep displaying plan details + planTextArea.setText(format(cachedRunningItem, runList)); planTextArea.positionCaret(0); } @@ -103,7 +110,7 @@ private QueueItem fetchRunningItem() { QueueGetPayload p = svc.queueGetTyped(); return p.runningItem(); // may be null } catch (Exception ex) { - LOG.log(Level.FINE, "Failed to fetch running item: " + ex.getMessage()); + logger.log(Level.FINE, "Failed to fetch running item: " + ex.getMessage()); return null; } } @@ -116,7 +123,7 @@ private List> fetchRunList() { if (p instanceof Map m && m.containsKey("run_list")) return (List>) m.get("run_list"); } catch (Exception ex) { - LOG.log(Level.FINE, "Failed to fetch run list: " + ex.getMessage()); + logger.log(Level.FINE, "Failed to fetch run list: " + ex.getMessage()); } return List.of(); } @@ -158,15 +165,24 @@ private static String format(QueueItem item, List> runs) { @FXML private void copyToQueue() { - QueueItem running = fetchRunningItem(); - if (running == null) return; - - try { - svc.queueItemAdd(running); - LOG.info("Copied running plan to queue: " + running.name()); - } catch (Exception ex) { - LOG.log(Level.WARNING, "Failed to copy running plan to queue", ex); - } + if (cachedRunningItem == null) return; + + // Capture insert position before starting background thread + String afterUid = QueueItemSelectionEvent.getInstance().getLastSelectedUid(); + + QueueItem item = cachedRunningItem; + new Thread(() -> { + try { + QueueItemAdd req = new QueueItemAdd( + QueueItemAdd.Item.from(item), + "GUI Client", "primary", afterUid); + String newUid = svc.addItemGetUid(req); + QueueItemSelectionEvent.getInstance().requestSelectByUids(List.of(newUid)); + logger.log(Level.FINE, "Copied running plan to queue: " + item.name()); + } catch (Exception ex) { + logger.log(Level.WARNING, "Failed to copy running plan to queue", ex); + } + }).start(); } @@ -174,9 +190,9 @@ private void copyToQueue() { private void updateEnvironment() { try { svc.environmentUpdate(Map.of()); - LOG.info("Environment update requested"); + logger.log(Level.FINE, "Environment update requested"); } catch (Exception ex) { - LOG.log(Level.WARNING, "Failed to update environment", ex); + logger.log(Level.WARNING, "Failed to update environment", ex); } } diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReStatusMonitorController.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReStatusMonitorController.java similarity index 96% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReStatusMonitorController.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReStatusMonitorController.java index 432eb91c02..8a7b6ea0f1 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/controller/ReStatusMonitorController.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/controller/ReStatusMonitorController.java @@ -28,11 +28,11 @@ public final class ReStatusMonitorController implements Initializable { render(StatusBus.latest().get()); listener = (obs, oldVal, newVal) -> render(newVal); - StatusBus.latest().addListener(listener); + StatusBus.addListener(listener); } public void shutdown() { - StatusBus.latest().removeListener(listener); + StatusBus.removeListener(listener); } private void render(StatusResponse s) { diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/AppLifecycle.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/AppLifecycle.java new file mode 100644 index 0000000000..8545cd87d7 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/AppLifecycle.java @@ -0,0 +1,82 @@ +package org.phoebus.applications.queueserver.util; + +import org.phoebus.applications.queueserver.view.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Manages application lifecycle with reference counting. + * Multiple queue-server apps (monitor, edit-control) can be open simultaneously. + * Shared state is only reset when the last app is closed. + */ +public final class AppLifecycle { + + private static final Logger logger = Logger.getLogger(AppLifecycle.class.getPackageName()); + private static final List shutdownCallbacks = new ArrayList<>(); + private static final AtomicInteger activeApps = new AtomicInteger(0); + + private AppLifecycle() {} + + /** Called when a queue-server app is opened. */ + public static void registerApp() { + int count = activeApps.incrementAndGet(); + logger.log(Level.FINE, "App registered, active count: " + count); + } + + /** + * Called when a queue-server app tab is closed. + * Shared state is reset only when the last app closes. + */ + public static void unregisterApp() { + int count = activeApps.decrementAndGet(); + logger.log(Level.FINE, "App unregistered, active count: " + count); + if (count <= 0) { + activeApps.set(0); + shutdown(); + } + } + + /** Register a shutdown callback. */ + public static void registerShutdown(Runnable shutdown) { + shutdownCallbacks.add(shutdown); + } + + /** Reset all static state. Called when the last app closes. */ + private static void shutdown() { + try { + logger.log(Level.INFO, "Last queue-server app closed - resetting state"); + + for (Runnable callback : shutdownCallbacks) { + try { + callback.run(); + } catch (Exception e) { + logger.log(Level.WARNING, "Error during shutdown callback", e); + } + } + shutdownCallbacks.clear(); + + // Shut down connection manager + try { ConnectionManager.getInstance().shutdown(); } catch (Exception e) { /* ignore */ } + + // Reset all event buses + try { StatusBus.reset(); } catch (Exception e) { /* ignore */ } + try { QueueItemSelectionEvent.getInstance().reset(); } catch (Exception e) { /* ignore */ } + try { ItemUpdateEvent.getInstance().reset(); } catch (Exception e) { /* ignore */ } + try { PlanEditEvent.getInstance().reset(); } catch (Exception e) { /* ignore */ } + try { TabSwitchEvent.getInstance().reset(); } catch (Exception e) { /* ignore */ } + try { UiSignalEvent.reset(); } catch (Exception e) { /* ignore */ } + try { PlansCache.reset(); } catch (Exception e) { /* ignore */ } + + // Reset Python converter + try { PythonParameterConverter.resetShared(); } catch (Exception e) { /* ignore */ } + + logger.log(Level.INFO, "Queue Server state reset complete"); + } catch (Exception e) { + logger.log(Level.WARNING, "Error during app shutdown", e); + } + } +} diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/ConnectionManager.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/ConnectionManager.java new file mode 100644 index 0000000000..f8a013f159 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/ConnectionManager.java @@ -0,0 +1,301 @@ +package org.phoebus.applications.queueserver.util; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import javafx.application.Platform; +import javafx.beans.property.ObjectProperty; +import javafx.beans.property.SimpleObjectProperty; +import org.phoebus.applications.queueserver.Preferences; +import org.phoebus.applications.queueserver.api.StatusResponse; +import org.phoebus.applications.queueserver.api.StatusWsMessage; +import org.phoebus.applications.queueserver.client.QueueServerWebSocket; +import org.phoebus.applications.queueserver.client.RunEngineService; + +import java.util.Map; +import java.util.concurrent.ScheduledFuture; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Singleton that owns the queue-server connection (WebSocket or HTTP polling). + * Multiple UI controllers ({@link org.phoebus.applications.queueserver.controller.ReManagerConnectionController}) + * bind to the shared {@link #stateProperty()} and call {@link #start()}/{@link #stop()}. + */ +public final class ConnectionManager { + + private static final ConnectionManager INSTANCE = new ConnectionManager(); + private static final Logger logger = Logger.getLogger(ConnectionManager.class.getPackageName()); + + private final RunEngineService svc = new RunEngineService(); + private final ObjectMapper mapper = new ObjectMapper() + .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + + private ScheduledFuture pollTask; + private ScheduledFuture reconnectTask; + private ScheduledFuture healthCheckTask; + private QueueServerWebSocket statusWs; + + private volatile StatusResponse latestStatus = null; + private volatile boolean websocketConnected = false; + private volatile boolean attemptingConnection = false; + private volatile long lastStatusUpdateTime = 0; + private volatile long connectionAttemptStartTime = 0; + private volatile int reconnectAttempts = 0; + + private static final long STATUS_TIMEOUT_MS = 3000; + private static final long CONNECTION_ATTEMPT_TIMEOUT_MS = 5000; + private static final long RECONNECT_INTERVAL_MS = 5000; + + public enum ConnectionState { + DISCONNECTED, + CONNECTING, + NETWORK_ERROR, + NO_STATUS, + CONNECTED + } + + /** Observable state – always updated on the FX thread. */ + private final ObjectProperty state = + new SimpleObjectProperty<>(ConnectionState.DISCONNECTED); + + private volatile boolean autoConnect = false; + + private ConnectionManager() {} + + public static ConnectionManager getInstance() { return INSTANCE; } + + public ObjectProperty stateProperty() { return state; } + + public ConnectionState getState() { return state.get(); } + + public boolean isAutoConnect() { return autoConnect; } + + /** Idempotent – does nothing if already running. */ + public void start() { + if (autoConnect) return; + autoConnect = true; + + if (pollTask != null && !pollTask.isDone()) return; + if (statusWs != null && statusWs.isConnected()) return; + + websocketConnected = false; + attemptingConnection = false; + latestStatus = null; + lastStatusUpdateTime = 0; + connectionAttemptStartTime = 0; + reconnectAttempts = 0; + + if (Preferences.use_websockets) { + logger.log(Level.INFO, "Starting status WebSocket connection"); + attemptWebSocketConnection(); + } else { + logger.log(Level.INFO, "Starting status polling every " + Preferences.update_interval_ms + " ms"); + attemptingConnection = true; + connectionAttemptStartTime = System.currentTimeMillis(); + pollTask = PollCenter.everyMs(Preferences.update_interval_ms, + this::queryStatusOnce, + this::updateWidgets); + } + + if (healthCheckTask == null) { + healthCheckTask = PollCenter.everyMs(500, this::checkConnectionHealth); + } + } + + /** Idempotent – does nothing if already stopped. */ + public void stop() { + logger.log(Level.INFO, "Stopping status monitoring"); + autoConnect = false; + + if (reconnectTask != null) { reconnectTask.cancel(true); reconnectTask = null; } + if (healthCheckTask != null) { healthCheckTask.cancel(true); healthCheckTask = null; } + if (pollTask != null) { pollTask.cancel(true); pollTask = null; } + if (statusWs != null) { statusWs.disconnect(); statusWs = null; } + + websocketConnected = false; + reconnectAttempts = 0; + + Platform.runLater(() -> { + state.set(ConnectionState.DISCONNECTED); + latestStatus = null; + StatusBus.push(null); + }); + } + + /** Full shutdown – resets everything. Called by AppLifecycle. */ + public void shutdown() { + stop(); + } + + // ---- WebSocket connection ------------------------------------------- + + private void attemptWebSocketConnection() { + try { + attemptingConnection = true; + connectionAttemptStartTime = System.currentTimeMillis(); + + statusWs = svc.createStatusWebSocket(); + statusWs.addListener(msg -> { + Map statusMap = msg.status(); + if (statusMap != null) { + try { + latestStatus = mapper.convertValue(statusMap, StatusResponse.class); + lastStatusUpdateTime = System.currentTimeMillis(); + if (!websocketConnected) { + websocketConnected = true; + attemptingConnection = false; + reconnectAttempts = 0; + logger.log(Level.INFO, "WebSocket connection established"); + } + } catch (Exception e) { + logger.log(Level.WARNING, "Failed to parse status from WebSocket", e); + } + } + }); + + statusWs.connect(); + + pollTask = PollCenter.everyMs(Preferences.update_interval_ms, () -> { + if (statusWs != null && !statusWs.isConnected()) { + if (websocketConnected) { + logger.log(Level.WARNING, "WebSocket connection lost"); + websocketConnected = false; + attemptingConnection = false; + if (autoConnect) scheduleReconnect(); + } + } + StatusResponse status = latestStatus; + if (status != null) { + Platform.runLater(() -> updateWidgets(status)); + } + }); + } catch (Exception e) { + logger.log(Level.SEVERE, "Failed to create WebSocket connection", e); + websocketConnected = false; + attemptingConnection = false; + if (autoConnect) scheduleReconnect(); + } + } + + private void scheduleReconnect() { + if (!autoConnect) return; + if (reconnectTask != null && !reconnectTask.isDone()) return; + if (attemptingConnection) return; + if (reconnectTask != null) reconnectTask.cancel(false); + + reconnectAttempts++; + logger.log(Level.INFO, "Scheduling reconnect attempt #" + reconnectAttempts + + " in " + RECONNECT_INTERVAL_MS + "ms"); + + reconnectTask = PollCenter.afterMs((int) RECONNECT_INTERVAL_MS, () -> { + if (autoConnect && !attemptingConnection) { + logger.log(Level.INFO, "Attempting reconnect (attempt #" + reconnectAttempts + ")"); + if (statusWs != null) { statusWs.disconnect(); statusWs = null; } + if (pollTask != null) { pollTask.cancel(false); pollTask = null; } + websocketConnected = false; + attemptWebSocketConnection(); + } + }); + } + + // ---- HTTP polling --------------------------------------------------- + + private StatusResponse queryStatusOnce() { + try { + StatusResponse status = svc.status(); + if (status != null) { + lastStatusUpdateTime = System.currentTimeMillis(); + if (attemptingConnection) { + attemptingConnection = false; + reconnectAttempts = 0; + logger.log(Level.INFO, "HTTP connection established"); + } + } + return status; + } catch (Exception ex) { + logger.log(Level.FINE, "Status query failed: " + ex.getMessage()); + return null; + } + } + + // ---- Health check --------------------------------------------------- + + private void checkConnectionHealth() { + ConnectionState newState; + + if (!autoConnect) { + newState = ConnectionState.DISCONNECTED; + } else if (Preferences.use_websockets) { + newState = checkWebSocketHealth(); + } else { + newState = checkPollingHealth(); + } + + if (newState != state.get()) { + ConnectionState oldState = state.get(); + logger.log(Level.FINE, "Connection state: " + oldState + " -> " + newState); + Platform.runLater(() -> { + state.set(newState); + applyStateEffects(newState); + }); + } + } + + private ConnectionState checkWebSocketHealth() { + if (attemptingConnection) { + long elapsed = System.currentTimeMillis() - connectionAttemptStartTime; + if (elapsed > CONNECTION_ATTEMPT_TIMEOUT_MS) { + attemptingConnection = false; + if (pollTask != null) { pollTask.cancel(false); pollTask = null; } + if (statusWs != null) { statusWs.disconnect(); statusWs = null; } + scheduleReconnect(); + return ConnectionState.NETWORK_ERROR; + } + return ConnectionState.CONNECTING; + } + if (!websocketConnected) { + if ((reconnectTask == null || reconnectTask.isDone()) + && (statusWs == null || !statusWs.isConnected())) { + scheduleReconnect(); + } + return ConnectionState.NETWORK_ERROR; + } + if (lastStatusUpdateTime == 0) { + return ConnectionState.CONNECTING; + } + long age = System.currentTimeMillis() - lastStatusUpdateTime; + return age > STATUS_TIMEOUT_MS ? ConnectionState.NO_STATUS : ConnectionState.CONNECTED; + } + + private ConnectionState checkPollingHealth() { + if (attemptingConnection) { + long elapsed = System.currentTimeMillis() - connectionAttemptStartTime; + return elapsed > CONNECTION_ATTEMPT_TIMEOUT_MS + ? ConnectionState.NETWORK_ERROR + : ConnectionState.CONNECTING; + } + if (lastStatusUpdateTime == 0) return ConnectionState.NETWORK_ERROR; + long age = System.currentTimeMillis() - lastStatusUpdateTime; + return age > STATUS_TIMEOUT_MS ? ConnectionState.NETWORK_ERROR : ConnectionState.CONNECTED; + } + + private void applyStateEffects(ConnectionState s) { + switch (s) { + case DISCONNECTED, NETWORK_ERROR, NO_STATUS -> { + latestStatus = null; + StatusBus.push(null); + } + case CONNECTED -> PlansCache.loadIfNeeded(); + default -> { } + } + } + + // ---- Push to StatusBus ---------------------------------------------- + + private void updateWidgets(StatusResponse s) { + if (s != null) { + logger.log(Level.FINEST, "Status update: manager_state=" + s.managerState()); + StatusBus.push(s); + } + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/HttpSupport.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/HttpSupport.java similarity index 87% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/HttpSupport.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/HttpSupport.java index 14d64f54fa..051206483d 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/HttpSupport.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/HttpSupport.java @@ -10,7 +10,7 @@ public final class HttpSupport { private HttpSupport() {} - public static final Logger LOG = Logger.getLogger("com.jbi.bluesky"); + public static final Logger logger = Logger.getLogger(HttpSupport.class.getPackageName()); /* ---------------- retry policy ----------- */ public static final int MAX_RETRIES = 3; @@ -29,6 +29,6 @@ public static long elapsed(long startNano) { } public static void fine(String msg) { - LOG.log(Level.FINE, msg); + logger.log(Level.FINE, msg); } } diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/JythonScriptExecutor.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/JythonScriptExecutor.java new file mode 100644 index 0000000000..d6fc6b4e6f --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/JythonScriptExecutor.java @@ -0,0 +1,154 @@ +package org.phoebus.applications.queueserver.util; + +import org.python.core.*; +import org.python.util.PythonInterpreter; + +import java.io.InputStream; +import java.util.concurrent.*; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Utility class for executing Jython scripts in the Queue Server application. + * Based on Phoebus display runtime JythonScriptSupport implementation. + */ +public class JythonScriptExecutor { + + private static final Logger logger = Logger.getLogger(JythonScriptExecutor.class.getPackageName()); + private static final ExecutorService EXECUTOR = Executors.newSingleThreadExecutor(r -> { + Thread thread = new Thread(r, "QueueServer-Jython"); + thread.setDaemon(true); + return thread; + }); + + private final PythonInterpreter python; + + static { + // Configure Jython options (similar to Phoebus display runtime) + PySystemState.initialize(); + Options.dont_write_bytecode = true; + + // Set console encoding + PySystemState sys = Py.getSystemState(); + sys.setdefaultencoding("utf-8"); + + logger.log(Level.FINE, "Jython initialized for Queue Server"); + } + + /** + * Create a new Jython script executor with a dedicated interpreter instance. + */ + public JythonScriptExecutor() { + // Synchronized to prevent concurrent initialization issues + synchronized (JythonScriptExecutor.class) { + this.python = new PythonInterpreter(); + } + } + + /** + * Execute a Python script with the given context variables. + * + * @param scriptContent The Python script code to execute + * @param contextVars Variables to pass into the Python context (key -> value pairs) + * @return The result object returned by the script (or null if none) + */ + public Object execute(String scriptContent, java.util.Map contextVars) { + try { + // Set context variables in the Python interpreter + if (contextVars != null) { + for (java.util.Map.Entry entry : contextVars.entrySet()) { + python.set(entry.getKey(), entry.getValue()); + } + } + + // Execute the script + python.exec(scriptContent); + + // Try to get a result variable if one was set + PyObject result = python.get("result"); + + // Clear context to prevent memory leaks + if (contextVars != null) { + for (String key : contextVars.keySet()) { + python.set(key, null); + } + } + + // Convert PyObject to Java object + return result != null ? result.__tojava__(Object.class) : null; + + } catch (Exception e) { + logger.log(Level.WARNING, "Jython script execution failed", e); + throw new RuntimeException("Script execution failed: " + e.getMessage(), e); + } + } + + /** + * Execute a Python script asynchronously. + * + * @param scriptContent The Python script code to execute + * @param contextVars Variables to pass into the Python context + * @return Future that will contain the result + */ + public Future executeAsync(String scriptContent, java.util.Map contextVars) { + return EXECUTOR.submit(() -> execute(scriptContent, contextVars)); + } + + /** + * Execute a Python script from a resource file. + * + * @param resourcePath Path to the Python script resource + * @param contextVars Variables to pass into the Python context + * @return The result object returned by the script + */ + public Object executeResource(String resourcePath, java.util.Map contextVars) throws Exception { + try (InputStream stream = getClass().getResourceAsStream(resourcePath)) { + if (stream == null) { + throw new IllegalArgumentException("Resource not found: " + resourcePath); + } + + String scriptContent = new String(stream.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8); + return execute(scriptContent, contextVars); + } + } + + /** + * Execute a simple Python expression and return the result. + * + * @param expression Python expression to evaluate + * @return The evaluated result + */ + public Object eval(String expression) { + try { + PyObject result = python.eval(expression); + return result.__tojava__(Object.class); + } catch (Exception e) { + logger.log(Level.WARNING, "Jython eval failed for: " + expression, e); + throw new RuntimeException("Evaluation failed: " + e.getMessage(), e); + } + } + + /** + * Close this executor and release resources. + */ + public void close() { + if (python != null) { + python.close(); + } + } + + /** + * Shutdown the shared executor service (call during application shutdown). + */ + public static void shutdown() { + EXECUTOR.shutdown(); + try { + if (!EXECUTOR.awaitTermination(5, TimeUnit.SECONDS)) { + EXECUTOR.shutdownNow(); + } + } catch (InterruptedException e) { + EXECUTOR.shutdownNow(); + Thread.currentThread().interrupt(); + } + } +} diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PlansCache.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PlansCache.java new file mode 100644 index 0000000000..ead627c280 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PlansCache.java @@ -0,0 +1,143 @@ +package org.phoebus.applications.queueserver.util; + +import org.phoebus.applications.queueserver.client.RunEngineService; +import javafx.application.Platform; +import javafx.beans.property.ObjectProperty; +import javafx.beans.property.SimpleObjectProperty; +import javafx.beans.value.ChangeListener; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Shared cache for allowed plans data. Fetches once and notifies all listeners. + * This avoids multiple controllers making redundant HTTP calls for the same data. + */ +public final class PlansCache { + + private static final Logger logger = Logger.getLogger(PlansCache.class.getPackageName()); + + private static final ObjectProperty>> PLANS = new SimpleObjectProperty<>(new HashMap<>()); + private static final List>>> listeners = new ArrayList<>(); + private static final AtomicBoolean loading = new AtomicBoolean(false); + private static final AtomicBoolean loaded = new AtomicBoolean(false); + + private PlansCache() {} + + /** + * Get the plans property for binding or adding listeners. + */ + public static ObjectProperty>> plans() { + return PLANS; + } + + /** + * Get the current plans map (never null, may be empty). + */ + public static Map> get() { + Map> p = PLANS.get(); + return p != null ? p : new HashMap<>(); + } + + /** + * Check if plans have been loaded. + */ + public static boolean isLoaded() { + return loaded.get(); + } + + /** + * Add a listener and track it for cleanup during reset. + */ + public static void addListener(ChangeListener>> listener) { + listeners.add(listener); + PLANS.addListener(listener); + } + + /** + * Remove a tracked listener. + */ + public static void removeListener(ChangeListener>> listener) { + listeners.remove(listener); + PLANS.removeListener(listener); + } + + /** + * Load plans from the server. Only makes one HTTP call even if called multiple times. + * After loading, all registered listeners are notified. + */ + public static void loadIfNeeded() { + // Already loaded or currently loading - skip + if (loaded.get() || !loading.compareAndSet(false, true)) { + return; + } + + logger.log(Level.FINE, "Loading allowed plans (shared cache)"); + + new Thread(() -> { + try { + RunEngineService svc = new RunEngineService(); + Map responseMap = svc.plansAllowedRaw(); + + Map> newPlans = new HashMap<>(); + if (responseMap != null && Boolean.TRUE.equals(responseMap.get("success"))) { + if (responseMap.containsKey("plans_allowed")) { + @SuppressWarnings("unchecked") + Map> plans = + (Map>) responseMap.get("plans_allowed"); + if (plans != null) { + newPlans.putAll(plans); + } + } + } + + final Map> result = newPlans; + Platform.runLater(() -> { + PLANS.set(result); + loaded.set(true); + loading.set(false); + logger.log(Level.FINE, "Loaded " + result.size() + " allowed plans into shared cache"); + }); + + } catch (Exception e) { + logger.log(Level.WARNING, "Failed to load allowed plans", e); + loading.set(false); + } + }, "PlansCache-Loader").start(); + } + + /** + * Force reload of plans (e.g., after reconnection). + */ + public static void reload() { + loaded.set(false); + loading.set(false); + loadIfNeeded(); + } + + /** + * Reset state for app restart. + */ + public static void reset() { + Runnable doReset = () -> { + for (ChangeListener>> listener : listeners) { + PLANS.removeListener(listener); + } + listeners.clear(); + PLANS.set(new HashMap<>()); + loaded.set(false); + loading.set(false); + }; + + if (Platform.isFxApplicationThread()) { + doReset.run(); + } else { + Platform.runLater(doReset); + } + } +} diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PollCenter.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PollCenter.java new file mode 100644 index 0000000000..9ba3d4a106 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PollCenter.java @@ -0,0 +1,62 @@ +package org.phoebus.applications.queueserver.util; + +import java.util.concurrent.*; +import java.util.function.Supplier; +import java.util.logging.Level; +import java.util.logging.Logger; + +// Single ScheduledExecutor shared by all widgets that need periodic polling. +public final class PollCenter { + + private static final Logger logger = Logger.getLogger(PollCenter.class.getPackageName()); + private static final ScheduledExecutorService EXEC = + Executors.newSingleThreadScheduledExecutor(r -> + new Thread(r, "JBI-poller")); + + private PollCenter() {} + + public static ScheduledFuture every(long periodSec, Runnable task) { + logger.log(Level.FINE, "Scheduling task with period: " + periodSec + " seconds"); + return EXEC.scheduleAtFixedRate(task, 0, periodSec, TimeUnit.SECONDS); + } + + public static ScheduledFuture everyMs(long periodMs, Runnable task) { + logger.log(Level.FINE, "Scheduling task with period: " + periodMs + " milliseconds"); + return EXEC.scheduleAtFixedRate(task, 0, periodMs, TimeUnit.MILLISECONDS); + } + + public static ScheduledFuture afterMs(long delayMs, Runnable task) { + logger.log(Level.FINE, "Scheduling one-time task after: " + delayMs + " milliseconds"); + return EXEC.schedule(task, delayMs, TimeUnit.MILLISECONDS); + } + + public static ScheduledFuture every( + long periodSec, + Supplier supplier, + java.util.function.Consumer fxConsumer) { + + return every(periodSec, () -> { + try { + T t = supplier.get(); + javafx.application.Platform.runLater(() -> fxConsumer.accept(t)); + } catch (Exception ex) { + logger.log(Level.WARNING, "Polling task failed", ex); + } + }); + } + + public static ScheduledFuture everyMs( + long periodMs, + Supplier supplier, + java.util.function.Consumer fxConsumer) { + + return everyMs(periodMs, () -> { + try { + T t = supplier.get(); + javafx.application.Platform.runLater(() -> fxConsumer.accept(t)); + } catch (Exception ex) { + logger.log(Level.WARNING, "Polling task failed", ex); + } + }); + } +} diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PythonParameterConverter.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PythonParameterConverter.java new file mode 100644 index 0000000000..8fb1aee336 --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/PythonParameterConverter.java @@ -0,0 +1,322 @@ +package org.phoebus.applications.queueserver.util; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Python-based parameter type converter for Queue Server. + * + * This class delegates type conversion to a Python script (using Jython), + * allowing us to use Python's ast.literal_eval for parsing parameter values + * instead of implementing complex type conversions in Java. + * + * Use {@link #getShared()} to get a shared instance that's initialized once + * in the background to avoid blocking the UI thread. + */ +public class PythonParameterConverter { + + private static final Logger logger = Logger.getLogger(PythonParameterConverter.class.getPackageName()); + private static final String SCRIPT_RESOURCE = "/org/phoebus/applications/queueserver/scripts/type_converter.py"; + + // Shared singleton instance - initialized once in background + private static volatile PythonParameterConverter sharedInstance; + private static volatile boolean initializationStarted = false; + private static final Object initLock = new Object(); + + private final ObjectMapper objectMapper = new ObjectMapper(); + private final JythonScriptExecutor executor; + private final String scriptContent; + + /** + * Get the shared singleton instance. This is the preferred way to get a converter. + * The instance is initialized lazily in the background on first call. + * May return null if initialization hasn't completed yet - caller should handle this. + */ + public static PythonParameterConverter getShared() { + if (sharedInstance == null && !initializationStarted) { + initializeInBackground(); + } + return sharedInstance; + } + + /** + * Start background initialization of the shared instance. + * Call this early at app startup to have the converter ready when needed. + */ + public static void initializeInBackground() { + synchronized (initLock) { + if (initializationStarted) { + return; // Already started + } + initializationStarted = true; + } + + new Thread(() -> { + try { + PythonParameterConverter converter = new PythonParameterConverter(); + // Warm up by doing a simple conversion + converter.normalizeAndRepr("warmup"); + sharedInstance = converter; + logger.log(Level.FINE, "Shared Python converter initialized and warmed up"); + } catch (Exception e) { + logger.log(Level.WARNING, "Failed to initialize shared Python converter", e); + initializationStarted = false; // Allow retry + } + }, "PythonConverter-SharedInit").start(); + } + + /** + * Reset the shared instance - call when app is closed to allow re-initialization. + */ + public static void resetShared() { + synchronized (initLock) { + if (sharedInstance != null) { + sharedInstance.close(); + sharedInstance = null; + } + initializationStarted = false; + } + } + + /** + * Create a new Python parameter converter. + * Prefer using {@link #getShared()} instead to avoid multiple initializations. + */ + public PythonParameterConverter() { + this.executor = new JythonScriptExecutor(); + + // Load the Python script from resources + try (var stream = getClass().getResourceAsStream(SCRIPT_RESOURCE)) { + if (stream == null) { + throw new IllegalStateException("Python converter script not found: " + SCRIPT_RESOURCE); + } + this.scriptContent = new String(stream.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8); + logger.log(Level.FINE, "Python type converter script loaded successfully"); + } catch (Exception e) { + logger.log(Level.SEVERE, "Failed to load Python converter script", e); + throw new RuntimeException("Failed to initialize Python converter", e); + } + } + + /** + * Parameter information for conversion. + */ + public static class ParameterInfo { + private String name; + private String value; + private boolean enabled; + private boolean isOptional; + private Object defaultValue; + + public ParameterInfo(String name, String value, boolean enabled, boolean isOptional, Object defaultValue) { + this.name = name; + this.value = value; + this.enabled = enabled; + this.isOptional = isOptional; + this.defaultValue = defaultValue; + } + + // Getters and setters + public String getName() { return name; } + public void setName(String name) { this.name = name; } + + public String getValue() { return value; } + public void setValue(String value) { this.value = value; } + + public boolean isEnabled() { return enabled; } + public void setEnabled(boolean enabled) { this.enabled = enabled; } + + public boolean isOptional() { return isOptional; } + public void setOptional(boolean optional) { isOptional = optional; } + + public Object getDefaultValue() { return defaultValue; } + public void setDefaultValue(Object defaultValue) { this.defaultValue = defaultValue; } + } + + /** + * Convert a list of parameters from string values to typed objects using Python. + * + * @param parameters List of parameter information + * @return Map of parameter names to their typed values + */ + public Map convertParameters(List parameters) { + try { + // Serialize parameters to JSON + String parametersJson = objectMapper.writeValueAsString(parameters); + + // Prepare context for Python script + Map context = new HashMap<>(); + context.put("parameters_json", parametersJson); + + // Execute the Python script + Object result = executor.execute(scriptContent, context); + + // Parse result JSON back to Map + if (result != null) { + String resultJson = result.toString(); + + // Check if result contains an error + Map resultMap = objectMapper.readValue(resultJson, + new TypeReference>() {}); + + if (resultMap.containsKey("error")) { + String errorMsg = "Python type conversion failed: " + resultMap.get("error"); + logger.log(Level.SEVERE, errorMsg); + throw new RuntimeException(errorMsg); + } + + return resultMap; + } + + return new HashMap<>(); + + } catch (Exception e) { + logger.log(Level.FINE, "Python parameter conversion failed: " + e.getMessage()); + throw new RuntimeException("Parameter conversion failed: " + e.getMessage(), e); + } + } + + + /** + * Validate a parameter value using Python. + * + * @param value String value to validate + * @return true if the value can be parsed, false otherwise + */ + public boolean validateValue(String value) { + if (value == null || value.trim().isEmpty()) { + return true; + } + + try { + List testParam = List.of( + new ParameterInfo("test", value, true, true, null) + ); + convertParameters(testParam); + return true; + } catch (Exception e) { + return false; + } + } + + /** + * Normalize a value by parsing it if it's a string, then converting to Python repr. + * This ensures that string representations of numbers like "1" become 1 (without quotes), + * while actual strings like "hello" become 'hello' (with quotes). + * + * @param value The value to normalize + * @return Python repr string with correct types + */ + public String normalizeAndRepr(Object value) { + if (value == null) { + return "None"; + } + + // If it's already a proper Java type (not String), just repr it + if (!(value instanceof String)) { + return toPythonRepr(value); + } + + // It's a string - try to parse it to see what type it really is + String strValue = (String) value; + if (strValue.trim().isEmpty()) { + return ""; + } + + try { + // Try to parse with Python to determine true type + List testParam = List.of( + new ParameterInfo("test", strValue, true, true, null) + ); + Map parsed = convertParameters(testParam); + + if (parsed.containsKey("test")) { + // Successfully parsed - use the parsed value's repr + return toPythonRepr(parsed.get("test")); + } + } catch (Exception e) { + // If parsing fails, treat as a string literal + } + + // Fallback - just repr the string as-is + return toPythonRepr(value); + } + + /** + * Convert a Java object to its Python string representation (repr). + * This preserves Python syntax including quotes around strings in lists/dicts. + * + * @param value The Java object to convert + * @return Python repr string + */ + public static String toPythonRepr(Object value) { + if (value == null) { + return "None"; + } + + // Handle strings - add single quotes + if (value instanceof String) { + String str = (String) value; + // Escape single quotes and backslashes + str = str.replace("\\", "\\\\").replace("'", "\\'"); + return "'" + str + "'"; + } + + // Handle booleans - Python uses True/False + if (value instanceof Boolean) { + return ((Boolean) value) ? "True" : "False"; + } + + // Handle numbers - convert to string directly + if (value instanceof Number) { + return value.toString(); + } + + // Handle lists + if (value instanceof List) { + List list = (List) value; + StringBuilder sb = new StringBuilder("["); + for (int i = 0; i < list.size(); i++) { + if (i > 0) sb.append(", "); + sb.append(toPythonRepr(list.get(i))); + } + sb.append("]"); + return sb.toString(); + } + + // Handle maps/dicts + if (value instanceof Map) { + Map map = (Map) value; + StringBuilder sb = new StringBuilder("{"); + boolean first = true; + for (Map.Entry entry : map.entrySet()) { + if (!first) sb.append(", "); + first = false; + sb.append(toPythonRepr(entry.getKey())); + sb.append(": "); + sb.append(toPythonRepr(entry.getValue())); + } + sb.append("}"); + return sb.toString(); + } + + // Fallback - just use toString + return value.toString(); + } + + /** + * Close the converter and release resources. + */ + public void close() { + if (executor != null) { + executor.close(); + } + } +} diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/QueueItemSelectionEvent.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/QueueItemSelectionEvent.java new file mode 100644 index 0000000000..d60b73987f --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/QueueItemSelectionEvent.java @@ -0,0 +1,103 @@ +package org.phoebus.applications.queueserver.util; + +import org.phoebus.applications.queueserver.api.QueueItem; + +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.function.Consumer; +import java.util.logging.Level; +import java.util.logging.Logger; + +public class QueueItemSelectionEvent { + + private static final QueueItemSelectionEvent INSTANCE = new QueueItemSelectionEvent(); + + private final List> listeners = new CopyOnWriteArrayList<>(); + private static final Logger logger = Logger.getLogger(QueueItemSelectionEvent.class.getPackageName()); + + /** The last selected item's UID (for inserting after) */ + private volatile String lastSelectedUid = null; + + /** + * Exact UIDs to select on the next queue refresh. + * Set by controllers after a successful add/copy HTTP call returns the new item UIDs. + * The queue controller checks this on every refresh and selects matching rows. + */ + private volatile List pendingSelectUids = null; + + private QueueItemSelectionEvent() {} + + public static QueueItemSelectionEvent getInstance() { + return INSTANCE; + } + + public void addListener(Consumer listener) { + listeners.add(listener); + } + + public void removeListener(Consumer listener) { + listeners.remove(listener); + } + + public void notifySelectionChanged(QueueItem selectedItem) { + for (Consumer listener : listeners) { + try { + listener.accept(selectedItem); + } catch (Exception e) { + logger.log(Level.WARNING, "Error in queue selection listener", e); + } + } + } + + /** + * Set the UID of the last selected item (for insert-after operations). + */ + public void setLastSelectedUid(String uid) { + this.lastSelectedUid = uid; + } + + /** + * Get the UID of the last selected item. + * Returns null if no item is selected, meaning items should be added at the back. + */ + public String getLastSelectedUid() { + return lastSelectedUid; + } + + /** + * Request that the queue controller select specific UIDs on the next refresh. + * Called from background threads after a successful add/copy HTTP response. + */ + public void requestSelectByUids(List uids) { + pendingSelectUids = List.copyOf(uids); + } + + /** + * Get the UIDs to select, or null if there are none pending. + */ + public List getPendingSelectUids() { + return pendingSelectUids; + } + + /** + * Clear pending selection (called after UIDs were found and selected, + * or when the operation failed). + */ + public void clearPendingSelect() { + pendingSelectUids = null; + } + + /** + * Check if there are UIDs waiting to be selected. + */ + public boolean hasPendingSelect() { + return pendingSelectUids != null; + } + + /** Reset state for app restart */ + public void reset() { + listeners.clear(); + lastSelectedUid = null; + pendingSelectUids = null; + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/RateLimiter.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/RateLimiter.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/RateLimiter.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/RateLimiter.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/RunEngineCli.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/RunEngineCli.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/RunEngineCli.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/RunEngineCli.java diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/RunEngineRepl.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/RunEngineRepl.java similarity index 100% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/util/RunEngineRepl.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/RunEngineRepl.java diff --git a/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/StatusBus.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/StatusBus.java new file mode 100644 index 0000000000..ad1c1b5dec --- /dev/null +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/util/StatusBus.java @@ -0,0 +1,82 @@ +package org.phoebus.applications.queueserver.util; + +import org.phoebus.applications.queueserver.api.StatusResponse; +import javafx.application.Platform; +import javafx.beans.property.ObjectProperty; +import javafx.beans.property.SimpleObjectProperty; +import javafx.beans.value.ChangeListener; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * A single instance that always holds the most-recent /api/status result + * (or {@code null} when the server is offline). + * + * Widgets that need live status call + * 
 StatusBus.latest().addListener((obs,oldVal,newVal) -> { ... })
+ * or bind directly to the property. + */ +public final class StatusBus { + + private static final Logger logger = Logger.getLogger(StatusBus.class.getPackageName()); + private static final ObjectProperty LATEST = new SimpleObjectProperty<>(null); + private static final List> listeners = new ArrayList<>(); + + private StatusBus() {} + + public static ObjectProperty latest() { + return LATEST; + } + + /** + * Add a listener and track it for cleanup during reset. + * Use this instead of latest().addListener() for proper lifecycle management. + */ + public static void addListener(ChangeListener listener) { + listeners.add(listener); + LATEST.addListener(listener); + } + + /** + * Remove a tracked listener. + */ + public static void removeListener(ChangeListener listener) { + listeners.remove(listener); + LATEST.removeListener(listener); + } + + public static void push(StatusResponse s) { + if (s != null) { + logger.log(Level.FINEST, "Status update: " + s.managerState()); + } else { + logger.log(Level.FINE, "Status cleared (server offline)"); + } + + if (Platform.isFxApplicationThread()) { + LATEST.set(s); + } else { + Platform.runLater(() -> LATEST.set(s)); + } + } + + /** Reset state for app restart - clears listeners first, then value (to avoid firing listeners during shutdown) */ + public static void reset() { + Runnable doReset = () -> { + // Remove all tracked listeners FIRST to prevent them from firing when we set null + for (ChangeListener listener : listeners) { + LATEST.removeListener(listener); + } + listeners.clear(); + // Now safe to set null - no listeners will fire + LATEST.set(null); + }; + + if (Platform.isFxApplicationThread()) { + doReset.run(); + } else { + Platform.runLater(doReset); + } + } +} diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/ItemUpdateEvent.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/ItemUpdateEvent.java similarity index 76% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/ItemUpdateEvent.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/ItemUpdateEvent.java index f0700c5581..860c74b705 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/ItemUpdateEvent.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/ItemUpdateEvent.java @@ -10,7 +10,7 @@ public class ItemUpdateEvent { private static final ItemUpdateEvent instance = new ItemUpdateEvent(); private final List> listeners = new ArrayList<>(); - private static final Logger LOG = Logger.getLogger(ItemUpdateEvent.class.getName()); + private static final Logger logger = Logger.getLogger(ItemUpdateEvent.class.getPackageName()); private ItemUpdateEvent() {} @@ -27,8 +27,13 @@ public void notifyItemUpdated(QueueItem updatedItem) { try { listener.accept(updatedItem); } catch (Exception e) { - LOG.log(Level.WARNING, "Item update listener error", e); + logger.log(Level.WARNING, "Item update listener error", e); } } } + + /** Reset state for app restart */ + public void reset() { + listeners.clear(); + } } \ No newline at end of file diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/PlanEditEvent.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/PlanEditEvent.java similarity index 79% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/PlanEditEvent.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/PlanEditEvent.java index fa31cb08c2..b175f474eb 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/PlanEditEvent.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/PlanEditEvent.java @@ -13,7 +13,7 @@ public class PlanEditEvent { private static final PlanEditEvent INSTANCE = new PlanEditEvent(); private final List> listeners = new CopyOnWriteArrayList<>(); - private static final Logger LOG = Logger.getLogger(PlanEditEvent.class.getName()); + private static final Logger logger = Logger.getLogger(PlanEditEvent.class.getPackageName()); private PlanEditEvent() {} @@ -34,8 +34,13 @@ public void notifyEditRequested(QueueItem itemToEdit) { try { listener.accept(itemToEdit); } catch (Exception e) { - LOG.log(Level.WARNING, "Error in plan edit listener", e); + logger.log(Level.WARNING, "Error in plan edit listener", e); } } } + + /** Reset state for app restart */ + public void reset() { + listeners.clear(); + } } \ No newline at end of file diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/TabSwitchEvent.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/TabSwitchEvent.java similarity index 75% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/TabSwitchEvent.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/TabSwitchEvent.java index 61069a74d2..99e2f11a4d 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/TabSwitchEvent.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/TabSwitchEvent.java @@ -9,7 +9,7 @@ public class TabSwitchEvent { private static final TabSwitchEvent instance = new TabSwitchEvent(); private final List> listeners = new ArrayList<>(); - private static final Logger LOG = Logger.getLogger(TabSwitchEvent.class.getName()); + private static final Logger logger = Logger.getLogger(TabSwitchEvent.class.getPackageName()); private TabSwitchEvent() {} @@ -26,8 +26,13 @@ public void switchToTab(String tabName) { try { listener.accept(tabName); } catch (Exception e) { - LOG.log(Level.WARNING, "Tab switch listener error", e); + logger.log(Level.WARNING, "Tab switch listener error", e); } } } + + /** Reset state for app restart */ + public void reset() { + listeners.clear(); + } } \ No newline at end of file diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/UiSignalEvent.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/UiSignalEvent.java similarity index 78% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/UiSignalEvent.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/UiSignalEvent.java index 3beb73e729..423f0fb02a 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/UiSignalEvent.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/UiSignalEvent.java @@ -13,4 +13,9 @@ private UiSignalEvent() {} public static BooleanProperty envDestroyArmedProperty() { return ENV_DESTROY_ARMED; } + + /** Reset state for app restart */ + public static void reset() { + ENV_DESTROY_ARMED.set(false); + } } diff --git a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/ViewFactory.java b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/ViewFactory.java similarity index 80% rename from app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/ViewFactory.java rename to app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/ViewFactory.java index a3c3f6291c..89d4fc4c59 100644 --- a/app/queue-server/src/main/java/org/phoebus/applications/queueserver/view/ViewFactory.java +++ b/app/queue-server/network/src/main/java/org/phoebus/applications/queueserver/view/ViewFactory.java @@ -17,11 +17,10 @@ */ public enum ViewFactory { - APPLICATION ("/org/phoebus/applications/queueserver/view/Application.fxml"), MONITOR_QUEUE ("/org/phoebus/applications/queueserver/view/MonitorQueue.fxml"), EDIT_AND_CONTROL_QUEUE ("/org/phoebus/applications/queueserver/view/EditAndControlQueue.fxml"); - private static final Logger LOG = Logger.getLogger(ViewFactory.class.getName()); + private static final Logger logger = Logger.getLogger(ViewFactory.class.getPackageName()); private final String path; @@ -31,7 +30,7 @@ public Parent get() { try { return FXMLLoader.load(ViewFactory.class.getResource(path)); } catch (IOException ex) { - LOG.log(Level.SEVERE, "FXML load failed: " + path, ex); + logger.log(Level.SEVERE, "FXML load failed: " + path, ex); return new StackPane(new Label("⚠ Unable to load " + path)); } } diff --git a/app/queue-server/src/main/resources/icons/bluesky.png b/app/queue-server/network/src/main/resources/icons/bluesky.png similarity index 100% rename from app/queue-server/src/main/resources/icons/bluesky.png rename to app/queue-server/network/src/main/resources/icons/bluesky.png diff --git a/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/css/style.css b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/css/style.css new file mode 100644 index 0000000000..6e020b588b --- /dev/null +++ b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/css/style.css @@ -0,0 +1,46 @@ +.tab-pane .tab-header-area .tab-header-background { + -fx-opacity: 0; +} + +.tab-pane .tab-content-area { + -fx-border-color: #b0b0b0; + -fx-border-width: 1; + -fx-background-color: #ffffff; + -fx-padding: 8; +} + +/* Completely hide all focus indicators without changing appearance */ +* { + -fx-focus-color: transparent; + -fx-faint-focus-color: transparent; +} + +/* Keep TextArea border same as unfocused when focused */ +.text-area:focused { + -fx-background-color: linear-gradient(to bottom, derive(-fx-text-box-border, -10%), -fx-text-box-border), + derive(-fx-base,-1%); +} + +/* Override TextArea content focus styling to match unfocused state */ +.text-area:focused .content { + -fx-background-color: + linear-gradient(from 0px 0px to 0px 4px, derive(-fx-control-inner-background, -8%), -fx-control-inner-background); + -fx-background-insets: 0; + -fx-background-radius: 2; +} + +/* Override TableView focus styling */ +.table-view:focused { + -fx-background-color: -fx-box-border, -fx-control-inner-background; + -fx-background-insets: 0, 1; +} + +/* Make table row selection blue instead of gray */ +.table-row-cell:selected { + -fx-background-color: #0096C9; + -fx-table-cell-border-color: derive(#0096C9, 20%); +} + +.table-row-cell:selected .table-cell { + -fx-text-fill: white; +} \ No newline at end of file diff --git a/app/queue-server/src/main/resources/org/phoebus/applications/queueserver/logging.properties b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/logging.properties similarity index 100% rename from app/queue-server/src/main/resources/org/phoebus/applications/queueserver/logging.properties rename to app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/logging.properties diff --git a/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/messages.properties b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/messages.properties new file mode 100644 index 0000000000..4f54486fdb --- /dev/null +++ b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/messages.properties @@ -0,0 +1,4 @@ +EditControlQueue=Edit & Control Queue +EditControlQueueMenuPath=Utility +QueueMonitor=Queue Monitor +QueueMonitorMenuPath=Utility diff --git a/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/messages_fr.properties b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/messages_fr.properties new file mode 100644 index 0000000000..2eb7a0f569 --- /dev/null +++ b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/messages_fr.properties @@ -0,0 +1,4 @@ +EditControlQueue=Modifier & Contr\u00f4ler la file +EditControlQueueMenuPath=Outil +QueueMonitor=Moniteur de file d'attente +QueueMonitorMenuPath=Outil diff --git a/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/scripts/type_converter.py b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/scripts/type_converter.py new file mode 100644 index 0000000000..ff485ad9f6 --- /dev/null +++ b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/scripts/type_converter.py @@ -0,0 +1,186 @@ +""" +Type converter script for Queue Server parameter parsing. + +This script uses Python's ast.literal_eval to safely parse parameter values +from string representations, matching the behavior of the Python Qt implementation. + +Usage from Java: + - Pass 'parameters_json' as a JSON string containing parameter definitions + - Returns 'result' as a JSON string with parsed values +""" + +import ast +import json +import sys + +# Sentinel value for empty/unset parameters (Jython 2.7 doesn't have inspect.Parameter.empty) +EMPTY = object() + +def parse_literal_value(value_str): + """ + Parse a string representation of a value into its proper Python type. + Mimics ast.literal_eval behavior used in the PyQt implementation. + + Args: + value_str: String representation of the value + + Returns: + Parsed value with appropriate Python type + """ + if value_str is None or value_str == '': + return EMPTY + + value_str = value_str.strip() + + # Handle None/null + if value_str in ('None', 'null'): + return None + + # Handle booleans + if value_str in ('True', 'true'): + return True + if value_str in ('False', 'false'): + return False + + # Handle quoted strings + if ((value_str.startswith("'") and value_str.endswith("'")) or + (value_str.startswith('"') and value_str.endswith('"'))): + return value_str[1:-1] + + # Try numeric parsing + try: + if '.' in value_str: + return float(value_str) + else: + return int(value_str) + except ValueError: + pass + + # Try ast.literal_eval for lists, dicts, tuples, etc. + try: + return ast.literal_eval(value_str) + except (ValueError, SyntaxError): + # If all else fails, return as string + return value_str + + +def convert_parameters(parameters_data): + """ + Convert parameter values from string representations to typed objects. + + Args: + parameters_data: List of parameter dictionaries with 'name', 'value', 'enabled' fields + + Returns: + Dictionary mapping parameter names to their parsed values + """ + result = {} + + for param in parameters_data: + param_name = param.get('name') + param_value = param.get('value') + is_enabled = param.get('enabled', True) + default_value = param.get('defaultValue') + + # Skip disabled parameters entirely - they should not be included in kwargs + if not is_enabled: + continue + + # Skip parameters with no value (empty and no default) + if param_value is None or param_value == '': + continue + + try: + # Parse the value string to proper type + parsed_value = parse_literal_value(param_value) + + # Only include if it's not empty + if parsed_value != EMPTY: + result[param_name] = parsed_value + + except Exception as e: + # Log error but continue processing other parameters + sys.stderr.write("Warning: Failed to parse parameter '%s' with value '%s': %s\n" % (param_name, param_value, e)) + # Fall back to string value + result[param_name] = param_value + + return result + + +def validate_parameters(parameters_data): + """ + Validate parameter values and return validation results. + + Args: + parameters_data: List of parameter dictionaries + + Returns: + Dictionary with validation results for each parameter + """ + validation_results = {} + + for param in parameters_data: + param_name = param.get('name') + param_value = param.get('value') + is_enabled = param.get('enabled', True) + is_optional = param.get('isOptional', False) + + if not is_enabled: + validation_results[param_name] = {'valid': True, 'message': 'Disabled'} + continue + + if param_value is None or param_value == '': + is_valid = is_optional + validation_results[param_name] = { + 'valid': is_valid, + 'message': 'Required parameter missing' if not is_valid else 'OK' + } + continue + + try: + # Try to parse the value + parse_literal_value(param_value) + validation_results[param_name] = {'valid': True, 'message': 'OK'} + except Exception as e: + validation_results[param_name] = { + 'valid': False, + 'message': 'Parse error: %s' % str(e) + } + + return validation_results + + +# Main execution +if __name__ == '__main__': + # When run directly (for testing) + test_params = [ + {'name': 'detector', 'value': "'det1'", 'enabled': True, 'isOptional': False}, + {'name': 'num_points', 'value': '10', 'enabled': True, 'isOptional': False}, + {'name': 'exposure', 'value': '0.5', 'enabled': True, 'isOptional': False}, + {'name': 'metadata', 'value': "{'key': 'value'}", 'enabled': True, 'isOptional': True}, + ] + + result = convert_parameters(test_params) + # Don't print - just for testing + pass + +# Script entry point for Jython execution +# Expects: parameters_json (input), sets: result (output) +try: + if 'parameters_json' in dir(): + # Parse input JSON + params_data = json.loads(parameters_json) + + # Convert parameters + converted = convert_parameters(params_data) + + # Set result as JSON string + result = json.dumps(converted) + +except Exception as e: + # Return error as result + result = json.dumps({ + 'error': str(e), + 'type': type(e).__name__ + }) + sys.stderr.write("Error in type_converter.py: %s\n" % e) diff --git a/app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/EditAndControlQueue.fxml b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/EditAndControlQueue.fxml similarity index 76% rename from app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/EditAndControlQueue.fxml rename to app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/EditAndControlQueue.fxml index 5d94bedfed..c7d57525fe 100644 --- a/app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/EditAndControlQueue.fxml +++ b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/EditAndControlQueue.fxml @@ -4,24 +4,29 @@ - + - + + + + + + - + - + diff --git a/app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/MonitorQueue.fxml b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/MonitorQueue.fxml similarity index 79% rename from app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/MonitorQueue.fxml rename to app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/MonitorQueue.fxml index 74a5727546..db7e5ec80e 100644 --- a/app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/MonitorQueue.fxml +++ b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/MonitorQueue.fxml @@ -18,22 +18,22 @@ - + - + - + - + diff --git a/app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/ReConsoleMonitor.fxml b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/ReConsoleMonitor.fxml similarity index 91% rename from app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/ReConsoleMonitor.fxml rename to app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/ReConsoleMonitor.fxml index 3142fd14d4..2857ff8b22 100644 --- a/app/queue-server/src/main/resources/org/phoebus/applications/queueserver/view/ReConsoleMonitor.fxml +++ b/app/queue-server/network/src/main/resources/org/phoebus/applications/queueserver/view/ReConsoleMonitor.fxml @@ -10,7 +10,7 @@ - +