int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.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] = 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); // Creation of childPOA is over. Destroy the Policy objects. for (CORBA::ULong i = 0; i < policies.length (); ++i) { policies[i]->destroy (); } poa_manager->activate (); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = orb->string_to_object (ior); Simple_Server_var server = Simple_Server::_narrow (object.in ()); if (CORBA::is_nil (server.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%C> is nil\n", ior), 1); } Callback_i callback_impl (orb.in ()); PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("client_callback"); child_poa->activate_object_with_id (id.in (), &callback_impl); CORBA::Object_var callback_object = child_poa->id_to_reference (id.in ()); Callback_var callback = Callback::_narrow (callback_object.in ()); CORBA::String_var ior = orb->object_to_string (callback.in ()); ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client callback activated as <%C>\n", ior.in ())); // Send the calback object to the server server->callback_object (callback.in ()); int pre_call_connections = orb->orb_core ()->lane_resources ().transport_cache ().current_size (); // A method to kickstart callbacks from the server CORBA::Long r = server->test_method (1); if (r != 0) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) unexpected result = %d ", r)); } orb->run (); int cur_connections = orb->orb_core ()->lane_resources ().transport_cache ().current_size (); if (cur_connections > pre_call_connections) { ACE_ERROR ((LM_ERROR, "(%P|%t) Expected %d " "connections in the transport cache, but found " "%d instead. Aborting.\n", pre_call_connections, cur_connections)); ACE_OS::abort (); } root_poa->destroy (1, 1); } catch (CORBA::Exception &excep) { excep._tao_print_exception ("Caught exception:"); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.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] = 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); // Creation of childPOA is over. Destroy the Policy objects. for (CORBA::ULong i = 0; i < policies.length (); ++i) { policies[i]->destroy (); } poa_manager->activate (); if (parse_args (argc, argv) != 0) return 1; Simple_Server_i server_impl (orb.in (), no_iterations); PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("simple_server"); child_poa->activate_object_with_id (id.in (), &server_impl); CORBA::Object_var obj = child_poa->id_to_reference (id.in ()); CORBA::String_var ior = orb->object_to_string (obj.in ()); ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ())); // If the ior_output_file exists, output the ior to it 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 for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); } int retval = 0; while (retval == 0) { // Just process one upcall. We know that we would get the // clients IOR in that call. CORBA::Boolean pending = orb->work_pending(); if (pending) { orb->perform_work(); } // Now that hopefully we have the clients IOR, just start // making remote calls to the client. retval = server_impl.call_client (); } ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, 1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); return 1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize orb CORBA::ORB_var orb = CORBA::ORB_init( argc, argv ); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var obj = orb->resolve_initial_references("Test"); if (CORBA::is_nil(obj.in())) { ACE_DEBUG ((LM_DEBUG, "Client could not RIR Test\n")); return 1; } Test_var test = Test::_narrow( obj.in() ); if (CORBA::is_nil(test.in())) { ACE_DEBUG ((LM_DEBUG, "Client could not narrow Test\n")); return 1; } test->_stubobj()->reset_profiles(); test->foo (); CORBA::Any a; a <<= Messaging::SYNC_WITH_SERVER; CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, a); obj = test->_set_policy_overrides (policy_list, CORBA::ADD_OVERRIDE); test = Test::_narrow ( obj.in()); test->_stubobj()->reset_profiles(); test->foo (); CORBA::Short n = test->get_call_count(); ACE_DEBUG ((LM_DEBUG, "Got call count of %d\n", n)); return n != 1; } catch(const CORBA::Exception& ex) { ex._tao_print_exception ("client:"); } return -1; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int retval = 1; try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = orb->string_to_object(ior); CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent"); CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (object.in ()); CORBA::Any timeout_as_any; timeout_as_any <<= timeout_period; CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = orb->create_policy (TAO::CONNECTION_TIMEOUT_POLICY_TYPE, timeout_as_any); policy_current->set_policy_overrides (policy_list, CORBA::ADD_OVERRIDE); for (CORBA::ULong l = 0; l != policy_list.length (); ++l) { policy_list[l]->destroy (); } retval = test_timeout (tmp.in ()); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return retval; }
void Echo_Client_ORBInitializer::post_init ( PortableInterceptor::ORBInitInfo_ptr info) { // TAO-Specific way to get to the ORB Core (and thus, the ORB). TAO_ORBInitInfo_var tao_info = TAO_ORBInitInfo::_narrow (info); CORBA::ORB_var orb = CORBA::ORB::_duplicate(tao_info->orb_core()->orb()); if (CORBA::is_nil(orb.in())) { throw CORBA::INTERNAL (); } PortableInterceptor::ORBInitInfo_3_1_var info_3_1 = PortableInterceptor::ORBInitInfo_3_1::_narrow(info); if (CORBA::is_nil(info_3_1.in())) { throw CORBA::INTERNAL (); } PortableInterceptor::ClientRequestInterceptor_ptr interceptor = PortableInterceptor::ClientRequestInterceptor::_nil (); // Install the Echo client request interceptor ACE_NEW_THROW_EX (interceptor, Echo_Client_Request_Interceptor, CORBA::NO_MEMORY ()); PortableInterceptor::ClientRequestInterceptor_var client_interceptor = interceptor; CORBA::Any client_proc_mode_as_any; client_proc_mode_as_any <<= this->processing_mode_; CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = orb->create_policy (PortableInterceptor::PROCESSING_MODE_POLICY_TYPE, client_proc_mode_as_any); info_3_1->add_client_request_interceptor_with_policy ( client_interceptor.in (), policy_list); policy_list[0]->destroy (); policy_list[0] = CORBA::Policy::_nil (); }
CORBA::Object_ptr register_with_proxy (CORBA::Object_ptr native) { // Disable protection for this insecure invocation test. Security::QOP qop = Security::SecQOPNoProtection; CORBA::Any no_protection; no_protection <<= qop; // Create the Security::QOPPolicy. CORBA::Policy_var policy = orb->create_policy (Security::SecQOPPolicy, no_protection); CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = CORBA::Policy::_duplicate (policy.in ()); // Create an object reference that uses plain IIOP (i.e. no // protection). CORBA::Object_var object = mapper->_set_policy_overrides (policy_list, CORBA::SET_OVERRIDE); ACE_DEBUG ((LM_DEBUG,"Trying to narrow an insecure reference\n")); Lorica::ReferenceMapper_var open_mapper = Lorica::ReferenceMapper::_narrow(object.in()); ACE_DEBUG ((LM_DEBUG,"Using open mapper for registering\n")); try { return open_mapper->as_server(native,"Hello", Lorica::ServerAgent::_nil()); } catch (CORBA::Exception &ex) { ACE_DEBUG ((LM_DEBUG,"open_mapper->as_server raised %s\n",ex._name())); return CORBA::Object::_nil(); } }
CORBA::Object_ptr set_timeout_policy (CORBA::Object_ptr obj, const ACE_Time_Value& to) { CORBA::Object_var ret; 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 ())) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Unable to set timeout policy.\n"))); ret = CORBA::Object::_duplicate (obj); } } catch (const CORBA::Exception& ex) { ex._tao_print_exception (ACE_TEXT ("set_timeout_policy ()")); ret = CORBA::Object::_duplicate (obj); } return ret._retn (); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize orb CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Get reference to Root POA. CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var rootpoa = PortableServer::POA::_narrow (obj.in ()); // Activate POA manager PortableServer::POAManager_var mgr = rootpoa->the_POAManager (); mgr->activate (); PortableServer::POA_var poa; TAO::Utils::PolicyList_Destroyer PolicyList (3); PolicyList.length (3); PolicyList [0] = rootpoa->create_lifespan_policy (PortableServer::PERSISTENT); PolicyList [1] = rootpoa->create_id_assignment_policy (PortableServer::USER_ID); CORBA::Any CallbackPolicy; CallbackPolicy <<= BiDirPolicy::BOTH; const char* sServerPoaName = "TelemetryServer"; PolicyList [2] = orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, CallbackPolicy); poa = rootpoa->create_POA (sServerPoaName, mgr.in(), PolicyList); PortableServer::ObjectId_var ServerId = PortableServer::string_to_ObjectId ("TimeServer"); // Create an object Time_impl *time_servant = new Time_impl; PortableServer::ServantBase_var self_manage (time_servant); poa->activate_object_with_id (ServerId.in (), time_servant); // Get a reference after activating the object CORBA::Object_var object = poa->id_to_reference (ServerId.in ()); TimeModule::Time_var tm = TimeModule::Time::_narrow (object.in ()); // Get reference to initial naming context CORBA::Object_var name_obj = orb->resolve_initial_references ("NameService"); CosNaming::NamingContext_var inc = CosNaming::NamingContext::_narrow (name_obj.in ()); if (CORBA::is_nil (inc.in ())) { ACE_ERROR ((LM_ERROR, "(%P|%t) Error fetching naming context\n")); } CosNaming::Name service_name; service_name.length(1); service_name[0].id = CORBA::string_dup ("Time"); inc->rebind (service_name, tm.in ()); // Run the event loop for fun ACE_Time_Value tv (3, 0); // Accept requests orb->run (&tv); rootpoa->destroy (0 , 0); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught an exception\n"); return -1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int priority = (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, priority); // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, priority, ACE_SCOPE_PROCESS)) != 0) { if (ACE_OS::last_error () == EPERM) { ACE_DEBUG ((LM_DEBUG, "server (%P|%t): user is not superuser, " "test runs in time-shared class\n")); } else ACE_ERROR ((LM_ERROR, "server (%P|%t): sched_params failed\n")); } try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var manager_object = orb->resolve_initial_references ("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (manager_object.in ()); CORBA::Any sync_scope; sync_scope <<= Messaging::SYNC_WITH_TARGET; CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, sync_scope); policy_manager->set_policy_overrides (policy_list, CORBA::SET_OVERRIDE); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); poa_manager->activate (); if (parse_args (argc, argv) != 0) return 1; Server_i server_i; Test::Server_var server = server_i._this (); CORBA::String_var str = orb->object_to_string (server.in ()); if (ior_file_name != 0) { FILE *output_file = ACE_OS::fopen (ior_file_name, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_file_name), 1); ACE_OS::fprintf (output_file, "%s", str.in ()); ACE_OS::fclose (output_file); } while (!server_i.done ()) { ACE_Time_Value tv (1, 0); orb->run (tv); } PortableServer::ObjectId_var id = root_poa->servant_to_id (&server_i); root_poa->deactivate_object (id.in ()); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception (argv[0]); } return 0; }
int main( int argc, char *argv[] ) { try { // Initialize orb CORBA::ORB_var orb = CORBA::ORB_init( argc, argv ); // Destringify ior CORBA::Object_var obj = orb->string_to_object( "file://IOR" ); if( CORBA::is_nil( obj.in() ) ) { cerr << "Nil reference" << endl; throw 0; } // Narrow CallbackServer_var cb_server = CallbackServer::_narrow( obj.in() ); if( CORBA::is_nil( cb_server.in() ) ) { cerr << "Argument is not a CallbackServer reference" << endl; throw 0; } //Get reference to Root POA obj = orb->resolve_initial_references( "RootPOA" ); PortableServer::POA_var poa = PortableServer::POA::_narrow( obj.in() ); // Policies for the childPOA to be created. CORBA::PolicyList policies (4); policies.length (4); CORBA::Any pol; pol <<= BiDirPolicy::BOTH; policies[0] = orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, pol); policies[1] = poa->create_id_assignment_policy(PortableServer::SYSTEM_ID); policies[2] = poa->create_implicit_activation_policy( PortableServer::IMPLICIT_ACTIVATION ); policies[3] = poa->create_lifespan_policy(PortableServer::TRANSIENT); PortableServer::POAManager_var mgr = poa->the_POAManager(); // 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 = poa->create_POA ("childPOA", mgr.in(), policies); // Creation of childPOA is over. Destroy the Policy objects. for (CORBA::ULong i = 0; i < policies.length (); ++i) { policies[i]->destroy (); } // Activate POA Manager mgr->activate(); // Create an object ClientCallback_i servant; // Register the servant with the RootPOA, obtain its object // reference, stringify it, and write it to a file. obj = child_poa->servant_to_reference( &servant ); //ClientCallback_var ccb = ClientCallback::_narrow( obj.in() ); cb_server->callback_hello( ClientCallback::_narrow( obj.in() ), CORBA::string_dup( "Greetings earthling" )); } catch( const CORBA::Exception &ex ) { cerr << "Uncaught CORBA exception: " << ex << endl; return 1; } }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int ret_val = 0; try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); 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_WITH_SERVER; 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 (); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = orb->string_to_object(ior); Test::Peer_var peer = Test::Peer::_narrow(tmp.in ()); if (CORBA::is_nil (peer.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil Test::Peer reference <%s>\n", ior), 1); } while(1) { peer->noop (); } /* Warning with TRU 64 builds ACE_DEBUG ((LM_DEBUG, "(%P|%t) scavenger - event loop finished\n")); orb->destroy (); */ } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); ret_val = 1; } return ret_val; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { CORBA::ORB_var orb = CORBA::ORB::_nil(); PortableServer::POA_var root_poa = PortableServer::POA::_nil(); Callback_i *servant = 0; try { orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.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] = 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); // Creation of childPOA is over. Destroy the Policy objects. for (CORBA::ULong i = 0; i < policies.length (); ++i) { policies[i]->destroy (); } poa_manager->activate (); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = orb->string_to_object (ior); Simple_Server_var server = Simple_Server::_narrow (object.in ()); if (CORBA::is_nil (server.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil\n", ior), 1); } servant = new Callback_i (orb.in ()); Callback_var callback = servant->_this (); // Send the calback object to the server server->callback_object (callback.in ()); // A method to kickstart callbacks from the server CORBA::Long r = server->test_method (1); if (r != 0) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) unexpected result = %d ", r)); } orb->run (); root_poa->destroy (1, 1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); return 1; } if (!CORBA::is_nil(root_poa.in())) root_poa->destroy (1,1); delete servant; return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); 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 (); if (parse_args (argc, argv) != 0) return 1; // Get the sender reference.. CORBA::Object_var tmp = orb->string_to_object(ior); Test::Sender_var sender = Test::Sender::_narrow(tmp.in ()); if (CORBA::is_nil (sender.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil coordinator reference <%s>\n", ior), 1); } Client_Task client_task (orb.in(), sender.in (), ACE_Thread_Manager::instance (), number_of_oneways); Server_Task server_task (orb.in (), ACE_Thread_Manager::instance ()); // Before creating threads we will let the sender know that we // will have two threads that would make invocations.. // this is the first oneway we do, so after this we would have a queue // on one of the transports sender->active_objects ((CORBA::Short) number_of_client_tasks); TAO::Transport_Cache_Manager& manager = orb->orb_core()->lane_resources ().transport_cache (); TAO::Transport_Cache_Manager::HASH_MAP& cachemap = manager.map(); TAO::Transport_Cache_Manager::HASH_MAP_ITER end_iter = cachemap.end (); bool tranportwithqueue = false; for (TAO::Transport_Cache_Manager::HASH_MAP_ITER iter = cachemap.begin (); iter != end_iter; ++iter) { TAO_Transport* transport = (*iter).int_id_.transport (); if (transport->queue_is_empty() == 0 && transport->is_connected() == false) { tranportwithqueue = true; break; } } if (!tranportwithqueue) { ACE_ERROR ((LM_ERROR, "(%P|%t) Error: expect a not connected transport with a queue\n")); } else { ACE_DEBUG((LM_DEBUG, "(%P|%t) Found not connected transport with a queue\n")); } if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 2,1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, number_of_client_tasks, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); ACE_DEBUG ((LM_DEBUG, "Event Loop finished\n")); orb->destroy (); if (tranportwithqueue == false) { return 1; } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); if (CORBA::is_nil (root_poa.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "backend_server(%P|%t) - panic: nil RootPOA\n"), 1); } PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = orb->string_to_object(ior); // one second in TimeT units TimeBase::TimeT const second = 10 * TimeBase::TimeT(1000000); CORBA::Any timeout_as_any; timeout_as_any <<= TimeBase::TimeT(timeout * second); CORBA::Any scope_as_any; scope_as_any <<= scope; TAO::Utils::PolicyList_Destroyer plist(1); plist.length(2); plist[0] = orb->create_policy(Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, timeout_as_any); plist[1] = orb->create_policy(Messaging::SYNC_SCOPE_POLICY_TYPE, scope_as_any); CORBA::PolicyCurrent_var policy_current = TAO::Utils::RIR_Narrow<CORBA::PolicyCurrent>::narrow( orb.in (), "PolicyCurrent"); policy_current->set_policy_overrides( plist, CORBA::ADD_OVERRIDE); Bug_3647_Regression::Backend_var backend = Bug_3647_Regression::Backend::_narrow(tmp.in ()); if (CORBA::is_nil (backend.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "middle_server(%P|%t) - nil backend reference <%s>\n", ior), 1); } using namespace Bug_3647_Regression; PortableServer::ServantBase_var impl( new Middle_Impl(backend.in(), orb.in(), verbose, timeout)); PortableServer::ObjectId_var id = root_poa->activate_object (impl.in()); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); Bug_3647_Regression::Middle_var middle = Bug_3647_Regression::Middle::_narrow (object.in ()); CORBA::String_var ior = orb->object_to_string (middle.in ()); // Output the IOR to the <ior_output_file> FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "middle_server(%P|%t) - Cannot open output file " "for writing IOR: %s\n", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run (); ACE_DEBUG ((LM_DEBUG, "middle_server(%P|%t) - event loop finished\n")); root_poa->destroy (1, 1); orb->destroy (); } catch (const CORBA::Exception& ex) { ACE_DEBUG ((LM_DEBUG, "middle_server")); 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[]) { try { CORBA::ORB_var orb = CORBA::ORB_init( argc, argv ); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var obj = orb->string_to_object( ior ); Messenger_var messenger = Messenger::_narrow( obj.in() ); CORBA::String_var message = CORBA::string_dup( "Terminating messenger service!" ); messenger->send_message( "Chief of Security", "New Directive", message.inout() ); messenger->shutdown("Chief of Security"); Security::QOP qop = Security::SecQOPIntegrityAndConfidentiality; CORBA::Any want_protection; want_protection <<= qop; CORBA::Policy_var policy = orb->create_policy (Security::SecQOPPolicy, want_protection); Security::EstablishTrust establish_trust; establish_trust.trust_in_client = 0; establish_trust.trust_in_target = 1; CORBA::Any want_trust; want_trust <<= establish_trust; CORBA::Policy_var policy2 = orb->create_policy (Security::SecEstablishTrustPolicy, want_trust); CORBA::PolicyList policy_list (2); policy_list.length (1); policy_list[0] = CORBA::Policy::_duplicate (policy.in ()); policy_list.length (2); policy_list[1] = CORBA::Policy::_duplicate (policy2.in ()); CORBA::Object_var object = obj->_set_policy_overrides (policy_list, CORBA::SET_OVERRIDE); Messenger_var messenger2 = Messenger::_narrow( object.in() ); message = CORBA::string_dup( "Terminating messenger service!" ); messenger2->send_message( "Chief of Security", "New Directive", message.inout() ); messenger2->shutdown("Chief of Security"); orb->destroy(); } catch(const CORBA::Exception& ex) { ex._tao_print_exception("Client: main block"); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); if (parse_args(argc, argv) != 0) { return 1; } // Create a bidirectional POA CORBA::Object_var obj = orb->resolve_initial_references("RootPOA"); 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] = 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 poa = root_poa->create_POA("bidirPOA", poa_manager.in(), policies); // Creation of bidirPOA is over. Destroy the Policy objects. for (CORBA::ULong i = 0; i < policies.length (); ++i) { policies[i]->destroy (); } poa_manager->activate (); PortableServer::Servant_var<Simple_i> svt = new Simple_i(orb.in(), callback_count); // Register and activate Simple servant PortableServer::ObjectId_var id = poa->activate_object(svt.in()); obj = poa->id_to_reference(id.in()); Simple_var server = Simple::_narrow(obj.in()); CORBA::String_var ior = orb->object_to_string(server.in()); if (ior_output_file != ACE_TEXT("")) { std::ofstream outfile(ACE_TEXT_ALWAYS_CHAR(ior_output_file.c_str())); outfile << ior.in(); } std::cout << "Activated as " << ior.in() << std::endl; // Our own special orb->run() that knows how to callback clients while (true) { // returns 1 as soon as it has successfully called back. if (svt->call_client()) { break; } // We don't want to check for work pending, because we really want // to simulate a normal orb->run() while adding the ability to call // our routine which calls back to the client. orb->perform_work(); } std::cout << "Event loop finished." << std::endl; CORBA::Boolean etherealize = true, wait = true; poa->destroy(etherealize, wait); orb->destroy(); return 0; } catch(const CORBA::Exception& ex) { std::cerr << "Caught CORBA::Exception: " << std::endl << ex << std::endl; } return 1; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); if (CORBA::is_nil (root_poa.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil RootPOA\n"), 1); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); // Make all oneways "reliable." { CORBA::Object_var manager_object = orb->resolve_initial_references("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow(manager_object.in()); if (CORBA::is_nil (policy_manager.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil PolicyManager\n"), 1); CORBA::Any policy_value; policy_value <<= Messaging::SYNC_WITH_SERVER; CORBA::PolicyList policies(1); policies.length(1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, policy_value); policy_manager->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); policies[0]->destroy (); } if (parse_args (argc, argv) != 0) return 1; Service *service_impl; ACE_NEW_RETURN (service_impl, Service(orb.in ()), 1); PortableServer::ServantBase_var owner_transfer(service_impl); PortableServer::ObjectId_var id = root_poa->activate_object (service_impl); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); Test::Service_var service = Test::Service::_narrow (object.in ()); CORBA::String_var ior = orb->object_to_string (service.in ()); // If the ior_output_file exists, output the ior to it FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run (); ACE_DEBUG ((LM_DEBUG, "Event loop finished\n")); root_poa->destroy (1, 1); 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[]) { int retval = 0; try { // Initialise ORB CORBA::ORB_var Orb = CORBA::ORB_init(argc, argv); // Set round-trip timeout const int timeout_secs = 5; CORBA::Object_var obj = Orb->resolve_initial_references ("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (obj.in()); CORBA::PolicyList policy_list; policy_list.length(0); policy_manager->set_policy_overrides(policy_list, CORBA::SET_OVERRIDE); TimeBase::TimeT timeout = timeout_secs * 10000000; CORBA::Any orb_timeout; orb_timeout <<= timeout; policy_list.length(1); policy_list[0] = Orb->create_policy( Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, orb_timeout); policy_manager->set_policy_overrides(policy_list, CORBA::SET_OVERRIDE); // Now try to contact a server. // Use a remote machine that is unreachable on the network. const char * obj_ref = "corbaloc:iiop:[email protected]:4567/NameService"; obj = Orb->string_to_object(obj_ref); CosNaming::NamingContext_var inc; if(!CORBA::is_nil(obj.in ())) { ACE_DEBUG(( LM_INFO, "Attempting to contact %C\n", obj_ref )); try { inc = CosNaming::NamingContext::_narrow(obj.in()); ACE_DEBUG(( LM_INFO, "OK\n" )); } catch(const CORBA::TRANSIENT &) { ACE_ERROR ((LM_ERROR, "Error, caught transient exception\n")); retval = 1; } catch(const CORBA::TIMEOUT &) { ACE_DEBUG ((LM_DEBUG, "Caught correct timeout\n")); } } } catch (const ::CORBA::Exception &ex) { ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :"); ++retval; } return retval; }
int initORB(int threadID) { try { char ORBid[10]; ACE_OS::sprintf (ORBid, "ORB_%d", threadID); ACE_DEBUG ((LM_DEBUG, "Initializing ORB \"%C\"\n", ORBid)); if ( g_registerORBinitializer ) { ACE_DEBUG ((LM_DEBUG, "Creating ORB initializer\n")); PortableInterceptor::ORBInitializer_var rCOI( new MyORBinitializer( ORBid ) ); PortableInterceptor::register_orb_initializer( rCOI.in() ); } ACE_DEBUG ((LM_DEBUG, "Creating TAO_ORB_Manager\n")); TAO_ORB_Manager* pORBmgr = new TAO_ORB_Manager; if ( -1 == pORBmgr->init( g_argc, g_argv, ORBid ) ) { ACE_DEBUG ((LM_DEBUG, "Failed to initialize ORB \"%C\"\n", ORBid)); throw CORBA::INTERNAL(); } ACE_DEBUG ((LM_DEBUG, "ORB \"%C\" initialized\n", ORBid)); if ( g_setTimeout ) { ACE_DEBUG ((LM_DEBUG, "Setting connection timeout policy for ORB \"%C\"\n", ORBid)); CORBA::PolicyList policyList; CORBA::ORB_var orb = pORBmgr->orb(); TimeBase::TimeT connectionTimeout = 100*10000; CORBA::Any any; any <<= connectionTimeout; CORBA::ULong l( policyList.length() ); policyList.length( l+1 ); policyList[l] = orb->create_policy( TAO::CONNECTION_TIMEOUT_POLICY_TYPE, any ); ACE_DEBUG ((LM_DEBUG, "Connection timeout policy set for ORB \"%C\"\n", ORBid)); } pORBmgr->fini(); delete pORBmgr; } catch (const CORBA::Exception& ex) { ACE_ERROR ((LM_ERROR, "Caught exception: %C\n", ex._info().c_str())); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); if (CORBA::is_nil (root_poa.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil RootPOA\n"), 1); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); // Make all oneways "reliable." { CORBA::Object_var manager_object = orb->resolve_initial_references("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow(manager_object.in()); if (CORBA::is_nil (policy_manager.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil PolicyManager\n"), 1); CORBA::Any policy_value; policy_value <<= Messaging::SYNC_WITH_SERVER; CORBA::PolicyList policies(1); policies.length(1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, policy_value); policy_manager->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); policies[0]->destroy (); } if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = orb->string_to_object(ior); Test::Service_var service = Test::Service::_narrow(tmp.in ()); if (CORBA::is_nil (service.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil service reference <%s>\n", ior), 1); } Callback *callback_impl; ACE_NEW_RETURN (callback_impl, Callback(orb.in ()), 1); PortableServer::ServantBase_var owner_transfer(callback_impl); PortableServer::ObjectId_var id = root_poa->activate_object (callback_impl); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); Test::Callback_var callback = Test::Callback::_narrow (object.in ()); poa_manager->activate (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - starting test\n")); service->run_test (callback.in ()); ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - running ORB\n")); orb->run (); root_poa->destroy (1, 1); 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[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager(); Publisher_impl publisher(orb.in ()); PortableServer::ObjectId_var id = root_poa->activate_object (&publisher); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); Publisher_var publisher_var = Publisher::_narrow (object.in ()); CORBA::String_var ior = orb->object_to_string(publisher_var.in()); ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in())); // output the ior FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s\n", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate(); const CORBA::Object_var pmobj (orb->resolve_initial_references("ORBPolicyManager" ) ); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow(pmobj.in() ); CORBA::Any orb_level; orb_level <<= Messaging::SYNC_NONE; CORBA::PolicyList policy_list; policy_list.length(1); policy_list[0] = orb->create_policy(Messaging::SYNC_SCOPE_POLICY_TYPE, orb_level); policy_manager->set_policy_overrides(policy_list, CORBA::SET_OVERRIDE); ThreadPool pool (orb.in ()); if (pool.activate(THR_NEW_LWP | THR_JOINABLE, 5) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate client threads\n"), 1); pool.thr_mgr ()->wait (); ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return 1; // Primary server CORBA::Object_var object_primary = orb->string_to_object (ior); //Secondary server CORBA::Object_var object_secondary = orb->string_to_object (name); // Get an object reference for the ORBs IORManipultion object! CORBA::Object_var IORM = orb->resolve_initial_references (TAO_OBJID_IORMANIPULATION, 0); TAO_IOP::TAO_IOR_Manipulation_var iorm = TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in ()); TAO_IOP::TAO_IOR_Manipulation::IORList iors (2); iors.length(2); iors [0] = object_primary; iors [1] = object_secondary; CORBA::Object_var merged = iorm->merge_iors (iors); CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent"); CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (object.in ()); CORBA::Any timeout_as_any; timeout_as_any <<= timeout_period; CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = orb->create_policy (TAO::CONNECTION_TIMEOUT_POLICY_TYPE, timeout_as_any); policy_current->set_policy_overrides (policy_list, CORBA::ADD_OVERRIDE); for (CORBA::ULong l = 0; l != policy_list.length (); ++l) { policy_list[l]->destroy (); } // Combined IOR stuff Simple_Server_var server = Simple_Server::_narrow (merged.in ()); if (CORBA::is_nil (server.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil.\n", ior), 1); } CORBA::ULongLong freq = run_test (server.in ()); if (freq != 919263) ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) ERROR in the test\n"))); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Shutting server down\n"))); server->shutdown (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught an exception\n"); return -1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.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] = 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); // Creation of childPOA is over. Destroy the Policy objects. for (CORBA::ULong i = 0; i < policies.length (); ++i) { policies[i]->destroy (); } poa_manager->activate (); CORBA::Object_var object = orb->string_to_object (ior); Sender_var sender = Sender::_narrow (object.in ()); if (CORBA::is_nil (sender.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil.\n", ior), 1); } Receiver_i *receiver; ACE_NEW_RETURN (receiver, Receiver_i (), -1); PortableServer::ServantBase_var owner_transfer (receiver); PortableServer::ObjectId_var id = root_poa->activate_object (receiver); CORBA::Object_var object_act = root_poa->id_to_reference (id.in ()); Receiver_var receiver_obj = Receiver::_narrow (object_act.in ()); // Send the calback object to the server sender->receiver_object (receiver_obj.in ()); // Threads that will handle the call backs Client_Task client_task (orb.in (), ACE_Thread_Manager::instance ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 4, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); CORBA::Long count = receiver->get_event_count (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) Number of events received.. [%d]\n", count)); root_poa->destroy (1, 1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); if (CORBA::is_nil (root_poa.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil RootPOA\n"), 1); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); 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_WITH_TRANSPORT; 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 (); if (parse_args (argc, argv) != 0) return 1; PortableServer::Servant_var<Echo> impl; { Echo * tmp; // ACE_NEW_RETURN is the worst possible way to handle // exceptions (think: what if the constructor allocates memory // and fails?), but I'm not in the mood to fight for a more // reasonable way to handle allocation errors in ACE. ACE_NEW_RETURN (tmp, Echo (orb.in (), 100), 1); impl = tmp; } PortableServer::ObjectId_var id = root_poa->activate_object (impl.in ()); CORBA::Object_var object_act = root_poa->id_to_reference (id.in ()); Test::Echo_var echo = Test::Echo::_narrow (object_act.in ()); CORBA::Object_var tmp = orb->string_to_object(ior); Test::Echo_Caller_var server = Test::Echo_Caller::_narrow(tmp.in ()); if (CORBA::is_nil (echo.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil Test::Echo_Caller reference <%s>\n", ior), 1); } poa_manager->activate (); Client_Task ctask (orb.in ()); server->start_task (echo.in()); if (ctask.activate (THR_NEW_LWP | THR_JOINABLE, 4, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); return 1; } ACE_Thread_Manager::instance ()->wait (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - event loop finished\n")); // Actually the code here should never be reached. root_poa->destroy (1, 1); 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[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = orb->string_to_object(ior); Test::Hello_var hello = Test::Hello::_narrow(tmp.in ()); if (CORBA::is_nil (hello.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil Test::Hello reference <%s>\n", ior), 1); } CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); poa_manager->activate (); CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent"); CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (object.in ()); TimeBase::TimeT timeout_period = 10 * 1000; CORBA::Any timeout_as_any; timeout_as_any <<= timeout_period; CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, timeout_as_any); policy_current->set_policy_overrides (policy_list, CORBA::ADD_OVERRIDE); // Let the client perform the test in a separate thread Client_Task client (hello.in (), orb.in (), ACE_Thread_Manager::instance ()); if (client.activate (THR_NEW_LWP | THR_JOINABLE, 8) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate client threads\n"), 1); client.thr_mgr ()->wait (); root_poa->destroy (1, // ethernalize objects 0 // wait for completion ); 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[]) { TAO_EC_Default_Factory::init_svcs (); int priority = (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, priority); // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, priority, ACE_SCOPE_PROCESS)) != 0) { if (ACE_OS::last_error () == EPERM) { ACE_DEBUG ((LM_DEBUG, "server (%P|%t): user is not superuser, " "test runs in time-shared class\n")); } else ACE_ERROR ((LM_ERROR, "server (%P|%t): sched_params failed\n")); } try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); #if (TAO_HAS_CORBA_MESSAGING == 1) CORBA::Object_var manager_object = orb->resolve_initial_references ("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (manager_object.in ()); CORBA::Any sync_scope; sync_scope <<= Messaging::SYNC_WITH_TARGET; CORBA::PolicyList policy_list (1); policy_list.length (1); policy_list[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, sync_scope); policy_manager->set_policy_overrides (policy_list, CORBA::SET_OVERRIDE); #else ACE_DEBUG ((LM_DEBUG, "CORBA Messaging disabled in this configuration," " test may not be optimally configured\n")); #endif /* TAO_HAS_MESSAGING */ CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); poa_manager->activate (); if (parse_args (argc, argv) != 0) return 1; TAO_EC_Event_Channel_Attributes attr (root_poa.in (), root_poa.in ()); TAO_EC_Event_Channel ec_impl (attr); ec_impl.activate (); RtecEventChannelAdmin::EventChannel_var ec = ec_impl._this (); CORBA::String_var str = orb->object_to_string (ec.in ()); if (ior_file_name != 0) { FILE *output_file= ACE_OS::fopen (ior_file_name, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_file_name), 1); ACE_OS::fprintf (output_file, "%s", str.in ()); ACE_OS::fclose (output_file); } orb->run (); PortableServer::ObjectId_var id = root_poa->servant_to_id (&ec_impl); root_poa->deactivate_object (id.in ()); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception (argv[0]); } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); if (CORBA::is_nil (root_poa.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil RootPOA\n"), 1); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); 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 (); if (parse_args (argc, argv) != 0) return 1; PortableServer::Servant_var<Echo_Caller> impl; { Echo_Caller * tmp; // ACE_NEW_RETURN is the worst possible way to handle // exceptions (think: what if the constructor allocates memory // and fails?), but I'm not in the mood to fight for a more // reasonable way to handle allocation errors in ACE. ACE_NEW_RETURN (tmp, Echo_Caller(orb.in()), 1); impl = tmp; } PortableServer::ObjectId_var id = root_poa->activate_object (impl.in ()); CORBA::Object_var object_act = root_poa->id_to_reference (id.in ()); Test::Echo_Caller_var server = Test::Echo_Caller::_narrow (object_act.in ()); CORBA::String_var ior = orb->object_to_string (server.in ()); // If the ior_output_file exists, output the ior to it FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run(); ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); root_poa->destroy (1, 1); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in server:"); return 1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize orb CORBA::ORB_var orb = CORBA::ORB_init( argc, argv ); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var obj; //Specify the relative round trip policy if (rt_timeout_msecs > 0) { // Timeout specified in hundreds of nanoseconds which is // 10000 milliseconds. TimeBase::TimeT relative_rt_timeout = rt_timeout_msecs * 10000; CORBA::Any relative_rt_timeout_as_any; relative_rt_timeout_as_any <<= relative_rt_timeout; CORBA::PolicyList policy_list(1); policy_list.length(1); policy_list[0] = orb->create_policy(Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, relative_rt_timeout_as_any); // Apply the policy at the ORB level. obj = orb->resolve_initial_references("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow(obj.in()); policy_manager->set_policy_overrides (policy_list, CORBA::ADD_OVERRIDE); // Destroy the Policy objects. for (CORBA::ULong i = 0; i < policy_list.length(); ++i) { policy_list[i]->destroy (); } policy_list.length(0); } ///// Get object reference ///// obj = orb->resolve_initial_references("Test"); ACE_ASSERT (!CORBA::is_nil(obj.in())); Test_var test = Test::_narrow( obj.in() ); ACE_ASSERT (!CORBA::is_nil(test.in())); if (max_tries > 1) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Maximum number of tries = %d\n", max_tries)); } CORBA::Short n = 0; for (int i = 0; i < max_tries; ++i) { try { n = test->get_num_requests (request_delay_secs); } catch (const CORBA::TIMEOUT &ex) { ex._tao_print_exception ("timeout exception:"); if (i == max_tries - 1) throw; } } if (n == 0) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) ERROR: Expected number of requests from " "server to be > 0\n"), -1); } else { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client got back <%d>\n", n)); } // In a per client situation the client has to shutdown the server if (shutdown_server) { test->shutdown(); } orb->destroy (); return 0; } catch(const CORBA::Exception& ex) { ex._tao_print_exception ("Client:"); } return -1; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); 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 (); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); if (CORBA::is_nil (root_poa.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil RootPOA\n"), 1); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); if (parse_args (argc, argv) != 0) return 1; Server *server_impl = 0; ACE_NEW_RETURN (server_impl, Server (orb.in ()), 1); PortableServer::ServantBase_var owner_transfer(server_impl); PortableServer::ObjectId_var id = root_poa->activate_object (server_impl); object = root_poa->id_to_reference (id.in ()); Test::Server_var test_server = Test::Server::_narrow (object.in ()); CORBA::String_var ior = orb->object_to_string (test_server.in ()); // Output the IOR to the <ior_output_file> FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s\n", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); root_poa->destroy (1, 1); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }