X-Git-Url: http://developer.intra2net.com/git/?p=libt2n;a=blobdiff_plain;f=test%2Ftimeout.cpp;h=509d88d73accd2657a1d13d0d000b31ec1638a09;hp=0493d627a38bdbe6a01ce44bac90ce879586ece3;hb=19facd8558fe2e32ce843860b40631ebe03ff3cf;hpb=45a2ebc9695c4d7be6548b7e0f800d117ae56a0b diff --git a/test/timeout.cpp b/test/timeout.cpp index 0493d62..509d88d 100644 --- a/test/timeout.cpp +++ b/test/timeout.cpp @@ -1,9 +1,24 @@ -/*************************************************************************** - * Copyright (C) 2004 by Intra2net AG * - * info@intra2net.com * - * * - ***************************************************************************/ +/* +Copyright (C) 2004 by Intra2net AG +The software in this package is distributed under the GNU General +Public License version 2 (with a special exception described below). + +A copy of GNU General Public License (GPL) is included in this distribution, +in the file COPYING.GPL. + +As a special exception, if other files instantiate templates or use macros +or inline functions from this file, or you compile this file and link it +with other works to produce a work based on this file, this file +does not by itself cause the resulting work to be covered +by the GNU General Public License. + +However the source code for this file must still be made available +in accordance with section (3) of the GNU General Public License. + +This exception does not invalidate any other reasons why a work based +on this file might be covered by the GNU General Public License. +*/ #include #include #include @@ -120,17 +135,32 @@ class real_write_connection: public socket_server_connection { socket_write(data); } }; +// this is an evil hack to get access to real_write, don't ever do this in an app!!! +class real_write_client_connection: public socket_client_connection +{ + public: + void real_write(const std::string& data) + { socket_write(data); } +}; + class test_timeout : public TestFixture { CPPUNIT_TEST_SUITE(test_timeout); + CPPUNIT_TEST(ConnectTimeout); CPPUNIT_TEST(HelloTimeoutNothing); CPPUNIT_TEST(HelloTimeoutSlowData); CPPUNIT_TEST(CommandTimeout); CPPUNIT_TEST(CommandSlowResponse); + CPPUNIT_TEST(DisconnectOnWrite); + CPPUNIT_TEST(WriteTwice); + CPPUNIT_TEST(DisconnectOnRead); + CPPUNIT_TEST(BreakAccept); CPPUNIT_TEST_SUITE_END(); + pid_t child_pid; + public: typedef uint32_t packet_size_indicator; @@ -139,7 +169,11 @@ class test_timeout : public TestFixture { } void tearDown() - { } + { + // make sure the server-child is dead before the next test runs + kill(child_pid,SIGKILL); + sleep(1); + } void send_hello(string hello_string, socket_server* ss, unsigned int conn_id) { @@ -164,11 +198,9 @@ class test_timeout : public TestFixture } } - void HelloTimeoutNothing() + void ConnectTimeout() { - pid_t pid; - - switch(pid=fork()) + switch(child_pid=fork()) { case -1: { @@ -178,11 +210,14 @@ class test_timeout : public TestFixture case 0: // child { - socket_server ss("./socket"); + try + { + socket_server ss("./socket"); + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } - // max 10 sec - for (int i=0; i < 10; i++) - ss.fill_buffer(1000000); // don't call atexit and stuff _exit(0); } @@ -194,18 +229,61 @@ class test_timeout : public TestFixture // wait till server is up sleep(1); - socket_client_connection sc("./socket"); string errormsg; + socket_client_connection sc("./socket"); + + CPPUNIT_ASSERT_EQUAL_MESSAGE("connection not closed",true,sc.connection::is_closed()); + + CPPUNIT_ASSERT_EQUAL_MESSAGE("wrong errormessage",string("no more retries left after connect error"),sc.get_last_error_msg()); + } + } + } + + void HelloTimeoutNothing() + { + switch(child_pid=fork()) + { + case -1: + { + CPPUNIT_FAIL("fork error"); + break; + } + case 0: + // child + { try { - command_client cc(sc,1000000,1000000); + socket_server ss("./socket"); + + // max 10 sec + for (int i=0; i < 10; i++) + ss.fill_buffer(1000000); + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; } - catch(t2n_transfer_error &e) - { errormsg=e.what(); } - catch(...) - { throw; } + + // don't call atexit and stuff + _exit(0); + } + + default: + // parent + { + string data; + + // wait till server is up + sleep(1); + socket_client_connection sc("./socket"); + command_client cc(&sc,1000000,1000000); + + t2n_exception* ep=cc.get_constuctor_exception(); + + string errormsg; + if (ep) + errormsg=ep->what(); CPPUNIT_ASSERT_EQUAL(string("timeout exceeded"),errormsg); } @@ -214,9 +292,69 @@ class test_timeout : public TestFixture void HelloTimeoutSlowData() { - pid_t pid; + switch(child_pid=fork()) + { + case -1: + { + CPPUNIT_FAIL("fork error"); + break; + } + case 0: + // child + { + try + { + socket_server ss("./socket"); + + // create a valid packet + ostringstream hello; + hello << "T2Nv" << PROTOCOL_VERSION << ';'; + int byteordercheck=1; + hello.write((char*)&byteordercheck,sizeof(byteordercheck)); + hello << ';'; + + packet_size_indicator psize=htonl(hello.str().size()); + std::string send_data(hello.str()); + send_data.insert(0,(char*)&psize,sizeof(packet_size_indicator)); + + ss.add_callback(new_connection,bind(&test_timeout::send_slow_raw_socket, boost::ref(*this), send_data,&ss, _1)); + + // max 10 sec + for (int i=0; i < 10; i++) + ss.fill_buffer(1000000); + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } + + // don't call atexit and stuff + _exit(0); + } + + default: + // parent + { + string data; + + // wait till server is up + sleep(1); + socket_client_connection sc("./socket"); + command_client cc(&sc,1000000,1000000); + + t2n_exception* ep=cc.get_constuctor_exception(); + + string errormsg; + if (ep) + errormsg=ep->what(); + + CPPUNIT_ASSERT_EQUAL(string("timeout exceeded"),errormsg); + } + } + } - switch(pid=fork()) + void CommandTimeout() + { + switch(child_pid=fork()) { case -1: { @@ -226,24 +364,26 @@ class test_timeout : public TestFixture case 0: // child { - socket_server ss("./socket"); + try + { + socket_server ss("./socket"); - // create a valid packet - ostringstream hello; - hello << "T2Nv" << PROTOCOL_VERSION << ';'; - int byteordercheck=1; - hello.write((char*)&byteordercheck,sizeof(byteordercheck)); - hello << ';'; + ostringstream hello; + hello << "T2Nv" << PROTOCOL_VERSION << ';'; + int byteordercheck=1; + hello.write((char*)&byteordercheck,sizeof(byteordercheck)); + hello << ';'; - packet_size_indicator psize=htonl(hello.str().size()); - std::string send_data(hello.str()); - send_data.insert(0,(char*)&psize,sizeof(packet_size_indicator)); + ss.add_callback(new_connection,bind(&test_timeout::send_hello, boost::ref(*this), hello.str(),&ss, _1)); - ss.add_callback(new_connection,bind(&test_timeout::send_slow_raw_socket, boost::ref(*this), send_data,&ss, _1)); + // max 10 sec + for (int i=0; i < 10; i++) + ss.fill_buffer(1000000); + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } - // max 10 sec - for (int i=0; i < 10; i++) - ss.fill_buffer(1000000); // don't call atexit and stuff _exit(0); } @@ -257,11 +397,14 @@ class test_timeout : public TestFixture sleep(1); socket_client_connection sc("./socket"); + command_client cc(&sc,1000000,1000000); + result_container rc; + string errormsg; try { - command_client cc(sc,1000000,1000000); + cc.send_command(new testfunc2_cmd("hello"),rc); } catch(t2n_transfer_error &e) { errormsg=e.what(); } @@ -273,11 +416,9 @@ class test_timeout : public TestFixture } } - void CommandTimeout() + void CommandSlowResponse() { - pid_t pid; - - switch(pid=fork()) + switch(child_pid=fork()) { case -1: { @@ -287,19 +428,41 @@ class test_timeout : public TestFixture case 0: // child { - socket_server ss("./socket"); + try + { + socket_server ss("./socket"); - ostringstream hello; - hello << "T2Nv" << PROTOCOL_VERSION << ';'; - int byteordercheck=1; - hello.write((char*)&byteordercheck,sizeof(byteordercheck)); - hello << ';'; + ostringstream hello; + hello << "T2Nv" << PROTOCOL_VERSION << ';'; + int byteordercheck=1; + hello.write((char*)&byteordercheck,sizeof(byteordercheck)); + hello << ';'; - ss.add_callback(new_connection,bind(&test_timeout::send_hello, boost::ref(*this), hello.str(),&ss, _1)); + ss.add_callback(new_connection,bind(&test_timeout::send_hello, boost::ref(*this), hello.str(),&ss, _1)); + + // max 10 sec + for (int i=0; i < 10; i++) + { + ss.fill_buffer(1000000); + + string data; + unsigned int cid; + + if(ss.get_packet(data,cid)) + { + // create a valid packet & send + string response="abcdefghijklmnopqrstuvwxyz"; + packet_size_indicator psize=htonl(response.size()); + std::string send_data(response); + send_data.insert(0,(char*)&psize,sizeof(packet_size_indicator)); + send_slow_raw_socket(send_data,&ss,cid); + } + } + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } - // max 10 sec - for (int i=0; i < 10; i++) - ss.fill_buffer(1000000); // don't call atexit and stuff _exit(0); } @@ -313,7 +476,7 @@ class test_timeout : public TestFixture sleep(1); socket_client_connection sc("./socket"); - command_client cc(sc,1000000,1000000); + command_client cc(&sc,1000000,1000000); result_container rc; string errormsg; @@ -332,11 +495,9 @@ class test_timeout : public TestFixture } } - void CommandSlowResponse() + void DisconnectOnWrite() { - pid_t pid; - - switch(pid=fork()) + switch(child_pid=fork()) { case -1: { @@ -346,34 +507,75 @@ class test_timeout : public TestFixture case 0: // child { - socket_server ss("./socket"); + try + { + socket_server ss("./socket"); + + // bail out as soon as we get something + ss.fill_buffer(-1); + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } + + // don't call atexit and stuff + _exit(0); + } - ostringstream hello; - hello << "T2Nv" << PROTOCOL_VERSION << ';'; - int byteordercheck=1; - hello.write((char*)&byteordercheck,sizeof(byteordercheck)); - hello << ';'; + default: + // parent + { + string data; - ss.add_callback(new_connection,bind(&test_timeout::send_hello, boost::ref(*this), hello.str(),&ss, _1)); + // don't kill us on broken pipe + signal(SIGPIPE, SIG_IGN); + + // wait till server is up + sleep(1); + socket_client_connection sc("./socket"); - // max 10 sec - for (int i=0; i < 10; i++) + string errormsg; + + string huge(5000000,'x'); + + try { - ss.fill_buffer(1000000); + sc.write(huge); + } + catch(t2n_transfer_error &e) + { errormsg=e.what(); } + catch(...) + { throw; } - string data; - unsigned int cid; + CPPUNIT_ASSERT_EQUAL(string("write() returned Broken pipe"),errormsg); + } + } + } - if(ss.get_packet(data,cid)) - { - // create a valid packet & send - string response="abcdefghijklmnopqrstuvwxyz"; - packet_size_indicator psize=htonl(response.size()); - std::string send_data(response); - send_data.insert(0,(char*)&psize,sizeof(packet_size_indicator)); - send_slow_raw_socket(send_data,&ss,cid); - } + void WriteTwice() + { + switch(child_pid=fork()) + { + case -1: + { + CPPUNIT_FAIL("fork error"); + break; + } + case 0: + // child + { + try + { + socket_server ss("./socket"); + + // bail out as soon as we get something + ss.fill_buffer(-1); + ss.fill_buffer(-1); + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; } + // don't call atexit and stuff _exit(0); } @@ -383,29 +585,239 @@ class test_timeout : public TestFixture { string data; + // don't kill us on broken pipe + signal(SIGPIPE, SIG_IGN); + // wait till server is up sleep(1); socket_client_connection sc("./socket"); - command_client cc(sc,1000000,1000000); - result_container rc; - string errormsg; + sc.write("somedata"); + + sleep(1); + + // server should disconnect now try { - cc.send_command(new testfunc2_cmd("hello"),rc); + sc.write("other data"); } catch(t2n_transfer_error &e) { errormsg=e.what(); } catch(...) { throw; } - CPPUNIT_ASSERT_EQUAL(string("timeout exceeded"),errormsg); + CPPUNIT_ASSERT_EQUAL(string("write() returned Broken pipe"),errormsg); + } + } + } + + void DisconnectOnRead() + { + pid_t pid2; + + switch(child_pid=fork()) + { + case -1: + { + CPPUNIT_FAIL("fork error"); + break; + } + case 0: + // child + { + try + { + // wait till server is up + sleep(1); + + socket_client_connection sc("./socket"); + + // this is an evil hack to get access to real_write, don't ever do this in an app!!! + real_write_client_connection *rwc=(real_write_client_connection*)≻ + rwc->real_write(string(10000,'x')); + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } + + // don't call atexit and stuff + _exit(0); + } + + default: + // parent + { + // don't kill us on broken pipe + signal(SIGPIPE, SIG_IGN); + + socket_server ss("./socket"); + + time_t t0 = time(NULL); + + // max 5 sec + while (time(NULL) < t0 + 5 ) + { + ss.fill_buffer(1000000); + + string data; + ss.get_packet(data); + } + + // are we still alive and able to process data? + + switch(pid2=fork()) + { + case -1: + { + CPPUNIT_FAIL("fork error"); + break; + } + case 0: + // child + { + try + { + socket_client_connection *sc=new socket_client_connection("./socket"); + sc->write(string(10000,'x')); + // socket is closed regularly + delete sc; + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } + + // don't run regular cleanup, otherwise cppunit stuff gets called + _exit(0); + } + + default: + // parent + { + string received; + + t0 = time(NULL); + + // max 10 sec + while (time(NULL) < t0 + 10 ) + { + ss.fill_buffer(1000000); + + if (ss.get_packet(received)) + break; + } + + CPPUNIT_ASSERT_EQUAL(string(10000,'x'),received); + } + } } } + kill(pid2,SIGKILL); } + void BreakAccept() + { + pid_t pid2; + + switch(child_pid=fork()) + { + case -1: + { + CPPUNIT_FAIL("fork error"); + break; + } + case 0: + // child + { + try + { + // wait till server is really up and waiting + sleep(2); + + // connect with very tight timeout and only 1 retry + socket_client_connection sc("./socket",50,1); + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } + + // don't call atexit and stuff + _exit(0); + } + + default: + // parent + { + // don't kill us on broken pipe + signal(SIGPIPE, SIG_IGN); + + socket_server ss("./socket"); + + // server is "working" while client wants to connect + sleep(5); + + time_t t0 = time(NULL); + + // max 5 sec + while (time(NULL) < t0 + 5 ) + { + ss.fill_buffer(1000000); + + string data; + ss.get_packet(data); + } + + // are we still alive and able to process data? + + switch(pid2=fork()) + { + case -1: + { + CPPUNIT_FAIL("fork error"); + break; + } + case 0: + // child + { + try + { + socket_client_connection *sc=new socket_client_connection("./socket"); + sc->write(string(10000,'x')); + delete sc; + // socket is closed regularly + } catch(...) + { + std::cerr << "exception in child. ignoring\n"; + } + + // don't run regular cleanup, otherwise cppunit stuff gets called + _exit(0); + } + + default: + // parent + { + string received; + + t0 = time(NULL); + + // max 10 sec + while (time(NULL) < t0 + 10 ) + { + ss.fill_buffer(1000000); + + if (ss.get_packet(received)) + break; + } + + CPPUNIT_ASSERT_EQUAL(string(10000,'x'),received); + } + } + } + } + kill(pid2,SIGKILL); + } }; CPPUNIT_TEST_SUITE_REGISTRATION(test_timeout);