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