int main(void)
{
#ifdef chat
InitScreen();
InitSystem();
ClientConnectChat(1);
MessageType();
ClientConnectChat(0);
DeleteScreen();
EndClient();
#endif
#ifdef server
ProcInit();
printf("server end \n");
#endif
#ifdef test
InitSystem();
#endif
return 0;
}
void CommsProcessor::serverCallback() {
string sourceAddress; // Address of datagram source
unsigned short sourcePort; // Port of datagram source
listenSocket.setLocalPort( svrPort );
// set up the listening socket
this->listenSocket.setRecvTimeout( 500 ); // 500 ms
while( running ) {
int bytesRcvd;
bytesRcvd = this->listenSocket.recvFrom( recvBuf, maxMsgSize, sourceAddress, sourcePort );
// if recieve call timedout then just start loop over
if( bytesRcvd == 0 )
continue;
Message *buf = (Message*)recvBuf;
switch( MessageType(buf->header.msgType) ) {
case MessageType::CLIENT_EVENT:
{
BufferReader readBuffer( buf->payload, buf->header.len);
EventType type = Event::getType( readBuffer );
Event* event = owner->eventCtors->invoke(readBuffer);
handoffQ->push( event );
break;
}
default:
break;
}
}
}
void GameClient::message_received(const char* msg) {
MessageType message_type = MessageType((msg[0] - 'A') * 26 + (msg[1] - 'A'));
const char* msg_contents = msg+2;
#ifdef DEBUG
fprintf(stderr, "Message received: \"%s\"\n", msg);
#endif
switch (message_type) {
case SHOOTER_MAP:
m_shooter->deserialize_map(msg_contents);
break;
case SHOOTER_STATE:
m_shooter->deserialize_state(msg_contents);
break;
case PING:
unsigned ping_start, ping_end;
ping_start = atoi(msg_contents);
ping_end = clock();
m_ping = ping_end - ping_start;
break;
case CLIENT_PLAYER_ID:
m_player_id = atoi(msg_contents);
break;
default:
fprintf(stderr, "Unknown message type: %d\n", message_type);
printf("Message was: %s\n", msg_contents);
break;
}
}
Variant ClientBase::sendBuffer(char type, RequestID requestID, std::ostringstream &stream)
{
unsigned int size = (unsigned int)stream.tellp();
size -= sizeof(size);
stream.seekp(0);
stream.write((const char*)&size, sizeof(size));
RequestData rd;
rd.type = MessageType(type);
rd.id = requestID;
rd.data = stream.str();
if(asyncMode())
{
rd.writeCompletePtr.reset(new FutureResult);
bool empty = m_messageQueue.empty();
m_messageQueue.push(rd);
if(empty)
{
writeData(m_messageQueue.front().data);
}
return rd.writeCompletePtr;
}
else
{
writeData(rd.data);
}
return Variant();
}
void Protocol::setFullMessage(const QString &fullMessage)
{
if (fullMessage.startsWith("$") and fullMessage.endsWith("$"))
{
QStringList msg = fullMessage.trimmed().split(";");
int type = msg.at(0).right(msg.at(0).size()-1).toInt();
header = MessageType(type);
if (msg.size() == 2)
body = msg.at(1).left(msg.at(1).size()-1);
else
body = msg.at(1);
QStringList commandList = msg.at(2).left(msg.at(2).size()-1).split(",");
QStringList command;
for (int i = 0; i < commandList.size(); i+=1)
{
command = commandList.at(i).split(":");
if (command.size() % 2 == 0)
otherCommands.insert(command.at(0).toLower(),QVariant(command.at(1)));
else
break;
}
}
}
void MessageManager::NotifyHandlers(MessageType msgType, char* msg)
{
//implements enum as int
for (int mt = DEFAULT_MSG; mt <= DEBUG_MSG; mt = mt << 1) {
if ((msgType & mt) == mt) {
auto range = m_handlers.equal_range(MessageType(mt));
for (auto iter = range.first; iter != range.second; iter++) {
iter->second->Notify(msg);
}
}
}
}
void MessagePump::EmitMessage(const Message& msg)
{
dtEntity::MessageType messageType = msg.GetType();
if(messageType == MessageType())
{
LOG_ERROR("Trying to send a message with an empty type string!");
return;
}
std::pair<MessageFunctorRegistry::iterator, MessageFunctorRegistry::iterator> keyRange;
keyRange = mMessageFunctors.equal_range(messageType);
// cannot call functors directly in loop because functors may call the
// RegisterForMessage function and invalidate the iterator.
typedef std::list<std::pair<MessageFunctor, StringId> > FunctorsToCall;
FunctorsToCall functorsToCall;
MessageFunctorRegistry::iterator it = keyRange.first;
while(it != keyRange.second)
{
MsgRegistryEntry entry = it->second;
unsigned int regoptions = entry.mOptions;
if((regoptions & FilterOptions::UNREGISTERED) != 0)
{
mMessageFunctors.erase(it++);
continue;
}
assert(messageType == it->first && "Something went wrong with message registration!");
functorsToCall.push_back(std::make_pair(entry.mFunctor, entry.mFuncName));
if((regoptions & FilterOptions::SINGLE_SHOT) != 0)
{
mMessageFunctors.erase(it++);
continue;
}
++it;
}
FunctorsToCall::iterator j;
for(j = functorsToCall.begin(); j != functorsToCall.end(); ++j)
{
#if DTENTITY_PROFILING_ENABLED
CProfileManager::Start_Profile(j->second);
#endif
(j->first)(msg);
#if DTENTITY_PROFILING_ENABLED
CProfileManager::Stop_Profile();
#endif
}
}
void CommsProcessor::clientCallback() {
string sourceAddress; // Address of datagram source
unsigned short sourcePort; // Port of datagram source
listenSocket.setLocalPort( clntPort );
// set up the listening socket
listenSocket.joinGroup( mcastAddr );
listenSocket.setRecvTimeout( 500 ); // 500 ms
while( running ) {
int bytesRcvd;
bytesRcvd = listenSocket.recvFrom( recvBuf, maxMsgSize, sourceAddress, sourcePort );
// if recieve call timedout then just start loop over
if( bytesRcvd == 0 )
continue;
Message *buf = (Message*)recvBuf;
switch( MessageType(buf->header.msgType) ) {
case MessageType::SERVER_EVENT:
{
BufferReader readBuffer( buf->payload, buf->header.len );
Event* event = owner->eventCtors->invoke(readBuffer);
if( event->getType() == EventType::UPDATE && owner->isRunning() ) {
if( owner->shouldProcessEvents() ) {
UpdateEvent* updateEvent = Event::cast<UpdateEvent>( event );
updateEvent->setChild( owner->objectCtors->invoke( readBuffer ) );
handoffQ->push( event );
} else delete event;
} else if ( owner->isRunning() ){
handoffQ->push( event );
} else {
delete event;
}
break;
}
case MessageType::SERVER_ANNOUNCE:
announceSignaled = true;
if( serverAddr == "255.255.255.255" ) {
serverAddr = sourceAddress;
}
cv.notify_one();
break;
default:
break;
}
}
listenSocket.leaveGroup( mcastAddr );
}
void MessageManager::UnRegisterHandler(IMessageHandler *hndlr, MessageType msgType)
{
//may call destructor on pointers???
for (int mt = DEFAULT_MSG; mt <= DEBUG_MSG; mt = mt << 1) {
if ((msgType & mt) == mt) {
auto range = m_handlers.equal_range(MessageType(mt));
auto iter = range.first;
while (iter != range.second)
{
if (iter->second == hndlr) {
auto temp = iter;
iter++;
m_handlers.erase(temp);
} else {
iter++;
}
}
}
}
}
std::vector< terrama2::core::ProcessLogger::Log > terrama2::core::ProcessLogger::getLogs(const ProcessId processId, uint32_t begin, uint32_t end) const
{
if(!isValid_)
throw terrama2::core::LogException() << ErrorDescription("Error on log!");
if(tableName_.empty())
{
QString errMsg = QObject::tr("Can not find log table name. Is it setted?");
TERRAMA2_LOG_ERROR() << errMsg;
throw terrama2::core::LogException() << ErrorDescription(errMsg);
}
if(begin > end)
std::swap(begin, end);
int rowNumbers = (end - begin) + 1;
std::string sql ="SELECT * FROM " + tableName_ +
" WHERE process_id = " + std::to_string(processId) +
" ORDER BY id DESC" +
" LIMIT " + std::to_string(rowNumbers) +
" OFFSET " + std::to_string(begin);
std::unique_ptr< te::da::DataSourceTransactor > transactor = dataSource_->getTransactor();
std::unique_ptr<te::da::DataSet> tempDataSet(transactor->query(sql));
std::vector< Log > logs;
while(tempDataSet->moveNext())
{
Log tempLog;
tempLog.id = tempDataSet->getInt32("id");
tempLog.processId = tempDataSet->getInt32("process_id");
tempLog.status = Status(tempDataSet->getInt32("status"));
tempLog.start_timestamp = std::shared_ptr<te::dt::TimeInstantTZ>(dynamic_cast<te::dt::TimeInstantTZ*>(tempDataSet->getDateTime("start_timestamp").release()));
tempLog.data_timestamp = std::shared_ptr<te::dt::TimeInstantTZ>(dynamic_cast<te::dt::TimeInstantTZ*>(tempDataSet->getDateTime("data_timestamp").release()));
tempLog.last_process_timestamp = std::shared_ptr<te::dt::TimeInstantTZ>(dynamic_cast<te::dt::TimeInstantTZ*>(tempDataSet->getDateTime("last_process_timestamp").release()));
tempLog.data = tempDataSet->getAsString("data");
std::string sqlMessages ="SELECT * FROM " + messagesTableName_ +
" WHERE log_id = " + std::to_string(tempLog.id) +
"ORDER BY id";
std::unique_ptr<te::da::DataSet> tempMessagesDataSet(transactor->query(sqlMessages));
std::vector< MessageLog > messages;
while(tempMessagesDataSet->moveNext())
{
MessageLog tempMessage;
tempMessage.id = tempMessagesDataSet->getInt32("id");
tempMessage.log_id = RegisterId(tempMessagesDataSet->getInt32("log_id"));
tempMessage.type = MessageType(tempMessagesDataSet->getInt32("type"));
tempMessage.description = tempMessagesDataSet->getAsString("description");
tempMessage.timestamp = std::shared_ptr<te::dt::TimeInstantTZ>(dynamic_cast<te::dt::TimeInstantTZ*>(tempMessagesDataSet->getDateTime("timestamp").release()));
messages.push_back(tempMessage);
}
tempLog.messages = messages;
logs.push_back(tempLog);
}
return logs;
}
NavMessage::MessageType
NavMessage::replyType( MessageType request ) {
return MessageType( request + 1 );
}
