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