Continue to implement the simulated transport

src/io/v3/address.hpp

@@ -25,4 +25,10 @@ struct Address {
   boost::uuids::uuid unique_id;
   boost::asio::ip::address last_known_ip;
   uint16_t last_known_port;
+
+  static Address TestAddress(uint16_t port) {
+    Address ret;
+    ret.last_known_port = port;
+    return ret;
+  }
 };

src/io/v3/simulator.hpp

@@ -32,10 +32,40 @@ struct SimulatorConfig {
   uint64_t rng_seed_;
 };
 
+class SimulatorTransport {
+ public:
+  SimulatorTransport(std::shared_ptr<SimulatorHandle> simulator_handle, Address address)
+      : simulator_handle_(simulator_handle), address_(address) {}
+
+  template <Message Request, Message Response>
+  ResponseFuture<Response> RequestTimeout(Address address, uint64_t request_id, Request request,
+                                          uint64_t timeout_microseconds) {
+    std::abort();
+  }
+
+  template <Message... Ms>
+  RequestResult<Ms...> ReceiveTimeout(uint64_t timeout_microseconds) {
+    std::abort();
+  }
+
+  template <Message M>
+  void Send(Address address, uint64_t request_id, M message) {
+    std::abort();
+  }
+
+  std::time_t Now() { std::abort(); }
+
+  bool ShouldShutDown() { std::abort(); }
+
+ private:
+  std::shared_ptr<SimulatorHandle> simulator_handle_;
+  Address address_;
+};
+
 class Simulator {
  public:
-  SimulatorTransport Register(Address address, bool is_server) {
-    return SimulatorTransport(simulator_handle_, address);
+  Io<SimulatorTransport> Register(Address address, bool is_server) {
+    return Io(SimulatorTransport(simulator_handle_, address), address);
   }
 
  private:

src/io/v3/simulator_handle.hpp

@@ -25,13 +25,3 @@ class SimulatorHandle {
   std::condition_variable cv_sim_;
   std::condition_variable cv_srv_;
 };
-
-class SimulatorTransport {
- public:
-  SimulatorTransport(std::shared_ptr<SimulatorHandle> simulator_handle, Address address)
-      : simulator_handle_(simulator_handle), address_(address) {}
-
- private:
-  std::shared_ptr<SimulatorHandle> simulator_handle_;
-  Address address_;
-};

src/io/v3/transport.hpp

@@ -27,8 +27,8 @@ concept Message = requires(T a, uint8_t *ptr, size_t len) {
   // These are placeholders and will be replaced
   // by some concept that identifies Thrift-generated
   // messages.
-  { a.serialize() } -> std::same_as<std::vector<uint8_t>>;
-  { T::deserialize(ptr, len) } -> std::same_as<T>;
+  { a.Serialize() } -> std::same_as<std::vector<uint8_t>>;
+  { T::Deserialize(ptr, len) } -> std::same_as<T>;
 };
 
 template <Message M>
@@ -38,6 +38,12 @@ struct MessageAndAddress {
   Address from;
 };
 
+template <Message M>
+using ResponseResult = BasicResult<Timeout, MessageAndAddress<M>>;
+
+template <Message M>
+using ResponseFuture = MgFuture<ResponseResult<M>>;
+
 template <Message... Ms>
 struct MessageVariantAndSenderAddress {
   std::variant<Ms...> message;
@@ -45,11 +51,8 @@ struct MessageVariantAndSenderAddress {
   Address from;
 };
 
-template <Message M>
-using RequestResult = BasicResult<MessageAndAddress<M>, Timeout>;
-
-template <Message M>
-using RequestFuture = MgFuture<RequestResult<M>>;
+template <Message... Ms>
+using RequestResult = BasicResult<Timeout, MessageVariantAndSenderAddress<Ms...>>;
 
 template <typename I>
 class Io {
@@ -61,14 +64,14 @@ class Io {
   }
 
   template <Message Request, Message Response>
-  RequestFuture<Response> RequestTimeout(Address address, Request request, uint64_t timeout_microseconds) {
+  ResponseFuture<Response> RequestTimeout(Address address, Request request, uint64_t timeout_microseconds) {
     uint64_t request_id = ++request_id_counter_;
     return implementation_.template RequestTimeout<Request, Response>(address, request_id, request,
                                                                       timeout_microseconds);
   }
 
   template <Message Request, Message Response>
-  RequestFuture<Response> RequestTimeout(Address address, Request request) {
+  ResponseFuture<Response> RequestTimeout(Address address, Request request) {
     uint64_t request_id = ++request_id_counter_;
     uint64_t timeout_microseconds = default_timeout_microseconds_;
     return implementation_.template RequestTimeout<Request, Response>(address, request_id, request,
@@ -76,12 +79,12 @@ class Io {
   }
 
   template <Message... Ms>
-  MessageVariantAndSenderAddress<Ms...> ReceiveTimeout(uint64_t timeout_microseconds) {
+  RequestResult<Ms...> ReceiveTimeout(uint64_t timeout_microseconds) {
     return implementation_.template ReceiveTimeout<Ms...>(timeout_microseconds);
   }
 
   template <Message... Ms>
-  MessageVariantAndSenderAddress<Ms...> ReceiveTimeout() {
+  RequestResult<Ms...> ReceiveTimeout() {
     uint64_t timeout_microseconds = default_timeout_microseconds_;
     return implementation_.template ReceiveTimeout<Ms...>(timeout_microseconds);
   }

tests/simulation/basic_request.cpp

@@ -17,15 +17,46 @@
 #include "io/v3/transport.hpp"
 #include "utils/logging.hpp"
 
+struct Request {
+  std::string data;
+
+  std::vector<uint8_t> Serialize() { return std::vector<uint8_t>(); }
+
+  static Request Deserialize(uint8_t *ptr, size_t len) { return Request{}; }
+};
+
+struct Response {
+  std::string data;
+
+  std::vector<uint8_t> Serialize() { return std::vector<uint8_t>(); }
+
+  static Response Deserialize(uint8_t *ptr, size_t len) { return Response{}; }
+};
+
 int main() {
   auto simulator = Simulator();
-  auto addr_1 = Address();
-  auto addr_2 = Address();
-  auto addr_3 = Address();
+  auto addr_1 = Address::TestAddress(1);
+  auto addr_2 = Address::TestAddress(2);
 
-  auto sim_transport_1 = simulator.Register(addr_1, true);
-  auto sim_transport_2 = simulator.Register(addr_2, true);
-  auto sim_transport_3 = simulator.Register(addr_3, true);
+  auto sim_io_1 = simulator.Register(addr_1, true);
+  auto sim_io_2 = simulator.Register(addr_2, true);
+
+  // send request
+  auto response_future = sim_io_1.RequestTimeout<Request, Response>(addr_2, Request{});
+
+  // receive request
+  RequestResult<Request> request_result = sim_io_2.ReceiveTimeout<Request>();
+  auto req_envelope = request_result.GetValue();
+  Request req = std::get<Request>(req_envelope.message);
+
+  auto srv_res = Response{req.data};
+
+  // send response
+  sim_io_2.Send(req_envelope.from, req_envelope.request_id, srv_res);
+
+  // receive response
+  auto response_result = response_future.Wait();
+  auto res = response_result.GetValue();
 
   return 0;
 }