mirror of
https://gitee.com/TarsCloud/TarsCpp.git
synced 2025-01-03 05:22:26 +08:00
368 lines
8.9 KiB
C++
Executable File
368 lines
8.9 KiB
C++
Executable File
|
|
#include "server/HelloServer.h"
|
|
#include "server/Hello.h"
|
|
#include "gtest/gtest.h"
|
|
#include "certs.h"
|
|
|
|
#include <mutex>
|
|
#include <iostream>
|
|
|
|
using namespace tars;
|
|
using namespace Test;
|
|
|
|
class PushCallBack : public ServantProxyCallback
|
|
{
|
|
public:
|
|
|
|
int onDispatch(ReqMessagePtr msg)
|
|
{
|
|
if(msg->request.sFuncName == "printResult")
|
|
{
|
|
string sRet;
|
|
sRet.assign(&(msg->response->sBuffer[0]), msg->response->sBuffer.size());
|
|
_onprintresult = true;
|
|
// printResult(msg->request.iRequestId, sRet);
|
|
return 0;
|
|
}
|
|
else if(msg->response->iRequestId == 0)
|
|
{
|
|
string sRet;
|
|
sRet.assign(&(msg->response->sBuffer[0]), msg->response->sBuffer.size());
|
|
++_onpushinfo;
|
|
// printPushInfo(sRet);
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
LOG_CONSOLE_DEBUG << "no match func!" <<endl;
|
|
}
|
|
return -3;
|
|
}
|
|
|
|
void onConnect(const TC_Endpoint &ep)
|
|
{
|
|
_onconnect = true;
|
|
// LOG_CONSOLE_DEBUG << "onConnect:" << ep.toString() << ", " << _onconnect << ", " << this << endl;
|
|
}
|
|
|
|
void onClose()
|
|
{
|
|
_onclose = true;
|
|
// LOG_CONSOLE_DEBUG << "onClose:" << _onclose << endl;
|
|
}
|
|
|
|
bool _onclose = false;
|
|
bool _onconnect = false;
|
|
bool _onprintresult = false;
|
|
int _onpushinfo = 0;
|
|
|
|
};
|
|
|
|
typedef tars::TC_AutoPtr<PushCallBack> PushCallBackPtr;
|
|
|
|
struct ClientHelloCallback : public HelloPrxCallback
|
|
{
|
|
ClientHelloCallback(int64_t t, int i, int c, const string &buff, std::atomic<int> &count) : start(t), cur(i), count(c), buffer(buff), callback_count(count)
|
|
{
|
|
}
|
|
|
|
ClientHelloCallback(HelloPrx prx, std::atomic<int> &count) : _prx(prx), callback_count(count)
|
|
{
|
|
}
|
|
|
|
//回调函数
|
|
virtual void callback_testTrans(int ret, const string &r);
|
|
|
|
//回调函数
|
|
virtual void callback_testHello(int ret, const string &r);
|
|
|
|
virtual void callback_testSyncTrans(tars::Int32 ret, const std::string& r);
|
|
|
|
virtual void callback_testHello_exception(tars::Int32 ret)
|
|
{
|
|
LOG_CONSOLE_DEBUG << "callback exception:" << ret << endl;
|
|
exit(-1);
|
|
}
|
|
|
|
virtual void callback_testTrans_exception(tars::Int32 ret)
|
|
{
|
|
LOG_CONSOLE_DEBUG << "callback exception:" << ret << endl;
|
|
exit(-1);
|
|
}
|
|
|
|
virtual void callback_testSyncTrans_exception(tars::Int32 ret)
|
|
{
|
|
LOG_CONSOLE_DEBUG << "callback exception:" << ret << endl;
|
|
exit(-1);
|
|
}
|
|
|
|
virtual void callback_testTimeout(int ret)
|
|
{
|
|
callback = true;
|
|
}
|
|
|
|
virtual void callback_testTimeout_exception(tars::Int32 ret)
|
|
{
|
|
callback_exception = true;
|
|
}
|
|
HelloPrx _prx;
|
|
|
|
bool callback = false;
|
|
bool callback_exception = false;
|
|
int64_t start;
|
|
int cur;
|
|
int count;
|
|
string buffer;
|
|
std::atomic<int> &callback_count;
|
|
|
|
};
|
|
|
|
|
|
struct HelloHttpCallback : public HttpCallback
|
|
{
|
|
HelloHttpCallback(int64_t t, int i, int c, const string &buff, std::atomic<int> &count) : start(t), cur(i), count(c),_buff(buff), callback_count(count)
|
|
{
|
|
|
|
}
|
|
|
|
virtual int onHttpResponse(const shared_ptr<TC_HttpResponse> &rsp)
|
|
{
|
|
[&]()
|
|
{
|
|
ASSERT_TRUE(rsp->getContent() == _buff);
|
|
}();
|
|
|
|
callback_count++;
|
|
|
|
if(cur == count-1)
|
|
{
|
|
int64_t cost = TC_Common::now2us() - start;
|
|
LOG_CONSOLE_DEBUG << "count:" << count << ", " << cost << " us, avg:" << 1.*cost/count << "us" << endl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
virtual int onHttpResponseException(int expCode)
|
|
{
|
|
LOG_CONSOLE_DEBUG << "onHttpResponseException expCode:" << expCode << endl;
|
|
return 0;
|
|
}
|
|
|
|
int64_t start;
|
|
int cur;
|
|
int count;
|
|
string _buff;
|
|
std::atomic<int> &callback_count;
|
|
|
|
};
|
|
|
|
class CustomCallBack : public ServantProxyCallback
|
|
{
|
|
public:
|
|
|
|
CustomCallBack(std::atomic<int> &count) : callback_count(count) {}
|
|
|
|
virtual int onDispatch(ReqMessagePtr msg)
|
|
{
|
|
if(msg->response->iRet != tars::TARSSERVERSUCCESS)
|
|
{
|
|
cout << "ret error:" << msg->response->iRet << endl;
|
|
}
|
|
else
|
|
{
|
|
// cout << "succ:" << string(msg->response->sBuffer.data(), msg->response->sBuffer.size()) << endl;
|
|
}
|
|
|
|
++callback_count;
|
|
return msg->response->iRet;
|
|
}
|
|
|
|
virtual void onClose()
|
|
{
|
|
|
|
}
|
|
|
|
std::atomic<int> &callback_count;
|
|
};
|
|
|
|
typedef tars::TC_AutoPtr<CustomCallBack> CustomCallBackPtr;
|
|
|
|
class HelloTest : public testing::Test
|
|
{
|
|
public:
|
|
//添加日志
|
|
static void SetUpTestCase()
|
|
{
|
|
|
|
}
|
|
static void TearDownTestCase()
|
|
{
|
|
}
|
|
|
|
virtual void SetUp()
|
|
{
|
|
_buffer.assign(100, 'a');
|
|
|
|
_conf = CONFIG();
|
|
|
|
TC_File::removeFile("RpcServer.tarsdat", false);
|
|
}
|
|
virtual void TearDown()
|
|
{
|
|
LOG_CONSOLE_DEBUG << "fd count:" << getFdCounts() << endl;
|
|
}
|
|
|
|
template<typename T>
|
|
void startServer(T &server, TC_Config conf, TC_EpollServer::SERVER_OPEN_COROUTINE openCoroutine = TC_EpollServer::NET_THREAD_MERGE_HANDLES_THREAD)
|
|
{
|
|
conf.set("/tars/application/server<opencoroutine>", TC_Common::tostr(openCoroutine));
|
|
|
|
ASSERT_TRUE(conf.get("/tars/application/server<opencoroutine>") == TC_Common::tostr(openCoroutine));
|
|
|
|
server.main(conf.tostr());
|
|
|
|
server.start();
|
|
|
|
server.waitForReady();
|
|
}
|
|
|
|
void startServer(HelloServer &server, TC_EpollServer::SERVER_OPEN_COROUTINE openCoroutine);
|
|
|
|
template<typename T>
|
|
void stopServer(T &server)
|
|
{
|
|
server.terminate();
|
|
server.getThreadControl().join();
|
|
}
|
|
|
|
TC_Endpoint getEndpoint(const string &adapter);
|
|
|
|
string getObj(TC_Config &conf, const string &adapter)
|
|
{
|
|
return conf.get("/tars/application/server/" + adapter + "<servant>") + "@" + conf.get("/tars/application/server/" + adapter + "<endpoint>");
|
|
}
|
|
|
|
TC_Endpoint getEndpoint(TC_Config &conf, const string &adapter)
|
|
{
|
|
return TC_Endpoint(conf.get("/tars/application/server/" + adapter + "<endpoint>"));
|
|
}
|
|
|
|
TC_Endpoint getLocalEndpoint(const TC_Config &conf)
|
|
{
|
|
return TC_Endpoint(conf.get("/tars/application/server<local>"));
|
|
}
|
|
|
|
template<typename T>
|
|
T getObj(Communicator *comm, const string &adapter)
|
|
{
|
|
comm->setProperty("sendqueuelimit", "1000000");
|
|
// comm->setProperty("asyncqueuecap", "1000000");
|
|
|
|
string obj = getObj(_conf, adapter);
|
|
T prx = comm->stringToProxy<T>(obj);
|
|
|
|
prx->tars_timeout(60000);
|
|
prx->tars_async_timeout(60000);
|
|
|
|
return prx;
|
|
}
|
|
|
|
int getFdCounts()
|
|
{
|
|
//linux下才生效, 其他平台都是返回的0
|
|
vector<string> fds;
|
|
TC_File::listDirectory("/proc/" + TC_Common::tostr(getpid()) + "/fd", fds, false);
|
|
return fds.size();
|
|
}
|
|
|
|
int getSocketFd(int iSocketType = SOCK_DGRAM, int iDomain = AF_INET)
|
|
{
|
|
TC_Socket s1;
|
|
s1.createSocket(iSocketType, AF_INET);
|
|
s1.setOwner(false);
|
|
|
|
return s1.getfd();
|
|
}
|
|
|
|
void waitForFinish(atomic<int> &callback_count, int count);
|
|
|
|
void wait(int millseconds);
|
|
|
|
void syncCustom(Communicator *comm, const string &adapter = "CustomAdapter");
|
|
|
|
void asyncCustom(Communicator *comm, const string &adapter = "CustomAdapter");
|
|
|
|
void testPush(Communicator *comm, const string &adapter = "PushAdapter");
|
|
|
|
void testReconnect(Communicator *comm, const string &adapter = "PushAdapter");
|
|
|
|
void checkWup();
|
|
|
|
void checkSyncHttp(Communicator *comm, const string &adapter = "HttpAdapter", bool close = false);
|
|
|
|
void checkASyncHttp(Communicator *comm, const string &adapter = "HelloAdapter", bool close = false);
|
|
|
|
void checkSync(Communicator *comm, const string &adapter = "HelloAdapter");
|
|
|
|
void checkSyncOnce(HelloPrx prx);
|
|
|
|
void checkASyncOnce(HelloPrx prx);//Communicator *comm, const string &adapter = "HelloAdapter");
|
|
|
|
void checkASync(Communicator *comm, const string &adapter = "HelloAdapter");
|
|
|
|
void checkTransSyncASync(Communicator *comm);
|
|
|
|
void checkTransASyncASync(Communicator *comm);
|
|
|
|
void checkTransSyncSync(Communicator *comm);
|
|
|
|
void checkTransASyncSync(Communicator *comm);
|
|
|
|
void checkWupTransSync(Communicator *comm);
|
|
|
|
void checkSyncTimeout(Communicator *comm);
|
|
|
|
void checkASyncTimeout(Communicator *comm);
|
|
|
|
void checkStat(Communicator *comm, int reportCount);
|
|
|
|
void rpcFromRegistry(Communicator *comm);
|
|
|
|
void rpcConHashFromRegistry(Communicator *comm);
|
|
|
|
void forEach(function<void()> func);
|
|
|
|
void forEach(function<void(Communicator *comm)> func);
|
|
|
|
void transGlobalCommunicator(function<void(Communicator *)> func, Communicator *comm);
|
|
|
|
void transServerCommunicator(function<void(Communicator *)> func);
|
|
|
|
void transAllocCommunicator(function<void(Communicator *)> func);
|
|
|
|
void transComplexCommunicator(function<void(Communicator *)> func, Communicator *comm);
|
|
|
|
void funcInCoroutine(function<void()> func, bool setSched = true);
|
|
|
|
void forEachInCoroutine(function<void(Communicator *comm)> func);
|
|
|
|
void transInCoroutineGlobalCommunicator(function<void(Communicator *)> func, Communicator *comm);
|
|
|
|
void transInCoroutineServerCommunicator(function<void(Communicator *)> func);
|
|
|
|
void transInCoroutineAllocCommunicator(function<void(Communicator *)> func);
|
|
|
|
void transInCoroutineComplexCommunicator(function<void(Communicator *)> func, Communicator *comm);
|
|
|
|
shared_ptr<Communicator> getCommunicator();
|
|
|
|
protected:
|
|
int _count = 1000;
|
|
// int _count = 10;
|
|
|
|
string _buffer;
|
|
|
|
TC_Config _conf;
|
|
};
|
|
|