LPSTR HttpPost(HANDLE hUser, LPSTR reqUrl, LPSTR reqParams)
{
NETLIBHTTPREQUEST nlhr = { sizeof(nlhr) };
nlhr.requestType = REQUEST_POST;
nlhr.flags = NLHRF_HTTP11 | NLHRF_SSL | NLHRF_NODUMP | NLHRF_NODUMPHEADERS;
nlhr.szUrl = reqUrl;
nlhr.headers = (NETLIBHTTPHEADER*)&HEADER_URL_ENCODED;
nlhr.headersCount = 1;
nlhr.pData = reqParams;
nlhr.dataLength = (int)mir_strlen(reqParams);
NLHR_PTR pResp((NETLIBHTTPREQUEST*)CallService(MS_NETLIB_HTTPTRANSACTION, (WPARAM)hUser, (LPARAM)&nlhr));
return ((pResp && pResp->resultCode == HTTP_OK) ? mir_strdup(pResp->pData) : nullptr);
}
int PeerNode::TaskExecuteResponse(int taskId, bool status)
{
int result = 0;
ResponseMessagePtr pResp(new ResponseMessage);
int fromPeerId = Peer::GetPeer()->GetPeerId();
Log(CONSOLE, L"Sending TASK EXECUTE RESPONSE, status : %b, task-id: %d to Peer: %d\n", status, taskId, m_peerId);
pResp->AddGeneralHeader((RESP_TYPE)TASK_EXECUTE_RESP, fromPeerId, status);
MessageMap mmap;
mmap["taskid"] = boost::lexical_cast<string>(taskId);
pResp->AddTaskInfo(mmap);
std::string xml = pResp->GetXML();
result = this->SendMessage(xml);
return result;
}
int PeerNode::TaskResponse(int taskId, bool status)
{
int result = 0;
ResponseMessagePtr pResp(new ResponseMessage);
int fromPeerId = Peer::GetPeer()->GetPeerId();
Log(CONSOLE, L"Sending TASK RESPONSE, status : %b, task-id: %d to Peer: %d\n", status, taskId, m_peerId);
pResp->AddGeneralHeader((RESP_TYPE)TASK_REQUEST_RESP, fromPeerId, status);
MessageMap mmap;
mmap["taskid"] = boost::lexical_cast<string>(taskId);
pResp->AddTaskInfo(mmap);
// give out the current peer list
unsigned long ts = 0;
std::vector<RemotePeers> peers = Peer::GetPeer()->GetPeerList(ts);
// add peerlist
pResp->AddPeerListTimestamp(ts);
pResp->AddPeerList(peers);
// add work history
WorkHistoryPtr pWH = WorkHistory::GetWorkHistory();
MessageMap hmap;
hmap["workload"] = boost::lexical_cast<string>(pWH->GetCurrentWorkLoad());
hmap["avgexecution"] = boost::lexical_cast<string>(pWH->GetAvgExecuteTime());
hmap["totalexecuted"] = boost::lexical_cast<string>(pWH->GetNumTaskHandled());
hmap["totalfailure"] = boost::lexical_cast<string>(pWH->GetNumTaskFailed());
pResp->AddWorkHistory(hmap);
std::string xml = pResp->GetXML();
result = this->SendMessage(xml);
return result;
}
bool QueryRoomHandler::handle(CmdTask& task)
{
srand((int) time(0));
unsigned int tmp_user[4] = {0};
tmp_user[0] = (rand() % (1000-800+1))+ 800;
tmp_user[1] = (rand() % ( 500-300+1))+ 300;
tmp_user[2] = (rand() % ( 300-200+1))+ 200;
tmp_user[3] = (rand() % ( 200-100+1))+ 100;
DataXCmdPtr& pCmd = task.pCmd;
if(!pCmd)
{
LOG4CPLUS_ERROR(FLogger, "convert command to dataxcmd failed.");
return false;
}
int rst = checkCmd(pCmd, string("GetDirReq"));
if(0 != rst)
{
LOG4CPLUS_ERROR(FLogger, "ckeck command failed. user id = "
<< pCmd->get_userid() << ", cmd_name = " << pCmd->get_cmd_name());
return false;
}
int game_id = 0;
bool bSuccess = decodeParam(pCmd->get_datax(), game_id);
if(!bSuccess)
{
LOG4CPLUS_ERROR(FLogger, "get game id from datax failed...");
return false;
}
//获取房间配置信息
vector<GameRoomInfo> room_list;
GameRoomConfig* pRoomConfig = GameRoomConfig::getInstance();
pRoomConfig->getRoomConfig(game_id, room_list);
//获取房间在线人数
map<RoomIdent, int> rooms_online;
pRoomConfig->getOnlineInfo(game_id, rooms_online);
int idx = 0;
int size = room_list.size();
IDataX* pParam = new XLDataX();
XLDataX** rooms_data = new XLDataX*[size];
RoomIdent room;
room.game_id = game_id;
vector<GameRoomInfo>::iterator it = room_list.begin();
for(; it != room_list.end(); ++it)
{
room.room_id = it->room_id;
rooms_data[idx] = new XLDataX();
rooms_data[idx]->PutInt(DataID_GameId, it->game_id);
rooms_data[idx]->PutInt(DataID_RoomId, it->room_id);
rooms_data[idx]->PutUTF8String(DataID_RoomName, (byte*)it->room_name.c_str(),
it->room_name.length());
rooms_data[idx]->PutInt(DataID_MinBeans_Limit, it->min_limit);
rooms_data[idx]->PutInt(DataID_MaxBeans_Limit, it->max_limit);
rooms_data[idx]->PutInt(DataID_RoomOnlineUsers, rooms_online[room] + tmp_user[idx] );
rooms_data[idx]->PutUTF8String(DataID_ServerCT, (byte*)it->server_ct.c_str(),
it->server_ct.length());
rooms_data[idx]->PutUTF8String(DataID_ServerCM, (byte*)it->server_cm.c_str(),
it->server_cm.length());
rooms_data[idx]->PutUTF8String(DataID_ServerCU, (byte*)it->server_cu.c_str(),
it->server_cu.length());
rooms_data[idx]->PutInt(DataID_RoomAnte, it->room_ante);
rooms_data[idx]->PutInt(DataID_QuickMin, it->min_quick);
rooms_data[idx]->PutInt(DataID_QuickMax, it->max_quick);
++idx;
}
pParam->PutDataXArray(DataID_Param1, (IDataX**)rooms_data, size, true);
delete [] rooms_data;
rooms_data = NULL;
DataXCmdPtr pResp(new DataXCmd("GetDirResp", pCmd->get_cipher_flag()));
pResp->set_datax(pParam);
pResp->set_userid(pCmd->get_userid());
//send pResp
CmdTask resp;
resp.idx = task.idx;
resp.seqno = task.seqno;
resp.pCmd = pResp;
resp.timestamp = task.timestamp;
ResponseManager::getInstance()->sendResponse(resp);
return true;
}
bool GoodsHandler::handle(CmdTask& task)
{
DataXCmdPtr& pCmd = task.pCmd;
int rst = checkCmd(pCmd, string("GetStoreConfig"));
if(0 != rst)
{
LOG4CPLUS_ERROR(FLogger, "ckeck command failed. user id = "
<< pCmd->get_userid() << ", cmd_name = " << pCmd->get_cmd_name());
return false;
}
int game_id = 0;
int tooltype = 0;
bool bSuccess = decodeParam(pCmd->get_datax(), game_id, tooltype);
if(!bSuccess)
{
LOG4CPLUS_ERROR(FLogger, "decodeParam failed...");
return false;
}
vector<goods_item> goods_set;
shop_config::instance()->get_goods_by_type(tooltype, goods_set);
LOG4CPLUS_DEBUG(FLogger, "get_goods_by_type = " << goods_set.size());
int idx = 0;
int size = goods_set.size();
IDataX* pParam = new XLDataX();
XLDataX** datax_goods = new XLDataX*[size];
vector<goods_item>::iterator it = goods_set.begin();
for(; it != goods_set.end(); ++it)
{
datax_goods[idx] = new XLDataX();
datax_goods[idx]->PutInt(DataID_ToolId, it->toolid);
datax_goods[idx]->PutUTF8String(DataID_ToolName, (byte*)it->toolname.c_str(), it->toolname.length());
datax_goods[idx]->PutBytes(DataID_ToolType, (byte*)&(it->tooltype), 1);
datax_goods[idx]->PutShort(DataID_ToolIcon, it->toolicon);
datax_goods[idx]->PutInt(DataID_ToolNum, it->toolnum);
datax_goods[idx]->PutFloat(DataID_Rmb, it->toolrmb);
datax_goods[idx]->PutFloat(DataID_Keke, it->toolkeke);
datax_goods[idx]->PutUTF8String(DataID_Content, (byte*)it->content.c_str(), it->content.length());
datax_goods[idx]->PutBytes(DataID_InStore, (byte*)it->instore.c_str(), it->instore.length());
datax_goods[idx]->PutBytes(DataID_OutStore, (byte*)it->outstore.c_str(), it->outstore.length());
datax_goods[idx]->PutShort(DataID_SaleId, it->saleid);
datax_goods[idx]->PutShort(DataID_TaskId, it->takeid);
datax_goods[idx]->PutBytes(DataID_VIPValid, (byte*)&(it->vipvalid), 1);
++idx;
}
pParam->PutInt(DataID_GameId, 1);
pParam->PutDataXArray(DataID_Param1, (IDataX**)datax_goods, size, true);
DataXCmdPtr pResp(new DataXCmd("GetStoreConfigResp", pCmd->get_cipher_flag()));
pResp->set_datax(pParam);
pResp->set_userid(pCmd->get_userid());
delete [] datax_goods;
datax_goods = NULL;
CmdTask resp;
resp.idx = task.idx;
resp.seqno = task.seqno;
resp.timestamp = task.timestamp;
resp.pCmd = pResp;
ResponseManager::getInstance()->sendResponse(resp);
return true;
}
void ResponseParser::digest(boost::shared_ptr<std::string> data, Message::MessageType request_type)
{
auto str = *data;
switch(parser_state_)
{
case ResponseParser::MessageParserStateNewRequest:
current_response_data_.clear();
switch(request_type)
{
case Message::MessageTypeSend:
case Message::MessageTypeDel:
case Message::MessageTypeQuit:
case Message::MessageTypeLogin:
if(str == "OK")
{
boost::shared_ptr<Response> pResp(new OkResponse());
delegate_method_(socket_id_, pResp);
}
else if(str == "ERR")
{
boost::shared_ptr<Response> pResp(new ErrResponse());
delegate_method_(socket_id_, pResp);
}
else
{
boost::shared_ptr<Response> pResp(new ErrResponse());
delegate_method_(socket_id_, pResp);
}
break;
case Message::MessageTypeList:
DEBUG("LIST");
try
{
current_response_data_.push_back(data);
total_lines_ = boost::lexical_cast<int>(str);
if(total_lines_ > 0)
{
parser_state_ = ResponseParser::MessageParserStateParsing;
}
else
{
boost::shared_ptr<Response> pResp(new ListResponse(str));
delegate_method_(socket_id_, pResp);
}
}
catch(const boost::bad_lexical_cast& e)
{
boost::shared_ptr<Response> pResp(new ErrResponse());
delegate_method_(socket_id_, pResp);
}
break;
case Message::MessageTypeRead:
if(str == "OK")
{
parser_state_ = ResponseParser::MessageParserStateParsing;
}
else if(str == "ERR")
{
boost::shared_ptr<Response> pResp(new ErrResponse());
delegate_method_(socket_id_, pResp);
}
else
{
boost::shared_ptr<Response> pResp(new ErrResponse());
delegate_method_(socket_id_, pResp);
}
break;
case Message::MessageTypeInvalid:
default:
DEBUG("Impossible client state. MsgType is " << request_type);
break;
}
break;
case ResponseParser::MessageParserStateParsing:
if(request_type == Message::MessageTypeList)
{
current_response_data_.push_back(data);
total_lines_--;
if(total_lines_ == 0)
{
std::string total_data;
foreach(auto tmp, current_response_data_)
{
total_data += *tmp + "\n";
}
boost::shared_ptr<Response> pResp;
try
{
pResp.reset(new ListResponse(total_data));
}
catch(const ConversionException& e)
{
pResp.reset(new ErrResponse());
}
delegate_method_(socket_id_, pResp);
parser_state_ = ResponseParser::MessageParserStateNewRequest;
}
