Initial Release

test/debug.cpp

@@ -0,0 +1,196 @@
+#include "tests.hpp"
+
+#include "thespian/handle.hpp"
+#include <thespian/debug.hpp>
+#include <thespian/instance.hpp>
+#include <thespian/socket.hpp>
+#include <thespian/tcp.hpp>
+#include <thespian/trace.hpp>
+
+#include <array>
+#include <cstring>
+#include <memory>
+
+using cbor::buffer;
+using cbor::extract;
+using std::make_shared;
+using std::make_unique;
+using std::move;
+using std::string;
+using std::string_view;
+using std::stringstream;
+using std::unique_ptr;
+using thespian::context;
+using thespian::env;
+using thespian::env_t;
+using thespian::error;
+using thespian::exit;
+using thespian::expected;
+using thespian::handle;
+using thespian::link;
+using thespian::ok;
+using thespian::receive;
+using thespian::result;
+using thespian::self;
+using thespian::socket;
+using thespian::spawn_link;
+using thespian::trap;
+using thespian::unexpected;
+using thespian::tcp::connector;
+
+namespace {
+
+struct debuggee {
+  auto receive(const handle &from, const buffer &m) {
+    if (m("ping")) {
+      return from.send("pong");
+    }
+    if (m("shutdown"))
+      return exit("debuggee_shutdown");
+    return unexpected(m);
+    return ok();
+  }
+
+  static auto start() -> expected<handle, error> {
+    return spawn_link(
+        [=]() {
+          ::receive([p{make_shared<debuggee>()}](auto from, auto m) {
+            return p->receive(move(from), move(m));
+          });
+          return ok();
+        },
+        "debuggee");
+  }
+};
+
+struct controller {
+  static constexpr string_view tag{"debug_test_controller"};
+  handle debug_tcp;
+  handle debuggee_;
+  connector c;
+  unique_ptr<thespian::socket> s;
+  size_t pong_count{};
+  bool success_{false};
+  string prev_buf;
+
+  explicit controller(handle d, handle debuggee)
+      : debug_tcp{std::move(d)}, debuggee_{std::move(debuggee)},
+        c{connector::create(tag)} {
+    trap(true);
+  }
+
+  auto receive(const handle & /*from*/, const buffer &m) {
+    int fd{};
+    string buf;
+    int written{};
+    int err{};
+    string_view err_msg{};
+
+    if (m("pong")) {
+      pong_count++;
+      if (pong_count == 2)
+        c.connect(in6addr_loopback, 4242);
+    } else if (m("connector", tag, "connected", extract(fd))) {
+      s = make_unique<thespian::socket>(socket::create(tag, fd));
+      s->read();
+      s->write("\n");
+      s->write("debuggee [\"ping\"]\n");
+    } else if (m("socket", tag, "read_error", extract(err), extract(err_msg))) {
+      return exit("read_error", err_msg);
+    } else if (m("socket", tag, "read_complete", extract(buf))) {
+      if (buf.empty()) {
+        s->close();
+        return ok();
+      }
+      s->read();
+      buf.swap(prev_buf);
+      buf.append(prev_buf);
+      string::size_type pos{};
+      while (not buf.empty() and pos != string::npos) {
+        pos = buf.find_first_of('\n');
+        if (pos != string::npos) {
+          auto ret = self().send("dispatch", string(buf.data(), pos));
+          if (not ret)
+            return ret;
+          buf.erase(0, pos + 1);
+        }
+      }
+      prev_buf = buf;
+    } else if (m("dispatch", extract(buf))) {
+      if (buf == "debuggee [\"pong\"]") {
+        s->write("debuggee [\"shutdown\"]\n");
+      }
+    } else if (m("socket", tag, "write_error", extract(err),
+                 extract(err_msg))) {
+      return exit("write_error", err_msg);
+    } else if (m("socket", tag, "write_complete", extract(written))) {
+      ;
+    } else if (m("socket", tag, "closed")) {
+      if (success_)
+        return exit("success");
+      auto ret = debuggee_.send("shutdown");
+      if (not ret)
+        return ret;
+      return exit("closed");
+    } else if (m("exit", "debuggee_shutdown")) {
+      success_ = true;
+      s->close();
+    } else if (m("connector", tag, "cancelled"))
+      return exit("cancelled");
+    else if (m("connector", tag, "error", extract(buf)))
+      return exit("connect_error", buf);
+
+    else
+      return unexpected(m);
+    return ok();
+  }
+};
+
+} // namespace
+
+auto debug(context &ctx, bool &result, env_t env_) -> ::result {
+  thespian::debug::enable(ctx);
+  return to_result(ctx.spawn_link(
+      [&ctx]() {
+        link(env().proc("log"));
+        auto ret = thespian::debug::tcp::create(ctx, 4242, "");
+        if (not ret)
+          return to_result(ret);
+        auto debug_tcp = ret.value();
+        ret = spawn_link(
+            [&ctx, debug_tcp]() {
+              trap(true);
+              ::receive([&ctx, debug_tcp](auto, auto /*m*/) -> ::result {
+                auto ret = debug_tcp.send("shutdown");
+                if (not ret)
+                  return ret;
+                thespian::debug::disable(ctx);
+                return exit();
+              });
+              return ok();
+            },
+            "controller_guard");
+        if (not ret)
+          return to_result(ret);
+        auto ret2 = debug_tcp.send("ping");
+        if (not ret2)
+          return ret2;
+        ret = debuggee::start();
+        if (not ret)
+          return to_result(ret);
+        auto debuggee = ret.value();
+        ret2 = debuggee.send("ping");
+        if (not ret2)
+          return ret2;
+        receive([p{make_shared<controller>(debug_tcp, debuggee)}](auto from,
+                                                                  auto m) {
+          return p->receive(move(from), move(m));
+        });
+        return ok();
+      },
+      [&](auto s) {
+        if (s == "success")
+          result = true;
+      },
+      "debug", move(env_)));
+}