void zchat_client_run(const char* server_url, const char* login) { client_state * state = client_state_init(server_url, login); client_task(state); client_state_destroy(state); }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { if (parse_args (argc, argv) == -1) return -1; try { ACE_Argv_Type_Converter satc (argc, argv); CORBA::ORB_var sorb = CORBA::ORB_init (satc.get_argc (), satc.get_TCHAR_argv (), server_orb.c_str ()); ACE_Manual_Event me; Server_Task server_task (output, sorb.in (), me, ACE_Thread_Manager::instance ()); if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } // Wait for the server thread to do some processing me.wait (); ACE_Argv_Type_Converter catc (argc, argv); CORBA::ORB_var corb = CORBA::ORB_init (catc.get_argc (), catc.get_TCHAR_argv (), client_orb.c_str ()); Client_Task client_task (input, corb.in (), syncMode, ACE_Thread_Manager::instance ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); } catch (const CORBA::Exception&) { // Ignore exceptions.. } 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 tmp = orb->string_to_object (ior); Test::Process_Factory_var process_factory = Test::Process_Factory::_narrow(tmp.in ()); if (CORBA::is_nil (process_factory.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil process reference <%s>\n", ior), 1); } Client_Task client_task (process_factory.in (), iterations); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, threads, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); process_factory->shutdown (); orb->destroy (); // Only pass the test if 90% of the calls worked if (client_task.successful_calls () < 0.9 * iterations * threads) { ACE_ERROR ((LM_ERROR, "ERROR: no calls were successful\n")); } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { //Use Real-time Scheduling class if possible set_priority(); try { CORBA::ORB_var sorb = CORBA::ORB_init (argc, argv); if (parse_args (argc,argv) == -1) return -1; ACE_Manual_Event wait_for_event; Server_Task server_task (sorb.in (), wait_for_event, ACE_Thread_Manager::instance ()); if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } // Wait for the server thread to do some processing wait_for_event.wait (); // Obtain the object reference Test::Roundtrip_var reference = server_task.get_reference (); Client_Task client_task (reference.in (), niterations, ACE_Thread_Manager::instance ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); } catch (const CORBA::Exception&) { // Ignore exceptions.. } 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 (); CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent"); CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (object.in ()); if (CORBA::is_nil (policy_current.in ())) { ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n")); return 1; } CORBA::Any scope_as_any; scope_as_any <<= Messaging::SYNC_NONE; CORBA::PolicyList policies (1); policies.length (1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, scope_as_any); policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); policies[0]->destroy (); if (parse_args (argc, argv) != 0) return 1; // Get the sender reference.. CORBA::Object_var tmp = orb->string_to_object(ior); Test::Sender_var sender = Test::Sender::_narrow(tmp.in ()); if (CORBA::is_nil (sender.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil coordinator reference <%s>\n", ior), 1); } Client_Task client_task (orb.in(), sender.in (), ACE_Thread_Manager::instance (), number_of_oneways); Server_Task server_task (orb.in (), ACE_Thread_Manager::instance ()); // Before creating threads we will let the sender know that we // will have two threads that would make invocations.. // this is the first oneway we do, so after this we would have a queue // on one of the transports sender->active_objects ((CORBA::Short) number_of_client_tasks); TAO::Transport_Cache_Manager& manager = orb->orb_core()->lane_resources ().transport_cache (); TAO::Transport_Cache_Manager::HASH_MAP& cachemap = manager.map(); TAO::Transport_Cache_Manager::HASH_MAP_ITER end_iter = cachemap.end (); bool tranportwithqueue = false; for (TAO::Transport_Cache_Manager::HASH_MAP_ITER iter = cachemap.begin (); iter != end_iter; ++iter) { TAO_Transport* transport = (*iter).int_id_.transport (); if (transport->queue_is_empty() == 0 && transport->is_connected() == false) { tranportwithqueue = true; break; } } if (!tranportwithqueue) { ACE_ERROR ((LM_ERROR, "(%P|%t) Error: expect a not connected transport with a queue\n")); } else { ACE_DEBUG((LM_DEBUG, "(%P|%t) Found not connected transport with a queue\n")); } if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 2,1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, number_of_client_tasks, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); ACE_DEBUG ((LM_DEBUG, "Event Loop finished\n")); orb->destroy (); if (tranportwithqueue == false) { return 1; } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int test_failed = 0; try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); if (CORBA::is_nil (root_poa.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Panic: nil RootPOA\n"), 1); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); poa_manager->activate (); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = orb->string_to_object(server_ior); Test::AMI_Buffering_var ami_buffering = Test::AMI_Buffering::_narrow(tmp.in ()); if (CORBA::is_nil (ami_buffering.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil Test::AMI_Buffering reference <%s>\n", server_ior), 1); } tmp = orb->string_to_object(admin_ior); Test::AMI_Buffering_Admin_var ami_buffering_admin = Test::AMI_Buffering_Admin::_narrow(tmp.in ()); if (CORBA::is_nil (ami_buffering_admin.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil Test::AMI_Buffering_Admin reference <%s>\n", admin_ior), 1); } Client_Task client_task (orb.in ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } if (run_message_count_test) { ACE_DEBUG ((LM_DEBUG, "Running message count flushing test\n")); test_failed = run_message_count (orb.in (), root_poa.in (), ami_buffering.in (), ami_buffering_admin.in ()); } else if (run_timeout_test) { ACE_DEBUG ((LM_DEBUG, "Running timeout flushing test\n")); test_failed = run_timeout (orb.in (), root_poa.in (), ami_buffering.in (), ami_buffering_admin.in ()); } else if (run_timeout_reactive_test) { ACE_DEBUG ((LM_DEBUG, "Running timeout (reactive) flushing test\n")); test_failed = run_timeout_reactive (orb.in (), root_poa.in (), ami_buffering.in (), ami_buffering_admin.in ()); } else if (run_buffer_size_test) { ACE_DEBUG ((LM_DEBUG, "Running buffer size flushing test\n")); test_failed = run_buffer_size (orb.in (), root_poa.in (), ami_buffering.in (), ami_buffering_admin.in ()); } else { ACE_ERROR ((LM_ERROR, "ERROR: No test was configured\n")); } client_task.terminate_loop (); client_task.thr_mgr ()->wait (); ami_buffering->shutdown (); root_poa->destroy (1, 1); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in client:"); return 1; } return test_failed; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { if (parse_args (argc, argv) == -1) return -1; try { // Start the Naming Service tasks NamingTask name_service ("NamingORBA", argc, argv); name_service.activate(); // Wait for the Naming Service initialized. name_service.waitInit(); ACE_Argv_Type_Converter satc (argc, argv); CORBA::ORB_var sorb = CORBA::ORB_init (satc.get_argc (), satc.get_TCHAR_argv (), server_orb.c_str ()); ACE_Manual_Event me; Server_Task server_task (name_service.root (), sorb.in (), me, ACE_Thread_Manager::instance ()); if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } // Wait for the server thread to do some processing me.wait (); ACE_Argv_Type_Converter catc (argc, argv); CORBA::ORB_var corb = CORBA::ORB_init (catc.get_argc (), catc.get_TCHAR_argv (), client_orb.c_str ()); Client_Task client_task (name_service.root (), corb.in (), ACE_Thread_Manager::instance (), result); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } // Wait for the client and server to finish ACE_Thread_Manager::instance ()->wait (); // Now that all threads have completed we can destroy the ORB sorb->destroy (); if (server_orb != client_orb) { corb->destroy (); } } catch (const CORBA::Exception&) { // Ignore exceptions.. } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { ACE_Argv_Type_Converter main_args_s (argc, argv); CORBA::ORB_var sorb = CORBA::ORB_init (main_args_s.get_argc (), main_args_s.get_TCHAR_argv (), "Server_ORB"); // Parse command line if (parse_args (argc, argv) == -1) { return -1; } ACE_Manual_Event me; Server_Task server_task (ior_output_file, sorb.in (), me, ACE_Thread_Manager::instance ()); if (server_task.activate (THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating the server task.")); return -1; } // Wait for the server task to activate. me.wait (); ACE_Argv_Type_Converter main_args_c (argc, argv); CORBA::ORB_var corb = CORBA::ORB_init (main_args_c.get_argc (), main_args_c.get_TCHAR_argv (), "Client_ORB"); { Client_Task client_task (ior_input_file, corb.in (), ACE_Thread_Manager::instance ()); if (client_task.activate (THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client thread.\n")); return -1; } ACE_Thread_Manager::instance ()->wait (); } corb->destroy (); } catch (const CORBA::Exception&) { // ignore exceptions } ACE_DEBUG ((LM_DEBUG, "Threaded client ready.\n")); return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize the ORB. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Initialize options based on command-line arguments. int parse_args_result = parse_args (argc, argv); if (parse_args_result != 0) return parse_args_result; // Get an object reference from the argument string. CORBA::Object_var object = orb->string_to_object (IOR); // Try to narrow the object reference to a <server> reference. test_var server = test::_narrow (object.in ()); Client_Task client_task (server.in ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, number_of_client_threads) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate client threads\n"), -1); // Make sure to give the client threads enough time to become // leaders. ACE_OS::sleep (4); Event_Loop_Task event_loop_task (orb.in ()); if (event_loop_task.activate (THR_NEW_LWP | THR_JOINABLE, number_of_event_loop_threads) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate event_loop threads\n"), -1); event_loop_task.thr_mgr ()->wait (); client_task.thr_mgr ()->wait (); ACE_DEBUG ((LM_DEBUG, "Client: All threads finished @ %T\n")); // Shutdown server. if (shutdown_server) { 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[]) { if (parse_args (argc, argv) == -1) return -1; try { ACE_Argv_Type_Converter satc (argc, argv); CORBA::ORB_var sorb = CORBA::ORB_init (satc.get_argc (), satc.get_TCHAR_argv (), server_orb.c_str ()); ACE_Manual_Event me; Server_Task server_task (output, simple_test_output, sorb.in (), me, ACE_Thread_Manager::instance ()); if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } // Wait for the server thread to do some processing me.wait (); ACE_Argv_Type_Converter catc (argc, argv); CORBA::ORB_var corb = CORBA::ORB_init (catc.get_argc (), catc.get_TCHAR_argv (), client_orb.c_str ()); Client_Task client_task (input, simple_test_input, corb.in (), ACE_Thread_Manager::instance ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } // Wait for the client and server to finish ACE_Thread_Manager::instance ()->wait (); // Now that all threads have completed we can destroy the ORB sorb->destroy (); if (server_orb != client_orb) { corb->destroy (); } CORBA::ULong errors = client_task.error_count () + server_task.error_count (); if (errors == 0) { ACE_DEBUG((LM_DEBUG, "(%P|%t) test passed\n")); } else { ACE_DEBUG((LM_DEBUG, "(%P|%t) test failed - error_count=%u\n", errors)); return 1; } } catch (const CORBA::Exception&) { // Ignore exceptions.. } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { if (parse_args (argc, argv) == -1) return -1; try { // Keep a copy of the ORB options args ACE_ARGV orb_args; for (int i = 1; i < argc; ++i) { if (orb_args.add (argv[i]) == -1) return -1; } ACE_Argv_Type_Converter satc (argc, argv); // This eats all orb-specific options! CORBA::ORB_var sorb = CORBA::ORB_init (satc.get_argc (), satc.get_TCHAR_argv (), server_orb.c_str ()); ACE_Manual_Event me; Server_Task server_task (output, sorb.in (), me, ACE_Thread_Manager::instance ()); if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } // Wait for the server thread to do some processing me.wait (); // Restore the orb-specific options. argc = orb_args.argc (); for (int i = 1; i < argc; ++i) { argv[i] = const_cast<ACE_TCHAR*> (orb_args[i]); } ACE_Argv_Type_Converter catc (argc, argv); CORBA::ORB_var corb = CORBA::ORB_init (catc.get_argc(), catc.get_TCHAR_argv(), client_orb.c_str ()); Client_Task client_task (input, corb.in (), ACE_Thread_Manager::instance ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } // Wait for the client and server to finish ACE_Thread_Manager::instance ()->wait (); // Now that all threads have completed we can destroy the ORB sorb->destroy (); if (server_orb != client_orb) { corb->destroy (); } } catch (const CORBA::Exception&) { // Ignore exceptions.. } return 0; }
int main (int argc, char ** argv) { pami_client_t client; pami_context_t context; pami_task_t task; size_t size; pami_dispatch_callback_function fn; pami_dispatch_hint_t options; pami_result_t result = PAMI_ERROR; /* ====== INITIALIZE ====== */ result = PAMI_Client_create ("TEST", &client, NULL, 0); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error. Unable to initialize pami client. result = %d\n", result); return 1; } task = client_task (client); size = client_size (client); result = PAMI_Context_createv (client, NULL, 0, &context, 1); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error. Unable to create pami context. result = %d\n", result); return 1; } fn.p2p = dispatch_fn; options.recv_immediate = PAMI_HINT_DEFAULT; result = PAMI_Dispatch_set (context, DISPATCH_ID_DEFAULT_EXPECT_IMMEDIATE, fn, (void *) EXPECT_IMMEDIATE, options); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error. Unable to register DISPATCH_ID_DEFAULT_EXPECT_IMMEDIATE. result = %d\n", result); return 1; } options.recv_immediate = PAMI_HINT_DEFAULT; result = PAMI_Dispatch_set (context, DISPATCH_ID_DEFAULT_EXPECT_ASYNC, fn, (void *) EXPECT_ASYNC, options); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error. Unable to register DISPATCH_ID_DEFAULT_EXPECT_ASYNC. result = %d\n", result); return 1; } options.recv_immediate = PAMI_HINT_ENABLE; result = PAMI_Dispatch_set (context, DISPATCH_ID_ENABLE, fn, (void *) EXPECT_IMMEDIATE, options); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error. Unable to register DISPATCH_ID_ENABLE. result = %d\n", result); return 1; } options.recv_immediate = PAMI_HINT_DISABLE; result = PAMI_Dispatch_set (context, DISPATCH_ID_DISABLE, fn, (void *) EXPECT_ASYNC, options); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error. Unable to register DISPATCH_ID_DISABLE. result = %d\n", result); return 1; } /* ====== START TEST ====== */ __test_errors = 0; __test_recvs = 0; size_t test_count = 0; volatile size_t send_active = 0; pami_send_t parameters; parameters.send.header.iov_base = __junk; parameters.send.header.iov_len = 0; parameters.send.data.iov_base = __junk; parameters.send.data.iov_len = 0; parameters.send.dispatch = 0; parameters.events.cookie = (void *) & send_active; parameters.events.local_fn = decrement; parameters.events.remote_fn = NULL; result = PAMI_Endpoint_create (client, 0, 0, ¶meters.send.dest); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: PAMI_Endpoint_create() failed for task 0, context 0 with %d.\n", result); return 1; } /* =================================================================== * 'recv_immediate' default * * (header+data) > recv_immediate_max MUST be an asynchronous receive * * A zero-byte send will \b always result in an immediate receive. * \see pami_dispatch_p2p_function * * Data sizes to test: * - recv_immediate_max + 1 * - 0 */ parameters.send.data.iov_len = recv_immediate_max (context, DISPATCH_ID_DEFAULT_EXPECT_ASYNC) + 1; parameters.send.dispatch = DISPATCH_ID_DEFAULT_EXPECT_ASYNC; test_count++; if (task == 1) { send_active++; result = PAMI_Send (context, ¶meters); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: Unable to send to 0x%08x using dispatch %zu with %d.\n", parameters.send.dest, parameters.send.dispatch, result); return 1; } } parameters.send.data.iov_len = 0; parameters.send.dispatch = DISPATCH_ID_DEFAULT_EXPECT_IMMEDIATE; test_count++; if (task == 1) { send_active++; result = PAMI_Send (context, ¶meters); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: Unable to send to 0x%08x using dispatch %zu with %d.\n", parameters.send.dest, parameters.send.dispatch, result); return 1; } } /* =================================================================== * 'recv_immediate' enabled * * All receives are 'immediate'. (header+data) > recv_immediate_max is * invalid, but may not neccesarily return an error. * * Data sizes to test: * - 0 * - recv_immediate_max * - recv_immediate_max + 1 ...... ? */ parameters.send.data.iov_len = 0; parameters.send.dispatch = DISPATCH_ID_ENABLE; test_count++; if (task == 1) { send_active++; result = PAMI_Send (context, ¶meters); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: Unable to send to 0x%08x using dispatch %zu with %d.\n", parameters.send.dest, parameters.send.dispatch, result); return 1; } } parameters.send.data.iov_len = recv_immediate_max (context, DISPATCH_ID_DEFAULT_EXPECT_ASYNC); parameters.send.dispatch = DISPATCH_ID_ENABLE; test_count++; if (task == 1) { send_active++; result = PAMI_Send (context, ¶meters); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: Unable to send to 0x%08x using dispatch %zu with %d.\n", parameters.send.dest, parameters.send.dispatch, result); return 1; } } #if 0 parameters.send.data.iov_len = recv_immediate_max (context, DISPATCH_ID_DEFAULT_EXPECT_ASYNC) + 1; parameters.send.dispatch = DISPATCH_ID_ENABLE; test_count++; if (task == 1) { send_active++; result = PAMI_Send (context, ¶meters); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: Unable to send to 0x%08x using dispatch %d with %d.\n", parameters.send.dest, parameters.send.dispatch, result); return 1; } } #endif /* =================================================================== * 'recv_immediate' disabled * * All receives are NOT 'immediate' - even "zero byte data" * * Data sizes to test: * - 0 * - recv_immediate_max * - recv_immediate_max + 1 */ parameters.send.data.iov_len = 0; parameters.send.dispatch = DISPATCH_ID_DISABLE; test_count++; if (task == 1) { send_active++; result = PAMI_Send (context, ¶meters); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: Unable to send to 0x%08x using dispatch %zu with %d.\n", parameters.send.dest, parameters.send.dispatch, result); return 1; } } parameters.send.data.iov_len = recv_immediate_max (context, DISPATCH_ID_DEFAULT_EXPECT_ASYNC); parameters.send.dispatch = DISPATCH_ID_DISABLE; test_count++; if (task == 1) { send_active++; result = PAMI_Send (context, ¶meters); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: Unable to send to 0x%08x using dispatch %zu with %d.\n", parameters.send.dest, parameters.send.dispatch, result); return 1; } } parameters.send.data.iov_len = recv_immediate_max (context, DISPATCH_ID_DEFAULT_EXPECT_ASYNC) + 1; parameters.send.dispatch = DISPATCH_ID_DISABLE; test_count++; if (task == 1) { send_active++; result = PAMI_Send (context, ¶meters); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error: Unable to send to 0x%08x using dispatch %zu with %d.\n", parameters.send.dest, parameters.send.dispatch, result); return 1; } } /* ====== WAIT FOR COMMUNICATION COMPLETION ====== */ if (task == 0) { while (__test_recvs < test_count) PAMI_Context_advance (context, 1000); } else if (task == 1) { while (send_active) PAMI_Context_advance (context, 1000); } /* ====== CLEANUP ====== */ result = PAMI_Context_destroyv (&context, 1); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error. Unable to destroy context, result = %d\n", result); return 1; } result = PAMI_Client_destroy (&client); if (result != PAMI_SUCCESS) { fprintf (stderr, "Error. Unable to destroy pami client. result = %d\n", result); return 1; } /* ====== REPORT ERRORS ====== */ if (__test_errors > 0) { fprintf (stderr, "Error. Non-compliant PAMI receive immediate implementation! error count = %zu\n", __test_errors); return 1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { if (parse_args (argc, argv) == -1) return -1; server_orb.set ("server_orb"); client_orb.set ("client_orb"); try { PortableInterceptor::ORBInitializer_ptr temp_initializer; ACE_NEW_RETURN (temp_initializer, Collocated_ORBInitializer, -1); // No exceptions yet! PortableInterceptor::ORBInitializer_var initializer = temp_initializer; PortableInterceptor::register_orb_initializer (initializer.in ()); CORBA::ORB_var sorb = CORBA::ORB_init (argc, argv, server_orb.c_str ()); ACE_Manual_Event me; Server_Task server_task (output, sorb.in (), me, ACE_Thread_Manager::instance ()); if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } // Wait for the server thread to do some processing me.wait (); CORBA::ORB_var corb = CORBA::ORB_init (argc, argv, client_orb.c_str ()); Client_Task client_task (input, corb.in (), ACE_Thread_Manager::instance ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); } catch (const CORBA::Exception&) { // Ignore exceptions.. } 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 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 (); // Policies for the childPOA to be created. CORBA::PolicyList policies (1); policies.length (1); CORBA::Any pol; pol <<= BiDirPolicy::BOTH; policies[0] = orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, pol); // Create POA as child of RootPOA with the above policies. This POA // will receive request in the same connection in which it sent // the request PortableServer::POA_var child_poa = root_poa->create_POA ("childPOA", poa_manager.in (), policies); // Creation of childPOA is over. Destroy the Policy objects. for (CORBA::ULong i = 0; i < policies.length (); ++i) { policies[i]->destroy (); } poa_manager->activate (); CORBA::Object_var object = orb->string_to_object (ior); Sender_var sender = Sender::_narrow (object.in ()); if (CORBA::is_nil (sender.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil.\n", ior), 1); } Receiver_i *receiver; ACE_NEW_RETURN (receiver, Receiver_i (), -1); PortableServer::ServantBase_var owner_transfer (receiver); PortableServer::ObjectId_var id = root_poa->activate_object (receiver); CORBA::Object_var object_act = root_poa->id_to_reference (id.in ()); Receiver_var receiver_obj = Receiver::_narrow (object_act.in ()); // Send the calback object to the server sender->receiver_object (receiver_obj.in ()); // Threads that will handle the call backs Client_Task client_task (orb.in (), ACE_Thread_Manager::instance ()); if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 4, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); CORBA::Long count = receiver->get_event_count (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) Number of events received.. [%d]\n", count)); root_poa->destroy (1, 1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); return 1; } return 0; }
int ClientApp::run (int argc, ACE_TCHAR* argv[]) { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Parse the command-line args for this application. // * Raises -1 if problems are encountered. // * Returns 1 if the usage statement was explicitly requested. // * Returns 0 otherwise. int result = this->parse_args (argc, argv); if (result != 0) { return result; } CORBA::Object_var obj = orb->string_to_object(this->ior_.c_str()); if (CORBA::is_nil(obj.in())) { ACE_ERROR((LM_ERROR, "(%P|%t) Failed to convert IOR string to obj ref.\n")); throw TestException(); } Foo_var foo = Foo::_narrow(obj.in()); if (CORBA::is_nil(foo.in())) { ACE_ERROR((LM_ERROR, "(%P|%t) Failed to narrow obj ref to Foo interface.\n")); throw TestException(); } // Create the callback object using the child poa with the custom // strategy. obj = orb->resolve_initial_references("RootPOA"); if (CORBA::is_nil(obj.in())) { ACE_ERROR((LM_ERROR, "(%P|%t) Failed to resolve initial ref for 'RootPOA'.\n")); throw TestException(); } PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in()); if (CORBA::is_nil(root_poa.in())) { ACE_ERROR((LM_ERROR, "(%P|%t) Failed to narrow obj ref to POA interface.\n")); throw TestException(); } PortableServer::POAManager_var poa_manager = root_poa->the_POAManager(); // Create the child POA. CORBA::PolicyList policies(0); policies.length(0); PortableServer::POA_var child_poa = root_poa->create_POA("ChildPoa", poa_manager.in(), policies); if (CORBA::is_nil(child_poa.in())) { ACE_ERROR((LM_ERROR, "(%P|%t) ERROR [ServerApp::run()]: " "Failed to create the child POA.\n")); throw TestException(); } // Create the thread pool servant dispatching strategy object, and // hold it in a (local) smart pointer variable. TAO_Intrusive_Ref_Count_Handle<TAO::CSD::TP_Strategy> csd_tp_strategy = new TAO::CSD::TP_Strategy(); csd_tp_strategy->set_num_threads(1); // Tell the strategy to apply itself to the child poa. if (csd_tp_strategy->apply_to(child_poa.in()) == false) { ACE_ERROR((LM_ERROR, "(%P|%t) ERROR [ServerApp::run()]: " "Failed to apply custom dispatching strategy to child poa.\n")); throw TestException(); } // Create the servant object. Callback_i* servant = new Callback_i (); // local smart pointer variable to deal with releasing the reference // to the servant object when the smart pointer object falls out of scope. PortableServer::ServantBase_var owner_transfer(servant); // Activate the servant using the Child POA. PortableServer::ObjectId_var oid = child_poa->activate_object(servant); // Obtain the object reference. obj = child_poa->servant_to_reference(servant); if (CORBA::is_nil(obj.in())) { ACE_ERROR((LM_ERROR, "(%P|%t) Failed to activate servant (Callback_i).\n")); throw TestException(); } Callback_var callback = Callback::_narrow (obj.in ()); ClientTask client_task(orb.in (), foo.in (), callback.in ()); if (client_task.open () != 0) { throw TestException(); } // Activate the POA Manager poa_manager->activate(); ACE_DEBUG((LM_DEBUG, "(%P|%t) ClientApp is ready.\n")); orb->run(); client_task.wait (); ACE_DEBUG((LM_DEBUG, "(%P|%t) ClientApp is destroying the Root POA.\n")); // Tear-down the root poa and orb. root_poa->destroy(1, 1); ACE_DEBUG((LM_DEBUG, "(%P|%t) ClientApp is destroying the ORB.\n")); orb->destroy(); ACE_DEBUG((LM_DEBUG, "(%P|%t) ClientApp has completed running successfully.\n")); return 0; }