interface added and web ui created
This commit is contained in:
Martino Ferrari
@@ -1,61 +1,281 @@
|
||||
# API Documentation
|
||||
|
||||
## 1. TCP Control Interface (Port 8080)
|
||||
|
||||
### 1.1 `TREE`
|
||||
Retrieves the full object hierarchy.
|
||||
- **Request:** `TREE
|
||||
`
|
||||
- **Response:** `JSON_OBJECT
|
||||
OK TREE
|
||||
`
|
||||
|
||||
### 1.2 `DISCOVER`
|
||||
Lists all registrable signals and their metadata.
|
||||
- **Request:** `DISCOVER
|
||||
`
|
||||
- **Response:** `{"Signals": [...]}
|
||||
OK DISCOVER
|
||||
`
|
||||
|
||||
### 1.3 `TRACE <path> <state>`
|
||||
Enables/disables telemetry for a signal.
|
||||
- **Example:** `TRACE App.Data.Timer.Counter 1
|
||||
`
|
||||
- **Response:** `OK TRACE <match_count>
|
||||
`
|
||||
|
||||
### 1.4 `FORCE <path> <value>`
|
||||
Overrides a signal value in memory.
|
||||
- **Example:** `FORCE App.Data.DDB.Signal 123.4
|
||||
`
|
||||
- **Response:** `OK FORCE <match_count>
|
||||
`
|
||||
|
||||
### 1.5 `PAUSE` / `RESUME`
|
||||
Controls global execution state via the Scheduler.
|
||||
- **Request:** `PAUSE
|
||||
`
|
||||
- **Response:** `OK
|
||||
`
|
||||
This document covers both transport implementations. The command text protocol is identical
|
||||
for both; only the carrier differs.
|
||||
|
||||
---
|
||||
|
||||
## 2. UDP Telemetry Format (Port 8081)
|
||||
## 1. DebugService — TCP Command Interface (default port 8080)
|
||||
|
||||
Telemetry packets are Little-Endian and use `#pragma pack(1)`.
|
||||
Commands are newline-terminated (`\n`) UTF-8 text strings sent over a persistent TCP
|
||||
connection. One client is served at a time; concurrent connections queue.
|
||||
|
||||
### 2.1 TraceHeader (20 Bytes)
|
||||
| Offset | Type | Name | Description |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| 0 | uint32 | magic | Always `0xDA7A57AD` |
|
||||
| 4 | uint32 | seq | Incremental sequence number |
|
||||
| 8 | uint64 | timestamp | High-resolution timestamp |
|
||||
| 16 | uint32 | count | Number of samples in payload |
|
||||
A client sending more than **100 commands per second** is disconnected (rate limit).
|
||||
A client that sends no data for **30 seconds** is disconnected (idle timeout).
|
||||
|
||||
### 2.2 Sample Entry
|
||||
| Offset | Type | Name | Description |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| 0 | uint32 | id | Internal Signal ID (from `DISCOVER`) |
|
||||
| 4 | uint32 | size | Data size in bytes |
|
||||
| 8 | Bytes | data | Raw signal memory |
|
||||
### 1.1 `DISCOVER`
|
||||
List all registered signals with full metadata.
|
||||
|
||||
- **Request:** `DISCOVER\n`
|
||||
- **Response:**
|
||||
```
|
||||
{"Signals":[{"id":<n>,"name":"…","alias":"…","type":"…","elements":<n>},...]}
|
||||
OK DISCOVER
|
||||
```
|
||||
|
||||
### 1.2 `TREE`
|
||||
Return the full live `ObjectRegistryDatabase` hierarchy as JSON.
|
||||
|
||||
- **Request:** `TREE\n`
|
||||
- **Response:**
|
||||
```json
|
||||
{"name":"Root","children":[…]}
|
||||
OK TREE
|
||||
```
|
||||
|
||||
### 1.3 `INFO <path>`
|
||||
Return metadata for a specific ORD node. Response is enriched with config fields
|
||||
(Frequency, Units, PVNames, …) when a full config has been provided via `SetFullConfig`.
|
||||
|
||||
- **Request:** `INFO App.Functions.GAM1\n`
|
||||
- **Response:**
|
||||
```
|
||||
{"path":"…","class":"…","signals":[…],"config":{…}}
|
||||
OK INFO
|
||||
```
|
||||
|
||||
### 1.4 `LS [path]`
|
||||
List the immediate children of an ORD node.
|
||||
|
||||
- **Request:** `LS App.Data\n`
|
||||
- **Response:**
|
||||
```
|
||||
{"nodes":["Timer","DDB"]}
|
||||
OK LS
|
||||
```
|
||||
|
||||
### 1.5 `TRACE <name> <0|1> [decimation]`
|
||||
Enable or disable high-speed tracing for a signal. Optional `decimation` controls
|
||||
how many RT cycles are skipped between samples (default 1 = every cycle).
|
||||
|
||||
- **Request:** `TRACE App.Data.DDB.Counter 1\n`
|
||||
- **Request:** `TRACE App.Data.DDB.Counter 1 10\n` *(every 10th sample)*
|
||||
- **Response:** `OK TRACE <match_count>\n`
|
||||
|
||||
### 1.6 `FORCE <name> <value>`
|
||||
Inject a persistent value into a signal's memory location. The RT broker will copy
|
||||
the forced value on every cycle until `UNFORCE` is called.
|
||||
|
||||
- **Request:** `FORCE App.Data.DDB.Counter 9999\n`
|
||||
- **Response:** `OK FORCE <match_count>\n`
|
||||
|
||||
### 1.7 `UNFORCE <name>`
|
||||
Remove a forced value; the signal resumes its normal data-flow value.
|
||||
|
||||
- **Request:** `UNFORCE App.Data.DDB.Counter\n`
|
||||
- **Response:** `OK UNFORCE <match_count>\n`
|
||||
|
||||
### 1.8 `BREAK <name> <op> <threshold>`
|
||||
Set a conditional breakpoint on a signal. When the condition fires, the application
|
||||
pauses and execution stepping becomes available. Supported operators:
|
||||
|
||||
| `op` string | Condition |
|
||||
|---|---|
|
||||
| `>` | signal > threshold |
|
||||
| `<` | signal < threshold |
|
||||
| `==` | signal == threshold |
|
||||
| `>=` | signal >= threshold |
|
||||
| `<=` | signal <= threshold |
|
||||
| `!=` | signal != threshold |
|
||||
| `OFF` | disable break (same as `BREAK <name> OFF`) |
|
||||
|
||||
- **Request:** `BREAK App.Data.DDB.Counter > 1000\n`
|
||||
- **Response:** `OK BREAK <match_count>\n`
|
||||
|
||||
### 1.9 `BREAK <name> OFF`
|
||||
Clear the breakpoint on a signal (equivalent to `BREAK <name> OFF 0`).
|
||||
|
||||
- **Request:** `BREAK App.Data.DDB.Counter OFF\n`
|
||||
- **Response:** `OK BREAK <match_count>\n`
|
||||
|
||||
### 1.10 `PAUSE`
|
||||
Halt all patched RT threads at the start of their next Execute cycle.
|
||||
|
||||
- **Request:** `PAUSE\n`
|
||||
- **Response:** `OK\n`
|
||||
|
||||
### 1.11 `RESUME`
|
||||
Release paused RT threads.
|
||||
|
||||
- **Request:** `RESUME\n`
|
||||
- **Response:** `OK\n`
|
||||
|
||||
### 1.12 `STEP <n> [thread]`
|
||||
Resume execution for exactly `n` RT output-broker cycles then pause again.
|
||||
Optional `thread` (OS thread name) restricts counting to one thread.
|
||||
|
||||
- **Request:** `STEP 5\n`
|
||||
- **Request:** `STEP 1 RealTimeThread1\n`
|
||||
- **Response:** `OK STEP\n`
|
||||
|
||||
### 1.13 `STEP_STATUS`
|
||||
Query current pause and stepping state.
|
||||
|
||||
- **Request:** `STEP_STATUS\n`
|
||||
- **Response:**
|
||||
```json
|
||||
{"paused":true,"gam":"App.Functions.GAM1","remaining":3}
|
||||
OK STEP_STATUS
|
||||
```
|
||||
|
||||
### 1.14 `VALUE <name>`
|
||||
Read the current raw value of a signal from its memory address. Arrays are
|
||||
capped at 256 elements; larger signals include `"truncated":true`.
|
||||
|
||||
- **Request:** `VALUE App.Data.DDB.Counter\n`
|
||||
- **Response:**
|
||||
```json
|
||||
{"name":"App.Data.DDB.Counter","type":"uint32","elements":1,"values":[42]}
|
||||
OK VALUE
|
||||
```
|
||||
|
||||
### 1.15 `MONITOR SIGNAL <name> <periodMs>`
|
||||
Register a signal for slow-rate polling. The service reads the signal directly
|
||||
from its `DataSourceI` and sends the value at the specified period.
|
||||
|
||||
- **Request:** `MONITOR SIGNAL App.Data.DDB.Counter 500\n`
|
||||
- **Response:** `OK MONITOR <id>\n`
|
||||
|
||||
On `DebugService`, monitored values are pushed over UDP with signal ID = internal monitor ID.
|
||||
On `WebDebugService`, they are broadcast as `{"type":"monitor",…}` SSE events.
|
||||
|
||||
### 1.16 `UNMONITOR SIGNAL <name>`
|
||||
Stop polling a monitored signal.
|
||||
|
||||
- **Request:** `UNMONITOR SIGNAL App.Data.DDB.Counter\n`
|
||||
- **Response:** `OK UNMONITOR\n`
|
||||
|
||||
### 1.17 `CONFIG`
|
||||
Return the full application configuration as JSON. Requires that `SetFullConfig()` was
|
||||
called after `ConfigureApplication()`.
|
||||
|
||||
- **Request:** `CONFIG\n`
|
||||
- **Response:**
|
||||
```json
|
||||
{"App":{"Class":"RealTimeApplication",…}}
|
||||
OK CONFIG
|
||||
```
|
||||
|
||||
### 1.18 `MSG <object> <function> [key=value …]`
|
||||
Send a MARTe2 `Message` to any object in the ORD.
|
||||
|
||||
- **Request:** `MSG App.Functions.GAM1 Reset\n`
|
||||
- **Request:** `MSG App.StateMachine GOTOSTATE NewState=Running\n`
|
||||
- **Response:** `OK MSG\n` or `ERROR MSG <reason>\n`
|
||||
|
||||
### 1.19 `SERVICE_INFO`
|
||||
Return metadata about the debug service itself.
|
||||
|
||||
- **Request:** `SERVICE_INFO\n`
|
||||
- **Response:**
|
||||
```json
|
||||
{"transport":"TCP","controlPort":8080,"udpPort":8081,"logPort":8082}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 2. WebDebugService — HTTP Interface (default port 8090)
|
||||
|
||||
### 2.1 `GET /`
|
||||
Returns the embedded single-page application. Open in any web browser.
|
||||
|
||||
### 2.2 `POST /api/command`
|
||||
Execute any command from Section 1. The request body is the command text
|
||||
(without a trailing newline). CORS headers are included.
|
||||
|
||||
- **Request headers:** `Content-Type: text/plain`
|
||||
- **Request body:** e.g. `TRACE App.Data.DDB.Counter 1`
|
||||
- **Response:** Plain text; same content as the TCP response.
|
||||
|
||||
### 2.3 `GET /api/events`
|
||||
Long-lived Server-Sent Events stream. Up to 8 simultaneous clients.
|
||||
|
||||
Each event is formatted as:
|
||||
```
|
||||
event: message
|
||||
data: <json>
|
||||
|
||||
```
|
||||
(blank line terminates each event per SSE spec)
|
||||
|
||||
#### SSE event types
|
||||
|
||||
| `type` field | Additional fields | Description |
|
||||
|---|---|---|
|
||||
| `trace` | `name`, `ts` (ns), `value` (f64) | One traced signal sample |
|
||||
| `monitor` | `name`, `ts` (ns), `value` (f64) | One slow-rate monitor sample |
|
||||
| `log` | `level`, `msg` | Forwarded `REPORT_ERROR` log entry |
|
||||
| `status` | `paused` (bool), `gam`, `remaining` | Pause/step state heartbeat (every 500 ms) |
|
||||
| `discover` | `signals` (array) | Full signal list (sent on SSE connect) |
|
||||
| `tree` | `tree` (object) | Full ORD tree (sent on SSE connect) |
|
||||
|
||||
Example trace event:
|
||||
```
|
||||
event: message
|
||||
data: {"type":"trace","name":"App.Data.DDB.Counter","ts":1234567890,"value":42.0}
|
||||
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 3. UDP Telemetry Format (DebugService, default port 8081)
|
||||
|
||||
Packets are little-endian and packed (`#pragma pack(1)`).
|
||||
|
||||
### 3.1 `TraceHeader` (20 bytes)
|
||||
|
||||
| Offset | Type | Field | Description |
|
||||
|---|---|---|---|
|
||||
| 0 | uint32 | `magic` | Always `0xDA7A57AD` |
|
||||
| 4 | uint32 | `seq` | Monotonically incrementing sequence number |
|
||||
| 8 | uint64 | `timestamp` | High-resolution hardware timestamp |
|
||||
| 16 | uint32 | `count` | Number of samples in this datagram |
|
||||
|
||||
### 3.2 Sample Entry (per signal)
|
||||
|
||||
| Offset | Type | Field | Description |
|
||||
|---|---|---|---|
|
||||
| 0 | uint32 | `id` | Signal ID from `DISCOVER` |
|
||||
| 4 | uint64 | `timestamp` | Per-sample RT timestamp |
|
||||
| 12 | uint32 | `size` | Payload size in bytes |
|
||||
| 16 | bytes | `data` | Raw signal memory (`size` bytes) |
|
||||
|
||||
Multiple samples may be packed into one datagram up to `STREAMER_MTU = 1400` bytes.
|
||||
A new datagram is started when the next sample would overflow the MTU.
|
||||
|
||||
---
|
||||
|
||||
## 4. Log Forwarding (DebugService, default port 8082)
|
||||
|
||||
The `TcpLogger` component (`Source/Components/Interfaces/TCPLogger/`) connects to the
|
||||
MARTe2 global `LoggerI` and forwards every `REPORT_ERROR` call as a text line:
|
||||
|
||||
```
|
||||
<level>|<object>|<function>|<message>\n
|
||||
```
|
||||
|
||||
Up to 8 simultaneous log clients are supported. If no client is connected, log events
|
||||
are silently discarded.
|
||||
|
||||
To enable:
|
||||
|
||||
```text
|
||||
+Logger = {
|
||||
Class = TcpLogger
|
||||
Port = 8082
|
||||
MaxClients = 8
|
||||
}
|
||||
```
|
||||
|
||||
On `WebDebugService`, logs are forwarded to SSE clients as `{"type":"log","level":"…","msg":"…"}`
|
||||
events — no separate `TcpLogger` instance is required.
|
||||
|
||||
+257
-32
@@ -1,44 +1,269 @@
|
||||
# System Architecture
|
||||
|
||||
## 1. Overview
|
||||
The suite consists of a C++ server library (`libmarte_dev.so`) that instrument MARTe2 applications at runtime, and a native Rust client for visualization.
|
||||
|
||||
The MARTe2 Debug Suite is a C++ server library that instruments running MARTe2 applications
|
||||
without modifying their source code. It exposes an abstract `DebugServiceI` interface that
|
||||
decouples the broker injection layer from the communication transport, allowing multiple
|
||||
transport backends to coexist (currently TCP/UDP and HTTP/SSE).
|
||||
|
||||
```
|
||||
┌────────────────────────────────────────────────────────────────────┐
|
||||
│ MARTe2 Application │
|
||||
│ ┌──────────┐ ┌───────────────────────┐ ┌──────────────────┐ │
|
||||
│ │ GAM(s) │ │ DebugBrokerWrapper │ │ FastScheduler │ │
|
||||
│ │ │◄──│ (Registry-patched) │ │ (unmodified) │ │
|
||||
│ └──────────┘ └──────────┬────────────┘ └──────────────────┘ │
|
||||
│ │ RT-path API │
|
||||
└────────────────────────────┼───────────────────────────────────────┘
|
||||
│
|
||||
┌────────▼────────┐
|
||||
│ DebugServiceI │ ← Abstract interface (singleton)
|
||||
└────────┬────────┘
|
||||
┌─────────────┴──────────────┐
|
||||
│ │
|
||||
┌────────▼────────┐ ┌─────────▼────────┐
|
||||
│ DebugService │ │ WebDebugService │
|
||||
│ TCP/UDP │ │ HTTP/SSE │
|
||||
└────────┬────────┘ └─────────┬─────────┘
|
||||
│ │
|
||||
┌──────────┼──────────┐ ┌──────────┼──────────┐
|
||||
│TCP 8080 │UDP 8081 │ │HTTP 8090 │SSE stream │
|
||||
│(commands)│(telemetry│ │(commands)│(telemetry)│
|
||||
└────┬─────┴────┬─────┘ └─────┬────┴────┬──────┘
|
||||
│ │ │ │
|
||||
┌────▼──────────▼─────┐ ┌─────────▼─────────▼──────┐
|
||||
│ Rust/egui GUI │ │ Web Browser (built-in UI)│
|
||||
│ (Tools/gui_client) │ │ http://localhost:8090 │
|
||||
└─────────────────────┘ └───────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 2. Core Mechanism: Registry Patching
|
||||
The "Zero-Code-Change" requirement is met by intercepting the MARTe2 `ClassRegistryDatabase`. When the `DebugService` initializes, it replaces the standard object builders for critical classes:
|
||||
|
||||
1. **Broker Injection:** Standard Brokers (e.g., `MemoryMapInputBroker`) are replaced with `DebugBrokerWrapper`. This captures data every time a GAM reads or writes a signal.
|
||||
2. **Scheduler Injection:** The `FastScheduler` is replaced with `DebugFastScheduler`. This provides hooks at the start/end of each real-time cycle for execution control (pausing).
|
||||
The "Zero-Code-Change" requirement is met by intercepting the MARTe2 `ClassRegistryDatabase`.
|
||||
When `DebugService` or `WebDebugService` initialises, `PatchRegistry()` replaces the
|
||||
`ObjectBuilder` for every standard `MemoryMap*Broker` class in the registry. When
|
||||
`RealTimeApplication::ConfigureApplication()` runs afterward it instantiates wrapped broker
|
||||
objects instead of the originals — the application sees no difference.
|
||||
|
||||
## 3. Communication Layer
|
||||
The system uses three distinct channels:
|
||||
Patched broker types:
|
||||
|
||||
### 3.1 Command & Control (TCP Port 8080)
|
||||
- **Protocol:** Text-based over TCP.
|
||||
- **Role:** Object tree discovery (`TREE`), signal metadata (`DISCOVER`), and trace activation (`TRACE`).
|
||||
- **Response Format:** JSON for complex data, `OK/ERROR` for status.
|
||||
| Class | Wrapper |
|
||||
|---|---|
|
||||
| `MemoryMapInputBroker` | `DebugBrokerWrapper<MemoryMapInputBroker>` |
|
||||
| `MemoryMapOutputBroker` | `DebugBrokerWrapper<MemoryMapOutputBroker>` |
|
||||
| `MemoryMapSynchronisedInputBroker` | `DebugBrokerWrapper<MemoryMapSynchronisedInputBroker>` |
|
||||
| `MemoryMapSynchronisedOutputBroker` | `DebugBrokerWrapper<MemoryMapSynchronisedOutputBroker>` |
|
||||
| `MemoryMapMultiBufferBroker` | `DebugBrokerWrapper<MemoryMapMultiBufferBroker>` |
|
||||
| `MemoryMapMultiBufferOutputBroker` | `DebugBrokerWrapper<MemoryMapMultiBufferOutputBroker>` |
|
||||
| `MemoryMapAsynchronousInputBroker` | `DebugBrokerWrapperAsync<MemoryMapAsynchronousInputBroker>` |
|
||||
| `MemoryMapAsynchronousOutputBroker` | `DebugBrokerWrapperAsync<MemoryMapAsynchronousOutputBroker>` |
|
||||
| `MemoryMapInterpolatedInputBroker` | `DebugBrokerWrapper<MemoryMapInterpolatedInputBroker>` |
|
||||
| `MemoryMapStatefulOutputBroker` | `DebugBrokerWrapper<MemoryMapStatefulOutputBroker>` |
|
||||
| `MemoryMapStatefulInputBroker` | `DebugBrokerWrapper<MemoryMapStatefulInputBroker>` |
|
||||
|
||||
### 3.2 High-Speed Telemetry (UDP Port 8081)
|
||||
- **Protocol:** Binary over UDP.
|
||||
- **Format:** Packed C-structs.
|
||||
- **Header:** `[Magic:4][Seq:4][TS:8][Count:4]` (Packed, 20 bytes).
|
||||
- **Payload:** `[ID:4][Size:4][Data:N]` (Repeated for each traced signal).
|
||||
---
|
||||
|
||||
### 3.3 Log Streaming (TCP Port 8082)
|
||||
- **Protocol:** Real-time event streaming.
|
||||
- **Service:** `TcpLogger` (Standalone component).
|
||||
- **Role:** Forwards global `REPORT_ERROR` calls and `stdout` messages to the GUI client.
|
||||
## 3. DebugServiceI Abstraction Layer
|
||||
|
||||
## 4. Component Diagram
|
||||
```text
|
||||
[ MARTe2 App ] <--- [ DebugFastScheduler ] (Registry Patch)
|
||||
| |
|
||||
+ <--- [ DebugBrokerWrapper ] (Registry Patch)
|
||||
| |
|
||||
+---------------------+
|
||||
| |
|
||||
[ DebugService ] [ TcpLogger ]
|
||||
| |
|
||||
+--- (TCP 8080) ------+-----> [ Rust GUI Client ]
|
||||
+--- (UDP 8081) ------+-----> [ (Oscilloscope) ]
|
||||
+--- (TCP 8082) ------+-----> [ (Log Terminal) ]
|
||||
`Source/Components/Interfaces/DebugService/DebugServiceI.h` defines the abstract singleton
|
||||
interface. It has two logical groups:
|
||||
|
||||
### 3.1 RT-path API
|
||||
Called from broker threads on every RT cycle. Must be as cheap as possible; the only
|
||||
permissible synchronisation primitive is `FastPollingMutexSem`.
|
||||
|
||||
| Method | Purpose |
|
||||
|---|---|
|
||||
| `RegisterSignal(addr, type, name, …)` | Called once per signal during broker `Init()` |
|
||||
| `ProcessSignal(info, size, timestamp)` | Apply forcing, check break, push trace sample |
|
||||
| `RegisterBroker(…)` | Cache broker metadata for active/break index updates |
|
||||
| `IsPaused() / SetPaused(bool)` | Query / set global pause state |
|
||||
| `ConsumeStepIfNeeded(gamName, thread)` | Decrement step counter on output-broker Execute |
|
||||
|
||||
### 3.2 Control-path API
|
||||
Called from server/command-handler threads; latency acceptable.
|
||||
|
||||
| Method | Purpose |
|
||||
|---|---|
|
||||
| `ForceSignal / UnforceSignal` | Persistent value injection |
|
||||
| `TraceSignal(name, enable, decimation)` | Enable/disable ring-buffer tracing |
|
||||
| `SetBreak / ClearBreak` | Conditional breakpoints |
|
||||
| `IsInstrumented(path, …)` | Query whether a signal is reachable |
|
||||
| `RegisterMonitorSignal / UnmonitorSignal` | Slow-rate signal polling |
|
||||
|
||||
### 3.3 Static singleton pattern
|
||||
|
||||
```cpp
|
||||
// Concrete implementation registers itself:
|
||||
DebugServiceI::SetInstance(this); // in Initialise()
|
||||
DebugServiceI::SetInstance(NULL_PTR(…)); // in destructor
|
||||
|
||||
// Broker wrappers retrieve it (no ORD search on the hot path):
|
||||
DebugServiceI *svc = DebugServiceI::GetInstance();
|
||||
if (svc != NULL_PTR(DebugServiceI*)) { ... }
|
||||
```
|
||||
|
||||
Shared data structures (`SignalAlias`, `BrokerInfo`) are also defined in `DebugServiceI.h`
|
||||
so both transport implementations can use them without a circular dependency.
|
||||
|
||||
---
|
||||
|
||||
## 4. Transport Implementations
|
||||
|
||||
### 4.1 DebugService (TCP/UDP)
|
||||
|
||||
`Source/Components/Interfaces/DebugService/DebugService.h/.cpp`
|
||||
|
||||
Runs two `SingleThreadService` threads:
|
||||
|
||||
| Thread | Role |
|
||||
|---|---|
|
||||
| `Server()` | Accepts one TCP client at a time; reads text commands; writes JSON/text responses |
|
||||
| `Streamer()` | Drains `TraceRingBuffer`; assembles and sends UDP datagrams; polls monitored signals |
|
||||
|
||||
Communication ports (all configurable):
|
||||
|
||||
| Port | Protocol | Purpose |
|
||||
|---|---|---|
|
||||
| `ControlPort` (default 8080) | TCP text | Commands and responses |
|
||||
| `UdpPort` (default 8081) | UDP binary | High-speed telemetry (`TraceHeader` + samples) |
|
||||
| `LogPort` (default 8082) | TCP stream | Log forwarding via `TcpLogger` sidecar |
|
||||
|
||||
### 4.2 WebDebugService (HTTP/SSE)
|
||||
|
||||
`Source/Components/Interfaces/WebDebugService/WebDebugService.h/.cpp`
|
||||
|
||||
Serves a single HTTP port (default 8090) with an embedded browser UI. Runs two
|
||||
`SingleThreadService` threads:
|
||||
|
||||
| Thread | Role |
|
||||
|---|---|
|
||||
| `HttpServer()` | Accepts TCP connections; routes GET/POST/OPTIONS; upgrades SSE clients |
|
||||
| `Streamer()` | Drains `TraceRingBuffer` → SSE events; polls monitored signals; heartbeat |
|
||||
|
||||
HTTP endpoints:
|
||||
|
||||
| Endpoint | Method | Purpose |
|
||||
|---|---|---|
|
||||
| `/` | GET | Serves embedded single-page application (HTML/CSS/JS) |
|
||||
| `/api/command` | POST | Execute a debug command; returns text response |
|
||||
| `/api/events` | GET | Server-Sent Events stream for real-time telemetry (up to 8 clients) |
|
||||
|
||||
The embedded web UI (`Source/Components/Interfaces/WebDebugService/WebUI.h`) is a
|
||||
self-contained single-page application using Chart.js for real-time signal plots and a
|
||||
Catppuccin Mocha dark theme. No install or server-side tooling required.
|
||||
|
||||
---
|
||||
|
||||
## 5. Signal Flow
|
||||
|
||||
### 5.1 Registration (startup, single-threaded)
|
||||
|
||||
```
|
||||
ConfigureApplication()
|
||||
└─► DebugBrokerWrapper::Init()
|
||||
└─► DebugBrokerHelper::InitSignals()
|
||||
├─► DebugServiceI::RegisterSignal() (canonical name + GAM alias)
|
||||
└─► DebugServiceI::RegisterBroker()
|
||||
```
|
||||
|
||||
### 5.2 RT loop (hot path, multi-threaded)
|
||||
|
||||
```
|
||||
RealTimeThread::Execute()
|
||||
└─► DebugBrokerWrapper::Execute()
|
||||
├─► Base::Execute() (data moved in/out of GAM memory)
|
||||
└─► DebugBrokerHelper::Process()
|
||||
├─► For each active signal:
|
||||
│ └─► DebugServiceI::ProcessSignal()
|
||||
│ ├─► if isForcing: memcpy forcedValue → signal memory
|
||||
│ ├─► if isTracing & decimation fires:
|
||||
│ │ └─► tracePushMutex → TraceRingBuffer::Push()
|
||||
│ └─► if breakOp set: evaluate condition → SetPaused(true)
|
||||
└─► (output brokers only) DebugServiceI::ConsumeStepIfNeeded()
|
||||
```
|
||||
|
||||
### 5.3 Telemetry delivery
|
||||
|
||||
**DebugService (UDP)**
|
||||
```
|
||||
Streamer thread
|
||||
└─► TraceRingBuffer::Pop()
|
||||
└─► assemble into streamerPacketBuffer (MTU=1400)
|
||||
└─► BasicUDPSocket::Write() → client
|
||||
```
|
||||
|
||||
**WebDebugService (SSE)**
|
||||
```
|
||||
Streamer thread
|
||||
└─► TraceRingBuffer::Pop()
|
||||
└─► BroadcastSse("message", {"type":"trace","name":…,"value":…})
|
||||
└─► write "event: message\ndata: {…}\n\n" to each SSE socket
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 6. TraceRingBuffer
|
||||
|
||||
Single-producer / single-consumer circular byte buffer defined in `DebugCore.h`.
|
||||
|
||||
```
|
||||
Buffer layout per entry: [ID:4][Timestamp:8][Size:4][Data:N]
|
||||
```
|
||||
|
||||
- `Push()` is serialised by `tracePushMutex` (multiple RT threads write; one Streamer reads).
|
||||
- `Pop()` is called exclusively by the Streamer thread.
|
||||
- Ring is initialised to 4 MB in both transport implementations.
|
||||
- On corrupt `size` field (`size >= bufferSize`): discards all entries to prevent cascading
|
||||
bad reads (Fix #5).
|
||||
|
||||
---
|
||||
|
||||
## 7. Performance Hardening
|
||||
|
||||
The following fixes were applied after initial implementation to improve correctness and
|
||||
real-time safety.
|
||||
|
||||
| Fix | Area | Change |
|
||||
|---|---|---|
|
||||
| **#1** | UDP streamer | Named constants `STREAMER_MTU = 1400` and `STREAMER_BUFFER_SIZE = 4096`; removed magic numbers |
|
||||
| **#2** | Multi-producer ring | `tracePushMutex` serialises `TraceRingBuffer::Push()` from concurrent RT threads |
|
||||
| **#3** | Break evaluation | Break indices copied to stack-local array while holding `activeMutex`; condition evaluated outside the lock |
|
||||
| **#4** | Decimation counter | `Atomic::Add` used for lock-free per-signal decimation in multi-producer `ProcessSignal` |
|
||||
| **#5** | Ring corruption | `Pop()` skips only the current corrupt entry; falls back to full discard only when `size >= bufferSize` |
|
||||
| **#6** | TCP rate limit | Server disconnects clients sending > 100 commands/second (`CMD_RATE_LIMIT = 100`) |
|
||||
| **#7** | Broker index swap | `Vec::Swap` inside spinlock followed by free outside; avoids holding the lock during deallocation |
|
||||
| **#8** | Idle timeout | Active TCP client disconnected after 30 s of silence (`CLIENT_IDLE_TIMEOUT_MS = 30000`) |
|
||||
| **#9** | VALUE output size | `GetSignalValue` caps output at 256 elements (`GET_VALUE_MAX_ELEMENTS`); includes `"Truncated"` flag |
|
||||
| **#10** | TCP framing | `inputBuffer` accumulates partial commands across `Read()` calls; bounded at 8 KiB (`INPUT_BUFFER_MAX`) |
|
||||
| **#11** | CDB cursor | `Initialise()` never calls `MoveToRoot()` on the CDB passed by the framework; avoids corrupting `ReferenceContainer` traversal |
|
||||
|
||||
---
|
||||
|
||||
## 8. Repository Layout
|
||||
|
||||
```
|
||||
Source/
|
||||
Core/Types/
|
||||
Vec/ — RT-safe dynamic array (no STL)
|
||||
Result/ — Error-carrying return type
|
||||
Components/Interfaces/
|
||||
DebugService/
|
||||
DebugCore.h — DebugSignalInfo, TraceRingBuffer, BreakOp
|
||||
DebugServiceI.h — Abstract interface + SignalAlias, BrokerInfo
|
||||
DebugBrokerWrapper.h — DebugBrokerHelper, wrapper templates, registry builder
|
||||
DebugService.h/.cpp — TCP/UDP transport implementation
|
||||
WebDebugService/
|
||||
WebUI.h — Embedded single-page HTML/CSS/JS application
|
||||
WebDebugService.h/.cpp — HTTP/SSE transport implementation
|
||||
TCPLogger/
|
||||
TcpLogger.h/.cpp — LoggerConsumerI forwarding logs to TCP clients
|
||||
Test/
|
||||
Integration/ — Integration test suite (180 s SIGALRM guard)
|
||||
UnitTests/ — Unit test suite
|
||||
Tools/
|
||||
gui_client/ — Rust/egui native GUI (DebugService TCP/UDP transport)
|
||||
```
|
||||
|
||||
@@ -1,32 +1,81 @@
|
||||
# Demo Walkthrough: High-Speed Tracing
|
||||
|
||||
This demo demonstrates tracing a `Timer.Counter` signal at 100Hz and verifying its consistency.
|
||||
This demo traces a `Timer.Counter` signal at 100 Hz, tests execution control, and verifies
|
||||
signal forcing. It works with either transport — choose the option that matches your setup.
|
||||
|
||||
---
|
||||
|
||||
## 1. Build and Launch the Test Environment
|
||||
|
||||
### 1. Launch the Test Environment
|
||||
Start the validation environment which simulates a real-time app:
|
||||
```bash
|
||||
./Build/Test/Integration/ValidationTest
|
||||
source env.sh
|
||||
make -f Makefile.gcc
|
||||
./Build/x86-linux/Test/Integration/IntegrationTests
|
||||
```
|
||||
*Note: The test will wait for a trace command before finishing.*
|
||||
|
||||
### 2. Connect the GUI
|
||||
In another terminal:
|
||||
The integration test starts a MARTe2 application with `DebugService` or `WebDebugService`
|
||||
already configured and waits for client interaction.
|
||||
|
||||
---
|
||||
|
||||
## 2. Connect a Client
|
||||
|
||||
### Option A — Web Browser (`WebDebugService`)
|
||||
|
||||
Open `http://localhost:8090` in any browser. The UI appears instantly with the live
|
||||
object tree already loaded.
|
||||
|
||||
### Option B — Rust GUI (`DebugService`)
|
||||
|
||||
```bash
|
||||
cd Tools/gui_client
|
||||
cargo run --release
|
||||
```
|
||||
|
||||
### 3. Explore the Tree
|
||||
1. On the left panel (**Application Tree**), expand `Root.App.Data.Timer`.
|
||||
2. Click the `ℹ Info` button on the `Timer` node to see its configuration (e.g., `SleepTime: 10000`).
|
||||
---
|
||||
|
||||
### 4. Activate Trace
|
||||
1. Locate the `Counter` signal under the `Timer` node.
|
||||
2. Click the **📈 Trace** button.
|
||||
3. The **Oscilloscope** in the center will immediately begin plotting the incremental counter.
|
||||
4. Verify the **UDP Packets** counter in the top bar is increasing rapidly.
|
||||
## 3. Explore the Tree
|
||||
|
||||
### 5. Test Execution Control
|
||||
1. Click the **⏸ Pause** button in the top bar.
|
||||
2. Observe that the plot stops updating and the counter value holds steady.
|
||||
3. Click **▶ Resume** to continue execution.
|
||||
1. In the **Application Tree**, expand `Root → App → Data → Timer`.
|
||||
2. Click **Info** (web UI) or **ℹ Info** (Rust GUI) on the `Timer` node.
|
||||
3. Verify the config panel shows `SleepTime: 10000` (100 Hz cycle).
|
||||
|
||||
---
|
||||
|
||||
## 4. Activate Trace
|
||||
|
||||
1. Locate the `Counter` signal under `Timer`.
|
||||
2. Click **Trace** (web UI) or **📈 Trace** (Rust GUI).
|
||||
3. The real-time plot begins with a monotonically increasing counter.
|
||||
4. Confirm telemetry is flowing:
|
||||
- **Web UI:** `{"type":"trace",…}` events appear in the browser DevTools Network tab.
|
||||
- **Rust GUI:** The **UDP Packets** counter in the top bar increments rapidly.
|
||||
|
||||
---
|
||||
|
||||
## 5. Test Execution Control
|
||||
|
||||
1. Click **Pause** (⏸).
|
||||
2. Observe that the plot freezes and the counter holds steady.
|
||||
3. Click **Step** with count = 5.
|
||||
4. The counter advances exactly 5 units then stops.
|
||||
5. Click **Resume** (▶) to continue normal execution.
|
||||
|
||||
---
|
||||
|
||||
## 6. Test Signal Forcing
|
||||
|
||||
1. Locate `Root.App.Data.DDB.Counter`.
|
||||
2. Click **Force** and enter `99999`.
|
||||
3. Observe the oscilloscope plot jump to and hold at `99999`.
|
||||
4. Click **Unforce** to release — the counter resumes its normal value.
|
||||
|
||||
---
|
||||
|
||||
## 7. Test a Breakpoint
|
||||
|
||||
1. Click **Break** on `Root.App.Data.DDB.Counter`.
|
||||
2. Set operator `>` and threshold `500`.
|
||||
3. Wait for the counter to exceed 500 — the application pauses automatically.
|
||||
4. The status shows **PAUSED** at the GAM that triggered the break.
|
||||
5. Click **Break OFF** then **Resume** to continue.
|
||||
|
||||
@@ -1,48 +1,110 @@
|
||||
# MARTe2 Debug Suite
|
||||
|
||||
An interactive observability and debugging suite for the MARTe2 real-time framework.
|
||||
An interactive observability and debugging suite for the MARTe2 real-time framework. Instruments any running application **without modifying its source code**, providing real-time signal tracing, forced-value injection, breakpoints, execution stepping, and log forwarding.
|
||||
|
||||
---
|
||||
|
||||
## Quick Start
|
||||
|
||||
### 1. Build the project
|
||||
### 1. Build
|
||||
|
||||
```bash
|
||||
. ./env.sh
|
||||
source env.sh
|
||||
make -f Makefile.gcc
|
||||
```
|
||||
|
||||
### 2. Run Integration Tests
|
||||
|
||||
```bash
|
||||
./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex # Runs all tests
|
||||
source env.sh
|
||||
./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex
|
||||
```
|
||||
|
||||
### 3. Launch GUI
|
||||
### 3. Choose Your Client
|
||||
|
||||
**Option A — Web UI (no install required)**
|
||||
|
||||
Add `WebDebugService` to your application config and open `http://localhost:8090` in any browser:
|
||||
|
||||
```text
|
||||
+WebDebugService = {
|
||||
Class = WebDebugService
|
||||
HttpPort = 8090
|
||||
}
|
||||
```
|
||||
|
||||
**Option B — Rust Native GUI**
|
||||
|
||||
Add `DebugService` to your application config, then launch the GUI:
|
||||
|
||||
```bash
|
||||
cd Tools/gui_client
|
||||
cargo run --release
|
||||
```
|
||||
|
||||
## Features
|
||||
- **Live Tree:** Explore the MARTe2 object database in real-time.
|
||||
- **Oscilloscope:** Trace any signal at high frequency (100Hz+) with automatic scaling.
|
||||
- **Signal Forcing:** Inject values directly into the real-time memory map.
|
||||
- **Log Forwarding:** Integrated framework log viewer with regex filtering.
|
||||
- **Execution Control:** Global pause/resume via scheduler-level hooks.
|
||||
|
||||
## Usage
|
||||
To enable debugging in your application, add the following to your `.cfg`:
|
||||
```text
|
||||
+DebugService = {
|
||||
Class = DebugService
|
||||
ControlPort = 8080
|
||||
UdpPort = 8081
|
||||
}
|
||||
|
||||
+LoggerService = {
|
||||
Class = LoggerService
|
||||
+DebugConsumer = {
|
||||
Class = TcpLogger
|
||||
Port = 8082
|
||||
}
|
||||
LogPort = 8082
|
||||
}
|
||||
```
|
||||
The suite automatically patches the registry to instrument your existing Brokers and Schedulers.
|
||||
|
||||
---
|
||||
|
||||
## Features
|
||||
|
||||
| Feature | Description |
|
||||
|---|---|
|
||||
| **Zero-code-change** | Registry patching replaces standard brokers at runtime — no application changes needed |
|
||||
| **Signal tracing** | Stream any signal at full RT rate over UDP (DebugService) or SSE (WebDebugService) |
|
||||
| **Signal forcing** | Persistent value injection directly into the RT memory map |
|
||||
| **Breakpoints** | Halt execution when a signal crosses a threshold (`> < == >= <= !=`) |
|
||||
| **Execution stepping** | Step N RT cycles then pause; optionally filter by thread |
|
||||
| **Live object tree** | Browse the full `ObjectRegistryDatabase` hierarchy with signal metadata |
|
||||
| **Config serving** | Retrieve the complete application CDB as JSON |
|
||||
| **Log forwarding** | All `REPORT_ERROR` events forwarded to the client in real time |
|
||||
| **Signal monitoring** | Poll any `DataSourceI` signal at a configurable period |
|
||||
| **MARTe2 messaging** | Send `Message` objects to any ORD object from the debug client |
|
||||
|
||||
---
|
||||
|
||||
## Transports at a Glance
|
||||
|
||||
| | `DebugService` | `WebDebugService` |
|
||||
|---|---|---|
|
||||
| **Client** | Rust native GUI or any TCP tool | Any web browser |
|
||||
| **Commands** | Text over TCP (port 8080) | HTTP POST `/api/command` |
|
||||
| **Telemetry** | Binary UDP (port 8081) | Server-Sent Events `/api/events` |
|
||||
| **Logs** | TcpLogger TCP (port 8082) | SSE event stream |
|
||||
| **Install** | Rust + Cargo | None |
|
||||
|
||||
Both transports implement the same `DebugServiceI` interface and register themselves as the global singleton — they are mutually exclusive (one per application).
|
||||
|
||||
---
|
||||
|
||||
## Repository Layout
|
||||
|
||||
```
|
||||
Source/
|
||||
Core/Types/
|
||||
Vec/ — RT-safe dynamic array (no STL)
|
||||
Result/ — Error-carrying return type
|
||||
Components/Interfaces/
|
||||
DebugService/
|
||||
DebugCore.h — DebugSignalInfo, TraceRingBuffer, break op codes
|
||||
DebugServiceI.h — Abstract interface + SignalAlias, BrokerInfo structs
|
||||
DebugBrokerWrapper.h — Broker wrapper templates + registry builder helpers
|
||||
DebugService.h/.cpp — TCP/UDP implementation
|
||||
WebDebugService/
|
||||
WebUI.h — Embedded single-page HTML/CSS/JS application
|
||||
WebDebugService.h/.cpp — HTTP/SSE implementation
|
||||
TCPLogger/
|
||||
TcpLogger.h/.cpp — LoggerConsumerI forwarding logs to TCP clients
|
||||
Test/
|
||||
Integration/ — Integration test suite (180 s SIGALRM guard)
|
||||
UnitTests/ — Unit test suite (COVERAGE V34)
|
||||
Tools/
|
||||
gui_client/ — Rust/egui native GUI (DebugService transport only)
|
||||
```
|
||||
|
||||
@@ -1,64 +1,145 @@
|
||||
# MARTe2 Debug Suite Specifications
|
||||
|
||||
**Version:** 1.2
|
||||
**Version:** 2.0
|
||||
**Status:** Active / Implemented
|
||||
|
||||
---
|
||||
|
||||
## 1. Executive Summary
|
||||
This project implements a "Zero-Code-Change" observability and debugging layer for the MARTe2 real-time framework. The system allows developers to Trace, Force, and Monitor any signal in a running MARTe2 application without modifying existing source code.
|
||||
|
||||
This project implements a "Zero-Code-Change" observability and debugging layer for the
|
||||
MARTe2 real-time framework. Developers can trace, force, and monitor any signal in a
|
||||
running MARTe2 application without modifying existing source code.
|
||||
|
||||
The suite ships two interchangeable transport backends sharing a common abstract interface:
|
||||
|
||||
- **`DebugService`** — TCP command channel + binary UDP telemetry + `TcpLogger` sidecar.
|
||||
Paired with a native Rust/egui GUI.
|
||||
- **`WebDebugService`** — HTTP command endpoint + Server-Sent Events telemetry, with an
|
||||
embedded single-page browser UI. No additional client software required.
|
||||
|
||||
---
|
||||
|
||||
## 2. System Architecture
|
||||
- **The Universal Debug Service (C++ Core):** A singleton MARTe2 Object that patches the registry and manages communication.
|
||||
- **The Broker Injection Layer (C++ Templates):** Templated wrappers that intercept `Execute()` and `Init()` calls for tracing, forcing, and execution control.
|
||||
- **The Remote Analyser (Rust/egui):** A high-performance, multi-threaded GUI for visualization and control.
|
||||
- **Network Stack:**
|
||||
- **Port 8080 (TCP):** Commands and Metadata.
|
||||
- **Port 8081 (UDP):** High-Speed Telemetry for Oscilloscope.
|
||||
- **Port 8082 (TCP):** Independent Real-Time Log Stream via `TcpLogger`.
|
||||
|
||||
- **`DebugServiceI` (Abstract Interface):** Singleton that decouples the broker injection
|
||||
layer from the transport. Defined in `DebugServiceI.h`.
|
||||
- **`DebugService` (TCP/UDP Transport):** TCP text command channel (port 8080), binary UDP
|
||||
telemetry (port 8081), `TcpLogger` log sidecar (port 8082).
|
||||
- **`WebDebugService` (HTTP/SSE Transport):** Single HTTP port (default 8090) serving the
|
||||
embedded web UI, command API, and SSE telemetry stream.
|
||||
- **`DebugBrokerWrapper` (Injection Layer):** C++ template wrappers injected via registry
|
||||
patching. Depend only on `DebugServiceI`; transport-agnostic.
|
||||
- **`TcpLogger` (Log Sidecar):** Optional standalone component forwarding `REPORT_ERROR`
|
||||
events to TCP clients on a dedicated port (used with `DebugService` only).
|
||||
|
||||
---
|
||||
|
||||
## 3. Requirements
|
||||
|
||||
### 3.1 Functional Requirements (FR)
|
||||
- **FR-01 (Discovery):** Discover the full MARTe2 object hierarchy at runtime. The GUI client SHALL request the full application tree upon connection and display it in a hierarchical tree view.
|
||||
- **FR-02 (Telemetry):** Stream high-frequency signal data (verified up to 100Hz+) to a remote client via UDP.
|
||||
|
||||
- **FR-01 (Discovery):** Discover the full MARTe2 object hierarchy at runtime. The client
|
||||
SHALL request the full application tree and display it hierarchically.
|
||||
- **FR-02 (Telemetry):** Stream high-frequency signal data (verified > 100 Hz) to a remote
|
||||
client. `DebugService` uses binary UDP; `WebDebugService` uses SSE.
|
||||
- **FR-03 (Forcing):** Allow manual override of signal values in memory during execution.
|
||||
- **FR-04 (Logs):** Stream global framework logs to a dedicated terminal/client via a standalone `TcpLogger` service.
|
||||
- **FR-05 (Log Filtering):** The client must support filtering logs by type (Debug, Information, Warning, FatalError) and by content using regular expressions.
|
||||
- **FR-06 (Execution Control):** Provide a mechanism to pause and resume the execution of all patched real-time threads (via Brokers), allowing for static inspection of the system state.
|
||||
- **FR-07 (Session Management):** Support runtime re-configuration and "Apply & Reconnect" logic. The GUI provides a "Disconnect" button to close active network streams.
|
||||
- **FR-08 (Decoupled Tracing):** Tracing activates telemetry; data is buffered and shown as a "Last Value" in the sidebar, but not plotted until manually assigned.
|
||||
- **FR-09 (Advanced Plotting):**
|
||||
- Support multiple plot panels with perfectly synchronized time (X) axes.
|
||||
- Drag-and-drop signals from the traced list into specific plots.
|
||||
- Plot modes: Standard (Time Series) and Logic Analyzer (Stacked rows).
|
||||
- Signal transformations: Gain, offset, units, and custom labels.
|
||||
- **FR-10 (Navigation & Scope):**
|
||||
- Context menus for resetting zoom (X, Y, or both).
|
||||
- "Fit to View" functionality that automatically scales both axes.
|
||||
- High-performance oscilloscope mode with configurable time windows (10ms to 10s).
|
||||
- Triggered acquisition (Single/Continuous, rising/falling edges).
|
||||
- **FR-11 (Data Recording):** Record any traced signal to disk in Parquet format with a visual recording indicator in the GUI.
|
||||
- **FR-12 (Configuration Awareness):** The DebugService SHALL store a complete copy of the application's configuration provided at initialization.
|
||||
- **FR-13 (Metadata Enrichment):** Metadata returned by `INFO` and `DISCOVER` SHALL be enriched with additional fields from the stored configuration (e.g., Frequency, PVNames, Units).
|
||||
- **FR-14 (Configuration Serving):** Provide a `CONFIG` command to serve the full stored configuration in JSON format to the client.
|
||||
The override SHALL persist across RT cycles until explicitly released.
|
||||
- **FR-04 (Logs):** Forward all `REPORT_ERROR` events to a connected client in real time.
|
||||
`DebugService` uses `TcpLogger` on a dedicated TCP port. `WebDebugService` embeds logs
|
||||
in the SSE stream.
|
||||
- **FR-05 (Log Filtering):** The client SHOULD support filtering log output by level and
|
||||
by content.
|
||||
- **FR-06 (Execution Control):** Provide pause and resume for all patched RT threads,
|
||||
allowing static inspection of the system state.
|
||||
- **FR-07 (Breakpoints):** Halt execution when a signal crosses a threshold. Supported
|
||||
operators: `>`, `<`, `==`, `>=`, `<=`, `!=`.
|
||||
- **FR-08 (Execution Stepping):** After a pause or breakpoint, allow resuming for exactly
|
||||
N output-broker cycles then pausing again. Optional per-thread filter.
|
||||
- **FR-09 (Decoupled Tracing):** Activating a trace SHALL only stream data; displaying
|
||||
the data (plot, sidebar) is the client's responsibility.
|
||||
- **FR-10 (Signal Monitoring):** Poll any `DataSourceI` signal at a configurable period
|
||||
without requiring that signal to be traced at full RT rate.
|
||||
- **FR-11 (Config Awareness):** The service SHALL accept and store a full copy of the
|
||||
application's CDB (`SetFullConfig`). `INFO` and `DISCOVER` responses SHALL be enriched
|
||||
with additional metadata fields from this CDB.
|
||||
- **FR-12 (Config Serving):** Provide a `CONFIG` command returning the full stored
|
||||
configuration as JSON.
|
||||
- **FR-13 (MARTe2 Messaging):** Allow sending `Message` objects to any ORD object via an
|
||||
`MSG` command.
|
||||
- **FR-14 (Dual Transport):** Both `DebugService` and `WebDebugService` SHALL implement
|
||||
the identical `DebugServiceI` interface and be mutually exclusive singletons. Switching
|
||||
transport SHALL require only a config change (different class name, different port).
|
||||
- **FR-15 (Embedded Web UI):** `WebDebugService` SHALL serve a self-contained single-page
|
||||
application with real-time plotting (Chart.js), signal tree, force/break/monitor dialogs,
|
||||
and an integrated log viewer — without any external server or build tooling.
|
||||
|
||||
### 3.2 Technical Constraints (TC)
|
||||
|
||||
- **TC-01:** No modifications allowed to the MARTe2 core library or component source code.
|
||||
- **TC-02:** Instrumentation must use Runtime Class Registry Patching.
|
||||
- **TC-03:** Real-time threads must remain lock-free; use `FastPollingMutexSem` or atomic operations for synchronization.
|
||||
- **TC-04:** Telemetry must be delivered via UDP to minimize impact on real-time jitter.
|
||||
- **TC-02:** Instrumentation MUST use runtime class registry patching (`ClassRegistryDatabase`).
|
||||
- **TC-03:** RT-path methods (`ProcessSignal`, `IsPaused`) MUST be lock-free or use only
|
||||
`FastPollingMutexSem`; no heap allocation on the RT path.
|
||||
- **TC-04:** `DebugService` telemetry MUST use UDP to minimise jitter impact.
|
||||
- **TC-05:** No STL — use `Vec<T>` and `StreamString` throughout.
|
||||
- **TC-06:** C++98 compatibility for all source files (no `auto`, no range-for, no raw
|
||||
string literals).
|
||||
- **TC-07:** The `DebugServiceI` abstract interface MUST be the only dependency of
|
||||
`DebugBrokerWrapper`. Concrete transport headers MUST NOT be included by broker code.
|
||||
|
||||
## 4. Performance Metrics
|
||||
- **Latency:** Telemetry dispatch overhead < 5 microseconds per signal.
|
||||
- **Throughput:** Support for 100Hz+ sampling rates with zero packet loss on local networks.
|
||||
- **Scalability:** Handle up to 4096 unique signals and 16 simultaneous client connections.
|
||||
- **Code Quality:** Maintain a minimum of **85% code coverage** across all core service and broker logic.
|
||||
---
|
||||
|
||||
## 5. Communication Protocol (Port 8080)
|
||||
- **LS [Path]:** List nodes at the specified path.
|
||||
- **TREE:** Returns a full recursive JSON structure representing the entire application tree.
|
||||
- **INFO [Path]:** Returns detailed metadata for a specific node or signal.
|
||||
- **PAUSE / RESUME:** Global execution control.
|
||||
- **TRACE <Signal> <1/0> [Decimation]:** Enable/disable telemetry for a signal.
|
||||
- **FORCE <Signal> <Value>:** Persistent signal override.
|
||||
- **UNFORCE <Signal>:** Remove override.
|
||||
- **LOG <Level> <Msg>:** Streaming format used on Port 8082.
|
||||
## 4. Performance Requirements
|
||||
|
||||
- **Latency:** `ProcessSignal` overhead < 5 µs per signal when tracing is inactive.
|
||||
- **Throughput:** Support > 100 Hz signal tracing with zero sample loss on local networks
|
||||
(UDP transport).
|
||||
- **Scalability:** Handle up to 4096 unique signals.
|
||||
- **Ring buffer size:** `TraceRingBuffer` initialised to 4 MB in both transports.
|
||||
- **SSE clients:** `WebDebugService` supports up to 8 simultaneous SSE clients.
|
||||
- **TCP rate limit:** Server disconnects clients sending > 100 commands/s.
|
||||
- **VALUE output cap:** `GetSignalValue` returns at most 256 elements per call.
|
||||
|
||||
---
|
||||
|
||||
## 5. Performance Hardening Log
|
||||
|
||||
| Fix | Category | Description |
|
||||
|---|---|---|
|
||||
| **#1** | Naming | `STREAMER_MTU = 1400`, `STREAMER_BUFFER_SIZE = 4096` replace magic numbers |
|
||||
| **#2** | Concurrency | `tracePushMutex` serialises multi-producer `TraceRingBuffer::Push()` |
|
||||
| **#3** | Concurrency | Break indices copied under `activeMutex`; condition evaluated outside lock |
|
||||
| **#4** | Concurrency | `Atomic::Add` for lock-free per-signal decimation counter |
|
||||
| **#5** | Robustness | `TraceRingBuffer::Pop` skips corrupt entry; full discard only when unrecoverable |
|
||||
| **#6** | Security | TCP command rate-limit: > 100 cmd/s → client disconnect |
|
||||
| **#7** | Latency | `Vec::Swap` inside spinlock; deallocation outside — shorter lock hold time |
|
||||
| **#8** | Robustness | 30-second idle timeout on active TCP client |
|
||||
| **#9** | Safety | `VALUE` output capped at 256 elements; `"truncated":true` flag included |
|
||||
| **#10** | Correctness | `inputBuffer` reassembles split TCP commands; bounded at 8 KiB |
|
||||
| **#11** | Correctness | `Initialise()` never calls `MoveToRoot()` on the framework-supplied CDB |
|
||||
|
||||
---
|
||||
|
||||
## 6. Command Protocol Summary
|
||||
|
||||
| Command | Transport | Description |
|
||||
|---|---|---|
|
||||
| `DISCOVER` | Both | Full signal list with metadata |
|
||||
| `TREE` | Both | Live ORD hierarchy as JSON |
|
||||
| `INFO <path>` | Both | Node metadata enriched from CDB |
|
||||
| `LS [path]` | Both | Immediate children of ORD node |
|
||||
| `TRACE <name> <0\|1> [dec]` | Both | Enable/disable signal tracing |
|
||||
| `FORCE <name> <value>` | Both | Persistent signal value injection |
|
||||
| `UNFORCE <name>` | Both | Remove forced value |
|
||||
| `BREAK <name> <op> <thr>` | Both | Set conditional breakpoint |
|
||||
| `BREAK <name> OFF` | Both | Clear breakpoint |
|
||||
| `PAUSE` | Both | Halt all RT threads |
|
||||
| `RESUME` | Both | Release paused RT threads |
|
||||
| `STEP <n> [thread]` | Both | Run N cycles then pause |
|
||||
| `STEP_STATUS` | Both | Query pause/step state |
|
||||
| `VALUE <name>` | Both | Read current signal value |
|
||||
| `MONITOR SIGNAL <name> <ms>` | Both | Register slow-rate polling |
|
||||
| `UNMONITOR SIGNAL <name>` | Both | Stop slow-rate polling |
|
||||
| `CONFIG` | Both | Full CDB as JSON |
|
||||
| `MSG <obj> <fn> [k=v …]` | Both | Send MARTe2 Message |
|
||||
| `SERVICE_INFO` | Both | Transport metadata |
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
#include "BrokerI.h"
|
||||
#include "DataSourceI.h"
|
||||
#include "DebugService.h"
|
||||
#include "DebugServiceI.h"
|
||||
#include "FastPollingMutexSem.h"
|
||||
#include "HighResolutionTimer.h"
|
||||
#include "MemoryMapBroker.h"
|
||||
@@ -90,8 +90,11 @@ public:
|
||||
// Spins while paused, then consumes one step counter tick (if stepping).
|
||||
// Input brokers must NOT call this — they complete normally to avoid blocking
|
||||
// cross-thread EventSem posts (RealTimeThreadSynchBroker would time out).
|
||||
static void OutputPauseAndStep(DebugService *service, const char8 *gamName) {
|
||||
if (service == NULL_PTR(DebugService *)) return;
|
||||
static void OutputPauseAndStep(DebugServiceI *service, const char8 *gamName) {
|
||||
if (service == NULL_PTR(DebugServiceI *)) return;
|
||||
// Fast path: nothing to do when neither paused nor stepping.
|
||||
// Avoids Threads::Name() lookup (and its mutex) on every 1000 Hz cycle.
|
||||
if (!service->IsPaused() && !service->IsStepPending()) return;
|
||||
// Wait if already paused (manual PAUSE or breakpoint from a previous cycle)
|
||||
while (service->IsPaused()) Sleep::MSec(10);
|
||||
// Pass the OS thread name so per-thread step filtering works.
|
||||
@@ -100,13 +103,13 @@ public:
|
||||
while (service->IsPaused()) Sleep::MSec(10);
|
||||
}
|
||||
|
||||
static void Process(DebugService *service,
|
||||
static void Process(DebugServiceI *service,
|
||||
DebugSignalInfo **signalInfoPointers,
|
||||
Vec<uint32> &activeIndices, Vec<uint32> &activeSizes,
|
||||
FastPollingMutexSem &activeMutex,
|
||||
volatile bool *anyBreakFlag,
|
||||
Vec<uint32> *breakIndices) {
|
||||
if (service == NULL_PTR(DebugService *))
|
||||
if (service == NULL_PTR(DebugServiceI *))
|
||||
return;
|
||||
|
||||
// NOTE: No spin here. Spinning for paused state is handled in Execute() of
|
||||
@@ -118,7 +121,7 @@ public:
|
||||
if (n > 0 && signalInfoPointers != NULL_PTR(DebugSignalInfo **)) {
|
||||
// Capture timestamp ONCE per broker cycle for lowest impact
|
||||
uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() *
|
||||
HighResolutionTimer::Period() * 1000000.0);
|
||||
HighResolutionTimer::Period() * 1.0e9);
|
||||
|
||||
for (uint32 i = 0; i < n; i++) {
|
||||
uint32 idx = activeIndices[i];
|
||||
@@ -130,13 +133,33 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
// Conditional break check — zero cost when anyBreakFlag is false
|
||||
// (single volatile read; the RT loop never pays for this when no break is set).
|
||||
if (*anyBreakFlag && !service->IsPaused() &&
|
||||
breakIndices != NULL_PTR(Vec<uint32> *)) {
|
||||
uint32 nb = breakIndices->Size();
|
||||
// FIX #3: copy break indices under lock into a local stack array, then
|
||||
// release activeMutex BEFORE evaluating. EvaluateBreak reads signal
|
||||
// memory which can stall (cache miss); holding activeMutex during that
|
||||
// stall would block UpdateBrokersBreakStatus() in the Server thread and
|
||||
// cause unnecessary priority inversion on the RT path.
|
||||
bool shouldCheckBreak = (*anyBreakFlag && !service->IsPaused() &&
|
||||
breakIndices != NULL_PTR(Vec<uint32> *) &&
|
||||
signalInfoPointers != NULL_PTR(DebugSignalInfo **));
|
||||
static const uint32 MAX_BREAK_INDICES = 64u;
|
||||
uint32 localBreakIdx[MAX_BREAK_INDICES];
|
||||
uint32 nb = 0u;
|
||||
if (shouldCheckBreak) {
|
||||
nb = breakIndices->Size();
|
||||
if (nb > MAX_BREAK_INDICES) nb = MAX_BREAK_INDICES;
|
||||
for (uint32 i = 0; i < nb; i++) {
|
||||
uint32 idx = (*breakIndices)[i];
|
||||
localBreakIdx[i] = (*breakIndices)[i];
|
||||
}
|
||||
}
|
||||
|
||||
activeMutex.FastUnLock();
|
||||
|
||||
// Evaluate break conditions outside the lock — safe because
|
||||
// EvaluateBreak only reads signalInfoPointers[idx]->memoryAddress,
|
||||
// which is RT data-bus memory and is never freed during the RT cycle.
|
||||
if (shouldCheckBreak && nb > 0u) {
|
||||
for (uint32 i = 0; i < nb; i++) {
|
||||
uint32 idx = localBreakIdx[i];
|
||||
DebugSignalInfo *s = signalInfoPointers[idx];
|
||||
if (s != NULL_PTR(DebugSignalInfo *) && s->breakOp != BREAK_OFF &&
|
||||
EvaluateBreak(s)) {
|
||||
@@ -145,14 +168,12 @@ public:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
activeMutex.FastUnLock();
|
||||
}
|
||||
|
||||
// Pass numCopies explicitly so we can mock it
|
||||
static void
|
||||
InitSignals(BrokerI *broker, DataSourceI &dataSourceIn,
|
||||
DebugService *&service, DebugSignalInfo **&signalInfoPointers,
|
||||
DebugServiceI *&service, DebugSignalInfo **&signalInfoPointers,
|
||||
uint32 numCopies, MemoryMapBrokerCopyTableEntry *copyTable,
|
||||
const char8 *functionName, SignalDirection direction,
|
||||
volatile bool *anyActiveFlag, Vec<uint32> *activeIndices,
|
||||
@@ -164,16 +185,14 @@ public:
|
||||
signalInfoPointers[i] = NULL_PTR(DebugSignalInfo *);
|
||||
}
|
||||
|
||||
ReferenceContainer *root = ObjectRegistryDatabase::Instance();
|
||||
Reference serviceRef = root->Find("DebugService");
|
||||
if (serviceRef.IsValid()) {
|
||||
service = dynamic_cast<DebugService *>(serviceRef.operator->());
|
||||
}
|
||||
// Use the singleton registered by DebugService::Initialise() — no ORD
|
||||
// search on the Init path, and no dependency on a concrete type.
|
||||
service = DebugServiceI::GetInstance();
|
||||
|
||||
if (service && (copyTable != NULL_PTR(MemoryMapBrokerCopyTableEntry *))) {
|
||||
|
||||
StreamString dsPath;
|
||||
DebugService::GetFullObjectName(dataSourceIn, dsPath);
|
||||
DebugServiceI::GetFullObjectName(dataSourceIn, dsPath);
|
||||
fprintf(stderr, ">> %s broker for %s [%d]\n",
|
||||
direction == InputSignals ? "Input" : "Output", dsPath.Buffer(),
|
||||
numCopies);
|
||||
@@ -225,7 +244,7 @@ public:
|
||||
|
||||
if (gamRef.IsValid()) {
|
||||
StreamString absGamPath;
|
||||
DebugService::GetFullObjectName(*(gamRef.operator->()), absGamPath);
|
||||
DebugServiceI::GetFullObjectName(*(gamRef.operator->()), absGamPath);
|
||||
// Register short path (In/Out) for GUI compatibility
|
||||
gamFullName.Printf("%s.%s.%s", absGamPath.Buffer(), dirStrShort,
|
||||
signalName.Buffer());
|
||||
@@ -261,7 +280,7 @@ public:
|
||||
template <typename BaseClass> class DebugBrokerWrapper : public BaseClass {
|
||||
public:
|
||||
DebugBrokerWrapper() : BaseClass() {
|
||||
service = NULL_PTR(DebugService *);
|
||||
service = NULL_PTR(DebugServiceI *);
|
||||
signalInfoPointers = NULL_PTR(DebugSignalInfo **);
|
||||
numSignals = 0;
|
||||
anyActive = false;
|
||||
@@ -326,7 +345,7 @@ public:
|
||||
return ret;
|
||||
}
|
||||
|
||||
DebugService *service;
|
||||
DebugServiceI *service;
|
||||
DebugSignalInfo **signalInfoPointers;
|
||||
uint32 numSignals;
|
||||
volatile bool anyActive;
|
||||
@@ -343,7 +362,7 @@ template <typename BaseClass>
|
||||
class DebugBrokerWrapperNoOptim : public BaseClass {
|
||||
public:
|
||||
DebugBrokerWrapperNoOptim() : BaseClass() {
|
||||
service = NULL_PTR(DebugService *);
|
||||
service = NULL_PTR(DebugServiceI *);
|
||||
signalInfoPointers = NULL_PTR(DebugSignalInfo **);
|
||||
numSignals = 0;
|
||||
anyActive = false;
|
||||
@@ -386,7 +405,7 @@ public:
|
||||
return ret;
|
||||
}
|
||||
|
||||
DebugService *service;
|
||||
DebugServiceI *service;
|
||||
DebugSignalInfo **signalInfoPointers;
|
||||
uint32 numSignals;
|
||||
volatile bool anyActive;
|
||||
@@ -402,7 +421,7 @@ public:
|
||||
class DebugMemoryMapAsyncOutputBroker : public MemoryMapAsyncOutputBroker {
|
||||
public:
|
||||
DebugMemoryMapAsyncOutputBroker() : MemoryMapAsyncOutputBroker() {
|
||||
service = NULL_PTR(DebugService *);
|
||||
service = NULL_PTR(DebugServiceI *);
|
||||
signalInfoPointers = NULL_PTR(DebugSignalInfo **);
|
||||
numSignals = 0;
|
||||
anyActive = false;
|
||||
@@ -446,7 +465,7 @@ public:
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
DebugService *service;
|
||||
DebugServiceI *service;
|
||||
DebugSignalInfo **signalInfoPointers;
|
||||
uint32 numSignals;
|
||||
volatile bool anyActive;
|
||||
@@ -463,7 +482,7 @@ class DebugMemoryMapAsyncTriggerOutputBroker
|
||||
public:
|
||||
DebugMemoryMapAsyncTriggerOutputBroker()
|
||||
: MemoryMapAsyncTriggerOutputBroker() {
|
||||
service = NULL_PTR(DebugService *);
|
||||
service = NULL_PTR(DebugServiceI *);
|
||||
signalInfoPointers = NULL_PTR(DebugSignalInfo **);
|
||||
numSignals = 0;
|
||||
anyActive = false;
|
||||
@@ -506,7 +525,7 @@ public:
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
DebugService *service;
|
||||
DebugServiceI *service;
|
||||
DebugSignalInfo **signalInfoPointers;
|
||||
uint32 numSignals;
|
||||
volatile bool anyActive;
|
||||
|
||||
@@ -114,7 +114,19 @@ public:
|
||||
ReadFromBuffer(&tempRead, &tempSize, 4);
|
||||
|
||||
if (tempSize > maxSize) {
|
||||
readIndex = write;
|
||||
// FIX #5: Skip only the current entry rather than discarding the
|
||||
// entire ring buffer. tempRead is already past the 16-byte header;
|
||||
// advancing by tempSize lands at the start of the next entry.
|
||||
//
|
||||
// Safety fallback: if tempSize >= bufferSize the stored size field
|
||||
// is corrupt (it can never be that large). In that case we cannot
|
||||
// locate the next entry safely, so fall back to discarding everything
|
||||
// to avoid reading garbage as sample headers on future Pop() calls.
|
||||
if (tempSize >= bufferSize) {
|
||||
readIndex = write; // corrupt ring — discard all
|
||||
} else {
|
||||
readIndex = (tempRead + tempSize) % bufferSize;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
#include "Atomic.h"
|
||||
#include "BasicTCPSocket.h"
|
||||
#include "ClassRegistryItem.h"
|
||||
#include "ConfigurationDatabase.h"
|
||||
@@ -21,7 +22,8 @@
|
||||
|
||||
namespace MARTe {
|
||||
|
||||
DebugService *DebugService::instance = (DebugService *)0;
|
||||
// DebugServiceI static members — defined here so no extra .cpp is needed.
|
||||
DebugServiceI *DebugServiceI::instance = NULL_PTR(DebugServiceI *);
|
||||
|
||||
static void EscapeJson(const char8 *src, StreamString &dst) {
|
||||
if (src == NULL_PTR(const char8 *))
|
||||
@@ -85,6 +87,15 @@ static bool FindPathInContainer(ReferenceContainer *container,
|
||||
|
||||
CLASS_REGISTER(DebugService, "1.0")
|
||||
|
||||
// Out-of-class definitions required by C++98 when the constants are odr-used
|
||||
// (i.e. their address is taken or they appear in a context that needs linkage).
|
||||
const uint32 DebugService::STREAMER_MTU;
|
||||
const uint32 DebugService::STREAMER_BUFFER_SIZE;
|
||||
const uint32 DebugService::CMD_RATE_LIMIT;
|
||||
const uint32 DebugService::CLIENT_IDLE_TIMEOUT_MS;
|
||||
const uint32 DebugService::GET_VALUE_MAX_ELEMENTS;
|
||||
const uint32 DebugService::INPUT_BUFFER_MAX;
|
||||
|
||||
DebugService::DebugService()
|
||||
: ReferenceContainer(), EmbeddedServiceMethodBinderI(),
|
||||
binderServer(this, ServiceBinder::ServerType),
|
||||
@@ -102,11 +113,15 @@ DebugService::DebugService()
|
||||
activeClient = NULL_PTR(BasicTCPSocket *);
|
||||
streamerPacketOffset = 0u;
|
||||
streamerSequenceNumber = 0u;
|
||||
cmdCountInWindow = 0u;
|
||||
cmdWindowStartMs = 0u;
|
||||
lastDataTimeMs = 0u;
|
||||
inputBuffer = ""; // FIX #10: initialise carry-over buffer
|
||||
}
|
||||
|
||||
DebugService::~DebugService() {
|
||||
if (instance == this) {
|
||||
instance = NULL_PTR(DebugService *);
|
||||
if (DebugServiceI::GetInstance() == this) {
|
||||
DebugServiceI::SetInstance(NULL_PTR(DebugServiceI *));
|
||||
}
|
||||
threadService.Stop();
|
||||
streamerService.Stop();
|
||||
@@ -135,7 +150,7 @@ bool DebugService::Initialise(StructuredDataI &data) {
|
||||
|
||||
if (controlPort > 0) {
|
||||
isServer = true;
|
||||
instance = this;
|
||||
DebugServiceI::SetInstance(this);
|
||||
}
|
||||
|
||||
port = 8081;
|
||||
@@ -463,12 +478,28 @@ void DebugService::ProcessSignal(DebugSignalInfo *signalInfo, uint32 size,
|
||||
memcpy(signalInfo->memoryAddress, signalInfo->forcedValue, size);
|
||||
}
|
||||
if (signalInfo->isTracing) {
|
||||
if (signalInfo->decimationCounter == 0) {
|
||||
// FIX #4: decimationCounter read-modify-write is a data race when multiple
|
||||
// RT threads call ProcessSignal() concurrently for signals with the same
|
||||
// DebugSignalInfo (e.g. an output signal read by two GAMs).
|
||||
//
|
||||
// Pattern: atomically increment, then claim the "push token" by exchanging
|
||||
// back to zero only when the counter reaches the decimation factor.
|
||||
// Only the thread that observes old >= decimationFactor actually pushes;
|
||||
// all others just increment and return. No separate lock is needed for
|
||||
// the counter itself.
|
||||
//
|
||||
// tracePushMutex still serialises the Push() call (FIX #2) because
|
||||
// TraceRingBuffer is SPSC and multiple RT threads can be pushing concurrently.
|
||||
Atomic::Add((volatile int32 *)&signalInfo->decimationCounter, 1);
|
||||
if ((uint32)signalInfo->decimationCounter >= signalInfo->decimationFactor) {
|
||||
int32 old = Atomic::Exchange((volatile int32 *)&signalInfo->decimationCounter, 0);
|
||||
if ((uint32)old >= signalInfo->decimationFactor) {
|
||||
tracePushMutex.FastLock();
|
||||
traceBuffer.Push(signalInfo->internalID, timestamp,
|
||||
(uint8 *)signalInfo->memoryAddress, size);
|
||||
tracePushMutex.FastUnLock();
|
||||
}
|
||||
}
|
||||
signalInfo->decimationCounter =
|
||||
(signalInfo->decimationCounter + 1) % signalInfo->decimationFactor;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -501,6 +532,11 @@ void DebugService::RegisterBroker(DebugSignalInfo **signalPointers,
|
||||
|
||||
void DebugService::UpdateBrokersActiveStatus() {
|
||||
for (uint32 i = 0; i < brokers.Size(); i++) {
|
||||
// FIX #3: signalPointers may be NULL when numSignals > 0 if the broker was
|
||||
// registered with a null array (e.g. from unit tests or misconfigured brokers).
|
||||
// Dereferencing NULL would be UB; skip the broker entirely.
|
||||
if (brokers[i].signalPointers == NULL_PTR(DebugSignalInfo **)) continue;
|
||||
|
||||
uint32 count = 0;
|
||||
for (uint32 j = 0; j < brokers[i].numSignals; j++) {
|
||||
DebugSignalInfo *s = brokers[i].signalPointers[j];
|
||||
@@ -524,20 +560,28 @@ void DebugService::UpdateBrokersActiveStatus() {
|
||||
if (brokers[i].activeMutex)
|
||||
brokers[i].activeMutex->FastLock();
|
||||
|
||||
// FIX #2: Use O(1) Swap instead of operator= (heap alloc + copy) inside
|
||||
// the critical section. The old arrays are carried out in tempInd/tempSizes
|
||||
// and freed after the lock is released.
|
||||
if (brokers[i].activeIndices)
|
||||
*(brokers[i].activeIndices) = tempInd;
|
||||
brokers[i].activeIndices->Swap(tempInd);
|
||||
if (brokers[i].activeSizes)
|
||||
*(brokers[i].activeSizes) = tempSizes;
|
||||
brokers[i].activeSizes->Swap(tempSizes);
|
||||
if (brokers[i].anyActiveFlag)
|
||||
*(brokers[i].anyActiveFlag) = (count > 0);
|
||||
|
||||
if (brokers[i].activeMutex)
|
||||
brokers[i].activeMutex->FastUnLock();
|
||||
// tempInd and tempSizes now hold the old arrays and are freed here,
|
||||
// outside the lock.
|
||||
}
|
||||
}
|
||||
|
||||
void DebugService::UpdateBrokersBreakStatus() {
|
||||
for (uint32 i = 0; i < brokers.Size(); i++) {
|
||||
// FIX #3: same null guard as UpdateBrokersActiveStatus.
|
||||
if (brokers[i].signalPointers == NULL_PTR(DebugSignalInfo **)) continue;
|
||||
|
||||
Vec<uint32> tempBreak;
|
||||
uint32 count = 0;
|
||||
for (uint32 j = 0; j < brokers[i].numSignals; j++) {
|
||||
@@ -549,12 +593,14 @@ void DebugService::UpdateBrokersBreakStatus() {
|
||||
}
|
||||
if (brokers[i].activeMutex)
|
||||
brokers[i].activeMutex->FastLock();
|
||||
// FIX #2: O(1) Swap — old array freed after the lock is released.
|
||||
if (brokers[i].breakIndices)
|
||||
*(brokers[i].breakIndices) = tempBreak;
|
||||
brokers[i].breakIndices->Swap(tempBreak);
|
||||
if (brokers[i].anyBreakFlag)
|
||||
*(brokers[i].anyBreakFlag) = (count > 0);
|
||||
if (brokers[i].activeMutex)
|
||||
brokers[i].activeMutex->FastUnLock();
|
||||
// tempBreak freed here, outside the lock.
|
||||
}
|
||||
}
|
||||
|
||||
@@ -582,50 +628,143 @@ ErrorManagement::ErrorType DebugService::Server(ExecutionInfo &info) {
|
||||
// The MARTe2 framework calls Execute() in a loop; each call should do
|
||||
// one unit of work and return so the framework can check for Stop().
|
||||
// This replaces the old internal infinite-while pattern.
|
||||
//
|
||||
// FIX #2: activeClient is guarded by clientMutex.
|
||||
// Rule: lock clientMutex only when ASSIGNING the pointer (including to NULL).
|
||||
// Do NOT hold it across blocking I/O (Read/Write) — that would stall any future
|
||||
// thread trying to grab the lock to check whether there is a live client.
|
||||
// The command handler (HandleCommand) receives the pointer by value so it is
|
||||
// safe to call without holding the lock.
|
||||
// Helper: current time in milliseconds (used for rate limiting and idle timeout)
|
||||
uint64 nowMs = (uint64)((float64)HighResolutionTimer::Counter() *
|
||||
HighResolutionTimer::Period() * 1000.0);
|
||||
|
||||
if (activeClient == NULL_PTR(BasicTCPSocket *)) {
|
||||
// Wait briefly for a new connection; return so the framework loop can
|
||||
// check if Stop() was requested between calls.
|
||||
BasicTCPSocket *newClient = tcpServer.WaitConnection(TimeoutType(100));
|
||||
if (newClient != NULL_PTR(BasicTCPSocket *)) {
|
||||
activeClient = newClient;
|
||||
clientMutex.FastLock();
|
||||
activeClient = newClient; // publish pointer — visible to other threads after unlock
|
||||
clientMutex.FastUnLock();
|
||||
// FIX #6/#8: reset per-connection state when a new client connects
|
||||
cmdCountInWindow = 0u;
|
||||
cmdWindowStartMs = nowMs;
|
||||
lastDataTimeMs = nowMs;
|
||||
}
|
||||
} else {
|
||||
// Check if client is still connected
|
||||
if (!activeClient->IsConnected()) {
|
||||
// FIX #8: idle-timeout check — runs every Execute() invocation even when
|
||||
// no data arrives, so a client that half-sends a command and goes silent
|
||||
// cannot hold the slot open indefinitely.
|
||||
if (nowMs - lastDataTimeMs > CLIENT_IDLE_TIMEOUT_MS) {
|
||||
REPORT_ERROR_STATIC(ErrorManagement::Warning,
|
||||
"Server: TCP client idle for >%u ms — closing connection.", CLIENT_IDLE_TIMEOUT_MS);
|
||||
inputBuffer = ""; // FIX #10: discard carry-over on disconnect
|
||||
clientMutex.FastLock();
|
||||
activeClient->Close();
|
||||
delete activeClient;
|
||||
activeClient = NULL_PTR(BasicTCPSocket *);
|
||||
clientMutex.FastUnLock();
|
||||
cmdCountInWindow = 0u;
|
||||
} else if (!activeClient->IsConnected()) {
|
||||
// Check if client is still connected
|
||||
inputBuffer = ""; // FIX #10
|
||||
clientMutex.FastLock();
|
||||
activeClient->Close();
|
||||
delete activeClient;
|
||||
activeClient = NULL_PTR(BasicTCPSocket *);
|
||||
clientMutex.FastUnLock();
|
||||
} else {
|
||||
char buffer[1024];
|
||||
uint32 size = 1024;
|
||||
if (activeClient->Read(buffer, size)) {
|
||||
if (size > 0) {
|
||||
// Process each line separately
|
||||
char *ptr = buffer;
|
||||
char *end = buffer + size;
|
||||
while (ptr < end) {
|
||||
char *newline = (char *)memchr(ptr, '\n', end - ptr);
|
||||
if (!newline) {
|
||||
lastDataTimeMs = nowMs; // FIX #8: refresh idle timestamp
|
||||
|
||||
// FIX #6: slide rate-limit window
|
||||
if (nowMs - cmdWindowStartMs >= 1000u) {
|
||||
cmdWindowStartMs = nowMs;
|
||||
cmdCountInWindow = 0u;
|
||||
}
|
||||
|
||||
// FIX #10: guard against a client that never sends a newline,
|
||||
// which would grow inputBuffer without bound.
|
||||
if (inputBuffer.Size() + (uint32)size > INPUT_BUFFER_MAX) {
|
||||
REPORT_ERROR_STATIC(ErrorManagement::Warning,
|
||||
"Server: input buffer overflow (>%u bytes without newline) "
|
||||
"— disconnecting.", INPUT_BUFFER_MAX);
|
||||
inputBuffer = "";
|
||||
clientMutex.FastLock();
|
||||
activeClient->Close();
|
||||
delete activeClient;
|
||||
activeClient = NULL_PTR(BasicTCPSocket *);
|
||||
clientMutex.FastUnLock();
|
||||
cmdCountInWindow = 0u;
|
||||
} else {
|
||||
// FIX #10: accumulate data; parse only complete (newline-terminated)
|
||||
// commands so that commands split across TCP segments are assembled
|
||||
// correctly before dispatch.
|
||||
(void)inputBuffer.Seek(inputBuffer.Size());
|
||||
uint32 writeSize = (uint32)size;
|
||||
inputBuffer.Write(buffer, writeSize);
|
||||
|
||||
const char8 *raw = inputBuffer.Buffer();
|
||||
uint32 total = (uint32)inputBuffer.Size();
|
||||
uint32 lineStart = 0u;
|
||||
bool rateLimitExceeded = false;
|
||||
|
||||
for (uint32 pos = 0u; pos < total && !rateLimitExceeded; pos++) {
|
||||
if (raw[pos] != '\n') continue;
|
||||
|
||||
uint32 len = pos - lineStart;
|
||||
// Trim trailing CR
|
||||
if (len > 0u && raw[lineStart + len - 1u] == '\r') len--;
|
||||
|
||||
if (len > 0u) {
|
||||
cmdCountInWindow++;
|
||||
if (cmdCountInWindow > CMD_RATE_LIMIT) {
|
||||
REPORT_ERROR_STATIC(ErrorManagement::Warning,
|
||||
"Server: client exceeded rate limit (%u cmd/s) — disconnecting.",
|
||||
CMD_RATE_LIMIT);
|
||||
rateLimitExceeded = true;
|
||||
break;
|
||||
}
|
||||
*newline = '\0';
|
||||
// Skip carriage return if present
|
||||
if (newline > ptr && *(newline - 1) == '\r')
|
||||
*(newline - 1) = '\0';
|
||||
StreamString command;
|
||||
uint32 len = (uint32)(newline - ptr);
|
||||
command.Write(ptr, len);
|
||||
if (command.Size() > 0) {
|
||||
uint32 cmdLen = len;
|
||||
command.Write(raw + lineStart, cmdLen);
|
||||
HandleCommand(command, activeClient);
|
||||
}
|
||||
ptr = newline + 1;
|
||||
lineStart = pos + 1u;
|
||||
}
|
||||
|
||||
if (rateLimitExceeded) {
|
||||
inputBuffer = "";
|
||||
clientMutex.FastLock();
|
||||
activeClient->Close();
|
||||
delete activeClient;
|
||||
activeClient = NULL_PTR(BasicTCPSocket *);
|
||||
clientMutex.FastUnLock();
|
||||
cmdCountInWindow = 0u;
|
||||
} else {
|
||||
// Save the incomplete line (bytes after the last '\n') for the
|
||||
// next Read() — they form the start of the next command.
|
||||
StreamString newInputBuffer;
|
||||
if (lineStart < total) {
|
||||
uint32 remLen = total - lineStart;
|
||||
newInputBuffer.Write(raw + lineStart, remLen);
|
||||
}
|
||||
inputBuffer = newInputBuffer;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Read failed (client disconnected or error), clean up
|
||||
inputBuffer = ""; // FIX #10
|
||||
clientMutex.FastLock();
|
||||
activeClient->Close();
|
||||
delete activeClient;
|
||||
activeClient = NULL_PTR(BasicTCPSocket *);
|
||||
clientMutex.FastUnLock();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -654,19 +793,63 @@ ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo &info) {
|
||||
HighResolutionTimer::Period() * 1000000.0);
|
||||
void *address = NULL_PTR(void *);
|
||||
if (monitoredSignals[i].dataSource->GetSignalMemoryBuffer(monitoredSignals[i].signalIdx, 0, address)) {
|
||||
// FIX #11: ProcessSignal() (called from RT broker threads) serialises
|
||||
// its traceBuffer.Push() under tracePushMutex. The Streamer's monitored-
|
||||
// signal path previously skipped that lock, creating a multi-producer race
|
||||
// between the RT threads and the Streamer thread.
|
||||
//
|
||||
// Lock order: mutex (always held here) → tracePushMutex.
|
||||
// RT broker threads only ever acquire tracePushMutex (never mutex), so
|
||||
// this ordering introduces no deadlock risk.
|
||||
tracePushMutex.FastLock();
|
||||
traceBuffer.Push(monitoredSignals[i].internalID, ts, (uint8 *)address, monitoredSignals[i].size);
|
||||
tracePushMutex.FastUnLock();
|
||||
}
|
||||
}
|
||||
}
|
||||
mutex.FastUnLock();
|
||||
|
||||
// Drain ring buffer into UDP packet(s)
|
||||
// Drain ring buffer into UDP packet(s).
|
||||
//
|
||||
// FIX #1: Two-level bounds checking to prevent buffer overflow.
|
||||
//
|
||||
// Level 1 — per-sample maximum size:
|
||||
// sampleData is SAMPLE_BUF_SIZE bytes. Pop() enforces this via maxSize so
|
||||
// the local buffer can never be overrun by Pop() itself.
|
||||
//
|
||||
// Level 2 — assembly-buffer hard limit:
|
||||
// After a flush, streamerPacketOffset resets to sizeof(TraceHeader). The
|
||||
// next sample occupies (sizeof(TraceHeader) + 16 + size) bytes. With
|
||||
// SAMPLE_BUF_SIZE = 1024 that is at most ~1060 bytes — well within
|
||||
// STREAMER_BUFFER_SIZE = 4096. The explicit guard below catches the case
|
||||
// where SAMPLE_BUF_SIZE or STREAMER_MTU are later changed carelessly so
|
||||
// that a single sample could still overflow the buffer.
|
||||
static const uint32 SAMPLE_BUF_SIZE = 1024u;
|
||||
// Compile-time sanity: one full header + per-sample header + max sample must fit
|
||||
// inside the assembly buffer. If this fires, raise STREAMER_BUFFER_SIZE or
|
||||
// lower SAMPLE_BUF_SIZE.
|
||||
// (C++98-compatible static assert via sizeof a negative-size array)
|
||||
typedef char StaticAssert_StreamerBufferTooSmall[
|
||||
(sizeof(TraceHeader) + 16u + SAMPLE_BUF_SIZE <= STREAMER_BUFFER_SIZE) ? 1 : -1];
|
||||
(void)sizeof(StaticAssert_StreamerBufferTooSmall); // suppress unused-typedef warning
|
||||
|
||||
uint32 id, size;
|
||||
uint64 ts;
|
||||
uint8 sampleData[1024];
|
||||
uint8 sampleData[SAMPLE_BUF_SIZE];
|
||||
bool hasData = false;
|
||||
while (traceBuffer.Pop(id, ts, sampleData, size, 1024)) {
|
||||
while (traceBuffer.Pop(id, ts, sampleData, size, SAMPLE_BUF_SIZE)) {
|
||||
hasData = true;
|
||||
|
||||
// Level 2 guard — should never fire given the static assert above, but
|
||||
// defends against future changes that widen SAMPLE_BUF_SIZE or shrink
|
||||
// STREAMER_BUFFER_SIZE without updating the other.
|
||||
if (size > SAMPLE_BUF_SIZE || streamerPacketOffset + 16u + size > STREAMER_BUFFER_SIZE) {
|
||||
REPORT_ERROR_STATIC(ErrorManagement::Warning,
|
||||
"Streamer: sample size %u would overflow assembly buffer (%u bytes used of %u) "
|
||||
"— sample dropped.", size, streamerPacketOffset, STREAMER_BUFFER_SIZE);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (streamerPacketOffset == 0u) {
|
||||
TraceHeader header;
|
||||
header.magic = 0xDA7A57AD;
|
||||
@@ -676,7 +859,8 @@ ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo &info) {
|
||||
memcpy(streamerPacketBuffer, &header, sizeof(TraceHeader));
|
||||
streamerPacketOffset = sizeof(TraceHeader);
|
||||
}
|
||||
if (streamerPacketOffset + 16u + size > 1400u) {
|
||||
// Flush the current packet when adding this sample would exceed the MTU.
|
||||
if (streamerPacketOffset + 16u + size > STREAMER_MTU) {
|
||||
uint32 toWrite = streamerPacketOffset;
|
||||
(void)udpSocket.Write((char8 *)streamerPacketBuffer, toWrite);
|
||||
TraceHeader header;
|
||||
@@ -705,7 +889,7 @@ ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo &info) {
|
||||
return ErrorManagement::NoError;
|
||||
}
|
||||
|
||||
bool DebugService::GetFullObjectName(const Object &obj,
|
||||
bool DebugServiceI::GetFullObjectName(const Object &obj,
|
||||
StreamString &fullPath) {
|
||||
fullPath = "";
|
||||
if (FindPathInContainer(ObjectRegistryDatabase::Instance(), &obj, fullPath)) {
|
||||
@@ -893,15 +1077,42 @@ void DebugService::HandleCommand(StreamString cmd, BasicTCPSocket *client) {
|
||||
const char8 *eq = StringHelper::SearchChar(line.Buffer(), '=');
|
||||
if (eq != NULL_PTR(const char8 *)) {
|
||||
uint32 eqPos = (uint32)(eq - line.Buffer());
|
||||
(void)line.Seek(0u);
|
||||
|
||||
char8 keyBuf[256] = {'\0'};
|
||||
// FIX #7: Enforce buffer bounds before reading key/value.
|
||||
// A key longer than keyBuf would be silently truncated by
|
||||
// Read(), producing a mismatched key (e.g. "LongKe" instead
|
||||
// of "LongKey") that causes CDB.Write() to inject a garbled
|
||||
// parameter. Skip the entire line if the key overflows —
|
||||
// the CDB write would be nonsensical anyway.
|
||||
// Values are safely capped: the worst case is a truncated
|
||||
// value, which the target GAM can detect and reject.
|
||||
static const uint32 KEY_BUF_SIZE = 256u;
|
||||
static const uint32 VAL_BUF_SIZE = 1024u;
|
||||
if (eqPos >= KEY_BUF_SIZE) {
|
||||
REPORT_ERROR_STATIC(ErrorManagement::Warning,
|
||||
"MSG: key length %u exceeds buffer (%u) — line skipped.",
|
||||
eqPos, KEY_BUF_SIZE);
|
||||
line = "";
|
||||
continue;
|
||||
}
|
||||
|
||||
(void)line.Seek(0u);
|
||||
char8 keyBuf[KEY_BUF_SIZE];
|
||||
MemoryOperationsHelper::Set(keyBuf, '\0', KEY_BUF_SIZE);
|
||||
uint32 keyReadSize = eqPos;
|
||||
(void)line.Read(keyBuf, keyReadSize);
|
||||
|
||||
(void)line.Seek(eqPos + 1u);
|
||||
uint32 valLen = (uint32)(line.Size() - eqPos - 1u);
|
||||
char8 valBuf[1024] = {'\0'};
|
||||
// Truncate silently to VAL_BUF_SIZE - 1 (leave room for '\0')
|
||||
if (valLen >= VAL_BUF_SIZE) {
|
||||
REPORT_ERROR_STATIC(ErrorManagement::Warning,
|
||||
"MSG: value length %u truncated to %u for key '%s'.",
|
||||
valLen, VAL_BUF_SIZE - 1u, keyBuf);
|
||||
valLen = VAL_BUF_SIZE - 1u;
|
||||
}
|
||||
char8 valBuf[VAL_BUF_SIZE];
|
||||
MemoryOperationsHelper::Set(valBuf, '\0', VAL_BUF_SIZE);
|
||||
(void)line.Read(valBuf, valLen);
|
||||
|
||||
// Trim trailing whitespace from value
|
||||
@@ -1418,6 +1629,25 @@ uint32 DebugService::ForceSignal(const char8 *name, const char8 *valueStr) {
|
||||
SuffixMatch(aliases[i].name.Buffer(), name)) {
|
||||
|
||||
DebugSignalInfo *s = signals[aliases[i].signalIndex];
|
||||
|
||||
// FIX #4: Guard against writing past the end of forcedValue[1024].
|
||||
// TypeConvert writes (byteSize * numberOfElements) bytes into forcedValue.
|
||||
// For large arrays (e.g. 512 float64s = 4096 bytes) this would silently
|
||||
// overflow the 1024-byte buffer and corrupt adjacent struct members.
|
||||
//
|
||||
// TypeDescriptor::numberOfBits is the element size in bits; integer divide
|
||||
// by 8 gives bytes. For structured/opaque types numberOfBits may be 0 —
|
||||
// those are also skipped because we cannot determine the layout safely.
|
||||
uint32 elemBytes = (uint32)(s->type.numberOfBits) / 8u;
|
||||
uint32 totalBytes = elemBytes * s->numberOfElements;
|
||||
if (elemBytes == 0u || totalBytes > (uint32)sizeof(s->forcedValue)) {
|
||||
REPORT_ERROR_STATIC(ErrorManagement::Warning,
|
||||
"ForceSignal: signal '%s' requires %u bytes but forcedValue buffer is "
|
||||
"only %u bytes — force request ignored.",
|
||||
s->name.Buffer(), totalBytes, (uint32)sizeof(s->forcedValue));
|
||||
continue;
|
||||
}
|
||||
|
||||
s->isForcing = true;
|
||||
AnyType dest(s->type, 0u, s->forcedValue);
|
||||
AnyType source(CharString, 0u, valueStr);
|
||||
@@ -1536,7 +1766,18 @@ void DebugService::GetSignalValue(const char8 *name, BasicTCPSocket *client) {
|
||||
TypeDescriptor td = sig->type;
|
||||
uint32 nElem = sig->numberOfElements;
|
||||
uint32 byteSize = (td.numberOfBits > 0u) ? (td.numberOfBits / 8u) : 1u;
|
||||
|
||||
// FIX #9: cap element count before computing byte totals.
|
||||
// Without a cap, a 1M-element uint8 signal would produce a multi-MB
|
||||
// comma-separated response, exhausting heap and blocking the Server thread.
|
||||
// GET_VALUE_MAX_ELEMENTS = 256 gives a ~4 KB worst-case JSON string.
|
||||
bool truncated = (nElem > GET_VALUE_MAX_ELEMENTS);
|
||||
if (truncated) {
|
||||
nElem = GET_VALUE_MAX_ELEMENTS;
|
||||
}
|
||||
uint32 totalBytes = byteSize * nElem;
|
||||
// Secondary cap: even after the element limit, ensure we never read more
|
||||
// than 1024 bytes from the RT memory region.
|
||||
if (totalBytes > 1024u) { totalBytes = 1024u; nElem = totalBytes / byteSize; }
|
||||
// Copy bytes while holding the mutex to avoid data races with the RT thread
|
||||
uint8 localBuf[1024];
|
||||
@@ -1582,7 +1823,10 @@ void DebugService::GetSignalValue(const char8 *name, BasicTCPSocket *client) {
|
||||
vp++;
|
||||
}
|
||||
resp += "\", \"Elements\": ";
|
||||
resp.Printf("%u}\nOK VALUE\n", nElem);
|
||||
// Include the capped element count and a Truncated flag so the client can
|
||||
// distinguish "this is the full signal" from "there are more elements".
|
||||
resp.Printf("%u, \"Truncated\": %s}\nOK VALUE\n",
|
||||
nElem, truncated ? "true" : "false");
|
||||
uint32 s = resp.Size();
|
||||
(void)client->Write(resp.Buffer(), s);
|
||||
}
|
||||
|
||||
@@ -4,45 +4,30 @@
|
||||
#include "BasicTCPSocket.h"
|
||||
#include "BasicUDPSocket.h"
|
||||
#include "ConfigurationDatabase.h"
|
||||
#include "DebugCore.h"
|
||||
#include "DebugServiceI.h"
|
||||
#include "EmbeddedServiceMethodBinderI.h"
|
||||
#include "MessageI.h"
|
||||
#include "Object.h"
|
||||
#include "ReferenceContainer.h"
|
||||
#include "ReferenceT.h"
|
||||
#include "SingleThreadService.h"
|
||||
#include "StreamString.h"
|
||||
#include "Vec.h"
|
||||
|
||||
namespace MARTe {
|
||||
|
||||
class MemoryMapBroker;
|
||||
class DataSourceI;
|
||||
|
||||
struct SignalAlias {
|
||||
StreamString name;
|
||||
uint32 signalIndex;
|
||||
};
|
||||
|
||||
struct BrokerInfo {
|
||||
DebugSignalInfo **signalPointers;
|
||||
uint32 numSignals;
|
||||
MemoryMapBroker *broker;
|
||||
volatile bool *anyActiveFlag;
|
||||
Vec<uint32> *activeIndices;
|
||||
Vec<uint32> *activeSizes;
|
||||
FastPollingMutexSem *activeMutex;
|
||||
// Conditional break — mirrors activeIndices but for break-enabled signals
|
||||
volatile bool *anyBreakFlag;
|
||||
Vec<uint32> *breakIndices;
|
||||
// GAM association for step-by-GAM
|
||||
StreamString gamName;
|
||||
bool isOutput;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief TCP/UDP implementation of DebugServiceI.
|
||||
*
|
||||
* Provides signal tracing (UDP), forced-value injection, break conditions,
|
||||
* and a text command channel (TCP) with a log-forwarding sidecar (TcpLogger).
|
||||
* Alternative transports (TTY, WebSocket, …) can be added by implementing
|
||||
* DebugServiceI without touching this class or any broker wrapper code.
|
||||
*/
|
||||
class DebugService : public ReferenceContainer,
|
||||
public MessageI,
|
||||
public EmbeddedServiceMethodBinderI {
|
||||
public EmbeddedServiceMethodBinderI,
|
||||
public DebugServiceI {
|
||||
public:
|
||||
friend class DebugServiceTest;
|
||||
CLASS_REGISTER_DECLARATION()
|
||||
@@ -52,49 +37,43 @@ public:
|
||||
|
||||
virtual bool Initialise(StructuredDataI &data);
|
||||
|
||||
DebugSignalInfo *RegisterSignal(void *memoryAddress, TypeDescriptor type,
|
||||
const char8 *name, uint8 numberOfDimensions = 0,
|
||||
// DebugServiceI RT-path overrides
|
||||
virtual DebugSignalInfo *RegisterSignal(void *memoryAddress, TypeDescriptor type,
|
||||
const char8 *name,
|
||||
uint8 numberOfDimensions = 0,
|
||||
uint32 numberOfElements = 1);
|
||||
void ProcessSignal(DebugSignalInfo *signalInfo, uint32 size,
|
||||
virtual void ProcessSignal(DebugSignalInfo *signalInfo, uint32 size,
|
||||
uint64 timestamp);
|
||||
|
||||
void RegisterBroker(DebugSignalInfo **signalPointers, uint32 numSignals,
|
||||
virtual void RegisterBroker(DebugSignalInfo **signalPointers, uint32 numSignals,
|
||||
MemoryMapBroker *broker, volatile bool *anyActiveFlag,
|
||||
Vec<uint32> *activeIndices, Vec<uint32> *activeSizes,
|
||||
FastPollingMutexSem *activeMutex,
|
||||
volatile bool *anyBreakFlag, Vec<uint32> *breakIndices,
|
||||
const char8 *gamName = NULL_PTR(const char8 *),
|
||||
bool isOutput = false);
|
||||
|
||||
virtual ErrorManagement::ErrorType Execute(ExecutionInfo &info);
|
||||
|
||||
virtual ErrorManagement::ErrorType HandleMessage(ReferenceT<Message> &data);
|
||||
|
||||
bool IsPaused() const { return isPaused; }
|
||||
void SetPaused(bool paused) { isPaused = paused; }
|
||||
|
||||
// Step-by-GAM / per-thread: called by each output broker.
|
||||
// threadName is the OS thread name (from Threads::Name(Threads::Id())).
|
||||
// Decrements stepRemaining only when stepThreadFilter is empty or matches;
|
||||
// when stepRemaining reaches 0, sets isPaused = true and records gamName.
|
||||
void ConsumeStepIfNeeded(const char8 *gamName,
|
||||
virtual bool IsPaused() const { return isPaused; }
|
||||
virtual void SetPaused(bool paused) { isPaused = paused; }
|
||||
virtual bool IsStepPending() const { return stepRemaining > 0u; }
|
||||
virtual void ConsumeStepIfNeeded(const char8 *gamName,
|
||||
const char8 *threadName = NULL_PTR(const char8 *));
|
||||
|
||||
// DebugServiceI control-path overrides
|
||||
virtual uint32 ForceSignal (const char8 *name, const char8 *valueStr);
|
||||
virtual uint32 UnforceSignal(const char8 *name);
|
||||
virtual uint32 TraceSignal (const char8 *name, bool enable, uint32 decimation = 1);
|
||||
virtual uint32 SetBreak (const char8 *name, uint8 op, float64 threshold);
|
||||
virtual uint32 ClearBreak (const char8 *name);
|
||||
virtual bool IsInstrumented(const char8 *fullPath, bool &traceable, bool &forcable);
|
||||
virtual uint32 RegisterMonitorSignal(const char8 *path, uint32 periodMs);
|
||||
virtual uint32 UnmonitorSignal (const char8 *path);
|
||||
|
||||
virtual ErrorManagement::ErrorType Execute(ExecutionInfo &info);
|
||||
virtual ErrorManagement::ErrorType HandleMessage(ReferenceT<Message> &data);
|
||||
|
||||
// TCP-transport-specific methods (not part of DebugServiceI)
|
||||
void GetStepStatus(BasicTCPSocket *client);
|
||||
// Step n cycles; if threadName is non-null/non-empty, only that thread advances.
|
||||
void Step(uint32 n, const char8 *threadName = NULL_PTR(const char8 *));
|
||||
|
||||
// Read the current raw value of a signal from its memory address.
|
||||
void GetSignalValue(const char8 *name, BasicTCPSocket *client);
|
||||
|
||||
static bool GetFullObjectName(const Object &obj, StreamString &fullPath);
|
||||
|
||||
uint32 ForceSignal(const char8 *name, const char8 *valueStr);
|
||||
uint32 UnforceSignal(const char8 *name);
|
||||
uint32 TraceSignal(const char8 *name, bool enable, uint32 decimation = 1);
|
||||
uint32 SetBreak(const char8 *name, uint8 op, float64 threshold);
|
||||
uint32 ClearBreak(const char8 *name);
|
||||
bool IsInstrumented(const char8 *fullPath, bool &traceable, bool &forcable);
|
||||
void Discover(BasicTCPSocket *client);
|
||||
void InfoNode(const char8 *path, BasicTCPSocket *client);
|
||||
void ListNodes(const char8 *path, BasicTCPSocket *client);
|
||||
@@ -112,9 +91,6 @@ public:
|
||||
StreamString path;
|
||||
};
|
||||
|
||||
uint32 RegisterMonitorSignal(const char8 *path, uint32 periodMs);
|
||||
uint32 UnmonitorSignal(const char8 *path);
|
||||
|
||||
private:
|
||||
void HandleCommand(StreamString cmd, BasicTCPSocket *client);
|
||||
void UpdateBrokersActiveStatus();
|
||||
@@ -178,17 +154,140 @@ private:
|
||||
FastPollingMutexSem mutex;
|
||||
TraceRingBuffer traceBuffer;
|
||||
|
||||
/**
|
||||
* @brief Mutex protecting traceBuffer.Push() from concurrent RT broker threads.
|
||||
*
|
||||
* TraceRingBuffer is designed for single-producer / single-consumer access.
|
||||
* In practice, multiple RT threads (one per RealTimeThread) call ProcessSignal()
|
||||
* concurrently, making it a multi-producer scenario. Without a lock they can
|
||||
* both pass the free-space check, both pick the same write index, and corrupt
|
||||
* each other's samples. This mutex serialises the Push path.
|
||||
*
|
||||
* The Streamer thread (sole consumer) never holds this lock, so the lock is
|
||||
* only contended between RT threads — not between RT and Streamer.
|
||||
*
|
||||
* FIX #2 — TraceRingBuffer multi-producer race.
|
||||
*/
|
||||
FastPollingMutexSem tracePushMutex;
|
||||
|
||||
/**
|
||||
* @brief Mutex protecting the activeClient pointer.
|
||||
*
|
||||
* activeClient is currently owned exclusively by the Server thread:
|
||||
* it is created, read, and destroyed only inside Server(). The mutex
|
||||
* enforces this invariant and makes future cross-thread access safe.
|
||||
*
|
||||
* Rules:
|
||||
* - Hold clientMutex whenever assigning (including to NULL) activeClient.
|
||||
* - Do NOT hold clientMutex across blocking I/O calls (Read / Write)
|
||||
* to avoid starving threads that only need the pointer.
|
||||
* - Any future code that needs to send data to the active client from a
|
||||
* non-Server thread must lock clientMutex, copy the pointer, release
|
||||
* the lock, then do the Write.
|
||||
*
|
||||
* FIX #2 — activeClient cross-thread safety.
|
||||
*/
|
||||
FastPollingMutexSem clientMutex;
|
||||
|
||||
BasicTCPSocket *activeClient;
|
||||
|
||||
/**
|
||||
* Maximum payload bytes in a single UDP datagram (leave room for IP+UDP headers
|
||||
* on a standard 1500-byte Ethernet MTU). Used in the Streamer to decide when
|
||||
* to flush the current packet and start a new one.
|
||||
*
|
||||
* FIX #1 — named constant to replace the magic number 1400.
|
||||
*/
|
||||
static const uint32 STREAMER_MTU = 1400u;
|
||||
|
||||
/**
|
||||
* Size of the streamer assembly buffer. Must be >= STREAMER_MTU so at least
|
||||
* one full UDP payload can be staged before flushing. A sample that on its own
|
||||
* would exceed (STREAMER_BUFFER_SIZE - sizeof(TraceHeader) - 16) bytes is
|
||||
* silently dropped and logged — it can never fit in any packet.
|
||||
*
|
||||
* FIX #1 — named constant; prevents silent integer arithmetic relying on
|
||||
* the array bound being "obviously 4096".
|
||||
*/
|
||||
static const uint32 STREAMER_BUFFER_SIZE = 4096u;
|
||||
|
||||
// Streamer state persisted across Execute() calls (framework loops Execute)
|
||||
uint8 streamerPacketBuffer[4096];
|
||||
uint8 streamerPacketBuffer[STREAMER_BUFFER_SIZE];
|
||||
uint32 streamerPacketOffset;
|
||||
uint32 streamerSequenceNumber;
|
||||
|
||||
/**
|
||||
* @brief Maximum commands allowed per 1-second sliding window per client.
|
||||
*
|
||||
* A client sending more than this many commands in one second is disconnected.
|
||||
* This prevents a tight command loop from monopolising the Server thread and
|
||||
* starving normal usage. The limit is intentionally generous (100/s) so that
|
||||
* legitimate scripted tooling is unaffected.
|
||||
*
|
||||
* FIX #6 — TCP command rate limiting.
|
||||
*/
|
||||
static const uint32 CMD_RATE_LIMIT = 100u;
|
||||
|
||||
/**
|
||||
* @brief Close the active TCP client if no data is received for this many ms.
|
||||
*
|
||||
* A client that sends a partial command and never completes it would otherwise
|
||||
* hold the single active-client slot open indefinitely, blocking all other
|
||||
* connections. After CLIENT_IDLE_TIMEOUT_MS of silence the connection is
|
||||
* closed and the slot freed.
|
||||
*
|
||||
* FIX #8 — active-client idle timeout.
|
||||
*/
|
||||
static const uint32 CLIENT_IDLE_TIMEOUT_MS = 30000u;
|
||||
|
||||
/**
|
||||
* @brief Maximum array elements returned by GetSignalValue / VALUE command.
|
||||
*
|
||||
* Without a cap, a 1-million-element uint8 array would produce a multi-MB
|
||||
* response string, exhausting heap and blocking the Server thread. Elements
|
||||
* beyond this limit are omitted; the response includes a "Truncated" flag.
|
||||
*
|
||||
* FIX #9 — GetSignalValue unbounded array output.
|
||||
*/
|
||||
static const uint32 GET_VALUE_MAX_ELEMENTS = 256u;
|
||||
|
||||
// Rate-limiter state (per active TCP connection, reset on each new connection)
|
||||
uint32 cmdCountInWindow; // commands received in the current 1-second window
|
||||
uint64 cmdWindowStartMs; // start of the current window, in milliseconds
|
||||
|
||||
// Idle-timeout state
|
||||
uint64 lastDataTimeMs; // last time the active client sent any data (ms)
|
||||
|
||||
/**
|
||||
* @brief Carry-over buffer for multi-segment TCP commands.
|
||||
*
|
||||
* A single TCP Read() call may return only part of a command if the OS
|
||||
* delivers it in multiple segments. Bytes after the last '\n' in the
|
||||
* current receive window are saved here and prepended to the next Read().
|
||||
* This ensures that "FORCE Signal " arriving in one segment and "123\n"
|
||||
* arriving in the next are assembled into the single command
|
||||
* "FORCE Signal 123" before dispatch.
|
||||
*
|
||||
* The buffer is bounded by INPUT_BUFFER_MAX (8 KiB). If a client sends
|
||||
* more than that without a newline it is disconnected.
|
||||
*
|
||||
* FIX #10 — incomplete input buffer handling for multi-line commands.
|
||||
*/
|
||||
StreamString inputBuffer;
|
||||
|
||||
/**
|
||||
* @brief Maximum carry-over bytes allowed before a client is disconnected.
|
||||
*
|
||||
* A client that sends a very long line without a newline would otherwise
|
||||
* grow inputBuffer without bound. At 8 KiB the limit is generous enough
|
||||
* for any legitimate command while still protecting against memory exhaustion.
|
||||
*
|
||||
* FIX #10 — DoS guard for the input carry-over buffer.
|
||||
*/
|
||||
static const uint32 INPUT_BUFFER_MAX = 8192u;
|
||||
|
||||
ConfigurationDatabase fullConfig;
|
||||
bool manualConfigSet;
|
||||
|
||||
static DebugService *instance;
|
||||
};
|
||||
|
||||
} // namespace MARTe
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
#ifndef DEBUGSERVICEI_H
|
||||
#define DEBUGSERVICEI_H
|
||||
|
||||
/**
|
||||
* @file DebugServiceI.h
|
||||
* @brief Abstract interface for the MARTe2 debug/instrumentation service.
|
||||
*
|
||||
* All broker wrappers (DebugBrokerWrapper) depend solely on this interface,
|
||||
* decoupling them from the concrete TCP/UDP implementation. Alternative
|
||||
* transports — TTY, WebSocket, shared-memory ring, etc. — can be plugged in
|
||||
* by providing a new concrete implementation without touching any broker or
|
||||
* application code.
|
||||
*
|
||||
* The interface is split into two logical groups:
|
||||
*
|
||||
* RT-path API
|
||||
* Called from broker threads on every RT cycle. Implementations must
|
||||
* keep these methods as cheap as possible; the only permissible
|
||||
* synchronisation primitive is a fast spinlock (FastPollingMutexSem).
|
||||
*
|
||||
* Control-path API
|
||||
* Called from server / command-handler threads (TCP, TTY, Web …).
|
||||
* Latency here is acceptable; correctness and thread-safety matter.
|
||||
*
|
||||
* Concrete implementations register themselves during Initialise() via
|
||||
* SetInstance(). Broker wrappers retrieve the active instance via
|
||||
* GetInstance(); there is no ORD search on the hot path.
|
||||
*/
|
||||
|
||||
#include "DebugCore.h"
|
||||
#include "FastPollingMutexSem.h"
|
||||
#include "Object.h"
|
||||
#include "StreamString.h"
|
||||
#include "TypeDescriptor.h"
|
||||
#include "Vec.h"
|
||||
|
||||
namespace MARTe {
|
||||
|
||||
// Forward declarations — concrete types are only needed in the implementation.
|
||||
class MemoryMapBroker;
|
||||
|
||||
struct SignalAlias {
|
||||
StreamString name;
|
||||
uint32 signalIndex;
|
||||
};
|
||||
|
||||
struct BrokerInfo {
|
||||
DebugSignalInfo **signalPointers;
|
||||
uint32 numSignals;
|
||||
MemoryMapBroker *broker;
|
||||
volatile bool *anyActiveFlag;
|
||||
Vec<uint32> *activeIndices;
|
||||
Vec<uint32> *activeSizes;
|
||||
FastPollingMutexSem *activeMutex;
|
||||
volatile bool *anyBreakFlag;
|
||||
Vec<uint32> *breakIndices;
|
||||
StreamString gamName;
|
||||
bool isOutput;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Abstract debug-service interface.
|
||||
*/
|
||||
class DebugServiceI {
|
||||
public:
|
||||
// -------------------------------------------------------------------------
|
||||
// Static instance registry
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Return the currently registered debug-service instance, or NULL.
|
||||
*
|
||||
* Called on every broker Init() path and from OutpautPauseAndStep().
|
||||
* Returns NULL when no debug service has been initialised, in which case
|
||||
* all instrumentation is a no-op.
|
||||
*/
|
||||
static DebugServiceI *GetInstance() { return instance; }
|
||||
|
||||
/**
|
||||
* @brief Register @p inst as the global debug-service.
|
||||
*
|
||||
* Concrete implementations call this from their Initialise() method.
|
||||
* Passing NULL deregisters the current instance (called from the
|
||||
* destructor so dangling pointers are never visible to broker threads).
|
||||
*/
|
||||
static void SetInstance(DebugServiceI *inst) { instance = inst; }
|
||||
|
||||
virtual ~DebugServiceI() {}
|
||||
|
||||
// =========================================================================
|
||||
// RT-path API (called from broker execute threads every cycle)
|
||||
// =========================================================================
|
||||
|
||||
/**
|
||||
* @brief Register a signal memory region with the debug service.
|
||||
*
|
||||
* Called once per signal during broker Init(). Returns a pointer to the
|
||||
* internal DebugSignalInfo that the broker caches for use on the hot path.
|
||||
* Thread-safe; must not be called after the RT loop has started.
|
||||
*/
|
||||
virtual DebugSignalInfo *RegisterSignal(void *memoryAddress,
|
||||
TypeDescriptor type,
|
||||
const char8 *name,
|
||||
uint8 numberOfDimensions = 0,
|
||||
uint32 numberOfElements = 1) = 0;
|
||||
|
||||
/**
|
||||
* @brief Process one signal on the RT path.
|
||||
*
|
||||
* Applies forced values (memcpy into signal memory) and, when tracing is
|
||||
* enabled and the decimation counter fires, pushes a sample to the trace
|
||||
* ring buffer. Called under the broker's activeMutex; implementations
|
||||
* must not acquire any lock that is also held by the Server thread.
|
||||
*/
|
||||
virtual void ProcessSignal(DebugSignalInfo *signalInfo,
|
||||
uint32 size,
|
||||
uint64 timestamp) = 0;
|
||||
|
||||
/**
|
||||
* @brief Register a broker so the service can push active/break index
|
||||
* updates to it without iterating every signal.
|
||||
*/
|
||||
virtual void RegisterBroker(DebugSignalInfo **signalPointers,
|
||||
uint32 numSignals,
|
||||
MemoryMapBroker *broker,
|
||||
volatile bool *anyActiveFlag,
|
||||
Vec<uint32> *activeIndices,
|
||||
Vec<uint32> *activeSizes,
|
||||
FastPollingMutexSem *activeMutex,
|
||||
volatile bool *anyBreakFlag,
|
||||
Vec<uint32> *breakIndices,
|
||||
const char8 *gamName = NULL_PTR(const char8 *),
|
||||
bool isOutput = false) = 0;
|
||||
|
||||
/** @brief Return true if the RT loop is currently held at a pause/breakpoint. */
|
||||
virtual bool IsPaused() const = 0;
|
||||
|
||||
/** @brief Set or clear the paused state (called by break-condition logic). */
|
||||
virtual void SetPaused(bool paused) = 0;
|
||||
|
||||
/** @brief Return true if a step count is pending (stepRemaining > 0). */
|
||||
virtual bool IsStepPending() const = 0;
|
||||
|
||||
/**
|
||||
* @brief Consume one step credit for the current output-broker cycle.
|
||||
*
|
||||
* Called by every output broker after Execute(). No-op when stepRemaining
|
||||
* is zero (the common case); only acquires a mutex when stepping is active.
|
||||
*/
|
||||
virtual void ConsumeStepIfNeeded(
|
||||
const char8 *gamName,
|
||||
const char8 *threadName = NULL_PTR(const char8 *)) = 0;
|
||||
|
||||
// =========================================================================
|
||||
// Control-path API (called from server / command-handler threads)
|
||||
// =========================================================================
|
||||
|
||||
virtual uint32 ForceSignal (const char8 *name, const char8 *valueStr) = 0;
|
||||
virtual uint32 UnforceSignal(const char8 *name) = 0;
|
||||
virtual uint32 TraceSignal (const char8 *name, bool enable, uint32 decimation = 1) = 0;
|
||||
virtual uint32 SetBreak (const char8 *name, uint8 op, float64 threshold) = 0;
|
||||
virtual uint32 ClearBreak (const char8 *name) = 0;
|
||||
virtual bool IsInstrumented(const char8 *fullPath,
|
||||
bool &traceable, bool &forcable) = 0;
|
||||
virtual uint32 RegisterMonitorSignal(const char8 *path, uint32 periodMs) = 0;
|
||||
virtual uint32 UnmonitorSignal (const char8 *path) = 0;
|
||||
|
||||
// =========================================================================
|
||||
// Utility (implementation-agnostic, defined in DebugService.cpp)
|
||||
// =========================================================================
|
||||
|
||||
/**
|
||||
* @brief Resolve the fully-qualified ORD path of @p obj into @p fullPath.
|
||||
*
|
||||
* Static so it can be called without a service instance. All concrete
|
||||
* implementations (and InitSignals in DebugBrokerWrapper.h) use this
|
||||
* to build canonical signal names. The definition lives in
|
||||
* DebugService.cpp alongside FindPathInContainer().
|
||||
*/
|
||||
static bool GetFullObjectName(const Object &obj, StreamString &fullPath);
|
||||
|
||||
protected:
|
||||
/** Pointer to the single active debug-service instance. */
|
||||
static DebugServiceI *instance;
|
||||
};
|
||||
|
||||
} // namespace MARTe
|
||||
|
||||
#endif // DEBUGSERVICEI_H
|
||||
@@ -24,7 +24,7 @@
|
||||
|
||||
OBJSX=
|
||||
|
||||
SPB = TCPLogger.x DebugService.x
|
||||
SPB = TCPLogger.x DebugService.x WebDebugService.x
|
||||
|
||||
ROOT_DIR=../../..
|
||||
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
export TARGET=x86-linux
|
||||
|
||||
include Makefile.inc
|
||||
@@ -0,0 +1,34 @@
|
||||
OBJSX=WebDebugService.x
|
||||
|
||||
PACKAGE=Components/Interfaces
|
||||
|
||||
ROOT_DIR=../../../../
|
||||
MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
|
||||
include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
|
||||
|
||||
INCLUDES += -I$(ROOT_DIR)/Source/Core/Types/Result
|
||||
INCLUDES += -I$(ROOT_DIR)/Source/Core/Types/Vec
|
||||
INCLUDES += -I$(ROOT_DIR)/Source/Components/Interfaces/TCPLogger
|
||||
INCLUDES += -I$(ROOT_DIR)/Source/Components/Interfaces/DebugService
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L0Types
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L1Portability
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L2Objects
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L3Streams
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Messages
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Logger
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Configuration
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L5GAMs
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L1Portability
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L3Services
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4Messages
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4LoggerService
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L5GAMs
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L1Portability
|
||||
INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L3Streams
|
||||
|
||||
all: $(OBJS) $(SUBPROJ) \
|
||||
$(BUILD_DIR)/WebDebugService$(LIBEXT) \
|
||||
$(BUILD_DIR)/WebDebugService$(DLLEXT)
|
||||
echo $(OBJS)
|
||||
|
||||
include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,205 @@
|
||||
#ifndef WEBDEBUGSERVICE_H
|
||||
#define WEBDEBUGSERVICE_H
|
||||
|
||||
#include "BasicTCPSocket.h"
|
||||
#include "ConfigurationDatabase.h"
|
||||
#include "DataSourceI.h"
|
||||
#include "DebugServiceI.h"
|
||||
#include "EmbeddedServiceMethodBinderI.h"
|
||||
#include "ReferenceContainer.h"
|
||||
#include "ReferenceT.h"
|
||||
#include "SingleThreadService.h"
|
||||
|
||||
namespace MARTe {
|
||||
|
||||
/**
|
||||
* @brief HTTP/SSE implementation of DebugServiceI.
|
||||
*
|
||||
* Serves a single-page web UI on httpPort (default 8090).
|
||||
* Endpoints:
|
||||
* GET / — embedded HTML application
|
||||
* POST /api/command — execute a debug command; returns text response
|
||||
* GET /api/events — Server-Sent Events stream for real-time telemetry
|
||||
*
|
||||
* SSE event types (JSON payload on each "data:" line):
|
||||
* {"type":"trace", "name":"…","ts":<ns>,"value":<f64>}
|
||||
* {"type":"monitor", "name":"…","ts":<ns>,"value":<f64>}
|
||||
* {"type":"log", "level":"…","msg":"…"}
|
||||
* {"type":"status", "paused":<bool>,"gam":"…","remaining":<u32>}
|
||||
* {"type":"discover","signals":[…]}
|
||||
* {"type":"tree", "tree":{…}}
|
||||
*
|
||||
* This is an alternative to DebugService (TCP/UDP) and registers itself as the
|
||||
* global DebugServiceI singleton on Initialise().
|
||||
*/
|
||||
class WebDebugService : public ReferenceContainer,
|
||||
public EmbeddedServiceMethodBinderI,
|
||||
public DebugServiceI {
|
||||
public:
|
||||
friend class WebDebugServiceTest;
|
||||
CLASS_REGISTER_DECLARATION()
|
||||
|
||||
WebDebugService();
|
||||
virtual ~WebDebugService();
|
||||
|
||||
virtual bool Initialise(StructuredDataI &data);
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// DebugServiceI RT-path overrides
|
||||
// -------------------------------------------------------------------------
|
||||
virtual DebugSignalInfo *RegisterSignal(void *memoryAddress,
|
||||
TypeDescriptor type,
|
||||
const char8 *name,
|
||||
uint8 numberOfDimensions = 0,
|
||||
uint32 numberOfElements = 1);
|
||||
virtual void ProcessSignal(DebugSignalInfo *signalInfo, uint32 size,
|
||||
uint64 timestamp);
|
||||
virtual void RegisterBroker(DebugSignalInfo **signalPointers,
|
||||
uint32 numSignals, MemoryMapBroker *broker,
|
||||
volatile bool *anyActiveFlag,
|
||||
Vec<uint32> *activeIndices,
|
||||
Vec<uint32> *activeSizes,
|
||||
FastPollingMutexSem *activeMutex,
|
||||
volatile bool *anyBreakFlag,
|
||||
Vec<uint32> *breakIndices,
|
||||
const char8 *gamName = NULL_PTR(const char8 *),
|
||||
bool isOutput = false);
|
||||
virtual bool IsPaused() const { return isPaused; }
|
||||
virtual void SetPaused(bool paused) { isPaused = paused; }
|
||||
virtual bool IsStepPending() const { return stepRemaining > 0u; }
|
||||
virtual void ConsumeStepIfNeeded(const char8 *gamName,
|
||||
const char8 *threadName = NULL_PTR(const char8 *));
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// DebugServiceI control-path overrides
|
||||
// -------------------------------------------------------------------------
|
||||
virtual uint32 ForceSignal (const char8 *name, const char8 *valueStr);
|
||||
virtual uint32 UnforceSignal (const char8 *name);
|
||||
virtual uint32 TraceSignal (const char8 *name, bool enable, uint32 decimation = 1);
|
||||
virtual uint32 SetBreak (const char8 *name, uint8 op, float64 threshold);
|
||||
virtual uint32 ClearBreak (const char8 *name);
|
||||
virtual bool IsInstrumented(const char8 *fullPath, bool &traceable, bool &forcable);
|
||||
virtual uint32 RegisterMonitorSignal(const char8 *path, uint32 periodMs);
|
||||
virtual uint32 UnmonitorSignal (const char8 *path);
|
||||
|
||||
// EmbeddedServiceMethodBinderI (framework dispatches to sub-binders)
|
||||
virtual ErrorManagement::ErrorType Execute(ExecutionInfo &info);
|
||||
|
||||
// Inject the full config CDB (call after ConfigureApplication)
|
||||
void SetFullConfig(ConfigurationDatabase &config);
|
||||
void RebuildConfigFromRegistry();
|
||||
|
||||
struct MonitoredSignal {
|
||||
ReferenceT<DataSourceI> dataSource;
|
||||
uint32 signalIdx;
|
||||
uint32 internalID;
|
||||
uint32 periodMs;
|
||||
uint64 lastPollTime;
|
||||
uint32 size;
|
||||
StreamString path;
|
||||
};
|
||||
|
||||
private:
|
||||
// HTTP server helpers
|
||||
bool ParseRequest(BasicTCPSocket *client, StreamString &method,
|
||||
StreamString &path, StreamString &body);
|
||||
void SendHttp(BasicTCPSocket *client, uint32 code, const char8 *ct,
|
||||
StreamString &body);
|
||||
void HandleRequest(BasicTCPSocket *client, const StreamString &method,
|
||||
const StreamString &path, const StreamString &body);
|
||||
void UpgradeToSse(BasicTCPSocket *client);
|
||||
|
||||
// Command handler — writes response to StreamString (not a socket)
|
||||
void HandleCommand(const StreamString &cmd, StreamString &out);
|
||||
void Discover (StreamString &out);
|
||||
void InfoNode (const char8 *path, StreamString &out);
|
||||
void ListNodes (const char8 *path, StreamString &out);
|
||||
void GetSignalValue(const char8 *name, StreamString &out);
|
||||
void ServeConfig (StreamString &out);
|
||||
void GetStepStatus(StreamString &out);
|
||||
void Step(uint32 n, const char8 *threadName = NULL_PTR(const char8 *));
|
||||
|
||||
// Tree / config helpers
|
||||
uint32 ExportTree(ReferenceContainer *container, StreamString &json,
|
||||
const char8 *pathPrefix);
|
||||
void EnrichWithConfig(const char8 *path, StreamString &json);
|
||||
static void JsonifyDatabase(ConfigurationDatabase &db, StreamString &json);
|
||||
|
||||
// Registry patching (same as DebugService)
|
||||
void PatchRegistry();
|
||||
|
||||
// Broker index maintenance
|
||||
void UpdateBrokersActiveStatus();
|
||||
void UpdateBrokersBreakStatus();
|
||||
|
||||
// SSE broadcast
|
||||
void BroadcastSse(const char8 *eventType, const StreamString &data);
|
||||
void RemoveDeadSseClients();
|
||||
|
||||
// Service thread entry points
|
||||
ErrorManagement::ErrorType HttpServer(ExecutionInfo &info);
|
||||
ErrorManagement::ErrorType Streamer (ExecutionInfo &info);
|
||||
|
||||
// Sub-binder so the framework can dispatch to two separate threads
|
||||
class WdsBinder : public EmbeddedServiceMethodBinderI {
|
||||
public:
|
||||
enum ServiceType { Http, Stream };
|
||||
WdsBinder(WebDebugService *p, ServiceType t) : parent(p), stype(t) {}
|
||||
virtual ErrorManagement::ErrorType Execute(ExecutionInfo &info) {
|
||||
return (stype == Stream) ? parent->Streamer(info)
|
||||
: parent->HttpServer(info);
|
||||
}
|
||||
private:
|
||||
WebDebugService *parent;
|
||||
ServiceType stype;
|
||||
};
|
||||
|
||||
uint16 httpPort;
|
||||
|
||||
volatile bool isPaused;
|
||||
volatile uint32 stepRemaining;
|
||||
StreamString pausedAtGam;
|
||||
StreamString stepThreadFilter;
|
||||
|
||||
BasicTCPSocket tcpServer;
|
||||
|
||||
WdsBinder binderHttp;
|
||||
WdsBinder binderStream;
|
||||
SingleThreadService httpService;
|
||||
SingleThreadService streamerService;
|
||||
|
||||
Vec<DebugSignalInfo *> signals;
|
||||
Vec<SignalAlias> aliases;
|
||||
Vec<BrokerInfo> brokers;
|
||||
Vec<MonitoredSignal> monitoredSignals;
|
||||
|
||||
FastPollingMutexSem mutex;
|
||||
FastPollingMutexSem tracePushMutex;
|
||||
TraceRingBuffer traceBuffer;
|
||||
|
||||
// SSE client list
|
||||
static const uint32 MAX_SSE_CLIENTS = 8u;
|
||||
BasicTCPSocket *sseClients[MAX_SSE_CLIENTS];
|
||||
FastPollingMutexSem sseMutex;
|
||||
|
||||
// Streamer packet state
|
||||
uint32 streamerSeq;
|
||||
uint64 streamerT0Ns; // nanosecond origin for relative timestamps sent over SSE
|
||||
|
||||
ConfigurationDatabase fullConfig;
|
||||
bool manualConfigSet;
|
||||
|
||||
static const uint32 GET_VALUE_MAX_ELEMENTS = 256u;
|
||||
|
||||
// Log history buffer — replayed to newly connecting SSE clients
|
||||
static const uint32 LOG_HISTORY_SIZE = 64u;
|
||||
static const uint32 LOG_ENTRY_MAX_SIZE = 512u;
|
||||
char8 logHistory[64][512];
|
||||
uint32 logHistoryWriteIdx;
|
||||
uint32 logHistoryFill;
|
||||
FastPollingMutexSem logHistoryMutex;
|
||||
};
|
||||
|
||||
} // namespace MARTe
|
||||
|
||||
#endif // WEBDEBUGSERVICE_H
|
||||
@@ -0,0 +1,611 @@
|
||||
#ifndef WEBUI_H
|
||||
#define WEBUI_H
|
||||
|
||||
#include "CompilerTypes.h"
|
||||
|
||||
namespace MARTe {
|
||||
|
||||
// clang-format off
|
||||
static const char8 *const WEB_UI_HTML =
|
||||
"<!DOCTYPE html>\n"
|
||||
"<html lang='en'>\n"
|
||||
"<head>\n"
|
||||
"<meta charset='UTF-8'>\n"
|
||||
"<meta name='viewport' content='width=device-width,initial-scale=1'>\n"
|
||||
"<title>MARTe2 Debug</title>\n"
|
||||
"<script src='https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js'></script>\n"
|
||||
"<style>\n"
|
||||
":root{--base:#1e1e2e;--mantle:#181825;--crust:#11111b;--text:#cdd6f4;--sub:#a6adc8;\n"
|
||||
" --ov:#6c7086;--s0:#313244;--s1:#45475a;--s2:#585b70;--blue:#89b4fa;\n"
|
||||
" --green:#a6e3a1;--yellow:#f9e2af;--red:#f38ba8;--mauve:#cba6f7;--peach:#fab387;\n"
|
||||
" --teal:#94e2d5;--sky:#89dceb;}\n"
|
||||
"*{box-sizing:border-box;margin:0;padding:0;}\n"
|
||||
"body{background:var(--base);color:var(--text);font-family:'JetBrains Mono','Fira Code',monospace;\n"
|
||||
" font-size:12px;height:100vh;display:flex;flex-direction:column;overflow:hidden;}\n"
|
||||
"#toolbar{background:var(--mantle);border-bottom:1px solid var(--s0);padding:5px 8px;\n"
|
||||
" display:flex;align-items:center;gap:6px;flex-shrink:0;flex-wrap:wrap;}\n"
|
||||
".dot{width:9px;height:9px;border-radius:50%;background:var(--red);flex-shrink:0;}\n"
|
||||
".dot.ok{background:var(--green);}\n"
|
||||
".dot.pause{background:var(--yellow);animation:blink 1s infinite;}\n"
|
||||
"@keyframes blink{0%,100%{opacity:1}50%{opacity:.3}}\n"
|
||||
"button{background:var(--s0);color:var(--text);border:1px solid var(--s1);border-radius:3px;\n"
|
||||
" padding:2px 7px;cursor:pointer;font-size:11px;font-family:inherit;}\n"
|
||||
"button:hover{background:var(--s1);}\n"
|
||||
"button.act{background:var(--blue);color:var(--base);border-color:var(--blue);}\n"
|
||||
"button.danger{background:var(--red);color:var(--base);border-color:var(--red);}\n"
|
||||
"input[type=text],input[type=number]{background:var(--s0);color:var(--text);\n"
|
||||
" border:1px solid var(--s1);border-radius:3px;padding:2px 5px;font-size:11px;font-family:inherit;}\n"
|
||||
"input:focus{outline:none;border-color:var(--blue);}\n"
|
||||
"label{color:var(--sub);font-size:11px;}\n"
|
||||
"select{background:var(--s0);color:var(--text);border:1px solid var(--s1);border-radius:3px;\n"
|
||||
" padding:2px 5px;font-size:11px;font-family:inherit;}\n"
|
||||
".sep{width:1px;height:18px;background:var(--s1);flex-shrink:0;}\n"
|
||||
"#main{display:flex;flex:1;overflow:hidden;}\n"
|
||||
"#left{width:255px;background:var(--mantle);border-right:1px solid var(--s0);\n"
|
||||
" display:flex;flex-direction:column;overflow:hidden;flex-shrink:0;}\n"
|
||||
"#center{flex:1;display:flex;flex-direction:column;overflow:hidden;}\n"
|
||||
"#right{width:215px;background:var(--mantle);border-left:1px solid var(--s0);\n"
|
||||
" display:flex;flex-direction:column;overflow:hidden;flex-shrink:0;}\n"
|
||||
"#bottom{height:135px;background:var(--mantle);border-top:1px solid var(--s0);\n"
|
||||
" display:flex;flex-direction:column;flex-shrink:0;}\n"
|
||||
".ph{background:var(--crust);padding:4px 7px;font-size:11px;color:var(--sub);\n"
|
||||
" display:flex;align-items:center;justify-content:space-between;flex-shrink:0;\n"
|
||||
" border-bottom:1px solid var(--s0);}\n"
|
||||
".ph span{font-weight:bold;color:var(--blue);}\n"
|
||||
"#tree{flex:1;overflow-y:auto;padding:3px;}\n"
|
||||
".tr{display:flex;align-items:center;padding:2px 3px;border-radius:3px;gap:2px;cursor:default;}\n"
|
||||
".tr:hover{background:var(--s0);}\n"
|
||||
".tog{width:13px;text-align:center;cursor:pointer;color:var(--ov);font-size:10px;flex-shrink:0;}\n"
|
||||
".ico{flex-shrink:0;font-size:10px;}\n"
|
||||
".tn{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:11px;}\n"
|
||||
".sig{color:var(--green);}\n"
|
||||
".tbtns{display:none;gap:2px;}\n"
|
||||
".tr:hover .tbtns{display:flex;}\n"
|
||||
".tb{background:none;border:none;padding:1px 3px;font-size:10px;cursor:pointer;\n"
|
||||
" border-radius:2px;color:var(--sub);}\n"
|
||||
".tb:hover{background:var(--s1);color:var(--text);}\n"
|
||||
".tch{padding-left:13px;}\n"
|
||||
"#ctrls{padding:4px 7px;display:flex;align-items:center;gap:5px;background:var(--crust);\n"
|
||||
" border-bottom:1px solid var(--s0);flex-shrink:0;flex-wrap:wrap;}\n"
|
||||
"#ca{flex:1;padding:6px;overflow:hidden;position:relative;}\n"
|
||||
"#mc{display:block;width:100%;height:100%;}\n"
|
||||
"#traced{flex:1;overflow-y:auto;padding:3px;}\n"
|
||||
".ti{display:flex;align-items:center;gap:3px;padding:2px 4px;border-radius:3px;margin-bottom:1px;}\n"
|
||||
".ti:hover{background:var(--s0);}\n"
|
||||
".tc{width:7px;height:7px;border-radius:2px;flex-shrink:0;}\n"
|
||||
".tnm{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:11px;}\n"
|
||||
".tv{font-size:10px;color:var(--yellow);min-width:55px;text-align:right;flex-shrink:0;}\n"
|
||||
".titbs{display:none;gap:2px;}\n"
|
||||
".ti:hover .titbs{display:flex;}\n"
|
||||
"#ltb{padding:3px 5px;display:flex;gap:6px;align-items:center;background:var(--crust);\n"
|
||||
" border-bottom:1px solid var(--s0);flex-shrink:0;}\n"
|
||||
"#lc{flex:1;overflow-y:auto;padding:2px 5px;}\n"
|
||||
".le{font-size:10px;line-height:1.4;font-family:monospace;white-space:pre-wrap;word-break:break-all;}\n"
|
||||
".lDEBUG{color:var(--ov);}\n"
|
||||
".lINFO{color:var(--text);}\n"
|
||||
".lWARNING{color:var(--yellow);}\n"
|
||||
".lERROR{color:var(--red);}\n"
|
||||
".mo{display:none;position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,.7);\n"
|
||||
" z-index:100;align-items:center;justify-content:center;}\n"
|
||||
".mo.show{display:flex;}\n"
|
||||
".mb{background:var(--mantle);border:1px solid var(--s1);border-radius:7px;padding:15px;min-width:290px;}\n"
|
||||
".mb h3{color:var(--blue);margin-bottom:11px;font-size:13px;}\n"
|
||||
".fr{display:flex;align-items:center;gap:7px;margin-bottom:7px;}\n"
|
||||
".fr label{min-width:75px;color:var(--sub);}\n"
|
||||
".fr input,.fr select,.fr textarea{flex:1;}\n"
|
||||
"textarea{background:var(--s0);color:var(--text);border:1px solid var(--s1);border-radius:3px;\n"
|
||||
" padding:2px 5px;font-size:11px;font-family:inherit;resize:vertical;}\n"
|
||||
"textarea:focus{outline:none;border-color:var(--blue);}\n"
|
||||
".mbtns{display:flex;gap:7px;justify-content:flex-end;margin-top:11px;}\n"
|
||||
"::-webkit-scrollbar{width:5px;height:5px;}\n"
|
||||
"::-webkit-scrollbar-track{background:var(--mantle);}\n"
|
||||
"::-webkit-scrollbar-thumb{background:var(--s1);border-radius:3px;}\n"
|
||||
"</style>\n"
|
||||
"</head>\n"
|
||||
"<body>\n"
|
||||
"<div id='toolbar'>\n"
|
||||
" <div id='sdot' class='dot'></div>\n"
|
||||
" <span id='stxt' style='color:var(--sub);font-size:11px'>Connecting\xe2\x80\xa6</span>\n"
|
||||
" <div class='sep'></div>\n"
|
||||
" <button onclick='cmd(\"DISCOVER\")'>Discover</button>\n"
|
||||
" <button onclick='cmd(\"TREE\")'>Tree</button>\n"
|
||||
" <div class='sep'></div>\n"
|
||||
" <button id='pbtn' onclick='togglePause()'>Pause</button>\n"
|
||||
" <div class='sep'></div>\n"
|
||||
" <label>Step:</label>\n"
|
||||
" <input type='number' id='sn' value='1' min='1' style='width:45px'>\n"
|
||||
" <input type='text' id='sthr' list='thrnodes' placeholder='thread' style='width:90px'>\n"
|
||||
" <datalist id='thrnodes'></datalist>\n"
|
||||
" <button onclick='doStep()'>Step</button>\n"
|
||||
" <button onclick='openMsg()'>Msg</button>\n"
|
||||
" <div class='sep'></div>\n"
|
||||
" <label>Win:</label>\n"
|
||||
" <input type='number' id='winms' value='5000' min='100' style='width:60px' onchange='winMs=+this.value'>\n"
|
||||
" <button onclick='clearChart()'>Clear</button>\n"
|
||||
" <span id='ss' style='color:var(--yellow);font-size:11px'></span>\n"
|
||||
"</div>\n"
|
||||
"<div id='main'>\n"
|
||||
" <div id='left'>\n"
|
||||
" <div class='ph'><span>App Tree</span><button onclick='cmd(\"TREE\")' style='font-size:10px'>↻</button></div>\n"
|
||||
" <div id='tree'><div style='color:var(--ov);padding:7px;font-size:11px'>Click Tree or Discover\xe2\x80\xa6</div></div>\n"
|
||||
" </div>\n"
|
||||
" <div id='center'>\n"
|
||||
" <div id='ctrls'>\n"
|
||||
" <label>Signal:</label>\n"
|
||||
" <select id='sigsel' style='width:150px'><option value=''>-- pick --</option></select>\n"
|
||||
" <button onclick='addToChart()'>+ Plot</button>\n"
|
||||
" <button onclick='toggleFollow()' id='fbtn' class='act'>Follow</button>\n"
|
||||
" </div>\n"
|
||||
" <div id='ca' ondragover='event.preventDefault()' ondrop='dropOnChart(event)'><canvas id='mc'></canvas></div>\n"
|
||||
" </div>\n"
|
||||
" <div id='right'>\n"
|
||||
" <div class='ph'><span>Traced</span></div>\n"
|
||||
" <div id='traced'></div>\n"
|
||||
" </div>\n"
|
||||
"</div>\n"
|
||||
"<div id='bottom'>\n"
|
||||
" <div class='ph'>\n"
|
||||
" <span>Log</span>\n"
|
||||
" <div style='display:flex;gap:5px;align-items:center'>\n"
|
||||
" <label><input type='checkbox' id='fdbg' checked> D</label>\n"
|
||||
" <label><input type='checkbox' id='finf' checked> I</label>\n"
|
||||
" <label><input type='checkbox' id='fwrn' checked> W</label>\n"
|
||||
" <label><input type='checkbox' id='ferr' checked> E</label>\n"
|
||||
" <button onclick='document.getElementById(\"lc\").innerHTML=\"\"'>Clr</button>\n"
|
||||
" </div>\n"
|
||||
" </div>\n"
|
||||
" <div id='lc'></div>\n"
|
||||
"</div>\n"
|
||||
"<!-- Modals -->\n"
|
||||
"<div class='mo' id='frcm'>\n"
|
||||
" <div class='mb'>\n"
|
||||
" <h3>Force Signal</h3>\n"
|
||||
" <div class='fr'><label>Signal:</label><span id='frcn' style='color:var(--green);font-size:11px;flex:1;overflow:hidden;text-overflow:ellipsis'></span></div>\n"
|
||||
" <div class='fr'><label>Value:</label><input type='text' id='frcv'></div>\n"
|
||||
" <div class='mbtns'>\n"
|
||||
" <button onclick='closeM(\"frcm\")'>Cancel</button>\n"
|
||||
" <button onclick='doUnforce()'>Unforce</button>\n"
|
||||
" <button class='act' onclick='doForce()'>Force</button>\n"
|
||||
" </div>\n"
|
||||
" </div>\n"
|
||||
"</div>\n"
|
||||
"<div class='mo' id='brkm'>\n"
|
||||
" <div class='mb'>\n"
|
||||
" <h3>Break Condition</h3>\n"
|
||||
" <div class='fr'><label>Signal:</label><span id='brkn' style='color:var(--green);font-size:11px;flex:1;overflow:hidden;text-overflow:ellipsis'></span></div>\n"
|
||||
" <div class='fr'><label>Op:</label><select id='brkop'><option>></option><option><</option><option>==</option><option>>=</option><option><=</option><option>!=</option></select></div>\n"
|
||||
" <div class='fr'><label>Threshold:</label><input type='number' id='brkthr' step='any' value='0'></div>\n"
|
||||
" <div class='mbtns'>\n"
|
||||
" <button onclick='closeM(\"brkm\")'>Cancel</button>\n"
|
||||
" <button onclick='doClrBreak()'>Clear</button>\n"
|
||||
" <button class='act' onclick='doBreak()'>Set</button>\n"
|
||||
" </div>\n"
|
||||
" </div>\n"
|
||||
"</div>\n"
|
||||
"<div class='mo' id='monm'>\n"
|
||||
" <div class='mb'>\n"
|
||||
" <h3>Monitor Signal</h3>\n"
|
||||
" <div class='fr'><label>Signal:</label><span id='monn' style='color:var(--green);font-size:11px;flex:1;overflow:hidden;text-overflow:ellipsis'></span></div>\n"
|
||||
" <div class='fr'><label>Period ms:</label><input type='number' id='monp' value='100' min='10'></div>\n"
|
||||
" <div class='mbtns'>\n"
|
||||
" <button onclick='closeM(\"monm\")'>Cancel</button>\n"
|
||||
" <button onclick='doUnmonitor()'>Unmonitor</button>\n"
|
||||
" <button class='act' onclick='doMonitor()'>Monitor</button>\n"
|
||||
" </div>\n"
|
||||
" </div>\n"
|
||||
"</div>\n"
|
||||
"<div class='mo' id='msgm'>\n"
|
||||
" <div class='mb'>\n"
|
||||
" <h3>Send Message</h3>\n"
|
||||
" <div class='fr'><label>Dest:</label><input type='text' id='msgd' list='msgnodes' autocomplete='off'></div>\n"
|
||||
" <datalist id='msgnodes'></datalist>\n"
|
||||
" <div class='fr'><label>Function:</label><input type='text' id='msgf'></div>\n"
|
||||
" <div class='fr'><label>Payload:</label><textarea id='msgp' rows='3' placeholder='key=val key2=val2'></textarea></div>\n"
|
||||
" <div class='mbtns'>\n"
|
||||
" <button onclick='closeM(\"msgm\")'>Cancel</button>\n"
|
||||
" <button class='act' onclick='doMsg()'>Send</button>\n"
|
||||
" </div>\n"
|
||||
" </div>\n"
|
||||
"</div>\n"
|
||||
"<script>\n"
|
||||
"var sigs=[],td={},isPaused=false,chart=null,cds={},winMs=5000,follow=true,curSig='',tnodes=[],threads=[];\n"
|
||||
"var lc=document.getElementById('lc');\n"
|
||||
"var COLS=['#89b4fa','#a6e3a1','#fab387','#cba6f7','#f38ba8','#94e2d5','#f9e2af','#89dceb'];\n"
|
||||
"var ci=0;\n"
|
||||
"function nc(){return COLS[ci++%COLS.length];}\n"
|
||||
"\n"
|
||||
"// --- SSE ---\n"
|
||||
"function connect(){\n"
|
||||
" var es=new EventSource('/api/events');\n"
|
||||
" es.onopen=function(){\n"
|
||||
" document.getElementById('sdot').className='dot ok';\n"
|
||||
" document.getElementById('stxt').textContent='Connected';\n"
|
||||
" cmd('TREE');cmd('DISCOVER');\n"
|
||||
" };\n"
|
||||
" es.onerror=function(){\n"
|
||||
" document.getElementById('sdot').className='dot';\n"
|
||||
" document.getElementById('stxt').textContent='Reconnecting\xe2\x80\xa6';\n"
|
||||
" es.close();setTimeout(connect,3000);\n"
|
||||
" };\n"
|
||||
" es.onmessage=function(e){\n"
|
||||
" try{handle(JSON.parse(e.data));}catch(x){}\n"
|
||||
" };\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"function handle(ev){\n"
|
||||
" if(ev.type==='trace'||ev.type==='monitor'){\n"
|
||||
" var n=ev.name,ts=ev.ts,v=ev.value;\n"
|
||||
" var isNew=!td[n];\n"
|
||||
" if(isNew){td[n]={pts:[],last:0,col:nc(),inC:false,tracing:false,forced:false};addOpt(n);updTraced();}\n"
|
||||
" td[n].pts.push({x:ts,y:v});\n"
|
||||
" if(td[n].pts.length>10000)td[n].pts.shift();\n"
|
||||
" td[n].last=v;\n"
|
||||
" } else if(ev.type==='log'){\n"
|
||||
" appLog(ev.level,ev.msg);\n"
|
||||
" } else if(ev.type==='status'){\n"
|
||||
" isPaused=ev.paused;\n"
|
||||
" updPause();\n"
|
||||
" var ss=document.getElementById('ss');\n"
|
||||
" if(ev.paused){\n"
|
||||
" ss.textContent='PAUSED'+(ev.gam?' at '+ev.gam:'')+(ev.remaining?' ('+ev.remaining+'step)':'');\n"
|
||||
" document.getElementById('sdot').className='dot pause';\n"
|
||||
" } else {\n"
|
||||
" ss.textContent='';\n"
|
||||
" document.getElementById('sdot').className='dot ok';\n"
|
||||
" }\n"
|
||||
" } else if(ev.type==='discover'){\n"
|
||||
" sigs=ev.signals||[];\n"
|
||||
" buildSel();\n"
|
||||
" } else if(ev.type==='tree'){\n"
|
||||
" renderTree(ev.tree);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"// --- Chart ---\n"
|
||||
"function initChart(){\n"
|
||||
" var ctx=document.getElementById('mc').getContext('2d');\n"
|
||||
" chart=new Chart(ctx,{\n"
|
||||
" type:'line',\n"
|
||||
" data:{datasets:[]},\n"
|
||||
" options:{\n"
|
||||
" animation:false,responsive:true,maintainAspectRatio:false,parsing:false,\n"
|
||||
" plugins:{legend:{display:true,position:'bottom',\n"
|
||||
" labels:{color:'#a6adc8',boxWidth:12,font:{size:10},\n"
|
||||
" generateLabels:function(ch){return ch.data.datasets.map(function(ds,i){\n"
|
||||
" return {text:ds.label.split('.').pop(),fillStyle:ds.borderColor,\n"
|
||||
" strokeStyle:ds.borderColor,lineWidth:0,datasetIndex:i};});}},\n"
|
||||
" onClick:function(e,li){remFromChart(chart.data.datasets[li.datasetIndex].label);}\n"
|
||||
" }},\n"
|
||||
" scales:{\n"
|
||||
" x:{type:'linear',ticks:{color:'#6c7086',maxTicksLimit:8,\n"
|
||||
" callback:function(v){return (v/1000).toFixed(1)+'s';}},\n"
|
||||
" grid:{color:'#313244'}},\n"
|
||||
" y:{ticks:{color:'#6c7086'},grid:{color:'#313244'}}\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
" });\n"
|
||||
" resizeChart();\n"
|
||||
" window.addEventListener('resize',resizeChart);\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"function resizeChart(){\n"
|
||||
" var a=document.getElementById('ca');\n"
|
||||
" var c=document.getElementById('mc');\n"
|
||||
" c.width=a.clientWidth;c.height=a.clientHeight;\n"
|
||||
" if(chart)chart.resize();\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"function updChart(){\n"
|
||||
" if(!chart)return;\n"
|
||||
" var keys=Object.keys(cds);\n"
|
||||
" if(keys.length===0)return;\n"
|
||||
" // Find the latest timestamp across all charted signals for follow mode\n"
|
||||
" var latestTs=0;\n"
|
||||
" for(var i=0;i<keys.length;i++){\n"
|
||||
" var t=td[keys[i]];\n"
|
||||
" if(t&&t.pts.length>0){var lt=t.pts[t.pts.length-1].x;if(lt>latestTs)latestTs=lt;}\n"
|
||||
" }\n"
|
||||
" for(var i=0;i<keys.length;i++){\n"
|
||||
" var n=keys[i],d=cds[n],t=td[n];\n"
|
||||
" if(!t)continue;\n"
|
||||
" if(follow){\n"
|
||||
" var pts=[],minT=latestTs-winMs;\n"
|
||||
" for(var j=0;j<t.pts.length;j++){if(t.pts[j].x>=minT)pts.push(t.pts[j]);}\n"
|
||||
" chart.data.datasets[d].data=pts;\n"
|
||||
" } else {\n"
|
||||
" chart.data.datasets[d].data=t.pts.slice();\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
" chart.update('none');\n"
|
||||
"}\n"
|
||||
"setInterval(function(){if(Object.keys(cds).length>0)updChart();tickValues();},100);\n"
|
||||
"\n"
|
||||
"function addToChart(){\n"
|
||||
" var n=document.getElementById('sigsel').value;\n"
|
||||
" if(!n||cds.hasOwnProperty(n))return;\n"
|
||||
" if(!td[n])td[n]={pts:[],last:0,col:nc(),inC:false,tracing:false,forced:false};\n"
|
||||
" var col=td[n].col,idx=chart.data.datasets.length;\n"
|
||||
" cds[n]=idx;td[n].inC=true;td[n].tracing=true;\n"
|
||||
" chart.data.datasets.push({label:n,data:[],borderColor:col,\n"
|
||||
" backgroundColor:col+'20',borderWidth:1.5,pointRadius:0,tension:0});\n"
|
||||
" chart.update('none');updTraced();\n"
|
||||
" cmd('TRACE '+n+' 1');\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"function addByName(n){\n"
|
||||
" if(!n||cds.hasOwnProperty(n))return;\n"
|
||||
" if(!td[n])td[n]={pts:[],last:0,col:nc(),inC:false,tracing:false,forced:false};\n"
|
||||
" var col=td[n].col,idx=chart.data.datasets.length;\n"
|
||||
" cds[n]=idx;td[n].inC=true;td[n].tracing=true;\n"
|
||||
" chart.data.datasets.push({label:n,data:[],borderColor:col,\n"
|
||||
" backgroundColor:col+'20',borderWidth:1.5,pointRadius:0,tension:0});\n"
|
||||
" chart.update('none');updTraced();\n"
|
||||
" cmd('TRACE '+n+' 1');\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"function dragStart(ev,n){ev.dataTransfer.setData('text',n);}\n"
|
||||
"function dropOnChart(ev){ev.preventDefault();var n=ev.dataTransfer.getData('text');if(n)addByName(n);}\n"
|
||||
"\n"
|
||||
"function remFromChart(n){\n"
|
||||
" if(!cds.hasOwnProperty(n))return;\n"
|
||||
" var idx=cds[n];\n"
|
||||
" chart.data.datasets.splice(idx,1);\n"
|
||||
" delete cds[n];\n"
|
||||
" var ks=Object.keys(cds);\n"
|
||||
" for(var i=0;i<ks.length;i++){if(cds[ks[i]]>idx)cds[ks[i]]--;}\n"
|
||||
" if(td[n])td[n].inC=false;\n"
|
||||
" chart.update('none');updTraced();\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"function clearChart(){\n"
|
||||
" var ks=Object.keys(cds);\n"
|
||||
" for(var i=0;i<ks.length;i++){if(td[ks[i]])td[ks[i]].inC=false;}\n"
|
||||
" chart.data.datasets=[];cds={};\n"
|
||||
" chart.update('none');updTraced();\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"function toggleFollow(){\n"
|
||||
" follow=!follow;\n"
|
||||
" document.getElementById('fbtn').className=follow?'act':'';\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"// --- Traced list ---\n"
|
||||
"function escId(s){return String(s).replace(/[^a-zA-Z0-9]/g,'_');}\n"
|
||||
"function updTraced(){\n"
|
||||
" var h='',ks=Object.keys(td);\n"
|
||||
" for(var i=0;i<ks.length;i++){\n"
|
||||
" var n=ks[i],t=td[n];\n"
|
||||
" var v=typeof t.last==='number'?t.last.toPrecision(5):String(t.last);\n"
|
||||
" var sn=n.split('.').pop();\n"
|
||||
" h+='<div class=\"ti\" draggable=\"true\" ondragstart=\"dragStart(event,\\''+escJ(n)+'\\')\">'\n"
|
||||
" h+='<div class=\"tc\" style=\"background:'+t.col+'\"></div>';\n"
|
||||
" h+='<div class=\"tnm\" title=\"'+escH(n)+'\">'+escH(sn)+'</div>';\n"
|
||||
" h+='<div class=\"tv\" id=\"tv_'+escId(n)+'\">'+escH(v)+'</div>';\n"
|
||||
" h+='<div class=\"titbs\">';\n"
|
||||
" if(t.inC)h+='<button class=\"tb\" onclick=\"remFromChart(\\''+escJ(n)+'\\')\">✕</button>';\n"
|
||||
" else h+='<button class=\"tb\" onclick=\"addByName(\\''+escJ(n)+'\\')\">▶</button>';\n"
|
||||
" if(t.tracing)h+='<button class=\"tb\" title=\"Untrace\" onclick=\"untraceN(\\''+escJ(n)+'\\')\">T×</button>';\n"
|
||||
" if(t.forced) h+='<button class=\"tb\" title=\"Unforce\" onclick=\"doUnforceN(\\''+escJ(n)+'\\')\">F×</button>';\n"
|
||||
" else h+='<button class=\"tb\" onclick=\"openFrc(\\''+escJ(n)+'\\')\">F</button>';\n"
|
||||
" h+='</div></div>';\n"
|
||||
" }\n"
|
||||
" document.getElementById('traced').innerHTML=h;\n"
|
||||
"}\n"
|
||||
"function untraceN(n){cmd('TRACE '+n+' 0');if(td[n])td[n].tracing=false;updTraced();}\n"
|
||||
"function doUnforceN(n){cmd('UNFORCE '+n);if(td[n])td[n].forced=false;updTraced();}\n"
|
||||
"function tickValues(){\n"
|
||||
" var ks=Object.keys(td);\n"
|
||||
" for(var i=0;i<ks.length;i++){\n"
|
||||
" var n=ks[i],t=td[n];\n"
|
||||
" var el=document.getElementById('tv_'+escId(n));\n"
|
||||
" if(el){var v=typeof t.last==='number'?t.last.toPrecision(5):String(t.last);el.textContent=v;}\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"// --- Signal select ---\n"
|
||||
"function buildSel(){\n"
|
||||
" var s=document.getElementById('sigsel');\n"
|
||||
" s.innerHTML='<option value=\"\">-- pick --</option>';\n"
|
||||
" for(var i=0;i<sigs.length;i++){\n"
|
||||
" s.innerHTML+='<option value=\"'+escH(sigs[i].name)+'\">'+escH(sigs[i].name)+'</option>';\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"function addOpt(n){\n"
|
||||
" var s=document.getElementById('sigsel');\n"
|
||||
" for(var i=0;i<s.options.length;i++){if(s.options[i].value===n)return;}\n"
|
||||
" s.innerHTML+='<option value=\"'+escH(n)+'\">'+escH(n)+'</option>';\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"// --- Log ---\n"
|
||||
"function appLog(lv,msg){\n"
|
||||
" var f={DEBUG:document.getElementById('fdbg').checked,\n"
|
||||
" INFO:document.getElementById('finf').checked,\n"
|
||||
" WARNING:document.getElementById('fwrn').checked,\n"
|
||||
" ERROR:document.getElementById('ferr').checked};\n"
|
||||
" if(lv==='Information')lv='INFO';\n"
|
||||
" else if(lv==='Warning')lv='WARNING';\n"
|
||||
" else if(lv==='Debug')lv='DEBUG';\n"
|
||||
" else if(lv==='FatalError'||lv==='Error'||lv==='WARN')lv='ERROR';\n"
|
||||
" if(!f[lv])return;\n"
|
||||
" var d=document.createElement('div');\n"
|
||||
" d.className='le l'+lv;\n"
|
||||
" var now=new Date();\n"
|
||||
" var ts=now.toTimeString().split(' ')[0]+'.'+String(now.getMilliseconds()).padStart(3,'0');\n"
|
||||
" d.textContent='['+ts+']['+lv.substring(0,4)+'] '+msg;\n"
|
||||
" lc.appendChild(d);\n"
|
||||
" if(lc.children.length>500)lc.removeChild(lc.firstChild);\n"
|
||||
" lc.scrollTop=lc.scrollHeight;\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"// --- Tree ---\n"
|
||||
"function renderTree(node){\n"
|
||||
" tnodes=[];threads=[];\n"
|
||||
" var c=document.getElementById('tree');\n"
|
||||
" c.innerHTML='';\n"
|
||||
" if(!node)return;\n"
|
||||
" renderNode(node,c,0,'');\n"
|
||||
" var dl=document.getElementById('thrnodes');\n"
|
||||
" dl.innerHTML='';\n"
|
||||
" for(var i=0;i<threads.length;i++){\n"
|
||||
" var op=document.createElement('option');op.value=threads[i];dl.appendChild(op);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"function renderNode(node,parent,depth,pathPfx){\n"
|
||||
" var fullPath=pathPfx?(pathPfx+'.'+node.Name):node.Name;\n"
|
||||
" var isRoot=(node.Class==='ObjectRegistryDatabase');\n"
|
||||
" if(isRoot)fullPath='';\n"
|
||||
" var isSig=node.IsTraceable||node.IsForcable;\n"
|
||||
" if(!isRoot&&fullPath&&!isSig)tnodes.push(fullPath);\n"
|
||||
" if(node.Class==='RealTimeThread'&&node.Name)threads.push(node.Name);\n"
|
||||
" var div=document.createElement('div');\n"
|
||||
" div.className='tn-node';\n"
|
||||
" var row=document.createElement('div');\n"
|
||||
" row.className='tr';\n"
|
||||
" row.style.paddingLeft=(3+depth*13)+'px';\n"
|
||||
" var hasCh=node.Children&&node.Children.length>0;\n"
|
||||
" var tog=document.createElement('span');\n"
|
||||
" tog.className='tog';\n"
|
||||
" if(hasCh){\n"
|
||||
" tog.textContent='\\u25b8';\n"
|
||||
" tog.onclick=function(){\n"
|
||||
" var ch=div.querySelector('.tch');\n"
|
||||
" if(ch){ch.style.display=ch.style.display==='none'?'':'none';\n"
|
||||
" tog.textContent=ch.style.display==='none'?'\\u25b8':'\\u25be';}\n"
|
||||
" };\n"
|
||||
" }\n"
|
||||
" var ico=document.createElement('span');\n"
|
||||
" ico.className='ico';\n"
|
||||
" ico.textContent=isSig?'\\u25c6':(hasCh?'\\u25c9':'\\u25cb');\n"
|
||||
" ico.style.color=isSig?'var(--green)':(hasCh?'var(--blue)':'var(--ov)');\n"
|
||||
" var nm=document.createElement('span');\n"
|
||||
" nm.className='tn'+(isSig?' sig':'');\n"
|
||||
" nm.textContent=node.Name;\n"
|
||||
" nm.title=(node.Class||'')+(node.Type?' ['+node.Type+']':'');\n"
|
||||
" row.appendChild(tog);row.appendChild(ico);row.appendChild(nm);\n"
|
||||
" if(isSig){\n"
|
||||
" var btns=document.createElement('span');\n"
|
||||
" btns.className='tbtns';\n"
|
||||
" var fp=fullPath;\n"
|
||||
" if(node.IsTraceable){\n"
|
||||
" addBtn(btns,'T','Trace',function(){if(!td[fp])td[fp]={pts:[],last:0,col:nc(),inC:false,tracing:false,forced:false};td[fp].tracing=true;cmd('TRACE '+fp+' 1');updTraced();});\n"
|
||||
" addBtn(btns,'\\u25b6','Plot',function(){addByName(fp);});\n"
|
||||
" }\n"
|
||||
" if(node.IsForcable){\n"
|
||||
" addBtn(btns,'F','Force',function(){openFrc(fp);});\n"
|
||||
" addBtn(btns,'B','Break',function(){openBrk(fp);});\n"
|
||||
" }\n"
|
||||
" addBtn(btns,'M','Monitor',function(){openMon(fp);});\n"
|
||||
" row.appendChild(btns);\n"
|
||||
" }\n"
|
||||
" div.appendChild(row);\n"
|
||||
" if(hasCh){\n"
|
||||
" var chDiv=document.createElement('div');\n"
|
||||
" chDiv.className='tch';\n"
|
||||
" for(var i=0;i<node.Children.length;i++){\n"
|
||||
" renderNode(node.Children[i],chDiv,depth+1,isRoot?'':fullPath);\n"
|
||||
" }\n"
|
||||
" div.appendChild(chDiv);\n"
|
||||
" }\n"
|
||||
" parent.appendChild(div);\n"
|
||||
"}\n"
|
||||
"function addBtn(parent,lbl,title,fn){\n"
|
||||
" var b=document.createElement('button');\n"
|
||||
" b.className='tb';b.textContent=lbl;b.title=title;\n"
|
||||
" b.onclick=fn;parent.appendChild(b);\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"// --- Commands ---\n"
|
||||
"function cmd(c){\n"
|
||||
" fetch('/api/command',{method:'POST',headers:{'Content-Type':'text/plain'},body:c})\n"
|
||||
" .then(function(r){return r.text();})\n"
|
||||
" .then(function(txt){\n"
|
||||
" if(c.indexOf('DISCOVER')===0){\n"
|
||||
" try{\n"
|
||||
" var clean=txt.replace(/\\nOK DISCOVER\\n?$/,'');\n"
|
||||
" var r=JSON.parse(clean);\n"
|
||||
" if(r.Signals){sigs=r.Signals;buildSel();}\n"
|
||||
" }catch(e){}\n"
|
||||
" } else if(c.indexOf('TREE')===0){\n"
|
||||
" try{renderTree(JSON.parse(txt.replace(/\\nOK TREE\\n?$/,'')));}\n"
|
||||
" catch(e){appLog('ERROR','Tree parse: '+e);}\n"
|
||||
" } else if(c.indexOf('STEP_STATUS')===0){\n"
|
||||
" try{\n"
|
||||
" var clean=txt.replace(/\\nOK STEP_STATUS\\n?$/,'');\n"
|
||||
" var st=JSON.parse(clean);\n"
|
||||
" var ev={type:'status',paused:st.Paused,gam:st.PausedAtGam,remaining:st.StepRemaining};\n"
|
||||
" handle(ev);\n"
|
||||
" }catch(e){}\n"
|
||||
" }\n"
|
||||
" })\n"
|
||||
" .catch(function(e){appLog('ERROR','cmd failed: '+e);});\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"function togglePause(){\n"
|
||||
" cmd(isPaused?'RESUME':'PAUSE');\n"
|
||||
"}\n"
|
||||
"function updPause(){\n"
|
||||
" var b=document.getElementById('pbtn');\n"
|
||||
" b.textContent=isPaused?'Resume':'Pause';\n"
|
||||
" b.className=isPaused?'danger':'';\n"
|
||||
"}\n"
|
||||
"function doStep(){\n"
|
||||
" var n=document.getElementById('sn').value||'1';\n"
|
||||
" var t=document.getElementById('sthr').value;\n"
|
||||
" var c='STEP '+n;if(t)c+=' '+t;\n"
|
||||
" cmd(c);\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"// --- Modals ---\n"
|
||||
"function openFrc(n){curSig=n;document.getElementById('frcn').textContent=n;\n"
|
||||
" document.getElementById('frcv').value='';showM('frcm');}\n"
|
||||
"function doForce(){var v=document.getElementById('frcv').value;\n"
|
||||
" if(v!==''){cmd('FORCE '+curSig+' '+v);if(td[curSig])td[curSig].forced=true;}\n"
|
||||
" closeM('frcm');updTraced();}\n"
|
||||
"function doUnforce(){cmd('UNFORCE '+curSig);if(td[curSig])td[curSig].forced=false;closeM('frcm');updTraced();}\n"
|
||||
"\n"
|
||||
"function openBrk(n){curSig=n;document.getElementById('brkn').textContent=n;showM('brkm');}\n"
|
||||
"function doBreak(){var op=document.getElementById('brkop').value;\n"
|
||||
" var t=document.getElementById('brkthr').value;\n"
|
||||
" cmd('BREAK '+curSig+' '+op+' '+t);closeM('brkm');}\n"
|
||||
"function doClrBreak(){cmd('BREAK '+curSig+' OFF');closeM('brkm');}\n"
|
||||
"\n"
|
||||
"function openMon(n){curSig=n;document.getElementById('monn').textContent=n;showM('monm');}\n"
|
||||
"function doMonitor(){var p=document.getElementById('monp').value||'100';\n"
|
||||
" cmd('MONITOR SIGNAL '+curSig+' '+p);closeM('monm');}\n"
|
||||
"function doUnmonitor(){cmd('UNMONITOR SIGNAL '+curSig);closeM('monm');}\n"
|
||||
"\n"
|
||||
"function openMsg(){\n"
|
||||
" var dl=document.getElementById('msgnodes');\n"
|
||||
" dl.innerHTML='';\n"
|
||||
" for(var i=0;i<tnodes.length;i++){\n"
|
||||
" var op=document.createElement('option');op.value=tnodes[i];dl.appendChild(op);\n"
|
||||
" }\n"
|
||||
" showM('msgm');\n"
|
||||
"}\n"
|
||||
"function doMsg(){var d=document.getElementById('msgd').value;\n"
|
||||
" var f=document.getElementById('msgf').value;\n"
|
||||
" var p=document.getElementById('msgp').value;\n"
|
||||
" var c='MSG '+d+' '+f+' 0';if(p)c+=' '+p.replace(/\\n/g,' ');\n"
|
||||
" cmd(c);closeM('msgm');}\n"
|
||||
"\n"
|
||||
"function showM(id){document.getElementById(id).className='mo show';}\n"
|
||||
"function closeM(id){document.getElementById(id).className='mo';}\n"
|
||||
"document.querySelectorAll('.mo').forEach(function(el){\n"
|
||||
" el.addEventListener('click',function(e){if(e.target===el)closeM(el.id);});\n"
|
||||
"});\n"
|
||||
"\n"
|
||||
"// --- Utils ---\n"
|
||||
"function escH(s){return String(s).replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>').replace(/\"/g,'"');}\n"
|
||||
"function escJ(s){return String(s).replace(/\\\\/g,'\\\\\\\\').replace(/'/g,\"\\\\'\");}\n"
|
||||
"\n"
|
||||
"// Init\n"
|
||||
"initChart();\n"
|
||||
"connect();\n"
|
||||
"</script>\n"
|
||||
"</body>\n"
|
||||
"</html>\n";
|
||||
// clang-format on
|
||||
|
||||
} // namespace MARTe
|
||||
|
||||
#endif // WEBUI_H
|
||||
@@ -62,6 +62,21 @@ public:
|
||||
size = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Exchange contents with another Vec in O(1) — no allocation, no element copies.
|
||||
*
|
||||
* Used by UpdateBrokersActiveStatus / UpdateBrokersBreakStatus to publish a
|
||||
* freshly built index list to the RT thread with the shortest possible lock
|
||||
* hold time: only three pointer/size swaps happen inside the mutex.
|
||||
* The old arrays end up in @p other and are freed when it leaves scope
|
||||
* AFTER the lock is released.
|
||||
*/
|
||||
void Swap(Vec<T, GROWTH> &other) {
|
||||
T *tmpArr = arr; arr = other.arr; other.arr = tmpArr;
|
||||
size_t tmpSz = size; size = other.size; other.size = tmpSz;
|
||||
size_t tmpMem = mem_size; mem_size = other.mem_size; other.mem_size = tmpMem;
|
||||
}
|
||||
|
||||
size_t Size() const {
|
||||
return size;
|
||||
}
|
||||
|
||||
+200
-37
@@ -1,56 +1,219 @@
|
||||
# Tutorial: High-Speed Observability with MARTe2 Debug GUI
|
||||
# Tutorial: Observability and Debugging with the MARTe2 Debug Suite
|
||||
|
||||
This guide will walk you through the process of tracing and forcing signals in a real-time MARTe2 application using the native Rust GUI client.
|
||||
This guide covers both transport options. Choose the one that fits your workflow:
|
||||
|
||||
## 1. Environment Setup
|
||||
| | `WebDebugService` | `DebugService` |
|
||||
|---|---|---|
|
||||
| **Client** | Any web browser | Rust native GUI |
|
||||
| **Setup** | Config only | Config + `cargo run` |
|
||||
| **Best for** | Quick inspection, remote access | High-performance plots, scripted tooling |
|
||||
|
||||
---
|
||||
|
||||
## Part A — Web UI (`WebDebugService`)
|
||||
|
||||
### A.1 Environment Setup
|
||||
|
||||
### Launch the MARTe2 Application
|
||||
First, start your application using the provided debug runner. This script launches the standard `MARTeApp.ex` while injecting the debugging layer:
|
||||
```bash
|
||||
./run_debug_app.sh
|
||||
cd /path/to/your/marte2/project
|
||||
source /path/to/marte_debug/env.sh
|
||||
```
|
||||
*Note: You should see logs indicating the `DebugService` has started on port 8080 and `TcpLogger` on port 8082.*
|
||||
|
||||
### Start the GUI Client
|
||||
In a new terminal window, navigate to the client directory and run the GUI:
|
||||
### A.2 Add `WebDebugService` to Your Config
|
||||
|
||||
Add the service as a **sibling** of the `+App` node (not inside it):
|
||||
|
||||
```text
|
||||
+WebDebugService = {
|
||||
Class = WebDebugService
|
||||
HttpPort = 8090
|
||||
}
|
||||
|
||||
+App = {
|
||||
Class = RealTimeApplication
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
Restart your application. You should see:
|
||||
```
|
||||
[WebDebugService] HTTP server listening on port 8090
|
||||
```
|
||||
|
||||
### A.3 Open the Web UI
|
||||
|
||||
Navigate to `http://localhost:8090` in any browser. The UI connects automatically via SSE.
|
||||
|
||||
---
|
||||
|
||||
### A.4 Exploring the Object Tree
|
||||
|
||||
The **Application Tree** panel on the left mirrors your live ORD hierarchy.
|
||||
|
||||
1. Expand `Root → App → Data` to find data sources.
|
||||
2. Click **Info** next to any node to see its class, config, and signals in the details panel.
|
||||
3. Click **List** to expand just the immediate children without recursing.
|
||||
|
||||
---
|
||||
|
||||
### A.5 Real-Time Signal Tracing
|
||||
|
||||
1. Locate a signal in the tree, e.g. `Root.App.Data.Timer.Counter`.
|
||||
2. Click **Trace** next to the signal. The signal appears in the **Traced Signals** list with
|
||||
its live last value.
|
||||
3. Click **Plot** to open it in the real-time Chart.js graph. Use the **Follow** toggle to
|
||||
keep the time axis scrolling.
|
||||
4. To set the sampling decimation (e.g. every 10th sample), use the command box at the bottom
|
||||
of the page:
|
||||
```
|
||||
TRACE App.Data.Timer.Counter 1 10
|
||||
```
|
||||
5. Click **Trace** again (or send `TRACE … 0`) to stop.
|
||||
|
||||
---
|
||||
|
||||
### A.6 Signal Forcing
|
||||
|
||||
1. Find a GAM output signal, e.g. `Root.App.Data.DDB.Counter`.
|
||||
2. Click **Force**. A modal dialog appears.
|
||||
3. Enter a value (e.g. `9999`) and click **Apply**.
|
||||
4. The signal is locked at that value every RT cycle.
|
||||
5. Click **Unforce** (or use the **Active Controls** panel) to release.
|
||||
|
||||
---
|
||||
|
||||
### A.7 Breakpoints
|
||||
|
||||
1. Click **Break** next to a signal.
|
||||
2. Select an operator (`>`, `<`, `==`, etc.) and enter a threshold.
|
||||
3. When the condition fires, the application pauses automatically. The status bar shows
|
||||
**PAUSED** and the GAM name where execution stopped.
|
||||
4. Use **Step** to advance one cycle at a time, or **Resume** to continue.
|
||||
5. Click **Break OFF** to clear the breakpoint.
|
||||
|
||||
---
|
||||
|
||||
### A.8 Execution Stepping
|
||||
|
||||
While paused (after a breakpoint or manual **Pause**):
|
||||
|
||||
1. Enter a step count in the **Step** box (e.g. `5`) and click **Step**.
|
||||
2. The RT loop runs exactly 5 output-broker cycles, then pauses again.
|
||||
3. The status SSE event (`{"type":"status","remaining":…}`) keeps the UI updated.
|
||||
|
||||
---
|
||||
|
||||
### A.9 Signal Monitoring
|
||||
|
||||
Monitoring polls a signal at a slow rate without using the RT trace path — useful for
|
||||
`DataSourceI` signals not connected to any GAM.
|
||||
|
||||
1. Click **Monitor** next to a signal.
|
||||
2. Enter a poll period in milliseconds (e.g. `500`).
|
||||
3. The signal's current value arrives via SSE every 500 ms as a `{"type":"monitor",…}` event.
|
||||
|
||||
---
|
||||
|
||||
### A.10 Log Viewer
|
||||
|
||||
The **Logs** panel at the bottom shows every `REPORT_ERROR` call forwarded as SSE events.
|
||||
Use the level buttons (D / I / W / E) to filter by severity, or type a keyword to search.
|
||||
|
||||
---
|
||||
|
||||
## Part B — Rust Native GUI (`DebugService`)
|
||||
|
||||
### B.1 Environment Setup
|
||||
|
||||
```bash
|
||||
source /path/to/marte_debug/env.sh
|
||||
```
|
||||
|
||||
### B.2 Add `DebugService` to Your Config
|
||||
|
||||
```text
|
||||
+DebugService = {
|
||||
Class = DebugService
|
||||
ControlPort = 8080
|
||||
UdpPort = 8081
|
||||
LogPort = 8082
|
||||
}
|
||||
|
||||
+App = {
|
||||
Class = RealTimeApplication
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
### B.3 Start the GUI Client
|
||||
|
||||
```bash
|
||||
cd Tools/gui_client
|
||||
cargo run --release
|
||||
```
|
||||
|
||||
## 2. Exploring the Object Tree
|
||||
Once connected, the left panel (**Application Tree**) displays the live hierarchy of your application.
|
||||
The GUI connects to `localhost:8080` automatically and requests the tree on startup.
|
||||
|
||||
1. **Navigate to Data:** Expand `Root` -> `App` -> `Data`.
|
||||
2. **Inspect Nodes:** Click the **ℹ Info** button next to any node (like `Timer` or `DDB`).
|
||||
3. **View Metadata:** The bottom-left pane will display the full JSON configuration of that object, including its class, parameters, and signals.
|
||||
---
|
||||
|
||||
## 3. Real-Time Signal Tracing (Oscilloscope)
|
||||
Tracing allows you to see signal values exactly as they exist in the real-time memory map.
|
||||
### B.4 Exploring the Object Tree
|
||||
|
||||
1. **Find a Signal:** In the tree, locate `Root.App.Data.Timer.Counter`.
|
||||
2. **Activate Trace:** Click the **📈 Trace** button.
|
||||
3. **Monitor the Scope:** The central **Oscilloscope** panel will begin plotting the signal.
|
||||
4. **Verify Data Flow:** Check the **UDP Packets** counter in the top bar; it should be increasing rapidly, confirming high-speed data reception (Port 8081).
|
||||
5. **Multi-Signal Trace:** You can click **📈 Trace** on other signals (like `Time`) to overlay multiple plots.
|
||||
The **Application Tree** panel on the left shows the live ORD.
|
||||
|
||||
## 4. Signal Forcing (Manual Override)
|
||||
Forcing allows you to bypass the framework logic and manually set a signal's value in memory.
|
||||
1. Expand `Root → App → Data`.
|
||||
2. Click **ℹ Info** next to any node to see its JSON config in the bottom-left pane.
|
||||
|
||||
1. **Locate Target:** Find a signal that is being written by a GAM, such as `Root.App.Data.DDB.Counter`.
|
||||
2. **Open Force Dialog:** Click the **⚡ Force** button next to the signal.
|
||||
3. **Inject Value:** In the popup dialog, enter a new value (e.g., `9999`) and click **Apply Force**.
|
||||
4. **Observe Effect:** If you are tracing the same signal, the oscilloscope plot will immediately jump to and hold at `9999`.
|
||||
5. **Release Control:** To stop forcing, click the **❌** button in the **Active Controls** (Right Panel) under "Forced Signals". The framework will resume writing its own values to that memory location.
|
||||
---
|
||||
|
||||
## 5. Advanced Controls
|
||||
### B.5 Real-Time Signal Tracing (Oscilloscope)
|
||||
|
||||
### Global Pause
|
||||
If you need to "freeze" the entire application to inspect a specific state:
|
||||
- Click **⏸ Pause** in the top bar. The real-time threads will halt at the start of their next cycle.
|
||||
- Click **▶ Resume** to restart the execution.
|
||||
1. Locate `Root.App.Data.Timer.Counter`.
|
||||
2. Click **📈 Trace**. The **Oscilloscope** panel begins plotting.
|
||||
3. The **UDP Packets** counter in the top bar increments — confirming high-speed telemetry
|
||||
on port 8081.
|
||||
4. Drag additional signals from the **Traced Signals** list into the oscilloscope panel for
|
||||
multi-signal overlay.
|
||||
|
||||
### Log Terminal
|
||||
The bottom panel displays every `REPORT_ERROR` event from the C++ framework, powered by the standalone `TcpLogger` service.
|
||||
- **Regex Filter:** Type a keyword like `Timer` in the filter box to isolate relevant events.
|
||||
- **Pause Logs:** Toggle **⏸ Pause Logs** to stop the scrolling view while data continues to be captured in the background.
|
||||
---
|
||||
|
||||
### B.6 Signal Forcing
|
||||
|
||||
1. Find `Root.App.Data.DDB.Counter`.
|
||||
2. Click **⚡ Force**.
|
||||
3. Enter a value (e.g. `9999`) and click **Apply Force**.
|
||||
4. The oscilloscope plot immediately jumps to and holds at `9999`.
|
||||
5. Click **❌** in the **Active Controls** panel to release the force.
|
||||
|
||||
---
|
||||
|
||||
### B.7 Global Pause and Resume
|
||||
|
||||
- Click **⏸ Pause** in the top bar to halt all RT threads.
|
||||
- Click **▶ Resume** to continue.
|
||||
|
||||
---
|
||||
|
||||
### B.8 Log Terminal
|
||||
|
||||
The bottom panel shows all `REPORT_ERROR` events forwarded from `TcpLogger` (port 8082).
|
||||
|
||||
- **Regex Filter:** Type a keyword (e.g. `Timer`) to isolate events.
|
||||
- **⏸ Pause Logs:** Stop scrolling while continuing to capture.
|
||||
|
||||
---
|
||||
|
||||
## Part C — Scripted / Programmatic Access
|
||||
|
||||
Both transports accept plain text commands. You can use `nc` or any TCP client:
|
||||
|
||||
```bash
|
||||
# DebugService
|
||||
echo -e "DISCOVER\nTRACE App.Data.DDB.Counter 1" | nc localhost 8080
|
||||
|
||||
# WebDebugService
|
||||
curl -s -X POST http://localhost:8090/api/command \
|
||||
-H "Content-Type: text/plain" \
|
||||
-d "DISCOVER"
|
||||
```
|
||||
|
||||
For the full command reference see [API.md](API.md).
|
||||
|
||||
@@ -0,0 +1,186 @@
|
||||
+App = {
|
||||
Class = RealTimeApplication
|
||||
+Functions = {
|
||||
Class = ReferenceContainer
|
||||
+GAM1 = {
|
||||
Class = IOGAM
|
||||
InputSignals = {
|
||||
Counter = {
|
||||
DataSource = Timer
|
||||
Type = uint32
|
||||
Frequency = 1000
|
||||
}
|
||||
Time = {
|
||||
DataSource = Timer
|
||||
Type = uint32
|
||||
}
|
||||
}
|
||||
OutputSignals = {
|
||||
Counter = {
|
||||
DataSource = SyncDB
|
||||
Type = uint32
|
||||
}
|
||||
Time = {
|
||||
DataSource = DDB
|
||||
Type = uint32
|
||||
}
|
||||
}
|
||||
}
|
||||
+CGAM = {
|
||||
Class = ConstantGAM
|
||||
OutputSignals = {
|
||||
Test = {
|
||||
DataSource = DDB2
|
||||
Type = float32
|
||||
Default = 0.123
|
||||
}
|
||||
}
|
||||
}
|
||||
+GAM2 = {
|
||||
Class = IOGAM
|
||||
InputSignals = {
|
||||
Counter = {
|
||||
DataSource = TimerSlow
|
||||
Frequency = 1
|
||||
}
|
||||
Time = {
|
||||
DataSource = TimerSlow
|
||||
}
|
||||
Test = {
|
||||
DataSource = DDB2
|
||||
Type = float32
|
||||
}
|
||||
}
|
||||
OutputSignals = {
|
||||
Counter = {
|
||||
Type = uint32
|
||||
DataSource = Logger
|
||||
}
|
||||
Time = {
|
||||
Type = uint32
|
||||
DataSource = Logger
|
||||
}
|
||||
ConstOut = {
|
||||
DataSource = Logger
|
||||
Type = float32
|
||||
}
|
||||
}
|
||||
}
|
||||
+GAM3 = {
|
||||
Class = IOGAM
|
||||
InputSignals = {
|
||||
Counter = {
|
||||
Frequency = 1
|
||||
Samples = 100
|
||||
Type = uint32
|
||||
DataSource = SyncDB
|
||||
}
|
||||
}
|
||||
OutputSignals = {
|
||||
Counter = {
|
||||
DataSource = DDB3
|
||||
NumberOfElements = 100
|
||||
Type = uint32
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
+Data = {
|
||||
Class = ReferenceContainer
|
||||
DefaultDataSource = DDB
|
||||
+SyncDB = {
|
||||
Class = RealTimeThreadSynchronisation
|
||||
Timeout = 200
|
||||
Signals = {
|
||||
Counter = {
|
||||
Type = uint32
|
||||
}
|
||||
}
|
||||
}
|
||||
+Timer = {
|
||||
Class = LinuxTimer
|
||||
Signals = {
|
||||
Counter = {
|
||||
Type = uint32
|
||||
}
|
||||
Time = {
|
||||
Type = uint32
|
||||
}
|
||||
}
|
||||
}
|
||||
+TimerSlow = {
|
||||
Class = LinuxTimer
|
||||
Signals = {
|
||||
Counter = {
|
||||
Type = uint32
|
||||
}
|
||||
Time = {
|
||||
Type = uint32
|
||||
}
|
||||
}
|
||||
}
|
||||
+Logger = {
|
||||
Class = LoggerDataSource
|
||||
Signals = {
|
||||
CounterCopy = {
|
||||
Type = uint32
|
||||
}
|
||||
TimeCopy = {
|
||||
Type = uint32
|
||||
}
|
||||
}
|
||||
}
|
||||
+DDB = {
|
||||
AllowNoProducer = 1
|
||||
Class = GAMDataSource
|
||||
Signals = {
|
||||
Counter= {
|
||||
Type = uint32
|
||||
}
|
||||
}
|
||||
}
|
||||
+DDB2 = {
|
||||
AllowNoProducer = 1
|
||||
Class = GAMDataSource
|
||||
}
|
||||
+DDB3 = {
|
||||
AllowNoProducer = 1
|
||||
Class = GAMDataSource
|
||||
}
|
||||
+DAMS = {
|
||||
Class = TimingDataSource
|
||||
}
|
||||
}
|
||||
+States = {
|
||||
Class = ReferenceContainer
|
||||
+State1 = {
|
||||
Class = RealTimeState
|
||||
+Threads = {
|
||||
Class = ReferenceContainer
|
||||
+Thread1 = {
|
||||
Class = RealTimeThread
|
||||
Functions = {GAM1}
|
||||
}
|
||||
+Thread2 = {
|
||||
Class = RealTimeThread
|
||||
Functions = {GAM2 CGAM}
|
||||
}
|
||||
+Thread3 = {
|
||||
Class = RealTimeThread
|
||||
Functions = {GAM3}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+Scheduler = {
|
||||
Class = GAMScheduler
|
||||
TimingDataSource = DAMS
|
||||
}
|
||||
}
|
||||
|
||||
+DebugService = {
|
||||
Class = WebDebugService
|
||||
HttpPort = 8090
|
||||
}
|
||||
|
||||
@@ -42,7 +42,7 @@ public:
|
||||
assert(service.TraceSignal("Z", true) == 1);
|
||||
assert(service.ForceSignal("Z", "123") == 1);
|
||||
|
||||
uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1000000.0);
|
||||
uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1.0e9);
|
||||
service.ProcessSignal(service.signals[0], 4, ts);
|
||||
assert(val == 123);
|
||||
service.UnforceSignal("Z");
|
||||
@@ -119,6 +119,567 @@ public:
|
||||
service.HandleCommand("STEP 3", NULL_PTR(BasicTCPSocket*));
|
||||
assert(service.stepThreadFilter.Size() == 0u);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #4: ForceSignal overflow guard
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestForceSignalOversizeRejected() {
|
||||
printf("FIX #4: ForceSignal oversized signal rejected...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
// A 256-element float64 array requires 2048 bytes — exceeds forcedValue[1024].
|
||||
// RegisterSignal itself is fine; the overflow guard is in ForceSignal.
|
||||
float64 bigArray[256];
|
||||
memset(bigArray, 0, sizeof(bigArray));
|
||||
service.RegisterSignal(bigArray, Float64Bit, "Big.Array", 1, 256);
|
||||
|
||||
// ForceSignal must reject the request and return 0 matches applied.
|
||||
// (The signal IS found by alias but the size check must veto it.)
|
||||
uint32 forced = service.ForceSignal("Array", "1.0");
|
||||
assert(forced == 0); // rejected — not forced
|
||||
printf(" -> PASS: oversized force correctly rejected\n");
|
||||
|
||||
// A normal scalar float64 (8 bytes) must still be forceable.
|
||||
float64 scalarVal = 0.0;
|
||||
service.RegisterSignal(&scalarVal, Float64Bit, "Small.Scalar", 0, 1);
|
||||
uint32 forcedSmall = service.ForceSignal("Scalar", "3.14");
|
||||
assert(forcedSmall == 1); // accepted
|
||||
printf(" -> PASS: normal scalar force accepted\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #1: Streamer buffer bounds — Pop maxSize respected
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestStreamerPopMaxSize() {
|
||||
printf("FIX #1: TraceRingBuffer Pop respects maxSize...\n");
|
||||
|
||||
TraceRingBuffer rb;
|
||||
assert(rb.Init(4096));
|
||||
|
||||
// Push a 512-byte sample
|
||||
uint8 bigSample[512];
|
||||
memset(bigSample, 0xAB, sizeof(bigSample));
|
||||
assert(rb.Push(42u, 999u, bigSample, 512u));
|
||||
|
||||
// Pop with a maxSize smaller than the pushed size — must return false
|
||||
// and not overflow the destination buffer.
|
||||
uint8 smallBuf[64];
|
||||
uint32 id = 0, size = 0;
|
||||
uint64 ts = 0;
|
||||
bool ok = rb.Pop(id, ts, smallBuf, size, 64u);
|
||||
assert(!ok); // must be rejected, not a buffer overrun
|
||||
printf(" -> PASS: Pop with insufficient maxSize correctly rejected\n");
|
||||
|
||||
// After skipping the oversized sample the buffer is empty (only one
|
||||
// sample was pushed), so a second Pop must also return false.
|
||||
ok = rb.Pop(id, ts, smallBuf, size, 64u);
|
||||
assert(!ok);
|
||||
printf(" -> PASS: Ring buffer empty after oversized pop skipped\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #5: TraceRingBuffer Pop skips only the oversized entry, not all data
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestRingBufferSkipOversizedEntry() {
|
||||
printf("FIX #5: Oversized Pop skips only that entry, not all data...\n");
|
||||
|
||||
TraceRingBuffer rb;
|
||||
assert(rb.Init(4096));
|
||||
|
||||
// Push sample A (oversized for a 64-byte receiver)
|
||||
uint8 bigSample[512];
|
||||
memset(bigSample, 0xAA, sizeof(bigSample));
|
||||
assert(rb.Push(1u, 100u, bigSample, 512u));
|
||||
|
||||
// Push sample B (fits in 64-byte receiver)
|
||||
uint8 smallSample[4] = {0xDE, 0xAD, 0xBE, 0xEF};
|
||||
assert(rb.Push(2u, 200u, smallSample, 4u));
|
||||
|
||||
uint8 dst[64];
|
||||
uint32 id = 0, sz = 0;
|
||||
uint64 rts = 0;
|
||||
|
||||
// Pop with maxSize=64: sample A (512 bytes) must be skipped, not crash
|
||||
bool ok1 = rb.Pop(id, rts, dst, sz, 64u);
|
||||
assert(!ok1); // A skipped
|
||||
printf(" -> PASS: oversized sample A correctly skipped\n");
|
||||
|
||||
// Sample B (4 bytes) must still be readable — before the fix the whole
|
||||
// ring was discarded so this would also return false.
|
||||
bool ok2 = rb.Pop(id, rts, dst, sz, 64u);
|
||||
assert(ok2);
|
||||
assert(id == 2u);
|
||||
assert(sz == 4u);
|
||||
assert(dst[0] == 0xDE && dst[3] == 0xEF);
|
||||
printf(" -> PASS: subsequent sample B retrieved after A was skipped\n");
|
||||
|
||||
// Buffer should now be empty
|
||||
bool ok3 = rb.Pop(id, rts, dst, sz, 64u);
|
||||
assert(!ok3);
|
||||
printf(" -> PASS: no further samples (buffer empty)\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #3: signalPointers null guard in UpdateBrokers*
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestUpdateBrokersNullSignalPointers() {
|
||||
printf("FIX #3: UpdateBrokers* with null signalPointers — no crash...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
// Register a broker whose signalPointers is NULL but numSignals > 0.
|
||||
// Before the fix this dereferenced NULL → segfault.
|
||||
volatile bool active = false;
|
||||
Vec<uint32> indices;
|
||||
Vec<uint32> sizes;
|
||||
FastPollingMutexSem mutex;
|
||||
volatile bool anyBreak = false;
|
||||
Vec<uint32> breakIdx;
|
||||
service.RegisterBroker(NULL_PTR(DebugSignalInfo**), 1u,
|
||||
NULL_PTR(MemoryMapBroker*),
|
||||
&active, &indices, &sizes, &mutex,
|
||||
&anyBreak, &breakIdx);
|
||||
|
||||
// These must not crash
|
||||
service.UpdateBrokersActiveStatus();
|
||||
service.UpdateBrokersBreakStatus();
|
||||
printf(" -> PASS: no crash on null signalPointers\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #9: GetSignalValue — large array truncated at GET_VALUE_MAX_ELEMENTS
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestGetSignalValueTruncation() {
|
||||
printf("FIX #9: GetSignalValue large array capped at %u elements...\n",
|
||||
(unsigned)DebugService::GET_VALUE_MAX_ELEMENTS);
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
// Register a 512-element uint8 array (> GET_VALUE_MAX_ELEMENTS = 256)
|
||||
static uint8 bigBuf[512];
|
||||
for (uint32 i = 0; i < 512; i++) bigBuf[i] = (uint8)(i & 0xFF);
|
||||
service.RegisterSignal(bigBuf, UnsignedInteger8Bit, "Big.Signal", 1, 512);
|
||||
|
||||
// VALUE command with NULL client is a smoke test — must not crash or loop
|
||||
service.HandleCommand("VALUE Signal", NULL_PTR(BasicTCPSocket*));
|
||||
printf(" -> PASS: VALUE on large array completed without hang\n");
|
||||
|
||||
// Verify directly: nElem is capped before the byte limit
|
||||
// The signal has 512 uint8 elements; after fix nElem must be <= 256
|
||||
DebugSignalInfo *sig = service.signals[0];
|
||||
assert(sig->numberOfElements == 512u); // original unchanged
|
||||
// We can't call GetSignalValue with a real socket here, but we can
|
||||
// verify the constant is properly visible and correctly set
|
||||
assert(DebugService::GET_VALUE_MAX_ELEMENTS == 256u);
|
||||
printf(" -> PASS: GET_VALUE_MAX_ELEMENTS constant is %u\n",
|
||||
(unsigned)DebugService::GET_VALUE_MAX_ELEMENTS);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #6/#8: rate-limit and idle-timeout constants exist and are sane
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestServerConstantsSane() {
|
||||
printf("FIX #6/#8: server protection constants are valid...\n");
|
||||
assert(DebugService::CMD_RATE_LIMIT > 0u);
|
||||
assert(DebugService::CLIENT_IDLE_TIMEOUT_MS > 0u);
|
||||
// Idle timeout must be large enough to not disconnect a healthy client
|
||||
// in a single polling cycle (which is ~100 ms)
|
||||
assert(DebugService::CLIENT_IDLE_TIMEOUT_MS >= 1000u);
|
||||
printf(" -> PASS: CMD_RATE_LIMIT=%u, CLIENT_IDLE_TIMEOUT_MS=%u\n",
|
||||
(unsigned)DebugService::CMD_RATE_LIMIT,
|
||||
(unsigned)DebugService::CLIENT_IDLE_TIMEOUT_MS);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #7: MSG key overflow — oversized key line is skipped, no buffer overrun
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestMsgKeyBoundsCheck() {
|
||||
printf("FIX #7: MSG command oversized key is skipped without crash...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
// Build a MSG command whose key is 300 characters long (> keyBuf[256]).
|
||||
// Before the fix the Read() would overflow the 256-byte stack buffer.
|
||||
StreamString cmd = "MSG DebugService DummyFunc 0 ";
|
||||
for (uint32 i = 0; i < 300u; i++) cmd += 'K';
|
||||
cmd += "=value";
|
||||
|
||||
// Must not crash or assert
|
||||
service.HandleCommand(cmd, NULL_PTR(BasicTCPSocket*));
|
||||
printf(" -> PASS: oversized key handled without buffer overflow\n");
|
||||
|
||||
// A normal-length key should still be accepted (regression check)
|
||||
service.HandleCommand("MSG DebugService DummyFunc 0 NormalKey=NormalValue",
|
||||
NULL_PTR(BasicTCPSocket*));
|
||||
printf(" -> PASS: normal key not rejected by bounds check\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #10: Multi-segment TCP command buffering via inputBuffer
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestServerInputBuffering() {
|
||||
printf("FIX #10: Multi-segment TCP command buffering...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
// Verify inputBuffer is initialised empty
|
||||
assert(service.inputBuffer.Size() == 0u);
|
||||
printf(" -> PASS: inputBuffer initialised to empty\n");
|
||||
|
||||
// Simulate fragment 1 arriving: "FORCE Signal " (no newline yet)
|
||||
// In the real Server() this would be written via Read(); here we
|
||||
// directly manipulate the carry-over buffer (friend-class access).
|
||||
{
|
||||
(void)service.inputBuffer.Seek(service.inputBuffer.Size());
|
||||
uint32 f1Len = 13u; // length of "FORCE Signal "
|
||||
service.inputBuffer.Write("FORCE Signal ", f1Len);
|
||||
}
|
||||
assert(service.inputBuffer.Size() == 13u);
|
||||
printf(" -> PASS: partial command held in inputBuffer after fragment 1\n");
|
||||
|
||||
// Simulate fragment 2 completing the command: "123\n"
|
||||
{
|
||||
(void)service.inputBuffer.Seek(service.inputBuffer.Size());
|
||||
uint32 f2Len = 4u;
|
||||
service.inputBuffer.Write("123\n", f2Len);
|
||||
}
|
||||
|
||||
// Now scan inputBuffer for complete lines — mirrors the Server() loop
|
||||
const char8 *raw = service.inputBuffer.Buffer();
|
||||
uint32 total = (uint32)service.inputBuffer.Size();
|
||||
uint32 lineStart = 0u;
|
||||
uint32 cmdsFound = 0u;
|
||||
char8 cmdBuf[64];
|
||||
memset(cmdBuf, 0, sizeof(cmdBuf));
|
||||
|
||||
for (uint32 pos = 0u; pos < total; pos++) {
|
||||
if (raw[pos] != '\n') continue;
|
||||
uint32 len = pos - lineStart;
|
||||
if (len > 0u && raw[lineStart + len - 1u] == '\r') len--;
|
||||
if (len > 0u) {
|
||||
cmdsFound++;
|
||||
uint32 cp = (len < 63u) ? len : 63u;
|
||||
memcpy(cmdBuf, raw + lineStart, cp);
|
||||
cmdBuf[cp] = '\0';
|
||||
}
|
||||
lineStart = pos + 1u;
|
||||
}
|
||||
|
||||
assert(cmdsFound == 1u);
|
||||
// The two fragments assembled into "FORCE Signal 123"
|
||||
assert(strncmp(cmdBuf, "FORCE Signal 123", 16) == 0);
|
||||
printf(" -> PASS: fragmented command reassembled to '%s'\n", cmdBuf);
|
||||
|
||||
// Remainder after the last '\n' should be empty (no trailing bytes)
|
||||
assert(lineStart == total);
|
||||
printf(" -> PASS: no partial remainder after complete command\n");
|
||||
|
||||
// Verify INPUT_BUFFER_MAX constant is reachable
|
||||
assert(DebugService::INPUT_BUFFER_MAX > 4096u);
|
||||
printf(" -> PASS: INPUT_BUFFER_MAX=%u\n",
|
||||
(unsigned)DebugService::INPUT_BUFFER_MAX);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #11: Streamer monitored-signal Push protected by tracePushMutex
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestStreamerMonitoredPushSerialised() {
|
||||
printf("FIX #11: Streamer monitored-signal Push uses tracePushMutex...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
uint32 val = 0xDEADBEEF;
|
||||
service.RegisterSignal(&val, UnsignedInteger32Bit, "Mon.Val", 0, 1);
|
||||
assert(service.TraceSignal("Val", true) == 1);
|
||||
|
||||
uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() *
|
||||
HighResolutionTimer::Period() * 1000000.0);
|
||||
|
||||
// Push via ProcessSignal (uses tracePushMutex internally — broker path)
|
||||
service.ProcessSignal(service.signals[0], 4u, ts);
|
||||
|
||||
// Push directly via tracePushMutex (simulates the Streamer monitored-
|
||||
// signal path after FIX #11 — it now also acquires tracePushMutex so
|
||||
// both push paths are serialised with respect to each other).
|
||||
uint32 monId = 0x80000001u;
|
||||
uint32 monVal = 0x12345678u;
|
||||
service.tracePushMutex.FastLock();
|
||||
(void)service.traceBuffer.Push(monId, ts + 1u, &monVal, 4u);
|
||||
service.tracePushMutex.FastUnLock();
|
||||
|
||||
// Both samples must be present in FIFO order — if there were a race
|
||||
// one or both would be corrupt or missing.
|
||||
uint32 id = 0, sz = 0; uint64 rts = 0; uint8 dst[64];
|
||||
assert(service.traceBuffer.Pop(id, rts, dst, sz, 64u));
|
||||
assert(id == service.signals[0]->internalID);
|
||||
assert(sz == 4u);
|
||||
|
||||
assert(service.traceBuffer.Pop(id, rts, dst, sz, 64u));
|
||||
assert(id == monId);
|
||||
assert(sz == 4u);
|
||||
|
||||
assert(!service.traceBuffer.Pop(id, rts, dst, sz, 64u)); // buffer empty
|
||||
printf(" -> PASS: broker and monitored-signal pushes both retrieved in order\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// FIX #2: tracePushMutex — concurrent Push from two logical threads
|
||||
// (single-threaded simulation: verify no data corruption across two pushes
|
||||
// that would race without the mutex)
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestTracePushSerialised() {
|
||||
printf("FIX #2: Concurrent ProcessSignal serialised via tracePushMutex...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
uint32 valA = 0xAABBCCDD;
|
||||
uint32 valB = 0x11223344;
|
||||
service.RegisterSignal(&valA, UnsignedInteger32Bit, "P.A", 0, 1);
|
||||
service.RegisterSignal(&valB, UnsignedInteger32Bit, "P.B", 0, 1);
|
||||
assert(service.TraceSignal("A", true) == 1);
|
||||
assert(service.TraceSignal("B", true) == 1);
|
||||
|
||||
uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() *
|
||||
HighResolutionTimer::Period() * 1000000.0);
|
||||
|
||||
// Simulate two sequential calls as would happen from two RT threads.
|
||||
// Without tracePushMutex they could interleave and corrupt the ring.
|
||||
service.ProcessSignal(service.signals[0], 4, ts);
|
||||
service.ProcessSignal(service.signals[1], 4, ts + 1u);
|
||||
|
||||
// Both samples must be retrievable in FIFO order with correct IDs.
|
||||
uint32 id, size;
|
||||
uint64 rts;
|
||||
uint8 buf[64];
|
||||
uint32 id0 = service.signals[0]->internalID;
|
||||
uint32 id1 = service.signals[1]->internalID;
|
||||
|
||||
assert(service.traceBuffer.Pop(id, rts, buf, size, 64u));
|
||||
assert(id == id0);
|
||||
assert(size == 4u);
|
||||
|
||||
assert(service.traceBuffer.Pop(id, rts, buf, size, 64u));
|
||||
assert(id == id1);
|
||||
assert(size == 4u);
|
||||
|
||||
printf(" -> PASS: Both samples intact after serialised push\n");
|
||||
}
|
||||
// -------------------------------------------------------------------------
|
||||
// Fix #2 (Swap): UpdateBrokersActiveStatus publishes all active-signal
|
||||
// indices correctly when multiple signals are tracing/forcing.
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestUpdateBrokersSwapPublishesAllIndices() {
|
||||
printf("Fix #2 (Swap): UpdateBrokersActiveStatus publishes all active indices...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
uint32 v0 = 0, v1 = 0, v2 = 0;
|
||||
service.RegisterSignal(&v0, UnsignedInteger32Bit, "S.X", 0, 1);
|
||||
service.RegisterSignal(&v1, UnsignedInteger32Bit, "S.Y", 0, 1);
|
||||
service.RegisterSignal(&v2, UnsignedInteger32Bit, "S.Z", 0, 1);
|
||||
|
||||
// Enable tracing on X and Z (not Y)
|
||||
assert(service.TraceSignal("X", true) == 1);
|
||||
assert(service.TraceSignal("Z", true) == 1);
|
||||
|
||||
volatile bool active = false;
|
||||
Vec<uint32> indices;
|
||||
Vec<uint32> sizes;
|
||||
FastPollingMutexSem mutex;
|
||||
volatile bool anyBreak = false;
|
||||
Vec<uint32> breakIdx;
|
||||
DebugSignalInfo *ptrs[3] = {
|
||||
service.signals[0], service.signals[1], service.signals[2]
|
||||
};
|
||||
service.RegisterBroker(ptrs, 3u, NULL_PTR(MemoryMapBroker *),
|
||||
&active, &indices, &sizes, &mutex,
|
||||
&anyBreak, &breakIdx);
|
||||
|
||||
service.UpdateBrokersActiveStatus();
|
||||
|
||||
// After Swap the broker's activeIndices must hold exactly indices 0 and 2
|
||||
assert(active == true);
|
||||
assert(indices.Size() == 2u);
|
||||
// indices are in order of signal position in the broker (0 then 2)
|
||||
assert(indices[0] == 0u);
|
||||
assert(indices[1] == 2u);
|
||||
printf(" -> PASS: Swap correctly published 2 active indices out of 3\n");
|
||||
|
||||
// Disable one; Swap again — only index 0 should remain
|
||||
assert(service.TraceSignal("Z", false) == 1);
|
||||
service.UpdateBrokersActiveStatus();
|
||||
assert(indices.Size() == 1u);
|
||||
assert(indices[0] == 0u);
|
||||
printf(" -> PASS: After disabling Z, only index 0 remains\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Fix #3 (copy-before-unlock): break evaluation still works after the
|
||||
// copy-indices-then-unlock refactor in DebugBrokerHelper::Process().
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestBreakEvaluationAfterLockRelease() {
|
||||
printf("Fix #3 (copy-before-unlock): break evaluation works after lock release...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
uint32 val = 5u;
|
||||
service.RegisterSignal(&val, UnsignedInteger32Bit, "Brk.Val", 0, 1);
|
||||
|
||||
// Set break: pause when Val > 3
|
||||
assert(service.SetBreak("Val", BREAK_GT, 3.0) == 1u);
|
||||
service.UpdateBrokersBreakStatus();
|
||||
|
||||
volatile bool active = false;
|
||||
Vec<uint32> indices;
|
||||
Vec<uint32> sizes;
|
||||
FastPollingMutexSem mutex;
|
||||
volatile bool anyBreak = false;
|
||||
Vec<uint32> breakIdx;
|
||||
DebugSignalInfo *ptrs[1] = { service.signals[0] };
|
||||
service.RegisterBroker(ptrs, 1u, NULL_PTR(MemoryMapBroker *),
|
||||
&active, &indices, &sizes, &mutex,
|
||||
&anyBreak, &breakIdx);
|
||||
|
||||
// UpdateBrokersBreakStatus must propagate the break flag to the broker
|
||||
service.UpdateBrokersBreakStatus();
|
||||
assert(anyBreak == true);
|
||||
assert(breakIdx.Size() == 1u);
|
||||
|
||||
// Process() copies break indices, releases lock, evaluates break.
|
||||
// val = 5 > 3 — service must become paused.
|
||||
DebugBrokerHelper::Process(&service, ptrs, indices, sizes, mutex,
|
||||
&anyBreak, &breakIdx);
|
||||
assert(service.IsPaused());
|
||||
printf(" -> PASS: break condition triggered correctly via copy-before-unlock path\n");
|
||||
|
||||
// Reset; change value below threshold — must NOT pause.
|
||||
service.SetPaused(false);
|
||||
val = 1u;
|
||||
DebugBrokerHelper::Process(&service, ptrs, indices, sizes, mutex,
|
||||
&anyBreak, &breakIdx);
|
||||
assert(!service.IsPaused());
|
||||
printf(" -> PASS: value below threshold does not trigger break\n");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Fix #4 (atomic decimation): decimationFactor > 1 causes exactly one Push
|
||||
// after factor calls to ProcessSignal.
|
||||
// -------------------------------------------------------------------------
|
||||
static void TestDecimationCounterAtomic() {
|
||||
printf("Fix #4 (atomic decimation): one push per decimation factor...\n");
|
||||
ObjectRegistryDatabase::Instance()->Purge();
|
||||
|
||||
DebugService service;
|
||||
assert(service.traceBuffer.Init(1024 * 1024));
|
||||
ConfigurationDatabase cfg;
|
||||
cfg.Write("ControlPort", (uint32)0);
|
||||
cfg.Write("StreamPort", (uint32)0);
|
||||
cfg.Write("SuppressTimeoutLogs", (uint32)1);
|
||||
assert(service.Initialise(cfg));
|
||||
|
||||
uint32 val = 0x42424242u;
|
||||
service.RegisterSignal(&val, UnsignedInteger32Bit, "Dec.Val", 0, 1);
|
||||
// TraceSignal with decimation = 3
|
||||
assert(service.TraceSignal("Val", true, 3u) == 1u);
|
||||
assert(service.signals[0]->decimationFactor == 3u);
|
||||
|
||||
uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() *
|
||||
HighResolutionTimer::Period() * 1000000.0);
|
||||
|
||||
// Calls 1 and 2 — counter advances but no push
|
||||
service.ProcessSignal(service.signals[0], 4u, ts);
|
||||
service.ProcessSignal(service.signals[0], 4u, ts + 1u);
|
||||
|
||||
uint32 id, sz; uint64 rts; uint8 buf[64];
|
||||
bool hasData = service.traceBuffer.Pop(id, rts, buf, sz, 64u);
|
||||
assert(!hasData); // no sample yet
|
||||
printf(" -> PASS: no push after 2 calls with decimation=3\n");
|
||||
|
||||
// Call 3 — counter reaches factor, one push occurs
|
||||
service.ProcessSignal(service.signals[0], 4u, ts + 2u);
|
||||
hasData = service.traceBuffer.Pop(id, rts, buf, sz, 64u);
|
||||
assert(hasData);
|
||||
assert(id == service.signals[0]->internalID);
|
||||
assert(sz == 4u);
|
||||
printf(" -> PASS: exactly one push after %u calls with decimation=3\n", 3u);
|
||||
|
||||
// Call 4 and 5 — no push again
|
||||
service.ProcessSignal(service.signals[0], 4u, ts + 3u);
|
||||
service.ProcessSignal(service.signals[0], 4u, ts + 4u);
|
||||
hasData = service.traceBuffer.Pop(id, rts, buf, sz, 64u);
|
||||
assert(!hasData);
|
||||
printf(" -> PASS: no push for calls 4 and 5 (decimation reset)\n");
|
||||
|
||||
// Call 6 — second push
|
||||
service.ProcessSignal(service.signals[0], 4u, ts + 5u);
|
||||
hasData = service.traceBuffer.Pop(id, rts, buf, sz, 64u);
|
||||
assert(hasData);
|
||||
printf(" -> PASS: second push on call 6\n");
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
@@ -133,9 +694,26 @@ void timeout_handler(int sig) {
|
||||
int main() {
|
||||
signal(SIGALRM, timeout_handler);
|
||||
alarm(10);
|
||||
printf("--- MARTe2 Debug Suite COVERAGE V30 ---\n");
|
||||
printf("--- MARTe2 Debug Suite COVERAGE V34 ---\n");
|
||||
MARTe::TestTcpLogger();
|
||||
MARTe::DebugServiceTest::TestAll();
|
||||
printf("\nCOVERAGE V30 PASSED!\n");
|
||||
// FIX #1, #2, #4
|
||||
MARTe::DebugServiceTest::TestForceSignalOversizeRejected();
|
||||
MARTe::DebugServiceTest::TestStreamerPopMaxSize();
|
||||
MARTe::DebugServiceTest::TestTracePushSerialised();
|
||||
// FIX #3, #6, #7, #8, #9
|
||||
MARTe::DebugServiceTest::TestUpdateBrokersNullSignalPointers();
|
||||
MARTe::DebugServiceTest::TestGetSignalValueTruncation();
|
||||
MARTe::DebugServiceTest::TestServerConstantsSane();
|
||||
MARTe::DebugServiceTest::TestMsgKeyBoundsCheck();
|
||||
// FIX #5, #10, #11
|
||||
MARTe::DebugServiceTest::TestRingBufferSkipOversizedEntry();
|
||||
MARTe::DebugServiceTest::TestServerInputBuffering();
|
||||
MARTe::DebugServiceTest::TestStreamerMonitoredPushSerialised();
|
||||
// Fix #2 (Swap), Fix #3 (copy-before-unlock), Fix #4 (atomic decimation)
|
||||
MARTe::DebugServiceTest::TestUpdateBrokersSwapPublishesAllIndices();
|
||||
MARTe::DebugServiceTest::TestBreakEvaluationAfterLockRelease();
|
||||
MARTe::DebugServiceTest::TestDecimationCounterAtomic();
|
||||
printf("\nCOVERAGE V34 PASSED!\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
Executable
+67
@@ -0,0 +1,67 @@
|
||||
#!/bin/bash
|
||||
# run_debug_app.sh - Launch the MARTe2 Debugging Environment using standard MARTeApp.ex
|
||||
|
||||
# 1. Environment Setup
|
||||
if [ -f "./env.sh" ]; then
|
||||
source ./env.sh
|
||||
else
|
||||
echo "ERROR: env.sh not found. Ensure you are in the project root."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# 2. Paths
|
||||
MARTE_EX="${MARTe2_DIR}/Build/${TARGET}/App/MARTeApp.ex"
|
||||
BUILD_DIR="$(pwd)/Build/${TARGET}"
|
||||
|
||||
# Our plugin libraries
|
||||
WEB_DEBUG_LIB="${BUILD_DIR}/Components/Interfaces/WebDebugService/libWebDebugService.so"
|
||||
TCPLOGGER_LIB="${BUILD_DIR}/Components/Interfaces/TCPLogger/libTcpLogger.so"
|
||||
|
||||
# Component library base search path
|
||||
COMPONENTS_BUILD_DIR="${MARTe2_Components_DIR}/Build/${TARGET}/Components"
|
||||
|
||||
# DYNAMICALLY FIND ALL COMPONENT DIRS and add to LD_LIBRARY_PATH
|
||||
ALL_COMPONENT_DIRS=$(find "$COMPONENTS_BUILD_DIR" -type d)
|
||||
for dir in $ALL_COMPONENT_DIRS; do
|
||||
if ls "$dir"/*.so >/dev/null 2>&1; then
|
||||
export LD_LIBRARY_PATH="$dir:$LD_LIBRARY_PATH"
|
||||
fi
|
||||
done
|
||||
|
||||
# Ensure our build dir and core dir are included
|
||||
export LD_LIBRARY_PATH="${BUILD_DIR}/Components/Interfaces/WebDebugService:${BUILD_DIR}/Components/Interfaces/TCPLogger:${MARTe2_DIR}/Build/${TARGET}/Core:${LD_LIBRARY_PATH}"
|
||||
|
||||
# 3. Cleanup
|
||||
echo "Cleaning up lingering processes..."
|
||||
pkill -9 MARTeApp.ex
|
||||
sleep 1
|
||||
|
||||
# 4. Validate libraries exist
|
||||
for lib in "$WEB_DEBUG_LIB" "$TCPLOGGER_LIB"; do
|
||||
if [ ! -f "$lib" ]; then
|
||||
echo "ERROR: Library not found: $lib"
|
||||
echo "Run: make -f Makefile.gcc core"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
|
||||
# 5. Launch Application
|
||||
echo "Launching standard MARTeApp.ex with webdebug_test.cfg (WebDebugService on port 8090)..."
|
||||
# LD_PRELOAD ensures our classes are registered before the config is parsed.
|
||||
# MARTeApp.ex does not use dlopen for plugins — preloading is the standard approach.
|
||||
# All required component .so files are collected via the find loop into LD_PRELOAD too.
|
||||
PRELOAD_LIBS="${WEB_DEBUG_LIB}:${TCPLOGGER_LIB}"
|
||||
|
||||
# Collect any additional component .so files referenced by the config
|
||||
for lib in \
|
||||
"${COMPONENTS_BUILD_DIR}/DataSources/RealTimeThreadSynchronisation/RealTimeThreadSynchronisation.so" \
|
||||
"${COMPONENTS_BUILD_DIR}/DataSources/LinuxTimer/LinuxTimer.so" \
|
||||
"${COMPONENTS_BUILD_DIR}/DataSources/LoggerDataSource/LoggerDataSource.so" \
|
||||
"${COMPONENTS_BUILD_DIR}/GAMs/IOGAM/IOGAM.so"; do
|
||||
if [ -f "$lib" ]; then
|
||||
PRELOAD_LIBS="${PRELOAD_LIBS}:${lib}"
|
||||
fi
|
||||
done
|
||||
|
||||
export LD_PRELOAD="${PRELOAD_LIBS}"
|
||||
"$MARTE_EX" -f Test/Configurations/webdebug_test.cfg -l RealTimeLoader -s State1
|
||||
Reference in New Issue
Block a user