engine: Replace direct use of oak types with ServerRegistrar interface

This makes replacing the implementation easier and speeds up builds.

Author: cassava

engine/src/registrar.hpp

@@ -27,45 +27,37 @@
 #include <cloe/registrar.hpp>  // for cloe::Registrar
 
 #include "coordinator.hpp"  // for Coordinator
-#include "server.hpp"       // for Server, oak::ProxyRegistrar
+#include "server.hpp"       // for Server, ServerRegistrar
 
 namespace engine {
 
 class Registrar : public cloe::Registrar {
  public:
-  Registrar(Server& s, std::shared_ptr<Coordinator> c)
-      : static_registrar_(s.static_registrar())
-      , api_registrar_(s.api_registrar())
+  Registrar(std::unique_ptr<ServerRegistrar> r, std::shared_ptr<Coordinator> c)
+      : server_registrar_(std::move(r))
       , coordinator_(std::move(c)) {}
 
   Registrar(const Registrar& ar,
             const std::string& trigger_prefix,
             const std::string& static_prefix,
             const std::string& api_prefix)
-      : static_registrar_(ar.static_registrar_)
-      , api_registrar_(ar.api_registrar_)
-      , coordinator_(ar.coordinator_) {
+      : coordinator_(ar.coordinator_) {
     if (trigger_prefix.empty()) {
       trigger_prefix_ = ar.trigger_prefix_;
     } else {
       trigger_prefix_ = ar.trigger_prefix_ + trigger_prefix;
     }
-    if (!static_prefix.empty()) {
-      static_registrar_ = ar.static_registrar_.with_prefix(static_prefix);
-    }
-    if (!api_prefix.empty()) {
-      api_registrar_ = ar.api_registrar_.with_prefix(api_prefix);
-    }
+    server_registrar_ = ar.server_registrar_->with_prefix(static_prefix, api_prefix);
   }
 
   void register_static_handler(const std::string& endpoint, cloe::Handler h) override {
-    static_registrar_.register_handler(endpoint, h);
+    server_registrar_->register_static_handler(endpoint, h);
   }
 
   void register_api_handler(const std::string& endpoint,
                             cloe::HandlerType t,
                             cloe::Handler h) override {
-    api_registrar_.register_handler(endpoint, t, h);
+    server_registrar_->register_api_handler(endpoint, t, h);
   }
 
   std::unique_ptr<cloe::Registrar> clone() const {
@@ -113,8 +105,7 @@ class Registrar : public cloe::Registrar {
   }
 
  private:
-  oak::Registrar static_registrar_;
-  oak::ProxyRegistrar<cloe::HandlerType> api_registrar_;
+  std::unique_ptr<ServerRegistrar> server_registrar_;
   std::shared_ptr<Coordinator> coordinator_;
   std::string trigger_prefix_;
 };

engine/src/server.cpp

@@ -22,16 +22,53 @@
 
 #include "server.hpp"
 
-#include <memory>   // for unique_ptr<>
+#include <memory>   // for unique_ptr<>, make_unique
 #include <utility>  // for make_pair
 
-#include <cloe/registrar.hpp> // for HandlerType
+#include <cloe/registrar.hpp>                       // for HandlerType
 #include <cloe/utility/output_serializer_json.hpp>  // for JsonFileSerializer
 
 #include <oak/server.hpp>  // for Server, StaticRegistrar, ...
 
 namespace engine {
 
+class ServerRegistrarImpl : public ServerRegistrar {
+ public:
+  ServerRegistrarImpl(
+      oak::Registrar static_reg, oak::ProxyRegistrar<cloe::HandlerType> api_reg)
+      : static_registrar_(static_reg), api_registrar_(api_reg) {}
+
+  std::unique_ptr<ServerRegistrar> clone() const override {
+    return std::make_unique<ServerRegistrarImpl>(static_registrar_, api_registrar_);
+  }
+
+  std::unique_ptr<ServerRegistrar> with_prefix(const std::string& static_prefix,
+                                               const std::string& api_prefix) const override {
+    auto static_reg = static_registrar_;
+    if (!static_prefix.empty()) {
+      static_reg = static_registrar_.with_prefix(static_prefix);
+    }
+    auto api_reg = api_registrar_;
+    if (!api_prefix.empty()) {
+      api_reg = api_registrar_.with_prefix(api_prefix);
+    }
+    return std::make_unique<ServerRegistrarImpl>(static_reg, api_reg);
+  }
+
+  void register_static_handler(const std::string& endpoint, cloe::Handler h) override {
+    static_registrar_.register_handler(endpoint, h);
+  }
+
+  void register_api_handler(const std::string& endpoint, cloe::HandlerType t,
+                                    cloe::Handler h) override {
+    api_registrar_.register_handler(endpoint, t, h);
+  }
+
+ private:
+  oak::Registrar static_registrar_;
+  oak::ProxyRegistrar<cloe::HandlerType> api_registrar_;
+};
+
 class ServerImpl : public Server {
  public:
   ServerImpl(const cloe::ServerConf& config) : Server(config) {
@@ -98,9 +135,13 @@ class ServerImpl : public Server {
         [this](const cloe::Request&, cloe::Response& r) { r.write(this->server_.endpoints()); });
   }
 
-  oak::Registrar static_registrar() override { return static_registrar_.with("", nullptr); }
+  std::unique_ptr<ServerRegistrar> server_registrar() override {
+    return std::make_unique<ServerRegistrarImpl>(static_registrar(), api_registrar());
+  }
+
+  oak::Registrar static_registrar() { return static_registrar_.with("", nullptr); }
 
-  oak::ProxyRegistrar<cloe::HandlerType> api_registrar() override {
+  oak::ProxyRegistrar<cloe::HandlerType> api_registrar() {
     return oak::ProxyRegistrar<cloe::HandlerType>({
         std::make_pair(cloe::HandlerType::STATIC, &static_api_registrar_),
         std::make_pair(cloe::HandlerType::DYNAMIC, &locked_api_registrar_),

engine/src/server.hpp

@@ -25,13 +25,33 @@
 #include <memory>  // for unique_ptr<>
 
 #include <cloe/registrar.hpp>  // for Registrar
-#include <oak/registrar.hpp>   // for oak::Registrar, oak::ProxyRegistrar
 
 #include "stack.hpp"          // for ServerConf
 #include "utility/defer.hpp"  // for Defer
 
 namespace engine {
 
+/**
+ * Server registrar interface.
+ *
+ * This lets you register static and API endpoints with the server.
+ * Get a new one from Server::server_registrar().
+ */
+class ServerRegistrar {
+ public:
+  virtual ~ServerRegistrar() = default;
+
+  virtual std::unique_ptr<ServerRegistrar> clone() const = 0;
+
+  virtual std::unique_ptr<ServerRegistrar> with_prefix(const std::string& static_prefix,
+                                                       const std::string& api_prefix) const = 0;
+
+  virtual void register_static_handler(const std::string& endpoint, cloe::Handler h) = 0;
+
+  virtual void register_api_handler(const std::string& endpoint, cloe::HandlerType t,
+                                    cloe::Handler h) = 0;
+};
+
 /**
  * Server interface to make altering the implementation easier.
  *
@@ -81,14 +101,10 @@ class Server {
   virtual void enroll(cloe::Registrar& r) = 0;
 
   /**
-   * Return the static content registrar.
-   */
-  virtual oak::Registrar static_registrar() = 0;
-
-  /**
-   * Return the API registrar.
+   * Return a new ServerRegistrar that lets you register static content and
+   * API endpoints with the web server.
    */
-  virtual oak::ProxyRegistrar<cloe::HandlerType> api_registrar() = 0;
+  virtual std::unique_ptr<ServerRegistrar> server_registrar() = 0;
 
   /**
    * Refresh and/or start streaming api data to a file.

engine/src/simulation.cpp

@@ -1161,7 +1161,7 @@ SimulationResult Simulation::run() {
   SimulationContext ctx;
   ctx.server = make_server(config_.server);
   ctx.coordinator.reset(new Coordinator{});
-  ctx.registrar.reset(new Registrar{*ctx.server, ctx.coordinator});
+  ctx.registrar.reset(new Registrar{ctx.server->server_registrar(), ctx.coordinator});
   ctx.commander.reset(new CommandExecuter{logger()});
   ctx.sync = SimulationSync(config_.simulation.model_step_width);
   ctx.config = config_;