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