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; }