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 #ifdef ACE_HAS_CPP14
  41   server_task_ = std::make_unique<Server_Task> (my_args);
  42 #else
  43   server_task_.reset (new Server_Task (my_args));
  44 #endif
  45
  46   ACE_ASSERT (server_task_);
  47
  48   server_task_->activate (THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, thread_pool);
  49
  50   int duration = 4; // wait 3 seconds for initialization
  51   ACE_Time_Value current = ACE_High_Res_Timer::gettimeofday_hr ();
  52   ACE_Time_Value timeout = current + ACE_Time_Value (duration);
  53
  54   while (current < timeout)
  55   {
  56     if (server_task_->ready ())
  57     {
  58       break;
  59     }
  60     ACE_Time_Value sleep_time;
  61     sleep_time.msec (10);
  62     ACE_OS::sleep (sleep_time);
  63     current += sleep_time;
  64   }
  65
  66   if (!server_task_->ready ())
  67   {
  68     server_task_->force_shutdown ();
  69     server_task_->wait ();
  70     server_task_.reset ();
  71     return false;
  72   }
  73
  74   return true;
  75 }
  76
  77 bool MyMain::init_client (const ACE_TCHAR* args)
  78 {
  79   std::string my_args (ACE_TEXT_ALWAYS_CHAR (args));
  80   int thread_pool = 1;
  81
  82 #ifdef ACE_HAS_CPP14
  83   client_task_ = std::make_unique<Client_Task> (my_args);
  84 #else
  85   client_task_.reset (new Client_Task (my_args));
  86 #endif
  87
  88   ACE_ASSERT (client_task_);
  89
  90   client_task_->activate (THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, thread_pool);
  91
  92   return true;
  93 }
  94
  95 MyMain::MyMain (int argc, ACE_TCHAR* argv[])
  96   : s_init_ (false)
  97   , shutdown_ (false)
  98 {
  99   argc--;
 100   for (int p = 1; p <= argc; p++)
 101   {
 102     if (ACE_OS::strcmp (argv[p], ACE_TEXT ("-?")) == 0)
 103     {
 104       print_usage ();
 105       return;
 106     }
 107
 108     if (ACE_OS::strcasecmp (argv[p], ACE_TEXT ("-s")) == 0)
 109     {
 110       const ACE_TCHAR* s_args = (((p + 1) <= argc) ? argv[p + 1] : 0);
 111       s_init_ = this->init_server (s_args);
 112       p++;
 113     }
 114     else if (ACE_OS::strcasecmp (argv[p], ACE_TEXT ("-c")) == 0)
 115     {
 116       const ACE_TCHAR* s_args = (((p + 1) <= argc) ? argv[p + 1] : 0);
 117       if (s_init_)
 118       {
 119         this->init_client (s_args);
 120       }
 121       p++;
 122     }
 123   }
 124 }
 125
 126 void MyMain::run ()
 127 {
 128   if (server_task_)
 129   {
 130     server_task_->wait ();
 131   }
 132
 133   if (client_task_)
 134   {
 135     client_task_->wait ();
 136   }
 137
 138   shutdown_ = true;
 139 }
 140
 141 MyMain::~MyMain ()
 142 {
 143   if (!shutdown_)
 144   {
 145     this->run ();
 146   }
 147 }
 148
 149 int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
 150 {
 151   MyMain my_main (argc, argv);
 152
 153   my_main.run ();
 154
 155   return 0;
 156 }