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