root/server.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2010 Antti-Juhani Kaijanaho

    Alue 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.

    Alue 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 Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_SERVER_HPP
#define GUARD_SERVER_HPP

#include "logger/logger.hh"
#include "tls/init.hh"

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time.hpp>
#include <boost/shared_ptr.hpp>
#include <fstream>
#include <set>

namespace db { class db; }
namespace http { class token; class session; class resource; }
namespace smtp_client { class smtp_client; }

class server : private boost::noncopyable
{
public:
        class conn_cb;
        class connection_factory;
        class connection : private boost::noncopyable
        {
        protected:                
                virtual server::conn_cb get_conn_cb() = 0;
                friend class server;
        public:
                virtual ~connection() {}
                virtual std::string get_port_name() const = 0;
                virtual boost::shared_ptr<connection_factory>
                get_factory() const = 0;
                virtual void tick(bool stats) = 0;
        };

        class connection_factory
        {
        public:
                virtual ~connection_factory() {}
                virtual boost::shared_ptr<connection>
                operator()(std::string port_name,
                           boost::asio::ip::tcp::acceptor &acc,
                           tls::init,
                           server::conn_cb srv_cb) = 0;
        };

        class http_resource_factory : private boost::noncopyable
        {
        public:
                virtual ~http_resource_factory() {}
                virtual boost::shared_ptr<http::resource>
                operator()(server::conn_cb cb, std::string path) = 0;
        };

        server(boost::asio::io_service &io_service,
               tls::init tlsinit,
               std::map<std::string, 
               std::pair<boost::shared_ptr<connection_factory>, bool> > &);

        void run();
        
        void hup();
        
        class conn_cb
        {
                server &srv;
                bool do_log;
                conn_cb(server *srv, bool do_log) : srv(*srv), do_log(do_log) {}
                friend class server;
        public:
                smtp_client::smtp_client &smtpc() const { return *srv.smtpc; }
                db::db &dbase() const { return *srv.dbase; }
                boost::shared_ptr<http::resource> get_http_resource
                (std::string host, std::string path);
                boost::shared_ptr<http::session> &get_session
                (std::string cookie) const
                        { return srv.http_sessions[cookie]; }
                boost::shared_ptr<http::token> &get_http_token
                (std::string token) const
                        { return srv.http_tokens[token]; }
                bool do_log_protocol_details() const { return do_log; }
                void active(boost::shared_ptr<connection>);
                void terminal(boost::shared_ptr<connection>);
        };

        static void register_http_resource(std::string path,
                                           http_resource_factory *);

private:
        boost::asio::io_service &io_service;
        boost::asio::io_service::strand strand;
        boost::asio::deadline_timer timer;
        boost::posix_time::ptime latest_logged_statistics;

        typedef
        std::map<std::string,
                 boost::shared_ptr<boost::asio::ip::tcp::acceptor> >
        acceptors_type;
        acceptors_type acceptors;

        boost::shared_ptr<smtp_client::smtp_client> smtpc;
        boost::shared_ptr<db::db> dbase;

        tls::init tlsinit;

        std::map<std::string, boost::shared_ptr<http::session> > http_sessions;
        std::map<std::string, boost::shared_ptr<http::token> > http_tokens;

        typedef std::map<std::string, http_resource_factory *> 
        http_resources_type;
        static http_resources_type *http_resources;

        // connections in various states
        std::map<std::string, boost::shared_ptr<connection> > waiting;
        std::set<boost::shared_ptr<connection> > active;

        void tick_handler(boost::system::error_code ec);

        void terminate_connection(boost::shared_ptr<connection>);
        void activate_connection(boost::shared_ptr<connection>);
        bool replace_waiting(boost::shared_ptr<connection>);
};

inline void server::register_http_resource(std::string path,
                                           http_resource_factory *rf)
{
        if (http_resources == 0) http_resources = new http_resources_type;
        if (http_resources->find(path) != http_resources->end())
                throw std::logic_error(path + " multiply registered");
        (*http_resources)[path] = rf;
}

inline void server::conn_cb::terminal(boost::shared_ptr<connection> cp)
{
        srv.strand.post(boost::bind(&server::terminate_connection,
                                    &srv,
                                    cp));
}

inline void server::conn_cb::active(boost::shared_ptr<connection> cp)
{
        srv.strand.post(boost::bind(&server::activate_connection,
                                    &srv,
                                    cp));
}

#endif /* GUARD_SERVER_HPP */