int handleService(ServiceRequest& req, MessageSender& sender, MessageReceiver& receiver, MessageReceiver& dataReceiver) {
sender.sendCoreMessage(req, SESSION_ID);
ServiceResponse* serviceResponse = dynamic_cast<ServiceResponse*>(receiver.getNextCoreMessage(1500));
if (serviceResponse == 0) {
std::cout << "Failure: No response to service request" << std::endl;
return 1;
}
if (serviceResponse->isSuccessful()) {
std::cout << "Request successful" << std::endl;
if (serviceResponse->hasData()) {
std::cout << "Response has associated data" << std::endl;
DataResponse* dataResponse = dynamic_cast<DataResponse*>(dataReceiver.getNextCoreMessage(1500));
if (dataResponse == 0) {
std::cout << "Failure: Associated data not available" << std::endl;
return 1;
}
std::cout << "Response data: " << dataResponse->data() << std::endl;
delete dataResponse;
}
}
else {
std::cout << "Request unsuccessful" << std::endl;
std::cout << "Error code: " << serviceResponse->errorCode() << std::endl;
std::cout << "Error message: " << serviceResponse->errorMessage() << std::endl;
}
delete serviceResponse;
return 0;
}
int Dispatcher::sendToClient(const string& cid,
const ServiceResponse& resp) {
checkConnectServers();
vector<CliSess> svs;
int ret = getClientLoginServer(cid, svs);
if(ret < 0) {
return ret;
}
ServiceResponse r = resp;
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->sendServiceResponse(r);
}
return ret;
}
int32 handle_service_response(const std::string& resp) {
int32 ret = 0;
ServiceResponse svresp;
if(!svresp.ParseFromString(resp)) {
LOG_OUT << "cid:" << m_cid
<< " handle_service_response ParseFromString fail\n";
return -1;
}
switch(svresp.svtype()) {
case 200:
ret = handle_peer_response(svresp.payload());
}
if(svresp.status()) {
LOG_OUT << "cid:" << m_cid
<< " handle_service_response fail, status:"
<< svresp.status() << std::endl;
} else {
std::stringstream os;
if(lastSn() == svresp.sn()) {
++success_count;
} else {
LOG_OUT << "SN_ERROR, cid:" << m_cid
<< " service_resp resp sn:" << svresp.sn()
<< " req sn:" << lastSn() << std::endl;
}
}
++m_sn;
return 0;
}
bool
ExemplarClient::getOneRandomNumber(double & result)
{
ODL_OBJENTER(); //####
ODL_P1("result = ", &result); //####
bool okSoFar = false;
try
{
yarp::os::Bottle parameters;
ServiceResponse response;
reconnectIfDisconnected();
if (send(MpM_SIMPLE_REQUEST_, parameters, response))
{
if (1 == response.count())
{
yarp::os::Value retrieved(response.element(0));
if (retrieved.isDouble())
{
result = retrieved.asDouble();
okSoFar = true;
}
else
{
ODL_LOG("! (retrieved.isDouble())"); //####
}
}
else
{
ODL_LOG("! (1 == response.count())"); //####
ODL_S1s("response = ", response.asString()); //####
}
}
else
{
ODL_LOG("! (send(MpM_SIMPLE_REQUEST_, parameters, response))"); //####
}
}
catch (...)
{
ODL_LOG("Exception caught"); //####
throw;
}
ODL_OBJEXIT_B(okSoFar); //####
return okSoFar;
} // ExemplarClient::getOneRandomNumber
int SvCon::processServiceResponse(const char* respbody, int len){
int ret = 0;
ServiceResponse svreq;
if(!svreq.ParseFromArray(respbody, len)){
ALogError(m_serv->getConfig().LogName) << "<action:handle_cmd> <status:"
<< (int)INPUT_FORMAT_ERROR
<< "> <errstr:INPUT_FORMAT_ERROR>";
return INPUT_FORMAT_ERROR;
}
ret = handleServiceResponse(svreq);
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.from_type()){
case 200:
ret = handle_peer_request(svreq.sn(), svreq.payload(), outpayload);
break;
default:
LOG_OUT << "cid:" << m_cid << ", handleServiceRequest:" << svreq.payload()
<< std::endl;
}
exit:
ServiceResponse svresp;
svresp.set_sn(svreq.sn());
svresp.set_from_sessid(m_sessid);
svresp.set_to_sessid(svreq.from_sessid());
svresp.set_from_type(0);
svresp.set_to_type(svreq.from_type());
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;
}
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 parse_service_resp(const std::string& resp,
ServiceResponse& svresp) {
return svresp.ParseFromString(resp);
}
int32 const_service_resp(const ServiceResponse& srresp,
std::string& req){
return srresp.SerializeToString(&req);
}
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();
}
bool
ExemplarClient::getRandomNumbers(const int howMany,
DoubleVector & result)
{
ODL_OBJENTER(); //####
ODL_I1("howMany = ", howMany); //####
ODL_P1("result = ", &result); //####
bool okSoFar = false;
try
{
if (0 < howMany)
{
yarp::os::Bottle parameters;
ServiceResponse response;
parameters.addInt(howMany);
reconnectIfDisconnected();
if (send(MpM_SIMPLE_REQUEST_, parameters, response))
{
if (howMany == response.count())
{
result.clear();
okSoFar = true;
for (int ii = 0; ii < howMany; ++ii)
{
yarp::os::Value retrieved(response.element(ii));
if (retrieved.isDouble())
{
result.push_back(retrieved.asDouble());
}
else
{
ODL_LOG("! (retrieved.isDouble())"); //####
okSoFar = false;
break;
}
}
}
else
{
ODL_LOG("! (howMany == response.count())"); //####
ODL_S1s("response = ", response.asString()); //####
}
}
else
{
ODL_LOG("! (send(MpM_SIMPLE_REQUEST_, parameters, response))"); //####
}
}
else
{
ODL_LOG("! (0 < howMany)"); //####
}
}
catch (...)
{
ODL_LOG("Exception caught"); //####
throw;
}
ODL_OBJEXIT_B(okSoFar); //####
return okSoFar;
} // ExemplarClient::getRandomNumbers
