tcp_server.hpp

Go to the documentation of this file.

/*
 * Copyright 2015, alex at staticlibs.net
 *
 * 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.
 */

// ---------------------------------------------------------------------
// pion:  a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc.  (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//

#ifndef STATICLIB_PION_TCP_SERVER_HPP
#define STATICLIB_PION_TCP_SERVER_HPP

#include <condition_variable>
#include <mutex>
#include <set>

#include "asio.hpp"

#include "staticlib/config.hpp"

#include "staticlib/pion/scheduler.hpp"
#include "staticlib/pion/tcp_connection.hpp"

namespace staticlib { 
namespace pion {

class tcp_server {

protected:
    scheduler active_scheduler;

    asio::ip::tcp::acceptor tcp_acceptor;

    tcp_connection::ssl_context_type ssl_context;

    std::condition_variable server_has_stopped;

    std::condition_variable no_more_connections;

    std::set<tcp_connection_ptr> conn_pool;

    asio::ip::tcp::endpoint tcp_endpoint;

    bool ssl_flag;

    bool listening;

    mutable std::mutex mutex;
    
public:

    tcp_server(const asio::ip::tcp::endpoint& endpoint, uint32_t number_of_threads) :
    active_scheduler(number_of_threads),
    tcp_acceptor(active_scheduler.get_io_service()),
    ssl_context(asio::ssl::context::sslv23),
    tcp_endpoint(endpoint), 
    ssl_flag(false),
    listening(false) { }

    tcp_server(const tcp_server&) = delete;

    tcp_server& operator=(const tcp_server&) = delete;

    virtual ~tcp_server() STATICLIB_NOEXCEPT {
        if (listening) {
            try {
                stop(false);
            } catch (const std::exception& e) {
                (void) e;
    //            STATICLIB_PION_LOG_WARN("Exception thrown in tcp::server destructor: " << e.message());
            }
        }
    }
    
    void start();

    void stop(bool wait_until_finished = false);

    bool is_listening() const {
        return listening;
    }

    virtual void handle_connection(tcp_connection_ptr& tcp_conn) {
        tcp_conn->set_lifecycle(tcp_connection::lifecycle::close); // make sure it will get closed
        tcp_conn->finish();
    }

    asio::io_service& get_io_service() {
        return active_scheduler.get_io_service();
    }

    scheduler& get_scheduler() {
        return active_scheduler;
    }

private:
        
    void handle_stop_request();

    void listen();

    void handle_accept(tcp_connection_ptr& tcp_conn, const std::error_code& accept_error);

    void handle_ssl_handshake(tcp_connection_ptr& tcp_conn, const std::error_code& handshake_error);

    void finish_connection(tcp_connection_ptr& tcp_conn);

    std::size_t prune_connections();

};

} // namespace
}

#endif // STATICLIB_PION_TCP_SERVER_HPP