Scheduler/Scheduler.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 // Unit tests
  24
  25 //#include "scheduler.test.hh"
  26 //#include "scheduler.test.ih"
  27
  28 // Custom includes
  29 #include <sys/types.h>
  30 #include <signal.h>
  31 #include <sys/wait.h>
  32 #include <unistd.h>
  33 #include <sys/socket.h>
  34 #include <sys/un.h>
  35 #include <errno.h>
  36 #include <string.h>
  37 #include <iostream>
  38 #include <boost/bind.hpp>
  39
  40 #include "Scheduler.hh"
  41
  42 #include "../Utils/auto_unit_test.hh"
  43 #include <boost/test/test_tools.hpp>
  44
  45 #define prefix_
  46 ///////////////////////////////cc.p////////////////////////////////////////
  47
  48 namespace {
  49
  50     char const * SOCK_PATH = "/tmp/sched_test.sock";
  51
  52     void error(char const * fn, char const * proc="")
  53     {
  54         std::cerr << "\n" << proc << fn << ": " << strerror(errno) << std::endl;
  55     }
  56
  57     void fail(char const * fn)
  58     {
  59         error(fn,"server: ");
  60         _exit(1);
  61     }
  62
  63     void server()
  64     {
  65         int sock = socket(PF_UNIX,SOCK_STREAM,0);
  66         if (sock<0) fail("socket");
  67         struct sockaddr_un sun;
  68         memset(&sun,0,sizeof(sun));
  69         sun.sun_family = AF_UNIX;
  70         strcpy(sun.sun_path,SOCK_PATH);
  71         if (bind(sock,(struct sockaddr*)&sun,sizeof(sun))<0) fail("bind");
  72         if (listen(sock,1)<0) fail("listen");
  73         int conn = accept(sock,0,0);
  74         if (conn < 0) fail("accept");
  75
  76         ///////////////////////////////////////////////////////////////////////////
  77
  78         if (write(conn,"READ",4)<0) fail("write");
  79         char buffer[1024];
  80         int size =  read(conn,buffer,1024);
  81         if (size<0) fail("read");
  82         if (size == 5) {
  83             buffer[5] = 0;
  84             if (strcmp(buffer,"WRITE")==0) {
  85                 if (write(conn,"OK",2)<0) fail("write");
  86             } else
  87                 if (write(conn,"FAIL",4)<0) fail("write");
  88         } else
  89             if (write(conn,"FAIL",4)<0) fail("write");
  90
  91         ///////////////////////////////////////////////////////////////////////////
  92
  93         close(conn);
  94         close(sock);
  95     }
  96
  97     int start_server()
  98     {
  99         unlink(SOCK_PATH);
 100         int pid = fork();
 101         if (pid == 0) {
 102             signal(SIGCHLD, SIG_IGN);
 103             server();
 104             _exit(0);
 105         }
 106         if (pid < 0) {
 107             error("fork");
 108             return 0;
 109         }
 110         signal(SIGCHLD, SIG_DFL);
 111
 112         sleep(1); // Wait for the server socket to be opened
 113         return pid;
 114     }
 115
 116     bool stop_server(int pid)
 117     {
 118         sleep(1); // Wait for the server to terminate
 119         if (kill(pid,SIGTERM)<0) {
 120             error("kill");
 121             return false;
 122         }
 123         int status = 0;
 124         if (waitpid(pid,&status,0)<0) {
 125             error("waitpid");
 126             return false;
 127         }
 128         unlink(SOCK_PATH);
 129         if (WIFSIGNALED(status)) {
 130             std::cerr << "\nserver terminated with signal " << WTERMSIG(status) << std::endl;
 131             return false;
 132         }
 133         if (WEXITSTATUS(status)!=0) {
 134             std::cerr << "\nserver terminated with exit status " << WEXITSTATUS(status) << std::endl;
 135             return false;
 136         }
 137         return true;
 138     }
 139
 140     char buffer[1024];
 141     int size;
 142     int event;
 143
 144     void callback(int fd, int ev)
 145     {
 146         event = ev;
 147         switch (event & senf::scheduler::FdEvent::EV_ALL) {
 148         case senf::scheduler::FdEvent::EV_READ:
 149             size = recv(fd,buffer,1024,0);
 150             break;
 151         case senf::scheduler::FdEvent::EV_PRIO:
 152             size = recv(fd,buffer,1024,MSG_OOB);
 153             break;
 154         case senf::scheduler::FdEvent::EV_WRITE:
 155             size = write(fd,buffer,size);
 156             break;
 157         }
 158         senf::scheduler::terminate();
 159     }
 160
 161     bool timeoutCalled = false;
 162     void timeout()
 163     {
 164         timeoutCalled = true;
 165         senf::scheduler::terminate();
 166     }
 167
 168     struct HandleWrapper
 169     {
 170         HandleWrapper(int fd,std::string const & tag) : fd_(fd), tag_(tag) {}
 171         int fd_;
 172         std::string tag_;
 173     };
 174
 175     int retrieve_filehandle(HandleWrapper const & handle)
 176     {
 177         return handle.fd_;
 178     }
 179
 180     void handleCallback(HandleWrapper const & handle, int event)
 181     {
 182         if (handle.tag_ != "TheTag")
 183             return;
 184         callback(handle.fd_,event);
 185     }
 186
 187     bool is_close(senf::ClockService::clock_type a, senf::ClockService::clock_type b)
 188     {
 189         return (a<b ? b-a : a-b) < senf::ClockService::milliseconds(100);
 190     }
 191
 192     senf::ClockService::clock_type sigtime (0);
 193
 194     void sigusr(siginfo_t const &)
 195     {
 196         sigtime = senf::ClockService::now();
 197         senf::scheduler::terminate();
 198     }
 199
 200     void delay(unsigned long milliseconds)
 201     {
 202         struct timespec ts;
 203         ts.tv_sec = milliseconds / 1000;
 204         ts.tv_nsec = (milliseconds % 1000) * 1000000;
 205         while (nanosleep(&ts,&ts) < 0 && errno == EINTR) ;
 206     }
 207
 208     void blockingHandler()
 209     {
 210         delay(2200);
 211         senf::scheduler::terminate();
 212     }
 213
 214     unsigned eventCount (0);
 215
 216     void eventeventhandler()
 217     {
 218         ++ eventCount;
 219     }
 220 }
 221
 222 void schedulerTest()
 223 {
 224     int pid = start_server();
 225     BOOST_REQUIRE (pid);
 226
 227     int sock = socket(PF_UNIX,SOCK_STREAM,0);
 228     if (sock<0) {
 229         error("socket");
 230         BOOST_FAIL("socket");
 231     }
 232     struct sockaddr_un sun;
 233     memset(&sun,0,sizeof(sun));
 234     sun.sun_family = AF_UNIX;
 235     strcpy(sun.sun_path,SOCK_PATH);
 236
 237     if (connect(sock,(struct sockaddr*)&sun,sizeof(sun))<0) {
 238         error("connect");
 239         BOOST_FAIL("connect");
 240     }
 241
 242     ///////////////////////////////////////////////////////////////////////////
 243
 244     senf::scheduler::EventHook evev ("eventCounter", eventeventhandler, true,
 245                                       senf::scheduler::EventHook::PRE);
 246
 247     {
 248         senf::scheduler::FdEvent fde1 ("testFdEvent", boost::bind(&callback, sock, _1),
 249                                       sock, senf::scheduler::FdEvent::EV_READ);
 250         event = senf::scheduler::FdEvent::EV_NONE;
 251         SENF_CHECK_NO_THROW( senf::scheduler::process() );
 252         BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_READ );
 253         BOOST_REQUIRE_EQUAL( size, 4 );
 254         buffer[size]=0;
 255         BOOST_CHECK_EQUAL( buffer, "READ" );
 256
 257         HandleWrapper handle(sock,"TheTag");
 258         senf::scheduler::FdEvent fde2 ("testFdEvent", boost::bind(&handleCallback,handle,_1),
 259                                       handle, senf::scheduler::FdEvent::EV_WRITE);
 260         strcpy(buffer,"WRITE");
 261         size=5;
 262         event = senf::scheduler::FdEvent::EV_NONE;
 263         SENF_CHECK_NO_THROW( senf::scheduler::process() );
 264         BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_WRITE );
 265
 266         SENF_CHECK_NO_THROW( fde2.disable() );
 267         event = senf::scheduler::FdEvent::EV_NONE;
 268         sleep(1);
 269         SENF_CHECK_NO_THROW( senf::scheduler::process() );
 270         BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_READ|senf::scheduler::FdEvent::EV_HUP );
 271         BOOST_REQUIRE_EQUAL( size, 2 );
 272         buffer[size]=0;
 273         BOOST_CHECK_EQUAL( buffer, "OK" );
 274     }
 275
 276     {
 277         senf::scheduler::TimerEvent timer1 ("testTimer1", &timeout,
 278                                             senf::ClockService::now()+senf::ClockService::milliseconds(200));
 279         senf::scheduler::TimerEvent timer2 ("testTimer2", &timeout,
 280                                             senf::ClockService::now()+senf::ClockService::milliseconds(400));
 281
 282         event = senf::scheduler::FdEvent::EV_NONE;
 283         senf::ClockService::clock_type t (senf::ClockService::now());
 284         SENF_CHECK_NO_THROW( senf::scheduler::process() );
 285         BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()-t) (senf::ClockService::milliseconds(200)) );
 286         BOOST_CHECK( timeoutCalled );
 287         BOOST_CHECK( ! timer1.enabled() );
 288         BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_NONE );
 289         BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()) (senf::scheduler::eventTime()) );
 290         timeoutCalled = false;
 291         SENF_CHECK_NO_THROW( senf::scheduler::process() );
 292         BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()-t) (senf::ClockService::milliseconds(400)) );
 293         BOOST_CHECK( timeoutCalled );
 294         BOOST_CHECK_EQUAL( event, senf::scheduler::FdEvent::EV_NONE );
 295         BOOST_CHECK( ! timer2.enabled() );
 296
 297         BOOST_MESSAGE( "A 'Scheduler task hanging' error is expected to be signaled here." );
 298         SENF_CHECK_NO_THROW( timer1.action(&blockingHandler) );
 299         SENF_CHECK_NO_THROW( timer1.timeout(senf::ClockService::now()) );
 300         SENF_CHECK_NO_THROW( senf::scheduler::process() );
 301         BOOST_CHECK_EQUAL( senf::scheduler::hangCount(), 1u );
 302     }
 303
 304     {
 305         senf::scheduler::TimerEvent timer ("testWatchdog", &timeout,
 306                                            senf::ClockService::now()+senf::ClockService::milliseconds(400));
 307         senf::scheduler::SignalEvent sig (SIGUSR1, &sigusr);
 308
 309         senf::ClockService::clock_type t = senf::ClockService::now();
 310         ::kill(::getpid(), SIGUSR1);
 311         delay(200);
 312         SENF_CHECK_NO_THROW( senf::scheduler::process() );
 313         BOOST_CHECK_PREDICATE( is_close, (senf::ClockService::now()) (t+senf::ClockService::milliseconds(200)) );
 314         BOOST_CHECK_PREDICATE( is_close, (sigtime) (t+senf::ClockService::milliseconds(200)) );
 315         SENF_CHECK_NO_THROW( senf::scheduler::process() );
 316     }
 317
 318     BOOST_CHECK( eventCount >= 8u );
 319
 320
 321     ///////////////////////////////////////////////////////////////////////////
 322
 323     close(sock);
 324
 325     BOOST_CHECK (stop_server(pid));
 326 }
 327
 328 BOOST_AUTO_UNIT_TEST(testSchedulerPollTimers)
 329 {
 330     BOOST_CHECK( ! senf::scheduler::usingHiresTimers() );
 331     schedulerTest();
 332 }
 333
 334 BOOST_AUTO_UNIT_TEST(testSchedulerHiresTimers)
 335 {
 336     if (senf::scheduler::haveScalableHiresTimers())
 337         BOOST_MESSAGE( "Using timerfd() hires timers" );
 338     else
 339         BOOST_MESSAGE( "Using POSIX hires timers");
 340     senf::scheduler::hiresTimers();
 341     BOOST_CHECK( senf::scheduler::usingHiresTimers() );
 342     schedulerTest();
 343     senf::scheduler::loresTimers();
 344     BOOST_CHECK( ! senf::scheduler::usingHiresTimers() );
 345 }
 346
 347 BOOST_AUTO_UNIT_TEST(testSchedulerPOSIXTimers)
 348 {
 349     if (senf::scheduler::haveScalableHiresTimers()) {
 350         senf::scheduler::detail::TimerDispatcher::instance().timerSource(
 351             std::auto_ptr<senf::scheduler::detail::TimerSource>(
 352                 new senf::scheduler::detail::POSIXTimerSource()));
 353         schedulerTest();
 354         senf::scheduler::loresTimers();
 355     }
 356 }
 357
 358 namespace {
 359
 360     void sigme()
 361     {
 362         senf::scheduler::BlockSignals signalBlocker;
 363         signalBlocker.block();
 364         signalBlocker.unblock();
 365         BOOST_CHECK( ! signalBlocker.blocked() );
 366         signalBlocker.unblock();
 367         signalBlocker.block();
 368         BOOST_CHECK( signalBlocker.blocked() );
 369         ::kill(::getpid(), SIGUSR1);
 370         delay(200);
 371     }
 372
 373 }
 374
 375 BOOST_AUTO_UNIT_TEST(blockSignals)
 376 {
 377     senf::scheduler::TimerEvent signaler ("sigme", &sigme, senf::ClockService::now());
 378     senf::scheduler::TimerEvent timer (
 379         "testWatchdog", &timeout, senf::ClockService::now()+senf::ClockService::milliseconds(400));
 380     senf::scheduler::SignalEvent sig (SIGUSR1, &sigusr);
 381
 382     senf::ClockService::clock_type t = senf::ClockService::now();
 383     SENF_CHECK_NO_THROW( senf::scheduler::process() );
 384
 385     BOOST_CHECK_PREDICATE( is_close,
 386                            (senf::ClockService::now())
 387                            (t+senf::ClockService::milliseconds(200)) );
 388     BOOST_CHECK_PREDICATE( is_close, (sigtime) (t+senf::ClockService::milliseconds(200)) );
 389
 390     SENF_CHECK_NO_THROW( senf::scheduler::process() );
 391 }
 392
 393 ///////////////////////////////cc.e////////////////////////////////////////
 394 #undef prefix_
 395
 396 \f
 397 // Local Variables:
 398 // mode: c++
 399 // fill-column: 100
 400 // c-file-style: "senf"
 401 // indent-tabs-mode: nil
 402 // ispell-local-dictionary: "american"
 403 // compile-command: "scons -u test"
 404 // comment-column: 40
 405 // End: