#include<boost/network/protocol/http/request.hpp>

#include<boost/network/protocol/http/server/sync_server.hpp>

#include<boost/network/protocol/http/server/async_server.hpp>

#include<boost/network/protocol/http/server/parameters.hpp>

namespaceboost {namespacenetwork {namespacehttp {

structserver : server_base<tags::http_server, Handler>::type {

typedeftypename server_base<tags::http_server, Handler>::type

server_base;

typedef server_options<tags::http_server, Handler> options;

BOOST_PARAMETER_CONSTRUCTOR(

server, (server_base), tag,

(required

(address, (typename server_base::string_typeconst &))

(port, (typename server_base::string_typeconst &))

(in_out(handler), (Handler &)))

(optional

(in_out(io_service), (boost::asio::io_service &))

(reuse_address, (bool))

(report_aborted, (bool))

(receive_buffer_size, (int))

(send_buffer_size, (int))

(receive_low_watermark, (int))

(send_low_watermark, (int))

(non_blocking_io, (int))

(linger, (bool))

(linger_timeout, (int)))

)

explicitserver(optionsconst &options)

: server_base(options) {}

};

template<classHandler>

structasync_server : server_base<tags::http_async_server, Handler>::type

{

typedeftypename server_base<tags::http_async_server, Handler>::type

server_base;

typedef server_options<tags::http_async_server, Handler> options;

BOOST_PARAMETER_CONSTRUCTOR(

async_server, (server_base), tag,

(required

(address, (typename server_base::string_typeconst &))

(port, (typename server_base::string_typeconst &))

(in_out(handler), (Handler&))

(in_out(thread_pool), (utils::thread_pool&)))

(optional

(in_out(io_service), (boost::asio::io_service&))

(reuse_address, (bool))

(report_aborted, (bool))

(receive_buffer_size, (int))

(send_buffer_size, (int))

(receive_low_watermark, (int))

(send_low_watermark, (int))

(non_blocking_io, (bool))

(linger, (bool))

(linger_timeout, (int)))

)

explicitasync_server(optionsconst &options)

: server_base(options) {}

};

}// namespace http

typedeftypename boost::network::http::response_header<Tag>::type response_header;

typedef async_connection<Tag,Handler> connection;

typedef shared_ptr<connection> connection_ptr;

typedef boost::unique_lock<boost::mutex> scoped_mutex_lock;

typedef boost::unique_lock<boost::mutex> scoped_mutex_lock;

template<classArgPack>

async_server_base(ArgPackconst & args)

: server_storage_base(args,

typename mpl::if_<

is_same<

typename parameter::value_type<ArgPack, tag::io_service,void>::type,

>,

server_storage_base::no_io_service,

server_storage_base::has_io_service

>::type())

, socket_options_base(args)

, handler(args[_handler])

, address_(args[_address])

, port_(args[_port])

, thread_pool(args[_thread_pool])

explicitasync_server_base(server_options<Tag, Handler>const &options)

: server_storage_base(options)

, socket_options_base(options)

, handler(options.handler())

, address_(options.address())

, port_(options.port())

, thread_pool(options.thread_pool() ? options.thread_pool() : boost::make_shared<utils::thread_pool>())

, acceptor(server_storage_base::service_)

, stopping(false)

, new_connection()

, listening_mutex_()

, stopping_mutex_()

, stopping_mutex_()

, listening(false)

{}

voidstop() {

scoped_mutex_locklistening_lock(listening_mutex_);

if (listening) {// we dont bother stopping if we arent currently listening

scoped_mutex_lockstopping_lock(stopping_mutex_);

stopping =true;

system::error_code ignored;

acceptor.close(ignored);

listening =false;

service_.post(boost::bind(&async_server_base::handle_stop,this));

}

scoped_mutex_locklistening_lock(listening_mutex_);

if (listening) {// we dont bother stopping if we arent currently listening

scoped_mutex_lockstopping_lock(stopping_mutex_);

stopping =true;

system::error_code ignored;

acceptor.close(ignored);

listening =false;

service_.post(boost::bind(&async_server_base::handle_stop,this));

}

}

voidlisten() {

scoped_mutex_locklistening_lock(listening_mutex_);

scoped_mutex_locklistening_lock(listening_mutex_);

BOOST_NETWORK_MESSAGE("Listening on" << address_ <<':' << port_);

if (!listening)start_listening();// we only initialize our acceptor/sockets if we arent already listening

if (!listening) {

Handler & handler;

string_type address_, port_;

utils::thread_pool & thread_pool;

boost::shared_ptr<utils::thread_pool> thread_pool;

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

bool stopping;

connection_ptr new_connection;

boost::mutex listening_mutex_;

boost::mutex stopping_mutex_;

boost::mutex stopping_mutex_;

bool listening;

voidhandle_stop() {

scoped_mutex_lockstopping_lock(stopping_mutex_);

if (stopping) service_.stop();// a user may have started listening again before the stop command is reached

}

voidhandle_stop() {

scoped_mutex_lockstopping_lock(stopping_mutex_);

if (stopping) service_.stop();// a user may have started listening again before the stop command is reached

}

voidhandle_accept(boost::system::error_codeconst & ec) {

{

scoped_mutex_lockstopping_lock(stopping_mutex_);

if (stopping)return;// we dont want to add another handler instance, and we dont want to know about errors for a socket we dont need anymore

}

{

scoped_mutex_lockstopping_lock(stopping_mutex_);

if (stopping)return;// we dont want to add another handler instance, and we dont want to know about errors for a socket we dont need anymore

}

if (!ec) {

socket_options_base::socket_options(new_connection->socket());

new_connection->start();

new_connection.reset(

newconnection(

service_

, handler

, thread_pool

)

);

acceptor.async_accept(new_connection->socket(),

boost::bind(

&async_server_base<Tag,Handler>::handle_accept

,this

, boost::asio::placeholders::error

)

);

newconnection(service_, handler, *thread_pool));

acceptor.async_accept(

new_connection->socket(),

boost::bind(

&async_server_base<Tag,Handler>::handle_accept,

this,

boost::asio::placeholders::error));

}else {

BOOST_NETWORK_MESSAGE("Error accepting connection, reason:" << ec);

}

}

voidstart_listening() {

using boost::asio::ip::tcp;

system::error_code error;

service_.reset();// this allows repeated cycles of run -> stop -> run

service_.reset();// this allows repeated cycles of run -> stop -> run

tcp::resolverresolver(service_);

tcp::resolver::queryquery(address_, port_);

tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error);

BOOST_NETWORK_MESSAGE("Error listening on socket: '" << error <<"' on" << address_ <<":" << port_);

return;

}

new_connection.reset(newconnection(service_, handler, thread_pool));

new_connection.reset(newconnection(service_, handler,*thread_pool));

acceptor.async_accept(new_connection->socket(),

boost::bind(

&async_server_base<Tag,Handler>::handle_accept

,this

, boost::asio::placeholders::error));

listening =true;

scoped_mutex_lockstopping_lock(stopping_mutex_);

stopping =false;// if we were in the process of stopping, we revoke that command and continue listening

scoped_mutex_lockstopping_lock(stopping_mutex_);

stopping =false;// if we were in the process of stopping, we revoke that command and continue listening

BOOST_NETWORK_MESSAGE("Now listening on socket: '" << address_ <<":" << port_ <<"'");

}

};

#include<boost/network/protocol/http/server/parameters.hpp>

#include<boost/optional.hpp>

#include<boost/utility/in_place_factory.hpp>

namespaceboost {namespacenetwork {namespacehttp {

asio::socket_base::non_blocking_io non_blocking_io;

asio::socket_base::linger linger;

template<classArgPack>

socket_options_base(ArgPackconst & args)

: acceptor_reuse_address(args[_reuse_address|false])

, acceptor_report_aborted(args[_report_aborted|false])

, non_blocking_io(args[_non_blocking_io|true])

, linger(args[_linger|true], args[_linger_timeout|0])

{

set_optional(receive_buffer_size, args, _receive_buffer_size);

set_optional(send_buffer_size, args, _send_buffer_size);

set_optional(receive_low_watermark, args, _receive_low_watermark);

set_optional(send_low_watermark, args, _send_low_watermark);

}

template<classTag,classHandler>

explicitsocket_options_base(server_options<Tag, Handler>const &options)

: acceptor_reuse_address(options.reuse_address())

, acceptor_report_aborted(options.report_aborted())

, receive_buffer_size(options.receive_buffer_size())

, send_buffer_size(options.send_buffer_size())

, receive_low_watermark(options.receive_low_watermark())

, send_low_watermark(options.send_low_watermark())

, non_blocking_io(options.non_blocking_io())

, linger(options.linger(), options.linger_timeout())

{}

voidacceptor_options(boost::asio::ip::tcp::acceptor & acceptor) {

acceptor.set_option(acceptor_reuse_address);

if (send_buffer_size) socket.set_option(*send_buffer_size, ignored);

if (send_low_watermark) socket.set_option(*send_low_watermark, ignored);

}

template<classOptional,classArgs,classKeyword>

typename boost::enable_if<

mpl::not_<

boost::is_same<

typename boost::parameter::value_type<Args, Keyword,void>::type

,void

>

>

,void

>::type

set_optional(Optional & option, Argsconst & args, Keywordconst & keyword) {

option = in_place<typename Optional::value_type>(args[keyword]);

}

template<classOptional,classArgs,classKeyword>

typename boost::enable_if<

boost::is_same<

typename boost::parameter::value_type<Args, Keyword,void>::type

,void

>

,void

>::type

set_optional(Optional &, Argsconst &, Keywordconst &) {

}

};

}/* http*/

#include<boost/network/protocol/http/server/parameters.hpp>

#include<boost/shared_ptr.hpp>

#include<boost/make_shared.hpp>

#include<boost/network/protocol/http/server/options.hpp>

namespaceboost {namespacenetwork {namespacehttp {

structserver_storage_base {

structno_io_service {};

structhas_io_service {};

template<classArgPack>

server_storage_base(ArgPackconst &/* args*/, no_io_service)

: self_service_(newboost::asio::io_service())

template<classTag,classHandler>

explicitserver_storage_base(server_options<Tag, Handler>const &options)

: self_service_(options.io_service()? options.io_service() :boost::make_shared<boost::asio::io_service>())

, service_(*self_service_)

{}

template<classArgPack>

server_storage_base(ArgPackconst & args, has_io_service)

: self_service_(0)

, service_(args[_io_service])

{}

~server_storage_base() {

delete self_service_;

self_service_ =0;

}

asio::io_service * self_service_;

boost::shared_ptr<asio::io_service> self_service_;

asio::io_service & service_;

};