server.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 <memory>  // for unique_ptr<>
#include <string>  // for string
#include <vector>  // for vector<>

// Requires: cppnetlib
#include <boost/network/include/http/server.hpp>
#include <boost/network/utils/thread_pool.hpp>

#include "oak/registrar.hpp"    // for StaticRegistrar, BufferRegistrar
#include "oak/route_muxer.hpp"  // for Muxer<>

namespace oak {

// These forward-declarations are a necessary evil:
class ServerImplHandler;
using ServerImpl = boost::network::http::server<ServerImplHandler>;

class RequestStub : public cloe::Request {
 public:
  cloe::RequestMethod method() const override { throw ERROR; }
  cloe::ContentType type() const override { throw ERROR; }
  const std::string& body() const override { throw ERROR; }
  const std::string& uri() const override { throw ERROR; }
  const std::string& endpoint() const override { throw ERROR; }
  const std::map<std::string, std::string>& query_map() const override { throw ERROR; }

 private:
  const std::logic_error ERROR = std::logic_error("using the request in any way is erroneous");
};

class ServerImplHandler {
 public:
  ServerImplHandler();

  void operator()(ServerImpl::request const&, ServerImpl::connection_ptr);

  void log(const ServerImpl::string_type& msg);

  void add(const std::string& key, Handler h);

  std::vector<std::string> endpoints() const { return muxer.routes(); }

  cloe::Json endpoints_to_json(const std::vector<std::string>& endpoints) const;

 private:
  Muxer<Handler> muxer;
};

class Server {
 public:
  Server(const std::string& addr, int port)
      : listen_addr_(addr), listen_port_(port), listen_threads_(3), listening_(false) {}

  Server() : listen_addr_("127.0.0.1"), listen_port_(8080), listen_threads_(3), listening_(false) {}

  ~Server() {
    if (this->is_listening()) {
      this->stop();
    }
  }

  void set_threads(int n) { listen_threads_ = n; }

  void set_address(const std::string& addr) { listen_addr_ = addr; }

  void set_port(int port) { listen_port_ = port; }

  bool is_listening() const { return listening_; }

  void listen();

  cloe::Json endpoints_to_json(const std::vector<std::string>& endpoints) const {
    return handler_.endpoints_to_json(endpoints);
  };

  void stop();

  std::vector<std::string> endpoints() const { return handler_.endpoints(); }

 protected:
  friend StaticRegistrar;
  friend LockedRegistrar;
  friend BufferRegistrar;

  void add_handler(const std::string& key, Handler h) { handler_.add(key, h); }

 private:
  // Configuration
  std::string listen_addr_;
  int listen_port_;
  int listen_threads_;

  // State
  bool listening_;
  ServerImplHandler handler_;
  std::unique_ptr<ServerImpl::options> options_;
  std::unique_ptr<ServerImpl> server_;
  std::unique_ptr<boost::thread> thread_;
};

}  // namespace oak