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(void)
  24 {
  25 }
  26
  27 int CC_Command::execute()
  28 {
  29   return 0;
  30 }
  31
  32 CC_Command::CC_Command(void)
  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(void)
  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(void)
 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(void)");
 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(void)
 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(void)");
 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(void)
 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     }
 249   catch (const CORBA::Exception& ex)
 250     {
 251       ex._tao_print_exception ("CC_UnLock_Cmd::execute(void)");
 252       return 0;
 253     }
 254   return 1; // CC_SUCCESS
 255 }
 256
 257 CC_TryLock_Cmd::CC_TryLock_Cmd (const char *lock_set_name,
 258                                 CosConcurrencyControl::lock_mode mode)
 259   : name_ (ACE_OS::strdup (lock_set_name)),
 260     mode_ (mode)
 261 {
 262   //  printf("CC_TryLock_Cmd::CC_TryLock_Cmd: lock set: %s, mode %s\n",
 263   //         lock_set_name, CC_TestUtils::get_lock_mode_name(mode));
 264 }
 265
 266 CC_TryLock_Cmd::~CC_TryLock_Cmd()
 267 {
 268   ACE_OS::free (this->name_);
 269 }
 270
 271 int CC_TryLock_Cmd::execute(void)
 272 {
 273   if(excep_)
 274     {
 275       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 276       delete excep_;
 277       excep_ = 0;
 278       return 0; // CC_FAIL
 279     }
 280
 281   ACE_OS::printf("Executing try_lock command (lock set: %s, mode: %s)\n",
 282                  name_, CC_TestUtils::get_lock_mode_name(mode_));
 283
 284   CORBA::Boolean lock_not_held;
 285
 286   try
 287     {
 288       CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_);
 289
 290       lock_not_held = ccls->try_lock (mode_);
 291
 292       if (lock_not_held)
 293         {
 294           ACE_DEBUG ((LM_DEBUG,
 295                       "%C lock not held\n",
 296                       CC_TestUtils::get_lock_mode_name (mode_)));
 297         }
 298       else
 299         ACE_DEBUG ((LM_DEBUG,
 300                     "%C lock held\n",
 301                     CC_TestUtils::get_lock_mode_name (mode_)));
 302     }
 303   catch (const CORBA::Exception& ex)
 304     {
 305       ex._tao_print_exception ("CC_TryLock_Cmd::execute(void)");
 306       return 0;
 307     }
 308
 309   return 1; // CC_SUCCESS
 310 }
 311
 312 CC_ChangeMode_Cmd::
 313     CC_ChangeMode_Cmd (const char *lock_set_name,
 314                        CosConcurrencyControl::lock_mode held_mode,
 315                        CosConcurrencyControl::lock_mode new_mode)
 316   : name_(ACE_OS::strdup (lock_set_name)),
 317     held_mode_ (held_mode),
 318     new_mode_ (new_mode)
 319 {
 320   //  printf("CC_ChangeMode_Cmd::CC_ChangeMode_Cmd: lock set: %s, held mode: %s, new mode: %s\n",
 321   //         lock_set_name,
 322   //         CC_TestUtils::get_lock_mode_name(held_mode),
 323   //         CC_TestUtils::get_lock_mode_name(new_mode));
 324 }
 325
 326 CC_ChangeMode_Cmd::~CC_ChangeMode_Cmd()
 327 {
 328   ACE_OS::strdup (this->name_);
 329 }
 330
 331 int CC_ChangeMode_Cmd::execute(void)
 332 {
 333   if(excep_)
 334     {
 335       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 336       delete excep_;
 337       excep_ = 0;
 338       return 0; // CC_FAIL
 339     }
 340
 341   ACE_OS::printf("Executing change_mode command (lock set: %s, held_mode: %s, new_mode: %s)\n",
 342                  name_, CC_TestUtils::get_lock_mode_name(held_mode_),
 343                  CC_TestUtils::get_lock_mode_name(new_mode_));
 344
 345   try
 346     {
 347       CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_);
 348
 349       ccls->change_mode (held_mode_, new_mode_);
 350
 351     }
 352   catch (const CORBA::Exception& ex)
 353     {
 354       ex._tao_print_exception ("CC_ChangeMode_Cmd::execute(void)");
 355     }
 356   return 1; // CC_SUCCESS
 357 }
 358
 359 CC_Sleep_Cmd::CC_Sleep_Cmd(int seconds)
 360   : time_ (seconds)
 361 {
 362 }
 363
 364 CC_Sleep_Cmd::~CC_Sleep_Cmd()
 365 {
 366 }
 367
 368 int CC_Sleep_Cmd::execute(void)
 369 {
 370   if(excep_)
 371     {
 372       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 373       delete excep_;
 374       excep_ = 0;
 375       return 0; // CC_FAIL
 376     }
 377
 378   ACE_OS::printf("Executing sleep command (time: %i)\n", time_);
 379
 380   ACE_OS::sleep(time_);
 381   return 1; // CC_SUCCESS
 382 }
 383
 384 CC_Repeat_Cmd::CC_Repeat_Cmd(int times)
 385   : times_ (times)
 386 {
 387 }
 388
 389 CC_Repeat_Cmd::~CC_Repeat_Cmd()
 390 {
 391 }
 392
 393 int CC_Repeat_Cmd::execute(void)
 394 {
 395   if(excep_)
 396     {
 397       ACE_OS::printf("Exception: %s\n", excep_->_rep_id ());
 398       delete excep_;
 399       excep_ = 0;
 400       return 0; // CC_FAIL
 401     }
 402
 403   ACE_OS::printf("Executing repeat command (times: %i)\n", times_);
 404
 405   return 1; // CC_SUCCESS
 406 }
 407
 408 CC_Wait_Cmd::CC_Wait_Cmd (const char *prompt)
 409   : prompt_ (ACE_OS::strdup (prompt))
 410 {
 411 }
 412
 413 CC_Wait_Cmd::~CC_Wait_Cmd()
 414 {
 415   ACE_OS::free (this->prompt_);
 416 }
 417
 418 int CC_Wait_Cmd::execute(void)
 419 {
 420   if (excep_)
 421     {
 422       ACE_OS::printf ("Exception: %s\n", excep_->_rep_id ());
 423       delete excep_;
 424       excep_ = 0;
 425       return 0; // CC_FAIL
 426     }
 427
 428   ACE_OS::printf ("Executing wait command\n");
 429
 430   ACE_OS::printf ("%s", prompt_);
 431   (void) ACE_OS::fgetc (stdin);
 432
 433   return 1; // CC_SUCCESS
 434 }
 435
 436 CC_Excep_Cmd::CC_Excep_Cmd (const char *excep)
 437   : ex_ (ACE_OS::strdup (excep))
 438 {
 439   //  printf("CC_Excep_Cmd::CC_Excep_Cmd: excep: %s\n", excep);
 440 }
 441
 442 CC_Excep_Cmd::~CC_Excep_Cmd(void)
 443 {
 444   ACE_OS::free (this->ex_);
 445 }
 446
 447 int
 448 CC_Excep_Cmd::execute(void)
 449 {
 450   ACE_OS::printf ("Executing excep command (expected: %s)\n", ex_);
 451   // First we check to see if an exception has occurred. If not we fail
 452   // because we expected to see one
 453   if(excep_==0)
 454     return 0; // CC_FAIL
 455
 456   // If there is an exception check that it's the expected one
 457   if(ACE_OS::strcmp(excep_->_rep_id (), ex_)==0)
 458     {
 459       delete excep_;
 460       excep_ = 0;
 461       return 1; // CC_SUCCESS
 462     }
 463   else
 464     {
 465       ACE_OS::printf ("Exception: %s\n", excep_->_rep_id ());
 466       delete excep_;
 467       excep_ = 0;
 468       return 0; // CC_FAIL
 469     }
 470 }
 471
 472 CC_Dummy_Cmd::CC_Dummy_Cmd(void)
 473 {
 474 }
 475
 476 CC_Dummy_Cmd::~CC_Dummy_Cmd(void)
 477 {
 478 }
 479
 480 int
 481 CC_Dummy_Cmd::execute(void)
 482 {
 483   return 1; // CC_SUCCESS
 484 }
 485
 486 CC_Print_Cmd::CC_Print_Cmd (const char * message)
 487   : msg_ (ACE_OS::strdup (message))
 488 {
 489 }
 490
 491 CC_Print_Cmd::~CC_Print_Cmd(void)
 492 {
 493   ACE_OS::free(msg_);
 494 }
 495
 496 int
 497 CC_Print_Cmd::execute(void)
 498 {
 499   ACE_OS::printf ("%s\n", msg_);
 500   return 1; // CC_SUCCESS
 501 }
 502
 503 CC_Lookup_Cmd::CC_Lookup_Cmd (const char *lock_set_name)
 504   : name_ (ACE_OS::strdup (lock_set_name))
 505 {
 506 }
 507
 508 CC_Lookup_Cmd::~CC_Lookup_Cmd()
 509 {
 510   if(name_)
 511     {
 512       ACE_OS::free(name_);
 513       name_ = 0;
 514     }
 515 }
 516
 517 int
 518 CC_Lookup_Cmd::execute(void)
 519 {
 520   if(excep_)
 521     {
 522       ACE_OS::printf ("Exception: %s\n", excep_->_rep_id ());
 523       delete excep_;
 524       excep_ = 0;
 525       return 0; // CC_FAIL
 526     }
 527
 528   ACE_OS::printf ("Executing lookup command (lock set: %s)\n", name_);
 529
 530   // Do the lookup if we haven't done it before
 531   if(cc_lockset_.in() == 0)
 532     {
 533       try
 534         {
 535           CORBA::Object_var ccls_obj =
 536             CC_naming_service::Instance()->get_obj_from_name ("",
 537                                                               name_);
 538
 539           CosConcurrencyControl::LockSet_var ccls =
 540             CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ());
 541
 542           cc_lockset_ = ccls;
 543
 544         }
 545       catch (const CORBA::Exception& ex)
 546         {
 547           ex._tao_print_exception ("CC_UnLock_Cmd::execute(void)");
 548         }
 549     }
 550   return 1; // CC_SUCCESS
 551 }
 552
 553 CC_CommandElem::CC_CommandElem(CC_Command *cmd, CC_CommandElem *next)
 554   : next_ (next), cmd_ (cmd)
 555 {
 556 }
 557
 558 CC_CommandElem::~CC_CommandElem(void)
 559 {
 560 }
 561
 562 CC_Command *CC_CommandElem::GetCommand(void)
 563 {
 564   return cmd_;
 565 }
 566
 567 CC_CommandElem *
 568 CC_CommandElem::GetNext(void)
 569 {
 570   return next_;
 571 }
 572
 573 void
 574 CC_CommandElem::SetNext(CC_CommandElem *next)
 575 {
 576   next_ = next;
 577 }
 578
 579 CC_CommandList::CC_CommandList(void)
 580   : head_ (0), last_ (0), times_ (1)
 581 {
 582   ACE_OS::printf("CC_CommandList::CC_CommandList\n");
 583 }
 584
 585 CC_CommandList::~CC_CommandList(void)
 586 {
 587 }
 588
 589 int
 590 CC_CommandList::add(CC_Command *cmd)
 591 {
 592   if(head_==0)
 593     {
 594       head_ = new CC_CommandElem(cmd, 0);
 595       last_ = head_;
 596     }
 597   else
 598     {
 599       CC_CommandElem *tmp = new CC_CommandElem(cmd, 0);
 600       last_->SetNext(tmp);
 601       last_ = tmp;
 602     }
 603   return 0;
 604 }
 605
 606 int
 607 CC_CommandList::execute(void)
 608 {
 609   CC_CommandElem *current = head_;
 610
 611   for(int i=0; i<times_; i++)
 612     {
 613       current = head_;
 614       while(current!=0)
 615         {
 616           if(current->GetCommand()->execute()==0) // == CC_FAIL
 617             {
 618               return 0; // CC_FAIL
 619             }
 620           current = current->GetNext();
 621         }
 622     }
 623   return 1; // CC_SUCCESS
 624 }
 625
 626 void
 627 CC_CommandList::setrepeat(int times)
 628 {
 629   times_ = times;
 630 }