PortableServer::POA_ptr
setup_poa (PortableServer::POA_ptr root_poa)
{
// Policies for the childPOA to be created.
CORBA::PolicyList policies (2);
policies.length (2);
// Tell the POA to use a servant manager.
policies[0] =
root_poa->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER);
// Allow implicit activation.
policies[1] =
root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Create POA as child of RootPOA with the above policies. This POA
// will use a SERVANT_ACTIVATOR because of RETAIN policy.
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Creation of childPOAs is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
return child_poa._retn ();
}
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
PortableServer::POA_var create_persistent_poa(PortableServer::POA_var root_poa,
PortableServer::POAManager_var mgr,
const char* name,
CORBA::PolicyList& policy_list)
{
PortableServer::POA_var result;
PortableServer::LifespanPolicy_var lifespan =
root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
// create a USER_ID IdAssignmentPolicy object
PortableServer::IdAssignmentPolicy_var assign =
root_poa->create_id_assignment_policy(PortableServer::USER_ID);
// create PolicyList.
size_t orig_len = policy_list.length();
policy_list.length(orig_len+2);
policy_list[orig_len+0]=
PortableServer::LifespanPolicy::_duplicate(lifespan.in());
policy_list[orig_len+1]=
PortableServer::IdAssignmentPolicy::_duplicate(assign.in());
// create the child POA
result = root_poa->create_POA(name, mgr.in(), policy_list);
return result;
}
CORBA::Boolean
ImR_Adapter::unknown_adapter (PortableServer::POA_ptr parent,
const char *name)
{
ACE_ASSERT (! CORBA::is_nil(parent));
ACE_ASSERT (name != 0);
CORBA::PolicyList policies (3);
const char *exception_message = "Null Message";
policies.length (3);
try
{
// Servant Retention Policy
exception_message = "While PortableServer::POA::create_servant_retention_policy";
policies[0] =
parent->create_servant_retention_policy (PortableServer::NON_RETAIN);
// Request Processing Policy
exception_message = "While PortableServer::POA::create_request_processing_policy";
policies[1] =
parent->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT);
policies[2] =
parent->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID);
PortableServer::POAManager_var poa_manager =
parent->the_POAManager ();
exception_message = "While create_POA";
PortableServer::POA_var child =
parent->create_POA (name,
poa_manager.in (),
policies);
exception_message = "While policy->destroy";
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
exception_message = "While child->the_activator";
child->the_activator (this);
exception_message = "While set_servant";
child->set_servant (this->default_servant_);
}
catch (const CORBA::Exception& ex)
{
ORBSVCS_ERROR ((LM_ERROR,
"IMR_Adapter_Activator::unknown_adapter - %s\n",
exception_message));
ex._tao_print_exception ("System Exception");
return 0;
}
// Finally, now everything is fine
return 1;
}
int
configure_policies (CORBA::ORB_ptr orb,
const TAO::BufferingConstraint &buffering_constraint,
Test::AMI_Buffering_ptr ami_buffering,
Test::AMI_Buffering_out flusher)
{
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
if (CORBA::is_nil (policy_current.in ()))
{
ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n"));
return 1;
}
CORBA::Any scope_as_any;
scope_as_any <<= Messaging::SYNC_NONE;
CORBA::Any buffering_as_any;
buffering_as_any <<= buffering_constraint;
CORBA::PolicyList policies (2); policies.length (2);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
policies[1] =
orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE,
buffering_as_any);
policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
policies[1]->destroy ();
TAO::BufferingConstraint flush_constraint;
flush_constraint.mode = TAO::BUFFER_FLUSH;
flush_constraint.message_count = 0;
flush_constraint.message_bytes = 0;
flush_constraint.timeout = 0;
buffering_as_any <<= flush_constraint;
policies.length (1);
policies[0] =
orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE,
buffering_as_any);
object =
ami_buffering->_set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
flusher =
Test::AMI_Buffering::_narrow (object.in ());
return 0;
}
RTPOA_Setup::RTPOA_Setup (CORBA::ORB_ptr orb,
const RTCORBA_Setup &rtcorba_setup)
{
RTPortableServer::POA_var root_poa =
RIR_Narrow<RTPortableServer::POA>::resolve (orb,
"RootPOA");
RTCORBA::RTORB_var rtorb =
RIR_Narrow<RTCORBA::RTORB>::resolve (orb,
"RTORB");
const CORBA::ULong stacksize = 1024 * 1024; // 1 Mb
const RTCORBA::ThreadpoolLanes &lanes = rtcorba_setup.lanes ();
const CORBA::Boolean allow_borrowing = 0;
const CORBA::Boolean allow_request_buffering = 0;
const CORBA::ULong max_buffered_requests = 0; // dummy value
const CORBA::ULong max_request_buffer_size = 0; // dummy value
RTCORBA::ThreadpoolId pool_id =
rtorb->create_threadpool_with_lanes (stacksize,
lanes,
allow_borrowing,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
// @@ We need an 'auto_ptr for thread pools' here!
CORBA::PolicyList policies (4); policies.length (4);
policies[0] =
rtorb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
rtcorba_setup.process_priority ());
policies[1] =
root_poa->create_id_assignment_policy (PortableServer::SYSTEM_ID);
policies[2] =
root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION);
#if 0
policies.length (3);
#else
policies[3] =
rtorb->create_threadpool_policy (pool_id);
#endif /* 0 */
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
this->poa_ =
root_poa->create_POA ("RTEC_Perf",
poa_manager.in (),
policies);
for (CORBA::ULong i = 0; i != policies.length (); ++i)
{
policies[i]->destroy ();
}
}
int
Manager::init (int argc, ACE_TCHAR *argv[])
{
this->orb_ = CORBA::ORB_init (argc, argv);
// Obtain the RootPOA.
CORBA::Object_var obj_var =
this->orb_->resolve_initial_references ("RootPOA");
// Get the POA_var object from Object_var.
PortableServer::POA_var root_poa_var =
PortableServer::POA::_narrow (obj_var.in ());
// Get the POAManager of the RootPOA.
PortableServer::POAManager_var poa_manager_var =
root_poa_var->the_POAManager ();
poa_manager_var->activate ();
// Policies for the childPOA to be created.
CORBA::PolicyList policies (4);
policies.length (4);
// The next two policies are common to both
// Id Assignment Policy
policies[0] =
root_poa_var->create_id_assignment_policy (PortableServer::USER_ID);
// Lifespan policy
policies[1] =
root_poa_var->create_lifespan_policy (PortableServer::PERSISTENT);
// Tell the POA to use a servant manager
policies[2] =
root_poa_var->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER);
// Servant Retention Policy -> Use a locator
policies[3] =
root_poa_var->create_servant_retention_policy (PortableServer::NON_RETAIN);
ACE_CString name = "newPOA";
this->new_poa_var_ =
root_poa_var->create_POA (name.c_str (),
poa_manager_var.in (),
policies);
// Creation of childPOAs is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
return 0;
}
int
create_POA_and_register_servant (CORBA::Policy_ptr threadpool_policy,
const char *poa_name,
PortableServer::POAManager_ptr poa_manager,
PortableServer::POA_ptr root_poa,
CORBA::ORB_ptr orb,
RTCORBA::RTORB_ptr rt_orb)
{
// Policies for the firstPOA to be created.
CORBA::PolicyList policies (3); policies.length (3);
// Implicit_activation policy.
policies[0] =
root_poa->create_implicit_activation_policy
(PortableServer::IMPLICIT_ACTIVATION);
// Thread pool policy.
policies[1] =
CORBA::Policy::_duplicate (threadpool_policy);
// Priority Model policy.
policies[2] =
rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, 0);
// Create the POA under the RootPOA.
PortableServer::POA_var poa =
root_poa->create_POA (poa_name,
poa_manager,
policies);
// Creation of POAs is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
test_i *servant =
new test_i (orb,
poa.in (),
nap_time);
PortableServer::ServantBase_var safe_servant (servant);
ACE_UNUSED_ARG (safe_servant);
PortableServer::ObjectId_var id =
poa->activate_object (servant);
CORBA::Object_var object = poa->id_to_reference (id.in ());
test_var test = test::_narrow (object.in ());
int const result = write_ior_to_file (orb, test.in ());
return result;
}
int
init_callback (Worker &w)
{
CORBA::Object_var obj =
w.orb_->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (obj.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Policies for the childPOA to be created.
CORBA::PolicyList policies (1);
policies.length (1);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
w.orb_->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE,
pol);
// Create POA as child of RootPOA with the above policies. This POA
// will receive request in the same connection in which it sent
// the request
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
Callback_i *servant = new Callback_i;
PortableServer::ServantBase_var owner = servant;
PortableServer::ObjectId_var id = child_poa->activate_object (servant);
obj = child_poa->id_to_reference (id.in());
w.callback_ = Test::CallBack::_narrow(obj.in());
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
return 0;
}
// Implementation skeleton constructor
CDBPropertySet::CDBPropertySet (CORBA::ORB_ptr orb,
PortableServer::POAManager_ptr poa_manager,
PortableServer::POA_ptr root_poa) :
poa_m(PortableServer::POA::_nil()),
poaCurrent_m(PortableServer::Current::_nil())
{
ACS_TRACE("baci::CDBPropertySet::CDBPropertySet");
CORBA::PolicyList policies (5);
policies.length (5);
// ID Assignment Policy
policies[0] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
// Lifespan Policy
policies[1] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
// Request Processing Policy
policies[2] =
root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT);
// Servant Retention Policy
policies[3] =
root_poa->create_servant_retention_policy (PortableServer::RETAIN);
// Id Uniqueness Policy
policies[4] =
root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID);
ACE_CString name = "DefaultServantPOA";
poa_m = root_poa->create_POA (name.c_str (),
poa_manager,
policies);
for (CORBA::ULong i = 0UL; i < policies.length (); ++i)
{
CORBA::Policy_ptr policy_p = policies[i];
policy_p->destroy();
}
// Get the POA Current object reference
CORBA::Object_var obj =
orb->resolve_initial_references ("POACurrent");
// Narrow the object reference to a POA Current reference
this->poaCurrent_m =
PortableServer::Current::_narrow (obj.in());
// Set default servant
poa_m->set_servant (this);
instance_mp = this;
}
void
Quoter_Stock_Factory_i::load_stock_objects (
PortableServer::POA_ptr poa,
PortableServer::POAManager_ptr poa_manager,
RtecEventChannelAdmin::SupplierAdmin_ptr supplier_admin)
{
if (!CORBA::is_nil (this->stock_factory_poa_.in ()))
return;
CORBA::PolicyList policies (2);
policies.length (2);
policies[0] =
poa->create_id_assignment_policy (PortableServer::USER_ID);
policies[1] =
poa->create_implicit_activation_policy (PortableServer::NO_IMPLICIT_ACTIVATION);
this->stock_factory_poa_ =
poa->create_POA ("Stock_Factory_POA",
poa_manager,
policies);
for (CORBA::ULong i = 0; i != policies.length (); ++i) {
policies[i]->destroy ();
}
while (!cin.eof () && cin.peek () != EOF) {
const int max_symbol_length = 8;
char symbol[max_symbol_length];
const int max_full_name_length = 64;
char full_name[max_full_name_length];
double price;
cin.getline (symbol, max_symbol_length, '\n');
cin.getline (full_name, max_full_name_length, '\n');
cin >> price;
cin.ignore (1, '\n');
Quoter_Stock_i *stock =
new Quoter_Stock_i (symbol, full_name, price);
PortableServer::ServantBase_var servant = stock;
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId (symbol);
this->stock_factory_poa_->activate_object_with_id (oid.in (),
servant.in ());
stock->connect (supplier_admin);
}
}
PortableServer::POA_ptr
createPOA (PortableServer::POA_ptr root_poa,
bool share_mgr,
const char* poa_name)
{
PortableServer::LifespanPolicy_var life =
root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
PortableServer::IdAssignmentPolicy_var assign =
root_poa->create_id_assignment_policy(PortableServer::USER_ID);
CORBA::PolicyList pols;
pols.length(2);
pols[0] = PortableServer::LifespanPolicy::_duplicate(life.in());
pols[1] = PortableServer::IdAssignmentPolicy::_duplicate(assign.in());
PortableServer::POAManager_var mgr = PortableServer::POAManager::_nil();
if (share_mgr)
{
mgr = root_poa->the_POAManager();
}
PortableServer::POA_var poa =
root_poa->create_POA(poa_name, mgr.in(), pols);
life->destroy();
assign->destroy();
return poa._retn();
}
void Test_xyz_serverTAOLayer::set_request_timeout_thread(
int timeout_ms)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(shutting_down_mutex_, 0);
if (!guard.locked())
{
ACE_DEBUG((LM_ERROR, "Acquiring shutting_down_mutex_ failed.\n"));
return;
}
request_timeout_thread_ms_ = timeout_ms;
// TimeT has 100 nanosecond resolution.
int usec(10); // ==> usec
int msec(1000); // ==> msec
int timeout_ns = usec * msec * timeout_ms;
TimeBase::TimeT relative_rt_timeout = timeout_ns;
CORBA::Any relative_rt_timeout_as_any;
relative_rt_timeout_as_any <<= relative_rt_timeout;
// Create the policy and put it in a policy list.
CORBA::PolicyList policies;
policies.length(1);
policies[0] = orb()->create_policy(Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, relative_rt_timeout_as_any);
// Apply the policy at the ORB level using the ORBPolicyManager.
policy_current_->set_policy_overrides(policies, CORBA::SET_OVERRIDE);
// Cleanup.
policies[0]->destroy ();
}
void Test_xyz_serverTAOLayer::set_connection_timeout_orb(
int timeout_ms)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(shutting_down_mutex_, 0);
if (!guard.locked())
{
ACE_DEBUG((LM_ERROR, "Acquiring shutting_down_mutex_ failed.\n"));
return;
}
// This method has effect on remote connection (server host different from client host)
connection_timeout_orb_ms_ = timeout_ms;
// TimeT has 100 nanosecond resolution.
int usec(10); // ==> usec
int msec(1000); // ==> msec
int timeout_ns = usec * msec * timeout_ms;
TimeBase::TimeT relative_rt_timeout = timeout_ns;
CORBA::Any relative_rt_timeout_as_any;
relative_rt_timeout_as_any <<= relative_rt_timeout;
CORBA::PolicyList policies;
policies.length(1);
policies[0] = orb()->create_policy (TAO::CONNECTION_TIMEOUT_POLICY_TYPE, relative_rt_timeout_as_any);
policy_manager_->set_policy_overrides (policies, CORBA::SET_OVERRIDE);
// Cleanup.
policies[0]->destroy ();
}
POA_ptr createPersistPOA(const char* name, POA_ptr root_poa, POAManager_ptr poaman) {
CORBA::PolicyList policies (2);
policies.length (2);
policies[0] = root_poa->create_id_assignment_policy(USER_ID);
policies[1] = root_poa->create_lifespan_policy(PERSISTENT);
POA_var poa = root_poa->create_POA(name, poaman, policies);
policies[0]->destroy();
policies[1]->destroy();
return poa._retn();
}
void
TAO_Notify_POA_Helper::set_persistent_policy (PortableServer::POA_ptr parent_poa, CORBA::PolicyList &policy_list)
{
policy_list.length (2);
policy_list[0] =
parent_poa->create_lifespan_policy (PortableServer::PERSISTENT);
policy_list[1] =
parent_poa->create_id_assignment_policy (PortableServer::USER_ID);
}
void
TAO_Notify_POA_Helper::set_policy (PortableServer::POA_ptr parent_poa, CORBA::PolicyList &policy_list)
{
policy_list.length (2);
policy_list[0] =
parent_poa->create_id_uniqueness_policy (PortableServer::UNIQUE_ID);
policy_list[1] =
parent_poa->create_id_assignment_policy (PortableServer::USER_ID);
}
void
Client::set_private_connection_policies (void)
{
CORBA::PolicyList policies;
policies.length (1);
policies[0] =
this->rt_orb_->create_private_connection_policy ();
this->policy_manager_->set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
}
int
Echo_Client_i::run (const char *name,
int argc,
ACE_TCHAR *argv[])
{
// Initialize the client.
if (client_.init (name, argc, argv) == -1)
return -1;
if (this->parse_args (argc, argv) == -1)
return -1;
try
{
CORBA::PolicyList policyList;
policyList.length(1);
CORBA::Any objectTimeout;
TimeBase::TimeT to = 50000;
to *= 365 * 24 * 3600;
to *= 100;
objectTimeout <<= to;
policyList[0] = client_.orb()->create_policy(
Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
objectTimeout);
CORBA::Object_var object =
client_->_set_policy_overrides(policyList, CORBA::ADD_OVERRIDE);
Echo_var srv(Echo::_narrow(object.in ()));
char* buf = new char [this->payload_length_+ 1];
ACE_OS::memset (buf, 'a', this->payload_length_);
buf[this->payload_length_] = '\0';
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Sending len: %d \n"), ACE_OS::strlen (buf)));
CORBA::String_var s = srv->echo_string (buf);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\nString echoed by client has len %d\n"),
ACE_OS::strlen(s.in ())));
delete [] buf;
if (client_.do_shutdown () == 1)
client_->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("\n Exception in RMI");
return -1;
}
return 0;
}
RTT_CORBA_API bool ApplicationServer::InitOrb(int argc, char* argv[], Seconds timeout ) {
if ( !CORBA::is_nil(orb) ){
return false;
}
try {
// First initialize the ORB, that will remove some arguments...
orb =
CORBA::ORB_init (argc, const_cast<char**>(argv),
"omniORB4");
if(timeout >= 0.1e-7)
{
#if defined( CORBA_IS_TAO ) && defined( CORBA_TAO_HAS_MESSAGING )
// Set the timeout value as a TimeBase::TimeT (100 nanosecond units)
// and insert it into a CORBA::Any.
TimeBase::TimeT relative_rt_timeout = timeout * 1.0e7;
CORBA::Any relative_rt_timeout_as_any;
relative_rt_timeout_as_any <<= relative_rt_timeout;
// Create the policy and put it in a policy list.
CORBA::PolicyList policies;
policies.length(1);
policies[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
relative_rt_timeout_as_any);
// Apply the policy at the ORB level using the ORBPolicyManager.
CORBA::Object_var obj = orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (obj.in());
policy_manager->set_policy_overrides (policies, CORBA::SET_OVERRIDE);
#else
log(Error) << "Ignoring ORB timeout setting in non-TAO/Messaging build." <<endlog();
#endif // CORBA_IS_TAO
}
// Also activate the POA Manager, since we may get call-backs !
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
rootPOA =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
rootPOA->the_POAManager ();
poa_manager->activate ();
return true;
}
catch (CORBA::Exception &e) {
log(Error) << "Orb Init : CORBA exception raised!" << Logger::nl;
Logger::log() << CORBA_EXCEPTION_INFO(e) << endlog();
std::cout << "ApplicationServer::InitOrb return false: ORBA exception raised\n";
}
return false;
}
PortableServer::POA_var MACIContainerServices::createOffShootPOA()
{
// Check if the POA was already created
if (!CORBA::is_nil(m_offShootPOA.ptr())) {
return m_offShootPOA;
}
// get the container POA
PortableServer::POA_var containerPOA = m_poa;
try{
m_offShootPOA = containerPOA->find_POA("OffShootPOA", false);
return m_offShootPOA;
}catch(CORBA::Exception &ex){
//if does not exist we just continue and create a new one
}
// get the POA Manager
PortableServer::POAManager_var poaManager = m_poa->the_POAManager();
//
// Prepare policies OffShoot POA will be using.
//
PortableServer::IdAssignmentPolicy_var offshoot_system_id_policy =
containerPOA->create_id_assignment_policy(PortableServer::SYSTEM_ID);
PortableServer::LifespanPolicy_var offshoot_transient_policy =
containerPOA->create_lifespan_policy(PortableServer::TRANSIENT);
PortableServer::RequestProcessingPolicy_var offshoot_use_active_object_map_only_policy =
containerPOA->create_request_processing_policy (PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY);
PortableServer::ServantRetentionPolicy_var offshoot_servant_retention_policy =
containerPOA->create_servant_retention_policy (PortableServer::RETAIN);
CORBA::PolicyList policiesOffShoot;
policiesOffShoot.length(4);
policiesOffShoot[0] = PortableServer::LifespanPolicy::_duplicate(offshoot_transient_policy.in());
policiesOffShoot[1] = PortableServer::IdAssignmentPolicy::_duplicate(offshoot_system_id_policy.in());
policiesOffShoot[2] = PortableServer::ServantRetentionPolicy::_duplicate(offshoot_servant_retention_policy.in());
policiesOffShoot[3] = PortableServer::RequestProcessingPolicy::_duplicate(offshoot_use_active_object_map_only_policy.in());
m_offShootPOA = containerPOA->create_POA("OffShootPOA",poaManager.in(),policiesOffShoot);
return m_offShootPOA;
}
void Test_xyz_serverTAOLayer::init_QOS()
{
CORBA::Object_var object = orb()->resolve_initial_references("ORBPolicyManager");
policy_manager_ = CORBA::PolicyManager::_narrow(object.in());
object = orb()->resolve_initial_references("PolicyCurrent");
policy_current_ = CORBA::PolicyCurrent::_narrow(object.in());
// Disable all default policies.
CORBA::PolicyList policies;
policies.length(0);
policy_manager_->set_policy_overrides(policies, CORBA::SET_OVERRIDE);
policy_current_->set_policy_overrides(policies, CORBA::SET_OVERRIDE);
}
int
Client_Task::svc (void)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting client task\n"));
try
{
// Apply sync_none policy
CORBA::Object_var object =
orb_->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
if (CORBA::is_nil (policy_current.in ()))
{
ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n"));
return 1;
}
CORBA::Any scope_as_any;
scope_as_any <<= Messaging::SYNC_NONE;
CORBA::PolicyList policies (1); policies.length (1);
policies[0] =
orb_->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
for (int i = 0; i != number_; ++i)
{
ACE_DEBUG ((LM_DEBUG,
"TAO (%P|%t) sending oneway invocation %d...\n", i));
this->sender_->send_ready_message ();
// Do it slowly.
ACE_OS::sleep(ACE_Time_Value(0,250000));
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught Exception");
return -1;
}
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client task finished\n"));
return 0;
}
int
TAO_IFR_Server::create_poa (void)
{
PortableServer::POAManager_var poa_manager =
this->root_poa_->the_POAManager ();
poa_manager->activate ();
CORBA::PolicyList policies (5);
policies.length (5);
// ID Assignment Policy.
policies[0] =
this->root_poa_->create_id_assignment_policy (PortableServer::USER_ID);
// Lifespan Policy.
policies[1] =
this->root_poa_->create_lifespan_policy (PortableServer::PERSISTENT);
// Request Processing Policy.
policies[2] =
this->root_poa_->create_request_processing_policy (
PortableServer::USE_DEFAULT_SERVANT
);
// Servant Retention Policy.
policies[3] =
this->root_poa_->create_servant_retention_policy (
PortableServer::NON_RETAIN
);
// Id Uniqueness Policy.
policies[4] =
this->root_poa_->create_id_uniqueness_policy (
PortableServer::MULTIPLE_ID
);
this->repo_poa_ =
this->root_poa_->create_POA ("repoPOA",
poa_manager.in (),
policies);
policies[0]->destroy ();
return 0;
}
int
ORB_Task::svc (void)
{
try
{
CORBA::Object_var ncRef =
orb_->string_to_object(
"corbaloc:iiop:10.175.12.99:15025/NameService" );
CORBA::PolicyList policies;
TimeBase::TimeT timeout = 5000 * 10000;
CORBA::Any timeoutAny;
timeoutAny <<= timeout;
policies.length(1);
policies[0] = orb_->create_policy(
Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
timeoutAny );
CORBA::Object_var object = ncRef->_set_policy_overrides(
policies, CORBA::SET_OVERRIDE );
policies[0]->destroy();
CosNaming::NamingContext_var namingContext =
CosNaming::NamingContext::_narrow( object.in() );
namingContext->_non_existent();
}
catch ( const CORBA::TRANSIENT&)
{
ACE_DEBUG ((LM_DEBUG, "Caught transient\n"));
}
catch ( const CORBA::TIMEOUT&)
{
ACE_DEBUG ((LM_DEBUG, "Caught timeout\n"));
}
catch ( const CORBA::Exception& e )
{
e._tao_print_exception ("Exception caught");
}
return 0;
}
void
createPOAs(ACE_CString &base)
{
PortableServer::LifespanPolicy_var life =
root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
PortableServer::IdAssignmentPolicy_var assign =
root_poa->create_id_assignment_policy(PortableServer::USER_ID);
CORBA::PolicyList pols;
pols.length(2);
pols[0] = PortableServer::LifespanPolicy::_duplicate(life.in());
pols[1] = PortableServer::IdAssignmentPolicy::_duplicate(assign.in());
PortableServer::POAManager_var mgr = PortableServer::POAManager::_nil();
ACE_CString poa_name = base + ACE_CString ("_a");
poa_a = root_poa->create_POA(poa_name.c_str(), mgr.in(), pols);
poa_name = base + ACE_CString ("_b");
poa_b = root_poa->create_POA(poa_name.c_str(), mgr.in(), pols);
}
CORBA::Object_ptr
ImR_Locator_i::set_timeout_policy (CORBA::Object_ptr obj, const ACE_Time_Value& to)
{
CORBA::Object_var ret (CORBA::Object::_duplicate (obj));
try
{
TimeBase::TimeT timeout;
ORBSVCS_Time::Time_Value_to_TimeT (timeout, to);
CORBA::Any tmp;
tmp <<= timeout;
CORBA::PolicyList policies (1);
policies.length (1);
policies[0] = orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
tmp);
ret = obj->_set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
if (CORBA::is_nil (ret.in ()))
{
if (debug_ > 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) ImR: Unable to set timeout policy.\n")));
}
ret = CORBA::Object::_duplicate (obj);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
ACE_TEXT ("(%P|%t) ImR_Locator_i::set_timeout_policy ()"));
}
return ret._retn ();
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the ORB first.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
int result = parse_args (argc, argv);
if (result != 0)
return result;
// Obtain the RootPOA.
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
// Get the POA_var object from Object_var.
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
// Get the POAManager of the RootPOA.
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Policies for the firstPOA to be created.
CORBA::PolicyList policies (3);
policies.length (3);
// Id Assignment Policy
policies[0] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
// Lifespan policy
policies[1] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
// Threading policy
policies[2] =
root_poa->create_thread_policy (PortableServer::ORB_CTRL_MODEL);
// Create the firstPOA under the RootPOA.
ACE_CString name = "firstPOA";
PortableServer::POA_var first_poa =
root_poa->create_POA (name.c_str (),
poa_manager.in (),
policies);
policies[2]->destroy ();
// Threading policy
policies[2] =
root_poa->create_thread_policy (PortableServer::SINGLE_THREAD_MODEL);
// Create the secondPOA under the firstPOA.
name = "secondPOA";
PortableServer::POA_var second_poa =
first_poa->create_POA (name.c_str (),
poa_manager.in (),
policies);
// Creation of POAs is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
// Create two Objects of Class test_i (defined in
// ./../GenericServant/test_i.h) Create one object at RootPOA
// and the other at firstPOA.
test_i first_servant (orb.in (),
root_poa.in ());
test_i second_servant (orb.in (),
first_poa.in ());
// Do "activate_object" to activate the first_servant object. It
// returns ObjectId for that object. Operation Used :
// ObjectId activate_object(in Servant p_servant)
// raises (ServantAlreadyActive, WrongPolicy);
PortableServer::ObjectId_var first_oid =
root_poa->activate_object (&first_servant);
// Get Object Reference for the first_servant object.
test_var first_test =
first_servant._this ();
// Get ObjectId for object secondtest and use that ObjectId to
// activate the second_servant object.
// Operation Used :
// void activate_object_with_id(in ObjectId oid, in Servant p_servant)
// raises (ObjectAlreadyActive, ServantAlreadyActive, WrongPolicy);
PortableServer::ObjectId_var second_oid =
PortableServer::string_to_ObjectId ("second test");
first_poa->activate_object_with_id (second_oid.in (),
&second_servant);
// Get Object reference for second_servant object.
test_var second_test =
second_servant._this ();
// Get ObjectId for the string thirdPOA Create the object reference
// for thirdPOA using that ObjectId. Operation Used :
// Object create_reference_with_id (in ObjectId oid, in CORBA::RepositoryId intf );
// This operation creates an object reference that encapsulates the
// specified Object Id and interface repository Id values.
/*
PortableServer::ObjectId_var third_oid =
PortableServer::string_to_ObjectId ("thirdtest");
*/
// This will test how the POA handles a user given ID
PortableServer::ObjectId_var third_oid =
PortableServer::string_to_ObjectId ("third test");
third_oid[5] = (CORBA::Octet) '\0';
CORBA::Object_var third_test =
second_poa->create_reference_with_id (third_oid.in (),
"IDL:test:1.0");
// Stringyfy all the object references and print them out.
CORBA::String_var first_ior =
orb->object_to_string (first_test.in ());
CORBA::String_var second_ior =
orb->object_to_string (second_test.in ());
CORBA::String_var third_ior =
orb->object_to_string (third_test.in ());
ACE_DEBUG ((LM_DEBUG,
"%C\n%C\n%C\n",
first_ior.in (),
second_ior.in (),
third_ior.in ()));
int write_result =
write_iors_to_file (first_ior.in (),
second_ior.in (),
third_ior.in ());
if (write_result != 0)
return write_result;
// Activate third servant using its ObjectID.
test_i third_servant (orb.in (),
second_poa.in ());
second_poa->activate_object_with_id (third_oid.in (),
&third_servant);
poa_manager->activate ();
orb->run ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
CORBA::ORB_var orb;
CORBA::Object_var obj;
PortableServer::POA_var root_poa;
PortableServer::POAManagerFactory_var poa_manager_factory;
if (parse_args (argc, argv) != 0)
return 1;
ACE_TCHAR *extra[4];
#ifdef ACE_USES_WCHAR
extra[0] = CORBA::wstring_dup (ACE_TEXT ("-ORBEndpoint"));
extra[1] =CORBA::wstring_alloc (100);
#else
extra[0] = CORBA::string_dup ("-ORBEndpoint");
extra[1] = CORBA::string_alloc (100);
#endif
ACE_OS::sprintf (extra[1],
ACE_TEXT ("iiop://localhost:%d/ssl_port=%d"),
endpoint_port, endpoint_port+1);
#ifdef ACE_USES_WCHAR
extra[2] = CORBA::wstring_dup (ACE_TEXT ("-ORBEndpoint"));
extra[3] = CORBA::wstring_alloc (100);
#else
extra[2] = CORBA::string_dup ("-ORBEndpoint");
extra[3] = CORBA::string_alloc (100);
#endif
ACE_OS::sprintf (extra[3],
ACE_TEXT ("iiop://localhost:%d/ssl_port=%d"),
endpoint_port+10, endpoint_port+11);
ACE_TCHAR **largv = new ACE_TCHAR *[argc+4];
int i = 0;
for (i = 0; i < argc; i++)
largv[i] = argv[i];
for (i = 0; i < 4; i++)
largv[argc+i] = extra[i];
argc += 4;
try
{
orb =
CORBA::ORB_init (argc, largv, "EndpointPolicy");
obj =
orb->resolve_initial_references("RootPOA");
root_poa =
PortableServer::POA::_narrow (obj.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
poa_manager_factory
= root_poa->the_POAManagerFactory ();
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception("initialization error ");
return 1;
}
for (i = 0; i < 4; i++)
#ifdef ACE_USES_WCHAR
CORBA::wstring_free (extra[i]);
#else
CORBA::string_free (extra[i]);
#endif
delete [] largv;
//-----------------------------------------------------------------------
// Create two valid endpoint policies. One to match each of the generated
// endpoint arguments supplied to ORB_init().
PortableServer::POAManager_var good_pm;
PortableServer::POAManager_var bad_pm;
CORBA::PolicyList policies;
policies.length (1);
EndpointPolicy::EndpointList list;
list.length (1);
list[0] = new IIOPEndpointValue_i("localhost", endpoint_port);
try
{
CORBA::Any policy_value;
policy_value <<= list;
policies[0] = orb->create_policy (EndpointPolicy::ENDPOINT_POLICY_TYPE,
policy_value);
good_pm = poa_manager_factory->create_POAManager ("goodPOAManager",
policies);
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception ("Failed to create reachable POA manager");
return 1;
}
try
{
PortableServer::ObjectId_var oid;
CORBA::Object_var o = CORBA::Object::_nil();
FILE *output_file= 0;
// Create poas assiciated with the each the good poa manager and the
// bad poa manager.
policies.length(0);
PortableServer::POA_var good_poa =
root_poa->create_POA ("goodPOA",
good_pm.in (),
policies);
ACE_DEBUG ((LM_DEBUG, "Creating IOR from good poa\n"));
o = good_poa->create_reference ("IDL:JustATest:1.0");
CORBA::String_var good_ior =
orb->object_to_string (o.in ());
output_file= ACE_OS::fopen (ior_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_file),
1);
ACE_OS::fprintf (output_file, "%s", good_ior.in ());
ACE_OS::fclose (output_file);
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception ("cannot run server");
}
root_poa->destroy (1, 1);
orb->destroy ();
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
CORBA::ORB_var orb;
try
{
orb = CORBA::ORB_init (argc, argv);
CORBA::Object_var root_poa_o =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var rootPOA =
PortableServer::POA::_narrow (root_poa_o.in ());
if (CORBA::is_nil (rootPOA.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"), 1);
}
PortableServer::POAManager_var poaMgr = rootPOA->the_POAManager ();
poaMgr->activate ();
CORBA::PolicyList policies;
policies.length (3);
policies[0] = rootPOA->create_id_assignment_policy (
PortableServer::SYSTEM_ID);
policies[1] = rootPOA->create_implicit_activation_policy (
PortableServer::NO_IMPLICIT_ACTIVATION);
policies[2] = rootPOA->create_lifespan_policy (
PortableServer::TRANSIENT);
PortableServer::POA_var fooPoa = rootPOA->create_POA (
"FOO_POA", poaMgr.in (), policies );
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
policies[i]->destroy ();
}
Foo_i servant;
PortableServer::ObjectId_var oid = fooPoa->activate_object( &servant );
CORBA::Object_var obj = fooPoa->id_to_reference (oid.in ());
foo_var client = foo::_narrow (obj.in());
client->check();
if (vc_check(client.in()))
{
orb->destroy();
return 1;
}
fooPoa->deactivate_object (oid.in () ); //servant is gone
if (vc_check(client.in(), false)) //exception expected
{
orb->destroy();
return 2;
}
}
catch(...)
{
return 3;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
PortableInterceptor::ORBInitializer_ptr tmp;
ACE_NEW_RETURN (tmp,
ServerORBInitializer,
-1); // No CORBA exceptions yet!
PortableInterceptor::ORBInitializer_var orb_initializer = tmp;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "ORT Test ORB");
if (parse_args (argc, argv) != 0)
return -1;
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
// Narrow
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
// Check for nil references
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
"Unable to obtain RootPOA reference.\n"),
-1);
// Get poa_manager reference
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Activate it.
poa_manager->activate ();
CORBA::PolicyList policies (0);
policies.length (0);
// Lets create some POA's
PortableServer::POA_var first_poa =
root_poa->create_POA ("FIRST_POA",
poa_manager.in (),
policies);
PortableServer::POA_var second_poa =
first_poa->create_POA ("SECOND_POA",
poa_manager.in (),
policies);
PortableServer::POA_var third_poa =
second_poa->create_POA ("THIRD_POA",
poa_manager.in (),
policies);
PortableServer::POA_var fourth_poa =
third_poa->create_POA ("FOURTH_POA",
poa_manager.in (),
policies);
ORT_test_i ort_test_impl (orb.in ());
PortableServer::ObjectId_var oid =
fourth_poa->activate_object (&ort_test_impl);
obj = fourth_poa->servant_to_reference (&ort_test_impl);
// Convert the object reference to a string format.
CORBA::String_var ior =
orb->object_to_string (obj.in ());
// Dump it to a file.
if (ior_output_file != 0)
{
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file %s for writing "
"IOR: %C",
ior_output_file,
ior.in ()),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
orb->run ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("ORT test server:");
return -1;
}
return 0;
}