Martino Ferrari
206 lines
8.1 KiB
C++
206 lines
8.1 KiB
C++
#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
|