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); int result = parse_args (argc, argv); if (result != 0) return result; // Thread Manager for managing task. ACE_Thread_Manager thread_manager; // Create task. Task task (thread_manager, orb.in ()); // Task activation flags. long flags = THR_NEW_LWP | THR_JOINABLE | orb->orb_core ()->orb_params ()->thread_creation_flags (); // Activate task. result = task.activate (flags); if (result == -1) { if (errno == EPERM) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot create thread with scheduling policy %s\n" "because the user does not have the appropriate privileges, terminating program....\n" "Check svc.conf options and/or run as root\n", sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())), 2); } else // Unexpected error. ACE_ASSERT (0); } // Wait for task to exit. result = thread_manager.wait (); ACE_ASSERT (result != -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); if (parse_args (argc, argv) != 0) return 1; PeriodicTask periodicTask(orb); orb->orb_core()->reactor()->schedule_timer(&periodicTask, 0, ACE_Time_Value::zero, ACE_Time_Value(timeout)); orb->run(); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return process_result; }
void TAO_Notify_ThreadPool_Task::init (const NotifyExt::ThreadPoolParams& tp_params, const TAO_Notify_AdminProperties::Ptr& admin_properties) { ACE_ASSERT (this->timer_.get() == 0); TAO_Notify_Timer_Queue* timer = 0; ACE_NEW_THROW_EX (timer, TAO_Notify_Timer_Queue (), CORBA::NO_MEMORY ()); this->timer_.reset (timer); TAO_Notify_Buffering_Strategy* buffering_strategy = 0; ACE_NEW_THROW_EX (buffering_strategy, TAO_Notify_Buffering_Strategy (*msg_queue (), admin_properties), CORBA::NO_MEMORY ()); this->buffering_strategy_.reset (buffering_strategy); long flags = THR_NEW_LWP | THR_DETACHED; CORBA::ORB_var orb = TAO_Notify_PROPERTIES::instance()->orb (); flags |= orb->orb_core ()->orb_params ()->thread_creation_flags (); // Guards the thread for auto-deletion; paired with close. // This is done in the originating thread before the spawn to // avoid any race conditions. for ( CORBA::ULong i = 0; i < tp_params.static_threads; ++i ) { this->_incr_refcnt(); } // Become an active object. if (this->ACE_Task <ACE_NULL_SYNCH>::activate (flags, tp_params.static_threads, 0, ACE_THR_PRI_OTHER_DEF) == -1) { // Undo the ref counts on error for ( CORBA::ULong i = 0; i < tp_params.static_threads; ++i ) { this->_decr_refcnt(); } if (ACE_OS::last_error () == EPERM) ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Insufficient privilege.\n"))); else if (ACE_OS::last_error () == EAGAIN) { ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) task activation at priority %d failed %p\n"), tp_params.default_priority, "activate")); throw CORBA::NO_RESOURCES (); } throw CORBA::BAD_PARAM (); } }
TAO_EC_Timeout_Generator* TAO_EC_Null_Factory::create_timeout_generator (TAO_EC_Event_Channel_Base *) { int argc = 0; ACE_TCHAR **argv = 0; CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); ACE_Reactor *reactor = orb->orb_core ()->reactor (); return new TAO_EC_Reactive_Timeout_Generator (reactor); }
TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Notify_Timer_Reactor::TAO_Notify_Timer_Reactor (void) :reactor_ (0) { // Get the ORB CORBA::ORB_var orb = TAO_Notify_PROPERTIES::instance()->orb (); this->reactor_ = orb->orb_core ()->reactor (); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize an ORB CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Create a holder for the common ORB Objects. TAO_Notify_ORB_Objects orb_objects; orb_objects.init (orb); /* Run the ORB in a separate thread */ TAO_Notify_ORB_Run_Task orb_run_task (orb_objects); /* Create a Client */ TAO_Notify_Lanes_Supplier_Client client (orb_objects); if (client.parse_args (argc, argv) != 0) { ACE_DEBUG ((LM_DEBUG, "Supplier_Client::Error parsing options\n")); return -1; } long flags = THR_NEW_LWP | THR_JOINABLE; flags |= orb->orb_core ()->orb_params ()->thread_creation_flags (); /* Both the tasks initialize themselves at Priority 0*/ if (orb_run_task.activate (flags) == -1 || client.activate (flags) == -1) { if (ACE_OS::last_error () == EPERM) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Insufficient privilege to activate ACE_Task.\n")), -1); else ACE_DEBUG ((LM_ERROR, ACE_TEXT ("(%t) Task activation at priority %d failed.\n"))); } orb_run_task.thr_mgr ()->wait (); client.thr_mgr ()->wait (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception (ACE_TEXT ("Supplier Client error ")); } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); int result = parse_args (argc, argv); if (result != 0) return result; // Make sure we can support multiple priorities that are required // for this test. check_supported_priorities (orb.in ()); // Thread Manager for managing task. ACE_Thread_Manager thread_manager; // Create task. Task task (thread_manager, orb.in ()); // Task activation flags. long flags = THR_NEW_LWP | THR_JOINABLE | orb->orb_core ()->orb_params ()->thread_creation_flags (); // Activate task. result = task.activate (flags); ACE_ASSERT (result != -1); ACE_UNUSED_ARG (result); // Wait for task to exit. result = thread_manager.wait (); ACE_ASSERT (result != -1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return -1; } return 0; }
void pause() { // get the reactor and set the timer. CORBA::ORB_var orb = TheServiceParticipant->get_ORB (); ACE_Reactor* reactor ; reactor = orb->orb_core()->reactor(); if (reactor->schedule_timer(this, 0, ACE_Time_Value(0,1)) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: PauseReactor, ") ACE_TEXT(" %p. \n"), "schedule_timer")); } }
int TAO_Notify_Tests_Periodic_Supplier::activate_task (ACE_Barrier* barrier) { barrier_ = barrier; long flags = THR_NEW_LWP | THR_JOINABLE; // Resolve the ORB CORBA::ORB_var orb; LOOKUP_MANAGER->resolve (orb); flags |= orb->orb_core ()->orb_params ()->thread_creation_flags (); TAO_Notify_Tests_Priority_Mapping* priority_mapping; LOOKUP_MANAGER->resolve (priority_mapping); CORBA::Short native_prio; priority_mapping->to_native (this->priority_, native_prio); // Become an active object. if (this->ACE_Task <ACE_SYNCH>::activate (flags, 1, 0, native_prio) == -1) { if (ACE_OS::last_error () == EPERM) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Insufficient privilege to activate ACE_Task.\n")), -1); else ACE_DEBUG ((LM_ERROR, ACE_TEXT ("(%t) Task activation at priority %d failed, ") ACE_TEXT ("exiting!\n%a"), this->priority_, -1)); } ACE_DEBUG ((LM_ERROR, "Activated Periodic Supplier Thread at priority %d\n", this->priority_)); return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { // scope TSS holder within main scope // so we're certain it gets destroyed before the // ACE object manager ACE_TSS<Worker> workers_; // provide global access workers_p = &workers_; try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return 1; // Make sure the reactor is initialised in the leader_follower ACE_Reactor* reactor = orb->orb_core ()->leader_follower ().reactor (); TEST_ASSERT ((reactor != 0)); // Ready to go Test_1 (orb->orb_core ()); Test_2 (orb->orb_core ()); Test_3 (orb->orb_core ()); Test_4 (orb->orb_core ()); Test_5 (orb->orb_core ()); Test_6 (orb->orb_core ()); Test_7 (orb->orb_core ()); Test_8 (orb->orb_core ()); Test_9 (orb->orb_core ()); Test_10 (orb->orb_core ()); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing complete.\n"))); // cleanup orb->destroy (); } catch (CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }
TAO_EC_Timeout_Generator* TAO_EC_Default_Factory::create_timeout_generator (TAO_EC_Event_Channel_Base *) { if (this->timeout_ == 0) { int argc = 0; ACE_TCHAR **argv = 0; CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, this->orbid_.c_str ()); ACE_Reactor *reactor = orb->orb_core ()->reactor (); return new TAO_EC_Reactive_Timeout_Generator (reactor); } #if 0 else if (this->timeout_ == 1) { } #endif 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 object = orb->string_to_object (ior); A::AMI_Test_var server = A::AMI_Test::_narrow (object.in ()); if (CORBA::is_nil (server.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil.\n", ior), 1); } // Activate POA to handle the call back. 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 (); // Let the client perform the test in a separate thread Handler* handler = 0; ACE_NEW_RETURN (handler, Handler, 1); PortableServer::ServantBase_var owner_transfer(handler); PortableServer::ObjectId_var id = root_poa->activate_object (handler); CORBA::Object_var object2 = root_poa->id_to_reference (id.in ()); A::AMI_AMI_TestHandler_var hello = A::AMI_AMI_TestHandler::_narrow (object2.in ()); object2 = CORBA::Object::_nil (); server->shutdown (); // oneway, so returns here immediately but server waits 5 sec Client client (server.in (), niterations, hello.in ()); if (client.activate (THR_NEW_LWP | THR_JOINABLE, nthreads) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate client threads\n"), 1); // Main thread collects replies. It needs to collect // <nthreads*niterations> replies. number_of_replies = nthreads *niterations; if (debug) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) : Entering perform_work loop to receive <%d> replies\n", number_of_replies)); } // ORB loop. ACE_Time_Value tv (1,0); orb->run (tv); if (debug) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) : Exited perform_work loop Received <%d> replies\n", (nthreads*niterations) - number_of_replies)); } ACE_DEBUG ((LM_DEBUG, "threads finished\n")); client.wait (); tv = ACE_Time_Value (1,0); orb->run (tv); root_poa->deactivate_object (id.in ()); root_poa->destroy (1, // ethernalize objects 0); // wait for completion hello = A::AMI_AMI_TestHandler::_nil (); root_poa = PortableServer::POA::_nil (); poa_object = CORBA::Object::_nil (); object = CORBA::Object::_nil (); server = A::AMI_Test::_nil (); poa_manager = PortableServer::POAManager::_nil (); client.clear (); orb->shutdown (); orb->destroy (); CORBA::ULong ref_count = orb->_refcount(); if (ref_count > 1) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("Refcount orb %d\n"), ref_count)); ++parameter_corruption; } else { TAO_ORB_Core* core = orb->orb_core (); if (core != 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("Core <> null\n"))); ++parameter_corruption; } } orb = CORBA::ORB::_nil (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); return 1; } return parameter_corruption; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // The usual server side boilerplate code. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); 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 (); poa_manager->activate (); // "built-in" strategies are the following: // 0 = RoundRobin // 1 = Random // 2 = LeastLoaded int default_strategy = 1; // Check the non-ORB arguments. ::parse_args (argc, argv, default_strategy); TAO_LB_LoadManager * lm = 0; ACE_NEW_THROW_EX (lm, TAO_LB_LoadManager(::ping_timeout_milliseconds, ::ping_interval_seconds), CORBA::NO_MEMORY ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, ENOMEM), CORBA::COMPLETED_NO)); PortableServer::ServantBase_var safe_lm = lm; // Initalize the LoadManager servant. lm->initialize (orb->orb_core ()->reactor (), orb.in (), root_poa.in ()); PortableGroup::Properties props (1); props.length (1); props[0].nam.length (1); props[0].nam[0].id = CORBA::string_dup ("org.omg.CosLoadBalancing.StrategyInfo"); CosLoadBalancing::StrategyInfo strategy_info; switch (default_strategy) { case 0: strategy_info.name = CORBA::string_dup ("RoundRobin"); break; case 1: strategy_info.name = CORBA::string_dup ("Random"); break; case 2: strategy_info.name = CORBA::string_dup ("LeastLoaded"); break; default: ORBSVCS_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ERROR: LoadBalancer internal error.\n") ACE_TEXT (" Unknown built-in strategy.\n")), -1); } props[0].val <<= strategy_info; lm->set_default_properties (props); CosLoadBalancing::LoadManager_var load_manager = lm->_this (); CORBA::String_var str = orb->object_to_string (load_manager.in ()); // to support corbaloc // Get a reference to the IOR table. CORBA::Object_var tobj = orb->resolve_initial_references ("IORTable"); IORTable::Table_var table = IORTable::Table::_narrow (tobj.in ()); // bind your stringified IOR in the IOR table table->bind ("LoadManager", str.in ()); FILE * lm_ior = ACE_OS::fopen (lm_ior_file, "w"); ACE_OS::fprintf (lm_ior, "%s", str.in ()); ACE_OS::fclose (lm_ior); #if defined (linux) && defined (ACE_HAS_THREADS) if (ACE_Thread_Manager::instance ()->spawn (::TAO_LB_run_load_manager, orb.in ()) == -1) { ORBSVCS_ERROR_RETURN ((LM_ERROR, "ERROR: Unable to spawn TAO LoadManager's " "ORB thread.\n"), -1); } ACE_Sig_Set sigset; sigset.sig_add (SIGINT); sigset.sig_add (SIGTERM); int signum = -1; // Block waiting for the registered signals. if (ACE_OS::sigwait (sigset, &signum) == -1) { ORBSVCS_ERROR_RETURN ((LM_ERROR, "(%P|%t) %p\n", "ERROR waiting on signal"), -1); } ACE_ASSERT (signum == SIGINT || signum == SIGTERM); #else // Activate/register the signal handler that (attempts) to // ensure graceful shutdown of the LoadManager so that remote // resources created by the LoadManager can be cleaned up. TAO_LB_Signal_Handler signal_handler (orb.in (), root_poa.in ()); if (signal_handler.activate () != 0) { ORBSVCS_ERROR_RETURN ((LM_ERROR, "Error: can't activate LB signal handler, exiting.\n"), -1); } // @@ There is a subtle race condition here. If the signal // handler thread shuts down the ORB before it is run, the // below call to ORB::run() will throw a CORBA::BAD_INV_ORDER // exception. orb->run (); // Wait for the signal handler thread to finish // before the process exits. signal_handler.wait (); #endif /* linux && ACE_HAS_THREADS */ orb->destroy (); } // catch (const PortableGroup::InvalidProperty& ex) // { // ORBSVCS_DEBUG ((LM_DEBUG, "Property ----> %s\n", ex.nam[0].id.in ())); // } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("TAO Load Manager"); 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 (); 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, " (%P|%t) Panic: nil RootPOA\n"), 1); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); if (parse_args (argc, argv) != 0) return 1; PortableServer::ServantBase_var impl; { Echo * tmp = 0; // 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(), 1000 / serverthreads), 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 (server.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil Test::Echo_Caller reference <%s>\n", ior), 1); } poa_manager->activate (); ORB_Task worker (orb.in()); worker.activate (THR_NEW_LWP | THR_JOINABLE, serverthreads); try { for(int i = serverthreads; i; --i) { server->start_task(echo.in()); } } catch (...) { } Client_Timer * task = new Client_Timer (orb->orb_core()->reactor()); task->activate (); task->remove_reference (); orb->run (); worker.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[]) { int result = 0; try { // Standard initialization: // parse arguments and get all the references (ORB, // RootPOA, RTORB, RTCurrent, POAManager). CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return -1; // Make sure we can support multiple priorities that are required // for this test. if (!check_supported_priorities (orb.in ())) return 2; // Thread Manager for managing task. ACE_Thread_Manager thread_manager; // Create task. Task task (thread_manager, orb.in ()); // Task activation flags. long flags = THR_NEW_LWP | THR_JOINABLE | orb->orb_core ()->orb_params ()->thread_creation_flags (); // Activate task. result = task.activate (flags); if (result == -1) { if (errno == EPERM) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot create thread with scheduling policy %s\n" "because the user does not have the appropriate privileges, terminating program....\n" "Check svc.conf options and/or run as root\n", sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())), 2); } else // Unexpected error. ACE_ERROR_RETURN ((LM_ERROR, "ERROR: Cannot create thread. errno = %d\n", ACE_ERRNO_GET), -1); } // Wait for task to exit. result = thread_manager.wait (); } catch (const ::CORBA::Exception & ex) { ex._tao_print_exception( "Exception caught:"); return -1; } return result; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize the EC Factory so we can customize the EC TAO_EC_Default_Factory::init_svcs (); // Initialize the ORB. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); const ACE_TCHAR *ecname = ACE_TEXT ("EventService"); const ACE_TCHAR *address = ACE_TEXT ("localhost"); const ACE_TCHAR *iorfile = 0; u_short port = 12345; u_short listenport = 12345; int mcast = 1; for (int i = 0; argv[i] != 0; i++) { if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-ecname")) == 0) { if (argv[i+1] != 0) ecname = argv[++i]; else ACE_ERROR_RETURN ((LM_ERROR, "Missing Event channel name\n"),0); } else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-address")) == 0) { if (argv[i+1] != 0) address = argv[++i]; else ACE_ERROR_RETURN ((LM_ERROR, "Missing address\n"),0); } else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-port")) == 0) { if (argv[i+1] != 0) port = ACE_OS::atoi(argv[++i]); else ACE_ERROR_RETURN ((LM_ERROR, "Missing port\n"),0); } else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-listenport")) == 0) { if (argv[i+1] != 0) listenport = ACE_OS::atoi(argv[++i]); else ACE_ERROR_RETURN ((LM_ERROR, "Missing port\n"), 0); } else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-iorfile")) == 0) { if (argv[i+1] != 0) iorfile = argv[++i]; else ACE_ERROR_RETURN ((LM_ERROR, "Missing ior file\n"), 0); } else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-udp")) == 0) mcast = 0; } // Get the POA CORBA::Object_var tmpobj = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (tmpobj.in ()); PortableServer::POAManager_var poa_manager = poa->the_POAManager (); poa_manager->activate (); // Create a local event channel and register it TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ()); TAO_EC_Event_Channel ec_impl (attributes); ec_impl.activate (); PortableServer::ObjectId_var oid = poa->activate_object(&ec_impl); tmpobj = poa->id_to_reference(oid.in()); RtecEventChannelAdmin::EventChannel_var ec = RtecEventChannelAdmin::EventChannel::_narrow(tmpobj.in()); // Find the Naming Service. tmpobj = orb->resolve_initial_references("NameService"); CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(tmpobj.in()); // Bind the Event Channel using Naming Services CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname)); root_context->rebind(name.in(), ec.in()); // Get a proxy push consumer from the EventChannel. RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers(); RtecEventChannelAdmin::ProxyPushConsumer_var consumer = admin->obtain_push_consumer(); // Instantiate an EchoEventSupplier_i servant. EchoEventSupplier_i servant(orb.in()); // Register it with the RootPOA. oid = poa->activate_object(&servant); tmpobj = poa->id_to_reference(oid.in()); RtecEventComm::PushSupplier_var supplier = RtecEventComm::PushSupplier::_narrow(tmpobj.in()); // Connect to the EC. ACE_SupplierQOS_Factory qos; qos.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1); consumer->connect_push_supplier (supplier.in (), qos.get_SupplierQOS ()); // Initialize the address server with the desired address. This will // be used by the sender object and the multicast receiver only if // one is not otherwise available via the naming service. ACE_INET_Addr send_addr (port, address); SimpleAddressServer addr_srv_impl (send_addr); // Create an instance of the addr server for local use PortableServer::ObjectId_var addr_srv_oid = poa->activate_object(&addr_srv_impl); tmpobj = poa->id_to_reference(addr_srv_oid.in()); RtecUDPAdmin::AddrServer_var addr_srv = RtecUDPAdmin::AddrServer::_narrow(tmpobj.in()); // Create and initialize the sender object PortableServer::Servant_var<TAO_ECG_UDP_Sender> sender = TAO_ECG_UDP_Sender::create(); TAO_ECG_UDP_Out_Endpoint endpoint; // need to be explicit about the address type when built with // IPv6 support, otherwise SOCK_DGram::open defaults to ipv6 when // given a sap_any address. This causes trouble on at least solaris // and windows, or at most on not-linux. if (endpoint.dgram ().open (ACE_Addr::sap_any, send_addr.get_type()) == -1) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot open send endpoint\n"), 1); } // TAO_ECG_UDP_Sender::init() takes a TAO_ECG_Refcounted_Endpoint. // If we don't clone our endpoint and pass &endpoint, the sender will // attempt to delete endpoint during shutdown. TAO_ECG_Refcounted_Endpoint clone (new TAO_ECG_UDP_Out_Endpoint (endpoint)); sender->init (ec.in (), addr_srv.in (), clone); // Setup the subscription and connect to the EC ACE_ConsumerQOS_Factory cons_qos_fact; cons_qos_fact.start_disjunction_group (); cons_qos_fact.insert (ACE_ES_EVENT_SOURCE_ANY, ACE_ES_EVENT_ANY, 0); RtecEventChannelAdmin::ConsumerQOS sub = cons_qos_fact.get_ConsumerQOS (); sender->connect (sub); // Create and initialize the receiver PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver = TAO_ECG_UDP_Receiver::create(); // TAO_ECG_UDP_Receiver::init() takes a TAO_ECG_Refcounted_Endpoint. // If we don't clone our endpoint and pass &endpoint, the receiver will // attempt to delete endpoint during shutdown. TAO_ECG_Refcounted_Endpoint clone2 (new TAO_ECG_UDP_Out_Endpoint (endpoint)); receiver->init (ec.in (), clone2, addr_srv.in ()); // Setup the registration and connect to the event channel ACE_SupplierQOS_Factory supp_qos_fact; supp_qos_fact.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1); RtecEventChannelAdmin::SupplierQOS pub = supp_qos_fact.get_SupplierQOS (); receiver->connect (pub); // Create the appropriate event handler and register it with the reactor auto_ptr<ACE_Event_Handler> eh; if (mcast) { auto_ptr<TAO_ECG_Mcast_EH> mcast_eh(new TAO_ECG_Mcast_EH (receiver.in())); mcast_eh->reactor (orb->orb_core ()->reactor ()); mcast_eh->open (ec.in()); ACE_auto_ptr_reset(eh,mcast_eh.release()); //eh.reset(mcast_eh.release()); } else { auto_ptr<TAO_ECG_UDP_EH> udp_eh (new TAO_ECG_UDP_EH (receiver.in())); udp_eh->reactor (orb->orb_core ()->reactor ()); ACE_INET_Addr local_addr (listenport); if (udp_eh->open (local_addr) == -1) ACE_ERROR ((LM_ERROR,"Cannot open EH\n")); ACE_auto_ptr_reset(eh,udp_eh.release()); //eh.reset(udp_eh.release()); } // Create an event (just a string in this case). // Create an event set for one event RtecEventComm::EventSet event (1); event.length (1); // Initialize event header. event[0].header.source = MY_SOURCE_ID; event[0].header.ttl = 1; event[0].header.type = MY_EVENT_TYPE; #if !defined (TAO_LACKS_EVENT_CHANNEL_ANY) // Initialize data fields in event. const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname)); event[0].data.any_value <<= eventData; #else // Use the octet sequence payload instead char *tmpstr = const_cast<char *>(ACE_TEXT_ALWAYS_CHAR (ecname)); size_t len = ACE_OS::strlen(tmpstr) +1; event[0].data.payload.replace ( len, len, reinterpret_cast<CORBA::Octet *> (tmpstr)); #endif /* !TAO_LACKS_EVENT_CHANNEL_ANY */ if (iorfile != 0) { CORBA::String_var str = orb->object_to_string( ec.in() ); std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) ); iorFile << str.in() << std::endl; iorFile.close(); } ACE_DEBUG ((LM_DEBUG, "Starting main loop\n")); const int EVENT_DELAY_MS = 1000; while (1) { consumer->push (event); ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS); orb->run(tv); } orb->destroy(); return 0; } catch (const CORBA::Exception& exc) { ACE_ERROR ((LM_ERROR, "Caught CORBA::Exception\n%C (%C)\n", exc._name (), exc._rep_id () )); } return 1; }
void OpenDDS::DCPS::DataDurabilityCache::init() { ACE_Allocator * const allocator = this->allocator_.get(); ACE_NEW_MALLOC( this->samples_, static_cast<sample_map_type *>( allocator->malloc(sizeof(sample_map_type))), sample_map_type(allocator)); typedef DurabilityQueue<sample_data_type> data_queue_type; if (this->kind_ == DDS::PERSISTENT_DURABILITY_QOS) { // Read data from the filesystem and create the in-memory data structures // as if we had called insert() once for each "datawriter" directory. using OpenDDS::FileSystemStorage::Directory; using OpenDDS::FileSystemStorage::File; Directory::Ptr root_dir = Directory::create(this->data_dir_.c_str()); std::vector<std::string> path(4); // domain, topic, type, datawriter for (Directory::DirectoryIterator domain = root_dir->begin_dirs(), domain_end = root_dir->end_dirs(); domain != domain_end; ++domain) { path[0] = domain->name(); DDS::DomainId_t domain_id; { std::istringstream iss(path[0]); iss >> domain_id; } for (Directory::DirectoryIterator topic = domain->begin_dirs(), topic_end = domain->end_dirs(); topic != topic_end; ++topic) { path[1] = topic->name(); for (Directory::DirectoryIterator type = topic->begin_dirs(), type_end = topic->end_dirs(); type != type_end; ++type) { path[2] = type->name(); key_type key(domain_id, path[1].c_str(), path[2].c_str(), allocator); sample_list_type * sample_list = 0; ACE_NEW_MALLOC(sample_list, static_cast<sample_list_type *>( allocator->malloc(sizeof(sample_list_type))), sample_list_type(0, static_cast<data_queue_type *>(0), allocator)); this->samples_->bind(key, sample_list, allocator); for (Directory::DirectoryIterator dw = type->begin_dirs(), dw_end = type->end_dirs(); dw != dw_end; ++dw) { path[3] = dw->name(); size_t old_len = sample_list->size(); sample_list->size(old_len + 1); data_queue_type *& slot = (*sample_list)[old_len]; // This variable is called "samples" in the insert() method be // we already have a "samples_" which is the overall data structure. data_queue_type * sample_queue = 0; ACE_NEW_MALLOC(sample_queue, static_cast<data_queue_type *>( allocator->malloc(sizeof(data_queue_type))), data_queue_type(allocator)); slot = sample_queue; sample_queue->fs_path_ = path; for (Directory::FileIterator file = dw->begin_files(), file_end = dw->end_files(); file != file_end; ++file) { std::ifstream is; if (!file->read(is)) { if (DCPS_debug_level) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) DataDurabilityCache::init ") ACE_TEXT("couldn't open file for PERSISTENT ") ACE_TEXT("data: %C\n"), file->name().c_str())); } continue; } DDS::Time_t timestamp; is >> timestamp.sec >> timestamp.nanosec >> std::noskipws; is.get(); // consume separator const size_t CHUNK = 4096; ACE_Message_Block mb(CHUNK); ACE_Message_Block * current = &mb; while (!is.eof()) { is.read(current->wr_ptr(), current->space()); if (is.bad()) break; current->wr_ptr(is.gcount()); if (current->space() == 0) { ACE_Message_Block * old = current; current = new ACE_Message_Block(CHUNK); old->cont(current); } } sample_queue->enqueue_tail( sample_data_type(timestamp, mb, allocator)); if (mb.cont()) mb.cont()->release(); // delete the cont() chain } } } } } } CORBA::ORB_var orb = TheServiceParticipant->get_ORB(); this->reactor_ = orb->orb_core()->reactor(); }
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_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 (); seed = (unsigned int) ACE_OS::gethrtime (); if (parse_args (argc, argv) != 0) return 1; ACE_DEBUG ((LM_DEBUG, "SEED = %u\n", seed)); Server_Peer *impl; ACE_NEW_RETURN (impl, Server_Peer (seed, orb.in (), payload_size), 1); PortableServer::ServantBase_var owner_transfer(impl); PortableServer::ObjectId_var id = root_poa->activate_object (impl); CORBA::Object_var object_act = root_poa->id_to_reference (id.in ()); Test::Peer_var peer = Test::Peer::_narrow (object_act.in ()); CORBA::String_var ior = orb->object_to_string (peer.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 (); Sleeper sleeper (orb.in ()); ACE_Time_Value interval(0, 500000); ACE_Reactor * reactor = orb->orb_core()->reactor(); reactor->schedule_timer(&sleeper, 0, interval, interval); // ACE_Time_Value run_time(600, 0); // orb->run (run_time); 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; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize the EC Factory so we can customize the EC TAO_EC_Default_Factory::init_svcs (); // Initialize the ORB. CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); const ACE_TCHAR* ecname = ACE_TEXT ("EventService"); const ACE_TCHAR* address = ACE_TEXT ("localhost"); const ACE_TCHAR* iorfile = 0; u_short port = 12345; u_short listenport = 12345; int mcast = 1; for (int i = 0; argv[i] != 0; i++) { if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) { if (argv[i+1] != 0) { i++; ecname = argv[i]; } else { std::cerr << "Missing Event channel name" << std::endl; } } else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-address")) == 0) { if (argv[i+1] != 0) { i++; address = argv[i]; } else { std::cerr << "Missing address" << std::endl; } } else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-port")) == 0) { if (argv[i+1] != 0) { i++; port = ACE_OS::atoi(argv[i]); } else { std::cerr << "Missing port" << std::endl; } } else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-listenport")) == 0) { if (argv[i+1] != 0) { i++; listenport = ACE_OS::atoi(argv[i]); } else { std::cerr << "Missing port" << std::endl; } } else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-iorfile")) == 0) { if (argv[i+1] != 0) { i++; iorfile = argv[i]; } } else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-udp")) == 0) { mcast = 0; } } // Get the POA CORBA::Object_var object = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (object.in ()); PortableServer::POAManager_var poa_manager = poa->the_POAManager (); poa_manager->activate (); // Create a local event channel and register it TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ()); PortableServer::Servant_var<TAO_EC_Event_Channel> ec_impl = new TAO_EC_Event_Channel(attributes); ec_impl->activate (); PortableServer::ObjectId_var oid = poa->activate_object(ec_impl.in()); CORBA::Object_var ec_obj = poa->id_to_reference(oid.in()); RtecEventChannelAdmin::EventChannel_var ec = RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in()); // Find the Naming Service. CORBA::Object_var obj = orb->resolve_initial_references("NameService"); CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(obj.in()); // Bind the Event Channel using Naming Services CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname)); root_context->rebind(name.in(), ec.in()); // Get a proxy push consumer from the EventChannel. RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers(); RtecEventChannelAdmin::ProxyPushConsumer_var consumer = admin->obtain_push_consumer(); // Instantiate an EchoEventSupplier_i servant. PortableServer::Servant_var<EchoEventSupplier_i> servant = new EchoEventSupplier_i(orb.in()); // Register it with the RootPOA. oid = poa->activate_object(servant.in()); CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in()); RtecEventComm::PushSupplier_var supplier = RtecEventComm::PushSupplier::_narrow(supplier_obj.in()); // Connect to the EC. ACE_SupplierQOS_Factory qos; qos.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1); consumer->connect_push_supplier (supplier.in (), qos.get_SupplierQOS ()); // Initialize the address server with the desired address. // This will be used by the sender object and the multicast // receiver. ACE_INET_Addr send_addr (port, address); PortableServer::Servant_var<SimpleAddressServer> addr_srv_impl = new SimpleAddressServer(send_addr); PortableServer::ObjectId_var addr_srv_oid = poa->activate_object(addr_srv_impl.in()); CORBA::Object_var addr_srv_obj = poa->id_to_reference(addr_srv_oid.in()); RtecUDPAdmin::AddrServer_var addr_srv = RtecUDPAdmin::AddrServer::_narrow(addr_srv_obj.in()); // Create and initialize the sender object PortableServer::Servant_var<TAO_ECG_UDP_Sender> sender = TAO_ECG_UDP_Sender::create(); TAO_ECG_UDP_Out_Endpoint endpoint; if (endpoint.dgram ().open (ACE_Addr::sap_any) == -1) { std::cerr << "Cannot open send endpoint" << std::endl; return 1; } // TAO_ECG_UDP_Sender::init() takes a TAO_ECG_Refcounted_Endpoint. // If we don't clone our endpoint and pass &endpoint, the sender will // attempt to delete endpoint during shutdown. TAO_ECG_Refcounted_Endpoint clone (new TAO_ECG_UDP_Out_Endpoint (endpoint)); sender->init (ec.in (), addr_srv.in (), clone); // Setup the subscription and connect to the EC ACE_ConsumerQOS_Factory cons_qos_fact; cons_qos_fact.start_disjunction_group (); cons_qos_fact.insert (ACE_ES_EVENT_SOURCE_ANY, ACE_ES_EVENT_ANY, 0); RtecEventChannelAdmin::ConsumerQOS sub = cons_qos_fact.get_ConsumerQOS (); sender->connect (sub); // Create and initialize the receiver PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver = TAO_ECG_UDP_Receiver::create(); // TAO_ECG_UDP_Receiver::init() takes a TAO_ECG_Refcounted_Endpoint. // If we don't clone our endpoint and pass &endpoint, the receiver will // attempt to delete endpoint during shutdown. TAO_ECG_Refcounted_Endpoint clone2 (new TAO_ECG_UDP_Out_Endpoint (endpoint)); receiver->init (ec.in (), clone2, addr_srv.in ()); // Setup the registration and connect to the event channel ACE_SupplierQOS_Factory supp_qos_fact; supp_qos_fact.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1); RtecEventChannelAdmin::SupplierQOS pub = supp_qos_fact.get_SupplierQOS (); receiver->connect (pub); // Create the appropriate event handler and register it with the reactor auto_ptr<ACE_Event_Handler> eh; if (mcast) { auto_ptr<TAO_ECG_Mcast_EH> mcast_eh(new TAO_ECG_Mcast_EH (receiver.in())); mcast_eh->reactor (orb->orb_core ()->reactor ()); mcast_eh->open (ec.in()); ACE_auto_ptr_reset(eh,mcast_eh.release()); //eh.reset(mcast_eh.release()); } else { auto_ptr<TAO_ECG_UDP_EH> udp_eh (new TAO_ECG_UDP_EH (receiver.in())); udp_eh->reactor (orb->orb_core ()->reactor ()); ACE_INET_Addr local_addr (listenport); if (udp_eh->open (local_addr) == -1) { std::cerr << "Cannot open EH" << std::endl; } ACE_auto_ptr_reset(eh,udp_eh.release()); //eh.reset(udp_eh.release()); } // Create an event (just a string in this case). const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname)); // Create an event set for one event RtecEventComm::EventSet event (1); event.length (1); // Initialize event header. event[0].header.source = MY_SOURCE_ID; event[0].header.ttl = 1; event[0].header.type = MY_EVENT_TYPE; // Initialize data fields in event. event[0].data.any_value <<= eventData; if (iorfile != 0) { CORBA::String_var str = orb->object_to_string( ec.in() ); std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) ); iorFile << str.in() << std::endl; iorFile.close(); } std::cout << "Starting main loop" << std::endl; const int EVENT_DELAY_MS = 10; while (1) { consumer->push (event); ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS); orb->run(tv); } orb->destroy(); return 0; } catch(const CORBA::Exception& exc) { std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl; } return 1; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { // Initialize the ORB, resolve references and parse arguments. // ORB. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Parse arguments. if (parse_args (argc, argv) != 0) return -1; // Make sure we can support multiple priorities that are required // for this test. if (!check_supported_priorities (orb.in ())) return 2; // Thread Manager for managing task. ACE_Thread_Manager thread_manager; // Create task. Task task (thread_manager, orb.in ()); // Task activation flags. long flags = THR_NEW_LWP | THR_JOINABLE | orb->orb_core ()->orb_params ()->thread_creation_flags (); // Activate task. int result = task.activate (flags); if (result == -1) { if (errno == EPERM) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot create thread with scheduling policy %s\n" "because the user does not have the appropriate privileges, terminating program....\n" "Check svc.conf options and/or run as root\n", sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())), 2); } else // Unexpected error. ACE_ASSERT (0); } // Wait for task to exit. result = thread_manager.wait (); ACE_ASSERT (result != -1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( "Unexpected exception in MT_Client_Protocol_Priority test client:"); return -1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { // Register the default factory in the Service Configurator. // If your platform supports static constructors then you can // simply using the ACE_STATIC_SVC_DEFINE() macro, unfortunately TAO // must run on platforms where static constructors do not work well, // so we have to explicitly invoke this function. TAO_EC_Default_Factory::init_svcs (); // The exception macros are described in $ACE_ROOT/docs/exceptions.html // and defined in $ACE_ROOT/ace/CORBA_macros.h. // If your platform supports native exceptions, and TAO was compiled // with native exception support then you can simply use try/catch // and avoid the argument. // Unfortunately many embedded systems cannot use exceptions due to // the space and time overhead. // try { // **************** HERE STARTS THE ORB SETUP // Create the ORB, pass the argv list for parsing. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Parse the arguments, you usually want to do this after // invoking ORB_init() because ORB_init() will remove all the // -ORB options from the command line. if (parse_args (argc, argv) == -1) { ACE_ERROR ((LM_ERROR, "Usage: Service [-m udp_mcast_addr]\n")); return 1; } if (valuetype) { Hello::ValueTypeData_init *vb_factory = 0; ACE_NEW_RETURN (vb_factory, Hello::ValueTypeData_init, 1); // supplied by mapping orb->register_value_factory (vb_factory->tao_repository_id (), vb_factory); vb_factory->_remove_ref (); // release ownership } // This is the standard code to get access to the POA and // activate it. // The POA starts in the holding state, if it is not activated // it will not process any requests. CORBA::Object_var object = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (object.in ()); PortableServer::POAManager_var poa_manager = poa->the_POAManager (); poa_manager->activate (); // **************** THAT COMPLETS THE ORB SETUP // **************** HERE START THE LOCAL EVENT CHANNEL SETUP // This structure is used to define the startup time event // channel configuration. // This structure is described in // // $TAO_ROOT/docs/ec_options.html // TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ()); // Create the Event Channel implementation class TAO_EC_Event_Channel ec_impl (attributes); // Activate the Event Channel, depending on the configuration // that may involve creating some threads. // But it should always be invoked because several internal data // structures are initialized at that point. ec_impl.activate (); // The event channel is activated as any other CORBA servant. // In this case we use the simple implicit activation with the // RootPOA RtecEventChannelAdmin::EventChannel_var event_channel = ec_impl._this (); // **************** THAT COMPLETES THE LOCAL EVENT CHANNEL SETUP // **************** HERE STARTS THE FEDERATION SETUP // The next step is to setup the multicast gateways. // There are two gateways involved, one sends the locally // generated events to the federated peers, the second gateway // receives multicast traffic and turns it into local events. // The sender requires a helper object to select what // multicast group will carry what traffic, this is the // so-called 'Address Server'. // The intention is that advanced applications can use different // multicast groups for different events, this can exploit // network interfaces that filter unwanted multicast traffic. // The helper object is accessed through an IDL interface, so it // can reside remotely. // In this example, and in many application, using a fixed // multicast group is enough, and a local address server is the // right approach. // First we convert the string into an INET address, then we // convert that into the right IDL structure: ACE_INET_Addr udp_addr (udp_mcast_address); ACE_DEBUG ((LM_DEBUG, "udp mcast address is: %s\n", udp_mcast_address)); // Now we create and activate the servant AddrServer as_impl (udp_addr); RtecUDPAdmin::AddrServer_var address_server = as_impl._this (); TAO_ECG_Refcounted_Endpoint endpoint(new TAO_ECG_UDP_Out_Endpoint); // Now we connect the sender as a consumer of events, it will // receive any event from any source and send it to the "right" // multicast group, as defined by the address server set above: RtecEventChannelAdmin::ConsumerQOS sub; sub.is_gateway = 1; sub.dependencies.length (1); sub.dependencies[0].event.header.type = ACE_ES_EVENT_ANY; // first free event type sub.dependencies[0].event.header.source = ACE_ES_EVENT_SOURCE_ANY; // Any source is OK // To receive events we need to setup an event handler: PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver = TAO_ECG_UDP_Receiver::create(); TAO_ECG_Mcast_EH mcast_eh (&(*receiver)); // The event handler uses the ORB reactor to wait for multicast // traffic: mcast_eh.reactor (orb->orb_core ()->reactor ()); // The multicast Event Handler needs to know to what multicast // groups it should listen to. To do so it becomes an observer // with the event channel, to determine the list of events // required by all the local consumer. // Then it register for the multicast groups that carry those // events: mcast_eh.open (event_channel.in ()); // Again the receiver connects to the event channel as a // supplier of events, using the Observer features to detect // local consumers and their interests: receiver->init (event_channel.in (), endpoint, address_server.in ()); // The Receiver is also a supplier of events. The exact type of // events is only known to the application, because it depends // on the traffic carried by all the multicast groups that the // different event handlers subscribe to. // In this example we choose to simply describe our publications // using wilcards, any event from any source. More advanced // application could use the Observer features in the event // channel to update this information (and reduce the number of // multicast groups that each receive subscribes to). // In a future version the event channel could perform some of // those tasks automatically RtecEventChannelAdmin::SupplierQOS pub; pub.publications.length (1); pub.publications[0].event.header.type = ACE_ES_EVENT_ANY; pub.publications[0].event.header.source = ACE_ES_EVENT_SOURCE_ANY; pub.is_gateway = 1; receiver->connect (pub); // **************** THAT COMPLETES THE FEDERATION SETUP // **************** HERE STARTS THE CLIENT SETUP // First let us create a consumer and connect it to the event // channel Consumer consumer (valuetype); RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin = event_channel->for_consumers (); consumer.connect (consumer_admin.in ()); // **************** THAT COMPLETES THE CLIENT SETUP // **************** HERE STARTS THE EVENT LOOP // Wait for events, including incoming multicast data. // We could also use orb->run(), but that will not let us // terminate the application in a nice way. for (int i = 0; i != 100; ++i) { CORBA::Boolean there_is_work = orb->work_pending (); if (there_is_work) { // We use a TAO extension. The CORBA mechanism does not // provide any decent way to control the duration of // perform_work() or work_pending(), so just calling // them results in a spin loop. ACE_Time_Value tv (0, 50000); orb->perform_work (tv); } ACE_Time_Value tv (0, 100000); ACE_OS::sleep (tv); if (consumer.event_count () == 25) { break; } } // **************** THAT COMPLETES THE EVENT LOOP // **************** HERE STARTS THE CLEANUP CODE consumer.disconnect (); // Now let us close the Receiver receiver->shutdown (); int const r = mcast_eh.shutdown (); if (r == -1) { ACE_ERROR_RETURN ((LM_ERROR, "Closing MCast event handler\n"), 1); } // The event channel must be destroyed, so it can release its // resources, and inform all the clients that are still // connected that it is going away. event_channel->destroy (); // Deactivating the event channel implementation is not strictly // required, the POA will do it for us, but it is good manners: { // Using _this() activates with the default POA, we must gain // access to that POA to deactivate the object. // Notice that we 'know' that the default POA for this servant // is the root POA, but the code is more robust if we don't // rely on that. PortableServer::POA_var poa = ec_impl._default_POA (); // Get the Object Id used for the servant.. PortableServer::ObjectId_var oid = poa->servant_to_id (&ec_impl); // Deactivate the object poa->deactivate_object (oid.in ()); } // Now we can destroy the POA, the flags mean that we want to // wait until the POA is really destroyed poa->destroy (1, 1); // Finally destroy the ORB orb->destroy (); // **************** THAT COMPLETES THE CLEANUP CODE ACE_DEBUG ((LM_DEBUG, "UDP receiver ready\n")); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Service"); return 1; } return 0; }
int Notifier_Input_Handler::init (int argc, ACE_TCHAR *argv[]) { // Call the init of <TAO_ORB_Manager> to initialize the ORB and // create the child poa under the root POA. this->argc_ = argc; this->argv_ = argv; if (this->orb_manager_.init_child_poa (this->argc_, this->argv_, "child_poa") == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "init_child_poa"), -1); int retval = this->parse_args (); if (retval != 0) return retval; // Register our <Input_Handler> to handle STDIN events, which will // trigger the <handle_input> method to process these events. CORBA::ORB_var orb = this->orb_manager_.orb (); if (ACE_Event_Handler::register_stdin_handler (this, orb->orb_core ()->reactor (), orb->orb_core ()->thr_mgr ()) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "register_stdin_handler"), -1); // Stash our ORB pointer for later reference. this->notifier_i_.orb (orb.in ()); // Activate the servant in the POA. CORBA::String_var str = this->orb_manager_.activate_under_child_poa ("Notifier", &this->notifier_i_); ACE_DEBUG ((LM_DEBUG, "The IOR is: <%s>\n", str.in ())); if (this->ior_output_file_) { ACE_OS::fprintf (this->ior_output_file_, "%s", str.in ()); ACE_OS::fclose (this->ior_output_file_); } if (this->using_naming_service_) { this->init_naming_service (); } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int result = 0; int extra_argc = 4; int second_extra_argc = 3; int largc = argc; int second_largc = argc; try { ACE_TCHAR **extra = 0; ACE_TCHAR **second_extra = 0; ACE_NEW_RETURN (extra, ACE_TCHAR *[extra_argc], -1); ACE_NEW_RETURN (second_extra, ACE_TCHAR *[second_extra_argc], -1); extra[0] = ACE::strnew (ACE_TEXT ("-ORBGestalt")); extra[1] = ACE::strnew (ACE_TEXT ("Local")); extra[2] = ACE::strnew (ACE_TEXT ("-ORBSvcConfDirective")); extra[3] = ACE::strnew (ACE_TEXT ("static Client_Strategy_Factory '-ORBReplyDispatcherTableSize 333'")); second_extra[0] = ACE::strnew (ACE_TEXT ("-ORBGestalt")); second_extra[1] = ACE::strnew (ACE_TEXT ("Local")); second_extra[2] = ACE::strnew (ACE_TEXT ("-ORBSvcConfDirective \"static Client_Strategy_Factory '-ORBReplyDispatcherTableSize 666'\"")); ACE_TCHAR **largv = new ACE_TCHAR *[largc+extra_argc]; for (int i = 0; i < largc; i++) largv[i] = argv[i]; ACE_TCHAR **second_largv = new ACE_TCHAR *[second_largc+second_extra_argc]; for (int i = 0; i < second_largc; i++) second_largv[i] = argv[i]; for (int i = 0; i < extra_argc; i++) { largv[argc+i] = extra[i]; } for (int i = 0; i < second_extra_argc; i++) { second_largv[argc+i] = second_extra[i]; } largc += extra_argc; second_largc += second_extra_argc; CORBA::ORB_var orb = CORBA::ORB_init (largc, largv, "FirstORB"); if (orb->orb_core()->client_factory()->reply_dispatcher_table_size () != 333) { ++result; } orb->destroy (); orb = CORBA::ORB::_nil (); CORBA::ORB_var second_orb = CORBA::ORB_init (second_largc, second_largv, "SecondORB"); if (second_orb->orb_core()->client_factory()->reply_dispatcher_table_size () != 666) { ++result; } second_orb->destroy (); second_orb = CORBA::ORB::_nil (); for (int i = 0; i < extra_argc; i++) ACE::strdelete (extra[i]); for (int i2 = 0; i2 < second_extra_argc; i2++) ACE::strdelete (second_extra[i2]); delete [] extra; delete [] largv; delete [] second_extra; delete [] second_largv; } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); } if (result == 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Test passed!"))); else ACE_ERROR ((LM_ERROR, ACE_TEXT ("Test failed. Result: %d\n"), result)); return result; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); int result = parse_args (argc, argv); if (result != 0) return result; // Make sure we can support multiple priorities that are required // for this test. if (!check_supported_priorities (orb.in ())) return 2; // The following finds out the lowest priority for this // scheduling policy. This will give us the biggest range on NT // since the default priority is 0 where as the lowest priority // is -15. int minimum_priority = ACE_Sched_Params::priority_min (orb->orb_core ()->orb_params ()->ace_sched_policy ()); // Thread Manager for managing task. ACE_Thread_Manager thread_manager; // Create task. Task task (thread_manager, orb.in ()); // Task activation flags. long flags = THR_NEW_LWP | THR_JOINABLE | orb->orb_core ()->orb_params ()->thread_creation_flags (); // Activate task. result = task.activate (flags, 1, 0, minimum_priority); if (result == -1) { if (errno == EPERM) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot create thread with scheduling policy %C\n" "because the user does not have the appropriate privileges, terminating program....\n" "Check svc.conf options and/or run as root\n", sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())), 2); } else // Unexpected error. ACE_ASSERT (0); } // Wait for task to exit. result = thread_manager.wait (); ACE_ASSERT (result != -1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Unexpected exception!"); return -1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { int result = 0; try { // Register the interceptors to check for the RTCORBA // service contexts in the reply messages. PortableInterceptor::ORBInitializer_ptr temp_initializer; ACE_NEW_RETURN (temp_initializer, Client_ORBInitializer, -1); // No exceptions yet! PortableInterceptor::ORBInitializer_var initializer = temp_initializer; PortableInterceptor::register_orb_initializer (initializer.in ()); // Initialize and obtain reference to the Test object. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return -1; // Make sure we can support multiple priorities that are required // for this test. if (!check_supported_priorities (orb.in ())) return 2; // Thread Manager for managing task. ACE_Thread_Manager thread_manager; // Create task. Task task (thread_manager, orb.in ()); // Task activation flags. long flags = THR_NEW_LWP | THR_JOINABLE | orb->orb_core ()->orb_params ()->thread_creation_flags (); // Activate task. result = task.activate (flags); if (result == -1) { if (errno == EPERM) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot create thread with scheduling policy %s\n" "because the user does not have the appropriate privileges, terminating program....\n" "Check svc.conf options and/or run as root\n", sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())), 2); } else // Unexpected error. ACE_ERROR_RETURN ((LM_ERROR, "ERROR: Cannot create thread. errno = %d\n", ACE_ERRNO_GET), -1); } // Wait for task to exit. result = thread_manager.wait (); } catch (const CORBA::Exception & ae) { ae._tao_print_exception ( "Caught exception:"); return -1; } return result; }