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 <string>
#include <utility>

#include <boost/thread/locks.hpp>         // for unique_lock
#include <boost/thread/shared_mutex.hpp>  // for shared_mutex

#include <cloe/handler.hpp>  // for Handler

#include "oak/route_muxer.hpp"  // for Muxer

namespace oak {

class Server;

using Handler = cloe::Handler;

using Response = cloe::Response;

using Middleware = std::function<Handler(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, 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, 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, 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, Handler h) override;

  boost::unique_lock<boost::shared_mutex> lock() {
    return boost::unique_lock<boost::shared_mutex>(access_);
  }

 private:
  mutable boost::shared_mutex access_;
};

class BufferRegistrar : public StaticRegistrar {
 public:
  using StaticRegistrar::StaticRegistrar;

  void register_handler(const std::string& route, Handler h) override;

  void refresh_buffer();

 protected:
  void refresh_route(const std::string& key);

 protected:
  mutable boost::shared_mutex access_;
  Muxer<Response> buffer_;
  Muxer<Handler> handlers_;
};

}  // namespace oak