http_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.
 */

/* 
 * File:   streaming_server.hpp
 * Author: alex
 *
 * Created on March 23, 2015, 8:10 PM
 */

#ifndef STATICLIB_PION_HTTP_SERVER_HPP
#define STATICLIB_PION_HTTP_SERVER_HPP

#include <cstdint>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <utility>

#include "asio.hpp"

#include "staticlib/config.hpp"
#include "staticlib/support.hpp"

#include "staticlib/pion/http_parser.hpp"
#include "staticlib/pion/http_request.hpp"
#include "staticlib/pion/http_response_writer.hpp"
#include "staticlib/pion/tcp_connection.hpp"
#include "staticlib/pion/tcp_server.hpp"
#include "staticlib/pion/websocket.hpp"

namespace staticlib { 
namespace pion {

class http_request_reader;

class http_server : public tcp_server {
    friend class http_request_reader;

public:
    using request_handler_type = std::function<void(http_request_ptr, response_writer_ptr)>;

    using payload_handler_creator_type = std::function<http_parser::payload_handler_type(http_request_ptr&)>;

    using handlers_map_type = std::unordered_map<std::string, request_handler_type>;

    using payloads_map_type = std::unordered_map<std::string, payload_handler_creator_type>; 

    using websocket_map_type = std::unordered_map<std::string, websocket_handler_type>; 

    // path -> (id, connection)
    using websocket_conn_registry_type = std::multimap<std::string, std::pair<std::string, std::weak_ptr<tcp_connection>>>;

private:
    uint32_t read_timeout;
    
    handlers_map_type get_handlers;

    handlers_map_type post_handlers;

    handlers_map_type put_handlers;

    handlers_map_type delete_handlers;

    handlers_map_type options_handlers;

    request_handler_type bad_request_handler;

    request_handler_type not_found_handler;

    // GET payload won't happen, but lets be consistent here
    // to simplify clients implementation and to make sure that
    // pion's form-data parsing won't be triggered
    payloads_map_type get_payloads;

    payloads_map_type post_payloads;

    payloads_map_type put_payloads;

    payloads_map_type delete_payloads;

    payloads_map_type options_payloads;

    websocket_map_type wsopen_handlers;

    websocket_map_type wsmessage_handlers;

    websocket_map_type wsclose_handlers;

    websocket_conn_registry_type websocket_conn_registry;

    std::mutex websocket_conn_registry_mtx;

public:
    ~http_server() STATICLIB_NOEXCEPT { }

    http_server(uint32_t number_of_threads, uint16_t port,
            asio::ip::address_v4 ip_address = asio::ip::address_v4::any(),
            uint32_t read_timeout_millis = 10000,
            const std::string& ssl_key_file = std::string(),
            std::function<std::string(std::size_t, asio::ssl::context::password_purpose)> ssl_key_password_callback = 
                    [](std::size_t, asio::ssl::context::password_purpose) { return std::string(); },
            const std::string& ssl_verify_file = std::string(),
            std::function<bool(bool, asio::ssl::verify_context&)> ssl_verify_callback = 
                    [](bool, asio::ssl::verify_context&) { return true; });

    void add_handler(const std::string& method, const std::string& resource,
            request_handler_type request_handler);

    void set_bad_request_handler(request_handler_type handler) {
        bad_request_handler = std::move(handler);
    }

    void set_not_found_handler(request_handler_type handler) {
        not_found_handler = std::move(handler);
    }

    void add_payload_handler(const std::string& method, const std::string& resource, 
            payload_handler_creator_type payload_handler);

    void add_websocket_handler(const std::string& event, const std::string& resource, 
            websocket_handler_type handler);

    void broadcast_websocket(const std::string& path, sl::io::span<const char> message,
            sl::websocket::frame_type frame_type = sl::websocket::frame_type::text,
            const std::set<std::string>& dest_ids = std::set<std::string>());
private:
    virtual void handle_connection(tcp_connection_ptr& conn) override;
    
    void handle_request_after_headers_parsed(http_request_ptr& request,
            tcp_connection_ptr& conn, const std::error_code& ec, sl::support::tribool& rc);

    void handle_request(http_request_ptr request,
            tcp_connection_ptr& conn, const std::error_code& ec);


};

} // namespace
}

#endif /* STATICLIB_PION_HTTP_SERVER_HPP */