registrar.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <functional>
#include <initializer_list>
#include <map>
#include <mutex>
#include <string>
#include <utility>
 
#include <cloe/handler.hpp>  // for Handler, Response
 
#include "oak/route_muxer.hpp"  // for Muxer
 
namespace oak {
 
class Server; // from oak/server.hpp
 
using Middleware = std::function<cloe::Handler(cloe::Handler)>;
 
using Logger = std::function<void(const std::string&)>;
 
Middleware chain_middleware(Middleware x, Middleware y);
 
class Registrar {
 public:
  Registrar(const Registrar* r, const std::string& prefix, Middleware m);
  virtual ~Registrar() = default;
 
  Registrar with(const std::string& prefix, Middleware m) const;
  Registrar with_prefix(const std::string& prefix) const;
  Registrar with_middleware(Middleware m) const;
  std::string prefix() const { return prefix_; }
  Middleware middleware() const { return middleware_; }
  virtual void register_handler(const std::string& route, cloe::Handler h);
 
 protected:
  Registrar(const std::string& prefix, Middleware m) : prefix_(prefix), middleware_(m) {}
 
 protected:
  Registrar* proxy_{nullptr};
  std::string prefix_;
  Middleware middleware_;
};
 
template <typename T>
class ProxyRegistrar {
 public:
  ProxyRegistrar(const std::map<T, Registrar*>& registrars, const std::string& prefix, Middleware m)
      : registrars_(registrars), prefix_(prefix), middleware_(m) {}
  explicit ProxyRegistrar(std::initializer_list<std::pair<T, Registrar*>> registrars) {
    for (auto p : registrars) {
      registrars_[p.first] = p.second;
    }
  }
 
  ProxyRegistrar<T> with(const std::string& prefix, Middleware m) const {
    assert(prefix.size() == 0 || prefix[0] == '/');
    return ProxyRegistrar<T>(registrars_, prefix_ + prefix, chain_middleware(middleware_, m));
  }
 
  ProxyRegistrar<T> with_prefix(const std::string& prefix) const {
    assert(prefix.size() > 0 && prefix[0] == '/');
    return ProxyRegistrar<T>(registrars_, prefix_ + prefix, middleware_);
  }
 
  ProxyRegistrar<T> with_middleware(Middleware m) const {
    assert(m != nullptr);
    return ProxyRegistrar<T>(registrars_, prefix_, chain_middleware(middleware_, m));
  }
 
  std::string prefix() const { return prefix_; }
  Middleware middleware() const { return middleware_; }
 
  void register_handler(const std::string& route, T select, cloe::Handler h) {
    assert(route.size() != 0 && route[0] == '/');
    assert(registrars_.size() != 0);
    if (middleware_) {
      h = middleware_(h);
    }
    auto endpoint = route;
    if (prefix_.size() != 0) {
      endpoint = prefix_ + route;
    }
    registrars_.at(select)->register_handler(endpoint, h);
  }
 
 private:
  std::map<T, Registrar*> registrars_;
  std::string prefix_;
  Middleware middleware_;
};
 
class StaticRegistrar : public Registrar {
 public:
  explicit StaticRegistrar(Server* s) : Registrar("", nullptr), server_(s) {
    assert(server_ != nullptr);
  }
  StaticRegistrar(Server* s, const std::string& prefix, Middleware m)
      : Registrar(prefix, m), server_(s) {
    assert(server_ != nullptr);
    assert(prefix_.size() == 0 || prefix_[0] == '/');
  }
  virtual ~StaticRegistrar() = default;
 
  void register_handler(const std::string& route, cloe::Handler h) override;
 
  void set_prefix(const std::string& prefix) { prefix_ = prefix; }
  void set_logger(Logger logger) { logger_ = logger; }
 
  const std::vector<std::string>& endpoints() const { return endpoints_; }
 
 protected:
  void log(const std::string& endpoint) {
    if (logger_) {
      logger_(endpoint);
    }
  }
 
 protected:
  Server* server_;
  Logger logger_;
  std::vector<std::string> endpoints_;
};
 
class LockedRegistrar : public StaticRegistrar {
 public:
  using StaticRegistrar::StaticRegistrar;
 
  void register_handler(const std::string& route, cloe::Handler h) override;
 
  std::unique_lock<std::shared_mutex> lock() {
    return std::unique_lock(access_);
  }
 
 private:
  mutable std::shared_mutex access_;
};
 
class BufferRegistrar : public StaticRegistrar {
 public:
  using StaticRegistrar::StaticRegistrar;
 
  void register_handler(const std::string& route, cloe::Handler h) override;
 
  void refresh_buffer();
 
 protected:
  void refresh_route(const std::string& key);
 
 protected:
  mutable std::shared_mutex access_;
  Muxer<cloe::Response> buffer_;
  Muxer<cloe::Handler> handlers_;
};
 
}  // namespace oak