egutierrez
d01c7157a1
- ws_client.{h,cpp}: copia de registry_dashboard (RFC 6455 manual sobre TCP, sin TLS).
Background thread, reconnect con backoff, drain por frame.
- main.cpp: arranca WsClient apuntando a /api/ws/dagruns. Drain por frame.
Parse JSON snapshot/delta -> upsert g_live_runs por id.
Panel "Live (WS)" muestra estado conexion, watermarks runs/steps, lista live runs.
- CMakeLists.txt: ws_client.cpp en sources.
Build verificado. Tabs DAG List/Detail/Run Detail con data_table::render() en commits siguientes.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
76 lines
2.4 KiB
C++
76 lines
2.4 KiB
C++
#pragma once
|
|
// Minimal WebSocket client (RFC 6455, ws:// only, no TLS) tailored for the
|
|
// Monitor tab. Background thread does connect + handshake + read loop and
|
|
// pushes incoming text payloads into a thread-safe queue that the ImGui
|
|
// thread drains each frame.
|
|
//
|
|
// Issue 0086 — first consumer of WS in the C++ dashboards. If a second app
|
|
// needs WS later, extract this file to cpp/functions/network/ via
|
|
// fn-constructor.
|
|
|
|
#include <atomic>
|
|
#include <condition_variable>
|
|
#include <deque>
|
|
#include <functional>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
class WsClient {
|
|
public:
|
|
WsClient();
|
|
~WsClient();
|
|
|
|
// Non-blocking. Spawns background thread that connects to ws://host:port/path
|
|
// and keeps the connection alive with exponential reconnect backoff.
|
|
// Safe to call multiple times — second call is a no-op once running.
|
|
void start(const std::string& host, int port, const std::string& path);
|
|
|
|
// Stop the background thread and tear down the connection.
|
|
void stop();
|
|
|
|
// True while a WS connection is up and handshake completed.
|
|
bool is_connected() const { return state_.load() == State::Connected; }
|
|
|
|
// Epoch seconds of last received frame (for the live LED in the Monitor).
|
|
long long last_event_ts() const { return last_event_ts_.load(); }
|
|
|
|
// Drain at most `max` queued text payloads. Returns the number drained.
|
|
// Called once per frame from the render thread.
|
|
int drain(std::vector<std::string>& out, int max = 64);
|
|
|
|
// Send a text frame to the server. Returns true if queued for sending.
|
|
// Used to send {"watermark": N} commands on reconnect.
|
|
bool send_text(const std::string& payload);
|
|
|
|
private:
|
|
enum class State { Idle, Connecting, Connected, Backoff, Stopped };
|
|
|
|
void run();
|
|
bool connect_once();
|
|
bool handshake();
|
|
bool read_loop();
|
|
bool send_frame(int opcode, const std::string& payload);
|
|
|
|
std::string host_;
|
|
int port_ = 0;
|
|
std::string path_;
|
|
|
|
std::atomic<State> state_{State::Idle};
|
|
std::atomic<long long> last_event_ts_{0};
|
|
std::atomic<int> sock_{-1};
|
|
|
|
std::thread worker_;
|
|
std::atomic<bool> stop_flag_{false};
|
|
|
|
std::mutex in_mu_;
|
|
std::deque<std::string> in_queue_;
|
|
|
|
std::mutex out_mu_;
|
|
std::deque<std::string> out_queue_;
|
|
|
|
// For waking the writer side of read_loop when send_text is called.
|
|
std::condition_variable out_cv_;
|
|
};
|