/// Connection base state machine
void nextOperation()
{
NetworkOperation netOp = m_connHandler->nextOperation();
switch ( netOp.operation() ) {
case NetworkOperation::READ: {
LOG_TRACE << "Next operation: READ " << netOp.size() << " bytes from " << identifier();
if ( netOp.buffer() == NULL ) {
LOG_FATAL << "Attempt to READ from " << identifier() << " to a NULL data block";
abort(); // here should be a system exception
}
if ( netOp.size() == 0 ) {
LOG_FATAL << "Attempt to READ 0 bytes data block from " << identifier();
abort(); // here should be a system exception
}
if ( netOp.timeout() > 0 )
setTimeout( netOp.timeout());
m_readBuffer = netOp.buffer();
socket().async_read_some( boost::asio::buffer( m_readBuffer, netOp.size() ),
m_strand.wrap( boost::bind( &ConnectionBase::handleRead,
this->shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred )));
break;
}
case NetworkOperation::WRITE: {
LOG_TRACE << "Next operation: WRITE " << netOp.size() << " bytes to " << identifier();
if ( netOp.data() == NULL ) {
LOG_FATAL << "Attempt to WRITE a NULL data block to " << identifier();
abort(); // here should be a system exception
}
if ( netOp.size() == 0 ) {
LOG_FATAL << "Attempt to WRITE a 0 bytes data block to " << identifier();
abort(); // here should be a system exception
}
if ( netOp.timeout() > 0 )
setTimeout( netOp.timeout());
boost::asio::async_write( socket(),
boost::asio::buffer( netOp.data(), netOp.size() ),
m_strand.wrap( boost::bind( &ConnectionBase::handleWrite,
this->shared_from_this(),
boost::asio::placeholders::error )));
break;
}
case NetworkOperation::CLOSE: {
LOG_TRACE << "Next operation: CLOSE connection to " << identifier();
// Initiate graceful connection closure.
setTimeout( 0 );
unregister();
m_strand.post( boost::bind( &ConnectionBase::handleShutdown,
this->shared_from_this() ));
break;
}
case NetworkOperation::NOOP:
LOG_TRACE << "Next operation: NOOP on connection to " << identifier();
break;
}
}
void justdoit()
{
rc_->get(strand_.wrap(
boost::bind(&tormoz_get::handle_done, shared_from_this(), _1, _2))
);
timer_.expires_from_now(boost::posix_time::milliseconds(100));
timer_.async_wait(strand_.wrap(boost::bind(&tormoz_get::handle_timeout, shared_from_this(), _1)));
}
// Called when the timer expires.
// We operate the timer continuously this simplifies the code.
//
void on_timer(error_code ec)
{
if(ec && ec != boost::asio::error::operation_aborted)
return fail("timer", ec);
// Verify that the timer really expired
// since the deadline may have moved.
//
if(timer_.expires_at() <= clock_type::now())
{
// Closing the socket cancels all outstanding
// operations. They will complete with
// boost::asio::error::operation_aborted
//
ws_.next_layer().close(ec);
return;
}
// Wait on the timer
timer_.async_wait(
strand_.wrap(std::bind(
&connection::on_timer,
shared_from_this(),
std::placeholders::_1)));
}
void do_finish (
std::string name,
boost::system::error_code const& ec,
HandlerType handler,
boost::asio::ip::tcp::resolver::iterator iter,
CompletionCounter)
{
if (ec == boost::asio::error::operation_aborted)
return;
std::vector <beast::IP::Endpoint> addresses;
// If we get an error message back, we don't return any
// results that we may have gotten.
if (!ec)
{
while (iter != boost::asio::ip::tcp::resolver::iterator())
{
addresses.push_back (beast::IPAddressConversion::from_asio (*iter));
++iter;
}
}
handler (name, addresses);
m_io_service.post (m_strand.wrap (std::bind (
&ResolverAsioImpl::do_work, this,
CompletionCounter (this))));
}
void CAuthenticationCenter::PostRandomTicket(boost::shared_ptr<CTcpConnection> conn,
boost::asio::io_service::strand& strand,
const std::string& secret_key,std::vector<std::string> command_vec)
{
strand.post(boost::bind(&CAuthenticationCenter::ProcessTicketMessage,this,
conn,secret_key,command_vec));
}
void do_resolve (std::vector <std::string> const& names,
HandlerType const& handler, CompletionCounter)
{
check_precondition (! names.empty());
if (m_called_stop.load () == 0)
{
// TODO NIKB use emplace_back once we move to C++11
m_work.push_back(Work(names, handler));
m_journal.debug <<
"Queued new job with " << names.size() <<
" tasks. " << m_work.size() << " jobs outstanding.";
if (m_work.size() == 1)
{
check_precondition (m_idle);
m_journal.trace << "Waking up";
m_idle = false;
m_io_service.post (m_strand.wrap (boost::bind (
&NameResolverImpl::do_work, this,
CompletionCounter(this))));
}
}
}
void CAuthenticationCenter::PostErrorMessage(boost::shared_ptr<CTcpConnection> conn,
boost::asio::io_service::strand& strand,
const std::string& errmsg)
{
strand.post(boost::bind(
&CAuthenticationCenter::ReplyErrorMessage,
this,conn,errmsg
));
}
void process_message(message_ptr msg)
{
//std::cout << ">";
unsigned int msgid;
msg->get_object<unsigned int>(msgid);
logfile.log(boost::lexical_cast<std::string>(msgid));
//do_stuff(); //TODO: find a way to do_stuff() concurrently
reply_strand_.post(boost::bind(&session::send_reply, shared_from_this(), msg));
}
void stop_async () override
{
if (m_stop_called.exchange (true) == false)
{
m_io_service.dispatch (m_strand.wrap (std::bind (
&ResolverAsioImpl::do_stop,
this, CompletionCounter (this))));
JLOG(m_journal.debug()) << "Queued a stop request";
}
}
void stop_async ()
{
if (m_called_stop.exchange (1) == 0)
{
m_io_service.dispatch (m_strand.wrap (boost::bind (
&NameResolverImpl::do_stop,
this, CompletionCounter (this))));
m_journal.debug << "Stopping";
}
}
// Read a message from the websocket stream
void do_read()
{
// Put the read on the timer
timer_.expires_from_now(std::chrono::seconds(15));
// Read a message
ws_.async_read(buffer_,
strand_.wrap(std::bind(
&connection::on_read,
shared_from_this(),
std::placeholders::_1)));
}
void resolve (
std::vector <std::string> const& names,
HandlerType const& handler)
{
check_precondition (m_called_stop.load () == 0);
check_precondition (!names.empty());
// TODO NIKB use rvalue references to construct and move
// reducing cost.
m_io_service.dispatch (m_strand.wrap (boost::bind (
&NameResolverImpl::do_resolve, this,
names, handler, CompletionCounter(this))));
}
inline void connection::handle_read(const boost::system::error_code& e,
std::size_t bytes_transferred) {
if (!e) {
boost::tribool result;
boost::tie(result, boost::tuples::ignore) = request_parser_.parse(
*request_, buffer_.data(), buffer_.data() + bytes_transferred);
if (result) {
try {
request_handler_.handle_request(*request_, reply_);
} catch (webserver::reply rep) {
reply_ = rep;
}
std::cerr << reply_.content << std::endl;
boost::asio::async_write(socket_, reply_.to_buffers(),
strand_.wrap(
boost::bind(&connection::handle_write, shared_from_this(),
boost::asio::placeholders::error)));
} else if (!result) {
reply_ = reply::stock_reply(reply::bad_request);
boost::asio::async_write(socket_, reply_.to_buffers(),
strand_.wrap(
boost::bind(&connection::handle_write, shared_from_this(),
boost::asio::placeholders::error)));
} else {
socket_.async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
boost::bind(&connection::handle_read, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
}
}
// If an error occurs then no new asynchronous operations are started. This
// means that all shared_ptr references to the connection object will
// disappear and the object will be destroyed automatically after this
// handler returns. The connection class's destructor closes the socket.
}
void resolve (
std::vector <std::string> const& names,
HandlerType const& handler) override
{
assert (m_stop_called == false);
assert (m_stopped == true);
assert (!names.empty());
// TODO NIKB use rvalue references to construct and move
// reducing cost.
m_io_service.dispatch (m_strand.wrap (std::bind (
&ResolverAsioImpl::do_resolve, this,
names, handler, CompletionCounter (this))));
}
void handle_read(message_ptr msg,
const boost::system::error_code & error,
size_t bytes_transferred)
{
if (!error)
{
request_strand_.post(boost::bind(&session::process_message, shared_from_this(), msg));
poll_message();
}
else
{
error_handler_(error);
}
}
/// Set / reset the timeout timer
void setTimeout( unsigned timeout )
{
if ( timeout == 0 ) {
LOG_TRACE << "Timeout for connection to " << identifier() << " reset";
m_timer.cancel();
}
else {
m_timer.cancel();
m_timer.expires_from_now( boost::posix_time::seconds( timeout ));
m_timer.async_wait( m_strand.wrap( boost::bind( &ConnectionBase::handleTimeout,
this->shared_from_this(),
boost::asio::placeholders::error )));
LOG_TRACE << "Timeout for connection to " << identifier() << " set to " << timeout << "s";
}
}
WSClientImpl(Config const& cfg, bool v2)
: work_(ios_)
, strand_(ios_)
, thread_([&] {
ios_.run();
})
, stream_(ios_)
, ws_(stream_)
{
auto const ep = getEndpoint(cfg, v2);
stream_.connect(ep);
ws_.handshake(ep.address().to_string() +
":" + std::to_string(ep.port()), "/");
ws_.async_read(op_, rb_,
strand_.wrap(std::bind(&WSClientImpl::on_read_msg,
this, beast::asio::placeholders::error)));
}
void handle_timeout(const boost::system::error_code& ec)
{
if (--count_ > 0)
{
rc_->stop();
rc_.reset( new rc_check(timer_.io_service(), std::string(p_.pp.login).append("@").append(p_.pp.domain),
p_.pp.ukey, p_.l, 1) );
timer_.expires_from_now(boost::posix_time::milliseconds(rand_r(&seed_) % 500));
timer_.async_wait(strand_.wrap(boost::bind(&tormoz_get::handle_timeout, shared_from_this(), _1)));
}
else if (rc_)
{
rc_->stop();
rc_.reset();
}
}
void
onTimer (boost::system::error_code ec)
{
if (ec)
{
if (ec != boost::asio::error::operation_aborted)
journal_.error <<
"onTimer: " << ec.message();
return;
}
logic_.onTimer();
timer_.expires_from_now(std::chrono::seconds(1), ec);
timer_.async_wait(strand_.wrap(exec_.wrap(
std::bind(&ManagerImp::onTimer, this,
beast::asio::placeholders::error))));
}
void do_work (CompletionCounter)
{
if (m_called_stop.load () == 1)
return;
// We don't have any work to do at this time
if (m_work.empty())
{
m_idle = true;
m_journal.trace << "Sleeping";
return;
}
if (m_work.front().names.empty())
m_work.pop_front();
std::string const name (m_work.front().names.back());
HandlerType handler (m_work.front().handler);
m_work.front().names.pop_back();
HostAndPort const hp (parseName(name));
if (hp.first.empty())
{
m_journal.error <<
"Unable to parse '" << name << "'";
m_io_service.post (m_strand.wrap (boost::bind (
&NameResolverImpl::do_work, this,
CompletionCounter(this))));
return;
}
boost::asio::ip::tcp::resolver::query query (
hp.first, hp.second);
m_resolver.async_resolve (query, boost::bind (
&NameResolverImpl::do_finish, this, name,
boost::asio::placeholders::error, handler,
boost::asio::placeholders::iterator,
CompletionCounter(this)));
}
// Called immediately after the connection is created.
// We keep this separate from the constructor because
// shared_from_this may not be called from constructors.
void run()
{
// Run the timer
on_timer({});
// Put the handshake on the timer
timer_.expires_from_now(std::chrono::seconds(15));
// Read the websocket handshake and send the response
ws_.async_accept_ex(
[](websocket::response_type& res)
{
res.insert(http::field::server, "websocket-server-async");
},
strand_.wrap(std::bind(
&connection::on_accept,
shared_from_this(),
std::placeholders::_1)));
}
void
on_read_msg(error_code const& ec)
{
if(ec)
return;
Json::Value jv;
Json::Reader jr;
jr.parse(buffer_string(rb_.data()), jv);
rb_.consume(rb_.size());
auto m = std::make_shared<msg>(
std::move(jv));
{
std::lock_guard<std::mutex> lock(m_);
msgs_.push_front(m);
cv_.notify_all();
}
ws_.async_read(op_, rb_, strand_.wrap(
std::bind(&WSClientImpl::on_read_msg,
this, beast::asio::placeholders::error)));
}
void do_resolve (std::vector <std::string> const& names,
HandlerType const& handler, CompletionCounter)
{
assert (! names.empty());
if (m_stop_called == false)
{
m_work.emplace_back (names, handler);
JLOG(m_journal.debug()) <<
"Queued new job with " << names.size() <<
" tasks. " << m_work.size() << " jobs outstanding.";
if (m_work.size() > 0)
{
m_io_service.post (m_strand.wrap (std::bind (
&ResolverAsioImpl::do_work, this,
CompletionCounter (this))));
}
}
}
// Called after the message read completes
void on_read(error_code ec)
{
// This error means the other side
// closed the websocket stream.
if(ec == websocket::error::closed)
return;
if(ec)
return fail("read", ec);
// Put the write on the timer
timer_.expires_from_now(std::chrono::seconds(15));
// Write the received message back
ws_.binary(ws_.got_binary());
ws_.async_write(buffer_.data(),
strand_.wrap(std::bind(
&connection::on_write,
shared_from_this(),
std::placeholders::_1)));
}
void do_work (CompletionCounter)
{
if (m_stop_called == true)
return;
// We don't have any work to do at this time
if (m_work.empty ())
return;
std::string const name (m_work.front ().names.back());
HandlerType handler (m_work.front ().handler);
m_work.front ().names.pop_back ();
if (m_work.front ().names.empty ())
m_work.pop_front();
HostAndPort const hp (parseName (name));
if (hp.first.empty ())
{
JLOG(m_journal.error()) <<
"Unable to parse '" << name << "'";
m_io_service.post (m_strand.wrap (std::bind (
&ResolverAsioImpl::do_work, this,
CompletionCounter (this))));
return;
}
boost::asio::ip::tcp::resolver::query query (
hp.first, hp.second);
m_resolver.async_resolve (query, std::bind (
&ResolverAsioImpl::do_finish, this, name,
std::placeholders::_1, handler,
std::placeholders::_2,
CompletionCounter (this)));
}
void CAuthenticationCenter::PostRandomTGT(boost::shared_ptr<CTcpConnection> conn,
boost::asio::io_service::strand& strand,
UserInfo &unode)
{
strand.post(boost::bind(&CAuthenticationCenter::ProcessTGTMessage,this,conn,unode));
}
inline void connection::start() {
socket_.async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
boost::bind(&connection::handle_read, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
}
