server.hpp

// A server for hosting a financial instrument exchange micro-service.
// Copyright 2020 Christian Kauten
//
// Author: Christian Kauten (kautenja@auburn.edu)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
 
#ifndef ORDER_ENTRY_SERVER_HPP
#define ORDER_ENTRY_SERVER_HPP
 
#include "exceptions.hpp"
#include "limit_order_book/limit_order_book.hpp"
#include "connection.hpp"
#include "authorizer.hpp"
#include <asio.hpp>
#include <nlohmann/json.hpp>
#include <vector>
 
namespace OrderEntry {
 
class Server {
 private:
    asio::io_context& context;
    asio::ip::tcp::acceptor acceptor;
    Authorizer<Connection> authorizer;
    LOB::LimitOrderBook& book;
 
    void accept() {
        // create a new connection with a shared pointer
        auto connection = Connection::create(context, authorizer, book);
        // asynchronously accept a new connection
        acceptor.async_accept(
            connection->get_socket(),
            [this, connection](const std::error_code& error) {
                // throw an error if there is an error code
                if (error) throw Exception(error.message());
                // start the connection and accept another connection
                connection->start();
                accept();
            }
        );
    }
 
 public:
    Server(
        asio::io_context& context_,
        LOB::LimitOrderBook& book_,
        uint16_t port,
        std::vector<nlohmann::json> accounts
    ) :
        context(context_),
        acceptor(context, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port)),
        authorizer(),
        book(book_) {
        for (auto user : accounts) {  // iterate over the accounts
            auto username = user["username"].get<std::string>();
            auto password = user["password"].get<std::string>();
            // create a new user
            authorizer.new_user(username, password);
        }
        // start accepting connections
        accept();
    }
 
    inline asio::ip::address address() const {
        return acceptor.local_endpoint().address();
    }
 
    inline uint16_t port() const { return acceptor.local_endpoint().port(); }
 
    inline const Authorizer<Connection>& get_authorizer() { return authorizer; }
 
    inline const LOB::LimitOrderBook& get_book() { return book; }
};
 
}  // namespace OrderEntry
 
#endif  // ORDER_ENTRY_SERVER_HPP