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; }