int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the ORB
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
// Get Object Reference using IOR file
CORBA::Object_var object =
orb->string_to_object (ior);
// Cast to Appropriate Type
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil\n", ior),
1);
}
Client_Worker client (server.in (), niterations);
if (client.activate (THR_NEW_LWP | THR_JOINABLE, nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Cannot Activate Client Threads\n"),
1);
client.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) threads finished\n"));
// Shut down the server if -x option given in command line
if (do_shutdown)
{
server->shutdown ();
}
// Destroying the ORB..
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
for (int i = 0; i != niterations; ++i)
{
CORBA::Long r =
server->test_method (i);
if (r != i)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) unexpected result = %d for %d",
r, i));
}
}
if (do_shutdown)
{
server->shutdown ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
Client client (server.in (), niterations);
if (client.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
client.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "threads finished\n"));
if (server_shutdown)
{
server->shutdown ();
}
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int do_shutdown_test (Simple_Server_var &server)
{
ACE_DEBUG ((LM_DEBUG,
"[client] invoking shutdown on the server \n "));
try
{
server->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Client: exception caught during shutdown - ");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil\n",
ior),
1);
}
while (!feof (stdin))
{
ACE_Read_Buffer buf (stdin, 0);
char *line = buf.read ('\n');
if (line == 0)
break;
server->send_line (line);
buf.alloc ()->free (line);
}
server->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object = orb->string_to_object (ior);
Simple_Server_var server = Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior), 1);
}
if (do_shutdown)
{
server->shutdown ();
}
else
{
Worker wrk (server.in ());
wrk.activate (THR_NEW_LWP|THR_JOINABLE|THR_INHERIT_SCHED, nthreads);
wrk.thr_mgr ()->wait ();
}
}
catch (const CORBA::Exception& ex)
{
ACE_DEBUG ((LM_ERROR, ACE_TEXT ("(%P|%t) ERROR: Exception caught: \n%C\n"),
ex._info ().c_str ()));
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
// Primary server
CORBA::Object_var object_primary =
orb->string_to_object (ior);
//Secondary server
CORBA::Object_var object_secondary =
orb->string_to_object (name);
// Get an object reference for the ORBs IORManipultion object!
CORBA::Object_var IORM =
orb->resolve_initial_references (TAO_OBJID_IORMANIPULATION, 0);
TAO_IOP::TAO_IOR_Manipulation_var iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in ());
TAO_IOP::TAO_IOR_Manipulation::IORList iors (2);
iors.length(2);
iors [0] = object_primary;
iors [1] = object_secondary;
CORBA::Object_var merged = iorm->merge_iors (iors);
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
CORBA::Any timeout_as_any;
timeout_as_any <<= timeout_period;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (TAO::CONNECTION_TIMEOUT_POLICY_TYPE,
timeout_as_any);
policy_current->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
for (CORBA::ULong l = 0;
l != policy_list.length ();
++l)
{
policy_list[l]->destroy ();
}
// Combined IOR stuff
Simple_Server_var server =
Simple_Server::_narrow (merged.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
CORBA::ULongLong freq =
run_test (server.in ());
if (freq != 919263)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) ERROR in the test\n")));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Shutting server down\n")));
server->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught an exception\n");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
Worker worker (orb.in ());
if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate worker threads\n"),
1);
int timeout = 30;
int now = 0;
while (now < timeout &&
((expect_ex_kind == 0 && !worker.invocation_completed ()) ||
(expect_ex_kind != 0 && expect_ex_kind != worker.received_ex_kind ()))
)
{
std::cout << "." << std::flush;
now += 1;
ACE_Time_Value tv (1, 0);
orb->run (tv);
}
ACE_ASSERT (now != 0);
std::cout << std::endl;
worker.done ();
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
server->shutdown ();
ACE_OS::sleep (1);
orb->destroy ();
worker.thr_mgr ()->wait ();
bool expect_no_ex =
expect_ex_kind == TAO::FOE_NON && worker.num_received_ex () == 0 && worker.invocation_completed ();
bool expect_ex_received =
expect_ex_kind == worker.received_ex_kind () && worker.num_received_ex () > 0 && !worker.invocation_completed ();
if (expect_no_ex || expect_ex_received)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t)client: test passed.\n"));
return 0;
}
else
{
ACE_DEBUG ((LM_ERROR, "(%P|%t)client: test failed.\n"));
return 1;
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
{
return 1;
}
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
Structure the_in_structure;
the_in_structure.seq.length (10);
if (test_user_exception == 1)
{
server->raise_user_exception ();
}
else if (test_system_exception == 1)
{
server->raise_system_exception ();
}
else
{
for (int i = 0; i != niterations; ++i)
{
CORBA::Long const tv = i + 100;
server->test_val(tv);
CORBA::Long const rtv = server->test_val ();
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
"DSI_Simpler_Server ==== Expected result = %d for %d\n",
rtv, tv));
}
if (rtv != tv)
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) ERROR: unexpected result = %d for %d\n",
rtv, tv));
}
the_in_structure.i = i;
CORBA::String_var name = CORBA::string_dup ("the name");
Structure_var the_out_structure;
CORBA::Long const r =
server->test_method (i,
the_in_structure,
the_out_structure.out (),
name.inout ());
if (TAO_debug_level > 0)
{
ACE_DEBUG ((LM_DEBUG,
"DSI_Simpler_Server ====\n"
" x = %d\n"
" i = %d\n"
" length = %d\n"
" name = <%C>\n",
r,
the_out_structure->i,
the_out_structure->seq.length (),
name.in ()));
}
if (r != i)
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) ERROR: unexpected result = %d for %d",
r, i));
}
}
}
if (do_shutdown)
{
server->shutdown ();
}
}
catch (const test_exception& ex)
{
if (test_user_exception == 1)
ACE_DEBUG ((LM_DEBUG,
"Client: caught expected user exception: %C\n",
ex._name()));
else
ex._tao_print_exception ("Client: exception caught - ");
ACE_DEBUG ((LM_DEBUG,
"error code: %d\n"
"error info: %C\n"
"status: %C\n",
ex.error_code,
ex.error_message.in (),
ex.status_message.in ()));
return test_user_exception == 1 ? 0 : 1;
}
catch (const CORBA::NO_PERMISSION& ex)
{
if (test_system_exception == 1)
ACE_DEBUG ((LM_DEBUG,
"Client: caught expected system exception: %C\n",
ex._name()));
else
ex._tao_print_exception ("Client: exception caught - ");
return test_system_exception == 1 ? 0 : 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Client: 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");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
Callback_i callback_impl (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&callback_impl);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Callback_var callback =
Callback::_narrow (object_act.in ());
for (int i = 0; i != niterations; ++i)
{
CORBA::Long r =
server->test_method (0, 0, callback.in ());
if (r != 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) unexpected result = %d for %d",
r, i));
}
}
if (do_abort)
{
try
{
server->shutdown_now (0);
}
catch (const CORBA::COMM_FAILURE&)
{
// Expected exception, continue....
}
}
else if (do_crash)
{
try
{
server->shutdown_now (1);
}
catch (const CORBA::COMM_FAILURE&)
{
// Expected exception, continue....
}
}
else if (do_suicide)
{
(void) server->test_method (1, 0, callback.in ());
// The shutdown callback could arrive after this twoway invocation
// returned. Wait for it shutdown callback and abort,
// otherwise it will timeout (in run_test.pl).
ACE_OS::sleep (120);
}
else if (do_self_shutdown)
{
(void) server->test_method (1, 1, callback.in ());
}
if (do_shutdown)
{
server->shutdown ();
}
root_poa->destroy (1, 1);
}
catch (const CORBA::COMM_FAILURE& x)
{
// For other case this is expected.
if (do_self_shutdown == 0)
{
x._tao_print_exception ("ERROR: Unexpected exception\n");
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in client:");
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;
Worker worker (orb.in ());
if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate worker threads\n"),
1);
int timeout = 30;
int now = 0;
while (now < timeout
&& ((expect_ex_kind != TAO::FOE_NON
&& worker.received_ex_kind () != expect_ex_kind
&& worker.num_received_ex () != expect_num_ex)
|| expect_ex_kind == TAO::FOE_NON))
{
std::cout << ".";
now += 1;
ACE_Time_Value tv (1, 0);
orb->run (tv);
}
std::cout << std::endl;
worker.done ();
if (do_shutdown)
{
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
server->shutdown ();
}
ACE_OS::sleep (1);
orb->destroy ();
worker.thr_mgr ()->wait ();
if (worker.received_ex_kind () != expect_ex_kind
|| worker.num_received_ex () != expect_num_ex)
{
ACE_ERROR_RETURN ((LM_ERROR,
("(%P|%t)client: test failed - expected is different from received. "
"expected %d/%d received %d/%d.\n"),
expect_ex_kind, expect_num_ex, worker.received_ex_kind (), worker.num_received_ex()),
1);
}
ACE_DEBUG ((LM_DEBUG, "(%P|%t)client: test passed.\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
Fixed_Priority_Scheduler* scheduler=0;
RTScheduling::Current_var current;
int prio;
int max_prio;
ACE_Sched_Params::Policy sched_policy = ACE_SCHED_RR;
int sched_scope = ACE_SCOPE_THREAD;
long flags;
if (sched_policy == ACE_SCHED_RR)
flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_RR;
else
flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_FIFO;
ACE_hthread_t main_thr_handle;
ACE_Thread::self (main_thr_handle);
max_prio = ACE_Sched_Params::priority_max (sched_policy,
sched_scope);
//FUZZ: disable check_for_lack_ACE_OS
ACE_Sched_Params sched_params (sched_policy, max_prio);
//FUZZ: enable check_for_lack_ACE_OS
ACE_OS::sched_params (sched_params);
if (ACE_Thread::getprio (main_thr_handle, prio) == -1)
{
if (errno == ENOTSUP)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT ("getprio not supported\n")
));
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n")
ACE_TEXT ("thr_getprio failed")));
}
}
ACE_DEBUG ((LM_DEBUG, "(%t): main thread prio is %d\n", prio));
try
{
RTScheduling::Scheduler_var sched_owner;
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);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
if (enable_dynamic_scheduling)
{
ACE_DEBUG ((LM_DEBUG, "Dyn Sched enabled\n"));
CORBA::Object_var manager_obj =
orb->resolve_initial_references ("RTSchedulerManager");
TAO_RTScheduler_Manager_var manager =
TAO_RTScheduler_Manager::_narrow (manager_obj.in ());
Kokyu::DSRT_Dispatcher_Impl_t disp_impl_type;
if (enable_yield)
{
disp_impl_type = Kokyu::DSRT_CV_BASED;
}
else
{
disp_impl_type = Kokyu::DSRT_OS_BASED;
}
ACE_NEW_RETURN (scheduler,
Fixed_Priority_Scheduler (orb.in (),
disp_impl_type,
sched_policy,
sched_scope), -1);
sched_owner = scheduler;
manager->rtscheduler (scheduler);
CORBA::Object_var object =
orb->resolve_initial_references ("RTScheduler_Current");
current =
RTScheduling::Current::_narrow (object.in ());
}
Worker worker1 (orb.in (),
server.in (),
current.in (),
scheduler, 10, 15);
if (worker1.activate (flags, 1, 0, max_prio) != 0)
{
ACE_ERROR ((LM_ERROR,
"(%t|%T) cannot activate worker thread.\n"));
}
ACE_OS::sleep(2);
Worker worker2 (orb.in (),
server.in (),
current.in (),
scheduler, 12, 5);
if (worker2.activate (flags, 1, 0, max_prio) != 0)
{
ACE_ERROR ((LM_ERROR,
"(%t|%T) cannot activate scheduler thread in RT mode.\n"));
}
worker1.wait ();
worker2.wait ();
ACE_DEBUG ((LM_DEBUG,
"(%t): wait for worker threads done in main thread\n"));
if (do_shutdown)
{
if (enable_dynamic_scheduling)
{
FP_Scheduling::SegmentSchedulingParameter sched_param;
sched_param.base_priority = 0;
CORBA::Policy_var sched_param_policy
= scheduler->create_segment_scheduling_parameter (sched_param);
CORBA::Policy_ptr implicit_sched_param = 0;
current->begin_scheduling_segment (0,
sched_param_policy.in (),
implicit_sched_param);
}
ACE_DEBUG ((LM_DEBUG, "(%t): about to call server shutdown\n"));
server->shutdown ();
ACE_DEBUG ((LM_DEBUG, "after shutdown call in main thread\n"));
if (enable_dynamic_scheduling)
{
current->end_scheduling_segment (0);
}
}
scheduler->shutdown ();
ACE_DEBUG ((LM_DEBUG, "scheduler shutdown done\n"));
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) == -1)
return -1;
CORBA::Object_var obj =
orb->string_to_object (proxy_ior);
if (obj.in () == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"The received object is nil\n"),
-1);
}
Simple_Server_var server =
Simple_Server::_narrow (obj.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference is nil\n"),
-1);
}
try
{
while (true)
{
// Make a remote call
server->remote_call ();
ACE_OS::sleep (2);
}
}
catch (CORBA::TRANSIENT& ex)
{
CORBA::ULong m = ex.minor () & 0x00000F80u;
if (m == TAO_INVOCATION_LOCATION_FORWARD_MINOR_CODE &&
ex.completed () == CORBA::COMPLETED_NO)
{
ACE_DEBUG ((LM_DEBUG,
"TRANSIENT caught in client as it was expected.\n"));
}
else
{
ex._tao_print_exception ("Unexpected TRANSIENT caught in client:");
return 2;
}
}
obj =
orb->string_to_object (control_ior);
if (obj.in () == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"The received objref is NULL\n"),
-1);
}
server =
Simple_Server::_narrow (obj.in ());
server->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception & ex)
{
ex._tao_print_exception ("Exception caught in client:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
object =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (object.in ());
object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
TimeBase::TimeT mid_value =
10000 * (min_timeout + max_timeout) / 2; // convert from msec to "TimeT" (0.1 usec units)
CORBA::Any any_orb;
any_orb <<= mid_value;
CORBA::Any any_thread;
any_thread <<= mid_value + 10000; // midvalue + 1 msec
CORBA::Any any_object;
any_object <<= mid_value + 20000; // midvalue + 2 msec
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_object);
object =
server->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
Simple_Server_var timeout_server =
Simple_Server::_narrow (object.in ());
policy_list[0]->destroy ();
policy_list[0] = CORBA::Policy::_nil ();
ACE_DEBUG ((LM_DEBUG,
"client (%P) testing from %d to %d milliseconds\n",
min_timeout, max_timeout));
for (CORBA::Long t = min_timeout; t < max_timeout; ++t)
{
ACE_DEBUG ((LM_DEBUG,
"\n================================\n"
"Trying with timeout = %d msec\n", t));
ACE_DEBUG ((LM_DEBUG,
"Cleanup ORB/Thread/Object policies\n"));
policy_list.length (0);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (none, orb.in (), server.in (), t);
ACE_DEBUG ((LM_DEBUG,
"client(%P) Set the ORB policies\n"));
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_orb);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (orb1, orb.in (), server.in (), t);
policy_list[0]->destroy ();
ACE_DEBUG ((LM_DEBUG,
"client(%P) Set the thread policies\n"));
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_thread);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (thread1, orb.in (), server.in (), t);
policy_list[0]->destroy ();
ACE_DEBUG ((LM_DEBUG,
"client(%P) Use the object policies\n"));
send_echo (object1, orb.in (), timeout_server.in (), t);
}
ACE_DEBUG ((LM_DEBUG,
"\n\n\nclient(%P) Test completed, "
"resynch with server\n"));
policy_list.length (0);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (none, orb.in (), server.in (), 0);
server->shutdown ();
int timeout_count_total = 0;
int in_time_count_total = 0;
for (int i = 0; i < 4; i++) {
timeout_count_total += timeout_count[i];
in_time_count_total += in_time_count[i];
ACE_DEBUG ((LM_DEBUG, "in_time_count[%C]= %d timeout_count[%C]= %d\n",
to_type_names[i], in_time_count[i],
to_type_names[i], timeout_count[i]));
}
if (timeout_count_total == 0)
ACE_ERROR ((LM_ERROR,
"ERROR: No messages timed out\n"));
//FUZZ: disable check_for_lack_ACE_OS
if (in_time_count_total == 0)
ACE_ERROR ((LM_ERROR,
"ERROR: No messages on time (within time limit)\n"));
//FUZZ: enable check_for_lack_ACE_OS
ACE_DEBUG ((LM_DEBUG, "in_time_count_total = %d, timeout_count_total = %d\n",
in_time_count_total, timeout_count_total));
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
Worker worker (orb.in ());
if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate worker threads\n"),
1);
int timeout = 30;
int now = 0;
while (now < timeout && worker.got_object_not_exist () != expected_object_not_exist)
{
now += 5;
ACE_Time_Value tv (5, 0);
orb->run (tv);
}
if (do_shutdown)
{
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
server->shutdown ();
}
orb->shutdown ();
worker.thr_mgr ()->wait ();
orb->destroy ();
if (worker.got_object_not_exist () != expected_object_not_exist)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t)client: test failed.\n"),
1);
}
else
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t)client: test passed.\n"));
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main:");
return 1;
}
return 0;
}
int
Client::svc (void)
{
try
{
Octet_Seq octetSeq(SIZE_BLOCK);
Char_Seq charSeq(SIZE_BLOCK);
ACE_High_Res_Timer timer;
ACE_OS::printf("Start sending %d Msgs...\n",this->niterations_);
charSeq.length(SIZE_BLOCK);
octetSeq.length(SIZE_BLOCK);
// This sets up the connector, so that we do not incur
// the overhead on the first call in the loop.
server_->sendCharSeq (charSeq);
timer.start ();
ACE_UINT32 client_count = 0;
for (ACE_UINT32 i = 0; i < this->niterations_; ++i)
{
client_count++;
server_->sendCharSeq (charSeq);
//server_->sendOctetSeq (octetSeq);
//ACE_DEBUG ((LM_DEBUG, "."));
}
timer.stop ();
ACE_Time_Value measured;
timer.elapsed_time (measured);
//ACE_DEBUG ((LM_DEBUG, "...finished\n"));
time_t dur = measured.sec () * 1000000 + measured.usec ();
if (dur == 0 || this->niterations_ == 0)
ACE_DEBUG ((LM_DEBUG, "Time not measurable, calculation skipped\n"));
else
{
ACE_DEBUG ((LM_DEBUG,
"Time for %u Msgs: %u usec\n",
this->niterations_,
dur));
ACE_DEBUG ((LM_DEBUG, "Time for 1 Msg: %u usec, %u calls/sec\n",
dur / this->niterations_,
1000000 / (dur / this->niterations_)));
}
for (int c = 0; c < 10; ++c)
server_->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("MT_Client: exception raised");
}
return 0;
}
