void UpdateStatsPacket::QueueUpdate(unsigned int nwId, ObjectAttributeIndex index, double value) {
updateLock.lock();
auto updates = updateQueue.find(nwId);
if(updates != updateQueue.end()) {
updates->second[index] = value;
//std::cout << "[0] Queued Stat update with value: " << value << std::endl;
} else {
std::unordered_map<ObjectAttributeIndex, double> attributes;
attributes[index] = value;
updateQueue[nwId] = attributes;
//std::cout << "[1] Queued Stat update with value: " << value << std::endl;
}
//std::cout << updateQueue[nwId].size() << " attribute updates of this object in total." << std::endl;
if(updateQueue.size() >= UCHAR_MAX) {
SendQueue();
} else if(!updateFired) {
updateFired = true;
//just wait a little and then send them batched together
//todo: make this batched stuff in a dedicated thread loop
std::async(std::launch::async, []() {
//std::cout << "Started Async sending..." << std::endl;
std::chrono::milliseconds delay(100);
std::this_thread::sleep_for(delay);
SendQueue();
updateFired = false;
});
}
updateLock.unlock();
}
void SocketEndpoint::HandleSend(const ErrorCode& error, const size_t& bytes_sent)
{
if (error)
{
Close();
}
AddSent(bytes_sent);
SendQueue();
}
void ClientContext::start()
{
m_security.GenerateHandshake(
GlobalConfigs::UseBlowfish (),
GlobalConfigs::UseSecurityBytes (),
GlobalConfigs::UseHandshake () );
SendQueue();
m_socket.async_receive(
boost::asio::buffer(m_message, 4096),
boost::bind(&ClientContext::message_recv, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
int McuMessageHandler::PopQueue(int id, int seq, unsigned long *data, unsigned long *data2)
{
int ret = 0;
pthread_mutex_lock(&m_queueMutex);
if(m_waitingQueue.size() <= 0)
{
LogUtility::Log(LOG_LEVEL_ERROR, "McuMessageHandler::PopQueue waiting queue empty.");
pthread_mutex_unlock(&m_queueMutex);
return -1;
}
StruMcuPacket *packet = *(m_waitingQueue.begin());
if((packet->id == id) && (packet->seq == seq))
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::PopQueue correct resp.");
if(data)
{
*data = packet->data;
}
if(data2)
{
*data2 = packet->data2;
}
m_waitingQueue.pop_front();
DestroyPacket(packet);
StopTimer(m_retryTimer);
if(m_waitingQueue.size() > 0)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::PopQueue send queue");
SendQueue();
}
}
else
{
LogUtility::Log(LOG_LEVEL_ERROR, "McuMessageHandler::PopQueue incorrect resp(%d, %04x).", packet->seq, packet->id);
ret = -1;
}
pthread_mutex_unlock(&m_queueMutex);
return ret;
}
void ClientContext::message_recv(const boost::system::error_code &ec, std::size_t recv)
{
if(!m_socket.is_open())
{
disconnected(CLIENT_LOST_CONNECTION);
return;
}
if(!ec)
{
printl("Client sent message to server. \n");
//////////////////////////////////////////////////////////////////////////////////////
m_security.Recv(m_message, recv);
PacketContainer pc;
if(m_security.HasPacketToRecv()) // else it was a security packet.
{
pc = m_security.GetPacketToRecv();
HandleMessage(&pc);
}
else
{
SendQueue();
}
// after packet handled, receive a new one.
m_socket.async_receive(
boost::asio::buffer(m_message, 4096),
boost::bind(&ClientContext::message_recv, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
else
{
if(recv == 0)
{
disconnected(CLIENT_LOST_CONNECTION);
return;
}
std::cout << "Error occured: " << ec.message() << std::endl;
}
};
int McuMessageHandler::PushQueue(StruMcuPacket *packet)
{
pthread_mutex_lock(&m_queueMutex);
if(m_waitingQueue.size() >= MCU_MAX_WAITING_QUEUE)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::PushQueue full");
pthread_mutex_unlock(&m_queueMutex);
DestroyPacket(packet);
return -1;
}
m_waitingQueue.push_back(packet);
if(m_waitingQueue.size() == 1)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::PushQueue empty");
SendQueue();
}
pthread_mutex_unlock(&m_queueMutex);
return 0;
}
void McuMessageHandler::HandleRetryTimer(void *)
{
pthread_mutex_lock(&m_queueMutex);
if(m_waitingQueue.size() <= 0)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::HandleRetryTimer empty");
pthread_mutex_unlock(&m_queueMutex);
return ;
}
StruMcuPacket *packet = *(m_waitingQueue.begin());
if(packet->retry > MCU_MAX_RETRY_TIMES)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::HandleRetryTimer %d reach limit", packet->id);
m_waitingQueue.pop_front();
if((packet->id == MCU_POS_GET_PASSENGER) || (packet->id == MCU_POS_GET_DEAL))
{
int index = packet->data2;
m_passengerRecord[index].state = STATE_TIMER;
StartTimer(m_passengerRecord[index].posPassengerRecordTimer);
}
DestroyPacket(packet);
if(m_waitingQueue.size() > 0)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::HandleRetryTimer proceed to next message");
SendQueue();
}
}
else
{
SendPacket(packet);
packet->retry ++;
StartTimer(m_retryTimer);
}
pthread_mutex_unlock(&m_queueMutex);
}
