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
 291 int FT_ReplicaFactory_i::init (CORBA::ORB_ptr orb)
 292 {
 293   int result = 0;
 294
 295   this->orb_ = CORBA::ORB::_duplicate (orb);
 296
 297   // Use the ROOT POA for now
 298   CORBA::Object_var poa_object =
 299     this->orb_->resolve_initial_references (TAO_OBJID_ROOTPOA);
 300
 301   if (CORBA::is_nil (poa_object.in ()))
 302   {
 303     ACE_ERROR_RETURN ((LM_ERROR,
 304                        ACE_TEXT (" (%P|%t) Unable to initialize the POA.\n")),
 305                       -1);
 306   }
 307
 308   // Get the POA object.
 309   this->poa_ =
 310     PortableServer::POA::_narrow (poa_object.in ());
 311
 312   if (CORBA::is_nil(this->poa_.in ()))
 313   {
 314     ACE_ERROR_RETURN ((LM_ERROR,
 315                        ACE_TEXT (" (%P|%t) Unable to narrow the POA.\n")),
 316                       -1);
 317   }
 318
 319   PortableServer::POAManager_var poa_manager =
 320     this->poa_->the_POAManager ();
 321
 322   poa_manager->activate ();
 323
 324   // Register with the POA.
 325
 326   this->object_id_ = this->poa_->activate_object (this);
 327
 328   CORBA::Object_var this_obj =
 329     this->poa_->id_to_reference (object_id_.in ());
 330
 331   this->ior_ = this->orb_->object_to_string (this_obj.in ());
 332
 333   if (this->factory_registry_ior_ != 0)
 334   {
 335     if (ACE_OS::strcmp (this->factory_registry_ior_, ACE_TEXT("none")) != 0)
 336     {
 337       CORBA::Object_var reg_obj = this->orb_->string_to_object(factory_registry_ior_);
 338       this->factory_registry_ = ::PortableGroup::FactoryRegistry::_narrow(reg_obj.in ());
 339       if (CORBA::is_nil(this->factory_registry_.in ()))
 340       {
 341         ACE_ERROR (( LM_ERROR,
 342            "Can't resolve Factory Registry IOR %s\n",
 343            this->factory_registry_ior_
 344            ));
 345         result = -1;
 346       }
 347     }
 348   }
 349   else // no -f option.  Try RIR(RM)
 350   {
 351     ///////////////////////////////
 352     // Find the ReplicationManager
 353     try
 354     {
 355       CORBA::Object_var rm_obj = orb->resolve_initial_references("ReplicationManager");
 356       this->replication_manager_ = ::FT::ReplicationManager::_narrow(rm_obj.in());
 357       if (!CORBA::is_nil (replication_manager_.in ()))
 358       {
 359         this->have_replication_manager_ = 1;
 360         // empty criteria
 361         ::PortableGroup::Criteria criteria;
 362         this->factory_registry_ = this->replication_manager_->get_factory_registry(criteria);
 363         if (CORBA::is_nil (this->factory_registry_.in ()))
 364         {
 365           ACE_ERROR ((LM_ERROR,"ReplicaFactory: ReplicationManager failed to return FactoryRegistry.  Factory will not be registered.\n" ));
 366         }
 367       }
 368       else
 369       {
 370         this->factory_registry_ =  ::PortableGroup::FactoryRegistry::_narrow(rm_obj.in());
 371         if (!CORBA::is_nil(this->factory_registry_.in ()))
 372         {
 373           ACE_DEBUG ((LM_DEBUG,"Found a FactoryRegistry DBA ReplicationManager\n" ));
 374         }
 375         else
 376         {
 377           ACE_ERROR ((LM_ERROR,"ReplicaFactory: Can't resolve ReplicationManager.\n" ));
 378         }
 379       }
 380     }
 381     catch (const CORBA::Exception& ex)
 382     {
 383       if (this->test_output_file_ == 0) // ignore if this is a test run
 384       {
 385         ex._tao_print_exception (
 386           "ReplicaFactory: Exception resolving ReplicationManager. Factory will not be registered.\n");
 387       }
 388     }
 389
 390   }
 391
 392   if ( ! CORBA::is_nil (this->factory_registry_.in ()))
 393   {
 394     size_t roleCount = roles_.size();
 395     for (size_t nRole = 0; nRole < roleCount; ++nRole)
 396     {
 397       const char * roleName = this->roles_[nRole].c_str();
 398
 399       PortableGroup::FactoryInfo info;
 400       info.the_factory = ::PortableGroup::GenericFactory::_narrow(this_obj.in ());
 401       info.the_location.length(1);
 402       info.the_location[0].id = CORBA::string_dup(this->location_.c_str ());
 403       info.the_criteria.length(1);
 404       info.the_criteria[0].nam.length(1);
 405       info.the_criteria[0].nam[0].id = CORBA::string_dup(PortableGroup::role_criterion);
 406       info.the_criteria[0].val <<= CORBA::string_dup(roleName);
 407
 408       ACE_ERROR (( LM_INFO,
 409          "Factory: %s@%C registering with factory registry\n",
 410          roleName,
 411          location_.c_str ()
 412          ));
 413
 414       char const * replica_repository_id =
 415         FT_TEST::_tc_TestReplica->id ();
 416
 417       this->factory_registry_->register_factory(
 418         roleName,
 419         replica_repository_id,
 420         info);
 421     }
 422     this->registered_ = 1;
 423   }
 424
 425   int identified = 0; // bool
 426
 427   if (this->roles_.size() > 0)
 428   {
 429     this->identity_ = ACE_TEXT("Factory");
 430     if (this->location_.length () != 0)
 431     {
 432       this->identity_ += ACE_TEXT("@");
 433       this->identity_ += ACE_TEXT_CHAR_TO_TCHAR(this->location_.c_str ());
 434     }
 435     identified = 1;
 436   }
 437
 438   if (this->ior_output_file_ != 0)
 439   {
 440     if (!identified)
 441     {
 442       this->identity_ = ACE_TEXT("file:");
 443       this->identity_ += this->ior_output_file_;
 444       // note: don't set identified--ns identity overrides file identitiy
 445     }
 446     result = write_ior (this->ior_output_file_, this->ior_. in ());
 447   }
 448   else
 449   {
 450     if (this->registered_)
 451     {
 452       // if we didn't register with a FactoryRegistry
 453       // and no IOR file specified,
 454       // then always try to register with name service
 455       this->ns_name_ = "FT_ReplicaFactory";
 456     }
 457   }
 458
 459   if (this->ns_name_.length () != 0)
 460   {
 461     if (!identified)
 462     {
 463       this->identity_ = ACE_TEXT("name:");
 464       this->identity_ += ACE_TEXT_CHAR_TO_TCHAR(this->ns_name_.c_str ());
 465     }
 466
 467     CORBA::Object_var naming_obj =
 468       this->orb_->resolve_initial_references ("NameService");
 469
 470     if (CORBA::is_nil(naming_obj.in ())){
 471       ACE_ERROR_RETURN ((LM_ERROR,
 472                          "%T %n (%P|%t) Unable to find the Naming Service\n"),
 473                         1);
 474     }
 475
 476     this->naming_context_ =
 477       CosNaming::NamingContext::_narrow (naming_obj.in ());
 478
 479     this->this_name_.length (1);
 480     this->this_name_[0].id = CORBA::string_dup (this->ns_name_.c_str ());
 481
 482     this->naming_context_->rebind (this->this_name_, this_obj.in());
 483   }
 484
 485   // if we're testing.  Create a replica at startup time
 486   if (this->test_output_file_ != 0)
 487   {
 488     // shouldn't be necessary, but create_replica assumes this
 489     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->internals_, 1);
 490     FT_TestReplica_i * replica = create_replica ("test");
 491
 492     PortableServer::POA_var poa = replica->_default_POA ();
 493     ::CORBA::Object_var replica_obj = poa->servant_to_reference(replica);
 494     ::CORBA::String_var replicaIOR = this->orb_->object_to_string(replica_obj.in ());
 495     write_ior (this->test_output_file_, replicaIOR.in ());
 496   }
 497
 498   return result;
 499 }
 500
 501 int FT_ReplicaFactory_i::fini (void)
 502 {
 503   if (this->ior_output_file_ != 0)
 504   {
 505     ACE_OS::unlink (this->ior_output_file_);
 506     this->ior_output_file_ = 0;
 507   }
 508   if (this->ns_name_.length () != 0)
 509   {
 510     this->naming_context_->unbind (this_name_);
 511     this->ns_name_.clear ();
 512   }
 513
 514   if (registered_)
 515   {
 516     registered_ = 0;
 517
 518     if (this->unregister_by_location_)
 519     {
 520       ACE_ERROR (( LM_INFO,
 521          "%s: unregistering all factories at %C\n",
 522          identity(),
 523          location_.c_str ()
 524          ));
 525
 526       PortableGroup::Location location(1);
 527       location.length(1);
 528       location[0].id = CORBA::string_dup(location_.c_str ());
 529       this->factory_registry_->unregister_factory_by_location (
 530               location);
 531     }
 532     else
 533     {
 534       size_t roleCount = roles_.size();
 535       for (size_t nRole = 0; nRole < roleCount; ++nRole)
 536       {
 537         const char * roleName = this->roles_[nRole].c_str();
 538         ACE_ERROR (( LM_INFO,
 539            "Factory for: %s@%C unregistering from factory registry\n",
 540            roleName,
 541            location_.c_str ()
 542            ));
 543
 544         PortableGroup::Location location(1);
 545         location.length(1);
 546         location[0].id = CORBA::string_dup(location_.c_str ());
 547         this->factory_registry_->unregister_factory (
 548                 roleName,
 549                 location);
 550       }
 551     }
 552   }
 553
 554   return 0;
 555 }
 556
 557
 558 void FT_ReplicaFactory_i::remove_replica(CORBA::ULong id, FT_TestReplica_i * replica)
 559 {
 560   ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
 561   if (id < this->replicas_.size())
 562   {
 563     if(this->replicas_[id] == replica)
 564     {
 565       replica->fini();
 566       delete replica;
 567       this->replicas_[id] = 0;
 568       this->empty_slots_ += 1;
 569     }
 570     else
 571     {
 572       ACE_ERROR (( LM_ERROR,
 573         "Remove replica %d mismatch.\n",
 574         static_cast<int> (id)
 575         ));
 576     }
 577   }
 578   else
 579   {
 580     ACE_ERROR (( LM_ERROR,
 581       "Attempt to remove invalid replica %d. Limit %d.\n",
 582       static_cast<int> (id),
 583       static_cast<int> (this->replicas_.size())
 584       ));
 585   }
 586 }
 587
 588 //////////////////////////////////////////
 589 // FT_ReplicaFactory_i CORBA methods
 590
 591 CORBA::Object_ptr FT_ReplicaFactory_i::create_object (
 592     const char * type_id,
 593     const PortableGroup::Criteria & the_criteria,
 594     PortableGroup::GenericFactory::FactoryCreationId_out factory_creation_id)
 595 {
 596   METHOD_ENTRY(FT_ReplicaFactory_i::create_object);
 597   ACE_UNUSED_ARG (type_id);
 598   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->internals_, CORBA::Object::_nil ());
 599
 600   ::TAO::PG_Property_Set decoder (the_criteria);
 601
 602   // boolean, becomes true if a required parameter is missing
 603   int missingParameter = 0;
 604   const char * missingParameterName = 0;
 605
 606   CORBA::Long initialValue = 0;
 607   if (! ::TAO::find (decoder, criterion_initial_value, initialValue) )
 608   {
 609     // not required.  Otherwise:
 610     // missingParameter = 1;
 611     // missingParameterName = criterion_initial_value;
 612   }
 613
 614   const char * role = "replica";
 615   if (! ::TAO::find (decoder, PortableGroup::role_criterion, role) )
 616   {
 617     ACE_ERROR((LM_INFO,
 618       "Property \"%s\" not found?\n", PortableGroup::role_criterion
 619       ));
 620     // not required.  Otherwise:
 621     // missingParameter = 1;
 622     // missingParameterName = PortableGroup::role_criterion;
 623   }
 624
 625   if (missingParameter)
 626   {
 627     ACE_ERROR ((LM_ERROR,
 628       "Throwing 'InvalidCriteria' due to missing %s\n",
 629       missingParameterName
 630       ));
 631     throw PortableGroup::InvalidCriteria();
 632   }
 633
 634   FT_TestReplica_i * replica = create_replica(role);
 635   if (replica == 0)
 636   {
 637     ACE_ERROR ((LM_ERROR,
 638       "New Replica_i returned NULL.  Throwing ObjectNotCreated.\n"
 639       ));
 640     throw PortableGroup::ObjectNotCreated();
 641   }
 642
 643   ACE_NEW_THROW_EX ( factory_creation_id,
 644     PortableGroup::GenericFactory::FactoryCreationId,
 645     PortableGroup::ObjectNotCreated());
 646   CORBA::ULong factory_id = replica->factory_id();
 647   (*factory_creation_id) <<= factory_id;
 648
 649   ACE_ERROR ((LM_INFO,
 650     "Created %s@%C#%d.\n", role, this->location_.c_str (), static_cast<int> (factory_id)
 651     ));
 652
 653
 654   ::CORBA::Object_ptr replica_obj =
 655     replica->_default_POA()->servant_to_reference(replica);
 656   METHOD_RETURN(FT_ReplicaFactory_i::create_object) replica_obj->_duplicate(replica_obj);
 657 }
 658
 659 FT_TestReplica_i * FT_ReplicaFactory_i::create_replica(const char * name)
 660 {
 661   // assume mutex is locked
 662   CORBA::ULong factoryId = allocate_id();
 663
 664   FT_TestReplica_i * pFTReplica = 0;
 665
 666   ACE_NEW_NORETURN(pFTReplica, FT_TestReplica_i(
 667     this,
 668     name,
 669     factoryId
 670     ));
 671
 672   this->replicas_[factoryId] = pFTReplica;
 673   this->empty_slots_ -= 1;
 674
 675   pFTReplica->init (this->orb_, this->name_persistent_file_);
 676   return pFTReplica;
 677 }
 678
 679 void FT_ReplicaFactory_i::delete_object (
 680     const PortableGroup::GenericFactory::FactoryCreationId & factory_creation_id)
 681 {
 682   METHOD_ENTRY(FT_ReplicaFactory_i::delete_object);
 683
 684   ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
 685
 686   CORBA::ULong factoryId;
 687   factory_creation_id >>= factoryId;
 688   if (factoryId < this->replicas_.size())
 689   {
 690     if(this->replicas_[factoryId] != 0)
 691     {
 692       this->replicas_[factoryId]->request_quit();
 693     }
 694     else
 695     {
 696       throw ::PortableGroup::ObjectNotFound();
 697     }
 698   }
 699   else
 700   {
 701     throw ::PortableGroup::ObjectNotFound();
 702   }
 703   METHOD_RETURN(FT_ReplicaFactory_i::delete_object);
 704 }
 705
 706 CORBA::Boolean FT_ReplicaFactory_i::is_alive (void)
 707 {
 708   METHOD_RETURN(FT_ReplicaFactory_i::is_alive)
 709     true;
 710 }
 711
 712 void FT_ReplicaFactory_i::shutdown (void)
 713 {
 714   METHOD_ENTRY(FT_FaultDetectorFactory_i::shutdown);
 715   ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->internals_);
 716   shutdown_i ();
 717   this->quit_requested_ = 1;
 718   METHOD_RETURN(FT_FaultDetectorFactory_i::shutdown);
 719 }