void EchoServer::start()
{
_transport.start();
EchoPacketFactory factory;
DefaultPacketStreamer streamer(&factory);
EchoServerAdapter serverAdapter;
IOComponent *ioc = _transport.listen(_spec, &streamer, &serverAdapter);
if (ioc == NULL) {
TBSYS_LOG(ERROR, "listen error.");
return;
}
_transport.wait();
}
void EchoServer::start() {
DefaultPacketFactory factory;
DefaultPacketStreamer streamer(&factory);
IOComponent *ioc = _transport.listen(_spec.c_str(), &streamer, this);
if (ioc == NULL) {
ANET_LOG(ERROR, "listen error.");
return;
}
ANET_LOG(INFO, "EchoServer(%s) started.", _spec.c_str());
_transport.run();
ANET_LOG(INFO, "EchoServer(%s) Quiting...", _spec.c_str());
ANET_GLOBAL_STAT.log();
ioc->close();
ioc->subRef();
}
void TCPCONNECTIONTF::testReadMaliciousDataInfinitLoop() {
ANET_LOG(DEBUG, "Begin testReadMaliciousDataInfinitLoop");
int64_t now = TimeUtil::getTime();
Transport tranClient;
Transport tranServer;
const char sepc[] = "tcp:localhost:12346";
ConnPacketFactory factory;
DefaultPacketStreamer defaultStreamer(&factory);
DefaultPacketHandler defaultHandler;
TCPServerAdapter adapter;
MaliciousStreamer maliciousStreamer(&factory);
IOComponent *listener =
tranServer.listen(sepc, &defaultStreamer, &adapter);
CPPUNIT_ASSERT(listener);
ANET_LOG(SPAM,"After tranServer->listen()");
tranServer.eventIteration(now);
ANET_LOG(SPAM,"After tranServer->eventIteration(now)");
//create a connection
Connection *conn = tranClient.connect(sepc, &maliciousStreamer);
ANET_LOG(SPAM,"After tranClient->connect(spec, _streamer, false)");
CPPUNIT_ASSERT(conn);
tranClient.eventIteration(now);
ANET_LOG(SPAM,"After tranClient->eventIteration(now)");
//accept the connection
tranServer.eventIteration(now);
ANET_LOG(SPAM,"After tranServer->eventIteration(now)");
conn->postPacket(new ConnPacket(11), &defaultHandler, NULL);
maliciousStreamer._maliciousLen = 0x80000000 + 10;
ANET_LOG(DEBUG,"before conn->writeData()");
conn->writeData();
ANET_LOG(DEBUG,"before connAcc->readData()");
tranServer.eventIteration(now);
ANET_LOG(DEBUG,"after connAcc->readData()");
tranClient.eventIteration(now);
CPPUNIT_ASSERT(conn->isClosed());
ANET_LOG(DEBUG,"after tranClient.eventIteration(now)");
conn->subRef();
listener->subRef();
ANET_LOG(DEBUG, "End testReadMaliciousDataInfinitLoop");
}
/**
* test Server and Client memory leak
* test whether packets are deleted when connection closed
*/
void TCPCONNECTIONTF::testMemLeak() {
char spec[] = "tcp:localhost:13147";
int64_t now = TimeUtil::getTime();
Transport *tranServer = new Transport;
Transport *tranClient = new Transport;
ConnServerAdapter *adapter = new ConnServerAdapter;
//add listener to tranServer
IOComponent *listener = tranServer->listen(spec, _streamer, adapter);
CPPUNIT_ASSERT(listener);
tranServer->eventIteration(now);
//create a connection
Connection *conn = tranClient->connect(spec, _streamer, false);
CPPUNIT_ASSERT(conn);
tranClient->eventIteration(now);
//accept the connection
tranServer->eventIteration(now);
// client send two packets
_conn->postPacket(new ConnPacket, _handler, NULL, true);
_conn->postPacket(new ConnPacket, _handler, NULL, true);
tranClient->eventIteration(now);
//server accept two packets
tranServer->eventIteration(now);
IOComponent *ioc = tranServer->_iocListTail;
Connection *tmpConn = ((TCPComponent *)ioc)->_connection;
//client close the connection
_conn->close();
tranClient->eventIteration(now);
tranServer->eventIteration(now);
CPPUNIT_ASSERT_EQUAL((size_t)0, tmpConn->_outputQueue.size());
delete adapter;
delete tranClient;
delete tranServer;
listener->subRef();
conn->subRef();
}
void TCPCONNECTIONTF::testClose()
{
TCPServerAdapter adapter;
Transport *tranServer = new Transport;
char spec[] = "tcp:localhost:13345";
tranServer->start();
IOComponent *listener = tranServer->listen(spec, _streamer, &adapter);
CPPUNIT_ASSERT(listener);
//start client
Transport *tranClient = new Transport;
tranClient->start();
Connection *conn = tranClient->connect(spec, _streamer, false);
CPPUNIT_ASSERT(conn);
CPPUNIT_ASSERT(_conn->postPacket(new ConnPacket(31), _handler, NULL));
// the close() has not implement
ANET_LOG(SPAM,"Before Calling _conn->close();");
_conn->close();
ANET_LOG(SPAM,"After Calling _conn->close();");
CPPUNIT_ASSERT(_conn->isClosed());
ANET_LOG(SPAM,"After Assert(_conn->isClosed();");
tranClient->stop();
ANET_LOG(SPAM,"After Calling tranClient->stop();");
tranClient->wait();
ANET_LOG(SPAM,"After Calling tranClient->wait();");
tranServer->stop();
ANET_LOG(SPAM,"After Calling tran_server->stop();");
tranServer->wait();
ANET_LOG(SPAM,"After Calling tranClient->wait();");
delete tranClient;
delete tranServer;
listener->subRef();
conn->subRef();
}
void doProcess(unsigned int port, unsigned int num, CMClient& client)
{
Transport transport;
transport.start(); //using multithreads mode of anet
Thread *threads = new Thread[num];
RequestProcessor *runnables = new RequestProcessor [num];
assert(threads);
assert(runnables);
for (long i=0; i<num; i++) {
threads[i].start(runnables + i, (void*)&client);
}
HTTPPacketFactory factory;
HTTPStreamer streamer(&factory);
HTTPServerAdapter serverAdapter;
stringstream ss;
char hostname[1024];
if (gethostname(hostname, 1024) != 0) {
transport.stop();
transport.wait();
delete [] threads;
delete [] runnables;
exit(-1);
}
// ss << "tcp:" << hostname << ":" << port;
ss << "tcp:" << ":" << port;
string str = ss.str();
const char *spec = str.c_str();
IOComponent *ioc = transport.listen(spec, &streamer, &serverAdapter);
if (ioc == NULL) {
printf("create listen port error\n");
transport.stop();
transport.wait();
delete [] threads;
delete [] runnables;
return;
}
printf("webserver start ok\n");
while (!globalStopFlag) {
usleep(100000);
}
transport.stop();
transport.wait();
globalQueue._condition.lock();
while (globalQueue._queue.size()) {
HTTPRequestEntry entry = globalQueue._queue.front();
entry._packet->free();
entry._connection->subRef();
globalQueue._queue.pop();
}
globalQueue._condition.broadcast();
globalQueue._condition.unlock();
for (long i=0; i<num; i++) {
threads[i].join();
}
delete [] threads;
delete [] runnables;
}
void doProcess(unsigned int port, unsigned int num) {
Thread *threads = new Thread[num];
RequestProcessor *runnables = new RequestProcessor [num];
assert(threads);
assert(runnables);
for (long i=0; i<num; i++) {
ANET_LOG(DEBUG, "Starting thread(%d)", i);
threads[i].start(&runnables[i], (void*)i);
}
Transport transport;
// transport.start(); //using multithreads mode of anet
DefaultPacketFactory factory;
DefaultPacketStreamer streamer(&factory);
MyServerAdapter serverAdapter;
stringstream ss;
char hostname[1024];
if (gethostname(hostname, 1024) != 0) {
ANET_LOG(ERROR, "Failed to get hostname");
exit(-1);
}
ss << "tcp:" << hostname << ":" << port;
string str = ss.str().c_str();
const char *spec = str.c_str();
ANET_LOG(INFO, "listen to %s", spec);
IOComponent *ioc = transport.listen(spec, &streamer, &serverAdapter);
if (ioc == NULL) {
ANET_LOG(ERROR, "listen (%s) ERROR.", spec);
return;
}
while (!globalStopFlag) {
// usleep(100000);
int64_t now;
transport.runIteration(now);
}
// transport.stop();
// transport.wait();
transport.closeComponents();
globalQueue._condition.lock();
while (globalQueue._queue.size()) {
RequestEntry entry = globalQueue._queue.front();
DefaultPacket *packet = (DefaultPacket*)entry._packet;
ANET_LOG(WARN,"Discard request %s", packet->getBody());
entry._packet->free();
entry._connection->subRef();
globalQueue._queue.pop();
}
globalQueue._condition.broadcast();
globalQueue._condition.unlock();
for (long i=0; i<num; i++) {
ANET_LOG(INFO, "Join thread(%d)",i);
threads[i].join();
}
printf("*****************************************************\n");
printf("Worker Summary\n");
printf("THREAD_ID TOT_TIME(ms) LOCK_TIME(ms) TASK_TIME(ms) TASK_WAIT(ms) TASKS_PROCESSED\n");
for (long i=0; i<num; i++) {
printf("%8ld %12.2f %12.2f %12.2f %13.2f %12ld\n",
runnables[i].m_id,
runnables[i].m_totalTime / 1000.0,
runnables[i].m_lockTime / 1000.0,
runnables[i].m_taskProcessTime / 1000.0,
runnables[i].m_taskWaitTime / 1000.0,
runnables[i].m_taskProcesssed);
}
printf("\n");
printf("Queue Summary\n");
printf(" #Enqueue Acc_Enqueue_Len #Signals Push_Time(ms) Push_Wait_Time(ms)\n");
printf("%12ld %14ld %8ld %13.2f %18.2f\n",
globalQueue.mEnqueueCount,
globalQueue.mAccDequeueLength,
globalQueue.mSignalCount,
globalQueue.mAccEnqueueTime / 1000.0,
globalQueue.mAccEnqueueWaitTime / 1000.0);
printf(" #Dequeue Acc_Dequeue_Len #Waits Pop_Time(ms) Pop_Wait_Time(ms)\n");
printf("%12ld %14ld %8ld %13.2f %18.2f\n",
globalQueue.mDequeCount,
globalQueue.mAccDequeueLength,
globalQueue.mWaitCount,
globalQueue.mAccDequeueTime / 1000.0,
globalQueue.mAccDequeueWaitTime / 1000.0);
printf("*****************************************************\n");
delete [] threads;
delete [] runnables;
}
