// ********************************************************************** // This file was generated by a TARS parser! // TARS version 3.0.6. // ********************************************************************** #ifndef __HELLO_H_ #define __HELLO_H_ #include #include #include #include "tup/Tars.h" #include "tup/TarsJson.h" using namespace std; #include "servant/ServantProxy.h" #include "servant/Servant.h" #include "promise/promise.h" #include "servant/Application.h" namespace Test { enum EN_KEY { KEY1 = 1, KEY2 = 2, }; inline string etos(const EN_KEY & e) { switch(e) { case KEY1: return "KEY1"; case KEY2: return "KEY2"; default: return ""; } } inline int stoe(const string & s, EN_KEY & e) { if(s == "KEY1") { e=KEY1; return 0;} if(s == "KEY2") { e=KEY2; return 0;} return -1; } struct JsonKey : public tars::TarsStructBase { public: static string className() { return "Test.JsonKey"; } static string MD5() { return "7b010a6336d210a506b1eb4bf4c1e014"; } JsonKey() { resetDefautlt(); } void resetDefautlt() { i = 0; } template void writeTo(tars::TarsOutputStream& _os) const { if (i != 0) { _os.write(i, 0); } } template void readFrom(tars::TarsInputStream& _is) { resetDefautlt(); _is.read(i, 0, false); } tars::JsonValueObjPtr writeToJson() const { tars::JsonValueObjPtr p = new tars::JsonValueObj(); p->value["i"] = tars::JsonOutput::writeJson(i); return p; } string writeToJsonString() const { return tars::TC_Json::writeValue(writeToJson()); } void readFromJson(const tars::JsonValuePtr & p, bool isRequire = true) { resetDefautlt(); if(NULL == p.get() || p->getType() != tars::eJsonTypeObj) { char s[128]; snprintf(s, sizeof(s), "read 'struct' type mismatch, get type: %d.", (p.get() ? p->getType() : 0)); throw tars::TC_Json_Exception(s); } tars::JsonValueObjPtr pObj=tars::JsonValueObjPtr::dynamicCast(p); tars::JsonInput::readJson(i,pObj->value["i"], false); } void readFromJsonString(const string & str) { readFromJson(tars::TC_Json::getValue(str)); } ostream& display(ostream& _os, int _level=0) const { tars::TarsDisplayer _ds(_os, _level); _ds.display(i,"i"); return _os; } ostream& displaySimple(ostream& _os, int _level=0) const { tars::TarsDisplayer _ds(_os, _level); _ds.displaySimple(i, false); return _os; } public: tars::Int32 i; }; inline bool operator==(const JsonKey&l, const JsonKey&r) { return l.i == r.i; } inline bool operator!=(const JsonKey&l, const JsonKey&r) { return !(l == r); } inline ostream& operator<<(ostream & os,const JsonKey&r) { os << r.writeToJsonString(); return os; } inline istream& operator>>(istream& is,JsonKey&l) { std::istreambuf_iterator eos; std::string s(std::istreambuf_iterator(is), eos); l.readFromJsonString(s); return is; } inline bool operator<(const JsonKey&l, const JsonKey&r) { if(l.i != r.i) return (l.i < r.i); return false; } inline bool operator<=(const JsonKey&l, const JsonKey&r) { return !(r < l); } inline bool operator>(const JsonKey&l, const JsonKey&r) { return r < l; } inline bool operator>=(const JsonKey&l, const JsonKey&r) { return !(l < r); } struct JsonData : public tars::TarsStructBase { public: static string className() { return "Test.JsonData"; } static string MD5() { return "7e2b4e48c7c69de6efedb26120c23c90"; } JsonData() { resetDefautlt(); } void resetDefautlt() { c = 0; s = 0; i = 0; l = 0; f = 0; d = 0; uc = 0; us = 0; ui = 0; b = true; k = Test::KEY1; ss = ""; data.clear(); v.clear(); im.clear(); bm.clear(); fm.clear(); bv.clear(); iv.clear(); dv.clear(); } template void writeTo(tars::TarsOutputStream& _os) const { if (c != 0) { _os.write(c, 0); } if (s != 0) { _os.write(s, 1); } if (i != 0) { _os.write(i, 2); } if (l != 0) { _os.write(l, 3); } if (f != 0) { _os.write(f, 4); } if (d != 0) { _os.write(d, 5); } if (uc != 0) { _os.write(uc, 6); } if (us != 0) { _os.write(us, 7); } if (ui != 0) { _os.write(ui, 8); } if (b != true) { _os.write(b, 9); } _os.write((tars::Int32)k, 10); if (ss != "") { _os.write(ss, 11); } if (data.size() > 0) { _os.write(data, 12); } if (v.size() > 0) { _os.write(v, 13); } if (im.size() > 0) { _os.write(im, 14); } if (bm.size() > 0) { _os.write(bm, 15); } if (fm.size() > 0) { _os.write(fm, 16); } if (bv.size() > 0) { _os.write(bv, 17); } if (iv.size() > 0) { _os.write(iv, 18); } if (dv.size() > 0) { _os.write(dv, 19); } } template void readFrom(tars::TarsInputStream& _is) { resetDefautlt(); _is.read(c, 0, false); _is.read(s, 1, false); _is.read(i, 2, false); _is.read(l, 3, false); _is.read(f, 4, false); _is.read(d, 5, false); _is.read(uc, 6, false); _is.read(us, 7, false); _is.read(ui, 8, false); _is.read(b, 9, false); tars::Int32 eTemp10 = Test::KEY1; _is.read(eTemp10, 10, false); k = (Test::EN_KEY)eTemp10; _is.read(ss, 11, false); _is.read(data, 12, false); _is.read(v, 13, false); _is.read(im, 14, false); _is.read(bm, 15, false); _is.read(fm, 16, false); _is.read(bv, 17, false); _is.read(iv, 18, false); _is.read(dv, 19, false); } tars::JsonValueObjPtr writeToJson() const { tars::JsonValueObjPtr p = new tars::JsonValueObj(); p->value["c"] = tars::JsonOutput::writeJson(c); p->value["s"] = tars::JsonOutput::writeJson(s); p->value["i"] = tars::JsonOutput::writeJson(i); p->value["l"] = tars::JsonOutput::writeJson(l); p->value["f"] = tars::JsonOutput::writeJson(f); p->value["d"] = tars::JsonOutput::writeJson(d); p->value["uc"] = tars::JsonOutput::writeJson(uc); p->value["us"] = tars::JsonOutput::writeJson(us); p->value["ui"] = tars::JsonOutput::writeJson(ui); p->value["b"] = tars::JsonOutput::writeJson(b); p->value["k"] = tars::JsonOutput::writeJson((tars::Int32)k); p->value["ss"] = tars::JsonOutput::writeJson(ss); p->value["data"] = tars::JsonOutput::writeJson(data); p->value["v"] = tars::JsonOutput::writeJson(v); p->value["im"] = tars::JsonOutput::writeJson(im); p->value["bm"] = tars::JsonOutput::writeJson(bm); p->value["fm"] = tars::JsonOutput::writeJson(fm); p->value["bv"] = tars::JsonOutput::writeJson(bv); p->value["iv"] = tars::JsonOutput::writeJson(iv); p->value["dv"] = tars::JsonOutput::writeJson(dv); return p; } string writeToJsonString() const { return tars::TC_Json::writeValue(writeToJson()); } void readFromJson(const tars::JsonValuePtr & p, bool isRequire = true) { resetDefautlt(); if(NULL == p.get() || p->getType() != tars::eJsonTypeObj) { char s[128]; snprintf(s, sizeof(s), "read 'struct' type mismatch, get type: %d.", (p.get() ? p->getType() : 0)); throw tars::TC_Json_Exception(s); } tars::JsonValueObjPtr pObj=tars::JsonValueObjPtr::dynamicCast(p); tars::JsonInput::readJson(c,pObj->value["c"], false); tars::JsonInput::readJson(s,pObj->value["s"], false); tars::JsonInput::readJson(i,pObj->value["i"], false); tars::JsonInput::readJson(l,pObj->value["l"], false); tars::JsonInput::readJson(f,pObj->value["f"], false); tars::JsonInput::readJson(d,pObj->value["d"], false); tars::JsonInput::readJson(uc,pObj->value["uc"], false); tars::JsonInput::readJson(us,pObj->value["us"], false); tars::JsonInput::readJson(ui,pObj->value["ui"], false); tars::JsonInput::readJson(b,pObj->value["b"], false); tars::JsonInput::readJson(k,pObj->value["k"], false); tars::JsonInput::readJson(ss,pObj->value["ss"], false); tars::JsonInput::readJson(data,pObj->value["data"], false); tars::JsonInput::readJson(v,pObj->value["v"], false); tars::JsonInput::readJson(im,pObj->value["im"], false); tars::JsonInput::readJson(bm,pObj->value["bm"], false); tars::JsonInput::readJson(fm,pObj->value["fm"], false); tars::JsonInput::readJson(bv,pObj->value["bv"], false); tars::JsonInput::readJson(iv,pObj->value["iv"], false); tars::JsonInput::readJson(dv,pObj->value["dv"], false); } void readFromJsonString(const string & str) { readFromJson(tars::TC_Json::getValue(str)); } ostream& display(ostream& _os, int _level=0) const { tars::TarsDisplayer _ds(_os, _level); _ds.display(c,"c"); _ds.display(s,"s"); _ds.display(i,"i"); _ds.display(l,"l"); _ds.display(f,"f"); _ds.display(d,"d"); _ds.display(uc,"uc"); _ds.display(us,"us"); _ds.display(ui,"ui"); _ds.display(b,"b"); _ds.display((tars::Int32)k,"k"); _ds.display(ss,"ss"); _ds.display(data,"data"); _ds.display(v,"v"); _ds.display(im,"im"); _ds.display(bm,"bm"); _ds.display(fm,"fm"); _ds.display(bv,"bv"); _ds.display(iv,"iv"); _ds.display(dv,"dv"); return _os; } ostream& displaySimple(ostream& _os, int _level=0) const { tars::TarsDisplayer _ds(_os, _level); _ds.displaySimple(c, true); _ds.displaySimple(s, true); _ds.displaySimple(i, true); _ds.displaySimple(l, true); _ds.displaySimple(f, true); _ds.displaySimple(d, true); _ds.displaySimple(uc, true); _ds.displaySimple(us, true); _ds.displaySimple(ui, true); _ds.displaySimple(b, true); _ds.displaySimple((tars::Int32)k, true); _ds.displaySimple(ss, true); _ds.displaySimple(data, true); _ds.displaySimple(v, true); _ds.displaySimple(im, true); _ds.displaySimple(bm, true); _ds.displaySimple(fm, true); _ds.displaySimple(bv, true); _ds.displaySimple(iv, true); _ds.displaySimple(dv, false); return _os; } public: tars::Char c; tars::Short s; tars::Int32 i; tars::Int64 l; tars::Float f; tars::Double d; tars::UInt8 uc; tars::UInt16 us; tars::UInt32 ui; tars::Bool b; Test::EN_KEY k; std::string ss; map data; vector v; map im; map bm; map fm; vector bv; vector iv; vector dv; }; inline bool operator==(const JsonData&l, const JsonData&r) { return l.c == r.c && l.s == r.s && l.i == r.i && l.l == r.l && tars::TC_Common::equal(l.f,r.f) && tars::TC_Common::equal(l.d,r.d) && l.uc == r.uc && l.us == r.us && l.ui == r.ui && l.b == r.b && l.k == r.k && l.ss == r.ss && l.data == r.data && l.v == r.v && l.im == r.im && l.bm == r.bm && tars::TC_Common::equal(l.fm,r.fm) && l.bv == r.bv && l.iv == r.iv && tars::TC_Common::equal(l.dv,r.dv); } inline bool operator!=(const JsonData&l, const JsonData&r) { return !(l == r); } inline ostream& operator<<(ostream & os,const JsonData&r) { os << r.writeToJsonString(); return os; } inline istream& operator>>(istream& is,JsonData&l) { std::istreambuf_iterator eos; std::string s(std::istreambuf_iterator(is), eos); l.readFromJsonString(s); return is; } struct JsonMap : public tars::TarsStructBase { public: static string className() { return "Test.JsonMap"; } static string MD5() { return "5bf0437e83ccb7e533b35c9747197b50"; } JsonMap() { resetDefautlt(); } void resetDefautlt() { json.clear(); } template void writeTo(tars::TarsOutputStream& _os) const { if (json.size() > 0) { _os.write(json, 0); } } template void readFrom(tars::TarsInputStream& _is) { resetDefautlt(); _is.read(json, 0, false); } tars::JsonValueObjPtr writeToJson() const { tars::JsonValueObjPtr p = new tars::JsonValueObj(); p->value["json"] = tars::JsonOutput::writeJson(json); return p; } string writeToJsonString() const { return tars::TC_Json::writeValue(writeToJson()); } void readFromJson(const tars::JsonValuePtr & p, bool isRequire = true) { resetDefautlt(); if(NULL == p.get() || p->getType() != tars::eJsonTypeObj) { char s[128]; snprintf(s, sizeof(s), "read 'struct' type mismatch, get type: %d.", (p.get() ? p->getType() : 0)); throw tars::TC_Json_Exception(s); } tars::JsonValueObjPtr pObj=tars::JsonValueObjPtr::dynamicCast(p); tars::JsonInput::readJson(json,pObj->value["json"], false); } void readFromJsonString(const string & str) { readFromJson(tars::TC_Json::getValue(str)); } ostream& display(ostream& _os, int _level=0) const { tars::TarsDisplayer _ds(_os, _level); _ds.display(json,"json"); return _os; } ostream& displaySimple(ostream& _os, int _level=0) const { tars::TarsDisplayer _ds(_os, _level); _ds.displaySimple(json, false); return _os; } public: map json; }; inline bool operator==(const JsonMap&l, const JsonMap&r) { return l.json == r.json; } inline bool operator!=(const JsonMap&l, const JsonMap&r) { return !(l == r); } inline ostream& operator<<(ostream & os,const JsonMap&r) { os << r.writeToJsonString(); return os; } inline istream& operator>>(istream& is,JsonMap&l) { std::istreambuf_iterator eos; std::string s(std::istreambuf_iterator(is), eos); l.readFromJsonString(s); return is; } /* callback of async proxy for client */ class HelloPrxCallback: public tars::ServantProxyCallback { public: virtual ~HelloPrxCallback(){} virtual void callback_testConHash(tars::Int32 ret, const std::string& sOut) { throw std::runtime_error("callback_testConHash() override incorrect."); } virtual void callback_testConHash_exception(tars::Int32 ret) { throw std::runtime_error("callback_testConHash_exception() override incorrect."); } virtual void callback_testCoro(tars::Bool ret, const std::string& sOut) { throw std::runtime_error("callback_testCoro() override incorrect."); } virtual void callback_testCoro_exception(tars::Int32 ret) { throw std::runtime_error("callback_testCoro_exception() override incorrect."); } virtual void callback_testDyeing(tars::Int32 ret, const std::string& strOut) { throw std::runtime_error("callback_testDyeing() override incorrect."); } virtual void callback_testDyeing_exception(tars::Int32 ret) { throw std::runtime_error("callback_testDyeing_exception() override incorrect."); } virtual void callback_testDyeingTrans(tars::Int32 ret) { throw std::runtime_error("callback_testDyeingTrans() override incorrect."); } virtual void callback_testDyeingTrans_exception(tars::Int32 ret) { throw std::runtime_error("callback_testDyeingTrans_exception() override incorrect."); } virtual void callback_testHello(tars::Int32 ret, const std::string& r) { throw std::runtime_error("callback_testHello() override incorrect."); } virtual void callback_testHello_exception(tars::Int32 ret) { throw std::runtime_error("callback_testHello_exception() override incorrect."); } virtual void callback_testPid(tars::Int32 ret, const std::string& r) { throw std::runtime_error("callback_testPid() override incorrect."); } virtual void callback_testPid_exception(tars::Int32 ret) { throw std::runtime_error("callback_testPid_exception() override incorrect."); } virtual void callback_testSyncTrans(tars::Int32 ret, const std::string& r) { throw std::runtime_error("callback_testSyncTrans() override incorrect."); } virtual void callback_testSyncTrans_exception(tars::Int32 ret) { throw std::runtime_error("callback_testSyncTrans_exception() override incorrect."); } virtual void callback_testTimeout(tars::Int32 ret) { throw std::runtime_error("callback_testTimeout() override incorrect."); } virtual void callback_testTimeout_exception(tars::Int32 ret) { throw std::runtime_error("callback_testTimeout_exception() override incorrect."); } virtual void callback_testTrans(tars::Int32 ret, const std::string& r) { throw std::runtime_error("callback_testTrans() override incorrect."); } virtual void callback_testTrans_exception(tars::Int32 ret) { throw std::runtime_error("callback_testTrans_exception() override incorrect."); } public: virtual const map & getResponseContext() const { CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); if(!pCbtd->getContextValid()) { throw TC_Exception("cann't get response context"); } return pCbtd->getResponseContext(); } public: virtual int onDispatch(tars::ReqMessagePtr msg) { static ::std::string __Hello_all[]= { "testConHash", "testCoro", "testDyeing", "testDyeingTrans", "testHello", "testPid", "testSyncTrans", "testTimeout", "testTrans" }; pair r = equal_range(__Hello_all, __Hello_all+9, string(msg->request.sFuncName)); if(r.first == r.second) return tars::TARSSERVERNOFUNCERR; switch(r.first - __Hello_all) { case 0: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testConHash_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); std::string sOut; _is.read(sOut, 1, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testConHash", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testConHash(_ret, sOut); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } case 1: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testCoro_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Bool _ret = false; _is.read(_ret, 0, true); std::string sOut; _is.read(sOut, 2, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testCoro", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testCoro(_ret, sOut); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } case 2: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testDyeing_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); std::string strOut; _is.read(strOut, 2, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["strOut"] = tars::JsonOutput::writeJson(strOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeing", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testDyeing(_ret, strOut); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } case 3: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testDyeingTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeingTrans", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testDyeingTrans(_ret); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } case 4: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testHello_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); std::string r; _is.read(r, 3, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testHello", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testHello(_ret, r); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } case 5: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testPid_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); std::string r; _is.read(r, 1, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testPid", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testPid(_ret, r); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } case 6: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testSyncTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); std::string r; _is.read(r, 3, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testSyncTrans", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testSyncTrans(_ret, r); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } case 7: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testTimeout_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTimeout", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testTimeout(_ret); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } case 8: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); std::string r; _is.read(r, 3, true); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTrans", 0, _trace_param_, ""); } CallbackThreadData * pCbtd = CallbackThreadData::getData(); assert(pCbtd != NULL); pCbtd->setResponseContext(msg->response->context); callback_testTrans(_ret, r); pCbtd->delResponseContext(); return tars::TARSSERVERSUCCESS; } } return tars::TARSSERVERNOFUNCERR; } }; typedef tars::TC_AutoPtr HelloPrxCallbackPtr; //callback of promise async proxy for client class HelloPrxCallbackPromise: public tars::ServantProxyCallback { public: virtual ~HelloPrxCallbackPromise(){} public: struct PromisetestConHash: virtual public TC_HandleBase { public: tars::Int32 _ret; std::string sOut; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestConHash > PromisetestConHashPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestConHashPtr > &promise) : _promise_testConHash(promise) {} virtual void callback_testConHash(const HelloPrxCallbackPromise::PromisetestConHashPtr &ptr) { _promise_testConHash.setValue(ptr); } virtual void callback_testConHash_exception(tars::Int32 ret) { std::string str(""); str += "Function:testConHash_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testConHash.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestConHashPtr > _promise_testConHash; public: struct PromisetestCoro: virtual public TC_HandleBase { public: tars::Bool _ret; std::string sOut; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestCoro > PromisetestCoroPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestCoroPtr > &promise) : _promise_testCoro(promise) {} virtual void callback_testCoro(const HelloPrxCallbackPromise::PromisetestCoroPtr &ptr) { _promise_testCoro.setValue(ptr); } virtual void callback_testCoro_exception(tars::Int32 ret) { std::string str(""); str += "Function:testCoro_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testCoro.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestCoroPtr > _promise_testCoro; public: struct PromisetestDyeing: virtual public TC_HandleBase { public: tars::Int32 _ret; std::string strOut; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestDyeing > PromisetestDyeingPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingPtr > &promise) : _promise_testDyeing(promise) {} virtual void callback_testDyeing(const HelloPrxCallbackPromise::PromisetestDyeingPtr &ptr) { _promise_testDyeing.setValue(ptr); } virtual void callback_testDyeing_exception(tars::Int32 ret) { std::string str(""); str += "Function:testDyeing_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testDyeing.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingPtr > _promise_testDyeing; public: struct PromisetestDyeingTrans: virtual public TC_HandleBase { public: tars::Int32 _ret; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestDyeingTrans > PromisetestDyeingTransPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingTransPtr > &promise) : _promise_testDyeingTrans(promise) {} virtual void callback_testDyeingTrans(const HelloPrxCallbackPromise::PromisetestDyeingTransPtr &ptr) { _promise_testDyeingTrans.setValue(ptr); } virtual void callback_testDyeingTrans_exception(tars::Int32 ret) { std::string str(""); str += "Function:testDyeingTrans_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testDyeingTrans.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingTransPtr > _promise_testDyeingTrans; public: struct PromisetestHello: virtual public TC_HandleBase { public: tars::Int32 _ret; std::string r; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestHello > PromisetestHelloPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestHelloPtr > &promise) : _promise_testHello(promise) {} virtual void callback_testHello(const HelloPrxCallbackPromise::PromisetestHelloPtr &ptr) { _promise_testHello.setValue(ptr); } virtual void callback_testHello_exception(tars::Int32 ret) { std::string str(""); str += "Function:testHello_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testHello.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestHelloPtr > _promise_testHello; public: struct PromisetestPid: virtual public TC_HandleBase { public: tars::Int32 _ret; std::string r; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestPid > PromisetestPidPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestPidPtr > &promise) : _promise_testPid(promise) {} virtual void callback_testPid(const HelloPrxCallbackPromise::PromisetestPidPtr &ptr) { _promise_testPid.setValue(ptr); } virtual void callback_testPid_exception(tars::Int32 ret) { std::string str(""); str += "Function:testPid_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testPid.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestPidPtr > _promise_testPid; public: struct PromisetestSyncTrans: virtual public TC_HandleBase { public: tars::Int32 _ret; std::string r; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestSyncTrans > PromisetestSyncTransPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestSyncTransPtr > &promise) : _promise_testSyncTrans(promise) {} virtual void callback_testSyncTrans(const HelloPrxCallbackPromise::PromisetestSyncTransPtr &ptr) { _promise_testSyncTrans.setValue(ptr); } virtual void callback_testSyncTrans_exception(tars::Int32 ret) { std::string str(""); str += "Function:testSyncTrans_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testSyncTrans.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestSyncTransPtr > _promise_testSyncTrans; public: struct PromisetestTimeout: virtual public TC_HandleBase { public: tars::Int32 _ret; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestTimeout > PromisetestTimeoutPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestTimeoutPtr > &promise) : _promise_testTimeout(promise) {} virtual void callback_testTimeout(const HelloPrxCallbackPromise::PromisetestTimeoutPtr &ptr) { _promise_testTimeout.setValue(ptr); } virtual void callback_testTimeout_exception(tars::Int32 ret) { std::string str(""); str += "Function:testTimeout_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testTimeout.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestTimeoutPtr > _promise_testTimeout; public: struct PromisetestTrans: virtual public TC_HandleBase { public: tars::Int32 _ret; std::string r; map _mRspContext; }; typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestTrans > PromisetestTransPtr; HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestTransPtr > &promise) : _promise_testTrans(promise) {} virtual void callback_testTrans(const HelloPrxCallbackPromise::PromisetestTransPtr &ptr) { _promise_testTrans.setValue(ptr); } virtual void callback_testTrans_exception(tars::Int32 ret) { std::string str(""); str += "Function:testTrans_exception|Ret:"; str += TC_Common::tostr(ret); _promise_testTrans.setException(tars::copyException(str, ret)); } protected: tars::Promise< HelloPrxCallbackPromise::PromisetestTransPtr > _promise_testTrans; public: virtual int onDispatch(tars::ReqMessagePtr msg) { static ::std::string __Hello_all[]= { "testConHash", "testCoro", "testDyeing", "testDyeingTrans", "testHello", "testPid", "testSyncTrans", "testTimeout", "testTrans" }; pair r = equal_range(__Hello_all, __Hello_all+9, string(msg->request.sFuncName)); if(r.first == r.second) return tars::TARSSERVERNOFUNCERR; switch(r.first - __Hello_all) { case 0: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testConHash_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestConHashPtr ptr = new HelloPrxCallbackPromise::PromisetestConHash(); try { _is.read(ptr->_ret, 0, true); _is.read(ptr->sOut, 1, true); } catch(std::exception &ex) { callback_testConHash_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testConHash_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testConHash(ptr); return tars::TARSSERVERSUCCESS; } case 1: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testCoro_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestCoroPtr ptr = new HelloPrxCallbackPromise::PromisetestCoro(); try { ptr->_ret = false; _is.read(ptr->_ret, 0, true); _is.read(ptr->sOut, 2, true); } catch(std::exception &ex) { callback_testCoro_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testCoro_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testCoro(ptr); return tars::TARSSERVERSUCCESS; } case 2: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testDyeing_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestDyeingPtr ptr = new HelloPrxCallbackPromise::PromisetestDyeing(); try { _is.read(ptr->_ret, 0, true); _is.read(ptr->strOut, 2, true); } catch(std::exception &ex) { callback_testDyeing_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testDyeing_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testDyeing(ptr); return tars::TARSSERVERSUCCESS; } case 3: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testDyeingTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestDyeingTransPtr ptr = new HelloPrxCallbackPromise::PromisetestDyeingTrans(); try { _is.read(ptr->_ret, 0, true); } catch(std::exception &ex) { callback_testDyeingTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testDyeingTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testDyeingTrans(ptr); return tars::TARSSERVERSUCCESS; } case 4: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testHello_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestHelloPtr ptr = new HelloPrxCallbackPromise::PromisetestHello(); try { _is.read(ptr->_ret, 0, true); _is.read(ptr->r, 3, true); } catch(std::exception &ex) { callback_testHello_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testHello_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testHello(ptr); return tars::TARSSERVERSUCCESS; } case 5: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testPid_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestPidPtr ptr = new HelloPrxCallbackPromise::PromisetestPid(); try { _is.read(ptr->_ret, 0, true); _is.read(ptr->r, 1, true); } catch(std::exception &ex) { callback_testPid_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testPid_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testPid(ptr); return tars::TARSSERVERSUCCESS; } case 6: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testSyncTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestSyncTransPtr ptr = new HelloPrxCallbackPromise::PromisetestSyncTrans(); try { _is.read(ptr->_ret, 0, true); _is.read(ptr->r, 3, true); } catch(std::exception &ex) { callback_testSyncTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testSyncTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testSyncTrans(ptr); return tars::TARSSERVERSUCCESS; } case 7: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testTimeout_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestTimeoutPtr ptr = new HelloPrxCallbackPromise::PromisetestTimeout(); try { _is.read(ptr->_ret, 0, true); } catch(std::exception &ex) { callback_testTimeout_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testTimeout_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testTimeout(ptr); return tars::TARSSERVERSUCCESS; } case 8: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); HelloPrxCallbackPromise::PromisetestTransPtr ptr = new HelloPrxCallbackPromise::PromisetestTrans(); try { _is.read(ptr->_ret, 0, true); _is.read(ptr->r, 3, true); } catch(std::exception &ex) { callback_testTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } ptr->_mRspContext = msg->response->context; callback_testTrans(ptr); return tars::TARSSERVERSUCCESS; } } return tars::TARSSERVERNOFUNCERR; } }; typedef tars::TC_AutoPtr HelloPrxCallbackPromisePtr; /* callback of coroutine async proxy for client */ class HelloCoroPrxCallback: public HelloPrxCallback { public: virtual ~HelloCoroPrxCallback(){} public: virtual const map & getResponseContext() const { return _mRspContext; } virtual void setResponseContext(const map &mContext) { _mRspContext = mContext; } public: int onDispatch(tars::ReqMessagePtr msg) { static ::std::string __Hello_all[]= { "testConHash", "testCoro", "testDyeing", "testDyeingTrans", "testHello", "testPid", "testSyncTrans", "testTimeout", "testTrans" }; pair r = equal_range(__Hello_all, __Hello_all+9, string(msg->request.sFuncName)); if(r.first == r.second) return tars::TARSSERVERNOFUNCERR; switch(r.first - __Hello_all) { case 0: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testConHash_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Int32 _ret; _is.read(_ret, 0, true); std::string sOut; _is.read(sOut, 1, true); setResponseContext(msg->response->context); callback_testConHash(_ret, sOut); } catch(std::exception &ex) { callback_testConHash_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testConHash_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } case 1: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testCoro_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Bool _ret = false; _is.read(_ret, 0, true); std::string sOut; _is.read(sOut, 2, true); setResponseContext(msg->response->context); callback_testCoro(_ret, sOut); } catch(std::exception &ex) { callback_testCoro_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testCoro_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } case 2: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testDyeing_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Int32 _ret; _is.read(_ret, 0, true); std::string strOut; _is.read(strOut, 2, true); setResponseContext(msg->response->context); callback_testDyeing(_ret, strOut); } catch(std::exception &ex) { callback_testDyeing_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testDyeing_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } case 3: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testDyeingTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Int32 _ret; _is.read(_ret, 0, true); setResponseContext(msg->response->context); callback_testDyeingTrans(_ret); } catch(std::exception &ex) { callback_testDyeingTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testDyeingTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } case 4: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testHello_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Int32 _ret; _is.read(_ret, 0, true); std::string r; _is.read(r, 3, true); setResponseContext(msg->response->context); callback_testHello(_ret, r); } catch(std::exception &ex) { callback_testHello_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testHello_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } case 5: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testPid_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Int32 _ret; _is.read(_ret, 0, true); std::string r; _is.read(r, 1, true); setResponseContext(msg->response->context); callback_testPid(_ret, r); } catch(std::exception &ex) { callback_testPid_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testPid_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } case 6: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testSyncTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Int32 _ret; _is.read(_ret, 0, true); std::string r; _is.read(r, 3, true); setResponseContext(msg->response->context); callback_testSyncTrans(_ret, r); } catch(std::exception &ex) { callback_testSyncTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testSyncTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } case 7: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testTimeout_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Int32 _ret; _is.read(_ret, 0, true); setResponseContext(msg->response->context); callback_testTimeout(_ret); } catch(std::exception &ex) { callback_testTimeout_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testTimeout_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } case 8: { if (msg->response->iRet != tars::TARSSERVERSUCCESS) { callback_testTrans_exception(msg->response->iRet); return msg->response->iRet; } tars::TarsInputStream _is; _is.setBuffer(msg->response->sBuffer); try { tars::Int32 _ret; _is.read(_ret, 0, true); std::string r; _is.read(r, 3, true); setResponseContext(msg->response->context); callback_testTrans(_ret, r); } catch(std::exception &ex) { callback_testTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } catch(...) { callback_testTrans_exception(tars::TARSCLIENTDECODEERR); return tars::TARSCLIENTDECODEERR; } return tars::TARSSERVERSUCCESS; } } return tars::TARSSERVERNOFUNCERR; } protected: map _mRspContext; }; typedef tars::TC_AutoPtr HelloCoroPrxCallbackPtr; /* proxy for client */ class HelloProxy : public tars::ServantProxy { public: typedef map TARS_CONTEXT; tars::Int32 testConHash(std::string &sOut,const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; _os.write(sOut, 1); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testConHash", 0, _trace_param_, ""); } std::map _mStatus; shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testConHash", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); _is.read(sOut, 1, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testConHash", 0, _trace_param_, ""); } return _ret; } void async_testConHash(HelloPrxCallbackPtr callback,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; std::map _mStatus; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testConHash", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testConHash", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestConHashPtr > promise_async_testConHash(const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestConHashPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testConHash", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testConHash(HelloCoroPrxCallbackPtr callback,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testConHash", _os, context, _mStatus, callback, true); } tars::Bool testCoro(const std::string & sIn,std::string &sOut,const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; _os.write(sIn, 1); _os.write(sOut, 2); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["sIn"] = tars::JsonOutput::writeJson(sIn); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testCoro", 0, _trace_param_, ""); } std::map _mStatus; shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testCoro", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Bool _ret = false; _is.read(_ret, 0, true); _is.read(sOut, 2, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testCoro", 0, _trace_param_, ""); } return _ret; } void async_testCoro(HelloPrxCallbackPtr callback,const std::string &sIn,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(sIn, 1); std::map _mStatus; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["sIn"] = tars::JsonOutput::writeJson(sIn); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testCoro", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testCoro", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestCoroPtr > promise_async_testCoro(const std::string &sIn,const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestCoroPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; _os.write(sIn, 1); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testCoro", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testCoro(HelloCoroPrxCallbackPtr callback,const std::string &sIn,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(sIn, 1); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testCoro", _os, context, _mStatus, callback, true); } tars::Int32 testDyeing(const std::string & strIn,std::string &strOut,const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; _os.write(strIn, 1); _os.write(strOut, 2); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["strIn"] = tars::JsonOutput::writeJson(strIn); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeing", 0, _trace_param_, ""); } std::map _mStatus; _mStatus.insert(std::make_pair(ServantProxy::STATUS_GRID_KEY, strIn)); shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testDyeing", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); _is.read(strOut, 2, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["strOut"] = tars::JsonOutput::writeJson(strOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeing", 0, _trace_param_, ""); } return _ret; } void async_testDyeing(HelloPrxCallbackPtr callback,const std::string &strIn,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(strIn, 1); std::map _mStatus; _mStatus.insert(std::make_pair(ServantProxy::STATUS_GRID_KEY, strIn)); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["strIn"] = tars::JsonOutput::writeJson(strIn); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeing", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testDyeing", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestDyeingPtr > promise_async_testDyeing(const std::string &strIn,const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; _os.write(strIn, 1); std::map _mStatus; _mStatus.insert(std::make_pair(ServantProxy::STATUS_GRID_KEY, strIn)); tars_invoke_async(tars::TARSNORMAL,"testDyeing", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testDyeing(HelloCoroPrxCallbackPtr callback,const std::string &strIn,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(strIn, 1); std::map _mStatus; _mStatus.insert(std::make_pair(ServantProxy::STATUS_GRID_KEY, strIn)); tars_invoke_async(tars::TARSNORMAL,"testDyeing", _os, context, _mStatus, callback, true); } tars::Int32 testDyeingTrans(const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeingTrans", 0, _trace_param_, ""); } std::map _mStatus; shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testDyeingTrans", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeingTrans", 0, _trace_param_, ""); } return _ret; } void async_testDyeingTrans(HelloPrxCallbackPtr callback,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; std::map _mStatus; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeingTrans", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testDyeingTrans", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestDyeingTransPtr > promise_async_testDyeingTrans(const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingTransPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testDyeingTrans", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testDyeingTrans(HelloCoroPrxCallbackPtr callback,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testDyeingTrans", _os, context, _mStatus, callback, true); } tars::Int32 testHello(tars::Int32 index,const std::string & s,std::string &r,const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); _os.write(r, 3); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testHello", 0, _trace_param_, ""); } std::map _mStatus; shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testHello", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); _is.read(r, 3, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testHello", 0, _trace_param_, ""); } return _ret; } void async_testHello(HelloPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testHello", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testHello", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestHelloPtr > promise_async_testHello(tars::Int32 index,const std::string &s,const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestHelloPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testHello", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testHello(HelloCoroPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testHello", _os, context, _mStatus, callback, true); } tars::Int32 testPid(std::string &r,const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; _os.write(r, 1); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testPid", 0, _trace_param_, ""); } std::map _mStatus; shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testPid", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); _is.read(r, 1, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testPid", 0, _trace_param_, ""); } return _ret; } void async_testPid(HelloPrxCallbackPtr callback,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; std::map _mStatus; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testPid", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testPid", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestPidPtr > promise_async_testPid(const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestPidPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testPid", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testPid(HelloCoroPrxCallbackPtr callback,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testPid", _os, context, _mStatus, callback, true); } tars::Int32 testSyncTrans(tars::Int32 index,const std::string & s,std::string &r,const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); _os.write(r, 3); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testSyncTrans", 0, _trace_param_, ""); } std::map _mStatus; shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testSyncTrans", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); _is.read(r, 3, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testSyncTrans", 0, _trace_param_, ""); } return _ret; } void async_testSyncTrans(HelloPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testSyncTrans", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testSyncTrans", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestSyncTransPtr > promise_async_testSyncTrans(tars::Int32 index,const std::string &s,const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestSyncTransPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testSyncTrans", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testSyncTrans(HelloCoroPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testSyncTrans", _os, context, _mStatus, callback, true); } tars::Int32 testTimeout(tars::Int32 timeout,const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; _os.write(timeout, 1); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["timeout"] = tars::JsonOutput::writeJson(timeout); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTimeout", 0, _trace_param_, ""); } std::map _mStatus; shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testTimeout", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTimeout", 0, _trace_param_, ""); } return _ret; } void async_testTimeout(HelloPrxCallbackPtr callback,tars::Int32 timeout,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(timeout, 1); std::map _mStatus; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["timeout"] = tars::JsonOutput::writeJson(timeout); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTimeout", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testTimeout", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestTimeoutPtr > promise_async_testTimeout(tars::Int32 timeout,const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestTimeoutPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; _os.write(timeout, 1); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testTimeout", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testTimeout(HelloCoroPrxCallbackPtr callback,tars::Int32 timeout,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(timeout, 1); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testTimeout", _os, context, _mStatus, callback, true); } tars::Int32 testTrans(tars::Int32 index,const std::string & s,std::string &r,const map &context = TARS_CONTEXT(),map * pResponseContext = NULL) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); _os.write(r, 3); ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTrans", 0, _trace_param_, ""); } std::map _mStatus; shared_ptr rep = tars_invoke(tars::TARSNORMAL,"testTrans", _os, context, _mStatus); if(pResponseContext) { pResponseContext->swap(rep->context); } tars::TarsInputStream _is; _is.setBuffer(rep->sBuffer); tars::Int32 _ret; _is.read(_ret, 0, true); _is.read(r, 3, true); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTrans", 0, _trace_param_, ""); } return _ret; } void async_testTrans(HelloPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { pSptd->newSpan(); string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTrans", 0, _trace_param_, ""); } tars_invoke_async(tars::TARSNORMAL,"testTrans", _os, context, _mStatus, callback); } tars::Future< HelloPrxCallbackPromise::PromisetestTransPtr > promise_async_testTrans(tars::Int32 index,const std::string &s,const map& context) { tars::Promise< HelloPrxCallbackPromise::PromisetestTransPtr > promise; HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise); tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testTrans", _os, context, _mStatus, callback); return promise.getFuture(); } void coro_testTrans(HelloCoroPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map& context = TARS_CONTEXT()) { tars::TarsOutputStream _os; _os.write(index, 1); _os.write(s, 2); std::map _mStatus; tars_invoke_async(tars::TARSNORMAL,"testTrans", _os, context, _mStatus, callback, true); } HelloProxy* tars_hash(int64_t key) { return (HelloProxy*)ServantProxy::tars_hash(key); } HelloProxy* tars_consistent_hash(int64_t key) { return (HelloProxy*)ServantProxy::tars_consistent_hash(key); } HelloProxy* tars_open_trace(bool traceParam = false) { return (HelloProxy*)ServantProxy::tars_open_trace(traceParam); } HelloProxy* tars_set_timeout(int msecond) { return (HelloProxy*)ServantProxy::tars_set_timeout(msecond); } static const char* tars_prxname() { return "HelloProxy"; } }; typedef tars::TC_AutoPtr HelloPrx; /* servant for server */ class Hello : public tars::Servant { public: virtual ~Hello(){} virtual tars::Int32 testConHash(std::string &sOut,tars::TarsCurrentPtr current) = 0; static void async_response_testConHash(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &sOut) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("sOut", sOut); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["sOut"] = tars::JsonOutput::writeJson(sOut); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(sOut, 1); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testConHash", 0, _trace_param_, ""); } } virtual tars::Bool testCoro(const std::string & sIn,std::string &sOut,tars::TarsCurrentPtr current) = 0; static void async_response_testCoro(tars::TarsCurrentPtr current, tars::Bool _ret, const std::string &sOut) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("sOut", sOut); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["sOut"] = tars::JsonOutput::writeJson(sOut); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(sOut, 2); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testCoro", 0, _trace_param_, ""); } } virtual tars::Int32 testDyeing(const std::string & strIn,std::string &strOut,tars::TarsCurrentPtr current) = 0; static void async_response_testDyeing(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &strOut) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("strOut", strOut); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["strOut"] = tars::JsonOutput::writeJson(strOut); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(strOut, 2); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["strOut"] = tars::JsonOutput::writeJson(strOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeing", 0, _trace_param_, ""); } } virtual tars::Int32 testDyeingTrans(tars::TarsCurrentPtr current) = 0; static void async_response_testDyeingTrans(tars::TarsCurrentPtr current, tars::Int32 _ret) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeingTrans", 0, _trace_param_, ""); } } virtual tars::Int32 testHello(tars::Int32 index,const std::string & s,std::string &r,tars::TarsCurrentPtr current) = 0; static void async_response_testHello(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &r) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("r", r); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["r"] = tars::JsonOutput::writeJson(r); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(r, 3); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testHello", 0, _trace_param_, ""); } } virtual tars::Int32 testPid(std::string &r,tars::TarsCurrentPtr current) = 0; static void async_response_testPid(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &r) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("r", r); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["r"] = tars::JsonOutput::writeJson(r); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(r, 1); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testPid", 0, _trace_param_, ""); } } virtual tars::Int32 testSyncTrans(tars::Int32 index,const std::string & s,std::string &r,tars::TarsCurrentPtr current) = 0; static void async_response_testSyncTrans(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &r) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("r", r); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["r"] = tars::JsonOutput::writeJson(r); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(r, 3); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testSyncTrans", 0, _trace_param_, ""); } } virtual tars::Int32 testTimeout(tars::Int32 timeout,tars::TarsCurrentPtr current) = 0; static void async_response_testTimeout(tars::TarsCurrentPtr current, tars::Int32 _ret) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTimeout", 0, _trace_param_, ""); } } virtual tars::Int32 testTrans(tars::Int32 index,const std::string & s,std::string &r,tars::TarsCurrentPtr current) = 0; static void async_response_testTrans(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &r) { size_t _rsp_len_ = 0; if (current->getRequestVersion() == TUPVERSION ) { UniAttribute tarsAttr; tarsAttr.setVersion(current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("r", r); vector sTupResponseBuffer; tarsAttr.encode(sTupResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer); _rsp_len_ = sTupResponseBuffer.size(); } else if (current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["r"] = tars::JsonOutput::writeJson(r); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); vector sJsonResponseBuffer; tars::TC_Json::writeValue(_p, sJsonResponseBuffer); current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer); _rsp_len_ = sJsonResponseBuffer.size(); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(r, 3); current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer()); _rsp_len_ = _os.getLength(); } if (current->isTraced()) { string _trace_param_; int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTrans", 0, _trace_param_, ""); } } public: int onDispatch(tars::TarsCurrentPtr _current, vector &_sResponseBuffer) { static ::std::string __Test__Hello_all[]= { "testConHash", "testCoro", "testDyeing", "testDyeingTrans", "testHello", "testPid", "testSyncTrans", "testTimeout", "testTrans" }; pair r = equal_range(__Test__Hello_all, __Test__Hello_all+9, _current->getFuncName()); if(r.first == r.second) return tars::TARSSERVERNOFUNCERR; switch(r.first - __Test__Hello_all) { case 0: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); std::string sOut; if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); tarsAttr.getByDefault("sOut", sOut, sOut); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); tars::JsonInput::readJson(sOut, _jsonPtr->value["sOut"], false); } else { _is.read(sOut, 1, false); } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testConHash", 0, _trace_param_, ""); } tars::Int32 _ret = testConHash(sOut, _current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("sOut", sOut); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["sOut"] = tars::JsonOutput::writeJson(sOut); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(sOut, 1); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testConHash", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } case 1: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); std::string sIn; std::string sOut; if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); tarsAttr.get("sIn", sIn); tarsAttr.getByDefault("sOut", sOut, sOut); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); tars::JsonInput::readJson(sIn, _jsonPtr->value["sIn"], true); tars::JsonInput::readJson(sOut, _jsonPtr->value["sOut"], false); } else { _is.read(sIn, 1, true); _is.read(sOut, 2, false); } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["sIn"] = tars::JsonOutput::writeJson(sIn); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testCoro", 0, _trace_param_, ""); } tars::Bool _ret = testCoro(sIn,sOut, _current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("sOut", sOut); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["sOut"] = tars::JsonOutput::writeJson(sOut); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(sOut, 2); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testCoro", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } case 2: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); std::string strIn; std::string strOut; if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); tarsAttr.get("strIn", strIn); tarsAttr.getByDefault("strOut", strOut, strOut); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); tars::JsonInput::readJson(strIn, _jsonPtr->value["strIn"], true); tars::JsonInput::readJson(strOut, _jsonPtr->value["strOut"], false); } else { _is.read(strIn, 1, true); _is.read(strOut, 2, false); } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["strIn"] = tars::JsonOutput::writeJson(strIn); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeing", 0, _trace_param_, ""); } tars::Int32 _ret = testDyeing(strIn,strOut, _current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("strOut", strOut); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["strOut"] = tars::JsonOutput::writeJson(strOut); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(strOut, 2); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["strOut"] = tars::JsonOutput::writeJson(strOut); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeing", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } case 3: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); } else { } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeingTrans", 0, _trace_param_, ""); } tars::Int32 _ret = testDyeingTrans(_current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeingTrans", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } case 4: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); tars::Int32 index; std::string s; std::string r; if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); tarsAttr.get("index", index); tarsAttr.get("s", s); tarsAttr.getByDefault("r", r, r); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); tars::JsonInput::readJson(index, _jsonPtr->value["index"], true); tars::JsonInput::readJson(s, _jsonPtr->value["s"], true); tars::JsonInput::readJson(r, _jsonPtr->value["r"], false); } else { _is.read(index, 1, true); _is.read(s, 2, true); _is.read(r, 3, false); } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testHello", 0, _trace_param_, ""); } tars::Int32 _ret = testHello(index,s,r, _current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("r", r); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["r"] = tars::JsonOutput::writeJson(r); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(r, 3); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testHello", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } case 5: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); std::string r; if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); tarsAttr.getByDefault("r", r, r); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); tars::JsonInput::readJson(r, _jsonPtr->value["r"], false); } else { _is.read(r, 1, false); } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testPid", 0, _trace_param_, ""); } tars::Int32 _ret = testPid(r, _current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("r", r); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["r"] = tars::JsonOutput::writeJson(r); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(r, 1); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testPid", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } case 6: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); tars::Int32 index; std::string s; std::string r; if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); tarsAttr.get("index", index); tarsAttr.get("s", s); tarsAttr.getByDefault("r", r, r); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); tars::JsonInput::readJson(index, _jsonPtr->value["index"], true); tars::JsonInput::readJson(s, _jsonPtr->value["s"], true); tars::JsonInput::readJson(r, _jsonPtr->value["r"], false); } else { _is.read(index, 1, true); _is.read(s, 2, true); _is.read(r, 3, false); } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testSyncTrans", 0, _trace_param_, ""); } tars::Int32 _ret = testSyncTrans(index,s,r, _current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("r", r); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["r"] = tars::JsonOutput::writeJson(r); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(r, 3); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testSyncTrans", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } case 7: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); tars::Int32 timeout; if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); tarsAttr.get("timeout", timeout); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); tars::JsonInput::readJson(timeout, _jsonPtr->value["timeout"], true); } else { _is.read(timeout, 1, true); } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["timeout"] = tars::JsonOutput::writeJson(timeout); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTimeout", 0, _trace_param_, ""); } tars::Int32 _ret = testTimeout(timeout, _current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTimeout", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } case 8: { tars::TarsInputStream _is; _is.setBuffer(_current->getRequestBuffer()); tars::Int32 index; std::string s; std::string r; if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.decode(_current->getRequestBuffer()); tarsAttr.get("index", index); tarsAttr.get("s", s); tarsAttr.getByDefault("r", r, r); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer())); tars::JsonInput::readJson(index, _jsonPtr->value["index"], true); tars::JsonInput::readJson(s, _jsonPtr->value["s"], true); tars::JsonInput::readJson(r, _jsonPtr->value["r"], false); } else { _is.read(index, 1, true); _is.read(s, 2, true); _is.read(r, 3, false); } ServantProxyThreadData *pSptd = ServantProxyThreadData::getData(); if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value["index"] = tars::JsonOutput::writeJson(index); _p_->value["s"] = tars::JsonOutput::writeJson(s); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTrans", 0, _trace_param_, ""); } tars::Int32 _ret = testTrans(index,s,r, _current); if(_current->isResponse()) { if (_current->getRequestVersion() == TUPVERSION) { UniAttribute tarsAttr; tarsAttr.setVersion(_current->getRequestVersion()); tarsAttr.put("", _ret); tarsAttr.put("tars_ret", _ret); tarsAttr.put("r", r); tarsAttr.encode(_sResponseBuffer); } else if (_current->getRequestVersion() == JSONVERSION) { tars::JsonValueObjPtr _p = new tars::JsonValueObj(); _p->value["r"] = tars::JsonOutput::writeJson(r); _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret); tars::TC_Json::writeValue(_p, _sResponseBuffer); } else { tars::TarsOutputStream _os; _os.write(_ret, 0); _os.write(r, 3); _os.swap(_sResponseBuffer); } if (pSptd && pSptd->_traceCall) { string _trace_param_; int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size()); if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_) { tars::JsonValueObjPtr _p_ = new tars::JsonValueObj(); _p_->value[""] = tars::JsonOutput::writeJson(_ret); _p_->value["r"] = tars::JsonOutput::writeJson(r); _trace_param_ = tars::TC_Json::writeValue(_p_); } else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_) { _trace_param_ = "{\"trace_param_over_max_len\":true}"; } TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTrans", 0, _trace_param_, ""); } } else if(pSptd && pSptd->_traceCall) { _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS)); } return tars::TARSSERVERSUCCESS; } } return tars::TARSSERVERNOFUNCERR; } }; } #endif