void AsyncLoopSocket(boost::function<TaskState()> doWork, boost::asio::ip::tcp::socket& sock, bool isRead)
{
if (sock.get_io_service().stopped())
{
return;
}
TaskState st = doWork();
if (st == TASK_WORKING)
{
if (isRead)
{
sock.async_read_some(boost::asio::null_buffers(), bind(AsyncLoopSocket, doWork, boost::ref(sock),
isRead));
}
else
{
sock.async_write_some(boost::asio::null_buffers(), bind(AsyncLoopSocket, doWork, boost::ref(sock),
isRead));
}
return;
}
// Work is over. stop any outstanding events.
// NOTE: this isn't 100% reliable, and there may be events that linger in the queue.
// The next time we reset() and run() the io_service, these events will be processed,
// and io_service::stopped() will return false, because we've just done reset() and run().
// The state management (SSHSession::State) is our first step in controlling this, and we
// may need to implement our own cancel mechanism
//
// this io_service feature poses an additional problem - by spreading the implementation
// responsibility across multiple classes, we create scenarios where io_service's queue
// may contain outstanding events referring to objects that were, in the meantime, destroyed.
// this is why we're favouring, for now, the use of AsyncLoopTimer, where we can use an
// io_service for each timer, and destroy it right after being used. this makes sure we
// process no "zombie" outstanding events.
sock.get_io_service().stop();
}
connection::connection(boost::asio::ip::tcp::socket socket,
connection_manager& manager/*, request_handler& handler*/)
: strand_(socket.get_io_service()),
socket_(std::move(socket)),
connection_manager_(manager),
request_handler_(*this),
total_bytes_received_(0),
timestamp_(0)
{
request_.header_length = 0;
request_.content_length = 0;
memset(this->v4_address_, 0x0, sizeof(this->v4_address_));
//tid_ = this_thread();
//LOG_TRACE_ALL("construct a connection resource ok, thread id:%u", tid_);
}