/**
* Register this object.
*/
int ReplicationManagerFaultConsumerAdapter::init (
CORBA::ORB_ptr orb)
{
ACE_DEBUG ((
LM_DEBUG,
ACE_TEXT ("Entered ReplicationManagerFaultConsumerAdapter::init.\n")
));
int result = 0;
this->orb_ = CORBA::ORB::_duplicate (orb);
//////////////////////////////////////////
// resolve reference to detector factory
ACE_DEBUG ((
LM_DEBUG,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("Getting ready to read iorDetectorFile.\n")
));
CORBA::Object_var detector_obj = this->orb_->string_to_object (
this->detector_ior_);
this->factory_ = ::FT::FaultDetectorFactory::_narrow (
detector_obj.in());
if (CORBA::is_nil (this->factory_.in()))
{
ACE_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("FaultDetectorFactory IOR is nil: %s\n"),
this->detector_ior_),
-1);
}
//////////////////////////////////////////
// resolve references to notifier
ACE_DEBUG ((
LM_DEBUG,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("Getting ready to read Notifier IOR file.\n")
));
CORBA::Object_var notifier_ior = this->orb_->string_to_object (
this->notifier_ior_);
this->notifier_ = ::FT::FaultNotifier::_narrow (
notifier_ior.in());
if (CORBA::is_nil (this->notifier_.in()))
{
ACE_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("FaultNotifier IOR is nil: %s\n"),
this->notifier_ior_),
-1);
}
// Create the real FaultConsumer.
//
// Note: We have to hang onto the servant class pointer so we can
// invoke member functions on it, but we also give ownership of it
// to a PortableServer::ServantBase_var.
ACE_DEBUG ((
LM_DEBUG,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("Getting ready to create the real FaultConsumer.\n")
));
ACE_NEW_RETURN (this->p_fault_consumer_, TAO::FT_FaultConsumer (), -1);
if (this->p_fault_consumer_ != 0)
{
this->consumer_servant_ = this->p_fault_consumer_;
}
//////////////////////////
// Get ready to initialize the consumer. We need to provide it
// with the following:
// - The POA in which it is to be activated.
// - FT::FaultNotifier IOR.
// - FT::ReplicationManager IOR (fake it for now).
// Get the RootPOA from the ORB.
CORBA::Object_var poa_obj = this->orb_->resolve_initial_references (
"RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (
poa_obj.in());
// Create a fault analyzer.
TAO::FT_FaultAnalyzer * analyzer = 0;
ACE_NEW_RETURN (analyzer, TAO::FT_DefaultFaultAnalyzer (), -1);
// Initialize the FaultConsumer.
// It will activate itself in the POA we pass it and connect to the
// Fault Notifier we pass it.
ACE_DEBUG ((
LM_DEBUG,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("Getting ready to initialize the real FaultConsumer.\n")
));
result = this->p_fault_consumer_->init (
poa.in(),
this->notifier_.in(),
analyzer);
if (result != 0)
{
ACE_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("Unable to initialize the real FaultConsumer.\n")),
result);
}
this->identity_ = "ReplicationManagerFaultConsumerAdapter";
// Activate the RootPOA.
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
/////////////////////////
// Set up fault detectors
if (result == 0)
{
////////////////////////////////////
// resolve references to replicas
// create a fault detector for each replica
size_t replicaCount = this->replica_iors_.size();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Number of replicas being monitored: (%u)\n"),
static_cast<unsigned int> (replicaCount)
));
for (size_t nRep = 0; result == 0 && nRep < replicaCount; ++nRep)
{
const char * iorName = this->replica_iors_[nRep];
CORBA::Object_var replica_obj = this->orb_->string_to_object (
iorName);
FT::PullMonitorable_var replica = FT::PullMonitorable::_narrow (
replica_obj.in());
if (CORBA::is_nil(replica.in()))
{
ACE_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("Can't resolve Replica IOR: %s\n"),
iorName),
-1);
}
else
{
this->replicas_.push_back(replica);
CORBA::String_var type_id = CORBA::string_dup("FaultDetector");
TAO_PG::Properties_Encoder encoder;
PortableGroup::Value value;
value <<= notifier_.in ();
encoder.add(::FT::FT_NOTIFIER, value);
value <<= replica.in ();
encoder.add(::FT::FT_MONITORABLE, value);
FT::FTDomainId domain_id = 0;
value <<= domain_id;
encoder.add(::FT::FT_DOMAIN_ID, value);
PortableGroup::Location object_location;
object_location.length(2);
object_location[0].id = CORBA::string_dup("test");
object_location[1].id = CORBA::string_dup("Location_A");
value <<= object_location;
encoder.add(::FT::FT_LOCATION, value);
PortableGroup::TypeId_var object_type = CORBA::string_dup (
"IDL:org.omg/CosNaming/NamingContextExt:1.0");
value <<= object_type.in ();
encoder.add(::FT::FT_TYPE_ID, value);
PortableGroup::ObjectGroupId group_id =
static_cast<PortableGroup::ObjectGroupId> (6191982);
value <<= group_id;
encoder.add(::FT::FT_GROUP_ID, value);
// allocate and populate the criteria
PortableGroup::Criteria_var criteria;
ACE_NEW_NORETURN (criteria,
PortableGroup::Criteria);
if (criteria.ptr() == 0)
{
ACE_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("ReplicationManagerFaultConsumerAdapter::init: ")
ACE_TEXT ("Error cannot allocate criteria.\n")),
-1);
}
else
{
encoder.encode(criteria);
PortableGroup::GenericFactory::FactoryCreationId_var factory_creation_id;
this->factory_->create_object (
type_id.in(),
criteria.in(),
factory_creation_id);
}
}
}
// Signal that we are ready to go.
if (result == 0 && this->readyFile_ != 0)
{
FILE* ready = ACE_OS::fopen (this->readyFile_, "w");
if (ready)
{
ACE_OS::fprintf (ready, "ready\n");
ACE_OS::fclose (ready);
}
}
}
return result;
}
int TAO::Object_Group_Creator::create_detector_for_replica (
CORBA::Object_ptr replica,
const char * role,
const char * type_id,
PortableGroup::ObjectGroupId group_id,
const PortableGroup::Location & location)
{
int result = 0;
if (this->have_replication_manager_)
{
CORBA::ULong detector_count = this->detector_infos_->length ();
for (CORBA::ULong n_detector = 0; result == 0 && n_detector < detector_count; ++n_detector)
{
PortableGroup::FactoryInfo & info = (*this->detector_infos_)[n_detector];
if ( info.the_location == location || n_detector + 1 == detector_count)
{
TAO_PG::Properties_Encoder encoder;
PortableGroup::Value value;
FT::PullMonitorable_ptr monitorable = FT::PullMonitorable::_narrow (replica);
value <<= monitorable;
encoder.add (::FT::FT_MONITORABLE, value);
FT::FTDomainId domain_id = 0;
value <<= domain_id;
encoder.add (::FT::FT_DOMAIN_ID, value);
value <<= location;
encoder.add (::FT::FT_LOCATION, value);
value <<= type_id;
encoder.add (::FT::FT_TYPE_ID, value);
value <<= group_id;
encoder.add (::FT::FT_GROUP_ID, value);
value <<= CORBA::string_dup (role);
encoder.add (PortableGroup::role_criterion, value);
// allocate and populate the criteria
PortableGroup::Criteria_var criteria;
ACE_NEW_NORETURN (criteria,
PortableGroup::Criteria);
if (criteria.ptr () == 0)
{
ACE_ERROR ( (LM_ERROR,
"%T %n (%P|%t)Object_Group_Creater: Error cannot allocate criteria.\n"
));
result = -1;
}
else
{
encoder.encode (criteria);
PortableGroup::GenericFactory::FactoryCreationId_var factory_creation_id;
info.the_factory->create_object (
type_id,
criteria.in (),
factory_creation_id);
result = 1;
}
}
}
}
return result;
}
/**
* Register this object as necessary
*/
int StubFaultAnalyzer::init (CORBA::ORB_ptr orb)
{
int result = 0;
this->orb_ = CORBA::ORB::_duplicate (orb);
//////////////////////////////////////////
// resolve reference to detector factory
CORBA::Object_var detector_obj = this->orb_->string_to_object(this->detector_ior_);
this->factory_ = ::FT::FaultDetectorFactory::_narrow(detector_obj.in ());
if (CORBA::is_nil(this->factory_.in ()))
{
ACE_OS::fprintf (stderr, "Can't resolve Detector Factory IOR %s\n",
ACE_TEXT_ALWAYS_CHAR (this->detector_ior_));
result = -1;
}
//////////////////////////////////////////
// resolve references to notifier
CORBA::Object_var not_obj = this->orb_->string_to_object(this->notifier_ior_);
this->notifier_ = ::FT::FaultNotifier::_narrow(not_obj.in ());
if (CORBA::is_nil(this->notifier_.in ()))
{
ACE_OS::fprintf (stderr, "Can't resolve Notifier IOR %s\n",
ACE_TEXT_ALWAYS_CHAR (this->notifier_ior_));
result = -1;
}
//////////////////////////////////
// register fault consumers
if (result == 0)
{
result = this->faultConsumer_.init (orb, this->notifier_);
}
if (result == 0)
{
result = this->batchConsumer_.init (orb, this->notifier_);
}
/////////////////////////
// Set up fault detectors
if (result == 0)
{
////////////////////////////////////
// resolve references to replicas
// create a fault detector for each replica
size_t replicaCount = this->replicaIORs.size();
for(size_t nRep = 0; result == 0 && nRep < replicaCount; ++nRep)
{
const char * iorName = this->replicaIORs[nRep];
CORBA::Object_var rep_obj = this->orb_->string_to_object(iorName);
FT::PullMonitorable_var replica = FT::PullMonitorable::_narrow(rep_obj.in ());
if (CORBA::is_nil(replica.in ()))
{
ACE_OS::fprintf (stderr, "Can't resolve Replica IOR %s\n", iorName);
result = -1;
}
else
{
this->replicas_.push_back(replica);
CORBA::String_var type_id = CORBA::string_dup("FaultDetector");
TAO_PG::Properties_Encoder encoder;
PortableGroup::Value value;
value <<= this->notifier_.in ();
encoder.add(::FT::FT_NOTIFIER, value);
value <<= replica.in ();
encoder.add(::FT::FT_MONITORABLE, value);
FT::FTDomainId domain_id = 0;
value <<= domain_id;
encoder.add(::FT::FT_DOMAIN_ID, value);
PortableGroup::Location object_location;
object_location.length(1);
object_location[0].id = CORBA::string_dup("Test location");
value <<= object_location;
encoder.add(::FT::FT_LOCATION, value);
PortableGroup::TypeId object_type = CORBA::string_dup("dummy_type");
value <<= object_type;
encoder.add(::FT::FT_TYPE_ID, value);
FT::ObjectGroupId group_id = 0;
value <<= group_id;
encoder.add(::FT::FT_GROUP_ID, value);
// allocate and populate the criteria
PortableGroup::Criteria_var criteria;
ACE_NEW_NORETURN (criteria,
PortableGroup::Criteria);
if (criteria.ptr() == 0)
{
ACE_ERROR((LM_ERROR,
"Error cannot allocate criteria.\n"
));
result = -1;
}
else
{
encoder.encode(criteria);
PortableGroup::GenericFactory::FactoryCreationId_var factory_creation_id;
ACE_DEBUG((LM_DEBUG,
"Call create_object with type: %s\n", type_id.in()
));
this->factory_->create_object (
type_id.in(),
criteria.in(),
factory_creation_id);
}
}
}
if (result == 0 && this->readyFile_ != 0)
{
FILE *ready = ACE_OS::fopen (this->readyFile_, "w");
if ( ready )
{
ACE_OS::fprintf (ready, "ready\n");
ACE_OS::fclose (ready);
}
}
}
return result;
}