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