virtual void _Reply_data(std::shared_ptr<protocol::Invoke> invoke) override final { if (invoke->has("_History_uid") == true) { // REGISTER THIS PROCESS ON HISTORY LIST std::shared_ptr<slave::InvokeHistory> history(new slave::InvokeHistory(invoke)); progress_list_.insert({ history->getUID(), history }); if (invoke->has("_Piece_first") == true) { // PARALLEL PROCESS size_t first = invoke->get("_Piece_first")->getValue<size_t>(); size_t last = invoke->get("_Piece_last")->getValue<size_t>(); invoke->erase(invoke->end() - 2, invoke->end()); ((base::ParallelSystemArrayBase*)system_array_)->sendPieceData(invoke, first, last); } else if (invoke->has("_Process_name") == true) { // DISTRIBUTED PROCESS auto ds_system_array = (distributed::base::DistributedSystemArrayBase*)system_array_; // FIND THE MATCHED ROLE const std::string &process_name = invoke->get("_Process_name")->getValue<std::string>(); if (ds_system_array->hasProcess(process_name) == false) return; // SEND DATA VIA THE ROLE auto process = ds_system_array->getProcess(process_name); ((distributed::base::DistributedProcessBase*)(process.get()))->sendData(invoke, 1.0); } } else replyData(invoke); };
R operator()(Ps... ps){ std::stringstream pss; serialize(pss, ps...); auto data = pss.str(); int msgno = data.size() / BT_MSG_MAX; bt_msg_header msg; while(msgno >= 0){ size_t len = std::min(BT_MSG_MAX, data.size()); msg.flags = 0; msg.type = msgtype; msg.to = pid; msg.length = len; msg.source = msgno--; msg.content = (void*)data.c_str(); msg.id = bt_send(msg); if(msgno >= 0) data = data.substr(len); } bt_msg_header reply; bt_msg_filter filter; std::stringstream rss; bool more_data = true; while(more_data){ filter.flags = bt_msg_filter_flags::Reply; filter.reply_to = msg.id; reply = bt_recv_filtered(filter, true); while(reply.reply_id != msg.id){ std::stringstream ss; ss << "RPC: Spurious message!" << std::endl; ss << "Message id: " << reply.id << std::endl; ss << "From : " << reply.from << std::endl; ss << "Flags : " << reply.flags << std::endl; ss << "Reply ID: " << reply.reply_id << " (Waiting for: " << msg.id << ")" << std::endl; bt_zero(ss.str().c_str()); bt_next_msg_filtered(&reply, filter); } std::vector<char> replyData(reply.length); bt_msg_content(&reply, &replyData[0], reply.length); rss.write(&replyData[0], replyData.size()); if(reply.type == MessageType_Continue){ msg.flags = bt_msg_flags::Reply; msg.reply_id = reply.id; msg.type = MessageType_Continue; msg.to = pid; msg.length = 0; msg.content = nullptr; msg.id = bt_send(msg); more_data = true; }else{ more_data = false; } bt_msg_ack(&reply); } rss.seekg(0); R ret; deserialize(rss, ret); return ret; }
void JPseudoServerInformationProcessor::processDownloadData(JSocket* socket, const JHead& head) { JInformationRequestByHeadBase req(JMainClientSocket::instance(),this); JTime_t localMtime=req.getLastLocalMtime(); QByteArray data; req.rqsInformationData(head); if(req.waitForInformationData(head,1000)){ localMtime=req.getLocalMtime(head); data = req.getInformationData(head); } replyData(socket,head,localMtime,data); }
virtual void _Reply_data(std::shared_ptr<protocol::Invoke> invoke) override { if (invoke->has("_History_uid")) { std::thread([this, invoke]() { // INIT HISTORY - WITH START TIME std::shared_ptr<InvokeHistory> history(new InvokeHistory(invoke)); invoke->erase("_History_uid"); invoke->erase("_Process_name"); invoke->erase("_Process_weight"); // MAIN PROCESS - REPLY_DATA std::shared_ptr<PInvoke> pInvoke(new PInvoke(invoke, history, this)); replyData(pInvoke); // NOTIFY - WITH END TIME if (pInvoke->isHold() == false) pInvoke->complete(); }).detach(); } else replyData(invoke); };
void BdLogic::replyFinished() { QByteArray replyData(m_reply->readAll()); if(m_replyGotError) { return; } qDebug() << BoxNames[m_dlState] << " reply body:\n" << replyData; // TODO: if state is login, check if it worked .... if(m_dlState != DLSTATE_LOGIN) { QJson::Parser parser; bool parsedOk = true; if(m_dlState == DLSTATE_INACTIVEPROJECTS) { m_boxMapRawJson[BoxNames[m_dlState]] += replyData; m_boxMapRawJson[BoxNames[m_dlState]] += "\n"; m_inactiveProjectListParsedJson.push_back(parser.parse(replyData, &parsedOk)); m_currentInactiveProjectDlIx++; } else { m_boxMapRawJson[BoxNames[m_dlState]] = replyData; m_boxMapParsedJson[BoxNames[m_dlState]] = parser.parse(replyData, &parsedOk); if(m_dlState == DLSTATE_RESOURCES) { buildInactiveProjectList(); } } if(!parsedOk) { m_statusString = QString("Error parsing JSON from URL: "); if(m_dlState == DLSTATE_RESOURCES) { m_statusString += DOIT_RESOURCES_DATA_URL; } else { m_statusString += DOIT_BASE_DATA_URL; m_statusString += BoxNames[m_dlState]; } // User doesn't really need to know line number of error, // but print during development: qDebug() << m_statusString << ": " << parser.errorString() << ", on line: " << parser.errorLine(); m_statusCode = BDLOGIC_STATUS_JSON_PARSE_ERROR; emit downloadStatusUpdated(m_statusCode, m_statusString); m_reply->deleteLater(); return; } } // After this, I can re-use my QNetworkReply pointer m_reply->deleteLater(); if(m_dlState != DLSTATE_INACTIVEPROJECTS) { m_dlState++; } // Catch no inactive projects, as soon as state is entered if(m_dlState == DLSTATE_INACTIVEPROJECTS) { if(m_currentInactiveProjectDlIx >= m_inactiveProjectUUIDList.length()) { m_dlState++; } } if(m_dlState != DLSTATE_FINISHED) { QNetworkRequest request; QString boxUrl; if(m_dlState == DLSTATE_RESOURCES) { boxUrl = DOIT_RESOURCES_DATA_URL; } else if(m_dlState == DLSTATE_INACTIVEPROJECTS) { boxUrl = DOIT_BASE_DATA_URL "project/"; boxUrl += QUrl::toPercentEncoding(m_inactiveProjectUUIDList[m_currentInactiveProjectDlIx]); } else { boxUrl = DOIT_BASE_DATA_URL; boxUrl += BoxNames[m_dlState]; } request.setUrl(boxUrl); m_reply = m_netManager->get(request); connect(m_reply, SIGNAL(finished()), this, SLOT(replyFinished())); connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(replyError(QNetworkReply::NetworkError))); connect(m_reply, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(replySSLError(QList<QSslError>))); m_statusString = QString("Downloading data for box: "); m_statusString += BoxNames[m_dlState]; emit downloadStatusUpdated(m_statusCode, m_statusString); } else { m_statusCode = BDLOGIC_STATUS_DOWNLOAD_FINISHED; m_statusString = QString("Downloading finished"); addInactiveProjectTasksToBoxes(); SetDataModelOrdering(0); emit downloadStatusUpdated(m_statusCode, m_statusString); qDebug() << m_statusString; } }
void CentralServerConnection::onReceive(const Archive::ByteStream & message) { Archive::ReadIterator ri = message.begin(); GameNetworkMessage msg(ri); ri = message.begin(); if(msg.isType("ConGenericMessage")) { // dispatch to CentralCommandParser ConGenericMessage con(ri); Unicode::String wideResult; m_centralCommandParser->parse(NetworkId(static_cast<NetworkId::NetworkIdType>(con.getMsgId())), Unicode::narrowToWide(con.getMsg()), wideResult); ConGenericMessage response(Unicode::wideToNarrow(wideResult), con.getMsgId()); send(response, true); } else if(msg.isType("CharacterTransferStatusMessage")) { CharacterTransferStatusMessage c(ri); CreatureObject * character = safe_cast<CreatureObject *>(NetworkIdManager::getObjectById(c.getToCharacterId())); if(character) { if(character->getClient()) { character->receiveCharacterTransferStatusMessage(c.getStatusMessage()); } } } else if(msg.isType("TransferRequestNameValidation")) { const GenericValueTypeMessage<TransferCharacterData> requestNameValidation(ri); LOG("CustomerService", ("CharacterTransfer: Received TransferRequestNameValidation from CentralServer : %s", requestNameValidation.getValue().toString().c_str())); std::string name = requestNameValidation.getValue().getDestinationCharacterName(); if(name.empty()) { name = requestNameValidation.getValue().getSourceCharacterName(); } // call the same name validation code that gets called for normal character creation std::string templateName = requestNameValidation.getValue().getObjectTemplateName(); if (templateName.empty()) { uint32 const templateCrc = requestNameValidation.getValue().getObjectTemplateCrc(); if (templateCrc != 0) { templateName = ObjectTemplateList::lookUp(templateCrc).getString(); } } VerifyAndLockNameRequest const verifyRequest(requestNameValidation.getValue().getDestinationStationId(), NetworkId::cms_invalid, templateName, Unicode::narrowToWide(name), 0xFFFFFFFF); StringId const verifyResult = GameServer::getInstance().handleVerifyAndLockNameRequest(verifyRequest, false, false); TransferCharacterData replyData(requestNameValidation.getValue()); replyData.setIsValidName(verifyResult == NameErrors::nameApproved); GenericValueTypeMessage<std::pair<std::string, TransferCharacterData> > reply("TransferReplyNameValidation", std::make_pair(std::string("@") + verifyResult.getCanonicalRepresentation(), replyData)); send(reply, true); } else if(msg.isType("TransferReplyCharacterList")) { const TransferReplyCharacterList reply(ri); const AvatarList & oldAl = reply.getAvatarList(); // remove any characters from the list that would qualify for free CTS; characters that // qualify for free CTS should/must use the in-game free CTS to transfer the character; AvatarList newAl; std::string const & clusterName = GameServer::getInstance().getClusterName(); for (AvatarList::const_iterator iter = oldAl.begin(); iter != oldAl.end(); ++iter) { if (!FreeCtsDataTable::getFreeCtsInfoForCharacter(static_cast<time_t>(NameManager::getInstance().getPlayerCreateTime(iter->m_networkId)), clusterName, false)) newAl.push_back(*iter); else LOG("CustomerService", ("CharacterTransfer: removing (%s, %s, %s) from paid CTS character list for station id %u because the character qualifies for free CTS", clusterName.c_str(), Unicode::wideToNarrow(iter->m_name).c_str(), iter->m_networkId.getValueString().c_str(), reply.getStationId())); } // send updated character list back to CentralServer const TransferReplyCharacterList updatedReply(reply.getTrack(), reply.getStationId(), newAl); send(updatedReply, true); } else if(msg.isType("CtsCompletedForcharacter")) { const GenericValueTypeMessage<std::pair<std::string, NetworkId> > msg(ri); MessageToQueue::getInstance().sendMessageToJava(msg.getValue().second, "ctsCompletedForCharacter", std::vector<int8>(), 0, false); } else if( msg.isType( "GameServerCSRequest" ) ) { GameServerCSRequestMessage request( ri ); GameServer::getInstance().handleCSRequest( request ); } else if( msg.isType( "CSFindAuthObject" ) ) { // see if we have the object. GenericValueTypeMessage< std::pair<NetworkId, unsigned int> > msg( ri ); ServerObject * object = safe_cast<ServerObject *>( NetworkIdManager::getObjectById( msg.getValue().first ) ); // return an appropriate response. if( object && object->isAuthoritative() ) { GenericValueTypeMessage< std::pair< unsigned int, bool > > rmsg( "CSFindAuthObjectReply", std::make_pair( msg.getValue().second, true ) ); GameServer::getInstance().sendToCentralServer( rmsg ); } else { GenericValueTypeMessage< std::pair< unsigned int, bool > > rmsg( "CSFindAuthObjectReply", std::make_pair( msg.getValue().second, false ) ); GameServer::getInstance().sendToCentralServer( rmsg ); } } else { ServerConnection::onReceive(message); } }