martino/marte-debug
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented separate TCP logger service

Browse Source
This commit is contained in:
Martino Ferrari
2026-02-21 22:30:16 +01:00
parent 817d7276b7
commit 87b9ccebfd
12 changed files with 626 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
ARCHITECTURE.md
View File

@@ -25,7 +25,8 @@ The system uses three distinct channels:
### 3.3 Log Streaming (TCP Port 8082)
- **Protocol:** Real-time event streaming.
- **Role:** Forwards global `REPORT_ERROR` calls from the framework to the GUI client.
- **Service:** `TcpLogger` (Standalone component).
- **Role:** Forwards global `REPORT_ERROR` calls and `stdout` messages to the GUI client.
## 4. Component Diagram
```text
@@ -33,9 +34,11 @@ The system uses three distinct channels:
| |
+ <--- [ DebugBrokerWrapper ] (Registry Patch)
| |
[ DebugService ] <----------+
|
+---- (TCP 8080) ----> [ Rust GUI Client ]
+---- (UDP 8081) ----> [ (Oscilloscope) ]
+---- (TCP 8082) ----> [ (Log Terminal) ]
+---------------------+
| |
[ DebugService ] [ TcpLogger ]
| |
+--- (TCP 8080) ------+-----> [ Rust GUI Client ]
+--- (UDP 8081) ------+-----> [ (Oscilloscope) ]
+--- (TCP 8082) ------+-----> [ (Log Terminal) ]
```

31
Headers/DebugService.h
View File

@@ -17,23 +17,17 @@
#include "ClassRegistryDatabase.h"
#include "ErrorManagement.h"
#include "AdvancedErrorManagement.h"
#include "LoggerConsumerI.h"
#include "Threads.h"
#include "EventSem.h"
namespace MARTe {
struct LogEntry {
ErrorManagement::ErrorInformation info;
char8 description[MAX_ERROR_MESSAGE_SIZE];
};
struct SignalAlias {
StreamString name;
uint32 signalIndex;
};
class DebugService : public ReferenceContainer, public MessageI, public EmbeddedServiceMethodBinderI, public LoggerConsumerI {
class DebugService : public ReferenceContainer, public MessageI, public EmbeddedServiceMethodBinderI {
public:
CLASS_REGISTER_DECLARATION()
@@ -46,16 +40,12 @@ public:
void ProcessSignal(DebugSignalInfo* signalInfo, uint32 size);
virtual ErrorManagement::ErrorType Execute(ExecutionInfo & info);
virtual void ConsumeLogMessage(LoggerPage *logPage);
static void LogCallback(const ErrorManagement::ErrorInformation &errorInfo, const char8 * const errorDescription);
void InsertLogIntoQueue(LoggerPage *logPage);
bool IsPaused() const { return isPaused; }
void SetPaused(bool paused) { isPaused = paused; }
static bool GetFullObjectName(const Object &obj, StreamString &fullPath);
// Made public for integration tests and debug access
uint32 ForceSignal(const char8* name, const char8* valueStr);
uint32 UnforceSignal(const char8* name);
uint32 TraceSignal(const char8* name, bool enable, uint32 decimation = 1);
@@ -71,11 +61,9 @@ private:
ErrorManagement::ErrorType Server(ExecutionInfo & info);
ErrorManagement::ErrorType Streamer(ExecutionInfo & info);
ErrorManagement::ErrorType LogStreamer(ExecutionInfo & info);
uint16 controlPort;
uint16 streamPort;
uint16 logPort;
StreamString streamIP;
bool isServer;
bool suppressTimeoutLogs;
@@ -83,15 +71,13 @@ private:
BasicTCPSocket tcpServer;
BasicUDPSocket udpSocket;
BasicTCPSocket logServer;
class ServiceBinder : public EmbeddedServiceMethodBinderI {
public:
enum ServiceType { ServerType, StreamerType, LogStreamerType };
enum ServiceType { ServerType, StreamerType };
ServiceBinder(DebugService *parent, ServiceType type) : parent(parent), type(type) {}
virtual ErrorManagement::ErrorType Execute(ExecutionInfo & info) {
if (type == StreamerType) return parent->Streamer(info);
if (type == LogStreamerType) return parent->LogStreamer(info);
return parent->Server(info);
}
private:
@@ -101,15 +87,12 @@ private:
ServiceBinder binderServer;
ServiceBinder binderStreamer;
ServiceBinder binderLogStreamer;
SingleThreadService threadService;
SingleThreadService streamerService;
SingleThreadService logStreamerService;
ThreadIdentifier serverThreadId;
ThreadIdentifier streamerThreadId;
ThreadIdentifier logStreamerThreadId;
static const uint32 MAX_SIGNALS = 4096;
DebugSignalInfo signals[MAX_SIGNALS];
@@ -126,17 +109,7 @@ private:
BasicTCPSocket* activeClients[MAX_CLIENTS];
FastPollingMutexSem clientsMutex;
BasicTCPSocket* activeLogClients[MAX_CLIENTS];
FastPollingMutexSem logClientsMutex;
static const uint32 LOG_QUEUE_SIZE = 1024;
LogEntry logQueue[LOG_QUEUE_SIZE];
volatile uint32 logQueueRead;
volatile uint32 logQueueWrite;
EventSem logEvent;
static DebugService* instance;
static ErrorManagement::ErrorProcessFunctionType originalLogCallback;
};
}

66
Headers/TcpLogger.h Normal file
View File

@@ -0,0 +1,66 @@
#ifndef TCPLOGGER_H
#define TCPLOGGER_H
#include "LoggerConsumerI.h"
#include "ReferenceContainer.h"
#include "EmbeddedServiceMethodBinderI.h"
#include "BasicTCPSocket.h"
#include "SingleThreadService.h"
#include "FastPollingMutexSem.h"
#include "EventSem.h"
#include "StreamString.h"
namespace MARTe {
struct TcpLogEntry {
ErrorManagement::ErrorInformation info;
char8 description[MAX_ERROR_MESSAGE_SIZE];
};
/**
* @brief Logger consumer that publishes framework logs to TCP and stdout.
* @details Implements LoggerConsumerI to be used inside a LoggerService.
*/
class TcpLogger : public ReferenceContainer, public LoggerConsumerI, public EmbeddedServiceMethodBinderI {
public:
CLASS_REGISTER_DECLARATION()
TcpLogger();
virtual ~TcpLogger();
virtual bool Initialise(StructuredDataI & data);
/**
* @brief Implementation of LoggerConsumerI.
* Called by LoggerService.
*/
virtual void ConsumeLogMessage(LoggerPage *logPage);
/**
* @brief Worker thread method for TCP streaming.
*/
virtual ErrorManagement::ErrorType Execute(ExecutionInfo & info);
private:
void InsertLogIntoQueue(const ErrorManagement::ErrorInformation &info, const char8 * const description);
uint16 port;
BasicTCPSocket server;
static const uint32 MAX_CLIENTS = 8;
BasicTCPSocket* activeClients[MAX_CLIENTS];
FastPollingMutexSem clientsMutex;
SingleThreadService service;
ThreadIdentifier workerThreadId;
static const uint32 QUEUE_SIZE = 1024;
TcpLogEntry queue[QUEUE_SIZE];
volatile uint32 readIdx;
volatile uint32 writeIdx;
EventSem eventSem;
};
}
#endif

8
README.md
View File

@@ -39,5 +39,13 @@ To enable debugging in your application, add the following to your `.cfg`:
ControlPort = 8080
UdpPort = 8081
}
+LoggerService = {
Class = LoggerService
+DebugConsumer = {
Class = TcpLogger
Port = 8082
}
}
```
The suite automatically patches the registry to instrument your existing Brokers and Schedulers.

2
SPECS.md
View File

@@ -8,7 +8,7 @@ Implement a "Zero-Code-Change" observability layer for the MARTe2 real-time fram
- **FR-01 (Discovery):** Discover the full MARTe2 object hierarchy at runtime.
- **FR-02 (Telemetry):** Stream high-frequency signal data (verified up to 100Hz) to a remote client.
- **FR-03 (Forcing):** Allow manual override of signal values in memory during execution.
- **FR-04 (Logs):** Stream global framework logs to a dedicated terminal.
- **FR-04 (Logs):** Stream global framework logs to a dedicated terminal via a standalone `TcpLogger` service.
- **FR-05 (Execution Control):** Pause and resume the real-time execution threads via scheduler injection.
- **FR-06 (UI):** Provide a native, immediate-mode GUI for visualization (Oscilloscope).

156
Source/DebugService.cpp
View File

@@ -26,7 +26,6 @@
namespace MARTe {
DebugService* DebugService::instance = NULL_PTR(DebugService*);
ErrorManagement::ErrorProcessFunctionType DebugService::originalLogCallback = NULL_PTR(ErrorManagement::ErrorProcessFunctionType);
static void EscapeJson(const char8* src, StreamString &dst) {
if (src == NULL_PTR(const char8*)) return;
@@ -44,17 +43,14 @@ static void EscapeJson(const char8* src, StreamString &dst) {
CLASS_REGISTER(DebugService, "1.0")
DebugService::DebugService() :
ReferenceContainer(), EmbeddedServiceMethodBinderI(), LoggerConsumerI(),
ReferenceContainer(), EmbeddedServiceMethodBinderI(),
binderServer(this, ServiceBinder::ServerType),
binderStreamer(this, ServiceBinder::StreamerType),
binderLogStreamer(this, ServiceBinder::LogStreamerType),
threadService(binderServer),
streamerService(binderStreamer),
logStreamerService(binderLogStreamer)
streamerService(binderStreamer)
{
controlPort = 0;
streamPort = 8081;
logPort = 8082;
streamIP = "127.0.0.1";
numberOfSignals = 0;
numberOfAliases = 0;
@@ -63,40 +59,27 @@ DebugService::DebugService() :
isPaused = false;
for (uint32 i=0; i<MAX_CLIENTS; i++) {
activeClients[i] = NULL_PTR(BasicTCPSocket*);
activeLogClients[i] = NULL_PTR(BasicTCPSocket*);
}
logQueueRead = 0;
logQueueWrite = 0;
serverThreadId = InvalidThreadIdentifier;
streamerThreadId = InvalidThreadIdentifier;
logStreamerThreadId = InvalidThreadIdentifier;
}
DebugService::~DebugService() {
if (instance == this) {
if (ErrorManagement::errorMessageProcessFunction == &DebugService::LogCallback) {
ErrorManagement::SetErrorProcessFunction(originalLogCallback);
}
instance = NULL_PTR(DebugService*);
}
threadService.Stop();
streamerService.Stop();
logStreamerService.Stop();
tcpServer.Close();
udpSocket.Close();
logServer.Close();
for (uint32 i=0; i<MAX_CLIENTS; i++) {
if (activeClients[i] != NULL_PTR(BasicTCPSocket*)) {
activeClients[i]->Close();
delete activeClients[i];
}
if (activeLogClients[i] != NULL_PTR(BasicTCPSocket*)) {
activeLogClients[i]->Close();
delete activeLogClients[i];
}
}
}
@@ -116,10 +99,6 @@ bool DebugService::Initialise(StructuredDataI & data) {
(void)data.Read("UdpPort", streamPort);
}
if (!data.Read("LogPort", logPort)) {
(void)data.Read("TcpLogPort", logPort);
}
StreamString tempIP;
if (data.Read("StreamIP", tempIP)) {
streamIP = tempIP;
@@ -133,22 +112,14 @@ bool DebugService::Initialise(StructuredDataI & data) {
}
if (isServer) {
if (ErrorManagement::errorMessageProcessFunction != &DebugService::LogCallback) {
originalLogCallback = ErrorManagement::errorMessageProcessFunction;
ErrorManagement::SetErrorProcessFunction(&DebugService::LogCallback);
}
if (!traceBuffer.Init(1024 * 1024)) return false;
(void)logEvent.Create();
PatchRegistry();
ConfigurationDatabase threadData;
threadData.Write("Timeout", (uint32)1000);
threadService.Initialise(threadData);
streamerService.Initialise(threadData);
logStreamerService.Initialise(threadData);
if (!tcpServer.Open()) {
REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to open TCP Server Socket");
@@ -166,13 +137,6 @@ bool DebugService::Initialise(StructuredDataI & data) {
}
printf("[DebugService] UDP Streamer socket opened\n");
if (!logServer.Open()) {
REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to open Log Server Socket");
return false;
}
(void)logServer.Listen(logPort);
printf("[DebugService] Log Server listening on port %u\n", logPort);
if (threadService.Start() != ErrorManagement::NoError) {
REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to start Server thread");
return false;
@@ -181,11 +145,7 @@ bool DebugService::Initialise(StructuredDataI & data) {
REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to start Streamer thread");
return false;
}
if (logStreamerService.Start() != ErrorManagement::NoError) {
REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to start LogStreamer thread");
return false;
}
printf("[DebugService] All worker threads started.\n");
printf("[DebugService] Worker threads started.\n");
}
return true;
@@ -333,11 +293,6 @@ ErrorManagement::ErrorType DebugService::Server(ExecutionInfo & info) {
}
while (info.GetStage() == ExecutionInfo::MainStage) {
if (ErrorManagement::errorMessageProcessFunction != &DebugService::LogCallback) {
originalLogCallback = ErrorManagement::errorMessageProcessFunction;
ErrorManagement::SetErrorProcessFunction(&DebugService::LogCallback);
}
BasicTCPSocket *newClient = tcpServer.WaitConnection(1);
if (newClient != NULL_PTR(BasicTCPSocket *)) {
clientsMutex.FastLock();
@@ -388,72 +343,6 @@ ErrorManagement::ErrorType DebugService::Server(ExecutionInfo & info) {
return ErrorManagement::NoError;
}
ErrorManagement::ErrorType DebugService::LogStreamer(ExecutionInfo & info) {
if (info.GetStage() == ExecutionInfo::TerminationStage) return ErrorManagement::NoError;
if (info.GetStage() == ExecutionInfo::StartupStage) {
logStreamerThreadId = Threads::Id();
return ErrorManagement::NoError;
}
while (info.GetStage() == ExecutionInfo::MainStage) {
BasicTCPSocket *newClient = logServer.WaitConnection(1);
if (newClient != NULL_PTR(BasicTCPSocket *)) {
logClientsMutex.FastLock();
bool added = false;
for (uint32 i=0; i<MAX_CLIENTS; i++) {
if (activeLogClients[i] == NULL_PTR(BasicTCPSocket*)) {
activeLogClients[i] = newClient;
added = true;
break;
}
}
logClientsMutex.FastUnLock();
if (!added) {
newClient->Close();
delete newClient;
}
}
bool hadData = false;
for (uint32 b=0; b<50; b++) {
if (logQueueRead == logQueueWrite) break;
hadData = true;
uint32 idx = logQueueRead % LOG_QUEUE_SIZE;
LogEntry &entry = logQueue[idx];
StreamString level;
ErrorManagement::ErrorCodeToStream(entry.info.header.errorType, level);
StreamString packet;
packet.Printf("LOG %s %s\n", level.Buffer(), entry.description);
uint32 size = packet.Size();
logClientsMutex.FastLock();
for (uint32 j=0; j<MAX_CLIENTS; j++) {
if (activeLogClients[j] != NULL_PTR(BasicTCPSocket*)) {
uint32 s = size;
if (!activeLogClients[j]->Write(packet.Buffer(), s)) {
activeLogClients[j]->Close();
delete activeLogClients[j];
activeLogClients[j] = NULL_PTR(BasicTCPSocket*);
}
}
}
logClientsMutex.FastUnLock();
logQueueRead++;
}
if (!hadData) {
(void)logEvent.Wait(TimeoutType(100));
logEvent.Reset();
} else {
Sleep::MSec(1);
}
}
return ErrorManagement::NoError;
}
ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo & info) {
if (info.GetStage() == ExecutionInfo::TerminationStage) return ErrorManagement::NoError;
if (info.GetStage() == ExecutionInfo::StartupStage) {
@@ -884,43 +773,4 @@ void DebugService::ListNodes(const char8* path, BasicTCPSocket *client) {
}
}
void DebugService::ConsumeLogMessage(LoggerPage *logPage) {
}
void DebugService::LogCallback(const ErrorManagement::ErrorInformation &errorInfo, const char8 * const errorDescription) {
ThreadIdentifier current = Threads::Id();
if (instance != NULL_PTR(DebugService*)) {
StreamString levelStr;
ErrorManagement::ErrorCodeToStream(errorInfo.header.errorType, levelStr);
printf("[%s] %s\n", levelStr.Buffer(), errorDescription);
fflush(stdout);
bool isWorkerThread = false;
if (instance->serverThreadId != InvalidThreadIdentifier && current == instance->serverThreadId) isWorkerThread = true;
if (instance->streamerThreadId != InvalidThreadIdentifier && current == instance->streamerThreadId) isWorkerThread = true;
if (instance->logStreamerThreadId != InvalidThreadIdentifier && current == instance->logStreamerThreadId) isWorkerThread = true;
if (isWorkerThread) return;
if (instance->suppressTimeoutLogs && StringHelper::SearchString(errorDescription, "Timeout expired in recv()") != NULL_PTR(const char8*)) return;
LoggerPage tempPage;
tempPage.errorInfo = errorInfo;
StringHelper::Copy(tempPage.errorStrBuffer, errorDescription);
instance->InsertLogIntoQueue(&tempPage);
}
if (originalLogCallback) originalLogCallback(errorInfo, errorDescription);
}
void DebugService::InsertLogIntoQueue(LoggerPage *logPage) {
uint32 next = (logQueueWrite + 1) % LOG_QUEUE_SIZE;
if (next != logQueueRead) {
LogEntry &entry = logQueue[logQueueWrite % LOG_QUEUE_SIZE];
entry.info = logPage->errorInfo;
StringHelper::Copy(entry.description, logPage->errorStrBuffer);
logQueueWrite = next;
(void)logEvent.Post();
}
}
}

157
Source/TcpLogger.cpp Normal file
View File

@@ -0,0 +1,157 @@
#include "TcpLogger.h"
#include "ObjectRegistryDatabase.h"
#include "Threads.h"
#include "StringHelper.h"
#include "ConfigurationDatabase.h"
namespace MARTe {
CLASS_REGISTER(TcpLogger, "1.0")
TcpLogger::TcpLogger() :
ReferenceContainer(), LoggerConsumerI(), EmbeddedServiceMethodBinderI(),
service(*this)
{
port = 8082;
readIdx = 0;
writeIdx = 0;
workerThreadId = InvalidThreadIdentifier;
for (uint32 i=0; i<MAX_CLIENTS; i++) {
activeClients[i] = NULL_PTR(BasicTCPSocket*);
}
}
TcpLogger::~TcpLogger() {
service.Stop();
server.Close();
clientsMutex.FastLock();
for (uint32 i=0; i<MAX_CLIENTS; i++) {
if (activeClients[i] != NULL_PTR(BasicTCPSocket*)) {
activeClients[i]->Close();
delete activeClients[i];
activeClients[i] = NULL_PTR(BasicTCPSocket*);
}
}
clientsMutex.FastUnLock();
}
bool TcpLogger::Initialise(StructuredDataI & data) {
if (!ReferenceContainer::Initialise(data)) return false;
if (!data.Read("Port", port)) {
(void)data.Read("TcpPort", port);
}
(void)eventSem.Create();
ConfigurationDatabase threadData;
threadData.Write("Timeout", (uint32)1000);
if (!service.Initialise(threadData)) return false;
if (!server.Open()) return false;
if (!server.Listen(port)) {
return false;
}
printf("[TcpLogger] Listening on port %u\n", port);
if (service.Start() != ErrorManagement::NoError) {
return false;
}
return true;
}
void TcpLogger::ConsumeLogMessage(LoggerPage *logPage) {
if (logPage == NULL_PTR(LoggerPage*)) return;
// 1. Mirror to stdout
StreamString levelStr;
ErrorManagement::ErrorCodeToStream(logPage->errorInfo.header.errorType, levelStr);
printf("[%s] %s\n", levelStr.Buffer(), logPage->errorStrBuffer);
fflush(stdout);
// 2. Queue for TCP
InsertLogIntoQueue(logPage->errorInfo, logPage->errorStrBuffer);
}
void TcpLogger::InsertLogIntoQueue(const ErrorManagement::ErrorInformation &info, const char8 * const description) {
uint32 next = (writeIdx + 1) % QUEUE_SIZE;
if (next != readIdx) {
TcpLogEntry &entry = queue[writeIdx % QUEUE_SIZE];
entry.info = info;
StringHelper::Copy(entry.description, description);
writeIdx = next;
(void)eventSem.Post();
}
}
ErrorManagement::ErrorType TcpLogger::Execute(ExecutionInfo & info) {
if (info.GetStage() == ExecutionInfo::TerminationStage) return ErrorManagement::NoError;
if (info.GetStage() == ExecutionInfo::StartupStage) {
workerThreadId = Threads::Id();
return ErrorManagement::NoError;
}
while (info.GetStage() == ExecutionInfo::MainStage) {
// 1. Check for new connections
BasicTCPSocket *newClient = server.WaitConnection(1);
if (newClient != NULL_PTR(BasicTCPSocket *)) {
clientsMutex.FastLock();
bool added = false;
for (uint32 i=0; i<MAX_CLIENTS; i++) {
if (activeClients[i] == NULL_PTR(BasicTCPSocket*)) {
activeClients[i] = newClient;
added = true;
break;
}
}
clientsMutex.FastUnLock();
if (!added) {
newClient->Close();
delete newClient;
} else {
(void)newClient->SetBlocking(false);
}
}
// 2. Stream data to clients
bool hadData = false;
while (readIdx != writeIdx) {
hadData = true;
uint32 idx = readIdx % QUEUE_SIZE;
TcpLogEntry &entry = queue[idx];
StreamString level;
ErrorManagement::ErrorCodeToStream(entry.info.header.errorType, level);
StreamString packet;
packet.Printf("LOG %s %s\n", level.Buffer(), entry.description);
uint32 size = packet.Size();
clientsMutex.FastLock();
for (uint32 j=0; j<MAX_CLIENTS; j++) {
if (activeClients[j] != NULL_PTR(BasicTCPSocket*)) {
uint32 s = size;
if (!activeClients[j]->Write(packet.Buffer(), s)) {
activeClients[j]->Close();
delete activeClients[j];
activeClients[j] = NULL_PTR(BasicTCPSocket*);
}
}
}
clientsMutex.FastUnLock();
readIdx = (readIdx + 1) % QUEUE_SIZE;
}
if (!hadData) {
(void)eventSem.Wait(TimeoutType(100));
eventSem.Reset();
} else {
Sleep::MSec(1);
}
}
return ErrorManagement::NoError;
}
}

4
TUTORIAL.md
View File

@@ -9,7 +9,7 @@ First, start your application using the provided debug runner. This script launc
```bash
./run_debug_app.sh
```
*Note: You should see logs indicating the `DebugService` has started on port 8080.*
*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:
@@ -51,6 +51,6 @@ If you need to "freeze" the entire application to inspect a specific state:
- Click **▶ Resume** to restart the execution.
### Log Terminal
The bottom panel displays every `REPORT_ERROR` event from the C++ framework.
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.

7
Test/Configurations/debug_test.cfg
View File

@@ -1,4 +1,4 @@
$App = {
+App = {
Class = RealTimeApplication
+Functions = {
Class = ReferenceContainer
@@ -32,7 +32,7 @@ $App = {
DefaultDataSource = DDB
+Timer = {
Class = LinuxTimer
SleepTime = 1000000 // 1 second cycle to reduce log spam
SleepTime = 1000000
Signals = {
Counter = {
Type = uint32
@@ -96,6 +96,7 @@ $App = {
Class = LoggerService
CPUs = 0x1
+DebugConsumer = {
Class = DebugService
Class = TcpLogger
Port = 8082
}
}

99
Test/UnitTests/main.cpp
View File

@@ -1,35 +1,108 @@
#include <stdio.h>
#include <assert.h>
#include "DebugCore.h"
#include "DebugService.h"
#include "TcpLogger.h"
#include "ConfigurationDatabase.h"
#include "ObjectRegistryDatabase.h"
#include "StandardParser.h"
using namespace MARTe;
void TestRingBuffer() {
printf("Testing TraceRingBuffer...\n");
TraceRingBuffer rb;
assert(rb.Init(1024));
// Each entry is 4(ID) + 4(Size) + 4(Val) = 12 bytes.
// 100 entries = 1200 bytes.
assert(rb.Init(2048));
uint32 id = 42;
uint32 val = 12345678;
// Fill buffer to test wrap-around
uint32 id = 1;
uint32 val = 0xAAAAAAAA;
uint32 size = 4;
assert(rb.Push(id, &val, size));
assert(rb.Count() > 0);
for (int i=0; i<100; i++) {
id = i;
val = 0xBBBB0000 | i;
if (!rb.Push(id, &val, size)) {
printf("Failed at iteration %d\n", i);
assert(false);
}
}
uint32 poppedId = 0;
uint32 poppedVal = 0;
uint32 poppedSize = 0;
assert(rb.Count() == 100 * (4 + 4 + 4));
assert(rb.Pop(poppedId, &poppedVal, poppedSize, 4));
assert(poppedId == 42);
assert(poppedVal == 12345678);
assert(poppedSize == 4);
uint32 pId, pVal, pSize;
for (int i=0; i<100; i++) {
assert(rb.Pop(pId, &pVal, pSize, 4));
assert(pId == (uint32)i);
assert(pVal == (0xBBBB0000 | (uint32)i));
}
assert(rb.Count() == 0);
printf("TraceRingBuffer test passed.\n");
}
void TestSuffixMatch() {
printf("Testing SuffixMatch...\n");
DebugService service;
uint32 mock = 0;
service.RegisterSignal(&mock, UnsignedInteger32Bit, "App.Data.Timer.Counter");
// Should match
assert(service.TraceSignal("App.Data.Timer.Counter", true) == 1);
assert(service.TraceSignal("Timer.Counter", true) == 1);
assert(service.TraceSignal("Counter", true) == 1);
// Should NOT match
assert(service.TraceSignal("App.Timer", true) == 0);
assert(service.TraceSignal("unt", true) == 0);
printf("SuffixMatch test passed.\n");
}
void TestTcpLogger() {
printf("Testing TcpLogger...\n");
TcpLogger logger;
ConfigurationDatabase config;
config.Write("Port", (uint16)9999);
assert(logger.Initialise(config));
REPORT_ERROR_STATIC(ErrorManagement::Information, "Unit Test Log Message");
printf("TcpLogger basic test passed.\n");
}
void TestDebugServiceRegistration() {
printf("Testing DebugService Signal Registration...\n");
DebugService service;
uint32 val1 = 10;
float32 val2 = 20.0;
DebugSignalInfo* s1 = service.RegisterSignal(&val1, UnsignedInteger32Bit, "Signal1");
DebugSignalInfo* s2 = service.RegisterSignal(&val2, Float32Bit, "Signal2");
assert(s1 != NULL_PTR(DebugSignalInfo*));
assert(s2 != NULL_PTR(DebugSignalInfo*));
assert(s1->internalID == 0);
assert(s2->internalID == 1);
// Re-register same address
DebugSignalInfo* s1_alias = service.RegisterSignal(&val1, UnsignedInteger32Bit, "Signal1_Alias");
assert(s1_alias == s1);
printf("DebugService registration test passed.\n");
}
int main(int argc, char **argv) {
printf("Running MARTe2 Component Tests...\n");
printf("Running MARTe2 Debug Suite Unit Tests...\n");
TestRingBuffer();
TestDebugServiceRegistration();
TestSuffixMatch();
TestTcpLogger();
printf("\nALL UNIT TESTS PASSED!\n");
return 0;
}

155
Tools/gui_client/src/main.rs
View File

@@ -58,6 +58,15 @@ struct SignalMetadata {
sig_type: String,
}
#[derive(Clone)]
struct ConnectionConfig {
ip: String,
tcp_port: String,
udp_port: String,
log_port: String,
version: u64,
}
enum InternalEvent {
Log(LogEntry),
Discovery(Vec<Signal>),
@@ -65,6 +74,7 @@ enum InternalEvent {
CommandResponse(String),
NodeInfo(String),
Connected,
Disconnected,
InternalLog(String),
TraceRequested(String),
ClearTrace(String),
@@ -91,10 +101,9 @@ struct LogFilters {
}
struct MarteDebugApp {
#[allow(dead_code)]
connected: bool,
tcp_addr: String,
log_addr: String,
config: ConnectionConfig,
shared_config: Arc<Mutex<ConnectionConfig>>,
signals: Vec<Signal>,
app_tree: Option<TreeItem>,
@@ -131,34 +140,43 @@ impl MarteDebugApp {
let (tx_events, rx_events) = unbounded::<InternalEvent>();
let internal_tx = tx_events.clone();
let tcp_addr = "127.0.0.1:8080".to_string();
let log_addr = "127.0.0.1:8082".to_string();
let config = ConnectionConfig {
ip: "127.0.0.1".to_string(),
tcp_port: "8080".to_string(),
udp_port: "8081".to_string(),
log_port: "8082".to_string(),
version: 0,
};
let shared_config = Arc::new(Mutex::new(config.clone()));
let id_to_meta = Arc::new(Mutex::new(HashMap::new()));
let traced_signals = Arc::new(Mutex::new(HashMap::new()));
let id_to_meta_clone = id_to_meta.clone();
let traced_signals_clone = traced_signals.clone();
let shared_config_cmd = shared_config.clone();
let shared_config_log = shared_config.clone();
let shared_config_udp = shared_config.clone();
let tx_events_c = tx_events.clone();
thread::spawn(move || {
tcp_command_worker(tcp_addr, rx_cmd_internal, tx_events_c);
tcp_command_worker(shared_config_cmd, rx_cmd_internal, tx_events_c);
});
let tx_events_log = tx_events.clone();
thread::spawn(move || {
tcp_log_worker(log_addr, tx_events_log);
tcp_log_worker(shared_config_log, tx_events_log);
});
let tx_events_udp = tx_events.clone();
thread::spawn(move || {
udp_worker(8081, id_to_meta_clone, traced_signals_clone, tx_events_udp);
udp_worker(shared_config_udp, id_to_meta_clone, traced_signals_clone, tx_events_udp);
});
Self {
connected: false,
tcp_addr: "127.0.0.1:8080".to_string(),
log_addr: "127.0.0.1:8082".to_string(),
config,
shared_config,
signals: Vec::new(),
app_tree: None,
id_to_meta,
@@ -237,20 +255,36 @@ impl MarteDebugApp {
}
}
fn tcp_command_worker(addr: String, rx_cmd: Receiver<String>, tx_events: Sender<InternalEvent>) {
fn tcp_command_worker(shared_config: Arc<Mutex<ConnectionConfig>>, rx_cmd: Receiver<String>, tx_events: Sender<InternalEvent>) {
let mut current_version = 0;
let mut current_addr = String::new();
loop {
if let Ok(mut stream) = TcpStream::connect(&addr) {
// Check for config updates
{
let config = shared_config.lock().unwrap();
if config.version != current_version {
current_version = config.version;
current_addr = format!("{}:{}", config.ip, config.tcp_port);
}
}
if let Ok(mut stream) = TcpStream::connect(&current_addr) {
let _ = stream.set_nodelay(true);
let mut reader = BufReader::new(stream.try_clone().unwrap());
let _ = tx_events.send(InternalEvent::Connected);
let tx_events_inner = tx_events.clone();
let stop_flag = Arc::new(Mutex::new(false));
let stop_flag_reader = stop_flag.clone();
thread::spawn(move || {
let mut line = String::new();
let mut json_acc = String::new();
let mut in_json = false;
while reader.read_line(&mut line).is_ok() {
if *stop_flag_reader.lock().unwrap() { break; }
let trimmed = line.trim();
if trimmed.is_empty() { line.clear(); continue; }
@@ -291,21 +325,47 @@ fn tcp_command_worker(addr: String, rx_cmd: Receiver<String>, tx_events: Sender<
});
while let Ok(cmd) = rx_cmd.recv() {
// Check if config changed while connected
{
let config = shared_config.lock().unwrap();
if config.version != current_version {
*stop_flag.lock().unwrap() = true;
break; // Trigger reconnect
}
}
if stream.write_all(format!("{}\n", cmd).as_bytes()).is_err() {
break;
}
}
let _ = tx_events.send(InternalEvent::Disconnected);
}
thread::sleep(std::time::Duration::from_secs(2));
}
}
fn tcp_log_worker(addr: String, tx_events: Sender<InternalEvent>) {
fn tcp_log_worker(shared_config: Arc<Mutex<ConnectionConfig>>, tx_events: Sender<InternalEvent>) {
let mut current_version = 0;
let mut current_addr = String::new();
loop {
if let Ok(stream) = TcpStream::connect(&addr) {
{
let config = shared_config.lock().unwrap();
if config.version != current_version {
current_version = config.version;
current_addr = format!("{}:{}", config.ip, config.log_port);
}
}
if let Ok(stream) = TcpStream::connect(&current_addr) {
let mut reader = BufReader::new(stream);
let mut line = String::new();
while reader.read_line(&mut line).is_ok() {
// Check for config update
{
if shared_config.lock().unwrap().version != current_version {
break;
}
}
let trimmed = line.trim();
if trimmed.starts_with("LOG ") {
let parts: Vec<&str> = trimmed[4..].splitn(2, ' ').collect();
@@ -324,14 +384,39 @@ fn tcp_log_worker(addr: String, tx_events: Sender<InternalEvent>) {
}
}
fn udp_worker(port: u16, id_to_meta: Arc<Mutex<HashMap<u32, SignalMetadata>>>, traced_data: Arc<Mutex<HashMap<String, TraceData>>>, tx_events: Sender<InternalEvent>) {
if let Ok(socket) = UdpSocket::bind(format!("0.0.0.0:{}", port)) {
fn udp_worker(shared_config: Arc<Mutex<ConnectionConfig>>, id_to_meta: Arc<Mutex<HashMap<u32, SignalMetadata>>>, traced_data: Arc<Mutex<HashMap<String, TraceData>>>, tx_events: Sender<InternalEvent>) {
let mut current_version = 0;
let mut socket: Option<UdpSocket> = None;
loop {
let (ver, port) = {
let config = shared_config.lock().unwrap();
(config.version, config.udp_port.clone())
};
if ver != current_version || socket.is_none() {
current_version = ver;
socket = UdpSocket::bind(format!("0.0.0.0:{}", port)).ok();
if socket.is_none() {
let _ = tx_events.send(InternalEvent::InternalLog(format!("UDP Bind Error on port {}", port)));
thread::sleep(std::time::Duration::from_secs(5));
continue;
}
let _ = socket.as_ref().unwrap().set_read_timeout(Some(std::time::Duration::from_millis(500)));
}
let s = socket.as_ref().unwrap();
let mut buf = [0u8; 4096];
let start_time = std::time::Instant::now();
let mut total_packets = 0u64;
loop {
if let Ok(n) = socket.recv(&mut buf) {
// Check for config update
if shared_config.lock().unwrap().version != current_version {
break; // Re-bind
}
if let Ok(n) = s.recv(&mut buf) {
total_packets += 1;
if (total_packets % 100) == 0 {
let _ = tx_events.send(InternalEvent::UdpStats(total_packets));
@@ -450,9 +535,13 @@ impl eframe::App for MarteDebugApp {
self.udp_packets = count;
}
InternalEvent::Connected => {
self.connected = true;
let _ = self.tx_cmd.send("TREE".to_string());
let _ = self.tx_cmd.send("DISCOVER".to_string());
}
InternalEvent::Disconnected => {
self.connected = false;
}
}
}
@@ -484,6 +573,38 @@ impl eframe::App for MarteDebugApp {
ui.toggle_value(&mut self.show_bottom_panel, "📜 Logs");
ui.separator();
ui.heading("MARTe2 Debug Explorer");
ui.separator();
ui.menu_button("🔌 Connection", |ui| {
egui::Grid::new("conn_grid")
.num_columns(2)
.spacing([40.0, 4.0])
.show(ui, |ui| {
ui.label("Server IP:");
ui.text_edit_singleline(&mut self.config.ip);
ui.end_row();
ui.label("Control Port (TCP):");
ui.text_edit_singleline(&mut self.config.tcp_port);
ui.end_row();
ui.label("Telemetry Port (UDP):");
ui.text_edit_singleline(&mut self.config.udp_port);
ui.end_row();
ui.label("Log Port (TCP):");
ui.text_edit_singleline(&mut self.config.log_port);
ui.end_row();
});
ui.separator();
if ui.button("🔄 Apply & Reconnect").clicked() {
self.config.version += 1;
let mut shared = self.shared_config.lock().unwrap();
*shared = self.config.clone();
ui.close_menu();
}
});
let status_color = if self.connected { egui::Color32::GREEN } else { egui::Color32::RED };
ui.label(egui::RichText::new(if self.connected { "● Online" } else { "○ Offline" }).color(status_color));
ui.separator();
if ui.button("🔄 Refresh").clicked() {
let _ = self.tx_cmd.send("TREE".to_string());

150
app_output.log Normal file
View File

@@ -0,0 +1,150 @@
MARTe2 Environment Set (MARTe2_DIR=/home/martino/Projects/marte_debug/dependency/MARTe2)
MARTe2 Components Environment Set (MARTe2_Components_DIR=/home/martino/Projects/marte_debug/dependency/MARTe2-components)
Cleaning up lingering processes...
Launching standard MARTeApp.ex with debug_test.cfg...
[Debug - Bootstrap.cpp:79]: Arguments:
-f = "Test/Configurations/debug_test.cfg"
-l = "RealTimeLoader"
-s = "State1"
[Information - Bootstrap.cpp:207]: Loader parameters:
-f = "Test/Configurations/debug_test.cfg"
-l = "RealTimeLoader"
-s = "State1"
Loader = "RealTimeLoader"
Filename = "Test/Configurations/debug_
[Information - Loader.cpp:67]: DefaultCPUs set to 1
[Information - Loader.cpp:74]: SchedulerGranularity is 10000
[Debug - Loader.cpp:189]: Purging ObjectRegistryDatabase with 0 objects
[Debug - Loader.cpp:192]: Purge ObjectRegistryDatabase. Number of objects left: 0
[Information - LinuxTimer.cpp:117]: SleepNature was not set. Using Default.
[Information - LinuxTimer.cpp:127]: Phase was not configured, using default 0
[Warning - LinuxTimer.cpp:164]: ExecutionMode not specified using: IndependentThread
[Warning - LinuxTimer.cpp:185]: CPUMask not specified using: 255
[Warning - LinuxTimer.cpp:191]: StackSize not specified using: 262144
[Information - LinuxTimer.cpp:236]: No timer provider specified. Falling back to HighResolutionTimeProvider
[Information - HighResolutionTimeProvider.cpp:163]: Sleep nature was not specified, falling back to default (Sleep::NoMore mode)
[Information - HighResolutionTimeProvider.cpp:61]: Inner initialization succeeded
[Information - LinuxTimer.cpp:267]: Backward compatibility parameters injection unnecessary
[Information - RealTimeThread.cpp:190]: No CPUs defined for the RealTimeThread Thread1
[Information - RealTimeThread.cpp:193]: No StackSize defined for the RealTimeThread Thread1
[DebugService] TCP Server listening on port 8080
[DebugService] UDP Streamer socket opened
[ParametersError - StringHelper.cpp:60]: Error: invalid input arguments
[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[ParametersError - StringHelper.cpp:60]: Error: invalid input arguments
[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[DebugService] Worker threads started.
[TcpLogger] Listening on port 8082
[ParametersError - StringHelper.cpp:60]: Error: invalid input arguments
[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[Information] LoaderPostInit not set
[Information] Going to rtAppBuilder.ConfigureAfterInitialisation()
[Information] Going to InitialiseSignalsDatabase
[Information] Going to FlattenSignalsDatabases
[Information] Caching introspection signals
[Information] Flattening functions input signals
[Debug] Updating the signal database
[Debug] Finished updating the signal database
[Information] Flattening functions output signals
[Debug] Updating the signal database
[Debug] Finished updating the signal database
[Information] Flattening data sources signals
[Debug] Updating the signal database
[Debug] Finished updating the signal database
[Debug] Updating the signal database
[Debug] Finished updating the signal database
[Debug] Updating the signal database
[Debug] Finished updating the signal database
[Information] Going to VerifyDataSourcesSignals
[Debug] Updating the signal database
[Information] Verifying signals for Timer
[Debug] Finished updating the signal database
[Information] Going to ResolveStates
[Information] Resolving state State1
[Information] Resolving thread container Threads
[Information] Resolving thread State1.Thread1
[Information] Resolving GAM1
[Information] Going to ResolveDataSources
[Information] Verifying signals for Logger
[Information] Resolving for function GAM1 [idx: 0]
[Information] Resolving 2 signals
[Information] Resolving 2 signals
[Information] Verifying signals for DDB
[Information] Verifying signals for DAMS
[Information] Going to VerifyConsumersAndProducers
[Information] Started application in state State1
[Information] Application starting
[Information] Verifying consumers and producers for Timer
[Information] Verifying consumers and producers for Logger
[Information] Verifying consumers and producers for DDB
[Information] Verifying consumers and producers for DAMS
[Information] Going to CleanCaches
[Debug] Purging dataSourcesIndexesCache. Number of children:3
[Debug] Purging functionsIndexesCache. Number of children:1
[Debug] Purging dataSourcesSignalIndexCache. Number of children:3
[Debug] Purging dataSourcesFunctionIndexesCache. Number of children:1
[Debug] Purging functionsMemoryIndexesCache. Number of children:2
[Debug] Purged functionsMemoryIndexesCache. Number of children:0
[Debug] Purged cachedIntrospections. Number of children:0
[Information] Going to rtAppBuilder.PostConfigureDataSources()
[Information] Going to rtAppBuilder.PostConfigureFunctions()
[Information] Going to rtAppBuilder.Copy()
[Information] Going to AllocateGAMMemory
[Information] Going to AllocateDataSourceMemory()
[Information] Going to AddBrokersToFunctions
[Information] Creating broker MemoryMapSynchronisedInputBroker for GAM1 and signal Counter(0)
[Information] Creating broker MemoryMapInputBroker for GAM1 and signal Time(1)
[Information] Getting input brokers for Timer
[Information] Getting output brokers for Timer
[Information] Getting input brokers for Logger
[Information] Getting output brokers for Logger
[Information] Getting input brokers for DDB
[Information] Getting output brokers for DDB
[Information] Getting input brokers for DAMS
[Information] Getting output brokers for DAMS
[Information] Going to FindStatefulDataSources
[Information] Going to configure scheduler
[Information] Preparing state State1
[Information] Frequency found = 1.000000
[Information] Frequency found = 1.000000
[Information] The timer will be set using a frequency of 1.000000 Hz
[ParametersError] Error: invalid input arguments
[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[Warning] Failed to change the thread priority (likely due to insufficient permissions)
[Information] LinuxTimer::Prepared = true
[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
[Warning] Failed to change the thread priority (likely due to insufficient permissions)
[Information] Time [0:0]:0
[Information] Time [0:0]:2000000
[Information] Time [0:0]:3000000
[Information] Time [0:0]:4000000
[Information] Time [0:0]:5000000
[Information] Time [0:0]:6000000
[Information] Time [0:0]:7000000
[Information] Time [0:0]:8000000
[Information] Time [0:0]:9000000
[Information] Time [0:0]:10000000
[Information] Time [0:0]:11000000
[Information] Time [0:0]:12000000
[Information] Time [0:0]:13000000
[Information] Time [0:0]:14000000
[Information] Time [0:0]:15000000
[Information] Time [0:0]:16000000
[Information] Time [0:0]:17000000
[Information] Time [0:0]:18000000
[Information] Time [0:0]:19000000
[Information] Time [0:0]:20000000
[Information] Time [0:0]:21000000
[Information] Time [0:0]:22000000
[Information] Time [0:0]:23000000
[Information] Time [0:0]:24000000
[Information] Time [0:0]:25000000
[Information] Time [0:0]:26000000
[Information] Time [0:0]:27000000
[Information] Time [0:0]:28000000