app: implement simple echo

4 files changed, 105 insertions, 13 deletions

diff --git a/ttwhy/io.cppm b/ttwhy/io.cppm
new file mode 100644
index 0000000..cbd3902
--- /dev/null
+++ b/ttwhy/io.cppm
@@ -0,0 +1,84 @@
+module;
+
+#include <asio.hpp>
+
+#include <expected>
+#include <format>
+#include <string>
+
+export module ttwhy:io;
+
+namespace ttwhy::io
+{
+
+  export template<typename Stream>
+  auto handle_signals(Stream & stream) -> asio::awaitable<std::error_code>
+  {
+    auto executor = co_await asio::this_coro::executor;
+    auto signals = asio::signal_set{executor, SIGINT, SIGTERM};
+
+    auto [error, signal] = co_await signals.async_wait(asio::as_tuple(asio::use_awaitable));
+    if (!error)
+    {
+      auto message = std::format("Received signal {}, exiting ...\n", signal);
+      co_await asio::async_write(stream, asio::buffer(message), asio::use_awaitable);
+    }
+    co_return error;
+  }
+
+  export template<typename InputStream, typename ErrorStream>
+  auto read(InputStream & input_stream, ErrorStream & error_stream)
+      -> asio::awaitable<std::expected<std::string, asio::error_code>>
+  {
+    auto data = std::string{15, '\0'};
+
+    auto [error, read] = co_await input_stream.async_read_some(asio::buffer(data), asio::as_tuple(asio::use_awaitable));
+
+    if (error)
+    {
+      auto message = std::format("{}, exiting ...\n", error.message());
+      co_await asio::async_write(error_stream, asio::buffer(message), asio::use_awaitable);
+      co_return std::unexpected{error};
+    }
+
+    data.resize(read);
+    co_return data;
+  }
+
+  export template<typename OutputStream, typename ErrorStream>
+  auto write(std::string const & string, OutputStream & output_stream, ErrorStream & error_stream)
+      -> asio::awaitable<asio::error_code>
+  {
+    auto [error, written] =
+        co_await asio::async_write(output_stream, asio::buffer(string), asio::as_tuple(asio::use_awaitable));
+
+    if (error)
+    {
+      auto message = std::format("{}, exiting ...\n", error.message());
+      co_await asio::async_write(error_stream, asio::buffer(message), asio::use_awaitable);
+    }
+
+    co_return error;
+  }
+
+  export template<typename InputStream, typename OutputStream, typename ErrorStream>
+  auto echo(InputStream & input_stream, OutputStream & output_stream, ErrorStream & error_stream)
+      -> asio::awaitable<asio::error_code>
+  {
+    while (true)
+    {
+      auto input = co_await read(input_stream, error_stream);
+      if (!input.has_value())
+      {
+        co_return input.error();
+      }
+
+      auto write_error = co_await write(input.value(), output_stream, error_stream);
+      if (write_error)
+      {
+        co_return write_error;
+      }
+    }
+  }
+
+}  // namespace ttwhy::io
diff --git a/ttwhy/lib.cppm b/ttwhy/lib.cppm
index fe7486f..14e0d5c 100644
--- a/ttwhy/lib.cppm
+++ b/ttwhy/lib.cppm
@@ -1,3 +1,4 @@
 export module ttwhy;
 
+export import :io;
 export import :scoped_attributes;
diff --git a/ttwhy/main.cpp b/ttwhy/main.cpp
index c210bee..649d01d 100644
--- a/ttwhy/main.cpp
+++ b/ttwhy/main.cpp
@@ -1,23 +1,30 @@
 #include <asio.hpp>
+#include <asio/experimental/awaitable_operators.hpp>
+
 #include <stdio.h>
 
+#include <format>
+
 import ttwhy;
 
-auto handle_signals(asio::cancellation_signal & cancellation_signal) -> asio::awaitable<void>
+auto app(int in, int out, int error) -> asio::awaitable<void>
 {
-  co_await asio::this_coro::reset_cancellation_state(asio::disable_cancellation());
-  co_await asio::this_coro::throw_if_cancelled(false);
+  using namespace asio::experimental::awaitable_operators;
 
   auto executor = co_await asio::this_coro::executor;
-  auto signals = asio::signal_set{executor, SIGINT, SIGTERM};
-  auto log_stream = asio::posix::stream_descriptor{executor, fileno(stdout)};
 
-  auto [error, signal] = co_await signals.async_wait(asio::as_tuple(asio::use_awaitable));
+  auto input_stream = asio::posix::stream_descriptor{executor, in};
+  auto output_stream = asio::posix::stream_descriptor{executor, out};
+  auto error_stream = asio::posix::stream_descriptor{executor, error};
+
+  auto result =
+      co_await (ttwhy::io::handle_signals(error_stream) || ttwhy::io::echo(input_stream, output_stream, error_stream));
+  auto final_error = result.index() == 0 ? std::get<0>(result) : std::get<1>(result);
 
-  if (!error)
+  if (final_error && final_error != asio::error::operation_aborted)
   {
-    co_await asio::async_write(log_stream, asio::buffer("shutting down...\n"), asio::as_tuple(asio::use_awaitable));
-    cancellation_signal.emit(asio::cancellation_type::all);
+    auto message = std::format("Terminated with error: {}\n", final_error.message());
+    co_await asio::async_write(error_stream, asio::buffer(message), asio::use_awaitable);
   }
 }
 
@@ -27,9 +34,8 @@ auto main() -> int
                                  .canonical_mode(false)
                                  .echo(false);
   auto context = asio::io_context{};
-  auto cancellation_signal = asio::cancellation_signal{};
 
-  asio::co_spawn(context, handle_signals(cancellation_signal), asio::detached);
+  asio::co_spawn(context, app(fileno(stdin), fileno(stdout), fileno(stderr)), asio::detached);
 
   context.run();
 }
diff --git a/ttwhy/scoped_attributes.cppm b/ttwhy/scoped_attributes.cppm
index 7c32ddf..b49dd18 100644
--- a/ttwhy/scoped_attributes.cppm
+++ b/ttwhy/scoped_attributes.cppm
@@ -1,9 +1,10 @@
 module;
 
-#include <cerrno>
-#include <system_error>
 #include <termios.h>
 #include <unistd.h>
+
+#include <cerrno>
+#include <system_error>
 #include <utility>
 
 export module ttwhy:scoped_attributes;