TAO/tests/Hang_Shutdown/client.cpp

   1 #include "TestC.h"
   2 #include "ace/Get_Opt.h"
   3 #include "ace/Task.h"
   4 #include "ace/Profile_Timer.h"
   5 #include "ace/OS_NS_unistd.h"
   6
   7 namespace Test
   8 {
   9   const ACE_TCHAR *ior = ACE_TEXT("file://server.ior");
  10
  11   ACE_Profile_Timer profile_timer;
  12   bool blocked = false;
  13
  14   bool
  15   parse_args (int argc, ACE_TCHAR *argv[])
  16   {
  17     ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("b:k:"));
  18     int c;
  19
  20     while ((c = get_opts ()) != -1)
  21       switch (c)
  22         {
  23         case 'b':
  24           {
  25             int tmp =
  26               ACE_OS::atoi (get_opts.opt_arg ());
  27
  28             if (tmp)
  29               blocked = true;
  30             else
  31               blocked = false;
  32           }
  33           break;
  34         case 'k':
  35           {
  36             ior = get_opts.opt_arg ();
  37           }
  38           break;
  39         case '?':
  40         default:
  41           ACE_ERROR_RETURN ((LM_ERROR,
  42                              "usage:  %s "
  43                              "-k <ior> "
  44                              "\n",
  45                              argv [0]),
  46                             false);
  47         }
  48
  49     // Indicates successful parsing of the command line
  50     return true;
  51   }
  52
  53   class Client_Task : public ACE_Task_Base
  54   {
  55   public:
  56     Client_Task (Hang_ptr h)
  57       : h_ (Hang::_duplicate (h))
  58     {}
  59
  60     virtual int svc (void)
  61     {
  62
  63       try
  64         {
  65           this->h_->send_stuff ("Testing",
  66                                 false);
  67
  68           this->h_->send_stuff ("Testing",
  69                                 false);
  70
  71           this->h_->send_stuff ("Testing",
  72                                 true);
  73         }
  74       catch (const CORBA::COMM_FAILURE& f)
  75         {
  76           ACE_UNUSED_ARG (f);
  77           ACE_DEBUG ((LM_DEBUG,
  78                       "(%P|%t) Caught COMM_FAILURE Exception\n"));
  79
  80           ACE_DEBUG ((LM_DEBUG,
  81                       "(%P|%t) This is expected\n"));
  82
  83           return 0;
  84         }
  85       catch (const CORBA::Exception& ex)
  86         {
  87           ex._tao_print_exception ("Caught CORBA Exception\n");
  88
  89           ACE_ERROR ((LM_ERROR,
  90                       "(%P|%t) Error in test\n"));
  91
  92           return -1;
  93         }
  94       catch (...)
  95         {
  96           ACE_DEBUG ((LM_DEBUG,
  97                       "(%P|%t) Caught a C++ exception\n"));
  98           ACE_ERROR ((LM_ERROR,
  99                       "(%P|%t) Error in test\n"));
 100
 101           return -1;
 102         }
 103
 104       return 0;
 105     }
 106
 107   private:
 108     Hang_var h_;
 109   };
 110
 111   class Shutdown_Task : public ACE_Task_Base
 112   {
 113   public:
 114     Shutdown_Task (CORBA::ORB_ptr o)
 115       : o_ (CORBA::ORB::_duplicate (o))
 116     {}
 117
 118     virtual int svc (void)
 119     {
 120
 121       try
 122         {
 123           ACE_DEBUG ((LM_DEBUG,
 124                       "(%P|%t) Calling shutdown\n"));
 125
 126           // Just wait for the main thread to start sending out
 127           // messages
 128           ACE_OS::sleep (4);
 129
 130           // Start the timer
 131           profile_timer.start ();
 132
 133           this->o_->shutdown (blocked);
 134
 135           // Stop the timer
 136           profile_timer.stop ();
 137
 138           // Get the elampsed time
 139           ACE_Profile_Timer::ACE_Elapsed_Time el;
 140           profile_timer.elapsed_time (el);
 141
 142           // The elapsed time is in secs
 143           if (el.real_time > 1)
 144             {
 145               ACE_ERROR ((LM_ERROR,
 146                           "(%P|%t) ERROR: Too long to shutdown\n"));
 147
 148               return 0;
 149             }
 150         }
 151       catch (...)
 152         {
 153           ACE_DEBUG ((LM_DEBUG,
 154                       "(%P|%t) Caught exception during shutdown\n"));
 155
 156           ACE_ERROR ((LM_ERROR,
 157                       "(%P|%t) Error in test\n"));
 158           return -1;
 159         }
 160
 161       ACE_DEBUG ((LM_DEBUG,
 162                   "(%P|%t) Returning from shutdown\n"));
 163       return 0;
 164     }
 165   private:
 166     CORBA::ORB_var o_;
 167   };
 168
 169   static int
 170   try_main (int argc, ACE_TCHAR *argv[])
 171   {
 172
 173     try
 174       {
 175         CORBA::ORB_var orb =
 176           CORBA::ORB_init (argc, argv);
 177
 178         if (parse_args (argc, argv) == false)
 179           return -1;
 180
 181         CORBA::Object_var tmp =
 182           orb->string_to_object (ior);
 183
 184         Hang_var test =
 185           Hang::_narrow (tmp.in ());
 186
 187         if (CORBA::is_nil (test.in ()))
 188           {
 189             ACE_ERROR_RETURN ((LM_DEBUG,
 190                                "Nil test reference <%s>\n",
 191                                ior),
 192                               1);
 193           }
 194
 195         Client_Task ct (test.in ());
 196
 197         if (ct.activate (THR_NEW_LWP | THR_JOINABLE, 1) != 0)
 198           ACE_ERROR_RETURN ((LM_ERROR,
 199                              "Cannot activate client threads\n"),
 200                             1);
 201
 202         ACE_DEBUG ((LM_DEBUG,
 203                     "(%P|%t) Activating shutdown thread\n"));
 204
 205         Shutdown_Task st (orb.in ());
 206
 207         if (st.activate (THR_NEW_LWP | THR_JOINABLE, 1) != 0)
 208           ACE_ERROR_RETURN ((LM_ERROR,
 209                              "Cannot activate shutdown threads\n"),
 210                             1);
 211
 212         ACE_Thread_Manager::instance ()->wait ();
 213
 214         orb->destroy ();
 215
 216       }
 217     catch (const CORBA::Exception& ex)
 218       {
 219         ex._tao_print_exception ("CORBA Exception caught\n");
 220         ACE_ERROR ((LM_ERROR,
 221                     "(%P|%t) Eror in test\n"));
 222         return -1;
 223       }
 224     catch (...)
 225       {
 226         ACE_DEBUG ((LM_DEBUG,
 227                     "(%P|%t) Error in test\n"));
 228         return -1;
 229       }
 230
 231     return 0;
 232   }
 233 }
 234
 235 int
 236 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 237 {
 238   return Test::try_main (argc, argv);
 239 }