void ServantLocator::postinvoke (const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, const char* operation, PortableServer::ServantLocator::Cookie the_cookie, PortableServer::Servant the_servant ) throw (CORBA::SystemException) { // // call services registered for postinvoke // if(home_servant_->service_name_ == "") { std::vector <Qedo::ComponentInstance_var> ::iterator iter; Components::CCMService_ptr service; for (iter = home_servant_->container_->services_postinvoke_.begin(); iter != home_servant_->container_->services_postinvoke_.end(); iter++) { service = dynamic_cast<Components::CCMService_ptr>((*iter)->executor_locator_.in()); service->postinvoke((*iter)->ccm_object_executor_->uuid_.c_str(), operation); } } the_servant->_remove_ref(); }
void GCServantLocator::postinvoke(const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, const char* operation, PortableServer::ServantLocator::Cookie the_cookie, PortableServer::Servant the_servant) { the_servant->_remove_ref(); }
Implicit_Deactivator::Implicit_Deactivator (PortableServer::Servant servant) { this->poa_ = servant->_default_POA (); this->id_ = this->poa_->servant_to_id (servant); }
void deactivate_servant (PortableServer::Servant servant) { PortableServer::POA_var poa = servant->_default_POA (); PortableServer::ObjectId_var id = poa->servant_to_id (servant); poa->deactivate_object (id.in ()); }
void Servant_Activator::etherealize (const PortableServer::ObjectId &, PortableServer::POA_ptr, PortableServer::Servant servant, CORBA::Boolean, CORBA::Boolean) { servant->_remove_ref (); }
int TAO_System_Id_With_Multiple_Id_Strategy::bind_using_system_id ( PortableServer::Servant servant, CORBA::Short priority, TAO_Active_Object_Map_Entry *&entry) { ACE_NEW_RETURN (entry, TAO_Active_Object_Map_Entry, -1); int result = this->active_object_map_->user_id_map_->bind_create_key (entry, entry->user_id_); if (result == 0) { entry->servant_ = servant; entry->priority_ = priority; result = this->active_object_map_->id_hint_strategy_->bind (*entry); if (result != 0) { this->active_object_map_->user_id_map_->unbind (entry->user_id_); delete entry; } #if defined (TAO_HAS_MONITOR_POINTS) && (TAO_HAS_MONITOR_POINTS == 1) this->active_object_map_->monitor_->receive ( this->active_object_map_->user_id_map_->current_size ()); #endif /* TAO_HAS_MONITOR_POINTS==1 */ } else { delete entry; } #if (TAO_HAS_MINIMUM_CORBA == 0) if (result == 0 && TAO_debug_level > 7) { CORBA::String_var idstr ( PortableServer::ObjectId_to_string (entry->user_id_)); CORBA::String_var repository_id ( servant ? servant->_repository_id () : 0); ACE_CString hex_idstr; hexstring (hex_idstr, idstr.in (), entry->user_id_.length ()); TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - TAO_System_Id_With_Multiple_Id_Strategy::" "bind_using_system_id: type=%C, id=%C\n", repository_id.in (), hex_idstr.c_str() )); } #endif return result; }
void ServantLocator::postinvoke (const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, const char* operation, PortableServer::ServantLocator::Cookie the_cookie, PortableServer::Servant the_servant ) throw (CORBA::SystemException) { the_servant->_remove_ref(); }
void ServantActivatorImpl::etherealize( const PortableServer::ObjectId& oid, PortableServer::POA_ptr poa, PortableServer::Servant servant, CORBA::Boolean cleanup_in_progress, CORBA::Boolean remaining_activations) { printf("------- ServantActivator.etherealize() --------\n"); servant->_remove_ref(); }
CORBA::Object_ptr ServantRetentionStrategyRetain::servant_to_reference ( PortableServer::Servant servant) { // Note: The allocation of an Object Id value and installation in // the Active Object Map caused by implicit activation may actually // be deferred until an attempt is made to externalize the // reference. The real requirement here is that a reference is // produced that will behave appropriately (that is, yield a // consistent Object Id value when asked politely). CORBA::Short priority = this->poa_->server_priority (); PortableServer::ObjectId_var system_id = this->servant_to_system_id_i (servant, priority); PortableServer::ObjectId user_id; // This operation requires the RETAIN, therefore don't worry about // the NON_RETAIN case. if (this->active_object_map_-> find_user_id_using_system_id (system_id.in (), user_id) != 0) { throw ::CORBA::OBJ_ADAPTER (); } // Remember params for potentially invoking <key_to_object> later. this->poa_->key_to_object_params_.set ( system_id, servant->_interface_repository_id (), servant, 1, priority, true); // Ask the ORT to create the object. // @@NOTE:There is a possible deadlock lurking here. We held the // lock, and we are possibly trying to make a call into the // application code. Think what would happen if the app calls us // back. We need to get to this at some point. return this->poa_->invoke_key_to_object_helper_i ( servant->_interface_repository_id (), user_id); }
void ServantLocatorImpl::postinvoke( const PortableServer::ObjectId& oid, PortableServer::POA_ptr poa, const char* operation, PortableServer::ServantLocator::Cookie cookie, PortableServer::Servant servant) { printf("------- ServantLocator.postinvoke(.., op='%s', .. ) " "--------\n", operation); servant->_remove_ref(); }
PortableServer::Servant GCServantLocator::preinvoke(const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, const char* operation, PortableServer::ServantLocator::Cookie& the_cookie) { boost::mutex::scoped_lock lock(activeMapMutex_); ServantMap::iterator iter = activeMap_.find(oid); if (iter == activeMap_.end()) { throw CORBA::OBJECT_NOT_EXIST(); } PortableServer::Servant servant = iter->second.servant; if (iter->second.destroy == std::string(operation)) { LOG_TRACE(GCServantLocator, "untracking " << (void*)servant); activeMap_.erase(iter); } else { servant->_add_ref(); iter->second.last_access = boost::get_system_time(); } return servant; }
CORBA::Object_ptr ServantRetentionStrategyRetain::id_to_reference ( const PortableServer::ObjectId &id, bool indirect) { // If an object with the specified Object Id value is currently // active, a reference encapsulating the information used to // activate the object is returned. PortableServer::ObjectId_var system_id; PortableServer::Servant servant; CORBA::Short priority; if (this->active_object_map_-> find_servant_and_system_id_using_user_id (id, servant, system_id.out (), priority) == 0) { // Remember params for potentially invoking <key_to_object> later. this->poa_->key_to_object_params_.set (system_id, servant->_interface_repository_id (), servant, 1, priority, indirect); return this->poa_->invoke_key_to_object_helper_i (servant->_interface_repository_id (), id); } else { // If the Object Id value is not active in the POA, an // ObjectNotActive exception is raised. throw PortableServer::POA::ObjectNotActive (); } }
void GCServantLocator::register_servant(const PortableServer::ObjectId& oid, PortableServer::Servant servant, boost::posix_time::time_duration ttl, const std::string& destroy) { boost::mutex::scoped_lock lock(activeMapMutex_); if (activeMap_.count(oid) > 0) { throw PortableServer::POA::ObjectAlreadyActive(); } LOG_TRACE(GCServantLocator, "tracking " << (void*)servant); ServantEntry& entry = activeMap_[oid]; entry.servant = servant; servant->_add_ref(); entry.ttl = ttl; entry.last_access = boost::get_system_time(); entry.destroy = destroy; }
void Servant_Activator::etherealize (const PortableServer::ObjectId &id, PortableServer::POA_ptr , PortableServer::Servant servant, CORBA::Boolean, CORBA::Boolean) { CORBA::String_var object_name = PortableServer::ObjectId_to_string (id); ACE_DEBUG ((LM_DEBUG, "Etherealize called with id = \"%C\"\n", object_name.in ())); if (ACE_OS::strcmp (object_name.in (), "without reference counting") == 0) delete servant; else { servant->_remove_ref (); } }
/* static */ int TAO_AV_Core::deactivate_servant (PortableServer::Servant servant) { // Because of reference counting, the POA will automatically delete // the servant when all pending requests on this servant are // complete. try { PortableServer::POA_var poa = servant->_default_POA (); PortableServer::ObjectId_var id = poa->servant_to_id (servant); poa->deactivate_object (id.in ()); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("deactivate_servant"); return -1; } return 0; }
void TimeServantLocator::postinvoke (const PortableServer::ObjectId & oid, PortableServer::POA_ptr poa, const char *operation, void *cookie, PortableServer::Servant servant) throw (CORBA::SystemException) { // Check to see if the object ID is valid (CORBA) CORBA::String_var oidString; try { oidString = PortableServer::ObjectId_to_string (oid); } catch (const CORBA::BAD_PARAM&) { throw CORBA::OBJECT_NOT_EXIST (); } debug ("TimeServantLocator::%s(%s)", __FUNCTION__, oidString.in()); // Decrement servant reference count servant->_remove_ref (); }
bool ServiceOptions::bindServiceObject(CORBA::ORB_ptr orb, CORBA::Object_ptr object, PortableServer::Servant p_servant, const char* objName, bool rebind) { if(is_set("with-naming")) { CosNaming::Name name; name.length(1); name[0].id=CORBA::string_dup(objName); name[0].kind=CORBA::string_dup(""); CORBA::Object_var obj ; try { obj = orb->resolve_initial_references("NameService"); }catch(const CORBA::ORB::InvalidName& ex){ std::cerr << argv()[0] << ": can't resolve `NameService'" << std::endl; return false; } CosNaming::NamingContext_var nc; try { nc = CosNaming::NamingContext::_narrow(obj.in()); }catch(const CORBA::SystemException& ex){ std::cerr << argv()[0] << ": can't narrow naming service" << std::endl; return false; } try { if(rebind){ nc->rebind(name,object); }else{ try{ nc->bind(name,object); }catch(const CosNaming::NamingContext::AlreadyBound&){ std::cerr<<argv()[0]<<":can't bind "<<objName<<" (AlreadyBound)"<< std::endl; return false; } } }catch(const CosNaming::NamingContext::CannotProceed&){ std::cerr<<argv()[0]<<": can't bind "<<objName<<" (CannotProceed)"<< std::endl; return false; }catch(const CosNaming::NamingContext::InvalidName&){ std::cerr<<argv()[0]<<":can't bind "<<objName<<" (InvalidName)"<< std::endl; return false; } std::cout<<argv()[0]<<": binding completed successfully"<<std::endl; } CORBA::String_var ior ; try { ior = orb->object_to_string(object); }catch(const CORBA::SystemException& ex){ #ifdef CORBA_SYSTEM_EXCEPTION_IS_STREAMBLE std::cerr << ex << std::endl; #else std::cerr << "CORBA::SystemException" << std::endl; #endif return false; } const char* fname = get_ior_fname(objName); if (fname!=NULL && strcmp(fname,"")!=0) { std::ofstream ofs (fname); if (ofs.bad()) { std::cerr << argv()[0] << ": can't open file " << fname << std::endl; perror(argv()[0]); return false; } ofs << ior.in(); ofs.close(); } if (is_set("ior-stdout")) { std::cout << ior << std::flush; } #ifdef ORBACUS CORBA::Object_var bmgrObj = orb->resolve_initial_references("BootManager"); OB::BootManager_var bootManager = OB::BootManager::_narrow(bmgrObj); PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId(objName); bootManager -> add_binding(oid.in(),object); #elif defined(OMNIORB) PortableServer::POA_var objPOA = p_servant->_default_POA(); CORBA::String_var objPOAName = objPOA->the_name(); if (strcmp(objPOAName.in(),"omniINSPOA")!=0) { CORBA::Object_var insPOAObj = orb->resolve_initial_references("omniINSPOA"); PortableServer::POA_var insPOA = PortableServer::POA::_narrow(insPOAObj); PortableServer::POAManager_var insPOAManager=insPOA->the_POAManager(); insPOAManager->activate(); PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId(objName); insPOA->activate_object_with_id(oid.in(),p_servant); } #elif defined(RSSH_TAO) #ifdef TAO_HAVE_IORTABLE_ADAPTER CORBA::Object_var table = orb->resolve_initial_references ("IORTable"); IORTable::Table_var adapter = IORTable::Table::_narrow (table.in()); if (CORBA::is_nil(adapter.in())) { cerr<<argv()[0]<<": nil IORTable reference"<<endl; } else { adapter->bind (objName, ior.in ()); } #else ACE_CString ins(objName); if (orb->_tao_add_to_IOR_table(ins,object)!=0) { return false; } #endif #elif defined(MICO) // create persistent POA with name as service name if we have no one. PortableServer::POA_var objPOA = p_servant->_default_POA(); CORBA::String_var objPOAName = objPOA->the_name(); std::cerr << "existent OBJPOAName=" << objPOAName.in() << std::endl; std::cerr << "objName=" << objName << std::endl; if (strcmp(objPOAName.in(),objName)!=0) { CORBA::Object_var rootPOAObj = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var rootPOA = PortableServer::POA::_narrow(rootPOAObj); CORBA::PolicyList pl; pl.length (2); pl[0] = rootPOA->create_lifespan_policy (PortableServer::PERSISTENT); pl[1] = rootPOA->create_id_assignment_policy (PortableServer::USER_ID); PortableServer::POA_var objPOA = rootPOA->create_POA(objName, PortableServer::POAManager::_nil (), pl); PortableServer::POAManager_var objPOAManager = objPOA->the_POAManager (); PortableServer::ObjectId_var objId = PortableServer::string_to_ObjectId (objName); objPOA->activate_object_with_id (objId.in(), p_servant); objPOAManager->activate(); }else{ //PortbaobjPOA } #endif return true; }
void RequestProcessingStrategyServantActivator::cleanup_servant ( PortableServer::Servant servant, const PortableServer::ObjectId &user_id ) { // If a servant manager is associated with the POA, // ServantLocator::etherealize will be invoked with the oid and the // servant. (The deactivate_object operation does not wait for the // etherealize operation to complete before deactivate_object // returns.) // // Note: If the servant associated with the oid is serving multiple // Object Ids, ServantLocator::etherealize may be invoked multiple // times with the same servant when the other objects are // deactivated. It is the responsibility of the object // implementation to refrain from destroying the servant while it is // active with any Id. // If the POA has no ServantActivator associated with it, the POA // implementation calls _remove_ref when all operation invocations // have completed. If there is a ServantActivator, the Servant is // consumed by the call to ServantActivator::etherealize instead. // @bala, is this order correct, see 11.3.9.17 of the spec, it // says first remove from the map, then etherealize. not the // other way around // @@ Johnny, you are right! This will not show up until a // thread is trying to activate the object in another thread // using activate_object_with_id (). A test case is a must for // atleast this issue. if (servant) { if (this->etherealize_objects_ && !CORBA::is_nil (this->servant_activator_.in ())) { this->etherealize_servant (user_id, servant, this->poa_->cleanup_in_progress ()); } else { // ATTENTION: Trick locking here, see class header for details Non_Servant_Upcall non_servant_upcall (*this->poa_); ACE_UNUSED_ARG (non_servant_upcall); try { servant->_remove_ref (); } catch (...) { // Ignore exceptions from servant cleanup. } } } // This operation causes the association of the Object Id specified // by the oid parameter and its servant to be removed from the // Active Object Map. if (this->poa_->unbind_using_user_id (user_id) != 0) throw ::CORBA::OBJ_ADAPTER (); }
void ServantRetentionStrategyRetain::activate_object_with_id ( const PortableServer::ObjectId &id, PortableServer::Servant servant, CORBA::Short priority, bool &wait_occurred_restart_call) { // If the POA has the SYSTEM_ID policy and it detects that the // Object Id value was not generated by the system or for this POA, // the activate_object_with_id operation may raise the BAD_PARAM // system exception. An ORB is not required to detect all such // invalid Object Id values, but a portable application must not // invoke activate_object_with_id on a POA that has the SYSTEM_ID // policy with an Object Id value that was not previously generated // by the system for that POA, or, if the POA also has the // PERSISTENT policy, for a previous instantiation of the same POA. if (this->poa_->has_system_id () && !this->poa_->is_poa_generated_id (id)) { throw ::CORBA::BAD_PARAM (); } // If the CORBA object denoted by the Object Id value is already // active in this POA (there is a servant bound to it in the Active // Object Map), the ObjectAlreadyActive exception is raised. bool priorities_match = true; bool result = this->is_user_id_in_map (id, priority, priorities_match, wait_occurred_restart_call); // @johnny the implementation is not complete, this does the spec also say // If the POA has the UNIQUE_ID policy and the servant is already // in the Active Object Map, the ServantAlreadyActive exception is raised. if (result) { throw PortableServer::POA::ObjectAlreadyActive (); } else if (wait_occurred_restart_call) { // We ended up waiting on a condition variable, the POA state // may have changed while we are waiting. Therefore, we need to // restart this call. return; } // If the activate_object_with_id_and_priority operation is invoked // with a different priority to an earlier invocation of one of the // create reference with priority operations, for the same object, // then the ORB shall raise a BAD_INV_ORDER system exception (with a // Standard Minor Exception Code of 1). If the priority value is the // same then the ORB shall return SUCCESS. if (!priorities_match) { throw ::CORBA::BAD_INV_ORDER (CORBA::OMGVMCID | 1, CORBA::COMPLETED_NO); } bool const may_activate = this->poa_->is_servant_activation_allowed (servant, wait_occurred_restart_call); if (!may_activate) { if (wait_occurred_restart_call) { return; } else { throw PortableServer::POA::ServantAlreadyActive (); } } // Otherwise, the activate_object_with_id operation enters an // association between the specified Object Id and the specified // servant in the Active Object Map. if (this->active_object_map_->bind_using_user_id (servant, id, priority) != 0) { throw ::CORBA::OBJ_ADAPTER (); } // // Everything is finally ok // // Inform the custom servant dispatching (CSD) strategy that the // sevant is activated. this->poa_->servant_activated_hook (servant, id); // ATTENTION: Trick locking here, see class header for details Non_Servant_Upcall non_servant_upcall (*this->poa_); ACE_UNUSED_ARG (non_servant_upcall); // The implementation of activate_object_with_id will invoke // _add_ref at least once on the Servant argument before // returning. When the POA no longer needs the Servant, it will // invoke _remove_ref on it the same number of times. servant->_add_ref (); }