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