TAO/orbsvcs/tests/Concurrency/CC_command.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    CC_command.cpp
   4  *
   5  *    This is the command classes for the test of the concurrency service.
   6  *
   7  *  @author   Torben Worm <tworm@cs.wustl.edu>
   8  */
   9 //=============================================================================
  10
  11
  12 #include "CC_command.h"
  13 #include "CC_test_utils.h"
  14 #include "CC_naming_service.h"
  15 #include "ace/ACE.h"
  16 #include "ace/Process.h"
  17 #include "ace/Log_Msg.h"
  18 #include "orbsvcs/CosConcurrencyControlC.h"
  19 #include "ace/OS_NS_stdio.h"
  20 #include "ace/OS_NS_unistd.h"
  21 #include "ace/OS_NS_string.h"
  22
  23 CC_Command::~CC_Command()
  24 {
  25 }
  26
  27 int CC_Command::execute()
  28 {
  29   return 0;
  30 }
  31
  32 CC_Command::CC_Command()
  33 {
  34 }
  35
  36 CosConcurrencyControl::LockSet_var
  37 CC_Command::GetLockSet (const char *lock_set_name)
  38 {
  39   CosConcurrencyControl::LockSet_var ccls_ret;
  40
  41   try
  42     {
  43       if(ACE_OS::strcmp(lock_set_name, "")!=0)
  44         {
  45           CORBA::Object_var ccls_obj =
  46             CC_naming_service::Instance()->get_obj_from_name ("",
  47                                                               lock_set_name);
  48
  49           ccls_ret =
  50             CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ());
  51         }
  52       else
  53         {
  54           // No lock set name was given. Use the global lock set.
  55           if(cc_lockset_.in()==0)
  56             {
  57               throw CORBA::UNKNOWN ();
  58             }
  59           else
  60             ccls_ret = cc_lockset_.in ();
  61         }
  62     }
  63   catch (const CORBA::Exception&)
  64     {
  65       throw;
  66     }
  67
  68   return ccls_ret;
  69 }
  70
  71 CORBA::Exception *CC_Command::excep_ = 0;
  72
  73 CosConcurrencyControl::LockSet_var CC_Command::cc_lockset_(0);
  74
  75 CC_Start_Cmd::CC_Start_Cmd (const char *config_file_name)
  76   : cfg_name_ (ACE_OS::strdup (config_file_name))
  77 {
  78   //  printf("CC_Start_Cmd::CC_Start_Cmd: config: %s\n", config_file_name);
  79 }
  80
  81 CC_Start_Cmd::~CC_Start_Cmd()
  82 {
  83   // cfg_name_ is allocated in the lexer with strdup
  84   if (cfg_name_)
  85     {
  86       ACE_OS::free(cfg_name_);
  87       cfg_name_ = 0;
  88     }
  89 }
  90
  91 int CC_Start_Cmd::execute()
  92 {
  93   if (excep_)
  94     {
  95       ACE_OS::printf ("Exception: %s\n", excep_->_rep_id ());
  96       delete excep_;
  97       excep_ = 0;
  98       return 0; // CC_FAIL
  99     }
 100
 101   ACE_OS::printf ("Executing start command (script file: %s)\n", cfg_name_);
 102
 103   char cmd_line[1024];
 104   int success = ACE_OS::sprintf(&cmd_line[0], "%s -c %s",
 105                                 "./CC_client", cfg_name_);
 106   if(success>=1024 || success==-1)
 107     ACE_ERROR_RETURN((LM_ERROR, "Creation of process failed: %s\n",
 108                       cmd_line), 0);
 109
 110   ACE_Process new_process;
 111   ACE_Process_Options options;
 112   options.command_line(ACE_TEXT_CHAR_TO_TCHAR(cmd_line));
 113
 114   if(new_process.spawn(options) == -1)
 115     {
 116       ACE_ERROR_RETURN((LM_ERROR, "Creation of process failed: %C\n",
 117                         cmd_line), 0);
 118     }
 119   return 1; // CC_SUCCESS
 120 }
 121
 122 CC_CreateLockSet_Cmd::CC_CreateLockSet_Cmd (const char *lock_set_name)
 123   : name_ (ACE_OS::strdup (lock_set_name))
 124 {
 125   //  printf("CC_CreateLockSet_Cmd::CC_CreateLockSet_Cmd: lock set: %s\n",
 126   //         lock_set_name);
 127 }
 128
 129 CC_CreateLockSet_Cmd::~CC_CreateLockSet_Cmd()
 130 {
 131   // name_ is allocated in the lexer with strdup
 132   if(name_)
 133     {
 134       ACE_OS::free(name_);
 135       name_ = 0;
 136     }
 137 }
 138
 139 int CC_CreateLockSet_Cmd::execute()
 140 {
 141   if(excep_)
 142     {
 143       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 144       delete excep_;
 145       excep_ = 0;
 146       return 0; // CC_FAIL
 147     }
 148
 149   ACE_OS::printf("Executing create command (lock set: %s)\n", name_);
 150
 151   try
 152     {
 153       CosConcurrencyControl::LockSet_ptr lock_set =
 154         CC_TestUtils::create_lock_set();
 155       if(ACE_OS::strcmp(name_,"")!=0)// Do not bind an empty name
 156         {
 157           CC_naming_service::Instance()->bind_name(name_,
 158                                                    lock_set);
 159         }
 160       else
 161         {
 162           // We did not specify a name => the global lock set variable is set
 163           cc_lockset_ = lock_set;
 164         }
 165     }
 166   catch (const CORBA::Exception& ex)
 167     {
 168       ex._tao_print_exception ("CC_CreateLockSet_Cmd::execute()");
 169     }
 170
 171   return 1; // CC_SUCCESS
 172 }
 173
 174 CC_Lock_Cmd::CC_Lock_Cmd (const char *lock_set_name,
 175                           CosConcurrencyControl::lock_mode mode)
 176   : name_ (ACE_OS::strdup (lock_set_name)),
 177     mode_(mode)
 178 {
 179   //  printf("CC_Lock_Cmd::CC_Lock_Cmd: lock set: %s, mode: %s\n",
 180   //         lock_set_name, CC_TestUtils::get_lock_mode_name(mode));
 181 }
 182
 183 CC_Lock_Cmd::~CC_Lock_Cmd()
 184 {
 185   ACE_OS::free (this->name_);
 186 }
 187
 188 int CC_Lock_Cmd::execute()
 189 {
 190   if(excep_)
 191     {
 192       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 193       delete excep_;
 194       excep_ = 0;
 195       return 0; // CC_FAIL
 196     }
 197
 198   ACE_OS::printf("Executing lock command (lock set: %s, mode: %s)\n",
 199                  name_, CC_TestUtils::get_lock_mode_name(mode_));
 200
 201   try
 202     {
 203       CosConcurrencyControl::LockSet_var ccls =
 204         GetLockSet(name_);
 205       ccls->lock (mode_);
 206     }
 207   catch (const CORBA::Exception& ex)
 208     {
 209       ex._tao_print_exception ("CC_Lock_Cmd::execute()");
 210       return 0;
 211     }
 212   return 1; // CC_SUCCESS
 213 }
 214
 215 CC_UnLock_Cmd::CC_UnLock_Cmd (const char *lock_set_name,
 216                               CosConcurrencyControl::lock_mode mode)
 217   : name_ (ACE_OS::strdup (lock_set_name)),
 218     mode_ (mode)
 219 {
 220   //  printf("CC_UnLock_Cmd::CC_UnLock_Cmd: lock set: %s, mode: %s\n",
 221   //         lock_set_name, CC_TestUtils::get_lock_mode_name(mode));
 222 }
 223
 224 CC_UnLock_Cmd::~CC_UnLock_Cmd()
 225 {
 226   ACE_OS::free (this->name_);
 227 }
 228
 229 int CC_UnLock_Cmd::execute()
 230 {
 231   if(excep_)
 232     {
 233       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 234       delete excep_;
 235       excep_ = 0;
 236       return 0; // CC_FAIL
 237     }
 238
 239   ACE_OS::printf("Executing unlock command (lock set: %s, mode: %s)\n",
 240                  name_, CC_TestUtils::get_lock_mode_name(mode_));
 241
 242   try
 243     {
 244       CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_);
 245
 246       ccls->unlock (mode_);
 247     }
 248   catch (const CORBA::Exception& ex)
 249     {
 250       ex._tao_print_exception ("CC_UnLock_Cmd::execute()");
 251       return 0;
 252     }
 253   return 1; // CC_SUCCESS
 254 }
 255
 256 CC_TryLock_Cmd::CC_TryLock_Cmd (const char *lock_set_name,
 257                                 CosConcurrencyControl::lock_mode mode)
 258   : name_ (ACE_OS::strdup (lock_set_name)),
 259     mode_ (mode)
 260 {
 261   //  printf("CC_TryLock_Cmd::CC_TryLock_Cmd: lock set: %s, mode %s\n",
 262   //         lock_set_name, CC_TestUtils::get_lock_mode_name(mode));
 263 }
 264
 265 CC_TryLock_Cmd::~CC_TryLock_Cmd()
 266 {
 267   ACE_OS::free (this->name_);
 268 }
 269
 270 int CC_TryLock_Cmd::execute()
 271 {
 272   if(excep_)
 273     {
 274       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 275       delete excep_;
 276       excep_ = 0;
 277       return 0; // CC_FAIL
 278     }
 279
 280   ACE_OS::printf("Executing try_lock command (lock set: %s, mode: %s)\n",
 281                  name_, CC_TestUtils::get_lock_mode_name(mode_));
 282
 283   CORBA::Boolean lock_not_held;
 284
 285   try
 286     {
 287       CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_);
 288
 289       lock_not_held = ccls->try_lock (mode_);
 290
 291       if (lock_not_held)
 292         {
 293           ACE_DEBUG ((LM_DEBUG,
 294                       "%C lock not held\n",
 295                       CC_TestUtils::get_lock_mode_name (mode_)));
 296         }
 297       else
 298         ACE_DEBUG ((LM_DEBUG,
 299                     "%C lock held\n",
 300                     CC_TestUtils::get_lock_mode_name (mode_)));
 301     }
 302   catch (const CORBA::Exception& ex)
 303     {
 304       ex._tao_print_exception ("CC_TryLock_Cmd::execute()");
 305       return 0;
 306     }
 307
 308   return 1; // CC_SUCCESS
 309 }
 310
 311 CC_ChangeMode_Cmd::
 312     CC_ChangeMode_Cmd (const char *lock_set_name,
 313                        CosConcurrencyControl::lock_mode held_mode,
 314                        CosConcurrencyControl::lock_mode new_mode)
 315   : name_(ACE_OS::strdup (lock_set_name)),
 316     held_mode_ (held_mode),
 317     new_mode_ (new_mode)
 318 {
 319   //  printf("CC_ChangeMode_Cmd::CC_ChangeMode_Cmd: lock set: %s, held mode: %s, new mode: %s\n",
 320   //         lock_set_name,
 321   //         CC_TestUtils::get_lock_mode_name(held_mode),
 322   //         CC_TestUtils::get_lock_mode_name(new_mode));
 323 }
 324
 325 CC_ChangeMode_Cmd::~CC_ChangeMode_Cmd()
 326 {
 327   ACE_OS::strdup (this->name_);
 328 }
 329
 330 int CC_ChangeMode_Cmd::execute()
 331 {
 332   if(excep_)
 333     {
 334       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 335       delete excep_;
 336       excep_ = 0;
 337       return 0; // CC_FAIL
 338     }
 339
 340   ACE_OS::printf("Executing change_mode command (lock set: %s, held_mode: %s, new_mode: %s)\n",
 341                  name_, CC_TestUtils::get_lock_mode_name(held_mode_),
 342                  CC_TestUtils::get_lock_mode_name(new_mode_));
 343
 344   try
 345     {
 346       CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_);
 347
 348       ccls->change_mode (held_mode_, new_mode_);
 349     }
 350   catch (const CORBA::Exception& ex)
 351     {
 352       ex._tao_print_exception ("CC_ChangeMode_Cmd::execute()");
 353     }
 354   return 1; // CC_SUCCESS
 355 }
 356
 357 CC_Sleep_Cmd::CC_Sleep_Cmd(int seconds)
 358   : time_ (seconds)
 359 {
 360 }
 361
 362 CC_Sleep_Cmd::~CC_Sleep_Cmd()
 363 {
 364 }
 365
 366 int CC_Sleep_Cmd::execute()
 367 {
 368   if(excep_)
 369     {
 370       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 371       delete excep_;
 372       excep_ = 0;
 373       return 0; // CC_FAIL
 374     }
 375
 376   ACE_OS::printf("Executing sleep command (time: %i)\n", time_);
 377
 378   ACE_OS::sleep(time_);
 379   return 1; // CC_SUCCESS
 380 }
 381
 382 CC_Repeat_Cmd::CC_Repeat_Cmd(int times)
 383   : times_ (times)
 384 {
 385 }
 386
 387 CC_Repeat_Cmd::~CC_Repeat_Cmd()
 388 {
 389 }
 390
 391 int CC_Repeat_Cmd::execute()
 392 {
 393   if(excep_)
 394     {
 395       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 396       delete excep_;
 397       excep_ = 0;
 398       return 0; // CC_FAIL
 399     }
 400
 401   ACE_OS::printf("Executing repeat command (times: %i)\n", times_);
 402
 403   return 1; // CC_SUCCESS
 404 }
 405
 406 CC_Wait_Cmd::CC_Wait_Cmd (const char *prompt)
 407   : prompt_ (ACE_OS::strdup (prompt))
 408 {
 409 }
 410
 411 CC_Wait_Cmd::~CC_Wait_Cmd()
 412 {
 413   ACE_OS::free (this->prompt_);
 414 }
 415
 416 int CC_Wait_Cmd::execute()
 417 {
 418   if (excep_)
 419     {
 420       ACE_OS::printf ("Exception: %s\n", excep_->_rep_id ());
 421       delete excep_;
 422       excep_ = 0;
 423       return 0; // CC_FAIL
 424     }
 425
 426   ACE_OS::printf ("Executing wait command\n");
 427
 428   ACE_OS::printf ("%s", prompt_);
 429   (void) ACE_OS::fgetc (stdin);
 430
 431   return 1; // CC_SUCCESS
 432 }
 433
 434 CC_Excep_Cmd::CC_Excep_Cmd (const char *excep)
 435   : ex_ (ACE_OS::strdup (excep))
 436 {
 437   //  printf("CC_Excep_Cmd::CC_Excep_Cmd: excep: %s\n", excep);
 438 }
 439
 440 CC_Excep_Cmd::~CC_Excep_Cmd()
 441 {
 442   ACE_OS::free (this->ex_);
 443 }
 444
 445 int
 446 CC_Excep_Cmd::execute()
 447 {
 448   ACE_OS::printf ("Executing excep command (expected: %s)\n", ex_);
 449   // First we check to see if an exception has occurred. If not we fail
 450   // because we expected to see one
 451   if(excep_==0)
 452     return 0; // CC_FAIL
 453
 454   // If there is an exception check that it's the expected one
 455   if(ACE_OS::strcmp(excep_->_rep_id (), ex_)==0)
 456     {
 457       delete excep_;
 458       excep_ = 0;
 459       return 1; // CC_SUCCESS
 460     }
 461   else
 462     {
 463       ACE_OS::printf ("Exception: %s\n", excep_->_rep_id ());
 464       delete excep_;
 465       excep_ = 0;
 466       return 0; // CC_FAIL
 467     }
 468 }
 469
 470 CC_Dummy_Cmd::CC_Dummy_Cmd()
 471 {
 472 }
 473
 474 CC_Dummy_Cmd::~CC_Dummy_Cmd()
 475 {
 476 }
 477
 478 int
 479 CC_Dummy_Cmd::execute()
 480 {
 481   return 1; // CC_SUCCESS
 482 }
 483
 484 CC_Print_Cmd::CC_Print_Cmd (const char * message)
 485   : msg_ (ACE_OS::strdup (message))
 486 {
 487 }
 488
 489 CC_Print_Cmd::~CC_Print_Cmd()
 490 {
 491   ACE_OS::free(msg_);
 492 }
 493
 494 int
 495 CC_Print_Cmd::execute()
 496 {
 497   ACE_OS::printf ("%s\n", msg_);
 498   return 1; // CC_SUCCESS
 499 }
 500
 501 CC_Lookup_Cmd::CC_Lookup_Cmd (const char *lock_set_name)
 502   : name_ (ACE_OS::strdup (lock_set_name))
 503 {
 504 }
 505
 506 CC_Lookup_Cmd::~CC_Lookup_Cmd()
 507 {
 508   if(name_)
 509     {
 510       ACE_OS::free(name_);
 511       name_ = 0;
 512     }
 513 }
 514
 515 int
 516 CC_Lookup_Cmd::execute()
 517 {
 518   if(excep_)
 519     {
 520       ACE_OS::printf ("Exception: %s\n", excep_->_rep_id ());
 521       delete excep_;
 522       excep_ = 0;
 523       return 0; // CC_FAIL
 524     }
 525
 526   ACE_OS::printf ("Executing lookup command (lock set: %s)\n", name_);
 527
 528   // Do the lookup if we haven't done it before
 529   if(cc_lockset_.in() == 0)
 530     {
 531       try
 532         {
 533           CORBA::Object_var ccls_obj =
 534             CC_naming_service::Instance()->get_obj_from_name ("",
 535                                                               name_);
 536
 537           CosConcurrencyControl::LockSet_var ccls =
 538             CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ());
 539
 540           cc_lockset_ = ccls;
 541         }
 542       catch (const CORBA::Exception& ex)
 543         {
 544           ex._tao_print_exception ("CC_UnLock_Cmd::execute()");
 545         }
 546     }
 547   return 1; // CC_SUCCESS
 548 }
 549
 550 CC_CommandElem::CC_CommandElem(CC_Command *cmd, CC_CommandElem *next)
 551   : next_ (next), cmd_ (cmd)
 552 {
 553 }
 554
 555 CC_CommandElem::~CC_CommandElem()
 556 {
 557 }
 558
 559 CC_Command *CC_CommandElem::GetCommand()
 560 {
 561   return cmd_;
 562 }
 563
 564 CC_CommandElem *
 565 CC_CommandElem::GetNext()
 566 {
 567   return next_;
 568 }
 569
 570 void
 571 CC_CommandElem::SetNext(CC_CommandElem *next)
 572 {
 573   next_ = next;
 574 }
 575
 576 CC_CommandList::CC_CommandList()
 577   : head_ (0), last_ (0), times_ (1)
 578 {
 579   ACE_OS::printf("CC_CommandList::CC_CommandList\n");
 580 }
 581
 582 CC_CommandList::~CC_CommandList()
 583 {
 584 }
 585
 586 int
 587 CC_CommandList::add(CC_Command *cmd)
 588 {
 589   if(head_==0)
 590     {
 591       head_ = new CC_CommandElem(cmd, 0);
 592       last_ = head_;
 593     }
 594   else
 595     {
 596       CC_CommandElem *tmp = new CC_CommandElem(cmd, 0);
 597       last_->SetNext(tmp);
 598       last_ = tmp;
 599     }
 600   return 0;
 601 }
 602
 603 int
 604 CC_CommandList::execute()
 605 {
 606   CC_CommandElem *current = head_;
 607
 608   for(int i=0; i<times_; i++)
 609     {
 610       current = head_;
 611       while(current!=0)
 612         {
 613           if(current->GetCommand()->execute()==0) // == CC_FAIL
 614             {
 615               return 0; // CC_FAIL
 616             }
 617           current = current->GetNext();
 618         }
 619     }
 620   return 1; // CC_SUCCESS
 621 }
 622
 623 void
 624 CC_CommandList::setrepeat(int times)
 625 {
 626   times_ = times;
 627 }