void node_disconnected(int sock, int node) {
int new_node;
pthread_mutex_lock(&peer_list_mutex);
pthread_mutex_lock(&peer_sock_mutex);
close(sock);
close(peer_srv_socks[node]);
peers[node] = peers.back();
peer_cli_socks[node] = peer_cli_socks.back();
peer_srv_socks[node] = peer_srv_socks.back();
peer_locks[node] = peer_locks.back();
peers.pop_back();
peer_cli_socks.pop_back();
peer_srv_socks.pop_back();
peer_locks.pop_back();
pthread_mutex_unlock(&peer_sock_mutex);
pthread_mutex_unlock(&peer_list_mutex);
pthread_mutex_lock(&replicas_lock);
for (unsigned int i = 0; i < replicas.size(); i++) {
if (replicas[i].node == node) {
new_node = rand() % peers.size();
create_replica(new_node, replicas[i].id);
replicas[i].node = new_node;
}
}
pthread_mutex_unlock(&replicas_lock);
}
CORBA::Object_ptr FT_ReplicaFactory_i::create_object (
const char * type_id,
const PortableGroup::Criteria & the_criteria,
PortableGroup::GenericFactory::FactoryCreationId_out factory_creation_id)
{
METHOD_ENTRY(FT_ReplicaFactory_i::create_object);
ACE_UNUSED_ARG (type_id);
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->internals_, CORBA::Object::_nil ());
::TAO::PG_Property_Set decoder (the_criteria);
// boolean, becomes true if a required parameter is missing
int missingParameter = 0;
const char * missingParameterName = 0;
CORBA::Long initialValue = 0;
if (! ::TAO::find (decoder, criterion_initial_value, initialValue) )
{
// not required. Otherwise:
// missingParameter = 1;
// missingParameterName = criterion_initial_value;
}
const char * role = "replica";
if (! ::TAO::find (decoder, PortableGroup::role_criterion, role) )
{
ACE_ERROR((LM_INFO,
"Property \"%s\" not found?\n", PortableGroup::role_criterion
));
// not required. Otherwise:
// missingParameter = 1;
// missingParameterName = PortableGroup::role_criterion;
}
if (missingParameter)
{
ACE_ERROR ((LM_ERROR,
"Throwing 'InvalidCriteria' due to missing %s\n",
missingParameterName
));
throw PortableGroup::InvalidCriteria();
}
FT_TestReplica_i * replica = create_replica(role);
if (replica == 0)
{
ACE_ERROR ((LM_ERROR,
"New Replica_i returned NULL. Throwing ObjectNotCreated.\n"
));
throw PortableGroup::ObjectNotCreated();
}
ACE_NEW_THROW_EX ( factory_creation_id,
PortableGroup::GenericFactory::FactoryCreationId,
PortableGroup::ObjectNotCreated());
CORBA::ULong factory_id = replica->factory_id();
(*factory_creation_id) <<= factory_id;
ACE_ERROR ((LM_INFO,
"Created %s@%C#%d.\n", role, this->location_.c_str (), static_cast<int> (factory_id)
));
::CORBA::Object_ptr replica_obj =
replica->_default_POA()->servant_to_reference(replica);
METHOD_RETURN(FT_ReplicaFactory_i::create_object) replica_obj->_duplicate(replica_obj);
}
int FT_ReplicaFactory_i::init (CORBA::ORB_ptr orb)
{
int result = 0;
this->orb_ = CORBA::ORB::_duplicate (orb);
// Use the ROOT POA for now
CORBA::Object_var poa_object =
this->orb_->resolve_initial_references (TAO_OBJID_ROOTPOA);
if (CORBA::is_nil (poa_object.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT (" (%P|%t) Unable to initialize the POA.\n")),
-1);
}
// Get the POA object.
this->poa_ =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil(this->poa_.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT (" (%P|%t) Unable to narrow the POA.\n")),
-1);
}
PortableServer::POAManager_var poa_manager =
this->poa_->the_POAManager ();
poa_manager->activate ();
// Register with the POA.
this->object_id_ = this->poa_->activate_object (this);
CORBA::Object_var this_obj =
this->poa_->id_to_reference (object_id_.in ());
this->ior_ = this->orb_->object_to_string (this_obj.in ());
if (this->factory_registry_ior_ != 0)
{
if (ACE_OS::strcmp (this->factory_registry_ior_, ACE_TEXT("none")) != 0)
{
CORBA::Object_var reg_obj = this->orb_->string_to_object(factory_registry_ior_);
this->factory_registry_ = ::PortableGroup::FactoryRegistry::_narrow(reg_obj.in ());
if (CORBA::is_nil(this->factory_registry_.in ()))
{
ACE_ERROR (( LM_ERROR,
"Can't resolve Factory Registry IOR %s\n",
this->factory_registry_ior_
));
result = -1;
}
}
}
else // no -f option. Try RIR(RM)
{
///////////////////////////////
// Find the ReplicationManager
try
{
CORBA::Object_var rm_obj = orb->resolve_initial_references("ReplicationManager");
this->replication_manager_ = ::FT::ReplicationManager::_narrow(rm_obj.in());
if (!CORBA::is_nil (replication_manager_.in ()))
{
this->have_replication_manager_ = 1;
// empty criteria
::PortableGroup::Criteria criteria;
this->factory_registry_ = this->replication_manager_->get_factory_registry(criteria);
if (CORBA::is_nil (this->factory_registry_.in ()))
{
ACE_ERROR ((LM_ERROR,"ReplicaFactory: ReplicationManager failed to return FactoryRegistry. Factory will not be registered.\n" ));
}
}
else
{
this->factory_registry_ = ::PortableGroup::FactoryRegistry::_narrow(rm_obj.in());
if (!CORBA::is_nil(this->factory_registry_.in ()))
{
ACE_DEBUG ((LM_DEBUG,"Found a FactoryRegistry DBA ReplicationManager\n" ));
}
else
{
ACE_ERROR ((LM_ERROR,"ReplicaFactory: Can't resolve ReplicationManager.\n" ));
}
}
}
catch (const CORBA::Exception& ex)
{
if (this->test_output_file_ == 0) // ignore if this is a test run
{
ex._tao_print_exception (
"ReplicaFactory: Exception resolving ReplicationManager. Factory will not be registered.\n");
}
}
}
if ( ! CORBA::is_nil (this->factory_registry_.in ()))
{
size_t roleCount = roles_.size();
for (size_t nRole = 0; nRole < roleCount; ++nRole)
{
const char * roleName = this->roles_[nRole].c_str();
PortableGroup::FactoryInfo info;
info.the_factory = ::PortableGroup::GenericFactory::_narrow(this_obj.in ());
info.the_location.length(1);
info.the_location[0].id = CORBA::string_dup(this->location_.c_str ());
info.the_criteria.length(1);
info.the_criteria[0].nam.length(1);
info.the_criteria[0].nam[0].id = CORBA::string_dup(PortableGroup::role_criterion);
info.the_criteria[0].val <<= CORBA::string_dup(roleName);
ACE_ERROR (( LM_INFO,
"Factory: %s@%C registering with factory registry\n",
roleName,
location_.c_str ()
));
char const * replica_repository_id =
FT_TEST::_tc_TestReplica->id ();
this->factory_registry_->register_factory(
roleName,
replica_repository_id,
info);
}
this->registered_ = 1;
}
int identified = 0; // bool
if (this->roles_.size() > 0)
{
this->identity_ = ACE_TEXT("Factory");
if (this->location_.length () != 0)
{
this->identity_ += ACE_TEXT("@");
this->identity_ += ACE_TEXT_CHAR_TO_TCHAR(this->location_.c_str ());
}
identified = 1;
}
if (this->ior_output_file_ != 0)
{
if (!identified)
{
this->identity_ = ACE_TEXT("file:");
this->identity_ += this->ior_output_file_;
// note: don't set identified--ns identity overrides file identitiy
}
result = write_ior (this->ior_output_file_, this->ior_. in ());
}
else
{
if (this->registered_)
{
// if we didn't register with a FactoryRegistry
// and no IOR file specified,
// then always try to register with name service
this->ns_name_ = "FT_ReplicaFactory";
}
}
if (this->ns_name_.length () != 0)
{
if (!identified)
{
this->identity_ = ACE_TEXT("name:");
this->identity_ += ACE_TEXT_CHAR_TO_TCHAR(this->ns_name_.c_str ());
}
CORBA::Object_var naming_obj =
this->orb_->resolve_initial_references ("NameService");
if (CORBA::is_nil(naming_obj.in ())){
ACE_ERROR_RETURN ((LM_ERROR,
"%T %n (%P|%t) Unable to find the Naming Service\n"),
1);
}
this->naming_context_ =
CosNaming::NamingContext::_narrow (naming_obj.in ());
this->this_name_.length (1);
this->this_name_[0].id = CORBA::string_dup (this->ns_name_.c_str ());
this->naming_context_->rebind (this->this_name_, this_obj.in());
}
// if we're testing. Create a replica at startup time
if (this->test_output_file_ != 0)
{
// shouldn't be necessary, but create_replica assumes this
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->internals_, 1);
FT_TestReplica_i * replica = create_replica ("test");
PortableServer::POA_var poa = replica->_default_POA ();
::CORBA::Object_var replica_obj = poa->servant_to_reference(replica);
::CORBA::String_var replicaIOR = this->orb_->object_to_string(replica_obj.in ());
write_ior (this->test_output_file_, replicaIOR.in ());
}
return result;
}
