static void
wait_for_exception (CORBA::ORB_ptr orb,
Test::Echo_ptr echo)
{
ACE_Time_Value tv (1, 0);
orb->run (tv);
bool exception_detected = false;
while(!exception_detected)
{
try
{
CORBA::String_var dummy =
echo->echo_operation ("foo");
}
catch (const CORBA::Exception& ex)
{
exception_detected = true;
}
}
tv = ACE_Time_Value (1, 0);
orb->run (tv);
}
void
send_echo (TO_TYPE ctype, CORBA::ORB_ptr orb,
Simple_Server_ptr server,
CORBA::Long t)
{
try
{
server->echo (0, t);
in_time_count[ctype]++;
}
catch (const CORBA::TIMEOUT& )
{
timeout_count[ctype]++;
// Trap this exception and continue...
ACE_DEBUG ((LM_DEBUG,
"==> Trapped a TIMEOUT exception (expected)\n"));
// Sleep so the server can send the reply...
ACE_Time_Value tv (max_timeout / 1000, // max_timeout is in msec, so get seconds
(max_timeout % 1000) * 1000); // and usec
// This is a non-standard TAO call that's used to give the
// client ORB a chance to cleanup the reply that's come back
// from the server.
orb->run (tv);
}
}
void
sync_server (CORBA::ORB_ptr orb,
Test::AMI_Buffering_ptr flusher)
{
// Get back in sync with the server...
flusher->flush ();
flusher->sync ();
// Drain responses from the queue
ACE_Time_Value tv (0, 100000);
orb->run (tv);
}
static ACE_THR_FUNC_RETURN svc (void *arg)
{
CORBA::ORB_ptr orb = (CORBA::ORB_ptr)arg;
try
{
orb->run ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception: orb->run");
}
return 0;
}
int main(int argc, char ** argv)
{
try {
// init ORB
CORBA::ORB_ptr orb = CORBA::ORB_init(argc, argv);
// init POA
CORBA::Object_var poa_obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(poa_obj);
PortableServer::POAManager_var manager = poa->the_POAManager();
// create service
Math_operation * service = new Math_operation;
// register within the naming service
try {
CORBA::Object_var ns_obj = orb->resolve_initial_references("NameService");
if (!CORBA::is_nil(ns_obj)) {
CosNaming::NamingContext_ptr nc = CosNaming::NamingContext::_narrow(ns_obj);
CosNaming::Name name;
name.length(1);
name[0].id = CORBA::string_dup("TestServer");
name[0].kind = CORBA::string_dup("");
nc->rebind(name, service->_this());
cout << argv[0] << ": server 'TestServer' bound" << endl;
}
} catch (CosNaming::NamingContext::NotFound &) {
cerr << "not found" << endl;
} catch (CosNaming::NamingContext::InvalidName &) {
cerr << "invalid name" << endl;
} catch (CosNaming::NamingContext::CannotProceed &) {
cerr << "cannot proceed" << endl;
}
// run
manager->activate();
orb->run();
// clean up
delete service;
// quit
orb->destroy();
} catch (CORBA::UNKNOWN) {
cerr << "unknown exception" << endl;
} catch (CORBA::SystemException &) {
cerr << "system exception" << endl;
}
}
int
run(CORBA::ORB_ptr orb, int argc, char* argv[])
{
//
// Resolve Root POA
//
CORBA::Object_var poaObj = orb -> resolve_initial_references("RootPOA");
PortableServer::POA_var rootPOA = PortableServer::POA::_narrow(poaObj);
//
// Get a reference to the POA manager
//
PortableServer::POAManager_var manager = rootPOA -> the_POAManager();
//
// Create implementation object
//
Testing_impl* testingImpl = new Testing_impl(rootPOA);
PortableServer::ServantBase_var servant = testingImpl;
Testing_var testing = testingImpl->_this();
//
// Save reference
//
CORBA::String_var s = orb->object_to_string(testing);
const char* refFile = "testing.ref";
ofstream out(refFile);
if(out.fail())
{
cerr << argv[0] << ": can't open `" << refFile << "': "
<< strerror(errno) << endl;
return EXIT_FAILURE;
}
out << s << endl;
out.close();
//
// Run implementation
//
manager->activate();
orb->run();
return EXIT_SUCCESS;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
int status = 0;
try
{
Consumer_Client client;
status = client.init (argc, argv);
if (status != 0)
ACE_ERROR_RETURN ((LM_ERROR, "Error: Client init failed.\n"),1);
CosNotifyChannelAdmin::EventChannel_var ec =
client.create_event_channel ("MyEventChannel", 1);
CORBA::ORB_ptr orb = client.orb ();
CORBA::Object_var object =
orb->string_to_object (ior);
sig_var sig = sig::_narrow (object.in ());
CosNotifyChannelAdmin::ConsumerAdmin_var admin =
create_consumeradmin (ec.in ());
if (CORBA::is_nil (admin.in ()))
ACE_ERROR_RETURN ((LM_ERROR, "Error: nil ConsumerAdmin.\n"),1);
create_consumers (admin.in (), &client);
ACE_DEBUG ((LM_DEBUG, "\nConsumer waiting for events...\n"));
sig->go ();
ACE_Time_Value tv (5);
orb->run (tv);
ACE_DEBUG ((LM_DEBUG, "Consumer done.\n"));
}
catch (const CORBA::Exception& e)
{
e._tao_print_exception ("Consumer Error: ");
status = 1;
}
return status;
}
void *
TAO_LB_run_load_manager (void * orb_arg)
{
CORBA::ORB_ptr orb = static_cast<CORBA::ORB_ptr> (orb_arg);
// Only the main thread should handle signals.
//
// @@ This is probably unnecessary since no signals should be
// delivered to this thread on Linux.
ACE_Sig_Guard signal_guard;
try
{
orb->run ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("TAO Load Manager");
return reinterpret_cast<void *> (-1);
}
return 0;
}
void test_impl(
CORBA::ORB_ptr orb,
ACE_TCHAR const * ior,
bool shutdown)
{
CORBA::Object_var object = orb->string_to_object(ior);
Test_var test = Test::_narrow(object.in());
if(CORBA::is_nil(test.in()))
{
throw "Nil reference after narrow";
}
for(int i = 0; i != niterations; ++i)
{
test->sendc_the_operation(AMI_TestHandler::_nil());
}
ACE_Time_Value wait_for_responses_interval(1, 0);
orb->run(wait_for_responses_interval);
if (shutdown)
test->shutdown ();
}
int
run_buffer_size (CORBA::ORB_ptr orb,
PortableServer::POA_ptr root_poa,
Test::AMI_Buffering_ptr ami_buffering,
Test::AMI_Buffering_Admin_ptr ami_buffering_admin)
{
TAO::BufferingConstraint buffering_constraint;
buffering_constraint.mode = TAO::BUFFER_MESSAGE_BYTES;
buffering_constraint.message_count = 0;
buffering_constraint.message_bytes = BUFFER_SIZE;
buffering_constraint.timeout = 0;
Test::AMI_Buffering_var flusher;
int test_failed =
configure_policies (orb, buffering_constraint,
ami_buffering, flusher.out ());
if (test_failed != 0)
return test_failed;
Test::Payload payload (PAYLOAD_LENGTH);
payload.length (PAYLOAD_LENGTH);
Reply_Handler *reply_handler_impl;
ACE_NEW_RETURN (reply_handler_impl,
Reply_Handler,
1);
PortableServer::ServantBase_var owner_transfer(reply_handler_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (reply_handler_impl);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test::AMI_AMI_BufferingHandler_var reply_handler =
Test::AMI_AMI_BufferingHandler::_narrow (object_act.in ());
CORBA::ULong bytes_sent = 0;
for (int i = 0; i != iterations; ++i)
{
sync_server (orb, flusher.in ());
CORBA::ULong initial_bytes_received =
ami_buffering_admin->bytes_received_count ();
if (initial_bytes_received != bytes_sent)
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d data lost (%u != %u)\n",
i, initial_bytes_received, bytes_sent));
}
while (1)
{
ami_buffering->sendc_receive_data (reply_handler.in (),
payload);
bytes_sent += PAYLOAD_LENGTH;
CORBA::ULong bytes_received =
ami_buffering_admin->bytes_received_count ();
ACE_Time_Value tv (0, 10 * 1000);
orb->run (tv);
CORBA::ULong payload_delta =
bytes_sent - initial_bytes_received;
if (bytes_received != initial_bytes_received)
{
// The queue has been flushed, check that enough data
// has been sent. The check cannot be precise because
// the ORB counts the GIOP message overhead, in this
// test we assume the overhead to be less than 10%
if (payload_delta < CORBA::ULong (GIOP_OVERHEAD * BUFFER_SIZE))
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d flush before "
"minimum buffer size was reached. "
"Sent = %u, Minimum buffer = %u bytes\n",
i,
payload_delta, BUFFER_SIZE));
}
break;
}
if (payload_delta > 2 * BUFFER_SIZE)
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d no flush past "
"buffer size threshold. "
"Sent = %u, Minimum buffer = %u bytes\n",
i,
payload_delta, BUFFER_SIZE));
break;
}
}
}
int liveness_test_failed =
run_liveness_test (orb,
reply_handler.in (),
ami_buffering,
flusher.in (),
ami_buffering_admin);
if (liveness_test_failed)
test_failed = 1;
return test_failed;
}
int
run_timeout_reactive (CORBA::ORB_ptr orb,
PortableServer::POA_ptr root_poa,
Test::AMI_Buffering_ptr ami_buffering,
Test::AMI_Buffering_Admin_ptr ami_buffering_admin)
{
TAO::BufferingConstraint buffering_constraint;
buffering_constraint.mode = TAO::BUFFER_TIMEOUT;
buffering_constraint.message_count = 0;
buffering_constraint.message_bytes = 0;
buffering_constraint.timeout = TIMEOUT_MILLISECONDS * 10000;
Test::AMI_Buffering_var flusher;
int test_failed =
configure_policies (orb, buffering_constraint,
ami_buffering, flusher.out ());
if (test_failed != 0)
return test_failed;
Test::Payload payload (PAYLOAD_LENGTH);
payload.length (PAYLOAD_LENGTH);
for (int j = 0; j != PAYLOAD_LENGTH; ++j)
payload[j] = CORBA::Octet(j % 256);
Reply_Handler *reply_handler_impl = 0;
ACE_NEW_RETURN (reply_handler_impl,
Reply_Handler,
1);
PortableServer::ServantBase_var owner_transfer(reply_handler_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (reply_handler_impl);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test::AMI_AMI_BufferingHandler_var reply_handler =
Test::AMI_AMI_BufferingHandler::_narrow (object_act.in ());
CORBA::ULong send_count = 0;
int retry_attempt = 0;
for (int i = 0; i != iterations; ++i)
{
sync_server (orb, flusher.in ());
CORBA::ULong initial_receive_count =
ami_buffering_admin->request_count ();
if (initial_receive_count != send_count)
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d message lost (%u != %u)\n",
i, initial_receive_count, send_count));
}
ACE_Time_Value start = ACE_OS::gettimeofday ();
for (int j = 0; j != 20; ++j)
{
ami_buffering->sendc_receive_data (reply_handler.in (),
payload);
send_count++;
}
while (1)
{
CORBA::ULong receive_count =
ami_buffering_admin->request_count ();
ACE_Time_Value tv (0, 10 * 1000);
orb->run (tv);
ACE_Time_Value elapsed = ACE_OS::gettimeofday () - start;
if (receive_count != initial_receive_count)
{
if (elapsed.msec () < TIMEOUT_MILLISECONDS)
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d flush before "
"timeout expired. "
"Elapsed = %d, Timeout = %d msecs\n",
i,
elapsed.msec (), TIMEOUT_MILLISECONDS));
}
// terminate the while loop.
break;
}
if (elapsed.msec () > TIMEOUT_TOLERANCE)
{
if (retry_attempt++ < 10) {
ACE_DEBUG ((LM_DEBUG, "DEBUG: Retry attempt %d beyond TIMEOUT_TOLERANCE.\n",
retry_attempt));
continue;
}
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d no flush past "
"timeout threshold. "
"Elapsed = %d, Timeout = %d msecs\n",
i,
elapsed.msec (), TIMEOUT_TOLERANCE));
break;
}
}
}
#if 0
int liveness_test_failed =
run_liveness_test (orb,
reply_handler.in (),
ami_buffering,
flusher.in (),
ami_buffering_admin);
if (liveness_test_failed)
test_failed = 1;
#endif /* 0 */
return test_failed;
}
int
run_message_count (CORBA::ORB_ptr orb,
PortableServer::POA_ptr root_poa,
Test::AMI_Buffering_ptr ami_buffering,
Test::AMI_Buffering_Admin_ptr ami_buffering_admin)
{
TAO::BufferingConstraint buffering_constraint;
buffering_constraint.mode = TAO::BUFFER_MESSAGE_COUNT;
buffering_constraint.message_count = BUFFERED_MESSAGES_COUNT;
buffering_constraint.message_bytes = 0;
buffering_constraint.timeout = 0;
Test::AMI_Buffering_var flusher;
int test_failed =
configure_policies (orb, buffering_constraint,
ami_buffering, flusher.out ());
if (test_failed != 0)
return test_failed;
Test::Payload payload (PAYLOAD_LENGTH);
payload.length (PAYLOAD_LENGTH);
for (int j = 0; j != PAYLOAD_LENGTH; ++j)
payload[j] = CORBA::Octet(j % 256);
Reply_Handler *reply_handler_impl = 0;
ACE_NEW_RETURN (reply_handler_impl,
Reply_Handler,
1);
PortableServer::ServantBase_var owner_transfer(reply_handler_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (reply_handler_impl);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test::AMI_AMI_BufferingHandler_var reply_handler =
Test::AMI_AMI_BufferingHandler::_narrow (object_act.in ());
CORBA::ULong send_count = 0;
for (int i = 0; i != iterations; ++i)
{
sync_server (orb, flusher.in ());
CORBA::ULong initial_receive_count =
ami_buffering_admin->request_count ();
if (initial_receive_count != send_count)
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d message lost (%u != %u)\n",
i, initial_receive_count, send_count));
}
while (1)
{
ami_buffering->sendc_receive_data (reply_handler.in (),
payload);
send_count++;
CORBA::ULong receive_count =
ami_buffering_admin->request_count ();
ACE_Time_Value tv (0, 10 * 1000);
orb->run (tv);
CORBA::ULong iteration_count =
send_count - initial_receive_count;
if (receive_count != initial_receive_count)
{
if (iteration_count < CORBA::ULong(BUFFERED_MESSAGES_COUNT))
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d flush before "
"message count reached. "
"Iteration count = %u, Threshold = %u\n",
i,
iteration_count, BUFFERED_MESSAGES_COUNT));
}
break;
}
if (iteration_count > 2 * BUFFERED_MESSAGES_COUNT)
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d no flush past "
"message count threshold. "
"Iteration count = %u, Threshold = %u\n",
i,
iteration_count, BUFFERED_MESSAGES_COUNT));
break;
}
}
}
int liveness_test_failed =
run_liveness_test (orb,
reply_handler.in (),
ami_buffering,
flusher.in (),
ami_buffering_admin);
if (liveness_test_failed)
test_failed = 1;
return test_failed;
}
int
run_liveness_test (CORBA::ORB_ptr orb,
Test::AMI_AMI_BufferingHandler_ptr reply_handler,
Test::AMI_Buffering_ptr ami_buffering,
Test::AMI_Buffering_ptr flusher,
Test::AMI_Buffering_Admin_ptr ami_buffering_admin)
{
ACE_DEBUG ((LM_DEBUG, ".... checking for liveness\n"));
int test_failed = 0;
// Get back in sync with the server...
sync_server (orb, flusher);
CORBA::ULong send_count =
ami_buffering_admin->request_count ();
int liveness_test_iterations = int(send_count);
ACE_DEBUG ((LM_DEBUG, " liveness_test_iterations = %d\n",
liveness_test_iterations));
Test::Payload payload (PAYLOAD_LENGTH);
payload.length (PAYLOAD_LENGTH);
for (int j = 0; j != PAYLOAD_LENGTH; ++j)
payload[j] = CORBA::Octet(j % 256);
int depth = 0;
for (int i = 0; i != liveness_test_iterations; ++i)
{
ami_buffering->sendc_receive_data (reply_handler,
payload);
send_count++;
CORBA::ULong receive_count =
ami_buffering_admin->request_count ();
ACE_Time_Value tv (0, 10 * 1000);
orb->run (tv);
// Once the system has sent enough messages we don't
// expect it to fall too far behind, i.e. at least 90% of the
// messages should be delivered....
CORBA::ULong expected =
CORBA::ULong (LIVENESS_TOLERANCE * send_count);
if (receive_count < expected)
{
test_failed = 1;
ACE_DEBUG ((LM_DEBUG,
"DEBUG: Iteration %d "
"not enough messages received %u "
"expected %u\n",
i, receive_count, expected));
sync_server (orb, flusher);
}
if (depth++ == LIVENESS_MAX_DEPTH)
{
sync_server (orb, flusher);
depth = 0;
}
}
return test_failed;
}