summaryrefslogtreecommitdiff
path: root/poc/web_swarm/orchestrator/c++/control.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'poc/web_swarm/orchestrator/c++/control.cpp')
-rw-r--r--poc/web_swarm/orchestrator/c++/control.cpp276
1 files changed, 276 insertions, 0 deletions
diff --git a/poc/web_swarm/orchestrator/c++/control.cpp b/poc/web_swarm/orchestrator/c++/control.cpp
new file mode 100644
index 0000000..6e2d7b7
--- /dev/null
+++ b/poc/web_swarm/orchestrator/c++/control.cpp
@@ -0,0 +1,276 @@
+#include "control.hpp"
+
+#include <kel/lbm/swarm/interpret.hpp>
+#include <kel/lbm/swarm/message.hpp>
+#include <kel/lbm/swarm/wire.hpp>
+
+#include <chrono>
+#include <iomanip>
+#include <sstream>
+#include <utility>
+
+namespace kel {
+namespace lbm {
+namespace swarm {
+
+namespace {
+
+uint64_t now_ms(){
+ using namespace std::chrono;
+ return static_cast<uint64_t>(
+ duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count());
+}
+
+} // namespace
+
+control::control(orchestrator &orch, control_config cfg)
+ : orch_{orch}, cfg_{std::move(cfg)}, registry_{cfg_.limits} {}
+
+control::~control(){
+ stop_heartbeat();
+}
+
+void control::on_event(std::function<void(const std::string &)> handler){
+ on_event_ = std::move(handler);
+}
+
+void control::emit(const std::string &line){
+ if(on_event_){
+ on_event_(line);
+ }
+}
+
+void control::attach(){
+ orch_.on_channel_open([this](const std::shared_ptr<session> &sess){
+ registry_.add_session(sess->id, now_ms());
+ emit("[" + sess->id + "] channel open, awaiting hello");
+ });
+
+ orch_.on_channel_closed([this](const std::shared_ptr<session> &sess){
+ auto rec = registry_.remove(sess->id);
+ if(rec){
+ emit("[" + sess->id + "] disconnected (" +
+ (rec->worker_id.empty() ? "unregistered" : rec->worker_id) + ")");
+ }
+ });
+
+ orch_.on_message([this](const std::shared_ptr<session> &sess,
+ const std::string &text){
+ handle_message(sess, text);
+ });
+}
+
+void control::handle_message(const std::shared_ptr<session> &sess,
+ const std::string &text){
+ auto eo_hdr = peek_header(text);
+ if(eo_hdr.is_error()){
+ emit("[" + sess->id + "] malformed control message, ignoring");
+ return;
+ }
+
+ const std::string type = eo_hdr.get_value().get<"type">().stl_string();
+ const uint64_t seq = eo_hdr.get_value().get<"seq">().get();
+
+ if(type == msg::hello){
+ handle_hello(sess, text);
+ return;
+ }
+
+ if(type == msg::pong){
+ auto eo = decode_message<sch::MsgPong>(text);
+ if(eo.is_error()){
+ emit("[" + sess->id + "] malformed pong, ignoring");
+ return;
+ }
+ registry_.record_pong(sess->id, seq,
+ eo.get_value().get<"sent_at_ms">().get(),
+ eo.get_value().get<"live">(), now_ms());
+ return;
+ }
+
+ if(type == msg::ready){
+ auto eo = decode_message<sch::MsgReady>(text);
+ if(eo.is_error()){
+ emit("[" + sess->id + "] malformed ready, ignoring");
+ return;
+ }
+ registry_.mark_ready(sess->id, eo.get_value().get<"live">(), now_ms());
+ emit("[" + sess->id + "] ready");
+ return;
+ }
+
+ if(type == msg::status){
+ auto eo = decode_message<sch::MsgStatus>(text);
+ if(eo.is_error()){
+ emit("[" + sess->id + "] malformed status, ignoring");
+ return;
+ }
+ const auto &live = eo.get_value().get<"live">();
+ registry_.update_live(sess->id, live, now_ms());
+
+ const std::string last_error = live.get<"last_error">().stl_string();
+ if(not last_error.empty()){
+ emit("[" + sess->id + "] reports error: " + last_error);
+ }
+ return;
+ }
+
+ emit("[" + sess->id + "] unknown message type '" + type + "', ignoring");
+}
+
+void control::handle_hello(const std::shared_ptr<session> &sess,
+ const std::string &text){
+ // Routing pass: the common capability fields are enough to learn the kind,
+ // and the backend section is skipped because it is not named here.
+ auto eo_route = decode_message<sch::MsgHello>(text);
+ if(eo_route.is_error()){
+ emit("[" + sess->id + "] hello missing its common fields, rejecting");
+ return;
+ }
+
+ const auto &common = eo_route.get_value().get<"capability">();
+ const std::string kind = common.get<"kind">().stl_string();
+ const std::string worker_id = common.get<"worker_id">().stl_string();
+ const std::string their_version = common.get<"schema_version">().stl_string();
+
+ if(their_version != schema_version){
+ // Caught deliberately rather than suffered as a decode failure later.
+ emit("[" + sess->id + "] schema version mismatch: worker says '" +
+ their_version + "', orchestrator is '" + std::string{schema_version} +
+ "' -- rejecting");
+ return;
+ }
+
+ uint64_t cells = 0u;
+ std::string summary;
+
+ if(kind == wkind::webgl2){
+ auto eo = decode_message<sch::MsgHelloWebGl2>(text);
+ if(eo.is_error()){
+ emit("[" + sess->id + "] hello claims webgl2 but has no usable "
+ "webgl2 section, rejecting");
+ return;
+ }
+ const auto &gl = eo.get_value().get<"capability">().get<"webgl2">();
+ cells = webgl2_capacity_cells(gl);
+ summary = webgl2_summary(gl);
+
+ } else if(kind == wkind::native){
+ auto eo = decode_message<sch::MsgHelloNative>(text);
+ if(eo.is_error()){
+ emit("[" + sess->id + "] hello claims native but has no usable "
+ "native section, rejecting");
+ return;
+ }
+ const auto &nat = eo.get_value().get<"capability">().get<"native">();
+ cells = native_capacity_cells(nat);
+ summary = native_summary(nat);
+
+ } else {
+ // Identifiable but unusable, which is a better outcome than a zeroed
+ // registration and is exactly what the routing decode is for.
+ emit("[" + sess->id + "] unsupported worker kind '" + kind +
+ "', rejecting");
+ return;
+ }
+
+ const uint64_t t = now_ms();
+ if(not registry_.mark_registered(sess->id, worker_id, kind, cells,
+ summary, t)){
+ return;
+ }
+
+ auto welcome = make_message<sch::MsgWelcome>(msg::welcome, sess->id, 0u);
+ welcome.get<"heartbeat_ms">().set(cfg_.heartbeat_ms);
+ welcome.get<"schema_version">().set(std::string{schema_version});
+
+ auto eo_out = encode_message<sch::MsgWelcome>(welcome);
+ if(eo_out.is_error()){
+ return;
+ }
+ orch_.send(sess, eo_out.get_value());
+
+ std::ostringstream line;
+ line << "[" << sess->id << "] registered " << worker_id
+ << " (" << kind << ") -- " << summary;
+ emit(line.str());
+}
+
+void control::start_heartbeat(){
+ if(running_.exchange(true)){
+ return;
+ }
+ ticker_ = std::thread{[this](){ heartbeat_loop(); }};
+}
+
+void control::stop_heartbeat(){
+ if(not running_.exchange(false)){
+ return;
+ }
+ tick_cv_.notify_all();
+ if(ticker_.joinable()){
+ ticker_.join();
+ }
+}
+
+void control::heartbeat_loop(){
+ while(running_.load()){
+ {
+ std::unique_lock<std::mutex> lock{tick_mutex_};
+ tick_cv_.wait_for(lock, std::chrono::milliseconds{cfg_.heartbeat_ms},
+ [this](){ return not running_.load(); });
+ }
+ if(not running_.load()){
+ break;
+ }
+
+ const uint64_t t = now_ms();
+
+ // The registry decides; this loop only carries out the decisions. In
+ // particular nothing is sent while its lock is held.
+ auto result = registry_.tick(t);
+
+ for(const auto &id : result.newly_stale){
+ emit("[" + id + "] stale, no response to the last " +
+ std::to_string(cfg_.limits.stale_after) + " pings");
+ }
+
+ for(const auto &rec : result.dropped){
+ emit("[" + rec.session_id + "] dropped after " +
+ std::to_string(cfg_.limits.drop_after) + " missed pings (" +
+ (rec.worker_id.empty() ? "unregistered" : rec.worker_id) + ")");
+
+ // Tear the transport down too, or the session lingers with nothing
+ // watching it.
+ if(auto sess = orch_.find_session(rec.session_id)){
+ if(sess->dc){
+ sess->dc->close();
+ }
+ if(sess->pc){
+ sess->pc->close();
+ }
+ }
+ }
+
+ for(const auto &target : result.to_ping){
+ auto sess = orch_.find_session(target.session_id);
+ if(not sess){
+ continue;
+ }
+
+ auto ping = make_message<sch::MsgPing>(msg::ping, target.session_id,
+ target.seq);
+ ping.get<"sent_at_ms">().set(t);
+
+ auto eo = encode_message<sch::MsgPing>(ping);
+ if(eo.is_error()){
+ continue;
+ }
+ orch_.send(sess, eo.get_value());
+ }
+ }
+}
+
+} // namespace swarm
+} // namespace lbm
+} // namespace kel