TAO/tests/Oneway_Send_Timeouts/main.cpp

   1 #include "Client_Task.h"
   2 #include "Server_Task.h"
   3
   4 #include "ace/High_Res_Timer.h"
   5 #include "ace/Log_Msg.h"
   6 #include "ace/OS_NS_string.h"
   7 #include "ace/OS_NS_strings.h"
   8
   9 #include <memory>
  10
  11 class MyMain
  12 {
  13 public:
  14   MyMain (int argc, ACE_TCHAR* argv[]);
  15   ~MyMain ();
  16
  17   void run ();
  18
  19 private:
  20   void print_usage ();
  21   bool init_server (const ACE_TCHAR* args);
  22   bool init_client (const ACE_TCHAR* args);
  23
  24   std::unique_ptr<Server_Task> server_task_;
  25   std::unique_ptr<Client_Task> client_task_;
  26
  27   bool s_init_;
  28   bool shutdown_;
  29 };
  30
  31 void MyMain::print_usage ()
  32 {}
  33
  34 bool MyMain::init_server (const ACE_TCHAR* args)
  35 {
  36   std::string my_args (ACE_TEXT_ALWAYS_CHAR (args));
  37   // main thread and extra thread for backdoor operations
  38   int thread_pool = 2;
  39
  40   server_task_ = std::make_unique<Server_Task> (my_args);
  41
  42   ACE_ASSERT (server_task_);
  43
  44   server_task_->activate (THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, thread_pool);
  45
  46   int duration = 4; // wait 3 seconds for initialization
  47   ACE_Time_Value current = ACE_High_Res_Timer::gettimeofday_hr ();
  48   ACE_Time_Value timeout = current + ACE_Time_Value (duration);
  49
  50   while (current < timeout)
  51   {
  52     if (server_task_->ready ())
  53     {
  54       break;
  55     }
  56     ACE_Time_Value sleep_time;
  57     sleep_time.msec (10);
  58     ACE_OS::sleep (sleep_time);
  59     current += sleep_time;
  60   }
  61
  62   if (!server_task_->ready ())
  63   {
  64     server_task_->force_shutdown ();
  65     server_task_->wait ();
  66     server_task_.reset ();
  67     return false;
  68   }
  69
  70   return true;
  71 }
  72
  73 bool MyMain::init_client (const ACE_TCHAR* args)
  74 {
  75   std::string my_args (ACE_TEXT_ALWAYS_CHAR (args));
  76   int thread_pool = 1;
  77
  78   client_task_ = std::make_unique<Client_Task> (my_args);
  79
  80   ACE_ASSERT (client_task_);
  81
  82   client_task_->activate (THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, thread_pool);
  83
  84   return true;
  85 }
  86
  87 MyMain::MyMain (int argc, ACE_TCHAR* argv[])
  88   : s_init_ (false)
  89   , shutdown_ (false)
  90 {
  91   argc--;
  92   for (int p = 1; p <= argc; p++)
  93   {
  94     if (ACE_OS::strcmp (argv[p], ACE_TEXT ("-?")) == 0)
  95     {
  96       print_usage ();
  97       return;
  98     }
  99
 100     if (ACE_OS::strcasecmp (argv[p], ACE_TEXT ("-s")) == 0)
 101     {
 102       const ACE_TCHAR* s_args = (((p + 1) <= argc) ? argv[p + 1] : 0);
 103       s_init_ = this->init_server (s_args);
 104       p++;
 105     }
 106     else if (ACE_OS::strcasecmp (argv[p], ACE_TEXT ("-c")) == 0)
 107     {
 108       const ACE_TCHAR* s_args = (((p + 1) <= argc) ? argv[p + 1] : 0);
 109       if (s_init_)
 110       {
 111         this->init_client (s_args);
 112       }
 113       p++;
 114     }
 115   }
 116 }
 117
 118 void MyMain::run ()
 119 {
 120   if (server_task_)
 121   {
 122     server_task_->wait ();
 123   }
 124
 125   if (client_task_)
 126   {
 127     client_task_->wait ();
 128   }
 129
 130   shutdown_ = true;
 131 }
 132
 133 MyMain::~MyMain ()
 134 {
 135   if (!shutdown_)
 136   {
 137     this->run ();
 138   }
 139 }
 140
 141 int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
 142 {
 143   MyMain my_main (argc, argv);
 144
 145   my_main.run ();
 146
 147   return 0;
 148 }