//==============================================================================
// Timeout
// - Handles a timeout.
//==============================================================================
void ConnectionHandler::timeout( boost::shared_ptr<Connection> _connection, const boost::system::error_code& _error )
{
// Check if operation has been canceled
if(_error)
return;
// Removes the connection
boost::mutex::scoped_lock connection_lock( connection_mutex );
for( unsigned int i = 0; i < m_connections.size(); i++ )
{
if( m_connections[i]->connection_id == _connection->connection_id )
{
// Set delete flag
_connection->delete_flag = true;
// Remove connection from list
_connection->ack_timer.cancel();
m_connections.erase(m_connections.begin()+i);
// Handle the event
m_network_handler->handleEvent(_connection->connection_id, DISCONNECTED_EVENT);
// Remove all reliable packets in queue for sending
m_packet_handler->removeReliablePacketsTo(_connection);
break;
}
}
}
//==============================================================================
// Send
// - Sends packet to a specific connection.
//==============================================================================
void ConnectionHandler::send( boost::shared_ptr<Packet> _packet )
{
// Get connection
boost::mutex::scoped_lock connection_lock( connection_mutex );
boost::shared_ptr<Connection> connection = this->getConnectionByID( _packet->id() );
if( connection.get() == NULL )
return;
// Update timers
connection->ack_timer.expires_from_now( boost::posix_time::milliseconds(SEND_ACK_MS) );
connection->ack_timer.async_wait( boost::bind(&ConnectionHandler::requestAck, this, connection, boost::asio::placeholders::error) );
if( m_packet_handler->getPacketSetting(_packet->msg())->reliable && !m_network_handler->isServer() )
{
connection->sync_timer.expires_from_now( boost::posix_time::milliseconds(CLOCK_SYNC_MS) );
connection->sync_timer.async_wait( boost::bind(&ConnectionHandler::requestAck, this, connection, boost::asio::placeholders::error) );
}
// Send packet
boost::mutex::scoped_lock socket_lock( m_socket_mutex );
m_socket->async_send_to( boost::asio::buffer(_packet->data(), _packet->bytes()), connection->endpoint,
boost::bind(&ConnectionHandler::sent, this,
_packet,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred) );
}
void SQLiteDBManager::resetPrimary() {
auto& self = instance();
WriteLock connection_lock(self.mutex_);
self.connection_.reset();
{
WriteLock create_lock(self.create_mutex_);
sqlite3_close(self.db_);
self.db_ = nullptr;
}
}
/*
* Gets message(s) from publisher(s)
* - loops till all pubs are disconnected or sub exits (manually)
* - thread-safe
*/
void Subscriber::GetMessages()
{
// wait for the first remote host to connect
boost::mutex::scoped_lock connection_lock(connection_mutex_);
while(com_->NoConnections() && com_->Running())
{
com_->pending_first_condition()->wait(connection_lock);
}
// read from publishers
if (com_->Running())
{
com_->Read();
}
}
//==============================================================================
// Receive
// - Handle received data.
//==============================================================================
void ConnectionHandler::receive( const boost::system::error_code& _error,
std::size_t _bytes_transferred )
{
if( !_error )
{
// Don't handle empty messages.
if( _bytes_transferred < 1 )
return;
// Pack data into a packet.
PacketHeader* header = typeCast<char*, PacketHeader*>(m_receive_buffer.data());
PacketSettings* settings = m_packet_handler->getPacketSetting(header->message_id);
boost::shared_ptr<Packet> receive_packet( new Packet() );
if( !receive_packet->pack(m_receive_buffer.data(), _bytes_transferred) )
{
boost::mutex::scoped_lock io_lock( m_network_handler->io_mutex );
std::cout << "Your packet wazzz not containing any data..." << std::endl;
}
// Start listening again when data has been copied.
this->listen();
// Lock the connection mutex
boost::mutex::scoped_lock connection_lock( connection_mutex );
// Handle connection and get a connection handle.
boost::shared_ptr<Connection> connection = this->handleConnection(m_receive_endpoint);
// Stamp the packet with the sender ID
receive_packet->id( connection->connection_id );
// Now let packet handler take care of the packet.
m_packet_handler->receivePacket( receive_packet, connection );
}
else
{
this->listen();
boost::mutex::scoped_lock io_lock( m_network_handler->io_mutex );
//std::cout << "Receive Error: " << _error.message().c_str() << std::endl;
}
}
