void NetworkInterfaceASIO::_asyncRunCommand(AsyncOp* op, NetworkOpHandler handler) {
LOG(2) << "Starting asynchronous command " << op->request().id << " on host "
<< op->request().target.toString();
if (MONGO_FAIL_POINT(NetworkInterfaceASIOasyncRunCommandFail)) {
_validateAndRun(op, asio::error::basic_errors::network_unreachable, [] {});
return;
}
// We invert the following steps below to run a command:
// 1 - send the given command
// 2 - receive a header for the response
// 3 - validate and receive response body
// 4 - advance the state machine by calling handler()
auto cmd = op->command();
// Step 4
auto recvMessageCallback = [this, cmd, handler, op](std::error_code ec, size_t bytes) {
// We don't call _validateAndRun here as we assume the caller will.
handler(ec, bytes);
};
// Step 3
auto recvHeaderCallback = [this, cmd, handler, recvMessageCallback, op](std::error_code ec,
size_t bytes) {
// The operation could have been canceled after starting the command, but before
// receiving the header
_validateAndRun(op, ec, [this, op, recvMessageCallback, ec, bytes, cmd, handler] {
// validate response id
uint32_t expectedId = cmd->toSend().header().getId();
uint32_t actualId = cmd->header().constView().getResponseToMsgId();
if (actualId != expectedId) {
LOG(3) << "got wrong response:"
<< " expected response id: " << expectedId
<< ", got response id: " << actualId;
return handler(make_error_code(ErrorCodes::ProtocolError), bytes);
}
asyncRecvMessageBody(cmd->conn().stream(),
&cmd->header(),
&cmd->toRecv(),
std::move(recvMessageCallback));
});
};
// Step 2
auto sendMessageCallback = [this, cmd, handler, recvHeaderCallback, op](std::error_code ec,
size_t bytes) {
_validateAndRun(op, ec, [this, cmd, op, recvHeaderCallback] {
asyncRecvMessageHeader(
cmd->conn().stream(), &cmd->header(), std::move(recvHeaderCallback));
});
};
// Step 1
asyncSendMessage(cmd->conn().stream(), &cmd->toSend(), std::move(sendMessageCallback));
}
void
TextRequestDialog::MessageReceived(BMessage *message)
{
switch(message->what) {
case kMsgButton: {
if(!fInvoker || !fInvoker->Message())
return;
int32 which;
message->FindInt32("which", &which);
BMessage toSend(*fInvoker->Message());
toSend.AddInt32("which", which);
if(which == 1)
toSend.AddString("text", fTextControl->Text());
fInvoker->Invoke(&toSend);
PostMessage(B_QUIT_REQUESTED);
} break;
case kMsgUpdateControls:
UpdateControls();
break;
default:
BWindow::MessageReceived(message);
}
}
//=============================================================================
// METHOD: SPELLexecutorIPC::
//=============================================================================
void SPELLexecutorIPC::sendMessage( const std::string& executorId, const SPELLipcMessage& msg )
{
if (m_connected)
{
SPELLipcMessage toSend(msg);
m_ipc.sendMessage(toSend);
}
}
void GameController::update(void) {
Vec2 time = _viewportPosition.getValue();
//Log(time);
_scene->setViewportPosition(time);
updatePhysicElements();
Network::UdpPacket* packet = new Network::UdpPacket();
packet->setCode(Network::UdpProxy::PLAYER_DIRECTION);
*packet << GameInput::getInstance().getInputDirection();
Network::UdpProxy::ToSend toSend(packet, _remoteAddress, _remotePort);
_udpProxy->sendPacket(toSend);
}
void ADServerConnection::sendToClient(const QString &msg)
{
dDebug() << "SENDING: " << msg;
m_client->reset();
QTextStream out(m_client);
QString toSend(msg);
toSend.remove('\n');
out << toSend+"%%" << endl;
m_client->flush();
}
void PrologThread::sendData(QByteArray results)
{
QByteArray packet;
QDataStream out(&packet, QIODevice::WriteOnly);
QString toSend(results);
qDebug() << toSend;
out << (quint16) 0;
out << toSend;
out.device()->seek(0);
out << (quint16) (packet.size() - sizeof(quint16));
_socket->write(packet);
_socket->flush();
}
bool CreateItemAndMailToPlayer(Player *pPlayer, uint32 itemId)
{
Item *pItem = new Item();
if(pItem->Create(sObjectMgr->GenerateLowGuid(HIGHGUID_ITEM), itemId, pPlayer) == false)
return false;
MailSender toSend(MAIL_NORMAL, pPlayer->GetGUIDLow(), MAIL_STATIONERY_GM);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
pItem->SaveToDB(trans);
MailDraft mailDraft(REQUESTER_DEFAULT_MAIL_SUBJECT, REQUESTER_DEFAULT_MAIL_BODY);
mailDraft.AddItem(pItem);
mailDraft.SendMailTo(trans, MailReceiver(pPlayer), toSend);
CharacterDatabase.CommitTransaction(trans);
return true;
}
//=============================================================================
// METHOD: SPELLexecutorIPC::
//=============================================================================
SPELLipcMessage SPELLexecutorIPC::sendRequest( const std::string& executorId, const SPELLipcMessage& msg, unsigned long timeoutMsec )
{
if (m_connected)
{
SPELLipcMessage toSend(msg);
return m_ipc.sendRequest(toSend,timeoutMsec);
}
else
{
SPELLipcMessage resp = SPELLipcHelper::createErrorResponse("IpcErrorResponse", msg);
resp.set( MessageField::FIELD_ERROR, "Cannot send request" );
resp.set( MessageField::FIELD_REASON, "IPC not connected");
resp.set( MessageField::FIELD_FATAL, PythonConstants::True );
return resp;
}
}
void TowerDefenseInstanceScript::TowerDefenseMapInstanceScript::SendMailToPlayer(Player *player, uint32 playerGUID, const char *mailMessage, ...)
{
MailSender toSend(MAIL_NORMAL, playerGUID, TD_SYSTEM_MAIL_TYPE);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
char Body[1024];
va_list List;
va_start(List, mailMessage);
vsnprintf(Body, 1024, mailMessage, List);
va_end(List);
MailDraft mailDraft(TD_SYSTEM_MSG_MAIL_SUBJECT, Body);
if(player){
mailDraft.SendMailTo(trans, MailReceiver(player), toSend);
RecordLog("TowerDefense: Player: [%s] received the mail: [%s] from the tower defense system.", player->GetName(), Body);
}
else{
mailDraft.SendMailTo(trans, MailReceiver(playerGUID), toSend);
RecordLog("TowerDefense: Player GUID: [%u] received the mail: [%s] from the tower defense system.", playerGUID, Body);
}
CharacterDatabase.CommitTransaction(trans);
}
//=============================================================================
// METHOD: SPELLclientIPC::
//=============================================================================
SPELLipcMessage SPELLclientIPC::sendRequest( int clientKey, const SPELLipcMessage& msg, unsigned long timeoutMsec )
{
SPELLipcMessage toSend(msg);
return m_ipc.sendRequest(clientKey,toSend,timeoutMsec);
}
//=============================================================================
// METHOD: SPELLclientIPC::
//=============================================================================
void SPELLclientIPC::sendMessage( int clientKey, const SPELLipcMessage& msg )
{
SPELLipcMessage toSend(msg);
m_ipc.sendMessage(clientKey,toSend);
}
void computeKmerFrequencyIncreasing(std::vector<T>& localvector, MPI_Comm comm = MPI_COMM_WORLD)
{
//Know my rank
int rank;
MPI_Comm_rank(comm, &rank);
static layer_comparator<kmerLayer, T> kmerCmp;
auto start = localvector.begin();
auto end = localvector.end();
//Sort by kmer, read id
mxx::sort(start, end,
[](const T& x, const T&y){
return (std::get<kmerLayer>(x) < std::get<kmerLayer>(y)
|| (std::get<kmerLayer>(x) == std::get<kmerLayer>(y)
&& std::get<readIdLayer>(x) < std::get<readIdLayer>(y)));
},
comm, false);
//Keep frequency for leftmost and rightmost kmers seperately
//Tuples of KmerId and count
using tupleType = std::tuple<uint64_t, uint64_t>;
std::vector<tupleType> toSend(2);
for(auto it = start; it!= end;) // iterate over all segments.
{
auto innerLoopBound = findRange(it, end, *it, kmerCmp);
//Leftmost bucket, appends information for sending to other ranks
if(innerLoopBound.first == start)
{
std::get<0>(toSend[0]) = std::get<kmerLayer>(*start);
std::get<1>(toSend[0]) = (innerLoopBound.second - innerLoopBound.first);
}
//Rightmost bucket
else if(innerLoopBound.second == end)
{
std::get<0>(toSend[1]) = std::get<kmerLayer>(*innerLoopBound.first);
std::get<1>(toSend[1]) = innerLoopBound.second - innerLoopBound.first;
for(auto it1 = innerLoopBound.first; it1 != innerLoopBound.second; it1++)
std::get<tmpLayer>(*it1) = std::distance(innerLoopBound.first, it1) + 1;
}
else
{
//Mark frequency as 1,2...totalCount
for(auto it1 = innerLoopBound.first; it1 != innerLoopBound.second; it1++)
std::get<tmpLayer>(*it1) = std::distance(innerLoopBound.first, it1) + 1;
}
it = innerLoopBound.second;
}
auto allBoundaryKmers = mxx::allgather_vectors(toSend);
static layer_comparator<0, tupleType> gatherCmp;
//Left boundary case
//Count size only on the left side of this rank
auto leftBucketBoundaryRange = std::equal_range(allBoundaryKmers.begin(), allBoundaryKmers.begin() + 2*rank, toSend[0], gatherCmp);
uint64_t leftBucketSize = 0;
for(auto it = leftBucketBoundaryRange.first; it != leftBucketBoundaryRange.second; it++)
{
leftBucketSize += std::get<1>(*it);
}
{
//Update leftmost bucket
auto innerLoopBound = findRange(start, end, *start, kmerCmp);
for(auto it = innerLoopBound.first; it != innerLoopBound.second; it ++)
std::get<tmpLayer>(*it) = leftBucketSize + (std::distance(innerLoopBound.first, it) + 1);
}
}
void computeKmerFrequencyAbsolute(std::vector<T>& localvector, MPI_Comm comm = MPI_COMM_WORLD)
{
//Know my rank
int rank;
MPI_Comm_rank(comm, &rank);
static layer_comparator<kmerLayer, T> kmerCmp;
auto start = localvector.begin();
auto end = localvector.end();
//Sort by kmer id
mxx::sort(start, end, kmerCmp, comm, false);
//Keep frequency for leftmost and rightmost kmers seperately
//Tuples of KmerId and count
using tupleType = std::tuple<uint64_t, uint64_t>;
std::vector<tupleType> toSend(2);
for(auto it = start; it!= end;) // iterate over all segments.
{
auto innerLoopBound = findRange(it, end, *it, kmerCmp);
//Leftmost bucket, appends information for sending to other ranks
if(innerLoopBound.first == start)
{
std::get<0>(toSend[0]) = std::get<kmerLayer>(*start);
std::get<1>(toSend[0]) = (innerLoopBound.second - innerLoopBound.first);
}
//Rightmost bucket
else if(innerLoopBound.second == end)
{
std::get<0>(toSend[1]) = std::get<kmerLayer>(*innerLoopBound.first);
std::get<1>(toSend[1]) = innerLoopBound.second - innerLoopBound.first;
uint64_t currentCount = innerLoopBound.second - innerLoopBound.first;
std::for_each(innerLoopBound.first, innerLoopBound.second, [currentCount](T &t){ std::get<tmpLayer>(t) = currentCount;});
}
else
{
uint64_t currentCount = innerLoopBound.second - innerLoopBound.first;
std::for_each(innerLoopBound.first, innerLoopBound.second, [currentCount](T &t){ std::get<tmpLayer>(t) = currentCount;});
}
it = innerLoopBound.second;
}
auto allBoundaryKmers = mxx::allgather_vectors(toSend);
static layer_comparator<0, tupleType> gatherCmp;
//Left boundary case
//Count size only on the left side of this rank
auto leftBucketBoundaryRange = std::equal_range(allBoundaryKmers.begin(), allBoundaryKmers.end(), toSend[0], gatherCmp);
uint64_t leftBucketSize = 0;
for(auto it = leftBucketBoundaryRange.first; it != leftBucketBoundaryRange.second; it++)
{
leftBucketSize += std::get<1>(*it);
}
{
//Update leftmost bucket
auto innerLoopBound = findRange(start, end, *start, kmerCmp);
std::for_each(innerLoopBound.first, innerLoopBound.second, [leftBucketSize](T &t){ std::get<tmpLayer>(t) = leftBucketSize;});
}
}
QList<QString> MessageController::setgetWLTime(QList<QString> aList,QDateTime to,QDateTime from)
{
QList<QString> returnList;
QString anId;
int id = rand() % 5000;
// int id = 2705;
anId.setNum(id);
qDebug() << id;
QString toString = to.toString("yyyy-MM-dThh:mm:ss");
QString fromString =from.toString("yyyy-MM-dThh:mm:ss");
int size = aList.size();
int k=0; //for sending
int i=0; //For searching through the list of received
QString compareString;
//Facility A demands
//WILL BE TO CHANGED W/ ID HERE FOR LOOP
toSend(XMLReader::getInstance()->requestWaitTimes(anId,toString,fromString));
//Example that we received asking us our bed.
//Facility B receive this
// receivedMessage.append("<?xml version=\"1.0\" encoding=\"utf-8\"?><Request ID=\"2705\"><Report startDate=\"2002-05-30T09:00:00\" endDate=\"1994-05-30T09:00:00\"><FacilityRecord><Facility ID=\"7\"/><ACRecord occupied=\"500\"/><CCCRecord occupied=\"0\"/><LTCRecord occupied=\"0\"/></FacilityRecord></Report></Request>");
// receivedMessage.append("<?xml version=\"1.0\" encoding=\"utf-8\"?><Request ID=\"2705\"><Report startDate=\"2002-05-30T09:00:00\" endDate=\"1994-05-30T09:00:00\"><FacilityRecord><Facility ID=\"7\"/><ACRecord occupied=\"25\"/><CCCRecord occupied=\"0\"/><LTCRecord occupied=\"0\"/></FacilityRecord></Report></Request>");
QTime t;
t.start();
t.restart();
qDebug() << t.elapsed();
//For 10 seconds
//Wait to see if B will answers
while((t.elapsed() < 10000) && (returnList.size() < size))
{
//Check for each element in the received list if they have the id requested
while(i <reportList.size())
{
QString requestID;
compareString = reportList.at(i);
QDomDocument doc("xmldocument");
if (doc.setContent(compareString)) {
//Get the root element
QDomElement root = doc.documentElement();
requestID = root.attribute("ID");
}
//If they are equal then add to return list and remove from received list.
if (requestID == anId)
{
returnList.append(reportList.at(i));
reportList.removeAt(i);
}
i++;
}
//Retake time
}
qDebug() << t.elapsed();
qDebug() <<"Size "<<returnList.size();
if(returnList.empty())
returnList.append("Empty");
return returnList;
}
/* The send command function. Waits for numResults number of reply messages */
ptr_GSM_msg GSM::sendCommand(string c, int numResults)
{
/* Smart pointer object with message */
ptr_GSM_msg returnMessage(new GSMMessage);
/* Exit if the module is off */
if (!powerOn)
{
returnMessage->addMessage("PowerOff");
return returnMessage;
}
/* Add message to send queue */
GSMMessage toSend(c,1);
sendQueue.put(&toSend);
/* Wait for reply */
mRespWaiting.lock();
int me = respWaiting;
me %= respLength;
respWaiting+=numResults;
mRespWaiting.unlock();
int rxed = 0;
/* Start timeout */
timeout = false;
timeoutTimer.start(TIMEOUT*1000);
/* Get reply messages. RX thread will set replyFor to our value and then we will get message from queue */
while (rxed < numResults)
{
/* Timed out so exit */
if (timeout)
{
for (int i = rxed; i < numResults; i++)
{
returnMessage->addMessage("TIMEOUT");
}
mRespWaiting.lock();
respWaiting -= (numResults - rxed);
mRespWaiting.unlock();
break;
}
/* See if message is recieved for us */
mRespWaiting.lock();
if (replyFor == me)
{
/* If it is, get from queue */
rxed++;
me++;
me%=respLength;
osEvent e = sendCommandReplyQueue.get();
if (e.status == osEventMessage)
{
/* Add the message to our return message */
string* m = ((string*) e.value.p);
returnMessage->addMessage(*m);
/* If an error on GSM module then rest of expected results will not be coming */
if ((*m).find("ERROR") != string::npos)
{
//Clear remaining requests because of error.
for (int i = rxed; i < numResults; i++)
{
returnMessage->addMessage("ERR_CLEARED");
}
mRespWaiting.lock();
respWaiting -= (numResults - rxed);
mRespWaiting.unlock();
rxed = numResults;
}
/* Delete receieved message */
delete m;
}
timeout = false;
timeoutTimer.start(TIMEOUT * 1000);
}
else
{
Thread::wait(10);
}
mRespWaiting.unlock();
}
/* Recieved all messages */
mRespWaiting.lock();
if (respWaiting == 0)
{
replyFor = -1;
}
waitingForReply = false;
mRespWaiting.unlock();
/* And send message back to function, unblocking */
return returnMessage;
}
