void SocketTest::testSelect()
{
Timespan timeout(250000);
EchoServer echoServer;
StreamSocket ss;
ss.connect(SocketAddress("localhost", echoServer.port()));
Socket::SocketList readList;
Socket::SocketList writeList;
Socket::SocketList exceptList;
readList.push_back(ss);
assert (Socket::select(readList, writeList, exceptList, timeout) == 0);
assert (readList.empty());
assert (writeList.empty());
assert (exceptList.empty());
ss.sendBytes("hello", 5);
ss.poll(timeout, Socket::SELECT_READ);
readList.push_back(ss);
writeList.push_back(ss);
assert (Socket::select(readList, writeList, exceptList, timeout) == 2);
assert (!readList.empty());
assert (!writeList.empty());
assert (exceptList.empty());
char buffer[256];
int n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
ss.close();
}
void SocketStreamTest::testEOF()
{
StreamSocket ss;
SocketStream str(ss);
{
EchoServer echoServer;
ss.connect(SocketAddress("localhost", echoServer.port()));
str << "hello";
assert (str.good());
str.flush();
assert (str.good());
ss.shutdownSend();
char buffer[5];
str.read(buffer, sizeof(buffer));
assert (str.good());
assert (str.gcount() == 5);
assert (std::string(buffer, 5) == "hello");
}
int c = str.get();
assert (c == -1);
assert (str.eof());
ss.close();
}
static void* recvDataLoop(void *arg)
{
StreamSocket *ss =(StreamSocket *)arg;
if(NULL == ss)
{
cerr << "recvDataLoop arg is NULL"<<__LINE__<<endl;
return NULL;
}
cout <<"###@@@enter recvDataLoop@@@@### ip:"<< ss->getRemoteIP()<<":"<< ss->getRemotePort()<<endl;
StreamSocket sock = StreamSocket(ss->getRemoteSocket(), ss->getRemoteIP(), ss->getRemotePort());
char buff[RECV_BUFFSIZE];
int len;
while(1)
{
len = sock.receive(sock.getRemoteSocket(), buff, sizeof(buff), 45);
if(len > 0)
{
if(-1 == streamSocketCommandProcess(sock, buff))
{
cout<<"\n nsStreamSocketCommandProcess send fail!:"<<endl;
// break;
}
}
}
cerr<<"\n###########@@@@@@@@@ exit @@@@@@@@############### \n";
sock.close(sock.getRemoteSocket());
return NULL;
}
void SocketTest::testFIFOBuffer()
{
Buffer<char> b(5);
b[0] = 'h';
b[1] = 'e';
b[2] = 'l';
b[3] = 'l';
b[4] = 'o';
FIFOBuffer f(5, true);
f.readable += delegate(this, &SocketTest::onReadable);
f.writable += delegate(this, &SocketTest::onWritable);
assert(0 == _notToReadable);
assert(0 == _readableToNot);
assert(0 == _notToWritable);
assert(0 == _writableToNot);
f.write(b);
assert(1 == _notToReadable);
assert(0 == _readableToNot);
assert(0 == _notToWritable);
assert(1 == _writableToNot);
EchoServer echoServer;
StreamSocket ss;
ss.connect(SocketAddress("localhost", echoServer.port()));
int n = ss.sendBytes(f);
assert (n == 5);
assert(1 == _notToReadable);
assert(1 == _readableToNot);
assert(1 == _notToWritable);
assert(1 == _writableToNot);
assert (f.isEmpty());
n = ss.receiveBytes(f);
assert (n == 5);
assert(2 == _notToReadable);
assert(1 == _readableToNot);
assert(1 == _notToWritable);
assert(2 == _writableToNot);
assert (f[0] == 'h');
assert (f[1] == 'e');
assert (f[2] == 'l');
assert (f[3] == 'l');
assert (f[4] == 'o');
f.readable -= delegate(this, &SocketTest::onReadable);
f.writable -= delegate(this, &SocketTest::onWritable);
ss.close();
}
void SocketTest::testEcho()
{
EchoServer echoServer;
StreamSocket ss;
ss.connect(SocketAddress("localhost", echoServer.port()));
int n = ss.sendBytes("hello", 5);
assert (n == 5);
char buffer[256];
n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
ss.close();
}
void regTest6()
{
tracef("reg test 6 begin: reg connect timeout.");
StreamSocket ss;
SocketAddress sa("127.0.0.1", 13333);
ss.connect(sa, Timespan(3, 0));
for(int i = 0; i < 25; i++)
{
tracef("%d seconds...", i + 1);
Thread::sleep(1000);
}
ss.close();
tracef("register test 6 finished.");
}
/** Public thread methods (clients connect here) */
void KeyValueStore::PublicThread::run()
{
Thread threads[MAX_CLIENT_THREADS];
HandleClient threadInst[MAX_CLIENT_THREADS];
const Config::ServerInformation& info = config.getServerInformation();
Config::ThreadControl& control = config.getThreadControl();
int id = 0;
char full = Protocol::SRV_FULL;
char conn = Protocol::SRV_CONN;
ServerSocket server;
SocketAddress sock(info.address, info.pubPort);
server.bind(sock, true);
server.listen(5);
printKv("Listening for clients on "<< info.address <<":"<< info.pubPort);
while(control.isLive()) {
// Simply do thread per client
StreamSocket client = server.acceptConnection();
printKv("Received client connection request - waiting for thread to free up");
// Wait five seconds
try {
freeThreads.wait(5000); // This beats busy waiting
} catch(TimeoutException& notUsed(e)) {
printKv("Server full - closing connection to client");
client.sendBytes(&full, sizeof(full));
client.close();
continue;
}
// Send success
client.sendBytes(&conn, sizeof(conn));
// tryJoin() doesn't work properly in linux, using isRunning() instead
// actively search for the next available thread
while(threads[id].isRunning()){ // Try to get an available thread
id = (id + 1) % MAX_CLIENT_THREADS;
Thread::sleep(250); // 250ms between each check
}
printKv("Serving client");
threadInst[id] = HandleClient(client, control);
threads[id].start(threadInst[id]);
}
server.close();
freeThreads.set(); // Free a thread with semaphore
}
void SocketTest::testAvailable()
{
EchoServer echoServer;
StreamSocket ss;
ss.connect(SocketAddress("localhost", echoServer.port()));
Timespan timeout(1000000);
ss.sendBytes("hello", 5);
char buffer[256];
assert (ss.poll(timeout, Socket::SELECT_READ));
int av = ss.available();
assert (av > 0 && av <= 5);
int n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
ss.close();
}
void CSimpleSocket::test(){
using namespace Poco;
using namespace Poco::Net;
StreamSocket sk;
bool connected = false;
try{
sk.connect(SocketAddress("s1.goyou.cn", 80), Timespan(6, 0));
connected = true;
}catch(Poco::Exception& exp){
std::cout << exp.displayText() << std::endl;
}
if (connected) {
try{
UInt8 buffer[2048] = "GET / HTTP/1.0\r\nUser-Agent: Mozilla/5.0\r\n\r\n";
int nSendLen = strlen((char*)buffer);
int nHasSendLen = 0;
while (nHasSendLen != nSendLen) {
int nLen = sk.sendBytes(buffer+nHasSendLen, nSendLen-nHasSendLen);
nHasSendLen += nLen;
}
int nRecvLen = 0;
do {
Socket::SocketList readList, writeList, expList;
readList.push_back(sk);
Socket::select(readList, writeList, expList, Timespan(3, 0));
nRecvLen = 0;
if (readList.size()) {
nRecvLen = sk.receiveBytes(buffer, 1024);
std::cout << nSendLen << " -- " << nRecvLen << std::endl;
buffer[nRecvLen] = 0;
std::cout << buffer << std::endl;
}
} while (nRecvLen>0);
sk.close();
}catch(Poco::Exception& exp){
std::cout <<exp.displayText() << std::endl;
}
}
}
void regTest2()
{
tracef("reg test 2 begin: reg send data.");
StreamSocket ss;
SocketAddress sa("127.0.0.1", 13333);
ss.connect(sa, Timespan(3, 0));
DynamicStruct ds;
ds["type"] = "request";
ds["action"] = "server.register";
DynamicStruct param;
param["token"] = "1234567890";
param["uuid"] = "SC000000001";
ds["param"] = param;
ss.sendBytes(ds.toString().c_str(), ds.toString().length());
tracef("reg data send: %s.", ds.toString().c_str());
ss.close();
tracef("socket closed.");
tracef("register test 2 finished.\n");
}
void SocketTest::testPoll()
{
EchoServer echoServer;
StreamSocket ss;
ss.connect(SocketAddress("localhost", echoServer.port()));
Stopwatch sw;
sw.start();
Timespan timeout(1000000);
assert (!ss.poll(timeout, Socket::SELECT_READ));
assert (sw.elapsed() >= 900000);
sw.restart();
assert (ss.poll(timeout, Socket::SELECT_WRITE));
assert (sw.elapsed() < 100000);
ss.sendBytes("hello", 5);
char buffer[256];
sw.restart();
assert (ss.poll(timeout, Socket::SELECT_READ));
assert (sw.elapsed() < 100000);
int n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
ss.close();
}
void SocketStreamTest::testLargeStreamEcho()
{
const int msgSize = 64000;
EchoServer echoServer;
StreamSocket ss;
ss.connect(SocketAddress("localhost", echoServer.port()));
SocketStream str(ss);
ss.setSendBufferSize(msgSize);
ss.setReceiveBufferSize(msgSize);
std::string payload(msgSize, 'x');
str << payload;
assert (str.good());
str.flush();
assert (str.good());
ss.shutdownSend();
assert (str.gcount() == 0);
char buffer[msgSize];
str.read(buffer, sizeof(buffer));
assert (str.good());
assert (str.gcount() == msgSize);
ss.close();
}
void regTest5()
{
tracef("reg test 5 begin:reg twice");
Context::Ptr pContext = new Context(Context::TLSV1_CLIENT_USE, "", Context::VERIFY_NONE);
SecureStreamSocket sss(pContext);
SocketAddress sa("127.0.0.1", 12222);
sss.connect(sa, Timespan(3, 0));
DynamicStruct ds;
ds["type"] = "request";
ds["action"] = "server.token";
Timestamp t;
UInt64 tms = t.epochMicroseconds();
char tms_str[32];
snprintf(tms_str, 31, "%llu", tms);
std::string key = "alpha2015";
key += tms_str;
MD5Engine md5;
md5.update(key);
const DigestEngine::Digest& digest = md5.digest();
std::string md5key = DigestEngine::digestToHex(digest);
DynamicStruct param;
param["key"] = md5key;
param["timestamp"] = tms_str;
param["dev_name"] = "lock3";
param["dev_type"] = "sc-01";
param["uuid"] = "SC00000003";
ds["param"] = param;
tracef("data send: %s.", ds.toString().c_str());
sss.sendBytes(ds.toString().c_str(), ds.toString().length());
char buf[1024] = {0, };
sss.receiveBytes(buf, 1024);
JSON::Parser parser;
Dynamic::Var var = parser.parse(buf);
JSON::Object::Ptr pObj = var.extract<JSON::Object::Ptr>();
DynamicStruct ds_recv = *pObj;
std::string token = ds_recv["param"]["token"];
DynamicStruct ds_reg;
ds_reg["type"] = "request";
ds_reg["action"] = "server.register";
DynamicStruct param_reg;
param_reg["token"] = token;
param_reg["uuid"] = "SC00000003";
ds_reg["param"] = param_reg;
StreamSocket ss;
SocketAddress sa2("127.0.0.1", 13333);
ss.connect(sa2, Timespan(3, 0));
ss.sendBytes(ds_reg.toString().c_str(), ds_reg.toString().length());
tracef("reg data send: %s.", ds_reg.toString().c_str());
memset(buf, 0, 1024);
ss.receiveBytes(buf, 1024);
tracef("receive bytes: %s.", buf);
ss.close();
Thread::sleep(2000);
StreamSocket ss2;
ss2.connect(sa2, Timespan(3, 0));
tracef("reg data send again: %s.", ds_reg.toString().c_str());
ss2.sendBytes(ds_reg.toString().c_str(), ds_reg.toString().length());
memset(buf, 0, 1024);
ss2.receiveBytes(buf, 1024);
tracef("recv data: %s.", buf);
ss2.close();
tracef("reg test 5 finished.");
}
void ServerThread::run(void* dummy) {
UInt32 tag;
UserNetworkIdentification otherID;
StreamSocket * socket;
printd(INFO, "ServerThread::run(): waiting for client...\n");
while (!shutdown) {
try {
socket = NULL;
//ExtendedBinaryMessage message;
// wait for incomming messages
if (!client.waitReadable(5.0))
continue;
// open new socket for incomming communication
socket = new StreamSocket(client.accept());
printd(INFO, "ServerThread::run(): Client connected!\n");
// update the local IP-address if not set yet
if (internalNetwork->myId.address.ipAddress == 0x7F000001)
internalNetwork->setLocalIPAddress(socket);
printd(INFO, "ServerThread::run(): calling handShake!\n");
// try to do handShake with other side
if (!handShake(socket, &otherID, tag)) {
printd(ERROR, "ServerThread::run(): handShake FAILED!\n");
socket->close();
continue;
} // if
internalNetwork->addConnectionToNetwork(socket, otherID);
// if (tag != internalNetwork->quickConnectTag)
// {
// printd(INFO, "ServerThread::run(): creating new SocketListEntry!\n");
// SocketListEntry* entry = new SocketListEntry();
// entry->socketTCP = socket;
// entry->id = otherID;
// entry->nextMsg = NULL;
// entry->prioritizedMsg = NULL;
//
// internalNetwork->socketListLock->aquire();
// internalNetwork->socketList.push_back(entry);
// internalNetwork->socketListLock->release();
// } // if
} catch (SocketException &e) {
printd(ERROR, "ServerThread::run(): network error: %s\n", e.what());
sleep(1);
}
}
client.close();
#if OSG_MAJOR_VERSION >= 2
// Enter Barrier
BarrierRefPtr cleanupBarrier = OSG::dynamic_pointer_cast<OSG::Barrier> (ThreadManager::the()->getBarrier(
"cleanupBarrier",false));
#else //OpenSG1:
// Enter Barrier
Barrier* cleanupBarrier = dynamic_cast<Barrier*> (ThreadManager::the()->getBarrier(
"cleanupBarrier"));
#endif
printd(INFO, "ServerThread::run(): entering cleanupBarrier with counter 3!\n");
cleanupBarrier->enter(3);
printd(INFO, "ServerThread::run(): goodby!\n");
}
void LocalSocketTest::testSocketsPerformance()
{
Timestamp::TimeDiff local = 0, net = 0;
std::size_t initBufSize = 1;
std::size_t initReps = 1;
bool noDelay[2] = { true, false };
std::cout << std::endl << "OS Name: " << Environment::osName() << std::endl;
std::cout << "OS Version: " << Environment::osVersion() << std::endl;
std::cout << "OS Architecture: " << Environment::osArchitecture() << std::endl;
for (int d = 0; d < 2; ++d)
{
double locData = 0.0, locTime = 0.0, netData = 0.0, netTime = 0.0;
std::ostringstream os;
os << Environment::osName() << '-'
<< Environment::osVersion() << '-'
<< Environment::osArchitecture() << "-TCP";
if (noDelay[d]) os << "-nodelay";
os << ".csv";
File f(os.str());
if (f.exists()) f.remove();
FileOutputStream fos(os.str());
for (std::size_t repetitions = initReps;
repetitions <= 100000;
repetitions *= 10)
{
for (std::size_t bufSize = initBufSize; bufSize < 20000; bufSize *= 2)
{
char* pBuf = new char[bufSize];
{
SocketAddress sas("/tmp/poco.server.tcp.sock");
EchoServer echoServer(sas, bufSize);
SocketAddress sac("/tmp/poco.client.tcp.sock");
StreamSocket ss(sas, &sac);
int recv = 0, sent = 0;
Stopwatch sw; int i = 0;
for (; i < repetitions; ++i)
{
sent = 0; recv = 0; local = 0;
do
{
int s;
sw.restart();
s = ss.sendBytes(pBuf + sent, bufSize - sent);
sw.stop();
local += sw.elapsed();
sent += s;
} while (sent < bufSize);
do
{
int r;
sw.restart();
r = ss.receiveBytes(pBuf + recv, bufSize - recv);
sw.stop();
local += sw.elapsed();
recv += r;
} while (recv < bufSize);
locData += sent;
locData += recv;
locTime += local;
poco_assert (sent == bufSize && recv == bufSize);
}
std::cout << "Local TCP socket, " << i << " repetitions, " << bufSize << " bytes, "
<< local << " [us]." << std::endl;
ss.close();
}
{
SocketAddress sa("localhost", 12345);
EchoServer echoServer(sa, bufSize);
StreamSocket ss;
ss.connect(SocketAddress(sa.host(), echoServer.port()));
if (noDelay[d]) ss.setNoDelay(true);
int recv = 0, sent = 0;
Stopwatch sw; int i = 0;
for (; i < repetitions; ++i)
{
sent = 0; recv = 0; net = 0;
do
{
int s;
sw.restart();
s = ss.sendBytes(pBuf + sent, bufSize - sent);
sw.stop();
net += sw.elapsed();
sent += s;
} while (sent < bufSize);
do
{
int r;
sw.restart();
r = ss.receiveBytes(pBuf + recv, bufSize - recv);
sw.stop();
net += sw.elapsed();
recv += r;
} while (recv < bufSize);
netData += sent;
netData += recv;
netTime += net;
poco_assert (sent == bufSize && recv == bufSize);
}
std::cout << "Network TCP socket, " << i << " repetitions, " << bufSize << " bytes, "
<< net << " [us]." << std::endl;
fos << i << ',' << bufSize << ',';
ss.close();
}
delete pBuf;
double ratio = ((double) net) / ((double) local);
double diff = ((double) net) - ((double) local);
std::cout << "Ratio: " << ratio << "(" << diff / 1000.0 << "[us/msg]" << std::endl;
fos << ratio << std::endl;
}
}
poco_assert (locData == netData);
double locDTR = ((locData / (locTime / Timestamp::resolution())) * 8) / 1000000;
double netDTR = ((netData / (netTime / Timestamp::resolution())) * 8) / 1000000;
std::cout << (d ? "NO DELAY" : "DELAY") << std::endl
<< "=================================" << std::endl
<< "Local DTR: " << ((locData / (locTime / Timestamp::resolution())) * 8) / 1000000 << " [Mbit/s]" << std::endl
<< "Network DTR: " << ((netData / (netTime / Timestamp::resolution())) * 8) / 1000000 << " [Mbit/s]" << std::endl
<< "Local sockets speedup: " << ((locDTR / netDTR) * 100) - 100 << '%' << std::endl
<< "=================================" << std::endl;
fos << "=================================" << std::endl
<< "Local DTR: " << ((locData / (locTime / Timestamp::resolution())) * 8) / 1000000 << " [Mbit/s]" << std::endl
<< "Network DTR: " << ((netData / (netTime / Timestamp::resolution())) * 8) / 1000000 << " [Mbit/s]" << std::endl
<< "Local sockets speedup: " << ((locDTR / netDTR) * 100) - 100 << '%' << std::endl
<< "=================================" << std::endl;
fos.close();
}
}
