TAO/orbsvcs/tests/FT_App/FT_Client.cpp

   1 #include "FT_TestReplicaC.h"
   2 #include <ace/Vector_T.h>
   3 #include <ace/SString.h>
   4 #include <ace/Get_Opt.h>
   5 // FUZZ: disable check_for_streams_include
   6 #include "ace/streams.h"
   7 #include "ace/OS_NS_unistd.h"
   8 #include "ace/OS_NS_stdio.h"
   9
  10 class FTClientMain
  11 {
  12   typedef ACE_Vector<ACE_CString> StringVec;
  13 public:
  14   ///////////////////////////
  15   // construction/destruction
  16   FTClientMain ();
  17
  18   ~FTClientMain ();
  19
  20   /////////////////
  21   // initialization
  22   int parse_args (int argc, ACE_TCHAR *argv[]);
  23
  24   ////////////
  25   // execution
  26   int run ();
  27
  28   /////////////////
  29   // implementation
  30 private:
  31   void usage (FILE* out)const;
  32   void commandUsage (FILE* out);
  33   int pass (
  34     long & counter,         // inout
  35     int & more,             // out
  36     ACE_CString & command,  // inout
  37     int retry);             // in
  38
  39   int next_replica ();
  40
  41   ////////////////////
  42   // forbidden methods
  43  private:
  44     FTClientMain (const FTClientMain & rhs);
  45     FTClientMain & operator = (const FTClientMain & rhs);
  46
  47   ////////////////
  48   // Data members
  49  private:
  50   CORBA::ORB_var orb_;
  51
  52   int argc_;
  53   ACE_TCHAR ** argv_;
  54   const ACE_TCHAR * inFileName_;
  55   FILE *inFile_;
  56   FILE *commandIn_;
  57
  58   enum Verbosity{
  59     SILENT,
  60     QUIET,
  61     NORMAL,
  62     NOISY,
  63     LOUD}
  64     verbose_;
  65
  66
  67   StringVec replica_iors_;
  68   size_t replica_pos_;
  69   const char * replica_name_;
  70   FT_TEST::TestReplica_var replica_;
  71 };
  72
  73
  74 FTClientMain::FTClientMain ()
  75   : inFile_(0)
  76   , commandIn_(stdin)
  77   , verbose_(NORMAL)
  78   , replica_pos_(0)
  79   , replica_name_("none")
  80 {
  81 }
  82
  83 FTClientMain::~FTClientMain ()
  84 {
  85   if (this->inFile_)
  86   {
  87     ACE_OS::fclose (this->inFile_);
  88     this->inFile_ = 0;
  89   }
  90 }
  91
  92 void FTClientMain::commandUsage(FILE* out)
  93 {
  94   ACE_OS::fprintf (out,
  95     "Each command must be at the beginning of a separate line.\n"
  96     "Everything after the command (and operand if any) is ignored.\n"
  97     "Valid commands are:\n"
  98     "  Access via method call:\n"
  99     "    =N    set counter to N\n"
 100     "    cN    get counter and compare to N (c stands for \"check\"\n"
 101     "    +N    increment counter by N\n"
 102     "    -N    decrement counter by N\n"
 103     "  Access as attribute:\n"
 104     "    >N    set attribute to N\n"
 105     "    <     get attribite\n"
 106     "  Try methods to be used by fault tolerant infrastructure:\n"
 107     "    !     is_alive\n"
 108     "    s     get_state\n"
 109     "    S     set_state\n"
 110     "    u     get_update\n"
 111     "    U     set_update\n"
 112     "  Simulate failure:\n"
 113     "    dN    die on condition:\n"
 114     "        d%d don't die\n"
 115     "        d%d immediately\n"
 116     "        d%d while idle\n"
 117     "      (FT_TestReplica interface)\n"
 118     "        d%d before state change\n"
 119     "        d%d after state change, before replication\n"
 120     "        d%d after replication, before reply\n"
 121     "      (Monitorable interface)\n"
 122     "        d%d during is alive\n"
 123     "        d%d is_alive returns false\n"
 124     "      (Updatable interface)\n"
 125     "        d%d during get update\n"
 126     "        d%d before set update\n"
 127     "        d%d after set update\n"
 128     "      (Checkpointable interface)\n"
 129     "        d%d during get state\n"
 130     "        d%d before set state\n"
 131     "        d%d after set state\n"
 132     " Logistics commands:\n"
 133     "   #    ignore this line (comment).\n"
 134     "   v    set verbosity:\n"
 135     "     0 don't check counter value.\n"
 136     "     1 only display counter value mismatch.\n"
 137     "     2 display counter value after every command (default).\n"
 138     "     3 display commands.\n"
 139     "     4 display method calls.\n"
 140     "   zN   sleep N seconds.\n"
 141     "   q    quit (end the client, not the replica(s).)\n"
 142     "   q1   quit (end the client, and shutdown the currently active replica.)\n"
 143     "   ?    help (this message)\n",
 144     FT_TEST::TestReplica::NOT_YET,
 145     FT_TEST::TestReplica::RIGHT_NOW,
 146     FT_TEST::TestReplica::WHILE_IDLE,
 147     FT_TEST::TestReplica::BEFORE_STATE_CHANGE,
 148     FT_TEST::TestReplica::BEFORE_REPLICATION,
 149     FT_TEST::TestReplica::BEFORE_REPLY,
 150     FT_TEST::TestReplica::DURING_IS_ALIVE,
 151     FT_TEST::TestReplica::DENY_IS_ALIVE,
 152     FT_TEST::TestReplica::DURING_GET_UPDATE,
 153     FT_TEST::TestReplica::BEFORE_SET_UPDATE,
 154     FT_TEST::TestReplica::AFTER_SET_UPDATE,
 155     FT_TEST::TestReplica::DURING_GET_STATE,
 156     FT_TEST::TestReplica::BEFORE_SET_STATE,
 157     FT_TEST::TestReplica::AFTER_SET_STATE);
 158 }
 159
 160 int
 161 FTClientMain::parse_args (int argc, ACE_TCHAR *argv[])
 162 {
 163   this->argc_ = argc;
 164   this->argv_ = argv;
 165   int result = 0;
 166
 167   // note: dfnkx are simple_util options
 168   // include them here so we can detect bad args
 169   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("c:f:"));
 170   int c;
 171
 172   while (result == 0 && (c = get_opts ()) != -1)
 173   {
 174     switch (c)
 175     {
 176       case 'c':
 177       {
 178         this->inFileName_ = get_opts.opt_arg ();
 179         this->inFile_ = ACE_OS::fopen (this->inFileName_, "r");
 180         if(this->inFile_ && !ferror (this->inFile_))
 181         {
 182           ACE_OS::fprintf (stdout, "FT Client: Reading commands from %s\n",
 183                            ACE_TEXT_ALWAYS_CHAR (this->inFileName_));
 184           this->commandIn_ = this->inFile_;
 185         }
 186         else
 187         {
 188           ACE_OS::fprintf (stderr, "FT Client: Can't open input file: %s\n",
 189                            ACE_TEXT_ALWAYS_CHAR (this->inFileName_));
 190           result = -1;
 191         }
 192         break;
 193       }
 194       case 'f':
 195       {
 196         replica_iors_.push_back(ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ()));
 197         break;
 198       }
 199
 200       default:
 201       case '?':
 202         usage(stderr);
 203         result = 1;
 204     }
 205   }
 206   return result;
 207 }
 208
 209 void FTClientMain::usage(FILE* out)const
 210 {
 211   ACE_OS::fprintf (out, "usage"
 212                    " -c <command file>"
 213                    " [-f <ior file>]...\n");
 214 }
 215
 216 int FTClientMain::pass (
 217   long & counter,
 218   int & more,
 219   ACE_CString & command,
 220   int retry)
 221 {
 222   int result = 0;
 223
 224   ::FT::State_var state;
 225   unsigned long stateValue = 0;
 226   ::FT::State_var update;
 227   unsigned long updateValue = 0;
 228
 229   while(more && result == 0 &&  !feof (this->commandIn_))
 230   {
 231     if (! retry || command.length () == 0 )
 232     {
 233       char buffer[1000];
 234       char *str_ = ACE_OS::fgets (buffer, sizeof(buffer)-1, this->commandIn_);
 235       if ( str_ )
 236       {
 237         str_ = ACE_OS::strrchr (str_, '\n');
 238         if ( str_ )
 239           *str_ = '\0';
 240       }
 241       command = buffer;
 242     }
 243     retry = 0;
 244
 245     if (command.length() >0)
 246     {
 247       char op = command[0];
 248       ACE_CString cdr = command.substr(1);
 249       char * junque;
 250       long operand = ACE_OS::strtol(cdr.c_str(),&junque, 10);
 251
 252       if (this->verbose_ >= NOISY)
 253       {
 254         ACE_OS::fprintf (stdout,  "FT Client: %s\n", command.c_str());
 255       }
 256
 257       // turn echo on (based on verbose)
 258       // individual commands can turn it off
 259       int echo = this->verbose_ >= QUIET;
 260
 261       switch(op)
 262       {
 263         case '#':
 264         {
 265           echo = 0;
 266           break;
 267         }
 268         case '=':
 269         {
 270           if (this->verbose_ >= LOUD)
 271           {
 272             ACE_OS::fprintf (stdout, "FT Client: ->set(%ld);\n", operand);
 273           }
 274           this->replica_->set(operand);
 275           counter = operand;
 276           break;
 277         }
 278         case 'c':
 279         {
 280           if (this->verbose_ >= LOUD)
 281           {
 282             ACE_OS::fprintf (stdout, "FT Client: ->get();\n");
 283           }
 284           long value = this->replica_->counter();
 285           if (value == operand)
 286           {
 287             ACE_OS::fprintf (stdout, "FT Client: Good: Read %ld expecting %ld\n", value, operand);
 288             counter = operand;
 289           }
 290           else
 291           {
 292             ACE_OS::fprintf (stdout, "FT Client: Error: Read %ld expecting %ld\n", value, operand);
 293           }
 294           echo = 0;
 295           break;
 296         }
 297         case '>':
 298         {
 299           if (this->verbose_ >= LOUD)
 300           {
 301             ACE_OS::fprintf (stdout, "FT Client: ->counter(%ld);\n", operand);
 302           }
 303           this->replica_->counter(operand);
 304           counter = operand;
 305           break;
 306         }
 307         case '+':
 308         {
 309           if (this->verbose_ >= LOUD)
 310           {
 311             ACE_OS::fprintf (stdout, "FT Client: ->increment(%ld);\n", operand);
 312           }
 313           this->replica_->increment(operand);
 314           counter += operand;
 315           break;
 316         }
 317         case '-':
 318         {
 319           if (this->verbose_ >= LOUD)
 320           {
 321             ACE_OS::fprintf (stdout, "FT Client: ->increment(%ld);\n", -operand);
 322           }
 323           this->replica_->increment(-operand);
 324           counter -= operand;
 325           break;
 326         }
 327         case '<':
 328         {
 329           if (this->verbose_ >= LOUD)
 330           {
 331             ACE_OS::fprintf (stdout, "FT Client: ->counter();\n");
 332           }
 333           long attribute = this->replica_->counter();
 334           ACE_OS::fprintf (stdout, "FT Client: Attribute: %ld\n", attribute);
 335           echo = 0;
 336           break;
 337         }
 338         case '!':
 339         {
 340           if (this->verbose_ >= LOUD)
 341           {
 342             ACE_OS::fprintf (stdout, "FT Client: ->is_alive();\n");
 343           }
 344           int alive = this->replica_->is_alive();
 345           ACE_OS::fprintf (stdout, "FT Client: Is alive?  %d\n", alive);
 346           break;
 347         }
 348         case 'd':
 349         {
 350           if (this->verbose_ >= LOUD)
 351           {
 352             ACE_OS::fprintf (stdout, "FT Client: ->die(%ld);\n", operand);
 353           }
 354           this->replica_->die(static_cast<FT_TEST::TestReplica::Bane> (operand));
 355           echo = 0;
 356           break;
 357         }
 358         case 's':
 359         {
 360           if (this->verbose_ >= LOUD)
 361           {
 362             ACE_OS::fprintf (stdout, "FT Client: ->get_state();\n");
 363           }
 364           state = this->replica_->get_state();
 365           stateValue = counter;
 366           break;
 367         }
 368         case 'S':
 369         {
 370           if (state->length () > 0)
 371           {
 372             if (this->verbose_ >= LOUD)
 373             {
 374               ACE_OS::fprintf (stdout, "FT Client: ->set_state(saved_state);\n");
 375             }
 376             this->replica_->set_state (state.in ());
 377             counter = stateValue;
 378           }
 379           else
 380           {
 381             ACE_OS::fprintf (stdout, "FT Client: Error: no saved state.\n");
 382           }
 383           break;
 384         }
 385         case 'u':
 386         {
 387           if (this->verbose_ >= LOUD)
 388           {
 389             ACE_OS::fprintf (stdout, "FT Client: ->get_update();\n");
 390           }
 391           update = this->replica_->get_update();
 392           updateValue = counter;
 393           break;
 394         }
 395         case 'U':
 396         {
 397           if (update->length () > 0)
 398           {
 399             if (this->verbose_ >= LOUD)
 400             {
 401               ACE_OS::fprintf (stdout, "FT Client: ->set_update(saved_update);\n");
 402             }
 403             this->replica_->set_update(update.in ());
 404             counter = updateValue;
 405           }
 406           else
 407           {
 408             ACE_OS::fprintf (stdout, "FT Client: ERROR: No saved update information.\n");
 409           }
 410           break;
 411         }
 412         case 'v':
 413         {
 414           this->verbose_ = static_cast<Verbosity> (operand);
 415           break;
 416         }
 417         case 'z':
 418         {
 419           if (operand == 0)
 420           {
 421             operand = 1;
 422           }
 423           ACE_Time_Value tv (operand,0);
 424           ACE_OS::sleep(tv);
 425           break;
 426         }
 427         case 'q':
 428         {
 429           if (operand != 0)
 430           {
 431             try
 432             {
 433               if (this->verbose_ >= LOUD)
 434               {
 435                 ACE_OS::fprintf (stdout, "FT Client: ->shutdown();\n");
 436               }
 437               this->replica_->shutdown();
 438               // @@ Note: this is here because the corba event loop seems to go to sleep
 439               // if there's nothing for it to do.
 440               // not quite sure why, yet.  Dale
 441               this->replica_->is_alive();
 442             }
 443             catch (const CORBA::Exception&)
 444             {
 445               ACE_OS::fprintf (stdout, "FT Client: Ignoring expected exception during shutdown.\n");
 446               ; // ignore exception during shutdown
 447             }
 448           }
 449           echo = 0;
 450           more = 0;
 451           break;
 452         }
 453         default:
 454         {
 455           if (op != '?')
 456           {
 457             ACE_OS::fprintf (stdout, "FT Client: Unknown: %s\n", command.c_str());
 458           }
 459           commandUsage(stderr);
 460           break;
 461         }
 462       }
 463       if (echo && this->verbose_ >= QUIET)
 464       {
 465         if (this->verbose_ >= LOUD)
 466         {
 467           ACE_OS::fprintf (stdout, "FT Client: ->get();\n");
 468         }
 469
 470         long value = this->replica_->get();
 471         if (value == counter)
 472         {
 473           if (this->verbose_ >= NORMAL)
 474           {
 475             ACE_OS::fprintf (stdout, "FT Client: %ld\n", counter);
 476           }
 477         }
 478         else
 479         {
 480           ACE_OS::fprintf (stdout, "FT Client: Error: read %ld expecting %ld\n", value, counter);
 481           result = -1;
 482         }
 483       }
 484     }
 485   }
 486   return result;
 487 }
 488
 489 int FTClientMain::next_replica ()
 490 {
 491   int result = 0;
 492   if (this->replica_pos_ < this->replica_iors_.size())
 493   {
 494     this->replica_name_ = this->replica_iors_[this->replica_pos_].c_str();
 495     this->replica_pos_ += 1;
 496     CORBA::Object_var rep_obj = this->orb_->string_to_object (this->replica_name_);
 497     this->replica_ = FT_TEST::TestReplica::_narrow (rep_obj.in ());
 498     if (! CORBA::is_nil (replica_.in ()))
 499     {
 500       result = 1;
 501     }
 502     else
 503     {
 504       ACE_OS::fprintf (stderr, "FT Client: Can't resolve IOR: %s\n", this->replica_name_);
 505     }
 506   }
 507   else
 508   {
 509     ACE_OS::fprintf (stderr,
 510                      "***OUT_OF_REPLICAS*** "
 511                      ACE_SIZE_T_FORMAT_SPECIFIER_ASCII
 512                      "\n",
 513                      this->replica_pos_);
 514   }
 515   return result;
 516 }
 517
 518
 519 int FTClientMain::run ()
 520 {
 521   int result = 0;
 522
 523   this->orb_ = CORBA::ORB_init(this->argc_, this->argv_);
 524
 525   int ok = next_replica ();
 526   if (ok)
 527   {
 528     // retry information
 529     ACE_CString command;
 530     int retry = 0;
 531     long counter = this->replica_->get();
 532
 533     if (this->verbose_ >= NORMAL)
 534     {
 535       ACE_OS::fprintf (stdout, "FT Client: Initial counter %ld\n", counter);
 536     }
 537     if (ACE_OS::isatty(ACE_OS::fileno(stdin)))
 538     {
 539       ACE_OS::fprintf (stdout, "FT Client: Commands(? for help):\n");
 540     }
 541
 542     int more = 1;
 543     while (more && result == 0 &&  !feof (this->commandIn_))
 544     {
 545       try
 546       {
 547         result = pass (counter, more, command, retry);
 548       }
 549       catch (const CORBA::SystemException& sysex)
 550       {
 551         ACE_OS::fprintf (stdout, "FT Client: Caught system exception:\n");
 552         sysex._tao_print_exception ("FT Client");
 553
 554         retry = 0;
 555         int handled = 0;
 556
 557         handled = next_replica();
 558         if (handled)
 559         {
 560           ACE_OS::fprintf (stdout, "FT Client: Recovering from fault.\n");
 561           ACE_OS::fprintf (stdout, "FT Client:   Activate %s\n", this->replica_name_);
 562           if (command.length () == 0)
 563           {
 564             ACE_OS::fprintf (stdout, "FT Client:   No command to retry.\n");
 565           }
 566           else if (command[0] == 'd')
 567           {
 568             ACE_OS::fprintf (stdout, "FT Client:   Not retrying \"die\" command.\n");
 569           }
 570           else if (sysex.completed () == CORBA::COMPLETED_YES)
 571           {
 572             ACE_OS::fprintf (stdout, "FT Client:   Last command completed.  No retry needed.\n");
 573           }
 574           else
 575           {
 576             if (sysex.completed () == CORBA::COMPLETED_MAYBE)
 577             {
 578               ACE_OS::fprintf (stdout, "FT Client:   Last command may have completed.  Retrying anyway.\n");
 579             }
 580             retry = 1;
 581             ACE_OS::fprintf (stdout, "FT Client:   Retrying command: %s\n", command.c_str());
 582           }
 583         }
 584         if (! handled)
 585         {
 586           ACE_OS::fprintf (stdout, "FT Client: Exception not handled.  Rethrow. ");
 587           throw;
 588         }
 589       }
 590     }
 591   }
 592   else
 593   {
 594     ACE_OS::fprintf (stderr, "FT Client: Can't connect to replica.\n");
 595   }
 596   return result;
 597 }
 598
 599
 600 int
 601 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 602 {
 603   FTClientMain app;
 604   int result = app.parse_args(argc, argv);
 605   if (result == 0)
 606   {
 607     try
 608     {
 609       result = app.run ();
 610     }
 611     catch (const CORBA::Exception& ex)
 612     {
 613       ex._tao_print_exception ("FT_Client::main\t\n");
 614       result = -1;
 615     }
 616   }
 617   return result;
 618 }