int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
SyncServer sync_server (argc, argv);
sync_server.run ();
}
catch (SyncServer::InitError& ex)
{
std::string& msg = reinterpret_cast<std::string&>(ex);
std::cerr << "Initialization Error: "
<< msg.c_str() << std::endl;
return -1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("ERROR: SyncServer caught exception");
return -1;
}
return 0;
}
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;
}
