http_server::http_server(io_service_pool& ios, unsigned short port, std::string address /*= "0.0.0.0"*/)
: m_io_service_pool(ios)
, m_io_service(ios.get_io_service())
, m_ssl_context(ios.get_io_service(), boost::asio::ssl::context::sslv23)
, m_acceptor(m_io_service)
, m_listening(false)
, m_timer(m_io_service)
{
m_ssl_context.set_options(boost::asio::ssl::context::default_workarounds| boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::single_dh_use);
//m_ssl_context.set_password_callback(boost::bind(&server::get_password, this));
//m_ssl_context.use_certificate_chain_file("server.pem");
//m_ssl_context.use_private_key_file("server.pem", boost::asio::ssl::context::pem);
//m_ssl_context.use_tmp_dh_file("dh512.pem");
boost::asio::ip::tcp::resolver resolver(m_io_service);
std::ostringstream port_string;
port_string.imbue(std::locale("C"));
port_string << port;
boost::system::error_code ignore_ec;
boost::asio::ip::tcp::resolver::query query(address, port_string.str());
boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, ignore_ec);
if (ignore_ec)
{
LOG_ERR << "HTTP Server bind address, DNS resolve failed: " << ignore_ec.message() << ", address: " << address;
return;
}
boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
m_acceptor.open(endpoint.protocol(), ignore_ec);
if (ignore_ec)
{
LOG_ERR << "HTTP Server open protocol failed: " << ignore_ec.message();
return;
}
m_acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true), ignore_ec);
if (ignore_ec)
{
LOG_ERR << "HTTP Server set option failed: " << ignore_ec.message();
return;
}
m_acceptor.bind(endpoint, ignore_ec);
if (ignore_ec)
{
LOG_ERR << "HTTP Server bind failed: " << ignore_ec.message() << ", address: " << address;
return;
}
m_acceptor.listen(boost::asio::socket_base::max_connections, ignore_ec);
if (ignore_ec)
{
LOG_ERR << "HTTP Server listen failed: " << ignore_ec.message();
return;
}
m_listening = true;
m_timer.expires_from_now(seconds(1));
m_timer.async_wait(boost::bind(&http_server::on_tick, this, boost::asio::placeholders::error));
}
static void terminator(io_service_pool& ios, router_server& serv, login_moudle& login, http_server& http_serv)
{
login.quit();
serv.stop();
http_serv.stop();
ios.stop();
}
async_asio_echo_serv_ex(short port, uint32_t buffer_size = 32768,
uint32_t packet_size = 64,
uint32_t pool_size = std::thread::hardware_concurrency())
: io_service_pool_(pool_size),
acceptor_(io_service_pool_.get_first_io_service(), ip::tcp::endpoint(ip::tcp::v4(), port)),
buffer_size_(buffer_size), packet_size_(packet_size)
{
do_accept();
}
async_asio_echo_serv_ex(const std::string & ip_addr, const std::string & port,
uint32_t buffer_size = 32768,
uint32_t packet_size = 64,
uint32_t pool_size = std::thread::hardware_concurrency())
: io_service_pool_(pool_size), acceptor_(io_service_pool_.get_first_io_service()),
buffer_size_(buffer_size), packet_size_(packet_size)
{
start(ip_addr, port);
}
void do_accept2()
{
session_.reset(new asio_session(io_service_pool_.get_io_service(), buffer_size_, packet_size_, g_test_mode));
acceptor_.async_accept(session_->socket(),
[this](const boost::system::error_code & ec)
{
if (!ec) {
session_->start();
}
else {
// Accept error
std::cout << "async_asio_echo_serv_ex::handle_accept2() - Error: (code = " << ec.value() << ") "
<< ec.message().c_str() << std::endl;
session_->stop();
session_.reset();
}
do_accept2();
});
}
void start(const std::string & ip_addr, const std::string & port)
{
ip::tcp::resolver resolver(io_service_pool_.get_now_io_service());
ip::tcp::resolver::query query(ip_addr, port);
ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
boost::system::error_code ec;
acceptor_.open(endpoint.protocol(), ec);
if (ec) {
// Open endpoint error
std::cout << "async_asio_echo_serv_ex::start() - Error: (code = " << ec.value() << ") "
<< ec.message().c_str() << std::endl;
return;
}
boost::asio::socket_base::reuse_address option(true);
acceptor_.set_option(option);
acceptor_.bind(endpoint);
acceptor_.listen();
do_accept();
}
GatewayServer::GatewayServer(io_service_pool& pool, const std::string& script_file)
:sub_service(pool, GATEWAYSERVER, script_file),
one_second_timer_(pool.get_logic_service())
{
}
void run()
{
thread_ = std::make_shared<std::thread>([this] { io_service_pool_.run(); });
}
void do_accept()
{
asio_session * new_session = new asio_session(io_service_pool_.get_io_service(), buffer_size_, packet_size_, g_test_mode);
acceptor_.async_accept(new_session->socket(), boost::bind(&async_asio_echo_serv_ex::handle_accept,
this, boost::asio::placeholders::error, new_session));
}
