1 files changed, 67 insertions, 34 deletions

diff --git a/server/src/main.cpp b/server/src/main.cpp
index a40b0b0..0a7a784 100644
--- a/server/src/main.cpp
+++ b/server/src/main.cpp
@@ -1,5 +1,5 @@
-#include <malloc.h>  // for malloc_trim(3)
 #include <boost/asio.hpp>
+#include <malloc.h> // for malloc_trim(3)
 
 import std;
 import routemon;
@@ -7,17 +7,23 @@ import routemon;
 namespace chrono = std::chrono;
 namespace net = boost::asio;
 
-enum class exit_status {
+enum class exit_status
+{
   failure,
   bad_usage,
 };
 
-auto real_main(std::span<char const*> args) -> exit_status {
+auto real_main(std::span<char const*> args) -> exit_status
+{
   auto sink = routemon::log::make_sink(routemon::log::level::info);
   auto l = routemon::log::logger{sink};
 
-  if (args.size() != 2) {
-    l.error("Fatal: expected exactly one argument (the configuration file location), got {}", args.size() - 1);
+  if (args.size() != 2)
+  {
+    l.error(
+        "Fatal: expected exactly one argument (the configuration file "
+        "location), got {}",
+        args.size() - 1);
     return exit_status::bad_usage;
   }
   auto const* config_filename = args[1];
@@ -25,54 +31,73 @@ auto real_main(std::span<char const*> args) -> exit_status {
   auto lgen = routemon::locale::make_generator();
   auto default_locale = lgen->generate("en_US.UTF-8");
   auto locales = {
-    default_locale,
-    lgen->generate("nl_NL.UTF-8"),
-    lgen->generate("de_DE.UTF-8"),
-    lgen->generate("en_GB.UTF-8"),
+      default_locale,
+      lgen->generate("nl_NL.UTF-8"),
+      lgen->generate("de_DE.UTF-8"),
+      lgen->generate("en_GB.UTF-8"),
   };
   auto lsel = routemon::locale::selector{locales, default_locale, lgen};
 
   auto ioc = net::io_context{1 /* concurrency hint */};
 
   auto config = routemon::config::app{};
-  try {
+  try
+  {
     config = routemon::config::load_file(config_filename);
-  } catch (std::exception const& e) {
-    l.with("filename", std::string_view{config_filename}).
-      error("Failed to load configuration: {}", e.what());
+  }
+  catch (std::exception const& e)
+  {
+    l.with("filename", std::string_view{config_filename})
+        .error("Failed to load configuration: {}", e.what());
     return exit_status::failure;
   }
   sink->set_level(config.logger.level);
-  // auto rwgps_client = routemon::rwgps::client{ioc, l, config.rwgps.api_key, config.rwgps.auth_token};
-  // for (auto route : rwgps_client.get_all_routes()) {
-  //   l.info("Route {} (user {}): {} @ {}", route.id, route.user_id, route.name, route.url);
+  // auto rwgps_client = routemon::rwgps::client{ioc, l, config.rwgps.api_key,
+  // config.rwgps.auth_token}; for (auto route :
+  // rwgps_client.get_all_routes())
+  // {
+  //   l.info("Route {} (user {}): {} @ {}", route.id, route.user_id,
+  //   route.name, route.url);
   // }
 
   auto dbc = std::shared_ptr<routemon::database::connection>{};
-  try {
+  try
+  {
     dbc = routemon::database::open(config.database.sqlite3_filename);
-  } catch (std::exception const& e) {
-    l.with("filename", config.database.sqlite3_filename).
-      error("Failed to open database: {}", e.what());
+  }
+  catch (std::exception const& e)
+  {
+    l.with("filename", config.database.sqlite3_filename)
+        .error("Failed to open database: {}", e.what());
     return exit_status::failure;
   }
 
-  l.with("filename", config.situations.datex2_filename).
-    info("Loading situations");
+  l.with("filename", config.situations.datex2_filename)
+      .info("Loading situations");
   auto const before_load = chrono::steady_clock::now();
   auto d2loader = routemon::datex2::loader{};
   auto pub = routemon::datex2::situation_publication{};
-  try {
-    pub = d2loader.load_situation_publication(config.situations.datex2_filename);
-  } catch (std::exception const& e) {
+  try
+  {
+    pub =
+        d2loader.load_situation_publication(config.situations.datex2_filename);
+  }
+  catch (std::exception const& e)
+  {
     l.error("Failed to load DATEX II situations publication: {}", e.what());
     return exit_status::failure;
   }
-  if (!d2loader.warnings().empty()) {
+  if (!d2loader.warnings().empty())
+  {
     auto const& warns = d2loader.warnings();
-    l.warn("Encountered {} unique warnings while loading DATEX II situations publication", warns.size());
+    l.warn(
+        "Encountered {} unique warnings while loading DATEX II situations "
+        "publication",
+        warns.size());
     auto i = 0uz;
-    for (auto it = warns.begin(); it != warns.end(); it = warns.upper_bound(*it)) {
+    for (auto it = warns.begin(); it != warns.end();
+         it = warns.upper_bound(*it))
+    {
       l.warn("Warning {} (appeared {}×): {}", ++i, warns.count(*it), *it);
     }
   }
@@ -82,11 +107,13 @@ auto real_main(std::span<char const*> args) -> exit_status {
   // to return as much memory as possible to the OS.
   malloc_trim(0);
   auto const after_load = chrono::steady_clock::now();
-  auto const dur_load = chrono::duration_cast<chrono::milliseconds>(after_load - before_load);
+  auto const dur_load =
+      chrono::duration_cast<chrono::milliseconds>(after_load - before_load);
   l.info("Loading situations finished in {}", dur_load);
 
   auto handler = routemon::api::handler{l, std::move(pub)};
-  auto http_server = routemon::srv::server{l, std::move(lsel), std::move(handler)};
+  auto http_server =
+      routemon::srv::server{l, std::move(lsel), std::move(handler)};
   http_server.spawn(ioc);
   ioc.run();
 
@@ -94,13 +121,19 @@ auto real_main(std::span<char const*> args) -> exit_status {
   return exit_status::failure;
 }
 
-auto main(int argc, char* argv[]) -> int {
-  if (argc < 0) {
+auto main(int argc, char* argv[]) -> int
+{
+  if (argc < 0)
+  {
     std::cout << "Fatal: argument count below zero" << std::endl;
     return EXIT_FAILURE;
   }
-  auto res = real_main(std::span{const_cast<char const**>(argv), static_cast<std::size_t>(argc)});
-  switch (res) {
+  auto res = real_main(
+      std::span{
+          const_cast<char const**>(argv), static_cast<std::size_t>(argc)
+      });
+  switch (res)
+  {
   case exit_status::failure:
     return EXIT_FAILURE;
   case exit_status::bad_usage: