int PushCliConn::sendJ2C(const Message& m){
Json::Value v;
v["cmd"] = PS_CMD_PUSH_REQUEST;
messageProtobufToJson(m, v);
ServiceRequest sreq;
sreq.set_payload(Json::FastWriter().write(v));
sreq.set_to_type(-1);
sreq.set_sn(m.sn());
int ret = getDispatcher()->sendToClient(m.to(), sreq);
PSLogTrace("PushServer") << "<action:handle push send2c> <conid:" << getId() << "><to:" << m.to() << "><result=" << ret << ">";
return ret == -20001?0:ret;
}
int SvList::transRequest(const ServiceRequest& req){
if(!m_svs.size()){
return NO_SERVICE;
}
AutoLock l(&m_cs);
CliCon* c = m_svs[m_cnt % m_svs.size()];
if(!c){
return NO_SERVICE;
}
string newreq;
req.SerializeToString(&newreq);
SendMsgOp *op = new SendMsgOp(c->getId(), SERVICE_REQ, newreq);
int ret = c->getEventLoop()->addAsynOperator(op);
if(ret < 0){
return INNER_ERROR;
}
++m_cnt;
if(m_cnt < 0){
m_cnt = 0;
}
return 0;
}
int32 do_service_req(int32 type, const string& payload) {
int32 ret = 0;
std::string req;
ServiceRequest srreq;
srreq.set_svtype(type);
srreq.set_payload(payload);
srreq.set_from_sessid(m_sessid);
srreq.set_sn(lastSn());
const_service_req(srreq, req);
std::string rsp;
ret = send_req(200, req);
if(ret < 0) {
LOG_OUT << "cid:" << m_cid
<< "test_service send fail!" << std::endl;
return ret;
}
return ret;
}
int TypeMap::transRequest(const ServiceRequest& req){
int type = req.to_type();
if(type <= 0 || type >= (int)m_svlsts.size()){
return INVALID_TYPE;
}
int ret = m_svlsts[type-1].transRequest(req);
return ret;
}
int32 handle_service_request(const std::string& resp) {
int32 ret = 0;
ServiceRequest svreq;
std::string outpayload;
++total_recv_req;
if(!svreq.ParseFromString(resp)) {
LOG_OUT << "cid:" << m_cid
<< " handle_service_request ParseFromString fail\n";
return -1;
}
if(svreq.to_sessid() != m_sessid) {
LOG_OUT << "cid:" << m_cid
<< " handle_service_request,ret sessid:"
<< svreq.from_sessid()
<< " != m_sessid:" << m_sessid << std::endl;
ret = -200;
}
switch(svreq.svtype()) {
case 200:
ret = handle_peer_request(svreq.sn(), svreq.payload(), outpayload);
break;
}
exit:
ServiceResponse svresp;
svresp.set_sn(svreq.sn());
svresp.set_from_sessid(m_sessid);
svresp.set_to_sessid(svreq.from_sessid());
svresp.set_svtype(svreq.svtype());
svresp.set_status(ret);
svresp.set_payload(outpayload);
std::string msg;
std::string body;
svresp.SerializeToString(&body);
ret = send_req(201, body);
if(ret == 0)
++recv_req_success_count;
m_status = CLIENT_STATUS_INIT;
return ret;
}
int Dispatcher::sendToClient(const string& cid,
const ServiceRequest& req) {
checkConnectServers();
vector<CliSess> svs;
int ret = getClientLoginServer(cid, svs);
if(ret < 0) {
return ret;
}
ServiceRequest r = req;
for(size_t i = 0; i < svs.size(); ++i) {
r.set_to_sessid(svs[i].first);
r.set_from_sessid(svs[i].second->getSessID());
r.set_from_type(svs[i].second->getSvType());
r.set_to_type(-1);
ret = svs[i].second->sendServiceRequest(r);
}
return ret;
}
int SvCon::processServiceRequest(const char* reqbody, int len){
int ret = 0;
ServiceRequest svreq;
if(!svreq.ParseFromArray(reqbody, len)){
ALogError(m_serv->getConfig().LogName) << "<action:handle_cmd> <status:"
<< (int)INPUT_FORMAT_ERROR
<< "> <errstr:INPUT_FORMAT_ERROR>";
return INPUT_FORMAT_ERROR;
}
if(svreq.to_type() != m_sv_type){
ALogError(m_serv->getConfig().LogName) << "<action:handle_cmd> <status:"
<< (int)INPUT_FORMAT_ERROR
<< "> <errstr:SERVICE_TYPE_ERROR>";
return SERVICE_TYPE_ERROR;
}
ret = handleServiceRequest(svreq);
return ret;
}
int32 run(){
int32 ret = 0;
int32 cnt = 0;
while(1){
++cnt;
std::string resp;
ret = recv_resp(resp);
if(ret < 0){
std::cout << "recv_resp fail!" << std::endl;
return -1;
}
ServiceRequest svreq;
parse_service_req(resp, svreq);
ServiceResponse svresp;
svresp.set_from_sessid(m_sessid);
svresp.set_to_sessid(svreq.from_sessid());
svresp.set_svtype(svreq.svtype());
svresp.set_sn(svreq.sn());
svresp.set_status(0);
svresp.set_payload(svreq.payload());
std::string req;
const_service_resp(svresp, req);
ret = send_req(SERVICE_RESP, req);
if(ret < 0){
std::cout << "send_req fail, sessid:" << svreq.from_sessid()
<< ", sn:" << svreq.sn() << std::endl;
return -1;
}else{
std::cout << "handle request, sessid:" << svreq.from_sessid()
<< ", sn:" << svreq.sn()
<< " ,send ret:" << ret << std::endl;
}
}
return ret;
}
int32 const_service_req(const ServiceRequest& srreq,
std::string& req) {
return srreq.SerializeToString(&req);
}
int32 parse_service_req(const std::string& resp,
ServiceRequest& svreq){
return svreq.ParseFromString(resp);
}
CoreMessage* CoreMessageXmlSerializer::deserialize(const std::string& message) const {
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load(message.c_str());
if (!bool(result)) {
syslog(LOG_ERR, "Message is not well-formed XML");
return (CoreMessage*) 0;
}
pugi::xml_node msg = doc.child("coreMessage");
if (msg.empty()) {
syslog(LOG_ERR, "Message is not a coreMessage");
return (CoreMessage*) 0;
}
if (msg.child("sessionId").empty()) {
syslog(LOG_ERR, "Message has no sessionId");
return (CoreMessage*) 0;
}
std::string sessionId = msg.child_value("sessionId");
if (msg.child("messageType").empty()) {
syslog(LOG_ERR, "Message has no messageType");
return (CoreMessage*) 0;
}
std::string typeName = msg.child_value("messageType");
if (msg.child("guid").empty()) {
syslog(LOG_ERR, "Message has no guid");
return (CoreMessage*) 0;
}
std::string guid = msg.child_value("guid");
CoreMessage* newMessage;
switch (CoreMessage::lookupType(typeName)) {
case CoreMessage::INITIATE_SESSION_REQUEST: {
newMessage = new InitiateSessionRequest(sessionId);
newMessage->setGuid(guid);
break;
}
case CoreMessage::INITIATE_SESSION_RESPONSE: {
InitiateSessionResponse* response = new InitiateSessionResponse(sessionId, guid);
impl_->setResponseFields(response, msg);
newMessage = response;
break;
}
case CoreMessage::KILL_SESSION_REQUEST: {
newMessage = new KillSessionRequest(sessionId);
newMessage->setGuid(guid);
break;
}
case CoreMessage::KILL_SESSION_RESPONSE: {
KillSessionResponse* response = new KillSessionResponse(sessionId, guid);
impl_->setResponseFields(response, msg);
newMessage = response;
break;
}
case CoreMessage::SERVICE_REQUEST: {
std::string func = msg.child_value("function");
ServiceRequest* serviceReq = new ServiceRequest(sessionId, func);
serviceReq->setGuid(guid);
pugi::xml_node params = msg.child("parameters");
for (pugi::xml_node::iterator it = params.begin(); it != params.end(); ++it) {
serviceReq->setParameter(it->child_value("name"), it->child_value("value"));
}
newMessage = serviceReq;
break;
}
case CoreMessage::SERVICE_RESPONSE: {
bool hasData = boost::lexical_cast<bool>(msg.child_value("hasData"));
ServiceResponse* response = new ServiceResponse(sessionId, guid, hasData);
impl_->setResponseFields(response, msg);
newMessage = response;
break;
}
case CoreMessage::DATA_RESPONSE: {
std::string data = msg.child_value("data");
DataResponse* response = new DataResponse(sessionId, guid, data);
impl_->setResponseFields(response, msg);
newMessage = response;
break;
}
default:
break; // Throw exception
}
newMessage->setChoreography(msg.child_value("choreography"));
newMessage->setDescription(msg.child_value("description"));
newMessage->setTimeStamp(boost::posix_time::from_iso_string(msg.child_value("timeStamp")));
return newMessage;
}
const std::string CoreMessageXmlSerializer::serialize(const CoreMessage& message) const {
pugi::xml_document doc;
pugi::xml_node msgNode = doc.append_child();
msgNode.set_name("coreMessage");
msgNode.append_child().set_name("sessionId");
msgNode.child("sessionId").append_child(pugi::node_pcdata).set_value(message.sessionId().c_str());
msgNode.append_child().set_name("messageType");
std::string typeName = CoreMessage::lookupTypeName(message.messageType());
msgNode.child("messageType").append_child(pugi::node_pcdata).set_value(typeName.c_str());
msgNode.append_child().set_name("guid");
msgNode.child("guid").append_child(pugi::node_pcdata).set_value(message.guid().c_str());
msgNode.append_child().set_name("choreography");
msgNode.child("choreography").append_child(pugi::node_pcdata).set_value(message.choreography().c_str());
msgNode.append_child().set_name("description");
msgNode.child("description").append_child(pugi::node_pcdata).set_value(message.description().c_str());
msgNode.append_child().set_name("timeStamp");
msgNode.child("timeStamp").append_child(pugi::node_pcdata).set_value(message.timeStampString().c_str());
switch (message.messageType()) {
case CoreMessage::INITIATE_SESSION_RESPONSE: //Fall-through
case CoreMessage::KILL_SESSION_RESPONSE: {
impl_->addResponseNodes(msgNode, message);
break;
}
case CoreMessage::SERVICE_REQUEST: {
const ServiceRequest req = dynamic_cast<const ServiceRequest&>(message);
msgNode.append_child().set_name("function");
msgNode.child("function").append_child(pugi::node_pcdata).set_value(req.functionName().c_str());
pugi::xml_node params = msgNode.append_child();
params.set_name("parameters");
std::vector<std::string>::const_iterator end = req.parameterNames().end();
for (std::vector<std::string>::const_iterator it = req.parameterNames().begin();
it != end; ++it) {
pugi::xml_node param = params.append_child();
param.set_name("parameter");
param.append_child().set_name("name");
param.child("name").append_child(pugi::node_pcdata).set_value(it->c_str());
param.append_child().set_name("value");
param.child("value").append_child(pugi::node_pcdata).set_value(req.parameterValue(*it).c_str());
}
break;
}
case CoreMessage::SERVICE_RESPONSE: {
impl_->addResponseNodes(msgNode, message);
const ServiceResponse resp = dynamic_cast<const ServiceResponse&>(message);
msgNode.append_child().set_name("hasData");
std::string hasData = boost::lexical_cast<std::string>(resp.hasData());
msgNode.child("hasData").append_child(pugi::node_pcdata).set_value(hasData.c_str());
break;
}
case CoreMessage::DATA_RESPONSE: {
impl_->addResponseNodes(msgNode, message);
const DataResponse resp = dynamic_cast<const DataResponse&>(message);
msgNode.append_child().set_name("data");
msgNode.child("data").append_child(pugi::node_pcdata).set_value(resp.data().c_str());
break;
}
default:
break;
}
std::stringstream ss;
pugi::xml_writer_stream writer(ss);
doc.print(writer);
return ss.str();
}
