TAO/orbsvcs/tests/FT_App/FT_ReplicaFactory_i.cpp

   1 /* -*- C++ -*- */
   2 //=============================================================================
   3 /**
   4  *  @file    FT_ReplicaFactory_i.cpp
   5  *
   6  *  This file is part of Fault Tolerant CORBA.
   7  *
   8  *  @author Dale Wilson <wilson_d@ociweb.com>
   9  */
  10 //=============================================================================
  11 #include "FT_ReplicaFactory_i.h"
  12 #include "FT_TestReplica_i.h"
  13 #include "ace/Get_Opt.h"
  14 #include "ace/OS_NS_unistd.h"
  15 #include "orbsvcs/CosNamingC.h"
  16 #include "orbsvcs/PortableGroupC.h"
  17 #include "orbsvcs/PortableGroup/PG_Property_Set.h"
  18
  19 // Use this macro at the beginning of CORBA methods
  20 // to aid in debugging.
  21 #define METHOD_ENTRY(name)    \
  22     ACE_DEBUG (( LM_DEBUG,    \
  23     "Enter %s\n", #name       \
  24       ))
  25
  26 // Use this macro to return from CORBA methods
  27 // to aid in debugging.  Note that you can specify
  28 // the return value after the macro, for example:
  29 // METHOD_RETURN(Plugh::plover) xyzzy; is equivalent
  30 // to return xyzzy;
  31 // METHOD_RETURN(Plugh::troll); is equivalent to
  32 // return;
  33 // WARNING: THIS GENERATES TWO STATEMENTS!!! THE FOLLOWING
  34 // will not do what you want it to:
  35 //  if (cave_is_closing) METHOD_RETURN(Plugh::pirate) aarrggh;
  36 // Moral:  Always use braces.
  37 #define METHOD_RETURN(name)   \
  38     ACE_DEBUG (( LM_DEBUG,    \
  39       "Leave %s\n", #name     \
  40       ));                     \
  41     return /* value goes here */
  42
  43
  44 static const char * criterion_initial_value = "INITIAL_VALUE";
  45
  46 //////////////////////////////////////////////////////
  47 // FT_ReplicaFactory_i  Construction/destruction
  48
  49 FT_ReplicaFactory_i::FT_ReplicaFactory_i ()
  50   : internals_ ()
  51   , orb_ (CORBA::ORB::_nil ())
  52   , poa_ (PortableServer::POA::_nil ())
  53   , object_id_ ()
  54   , ior_ ()
  55   , ior_output_file_ (0)
  56   , identity_ ()
  57   , have_replication_manager_(0)
  58   , replication_manager_(0)
  59   , factory_registry_ior_(0)
  60   , factory_registry_ (0)
  61   , registered_(0)
  62   , test_output_file_(0)
  63   , ns_name_("")
  64   , naming_context_ (CosNaming::NamingContext::_nil ())
  65   , this_name_ ()
  66   , roles_ ()
  67   , location_ ("unknown")
  68   , quit_on_idle_ (0)
  69   , unregister_by_location_ (0)
  70   , replicas_ ()
  71   , empty_slots_(0)
  72   , quit_requested_(0)
  73   , name_persistent_file_(ACE_TEXT(""))
  74 {
  75   char const * repo_id =
  76     FT_TEST::_tc_TestReplica->id ();
  77
  78   ACE_DEBUG ((LM_DEBUG,
  79               "TestReplica type_id: %s\n",
  80               repo_id));
  81
  82 //  ACE_DEBUG((LM_DEBUG, "Hobbit type_id: %s\n", FT_TEST::_tc_Hobbit->id() ));
  83 //  ACE_DEBUG((LM_DEBUG, "Elf type_id: %s\n", FT_TEST::_tc_Elf->id() ));
  84 //  ACE_DEBUG((LM_DEBUG, "Human type_id: %s\n", FT_TEST::_tc_Human->id() ));
  85 }
  86
  87
  88 FT_ReplicaFactory_i::~FT_ReplicaFactory_i ()
  89 {
  90   {
  91     ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
  92
  93     // be sure all replicas are gone
  94     // before this object disappears
  95     shutdown_i ();
  96   }
  97 }
  98
  99 ////////////////////////////////////////////
 100 // FT_ReplicaFactory_i private methods
 101
 102 CORBA::ULong FT_ReplicaFactory_i::allocate_id()
 103 {
 104   // assume mutex is locked
 105   CORBA::ULong id = this->replicas_.size();
 106   if (this->empty_slots_ != 0)
 107   {
 108     for(CORBA::ULong pos = 0; pos < id; ++pos)
 109     {
 110       if (this->replicas_[pos] == 0)
 111       {
 112         id = pos;
 113       }
 114     }
 115   }
 116   else
 117   {
 118     this->replicas_.push_back(0);
 119     this->empty_slots_ += 1;
 120   }
 121   return id;
 122 }
 123
 124 void FT_ReplicaFactory_i::shutdown_i()
 125 {
 126   // assume mutex is locked
 127   for (size_t nReplica = 0; nReplica < this->replicas_.size(); ++nReplica)
 128   {
 129     FT_TestReplica_i * replica = this->replicas_[nReplica];
 130     if (replica != 0)
 131     {
 132       replica->request_quit();
 133     }
 134   }
 135 }
 136
 137 int FT_ReplicaFactory_i::write_ior(const ACE_TCHAR * outputFile, const char * ior)
 138 {
 139   int result = -1;
 140   FILE* out = ACE_OS::fopen (outputFile, "w");
 141   if (out)
 142   {
 143     ACE_OS::fprintf (out, "%s", ior);
 144     ACE_OS::fclose (out);
 145     result = 0;
 146   }
 147   else
 148   {
 149     ACE_ERROR ((LM_ERROR,
 150       "Open failed for %s\n", outputFile
 151     ));
 152   }
 153   return result;
 154 }
 155
 156 //////////////////////////////////////////////////////
 157 // FT_ReplicaFactory_i public, non-CORBA methods
 158
 159 int FT_ReplicaFactory_i::parse_args (int argc, ACE_TCHAR * argv[])
 160 {
 161   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("o:n:f:i:l:t:p:qu"));
 162   int c;
 163
 164   while ((c = get_opts ()) != -1)
 165   {
 166     switch (c)
 167     {
 168       case 'o':
 169       {
 170         this->ior_output_file_ = get_opts.opt_arg ();
 171         break;
 172       }
 173       case 'n':
 174       {
 175         this->ns_name_ = ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ());
 176         break;
 177       }
 178       case 'f':
 179       {
 180         this->factory_registry_ior_ = get_opts.opt_arg ();
 181         break;
 182       }
 183       case 'i':
 184       {
 185         this->roles_.push_back(ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ()));
 186         break;
 187       }
 188       case 'l':
 189       {
 190         this->location_ = ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ());
 191         break;
 192       }
 193       case 'q':
 194       {
 195         this->quit_on_idle_ = 1;
 196         break;
 197       }
 198       case 'u':
 199       {
 200         this->unregister_by_location_ = 1;
 201         break;
 202       }
 203
 204       case 't':
 205       {
 206         this->test_output_file_ = get_opts.opt_arg ();
 207         break;
 208       }
 209       case 'p':
 210       {
 211        this->name_persistent_file_ = get_opts.opt_arg ();
 212        break;
 213       }
 214
 215       case '?':
 216         // fall thru
 217       default:
 218         ACE_ERROR_RETURN ((LM_ERROR,
 219                            "usage:  %s\n"
 220                            " -o <factory ior file>\n"
 221                            " -n <naming service registration name>\n"
 222                            " -f <factory registry ior file>\n"
 223                            " -i <registration: role>\n"
 224                            " -l <registration: location>\n"
 225                            " -t <test replica ior file>\n"
 226                            " -p <name presistent file>\n"
 227                            " -u{nregister by location}\n"
 228                            " -q{uit on idle}\n",
 229                            argv [0]),
 230                           -1);
 231       break;
 232     }
 233   }
 234   // Indicates successful parsing of the command line
 235   return 0;
 236 }
 237
 238 const char * FT_ReplicaFactory_i::location () const
 239 {
 240   return this->location_.c_str ();
 241 }
 242
 243 const ACE_TCHAR * FT_ReplicaFactory_i::identity () const
 244 {
 245   return this->identity_.c_str();
 246 }
 247
 248 int FT_ReplicaFactory_i::idle (int & result)
 249 {
 250   result = 0;
 251   size_t replicaCount = this->replicas_.size();
 252   if (replicaCount != this->empty_slots_)
 253   {
 254     for (size_t nReplica = 0; result == 0 && nReplica < replicaCount; ++nReplica)
 255     {
 256       FT_TestReplica_i * replica = this->replicas_[nReplica];
 257       if (replica != 0)
 258       {
 259         // give the replica's idle processing a change
 260         // ignore the return status (the replica should shut itself down
 261         // unless result is non-zero.
 262         // non-zero result means panic.
 263         replica->idle(result);
 264       }
 265     }
 266   }
 267
 268   int quit = (this->quit_requested_ || result != 0);
 269   if (!quit && this->replicas_.size() == this->empty_slots_)
 270   {
 271 /*  if you re-enable this, add some kind of throttle to avoid noise.
 272     ACE_ERROR (( LM_ERROR,
 273       "ReplicaFactory is idle.\n"
 274       ));
 275 */
 276     if (this->quit_on_idle_ && this->empty_slots_ != 0)
 277     {
 278       ACE_ERROR (( LM_ERROR,
 279         "%s exits due to quit on idle option.\n",
 280         identity()
 281         ));
 282       quit = 1;
 283     }
 284   }
 285
 286   return quit;
 287 }
 288
 289
 290 int FT_ReplicaFactory_i::init (CORBA::ORB_ptr orb)
 291 {
 292   int result = 0;
 293
 294   this->orb_ = CORBA::ORB::_duplicate (orb);
 295
 296   // Use the ROOT POA for now
 297   CORBA::Object_var poa_object =
 298     this->orb_->resolve_initial_references (TAO_OBJID_ROOTPOA);
 299
 300   if (CORBA::is_nil (poa_object.in ()))
 301   {
 302     ACE_ERROR_RETURN ((LM_ERROR,
 303                        ACE_TEXT (" (%P|%t) Unable to initialize the POA.\n")),
 304                       -1);
 305   }
 306
 307   // Get the POA object.
 308   this->poa_ =
 309     PortableServer::POA::_narrow (poa_object.in ());
 310
 311   if (CORBA::is_nil(this->poa_.in ()))
 312   {
 313     ACE_ERROR_RETURN ((LM_ERROR,
 314                        ACE_TEXT (" (%P|%t) Unable to narrow the POA.\n")),
 315                       -1);
 316   }
 317
 318   PortableServer::POAManager_var poa_manager =
 319     this->poa_->the_POAManager ();
 320
 321   poa_manager->activate ();
 322
 323   // Register with the POA.
 324
 325   this->object_id_ = this->poa_->activate_object (this);
 326
 327   CORBA::Object_var this_obj =
 328     this->poa_->id_to_reference (object_id_.in ());
 329
 330   this->ior_ = this->orb_->object_to_string (this_obj.in ());
 331
 332   if (this->factory_registry_ior_ != 0)
 333   {
 334     if (ACE_OS::strcmp (this->factory_registry_ior_, ACE_TEXT("none")) != 0)
 335     {
 336       CORBA::Object_var reg_obj = this->orb_->string_to_object(factory_registry_ior_);
 337       this->factory_registry_ = ::PortableGroup::FactoryRegistry::_narrow(reg_obj.in ());
 338       if (CORBA::is_nil(this->factory_registry_.in ()))
 339       {
 340         ACE_ERROR (( LM_ERROR,
 341            "Can't resolve Factory Registry IOR %s\n",
 342            this->factory_registry_ior_
 343            ));
 344         result = -1;
 345       }
 346     }
 347   }
 348   else // no -f option.  Try RIR(RM)
 349   {
 350     ///////////////////////////////
 351     // Find the ReplicationManager
 352     try
 353     {
 354       CORBA::Object_var rm_obj = orb->resolve_initial_references("ReplicationManager");
 355       this->replication_manager_ = ::FT::ReplicationManager::_narrow(rm_obj.in());
 356       if (!CORBA::is_nil (replication_manager_.in ()))
 357       {
 358         this->have_replication_manager_ = 1;
 359         // empty criteria
 360         ::PortableGroup::Criteria criteria;
 361         this->factory_registry_ = this->replication_manager_->get_factory_registry(criteria);
 362         if (CORBA::is_nil (this->factory_registry_.in ()))
 363         {
 364           ACE_ERROR ((LM_ERROR,"ReplicaFactory: ReplicationManager failed to return FactoryRegistry.  Factory will not be registered.\n" ));
 365         }
 366       }
 367       else
 368       {
 369         this->factory_registry_ =  ::PortableGroup::FactoryRegistry::_narrow(rm_obj.in());
 370         if (!CORBA::is_nil(this->factory_registry_.in ()))
 371         {
 372           ACE_DEBUG ((LM_DEBUG,"Found a FactoryRegistry DBA ReplicationManager\n" ));
 373         }
 374         else
 375         {
 376           ACE_ERROR ((LM_ERROR,"ReplicaFactory: Can't resolve ReplicationManager.\n" ));
 377         }
 378       }
 379     }
 380     catch (const CORBA::Exception& ex)
 381     {
 382       if (this->test_output_file_ == 0) // ignore if this is a test run
 383       {
 384         ex._tao_print_exception (
 385           "ReplicaFactory: Exception resolving ReplicationManager. Factory will not be registered.\n");
 386       }
 387     }
 388
 389   }
 390
 391   if ( ! CORBA::is_nil (this->factory_registry_.in ()))
 392   {
 393     size_t roleCount = roles_.size();
 394     for (size_t nRole = 0; nRole < roleCount; ++nRole)
 395     {
 396       const char * roleName = this->roles_[nRole].c_str();
 397
 398       PortableGroup::FactoryInfo info;
 399       info.the_factory = ::PortableGroup::GenericFactory::_narrow(this_obj.in ());
 400       info.the_location.length(1);
 401       info.the_location[0].id = CORBA::string_dup(this->location_.c_str ());
 402       info.the_criteria.length(1);
 403       info.the_criteria[0].nam.length(1);
 404       info.the_criteria[0].nam[0].id = CORBA::string_dup(PortableGroup::role_criterion);
 405       info.the_criteria[0].val <<= CORBA::string_dup(roleName);
 406
 407       ACE_ERROR (( LM_INFO,
 408          "Factory: %s@%C registering with factory registry\n",
 409          roleName,
 410          location_.c_str ()
 411          ));
 412
 413       char const * replica_repository_id =
 414         FT_TEST::_tc_TestReplica->id ();
 415
 416       this->factory_registry_->register_factory(
 417         roleName,
 418         replica_repository_id,
 419         info);
 420     }
 421     this->registered_ = 1;
 422   }
 423
 424   int identified = 0; // bool
 425
 426   if (this->roles_.size() > 0)
 427   {
 428     this->identity_ = ACE_TEXT("Factory");
 429     if (this->location_.length () != 0)
 430     {
 431       this->identity_ += ACE_TEXT("@");
 432       this->identity_ += ACE_TEXT_CHAR_TO_TCHAR(this->location_.c_str ());
 433     }
 434     identified = 1;
 435   }
 436
 437   if (this->ior_output_file_ != 0)
 438   {
 439     if (!identified)
 440     {
 441       this->identity_ = ACE_TEXT("file:");
 442       this->identity_ += this->ior_output_file_;
 443       // note: don't set identified--ns identity overrides file identitiy
 444     }
 445     result = write_ior (this->ior_output_file_, this->ior_. in ());
 446   }
 447   else
 448   {
 449     if (this->registered_)
 450     {
 451       // if we didn't register with a FactoryRegistry
 452       // and no IOR file specified,
 453       // then always try to register with name service
 454       this->ns_name_ = "FT_ReplicaFactory";
 455     }
 456   }
 457
 458   if (this->ns_name_.length () != 0)
 459   {
 460     if (!identified)
 461     {
 462       this->identity_ = ACE_TEXT("name:");
 463       this->identity_ += ACE_TEXT_CHAR_TO_TCHAR(this->ns_name_.c_str ());
 464     }
 465
 466     CORBA::Object_var naming_obj =
 467       this->orb_->resolve_initial_references ("NameService");
 468
 469     if (CORBA::is_nil(naming_obj.in ())){
 470       ACE_ERROR_RETURN ((LM_ERROR,
 471                          "%T %n (%P|%t) Unable to find the Naming Service\n"),
 472                         1);
 473     }
 474
 475     this->naming_context_ =
 476       CosNaming::NamingContext::_narrow (naming_obj.in ());
 477
 478     this->this_name_.length (1);
 479     this->this_name_[0].id = CORBA::string_dup (this->ns_name_.c_str ());
 480
 481     this->naming_context_->rebind (this->this_name_, this_obj.in());
 482   }
 483
 484   // if we're testing.  Create a replica at startup time
 485   if (this->test_output_file_ != 0)
 486   {
 487     // shouldn't be necessary, but create_replica assumes this
 488     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->internals_, 1);
 489     FT_TestReplica_i * replica = create_replica ("test");
 490
 491     PortableServer::POA_var poa = replica->_default_POA ();
 492     ::CORBA::Object_var replica_obj = poa->servant_to_reference(replica);
 493     ::CORBA::String_var replicaIOR = this->orb_->object_to_string(replica_obj.in ());
 494     write_ior (this->test_output_file_, replicaIOR.in ());
 495   }
 496
 497   return result;
 498 }
 499
 500 int FT_ReplicaFactory_i::fini ()
 501 {
 502   if (this->ior_output_file_ != 0)
 503   {
 504     ACE_OS::unlink (this->ior_output_file_);
 505     this->ior_output_file_ = 0;
 506   }
 507   if (this->ns_name_.length () != 0)
 508   {
 509     this->naming_context_->unbind (this_name_);
 510     this->ns_name_.clear ();
 511   }
 512
 513   if (registered_)
 514   {
 515     registered_ = 0;
 516
 517     if (this->unregister_by_location_)
 518     {
 519       ACE_ERROR (( LM_INFO,
 520          "%s: unregistering all factories at %C\n",
 521          identity(),
 522          location_.c_str ()
 523          ));
 524
 525       PortableGroup::Location location(1);
 526       location.length(1);
 527       location[0].id = CORBA::string_dup(location_.c_str ());
 528       this->factory_registry_->unregister_factory_by_location (
 529               location);
 530     }
 531     else
 532     {
 533       size_t roleCount = roles_.size();
 534       for (size_t nRole = 0; nRole < roleCount; ++nRole)
 535       {
 536         const char * roleName = this->roles_[nRole].c_str();
 537         ACE_ERROR (( LM_INFO,
 538            "Factory for: %s@%C unregistering from factory registry\n",
 539            roleName,
 540            location_.c_str ()
 541            ));
 542
 543         PortableGroup::Location location(1);
 544         location.length(1);
 545         location[0].id = CORBA::string_dup(location_.c_str ());
 546         this->factory_registry_->unregister_factory (
 547                 roleName,
 548                 location);
 549       }
 550     }
 551   }
 552
 553   return 0;
 554 }
 555
 556
 557 void FT_ReplicaFactory_i::remove_replica(CORBA::ULong id, FT_TestReplica_i * replica)
 558 {
 559   ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
 560   if (id < this->replicas_.size())
 561   {
 562     if(this->replicas_[id] == replica)
 563     {
 564       replica->fini();
 565       delete replica;
 566       this->replicas_[id] = 0;
 567       this->empty_slots_ += 1;
 568     }
 569     else
 570     {
 571       ACE_ERROR (( LM_ERROR,
 572         "Remove replica %d mismatch.\n",
 573         static_cast<int> (id)
 574         ));
 575     }
 576   }
 577   else
 578   {
 579     ACE_ERROR (( LM_ERROR,
 580       "Attempt to remove invalid replica %d. Limit %d.\n",
 581       static_cast<int> (id),
 582       static_cast<int> (this->replicas_.size())
 583       ));
 584   }
 585 }
 586
 587 //////////////////////////////////////////
 588 // FT_ReplicaFactory_i CORBA methods
 589
 590 CORBA::Object_ptr FT_ReplicaFactory_i::create_object (
 591     const char * type_id,
 592     const PortableGroup::Criteria & the_criteria,
 593     PortableGroup::GenericFactory::FactoryCreationId_out factory_creation_id)
 594 {
 595   METHOD_ENTRY(FT_ReplicaFactory_i::create_object);
 596   ACE_UNUSED_ARG (type_id);
 597   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->internals_, CORBA::Object::_nil ());
 598
 599   ::TAO::PG_Property_Set decoder (the_criteria);
 600
 601   // boolean, becomes true if a required parameter is missing
 602   int missingParameter = 0;
 603   const char * missingParameterName = 0;
 604
 605   CORBA::Long initialValue = 0;
 606   if (! ::TAO::find (decoder, criterion_initial_value, initialValue) )
 607   {
 608     // not required.  Otherwise:
 609     // missingParameter = 1;
 610     // missingParameterName = criterion_initial_value;
 611   }
 612
 613   const char * role = "replica";
 614   if (! ::TAO::find (decoder, PortableGroup::role_criterion, role) )
 615   {
 616     ACE_ERROR((LM_INFO,
 617       "Property \"%s\" not found?\n", PortableGroup::role_criterion
 618       ));
 619     // not required.  Otherwise:
 620     // missingParameter = 1;
 621     // missingParameterName = PortableGroup::role_criterion;
 622   }
 623
 624   if (missingParameter)
 625   {
 626     ACE_ERROR ((LM_ERROR,
 627       "Throwing 'InvalidCriteria' due to missing %s\n",
 628       missingParameterName
 629       ));
 630     throw PortableGroup::InvalidCriteria();
 631   }
 632
 633   FT_TestReplica_i * replica = create_replica(role);
 634   if (replica == 0)
 635   {
 636     ACE_ERROR ((LM_ERROR,
 637       "New Replica_i returned NULL.  Throwing ObjectNotCreated.\n"
 638       ));
 639     throw PortableGroup::ObjectNotCreated();
 640   }
 641
 642   ACE_NEW_THROW_EX ( factory_creation_id,
 643     PortableGroup::GenericFactory::FactoryCreationId,
 644     PortableGroup::ObjectNotCreated());
 645   CORBA::ULong factory_id = replica->factory_id();
 646   (*factory_creation_id) <<= factory_id;
 647
 648   ACE_ERROR ((LM_INFO,
 649     "Created %s@%C#%d.\n", role, this->location_.c_str (), static_cast<int> (factory_id)
 650     ));
 651
 652
 653   ::CORBA::Object_ptr replica_obj =
 654     replica->_default_POA()->servant_to_reference(replica);
 655   METHOD_RETURN(FT_ReplicaFactory_i::create_object) replica_obj->_duplicate(replica_obj);
 656 }
 657
 658 FT_TestReplica_i * FT_ReplicaFactory_i::create_replica(const char * name)
 659 {
 660   // assume mutex is locked
 661   CORBA::ULong factoryId = allocate_id();
 662
 663   FT_TestReplica_i * pFTReplica = 0;
 664
 665   ACE_NEW_NORETURN(pFTReplica, FT_TestReplica_i(
 666     this,
 667     name,
 668     factoryId
 669     ));
 670
 671   this->replicas_[factoryId] = pFTReplica;
 672   this->empty_slots_ -= 1;
 673
 674   pFTReplica->init (this->orb_, this->name_persistent_file_);
 675   return pFTReplica;
 676 }
 677
 678 void FT_ReplicaFactory_i::delete_object (
 679     const PortableGroup::GenericFactory::FactoryCreationId & factory_creation_id)
 680 {
 681   METHOD_ENTRY(FT_ReplicaFactory_i::delete_object);
 682
 683   ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
 684
 685   CORBA::ULong factoryId;
 686   factory_creation_id >>= factoryId;
 687   if (factoryId < this->replicas_.size())
 688   {
 689     if(this->replicas_[factoryId] != 0)
 690     {
 691       this->replicas_[factoryId]->request_quit();
 692     }
 693     else
 694     {
 695       throw ::PortableGroup::ObjectNotFound();
 696     }
 697   }
 698   else
 699   {
 700     throw ::PortableGroup::ObjectNotFound();
 701   }
 702   METHOD_RETURN(FT_ReplicaFactory_i::delete_object);
 703 }
 704
 705 CORBA::Boolean FT_ReplicaFactory_i::is_alive ()
 706 {
 707   METHOD_RETURN(FT_ReplicaFactory_i::is_alive)
 708     true;
 709 }
 710
 711 void FT_ReplicaFactory_i::shutdown ()
 712 {
 713   METHOD_ENTRY(FT_FaultDetectorFactory_i::shutdown);
 714   ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
 715   shutdown_i ();
 716   this->quit_requested_ = 1;
 717   METHOD_RETURN(FT_FaultDetectorFactory_i::shutdown);
 718 }