int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { #if TAO_HAS_INTERCEPTORS == 1 PortableInterceptor::ORBInitializer_ptr orb_initializer = PortableInterceptor::ORBInitializer::_nil (); ACE_NEW_RETURN (orb_initializer, Server_IORInterceptor_ORBInitializer, -1); // No CORBA exceptions yet! PortableInterceptor::ORBInitializer_var orb_initializer_var = orb_initializer; PortableInterceptor::register_orb_initializer (orb_initializer_var.in ()); #endif /* TAO_HAS_INTERCEPTORS == 1 */ // The usual initialization stuff // Initialize the ORB. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "server_sum_orb"); if (parse_args (argc, argv) != 0) return -1; // Resolve reference to RootPOA CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA"); // Narrow it down correctly. PortableServer::POA_var root_poa = PortableServer::POA::_narrow (obj.in ()); // Check for nil references if (CORBA::is_nil (root_poa.in ())) ACE_ERROR_RETURN ((LM_ERROR, "Unable to obtain RootPOA reference.\n"), -1); // Get poa_manager reference PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); // Activate it. poa_manager->activate (); // initialize the sum_server sum_server_i sum_server_impl; // Activate obj = sum_server_impl._this (); // Narrow it down. ORT::sum_server_var sum_server = ORT::sum_server::_narrow (obj.in ()); // Check for nil reference if (CORBA::is_nil (sum_server.in ())) ACE_ERROR_RETURN ((LM_ERROR, "Unable to obtain reference to ORT::sum_server " "object.\n"), -1); // Convert the object reference to a string format. CORBA::String_var ior = orb->object_to_string (sum_server.in ()); // If the ior_output_file exists, output the IOR to it. if (ior_output_file != 0) { FILE *output_file = ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing " "IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); } orb->run (); ACE_DEBUG ((LM_INFO, "Successful.\n")); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("ORT example server:"); return -1; } return 0; }
int main(int argc, char *argv[]) { if (argc<4){ ACE_OS::printf ("usage: testClient <server_name> <depth> <isError> [iteration]\n"); return -1; }//if // create logging proxy LoggingProxy m_logger (0, 0, 31, 0); LoggingProxy::init (&m_logger); CORBA::ORB_var orb; ACS_TEST_INIT_CORBA; // init ACS error system ACSError::init (orb.ptr()); /**************************************/ acserrOldTest_var test; int depth; sscanf (argv[2], "%d", &depth); bool isErr = *argv[3]-'0'; int iteration=1, i=1; const int size = 20; // max value 1.84 x 10^19 char printBuf[size+1]; if (argc>4) sscanf (argv[4], "%d", &iteration); ACS_DEBUG("main", "****** Test Block *****"); try { ACS_DEBUG("acserrOldTestClient", "Getting object reference ... "); char fileName[64]; sprintf(fileName, "file://%s.ior", argv[1]); CORBA::Object_var testObj = orb->string_to_object (fileName); ACS_DEBUG("acserrOldTestClient", "Narrowing it .... "); test = acserrOldTest::_narrow (testObj.in()); unsigned long long numToPrint; while( iteration >= i ){ ACS_SHORT_LOG((LM_INFO, "Performing test1 (remote call)... (%d/%d)", i, iteration)); ACSErr::ErrorTrace *c = test->test (depth, isErr); ACSError error(c, true); ACS_SHORT_LOG((LM_INFO, "Stack depth: %d", error.getDepth())); error.log(); //ACSError *error = new ACSError (c, true) -> new ACS_ERROR (c, true); while (c!=NULL){ ACS_SHORT_LOG((LM_INFO, "FileName: \"%s\"",error.getFileName())); ACS_SHORT_LOG((LM_INFO, "LineNumber: \"%d\"",error.getLineNumber())); ACS_SHORT_LOG((LM_INFO, "Routine: \"%s\"",error.getRoutine())); ACS_SHORT_LOG((LM_INFO, "HostName: \"%s\"",error.getHostName())); ACS_SHORT_LOG((LM_INFO, "Process: \"%s\"",error.getProcess())); ACS_SHORT_LOG((LM_INFO, "Thread: \"%s\"",error.getThread())); for (int ii = 0; ii < size; ii++) printBuf[ii] = ' '; printBuf[size] = '\0'; numToPrint = error.getTimeStamp(); for (int ii = size - 1; ii >= 0; ii--) { printBuf[ii] = numToPrint % 10 + '0'; numToPrint /= 10; if (numToPrint == 0) break; } ACS_SHORT_LOG((LM_INFO, "TimeStamp: \"%s\"",printBuf)); ACS_SHORT_LOG((LM_INFO, "ErrorType: \"%d\"",error.getErrorType())); ACS_SHORT_LOG((LM_INFO, "ErrorCode: \"%d\"",error.getErrorCode())); ACS_SHORT_LOG((LM_INFO, "Severity: \"%d\"", error.getSeverity())); ACS_SHORT_LOG((LM_INFO, "Description: \"%s\"",error.getDescription())); c = error.getNext(); } i++; }//while } catch( CORBA::Exception &ex) { ACE_PRINT_EXCEPTION (ex, "EXCEPTION CAUGHT"); return -1; } ACS_SHORT_LOG((LM_INFO, "Test1 performed.")); //test2 i=1; while (i<=iteration){ try { ACS_SHORT_LOG((LM_INFO, "Performing test2 (remote call - exceptions) ... (%d/%d)", i, iteration)); test->testExceptions (depth, isErr); } catch (ACSErr::ACSException &ex) { ACS_SHORT_LOG((LM_INFO, "Catch ACSException !")); ACSError exception (ex); // put CORBA exception (ACSException) into ACSError wrapper exception.log(); } catch( CORBA::Exception &_ex) { ACE_PRINT_EXCEPTION (_ex, "EXCEPTION CAUGHT"); return -1; } i++; }//while ACS_SHORT_LOG((LM_INFO, "Test2 performed.")); // test3 (no error) i=1; while (i<=iteration){ try { ACS_SHORT_LOG((LM_INFO, "Performing test3 (no error) ... (%d/%d)", i, iteration)); test->testNoError (); } catch( CORBA::Exception &_ex) { ACE_PRINT_EXCEPTION (_ex, "EXCEPTION CAUGHT"); return -1; } i++; }//while ACS_SHORT_LOG((LM_INFO, "Test3 performed.")); test->shutdown(); ACE_OS::sleep(5); LoggingProxy::done(); return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { MessageLog logger(HELLO_CALL_NUMBER); try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); PortableGroup::GOA_var root_poa = PortableGroup::GOA::_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 (); // servant Hello_Impl* hello_impl; ACE_NEW_RETURN (hello_impl, Hello_Impl (orb.in (), &logger), 1); PortableServer::ServantBase_var owner_transfer (hello_impl); if (parse_args (argc, argv) != 0) return 2; // create UIPMC reference CORBA::String_var multicast_url = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(uipmc_url)); CORBA::Object_var miop_ref = orb->string_to_object (multicast_url.in ()); // create id PortableServer::ObjectId_var id = root_poa->create_id_for_reference (miop_ref.in ()); // activate Hello Object root_poa->activate_object_with_id (id.in (), hello_impl); CORBA::String_var ior = orb->object_to_string (miop_ref.in ()); ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) { FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); } ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); } poa_manager->activate (); orb->run (); root_poa->destroy (1, 1); orb->destroy (); if (logger.report_statistics () == 0) ACE_ERROR_RETURN ((LM_ERROR, "\n (%P|%t) ERROR: No single call got through to the server\n"), 3); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in server main ():"); return 4; } ACE_DEBUG ((LM_DEBUG, "\n (%P|%t) server finished successfully..\n")); return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int status = 0; 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); // To use the smart proxy it is necessary to allocate the // user-defined smart factory on the heap as the smart proxy // generated classes take care of destroying the object. This // way it a win situation for the application developer who // doesnt have to make sure to destoy it and also for the smart // proxy designer who now can manage the lifetime of the object // much surely. Smart_Test_Factory *test_factory = 0; ACE_NEW_RETURN (test_factory, Smart_Test_Factory, -1); ACE_UNUSED_ARG (test_factory); Test_var server = Test::_narrow (object.in ()); if (CORBA::is_nil (server.in ())) ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil.\n", ior), 1); try { CORBA::String_var sm_ior = orb->object_to_string (server.in ()); if (Smart_Test_Proxy::fake_ior () != sm_ior.in ()) { status = 1; ACE_ERROR ((LM_ERROR, "ERROR: The Smart Proxy IOR is:\n%C\n" "but should have been: %C\n", sm_ior.in (), Smart_Test_Proxy::fake_ior ().c_str ())); } } catch (const CORBA::MARSHAL& ex) { status = 1; ex._tao_print_exception ("Unexpected MARSHAL exception:"); } server->method (0); server->shutdown (); // The following sleep is a hack to make sure the above oneway // request gets sent before we exit. Otherwise, at least on // Windows XP, the server may not even get the request. ACE_Time_Value tv (0, 100000); ACE_OS::sleep(tv); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Client-side exception:"); status = 1; } return status; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { // Initialize the ORB CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Get initial reference to the Root POA CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); // Narrow down to the appropriate type 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); // Get referencee to the POA manager PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); // Parse the arguments if (parse_args (argc, argv) != 0) return 1; ACE_DEBUG(( LM_DEBUG, "ior file = %s\t#threads = %d\t" "msglen = %d\n", ior_output_file, nthreads, msglen)); // Create the factory servant Object_Factory_i *factory_impl = 0; ACE_NEW_THROW_EX (factory_impl, Object_Factory_i (orb.in (), msglen), CORBA::NO_MEMORY ()); PortableServer::ServantBase_var safe (factory_impl); // _this method registers the object withe the POA and returns // an object reference PortableServer::ObjectId_var id = root_poa->activate_object (factory_impl); CORBA::Object_var object_act = root_poa->id_to_reference (id.in ()); Two_Objects_Test::Object_Factory_var factory = Two_Objects_Test::Object_Factory::_narrow (object_act.in ()); // Convert the object reference to a string so that it can // be saved in a file and used by clinet programs later CORBA::String_var ior = orb->object_to_string (factory.in ()); // If the ior_output_file exists, output the ior to it FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); // Activate the POA manager poa_manager->activate (); // Instantiate the specified # of worker threads Worker worker (orb.in ()); if (worker.activate (THR_NEW_LWP | THR_JOINABLE, nthreads) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate server threads\n"), 1); // Wait for all threads to get done worker.thr_mgr ()->wait (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) event loop finished\n")); root_poa->destroy (1, 1); 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 { // ORB. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Parse arguments. if (parse_args (argc, argv) != 0) return -1; // Make sure we can support multiple priorities that are required // for this test. if (!check_supported_priorities (orb.in ())) return 2; // Thread Manager for managing task. ACE_Thread_Manager thread_manager; // Create task. Task task (thread_manager, orb.in ()); // Task activation flags. long flags = THR_NEW_LWP | THR_JOINABLE | orb->orb_core ()->orb_params ()->thread_creation_flags (); // Activate task. int result = task.activate (flags); if (result == -1) { if (errno == EPERM) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot create thread with scheduling policy %s\n" "because the user does not have the appropriate privileges, terminating program....\n" "Check svc.conf options and/or run as root\n", sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())), 2); } else // Unexpected error. ACE_ASSERT (0); } // Wait for task to exit. result = thread_manager.wait (); ACE_ASSERT (result != -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 c_breath = 4; int c_depth = 4; int o_breath = 4; ACE_TCHAR *ns1ref = 0; ACE_TCHAR *ns2ref = 0; ACE_Get_Opt get_opts (argc, argv, ACE_TEXT ("b:d:o:p:q:")); int c; int i; while ((c = get_opts ()) != -1) switch (c) { case 'b': i = ACE_OS::atoi(get_opts.opt_arg ()); if (i<2) { ACE_ERROR((LM_ERROR, ACE_TEXT ("Invalid breath, must be 2 or more\n"))); ACE_OS::exit(1); } c_breath = i; break; case 'd': i = ACE_OS::atoi(get_opts.opt_arg ()); if (i<2) { ACE_ERROR((LM_ERROR, ACE_TEXT ("Invalid depth, must be 2 or more\n"))); ACE_OS::exit(1); } c_depth = i; break; case 'o': i = ACE_OS::atoi(get_opts.opt_arg ()); if (i<2) { ACE_ERROR((LM_ERROR, ACE_TEXT ("Invalid breath, must be 2 or more\n"))); ACE_OS::exit(1); } o_breath = i; break; case 'p': ns1ref = get_opts.opt_arg (); break; case 'q': ns2ref = get_opts.opt_arg (); break; default: ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Argument %c \n usage: %s") ACE_TEXT (" [-b <breath of context tree>]") ACE_TEXT (" [-d <depth of context tree>]") ACE_TEXT (" [-o <breath of object tree>]") ACE_TEXT (" -p <ior of first name server>") ACE_TEXT (" -q <ior of second name server>") ACE_TEXT ("\n")), -1); } CosNaming::NamingContext_var root_context_1; CosNaming::NamingContext_var root_context_2; try { // Initialize orb CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); // ior's are specified for the name servers through a commandline // option or a file. // Resolve the first name server CORBA::Object_var ns1obj = orb->string_to_object ( ACE_TEXT_ALWAYS_CHAR (ns1ref)); if (CORBA::is_nil (ns1obj.in ())) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("invalid ior <%s>\n"), ns1ref), -1); root_context_1 = CosNaming::NamingContext::_narrow (ns1obj.in ()); // Resolve the second name server CORBA::Object_var ns2obj = orb->string_to_object ( ACE_TEXT_ALWAYS_CHAR (ns2ref)); if (CORBA::is_nil (ns2obj.in ())) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("invalid ior <%s>\n"), ns2ref), -1); root_context_2 = CosNaming::NamingContext::_narrow (ns2obj.in ()); } catch (const CORBA::Exception& ex) { ex._tao_print_exception (ACE_TEXT ("Unable to resolve name servers")); return -1; } // Create a bunch of objects in one context // Note: strings to the naming service must be char, not wchar try { // Bind one context level under root. CosNaming::Name level1; level1.length (1); level1[0].id = CORBA::string_dup ("level1_context"); CosNaming::NamingContext_var level1_context; level1_context = root_context_1->bind_new_context (level1); for (i=0; i<o_breath; i++) { // Instantiate a dummy object and bind it under the new context. My_Test_Object *impl1 = new My_Test_Object (i+1); Test_Object_var obj1 = impl1->_this (); impl1->_remove_ref (); level1.length (2); char wide_name[16]; ACE_OS::sprintf(wide_name, "obj_%d", i); level1[1].id = CORBA::string_dup (wide_name); root_context_1->bind (level1, obj1.in ()); } } catch (const CORBA::Exception& ex) { ex._tao_print_exception (ACE_TEXT ("Unable to create a lot of objects")); return -1; } // Create a deep context tree try { CosNaming::NamingContext_var next_context = root_context_1; for (i=0; i<c_depth; i++) { // Bind level1 context under root. CosNaming::Name deep; deep.length (1); char deep_name[16]; ACE_OS::sprintf(deep_name, "deep_%d", i); deep[0].id = CORBA::string_dup (deep_name); CosNaming::NamingContext_var deep_context; deep_context = next_context->bind_new_context (deep); next_context = deep_context; } } catch (const CORBA::Exception& ex) { ex._tao_print_exception (ACE_TEXT ("Unable to create deep context")); return -1; } // Create a wide context tree try { for (i=0; i<c_breath; i++) { // Bind all level of context under root. CosNaming::Name wide; wide.length (1); char wide_name[16]; ACE_OS::sprintf(wide_name, "wide_%d", i); wide[0].id = CORBA::string_dup (wide_name); CosNaming::NamingContext_var wide_context; wide_context = root_context_1->bind_new_context (wide); } } catch (const CORBA::Exception& ex) { ex._tao_print_exception (ACE_TEXT ("Unable to create wide context")); return -1; } // Delete three selected things, one from each tree try { // Remove the second to last object from the Naming Context CosNaming::Name wide1; wide1.length (2); wide1[0].id = CORBA::string_dup ("level1_context"); char wide_name[16]; ACE_OS::sprintf(wide_name, "obj_%d", o_breath-2); wide1[1].id = CORBA::string_dup (wide_name); root_context_1->unbind (wide1); // Remove the second to last context from the wide root Naming Context CosNaming::Name wide2; wide2.length (1); ACE_OS::sprintf(wide_name, "wide_%d", c_breath-2); wide2[0].id = CORBA::string_dup (wide_name); CORBA::Object_var result_obj_ref = root_context_1->resolve (wide2); CosNaming::NamingContext_var result_object = CosNaming::NamingContext::_narrow (result_obj_ref.in ()); if (CORBA::is_nil (result_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Problems with resolving wide context ") ACE_TEXT ("- nil object ref.\n")), -1); result_object->destroy(); root_context_1->unbind (wide2); // Remove the last context from the deep Naming Context CosNaming::Name deep; deep.length (c_depth); char deep_name[16]; for (i=0; i<c_depth; i++) { ACE_OS::sprintf(deep_name, "deep_%d", i); deep[i].id = CORBA::string_dup (deep_name); } result_obj_ref = root_context_1->resolve (deep); result_object = CosNaming::NamingContext::_narrow (result_obj_ref.in ()); if (CORBA::is_nil (result_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Problems with resolving deep context ") ACE_TEXT ("- nil object ref.\n")), -1); result_object->destroy(); root_context_1->unbind (deep); } catch (const CORBA::Exception& ex) { ex._tao_print_exception (ACE_TEXT ("Unable to delete objects")); return -1; } // Now use the other name server to access 3 objects next to the // deleted objects and the 3 deleted objects try { // Access the last object from the Naming Context CosNaming::Name wide; wide.length (2); wide[0].id = CORBA::string_dup ("level1_context"); char wide_name[16]; ACE_OS::sprintf(wide_name, "obj_%d", o_breath-1); wide[1].id = CORBA::string_dup (wide_name); CORBA::Object_var result_obj_ref = root_context_2->resolve (wide); Test_Object_var result_object = Test_Object::_narrow (result_obj_ref.in ()); if (CORBA::is_nil (result_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Problems with resolving object from ") ACE_TEXT ("redundant server - nil object ref.\n")), -1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( ACE_TEXT ( "Unable to resolve object from redundant server")); return -1; } try { // Access the deleted second to last object from the Naming Context CosNaming::Name wide; wide.length (2); wide[0].id = CORBA::string_dup ("level1_context"); char wide_name[16]; ACE_OS::sprintf(wide_name, "obj_%d", o_breath-2); wide[1].id = CORBA::string_dup (wide_name); CORBA::Object_var result_obj_ref = root_context_2->resolve (wide); ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Problems with resolving object from ") ACE_TEXT ("redundant server - deleted object found.\n")), -1); } catch (const CORBA::Exception&) { //expect exception since the context was deleted } try { // Access the last context from the wide Naming Context CosNaming::Name wide; wide.length (1); char wide_name[16]; ACE_OS::sprintf(wide_name, "wide_%d", c_breath-1); wide[0].id = CORBA::string_dup (wide_name); CORBA::Object_var result_obj_ref = root_context_2->resolve (wide); CosNaming::NamingContext_var result_object = CosNaming::NamingContext::_narrow (result_obj_ref.in ()); if (CORBA::is_nil (result_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Problems with resolving wide context from ") ACE_TEXT ("redundant server - nil object ref.\n")), -1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( ACE_TEXT ( "Unable to resolve wide context from redundant server")); return -1; } try { // Access the deleted second to last object from the Naming Context CosNaming::Name wide; wide.length (2); char wide_name[16]; ACE_OS::sprintf(wide_name, "wide_%d", c_breath-2); wide[0].id = CORBA::string_dup (wide_name); CORBA::Object_var result_obj_ref = root_context_2->resolve (wide); ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Problems with resolving wide context from ") ACE_TEXT ("redundant server - deleted object found.\n")), -1); } catch (const CORBA::Exception&) { //expect exception since the context was deleted } try { // Access the deleted last context from the deep Naming Context CosNaming::Name deep; deep.length (c_depth); char deep_name[16]; for (i=0; i<c_depth; i++) { ACE_OS::sprintf(deep_name, "deep_%d", i); deep[i].id = CORBA::string_dup (deep_name); } CORBA::Object_var result_obj_ref = root_context_1->resolve (deep); ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Problems with resolving deep context from ") ACE_TEXT ("redundant server - deleted object found.\n")), -1); } catch (const CORBA::Exception&) { //expect exception since the context was deleted } try { // Access the second to last object from the Naming Context CosNaming::Name deep; deep.length (c_depth-1); char deep_name[16]; for (i=0; i<c_depth-1; i++) { ACE_OS::sprintf(deep_name, "deep_%d", i); deep[i].id = CORBA::string_dup (deep_name); } CORBA::Object_var result_obj_ref = root_context_1->resolve (deep); CosNaming::NamingContext_var result_object = CosNaming::NamingContext::_narrow (result_obj_ref.in ()); if (CORBA::is_nil (result_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Problems with resolving deep context from ") ACE_TEXT ("redundant server - nil object ref.\n")), -1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( ACE_TEXT ( "Unable to resolve deep context from redundant server")); return -1; } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Redundancy test OK\n"))); // Test performance of binding a bunch of objects in one context try { // Bind one context level under root. CosNaming::Name level1; level1.length (1); level1[0].id = CORBA::string_dup ("perf_context"); CosNaming::NamingContext_var perf_context; perf_context = root_context_1->bind_new_context (level1); // Instantiate a dummy object and bind it under the new context. My_Test_Object *impl1 = new My_Test_Object (i+1); Test_Object_var obj1 = impl1->_this (); impl1->_remove_ref (); int test_runs = 100; ACE_High_Res_Timer::global_scale_factor_type gsf = ACE_High_Res_Timer::global_scale_factor (); ACE_hrtime_t start = ACE_OS::gethrtime (); // Test how long it takes to bind for (i=0; i<test_runs; i++) { level1.length (1); char wide_name[16]; ACE_OS::sprintf(wide_name, "obj_%d", i); level1[0].id = CORBA::string_dup (wide_name); perf_context->bind (level1, obj1.in ()); } ACE_hrtime_t elapsed_time = ACE_OS::gethrtime () - start; // convert to microseconds ACE_UINT32 usecs = ACE_UINT32(elapsed_time / gsf); double secs = usecs / 1000000.0; ACE_DEBUG ((LM_DEBUG, "Bound %i objects in %.2f secs\n", test_runs, secs)); // Test how long it takes to resolve start = ACE_OS::gethrtime (); for (i=0; i<test_runs; i++) { level1.length (1); char wide_name[16]; ACE_OS::sprintf(wide_name, "obj_%d", i); level1[0].id = CORBA::string_dup (wide_name); CORBA::Object_var result_obj_ref = perf_context->resolve (level1); } elapsed_time = ACE_OS::gethrtime () - start; // convert to microseconds usecs = ACE_UINT32(elapsed_time / gsf); secs = ((ACE_INT32) usecs) / 1000000.0; ACE_DEBUG ((LM_DEBUG, "Resolved %i objects in %.2f secs\n", test_runs, secs)); // Test how long it takes to unbind start = ACE_OS::gethrtime (); for (i=0; i<test_runs; i++) { level1.length (1); char wide_name[16]; ACE_OS::sprintf(wide_name, "obj_%d", i); level1[0].id = CORBA::string_dup (wide_name); perf_context->unbind (level1); } elapsed_time = ACE_OS::gethrtime () - start; // convert to microseconds usecs = ACE_UINT32(elapsed_time / gsf); secs = ((ACE_INT32) usecs) / 1000000.0; ACE_DEBUG ((LM_DEBUG, "Unbound %i objects in %.2f secs\n", test_runs, secs)); } catch (const CORBA::Exception& ex) { ex._tao_print_exception (ACE_TEXT ("ERROR: Exception during performance test.\n")); return -1; } // All tests have passed up to this point return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int priority = (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, priority, ACE_SCOPE_PROCESS)) != 0) { if (ACE_OS::last_error () == EPERM) { ACE_DEBUG ((LM_DEBUG, "client (%P|%t): user is not superuser, " "test runs in time-shared class\n")); } else ACE_ERROR ((LM_ERROR, "client (%P|%t): sched_params failed\n")); } 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); Test::Roundtrip_var roundtrip = Test::Roundtrip::_narrow (object.in ()); if (CORBA::is_nil (roundtrip.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Nil Test::Roundtrip reference <%s>\n", ior), 1); } for (int j = 0; j < 100; ++j) { ACE_hrtime_t start = 0; (void) roundtrip->test_method (start, number); } ACE_Sample_History history (niterations); // const float usecs = 1.0 / rate * 1e6; // ACE_Time_Value tv (0, static_cast<const long> (usecs)); // const timespec ts = tv; ACE_hrtime_t test_start = ACE_OS::gethrtime (); for (int i = 0; i < niterations; ++i) { ACE_hrtime_t start = ACE_OS::gethrtime (); /* if (rate) { //(void) ACE_OS::nanosleep (&ts, 0); //prime_number = ACE::is_prime (699999, 2, 349999); } */ (void) roundtrip->test_method (start, number); ACE_hrtime_t now = ACE_OS::gethrtime (); history.sample (now - start); } ACE_hrtime_t test_end = ACE_OS::gethrtime (); ACE_DEBUG ((LM_DEBUG, "test finished\n")); ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration....")); ACE_High_Res_Timer::global_scale_factor_type gsf = ACE_High_Res_Timer::global_scale_factor (); ACE_DEBUG ((LM_DEBUG, "done\n")); if (do_dump_history) { history.dump_samples (ACE_TEXT("HISTORY"), gsf); } ACE_Basic_Stats stats; history.collect_basic_stats (stats); stats.dump_results (ACE_TEXT("Total"), gsf); ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf, test_end - test_start, stats.samples_count ()); if (do_shutdown) { roundtrip->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); CORBA::Object_var obj = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in()); PortableServer::POAManager_var mgr = root_poa->the_POAManager(); const char* poa_name = "MessengerService"; PortableServer::POA_var messenger_poa = createPOA(root_poa.in(), poa_name); Terminator terminator; if (terminator.open (0) == -1) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT ("main Error opening terminator\n")),-1); PortableServer::Servant_var<Messenger_i> messenger_servant = new Messenger_i(orb.in(), terminator); PortableServer::ObjectId_var object_id = PortableServer::string_to_ObjectId("messenger_object"); // // Activate the servant with the messenger POA, // obtain its object reference, and get a // stringified IOR. // messenger_poa->activate_object_with_id(object_id.in(), messenger_servant.in()); // // Create binding between "MessengerService" and // the messenger object reference in the IOR Table. // Use a TAO extension to get the non imrified poa // to avoid forwarding requests back to the ImR. TAO_Root_POA* tpoa = dynamic_cast<TAO_Root_POA*>(messenger_poa.in()); obj = tpoa->id_to_reference_i(object_id.in(), false); CORBA::String_var messenger_ior = orb->object_to_string(obj.in()); obj = orb->resolve_initial_references("IORTable"); IORTable::Table_var table = IORTable::Table::_narrow(obj.in()); table->bind(poa_name, messenger_ior.in()); // // This server is now ready to run. // This version does not create an IOR // file as demonstrated in the // Developer's Guide. It assumes that // users create IORs for the client using // the tao_imr utility. // // // Stop discarding requests. // mgr->activate(); std::cout << "Messenger server ready." << std::endl; orb->run(); std::cout << "Messenger server shutting down." << std::endl; root_poa->destroy(1,1); orb->destroy(); ACE_Message_Block *mb; ACE_NEW_RETURN(mb, ACE_Message_Block(0, ACE_Message_Block::MB_HANGUP), -1); terminator.putq(mb); terminator.wait(); } catch(const CORBA::Exception& ex) { std::cerr << "Server main() Caught CORBA::Exception" << ex << std::endl; return 1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { gsf = ACE_High_Res_Timer::global_scale_factor (); try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); int parse_args_result = parse_args (argc, argv); if (parse_args_result != 0) return parse_args_result; CORBA::Object_var object = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); test_i *servant = new test_i (orb.in (), root_poa.in ()); PortableServer::ServantBase_var safe_servant (servant); test_var test = servant->_this (); CORBA::String_var ior = orb->object_to_string (test.in ()); FILE *output_file = ACE_OS::fopen (ior_file, "w"); ACE_ASSERT (output_file != 0); u_int result = ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_ASSERT (result == ACE_OS::strlen (ior.in ())); ACE_UNUSED_ARG (result); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run (); ACE_OS::sleep(1); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught"); return -1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { ORBInitializer *initializer = 0; ACE_NEW_RETURN (initializer, ORBInitializer, -1); // No exceptions yet! PortableInterceptor::ORBInitializer_var orb_initializer = initializer; PortableInterceptor::register_orb_initializer (orb_initializer.in ()); 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 (); if (parse_args (argc, argv) != 0) return 1; poa_manager->activate (); CORBA::Object_var lm_object = orb->resolve_initial_references ("LoadManager"); CosLoadBalancing::LoadManager_var load_manager = CosLoadBalancing::LoadManager::_narrow (lm_object.in ()); RPS_Monitor * monitor_servant; ACE_NEW_THROW_EX (monitor_servant, RPS_Monitor (initializer->interceptor ()), CORBA::NO_MEMORY ()); PortableServer::ServantBase_var safe_monitor_servant (monitor_servant); CosLoadBalancing::LoadMonitor_var load_monitor = monitor_servant->_this (); PortableGroup::Location_var location = load_monitor->the_location (); CORBA::Object_var stockfactory = ::join_object_group (orb.in (), load_manager.in (), location.in ()); TAO_LB_LoadAlert & alert_servant = initializer->load_alert (); CosLoadBalancing::LoadAlert_var load_alert = alert_servant._this (); CORBA::String_var ior = orb->object_to_string (stockfactory.in ()); // If the ior_output_file exists, output the ior to it FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); load_manager->register_load_monitor (location.in (), load_monitor.in ()); load_manager->register_load_alert (location.in (), load_alert.in ()); orb->run (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); root_poa->destroy (1, 1); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("lb_server exception"); return 1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { //init IFR objref try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); TAO_IFR_Client_Adapter *ifr_client = ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance ( TAO_ORB_Core::ifr_client_adapter_name ()); if (ifr_client == 0) { throw ::CORBA::INTF_REPOS (); } ACE_DEBUG ((LM_DEBUG, "Got IFR_Client ref.\n")); CORBA::InterfaceDef_var intDef = ifr_client->get_interface (orb.in (), "IDL:IFR_Test/test_if:1.0"); if (CORBA::is_nil (intDef.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "get interface returned nil ref\n"), 1); } CORBA::ContainedSeq_var attributes = intDef->contents (CORBA::dk_Attribute, 1); CORBA::ULong n_ats = attributes->length (); CORBA::ULong index = 0UL; CORBA::String_var name = attributes[index]->name (); ACE_DEBUG ((LM_DEBUG, "found %d attributes, name = %s\n", n_ats, name.in ())); CORBA::AttributeDef_var attr = CORBA::AttributeDef::_narrow (attributes[index]); if (CORBA::is_nil (attr.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "could not narrow attribute ref\n"), 1); } CORBA::TypeCode_var tc = attr->type (); ACE_DEBUG ((LM_DEBUG, "foo attr typecode = %s\n", tc->id ())); } catch (const ::CORBA::Exception &ex) { ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :"); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { { PortableInterceptor::ORBInitializer_var initializer( new Server_ORBInitializer); PortableInterceptor::register_orb_initializer(initializer.in()); } 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 (); if (parse_args (argc, argv) != 0) return 1; Echo *echo_impl; ACE_NEW_RETURN (echo_impl, Echo (orb.in ()), 1); PortableServer::ServantBase_var owner_transfer(echo_impl); PortableServer::ObjectId_var id = root_poa->activate_object (echo_impl); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); Test::Echo_var echo = Test::Echo::_narrow (object.in ()); CORBA::String_var ior = orb->object_to_string (echo.in ()); // Output the IOR to the <ior_output_file> FILE *output_file = ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); root_poa->destroy (1, 1); 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[]) { ACE_DEBUG ((LM_DEBUG, "Middle (%P|%t) started\n")); try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if ( ! parse_args (argc, argv)) { return -1; } /////////////////////////////// // Prepare to be a CORBA server CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); /////////////////////////////// // Prepare to be a CORBA client FILE *input_file = ACE_OS::fopen (ior_input_file, "r"); if (input_file == 0) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot open input IOR file: %s", ior_input_file), -1); } ACE_OS::fread (input_ior, 1, sizeof(input_ior), input_file); ACE_OS::fclose (input_file); // Convert the IOR to an object reference. CORBA::Object_var object = orb->string_to_object (input_ior); // narrow the object reference to a ThreeTier reference ThreeTier_var target = ThreeTier::_narrow (object.in ()); if (CORBA::is_nil (target.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "IOR does not refer to a ThreeTier implementation"), -1); } // We should have a good connection now // temporary: check it out //target->tick(); //target->tock(); Middle_i middle (orb.in(), target.in ()); if (middle.parse_args (argc, argv) ) { ///////////////////////////////// // Activate server side mechanism PortableServer::ObjectId_var id = root_poa->activate_object (&middle); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); ThreeTier_var server = ThreeTier::_narrow (object.in ()); CORBA::String_var ior = orb->object_to_string (server.in ()); FILE *output_file = ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), -1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run (); } } catch (const CORBA::UserException& userex) { userex._tao_print_exception ("Middle: User Exception in main"); return -1; } catch (const CORBA::SystemException& sysex) { sysex._tao_print_exception ("Middle: System Exception in main"); return -1; } ACE_DEBUG ((LM_DEBUG, "Middle (%P|%t) exits\n")); return 0; }
int acserrOldTestServer (char *szCmdLn){ ACE_OS_Object_Manager ace_os_object_manager; ACE_Object_Manager ace_object_manager; int argc; char *argv[100]; argc = argUnpack(szCmdLn, argv); argv[0] = "acserrOldTestServer"; #else int acserrOldTestServer (int argc, char *argv[]){ #endif // defined( MAKE_VXWORKS ) if (argc<2){ ACE_OS::printf ("usage: errorServer <server_name> [destination_server_name] \n"); return -1; } ACE_OS::signal(SIGINT, TerminationSignalHandler); // Ctrl+C ACE_OS::signal(SIGTERM, TerminationSignalHandler); // termination request // create logging proxy LoggingProxy m_logger (0, 0, 31, 0); LoggingProxy::init (&m_logger); // creating ORB ACS_TEST_INIT_CORBA; // init ACS error system (and inside also logging) ACSError::init (orb.ptr()); try { //Get a reference to the RootPOA CORBA::Object_var obj = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager(); #ifdef MAKE_VXWORKS ACSError::processName (szCmdLn); #else char *buf; ACE_OS::argv_to_string (argv, buf); ACSError::processName (buf); delete[] buf; #endif ACS_DEBUG ("errorServer", "Creating test object ..."); acserrOldTest_var dest; if (argc>2){ ACS_DEBUG ("errorServer", "Getting object reference ... "); char refName[64]; sprintf(refName, "file://%s.ior", argv[2]); CORBA::Object_var destObj = orb->string_to_object (refName); ACS_DEBUG ("errorServer", "Narrowing it .... "); dest = acserrOldTest::_narrow (destObj.in()); }//if acserrOldTestImpl esTest (dest.in(), argv[1]); acserrOldTest_var testObj = esTest._this (); poa_manager->activate (); ACS_DEBUG ("errorServer","POA Manager -> activate"); ACS_DEBUG_PARAM ("errorServer", "Writing ior to the file: %s .... ", argv[1]); char* ior = orb->object_to_string (testObj.in()); char fileName[64]; sprintf(fileName, "%s.ior", argv[1]); FILE *output_file = ACE_OS::fopen (fileName, "w"); if (output_file == 0) { ACS_SHORT_LOG((LM_ERROR, "Cannot open output files for writing IOR: ior.ior")); return -1; } int result = ACE_OS::fprintf (output_file, "%s", ior); if (result < 0) { ACS_SHORT_LOG ((LM_ERROR, "ACE_OS::fprintf failed while writing %s to ior.ior\n", ior)); return -1; } ACE_OS::fclose (output_file); ACS_DEBUG ("errorServer", "Waiting for requests ..."); orb->run (); } catch( CORBA::Exception &ex ) { ex._tao_print_exception("EXCEPTION CAUGHT"); return -1; } // orb->shutdown(true); //wait until all requests have completed LoggingProxy::done(); std::cout << std::flush; sleep(3); return 0; }//startErrorServer #ifndef MAKE_VXWORKS int main(int argc, char *argv[]) { return acserrOldTestServer (argc, argv); }
/** * starts the server for the component installer object */ int main (int argc, char** argv) { std::cout << "Qedo Component Installer " << QEDO_VERSION << std::endl; // // Resolve config values from config file // if (! strcmp (Qedo::ConfigurationReader::instance()->lookup_config_value ("/General/VerboseOutput"), "true")) { Qedo::debug_output = true; } for (int i = 1; i < argc; i++) { if (! strcmp (argv[i], "--verbose")) { Qedo::debug_output = true; } } // // get the qedo dir // Qedo::g_qedo_dir = Qedo::getEnvironment( "QEDO" ); if(Qedo::g_qedo_dir.empty()) { std::cout << "Missing Environment Variable QEDO" << std::endl; std::cout << "Assuming current dir as local deployment dir" << std::endl; Qedo::g_qedo_dir = Qedo::getCurrentDirectory(); } std::cout << "..... Qedo directory is " << Qedo::g_qedo_dir << std::endl; // // init ORB // orb = CORBA::ORB_init (argc, argv); Qedo::ComponentInstallationImpl* component_installation = new Qedo::ComponentInstallationImpl (orb); try { component_installation->initialize(); } catch (Qedo::ComponentInstallationImpl::CannotInitialize&) { std::cerr << "Cannot initialize Component Installer... exiting." << std::endl; orb->destroy(); exit (1); } #ifdef HAVE_SIGACTION struct sigaction act; /* Assign sig_chld as our SIGINT handler */ act.sa_handler = handle_sigint; /* We don't want to block any other signals in this example */ sigemptyset(&act.sa_mask); /* * Make these values effective. If we were writing a real * application, we would probably save the old value instead of * passing NULL. */ if (sigaction(SIGINT, &act, NULL) < 0) { std::cerr << "sigaction failed" << std::endl; return 1; } #else signal ( SIGINT, handle_sigint ); #endif std::cout << "Qedo Component Installer is up and running ...\n"; orb->run(); return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { Server_ORBInitializer2 *temp_initializer = 0; ACE_NEW_RETURN (temp_initializer, Server_ORBInitializer2, -1); // No exceptions yet! PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; PortableInterceptor::register_orb_initializer (orb_initializer.in ()); 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 (); CORBA::PolicyList policies (2); policies.length (2); policies[0] = root_poa->create_id_assignment_policy (PortableServer::USER_ID); policies[1] = root_poa->create_lifespan_policy (PortableServer::PERSISTENT); PortableServer::POA_var my_poa = root_poa->create_POA ("my_poa", poa_manager.in (), policies); // Creation of the new POA is over, so destroy the Policy_ptr's. for (CORBA::ULong i = 0; i < policies.length (); ++i) { CORBA::Policy_ptr policy = policies[i]; policy->destroy (); } if (parse_args (argc, argv) != 0) return -1; Hello *hello_impl = 0; ACE_NEW_RETURN (hello_impl, Hello (orb.in (), Test::Hello::_nil (), my_id_number), -1); PortableServer::ServantBase_var owner (hello_impl); PortableServer::ObjectId_var server_id = PortableServer::string_to_ObjectId ("server_id"); my_poa->activate_object_with_id (server_id.in (), hello_impl); CORBA::Object_var hello = my_poa->id_to_reference (server_id.in ()); CORBA::String_var ior = orb->object_to_string (hello.in ()); // Output the IOR to the <ior_output_file> FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s\n", ior_output_file), -1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run (); root_poa->destroy (1, 1); 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); 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 (); // Install a persistent POA in order to achieve a persistent IOR // for our object. CORBA::PolicyList policies; policies.length (2); policies[0] = root_poa->create_lifespan_policy(PortableServer::PERSISTENT); policies[1] = root_poa->create_id_assignment_policy (PortableServer::USER_ID); PortableServer::POA_var persistent_poa = root_poa->create_POA("persistent", poa_manager.in (), policies); policies[0]->destroy (); policies[1]->destroy (); if (parse_args (argc, argv) != 0) return 1; UDP_i udp_i (orb.in ()); PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("UDP_Object"); persistent_poa->activate_object_with_id (id.in (), &udp_i); CORBA::Object_var obj = persistent_poa->id_to_reference (id.in ()); UDP_var udp_var = UDP::_narrow (obj.in ()); // UDP_var udp_var = udp_i._this (); if (CORBA::is_nil (udp_var.in ())) ACE_DEBUG ((LM_DEBUG, "Failed to narrow correct object reference.\n")); CORBA::String_var ior = orb->object_to_string (udp_var.in ()); ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) { FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); } poa_manager->activate (); orb->run (); ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, // ethernalize objects 0); // wait for completion orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); return 1; } return 0; }
int ServerApp::run_i(int argc, ACE_TCHAR *argv[]) { // Initialize the ORB before parsing our own args. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Parse the command-line args for this application. // * Returns -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; } TheAppShutdown->init(orb.in(), num_clients_); // Get the Root POA PortableServer::POA_var root_poa = RefHelper<PortableServer::POA>::resolve_initial_ref(orb.in(), "RootPOA"); // Get the POAManager from the Root POA. PortableServer::POAManager_var poa_manager = root_poa->the_POAManager(); // Create the child POA Policies. CORBA::PolicyList policies(0); policies.length(0); // Create the child POA PortableServer::POA_var child_poa = AppHelper::create_poa("ChildPoa", root_poa.in(), poa_manager.in(), policies); // Create the servant object. Foo_A_i* servant = new Foo_A_i(); // Local smart pointer variable to deal with releasing the reference // to the servant object when the variable falls out of scope. PortableServer::ServantBase_var servant_owner(servant); // Obtain the object reference using the servant CORBA::Object_var obj = AppHelper::activate_servant(child_poa.in(), servant); // Stringify and save the object reference to a file AppHelper::ref_to_file(orb.in(), obj.in(), this->ior_filename_.c_str()); // Activate the POA Manager poa_manager->activate(); ACE_DEBUG((LM_DEBUG, "(%P|%t) ServerApp is ready. Running the ORB event loop.\n")); // Run the ORB event loop. orb->run (); ACE_DEBUG((LM_DEBUG, "(%P|%t) ServerApp ORB event loop has completed.\n")); TheAppShutdown->wait (); // Calling wait on ACE_Thread_Manager singleton to avoid the problem // that the main thread might exit before all CSD Threads exit. // Wait for all CSD task threads exit. ACE_Thread_Manager::instance ()->wait (); ACE_DEBUG((LM_DEBUG, "(%P|%t) ServerApp is destroying the Root POA.\n")); root_poa->destroy(1, 1); ACE_DEBUG((LM_DEBUG, "(%P|%t) ServerApp is destroying the ORB.\n")); orb->destroy(); ACE_DEBUG((LM_DEBUG, "(%P|%t) ServerApp has completed running successfully.\n")); return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { DANCE_DISABLE_TRACE (); int retval = 0; try { DAnCE::Logger_Service * dlf = ACE_Dynamic_Service<DAnCE::Logger_Service>::instance ("DAnCE_Logger"); if (dlf) { dlf->init (argc, argv); } DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - initializing ORB\n"))); CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - initializing module instance\n"))); TAO::Utils::ORB_Destroyer safe_orb (orb); CORBA::Object_var poa_obj = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (poa_obj.in ()); PortableServer::POAManager_var mgr = poa->the_POAManager (); PortableServer::POA_var persistent_poa; TAO::Utils::PolicyList_Destroyer policies (2); policies.length (2); try { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - ") ACE_TEXT("before creating the \"Managers\" POA.\n"))); policies[0] = poa->create_id_assignment_policy (PortableServer::USER_ID); policies[1] = poa->create_lifespan_policy (PortableServer::PERSISTENT); persistent_poa = poa->create_POA ("Managers", mgr.in(), policies); } catch (const PortableServer::POA::AdapterAlreadyExists &) { persistent_poa = poa->find_POA ("Managers", 0); } DAnCE::Plan_Launcher_Daemon_i *pl_daemon (0); ACE_NEW_RETURN (pl_daemon, DAnCE::Plan_Launcher_Daemon_i (orb.in ()), 0); PortableServer::ServantBase_var safe_servant (pl_daemon); PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId ("Plan_Launcher_Daemon"); persistent_poa->activate_object_with_id (oid, pl_daemon); CORBA::Object_var pl_obj = persistent_poa->id_to_reference (oid.in ()); CORBA::String_var pl_ior = orb->object_to_string (pl_obj.in ()); DAnCE::Utility::write_IOR (ACE_TEXT ("PL_Daemon.ior"), pl_ior.in ()); orb->run (); DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - destroying ORB\n"))); orb->destroy (); } catch (const CORBA::Exception& ex) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_EMERGENCY, DLINFO "PL_Daemon - Error - CORBA Exception :%C\n", ex._info ().c_str ())); retval = -1; } catch (...) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, "PL_Daemon - Error: Unknown exception.\n")); retval = -1; } return retval; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // We do the command line parsing first 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 (); CORBA::PolicyList policies; policies.length (3); policies[0] = root_poa->create_id_assignment_policy ( PortableServer::USER_ID); policies[1] = root_poa->create_implicit_activation_policy ( PortableServer::NO_IMPLICIT_ACTIVATION); policies[2] = root_poa->create_lifespan_policy ( PortableServer::PERSISTENT); PortableServer::POA_var poa = root_poa->create_POA ( "PERS_POA", poa_manager.in (), policies); for (CORBA::ULong i = 0; i < policies.length (); ++i) { policies[i]->destroy (); } // Instantiate the LCD_Display implementation class Simple_Server_i display_impl (orb.in (), ACE_TEXT_ALWAYS_CHAR(key)); PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("IOGR_OID"); poa->activate_object_with_id (id.in(), &display_impl); CORBA::Object_var server = poa->id_to_reference (id.in ()); CORBA::String_var ior = orb->object_to_string (server.in ()); ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) { FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); } poa_manager->activate (); orb->run (); } 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, "MY_TEST_ORB"); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (object.in ()); if (CORBA::is_nil (root_poa.in ())) { ACE_ERROR ((LM_ERROR, "rootPOA is nil!\n")); return -1; } PortableServer::POAManager_var poa_manager = root_poa->the_POAManager(); // Run ORB Event loop. poa_manager->activate (); // Create task. Task *task = 0; ACE_NEW_RETURN (task, Task (orb.in ()), 1); IORTable::Locator_var owner_transfer (task); // Resolve the IORTable and set the locator CORBA::Object_var iorTableObj = orb->resolve_initial_references("IORTable"); IORTable::Table_var local_ior_table = IORTable::Table::_narrow (iorTableObj.in ()); local_ior_table->set_locator (task); try { ACE_DEBUG ((LM_DEBUG, "OK, now try to resolve a co-located " "IORTable entry...\n")); CORBA::Object_var clientObj = orb->string_to_object (testIOR); simple::SimpleTest_T_var simpleTestClient = simple::SimpleTest_T::_narrow (clientObj.in ()); if (CORBA::is_nil (simpleTestClient.in ())) { ACE_ERROR ((LM_ERROR, "Simpe client is nil!\n")); return 1; } ACE_DEBUG ((LM_DEBUG, "We narrowed the object, now let's invoke it!\n")); simpleTestClient->shutdown (); } catch(const CORBA::OBJ_ADAPTER &objAdapter) { objAdapter._tao_print_exception ("CAUGHT OBJ_ADAPTER!!!"); } catch(const CORBA::OBJECT_NOT_EXIST &objNE) { objNE._tao_print_exception ("CAUGHT OBJECT NOT EXIST!!!"); } ACE_DEBUG ((LM_DEBUG, "Leaving!\n")); } catch (const CORBA::Exception &ex) { ex._tao_print_exception ("CAUGHT EXCEPTION: "); return -1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { MIF_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, MIF_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) { MIF_Scheduling::SchedulingParameter sched_param; sched_param.importance = 0; CORBA::Policy_var sched_param_policy = scheduler->create_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); 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 (); 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_WITH_TRANSPORT; 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; PortableServer::Servant_var<Echo> impl; { Echo * tmp; // ACE_NEW_RETURN is the worst possible way to handle // exceptions (think: what if the constructor allocates memory // and fails?), but I'm not in the mood to fight for a more // reasonable way to handle allocation errors in ACE. ACE_NEW_RETURN (tmp, Echo (orb.in (), 100), 1); impl = tmp; } PortableServer::ObjectId_var id = root_poa->activate_object (impl.in ()); CORBA::Object_var object_act = root_poa->id_to_reference (id.in ()); Test::Echo_var echo = Test::Echo::_narrow (object_act.in ()); CORBA::Object_var tmp = orb->string_to_object(ior); Test::Echo_Caller_var server = Test::Echo_Caller::_narrow(tmp.in ()); if (CORBA::is_nil (echo.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil Test::Echo_Caller reference <%s>\n", ior), 1); } poa_manager->activate (); Client_Task ctask (orb.in ()); server->start_task (echo.in()); if (ctask.activate (THR_NEW_LWP | THR_JOINABLE, 4, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); return 1; } ACE_Thread_Manager::instance ()->wait (); ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - event loop finished\n")); // Actually the code here should never be reached. root_poa->destroy (1, 1); 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[]) { CORBA::ORB_var orb; try { // Initialize orb orb = CORBA::ORB_init (argc, argv); // Get reference to Root POA. CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (obj.in ()); // Get POA manager PortableServer::POAManager_var poa_mgr = poa->the_POAManager (); // Create a policy list. We use persistent objects with // user-assigned IDs, and explicit activation. CORBA::PolicyList policy_list; policy_list.length (6); policy_list[0] = poa->create_lifespan_policy ( PortableServer::TRANSIENT // REVISIT ); policy_list[1] = poa->create_id_assignment_policy ( PortableServer::USER_ID ); policy_list[2] = poa->create_implicit_activation_policy ( PortableServer::NO_IMPLICIT_ACTIVATION ); policy_list[3] = poa->create_request_processing_policy ( PortableServer::USE_SERVANT_MANAGER ); policy_list[4] = poa->create_servant_retention_policy ( PortableServer::NON_RETAIN ); policy_list[5] = poa->create_thread_policy ( PortableServer::SINGLE_THREAD_MODEL ); // Create a POA for all CCS elements. PortableServer::POA_var ccs_poa = poa->create_POA ("CCS_POA", poa_mgr.in (), policy_list); // Create a controller and set static m_ctrl member // for thermostats and thermometers. Controller_impl ctrl_servant (ccs_poa.in (), "/tmp/CCS_assets"); Thermometer_impl::m_ctrl = &ctrl_servant; // Create a reference for the controller and // create the corresponding CORBA object. PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId (Controller_oid); CORBA::Object_var ctrl = ccs_poa->create_reference_with_id ( oid.in (), "IDL:acme.com/CCS/Controller:1.0" ); // Get reference to initial naming context. CosNaming::NamingContext_var inc = resolve_init<CosNaming::NamingContext> ( orb.in (), "NameService" ); // Attempt to create CCS context. CosNaming::Name n; n.length (1); n[0].id = CORBA::string_dup ("CCS"); try { CosNaming::NamingContext_var nc = inc->bind_new_context (n); } catch (const CosNaming::NamingContext::AlreadyBound &) { // Fine, CCS context already exists. } // Force binding of controller reference to make // sure it is always up-to-date. n.length (2); n[1].id = CORBA::string_dup ("Controller"); inc->rebind (n, ctrl.in ()); // Instantiate the servant locator for devices. PortableServer::ServantManager_var locator = new DeviceLocator_impl (&ctrl_servant); // Set servant locator. ccs_poa->set_servant_manager (locator.in ()); // Activate the POA manager. poa_mgr->activate (); // Accept requests orb->run (); } catch (const CORBA::Exception & e) { std::cerr << "Uncaught CORBA exception: " << e << std::endl; return 1; } catch (...) { assert (0); // Uncaught exception, dump core } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); int result = parse_args (argc, argv); if (result != 0) return result; if (shutdown_server) { CORBA::Object_var object = orb->string_to_object (ior); test_var test = test::_narrow (object.in ()); test->shutdown (); } else { // Thread Manager for managing task. ACE_Thread_Manager thread_manager; // Create task. Task task (thread_manager, orb.in ()); // Task activation flags. long flags = THR_NEW_LWP | THR_JOINABLE | orb->orb_core ()->orb_params ()->thread_creation_flags (); // Activate task. result = task.activate (flags); if (result == -1) { if (errno == EPERM) { ACE_ERROR_RETURN ((LM_ERROR, "Cannot create thread with scheduling policy %s\n" "because the user does not have the appropriate privileges, terminating program....\n" "Check svc.conf options and/or run as root\n", sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())), 2); } else // Unexpected error. ACE_ASSERT (0); } // Wait for task to exit. result = thread_manager.wait (); ACE_ASSERT (result != -1); if (decreased == false) { ACE_ERROR_RETURN ((LM_ERROR, "ERROR: Number of threads didn't decrease\n"), -1); } } } 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; A::AMI_Test_var server; CORBA::Object_var object = orb->string_to_object (ior); server = A::AMI_Test::_narrow (object.in ()); if (CORBA::is_nil (server.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil.\n", ior), 1); } // Activate POA to handle the call back. 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 (); // Let the client perform the test in a separate thread Handler handler; PortableServer::ObjectId_var id = root_poa->activate_object (&handler); CORBA::Object_var hnd_object = root_poa->id_to_reference (id.in ()); A::AMI_AMI_TestHandler_var the_handler_var = A::AMI_AMI_TestHandler::_narrow (hnd_object.in ()); handler.set_ami_test (server.in ()); Client client (server.in (), niterations, the_handler_var.in ()); if (client.activate (THR_NEW_LWP | THR_JOINABLE, nthreads) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate client threads\n"), 1); // Main thread collects replies. It needs to collect // <nthreads*niterations> replies. number_of_replies = nthreads *niterations; if (debug) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) : Entering perform_work loop to receive <%d> replies\n", number_of_replies.value ())); } // ORB loop. Worker worker (orb.in ()); if (worker.activate (THR_NEW_LWP | THR_JOINABLE, nthreads) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate client threads\n"), 1); worker.thr_mgr ()->wait (); if (debug) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) : Exited perform_work loop Received <%d> replies\n", (nthreads*niterations) - number_of_replies.value ())); } client.thr_mgr ()->wait (); ACE_DEBUG ((LM_DEBUG, "threads finished\n")); server->shutdown (); root_poa->destroy (1, // ethernalize objects 0 // wait for completion ); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); return 1; } return parameter_corruption; }
void TerminationSignalHandler(int) { ACE_OS::printf("Server goes down ... \n"); ACSError::done(); orb->shutdown (true); }
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 (); if (parse_args (argc, argv) != 0) return 1; Simple_Server_i server_impl (orb.in ()); PortableServer::ObjectId_var id = root_poa->activate_object (&server_impl); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); Simple_Server_var server = Simple_Server::_narrow (object.in ()); CORBA::String_var local_ior = orb->object_to_string (server.in ()); ACE_DEBUG ((LM_DEBUG, "Client interface started on <%C>\n", local_ior.in ())); CORBA::Object_var remote_object = orb->string_to_object (ior); Simple_Server_var remote_server = Simple_Server::_narrow (remote_object.in ()); if (CORBA::is_nil (remote_server.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil\n", ior), 1); } if (do_shutdown) { remote_server->shutdown (); } else { poa_manager->activate (); Worker worker (orb.in ()); if (worker.activate (THR_NEW_LWP | THR_JOINABLE, 1) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate client thread\n"), 1); ACE_DEBUG ((LM_DEBUG, "ORB Thread started\n")); CORBA::String_var str = remote_server->test_method (server.in ()); ACE_DEBUG ((LM_DEBUG, "Received \"%C\"\n", str.in ())); orb->shutdown (true); worker.thr_mgr ()->wait (); ACE_DEBUG ((LM_DEBUG, "ORB Thread completed\n")); } orb->destroy (); } catch (CORBA::Exception& ex) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("(%P|%t) Exception caught: \n%s\n"), ACE_TEXT_CHAR_TO_TCHAR (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); 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) Unable to initialize the POA.\n"), 1); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); if (parse_args (argc, argv) != 0) return 1; Simple_Server_i server_impl (orb.in ()); PortableServer::ObjectId_var id = root_poa->activate_object (&server_impl); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); Simple_Server_var server = Simple_Server::_narrow (object.in ()); CORBA::String_var ior = orb->object_to_string (server.in ()); CORBA::Object_var table_object = orb->resolve_initial_references("IORTable"); IORTable::Table_var table = IORTable::Table::_narrow (table_object.in ()); if (CORBA::is_nil (table.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the IORTable.\n"), 1); table->bind ("Simple_Server", ior.in ()); //ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ())); FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); poa_manager->activate (); orb->run (); ACE_DEBUG ((LM_DEBUG, "(%P|%t)server: event loop finished\n")); root_poa->destroy (1, 1); orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }