int
main (int argc, char** argv)
{
std::cout << "Qedo Assembly Factory" << std::endl;
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
//
// register valuetype factories
//
CORBA::ValueFactoryBase_var factory;
factory = new Qedo::CookieFactory_impl();
orb->register_value_factory("IDL:omg.org/Components/Cookie:1.0", factory);
factory = new Qedo::ConfigValueFactory_impl();
orb->register_value_factory("IDL:omg.org/Components/ConfigValue:1.0", factory);
Qedo::AssemblyFactoryImpl* assembly_factory = new Qedo::AssemblyFactoryImpl(orb);
try
{
assembly_factory->initialize();
}
catch (Qedo::AssemblyFactoryImpl::CannotInitialize&)
{
std::cerr << "Cannot initialize Assembly Factory... exiting." << std::endl;
orb->destroy();
exit (1);
}
orb->run();
}
/**
* the executable starts a HomeFinder
*/
int
main (int argc, char** argv)
{
std::cout << "Qedo Home Finder" << std::endl;
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
//
// register valuetype factories
//
CORBA::ValueFactoryBase* factory;
factory = new Qedo::CookieFactory_impl();
orb->register_value_factory("IDL:omg.org/Components/Cookie:1.0", factory);
Qedo::HomeFinderImpl* home_finder = new Qedo::HomeFinderImpl(orb);
try
{
home_finder->initialize();
}
catch (Qedo::HomeFinderImpl::CannotInitialize&)
{
std::cerr << "Cannot initialize Home Finder... exiting." << std::endl;
orb->destroy();
exit (1);
}
NORMAL_OUT("Qedo Home Finder is up and running ...")
orb->run();
return 0;
}
/**
* start the server for the assembly factory object
*/
int
main (int argc, char** argv)
{
std::cout << "Qedo Assembly Factory " << QEDO_VERSION << std::endl;
// get the qedo dir
#ifdef _WIN32
TCHAR tchBuffer[256];
LPTSTR lpszSystemInfo = tchBuffer;
DWORD dwResult = ExpandEnvironmentStrings("%QEDO%", lpszSystemInfo, 256);
Qedo::g_qedo_dir.append(lpszSystemInfo);
#else
char *e = getenv("QEDO");
if(e) Qedo::g_qedo_dir.append(e);
#endif
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
//
// register valuetype factories
//
CORBA::ValueFactoryBase* factory;
factory = new Qedo::CookieFactory_impl();
orb->register_value_factory("IDL:omg.org/Components/Cookie:1.0", factory);
factory = new Qedo::ConfigValueFactory_impl();
orb->register_value_factory("IDL:omg.org/Components/ConfigValue:1.0", factory);
Qedo::AssemblyFactoryImpl* assembly_factory = new Qedo::AssemblyFactoryImpl(orb);
try
{
assembly_factory->initialize();
}
catch (Qedo::AssemblyFactoryImpl::CannotInitialize&)
{
std::cerr << "Cannot initialize Assembly Factory... exiting." << std::endl;
orb->destroy();
exit (1);
}
std::cout << "Qedo Assembly Factory Server is up and running ...\n";
orb->run();
return 0;
}
//
// entry point
//
::Components::HomeExecutorBase_ptr
create_CutleryHomeE(void)
{
// BEGIN USER INSERT SECTION create_CutleryHome
int dummy = 0;
CORBA::ORB_var orb = CORBA::ORB_init (dummy, 0);
CORBA::ValueFactoryBase* oldFact;
oldFact = orb->register_value_factory ("IDL:omg.org/Components/Cookie:1.0", new dinner::CookieFactory_impl());
// END USER INSERT SECTION create_CutleryHome
return new ::dinner::CutleryHomeImpl();
}
int
ACE_TMAIN (
int argc,
ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
MessageFactory *mf = new MessageFactory ();
CORBA::String_var id = _tc_Message->id ();
ACE_DEBUG ((LM_DEBUG, "Registering factory reference\n"));
orb->register_value_factory (id.in (), mf);
ACE_DEBUG ((LM_DEBUG, "Unregistering factory reference\n"));
orb->unregister_value_factory (id.in ());
ACE_DEBUG ((LM_DEBUG, "Value factory destructor flag: %i\n", MessageFactory::destructorInvoked_));
ACE_DEBUG ((LM_DEBUG, "Actively removing reference\n"));
mf->_remove_ref ();
ACE_DEBUG ((LM_DEBUG, "Value factory destructor flag: %i\n", MessageFactory::destructorInvoked_));
ACE_DEBUG ((LM_DEBUG, "Shutting down / destroying ORB\n"));
orb->shutdown (true);
orb->destroy ();
if (MessageFactory::destructorInvoked_ == 1)
{
ACE_DEBUG ((LM_ERROR, "Test passed: value factory destructor was invoked as expected\n"));
return 0;
}
else
{
ACE_DEBUG ((LM_ERROR, "Test failed: value factory destructor was not invoked\n"));
return 1;
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("CORBA exception caught during execution");
return -1;
}
catch (...)
{
ACE_DEBUG ((LM_ERROR, "Non-CORBA exception caught during execution"));
return -1;
}
}
//
// entry point
//
::Components::HomeExecutorBase_ptr
create_ObserverHomeE(void)
{
// BEGIN USER INSERT SECTION create_ObserverHome
// This is a preliminary hack to register the valuetype factories
int dummy = 0;
CORBA::ORB_var orb = CORBA::ORB_init (dummy, 0);
CORBA::ValueFactoryBase_var oldFact;
oldFact = orb->register_value_factory ("IDL:dinner/PhilosopherState:1.0", new dinner::PhilosopherStateFactory_impl() );
// END USER INSERT SECTION create_ObserverHome
return new ::dinner::ObserverHomeImpl();
}
//
// cleaner object for a ValueFactory
//
ValueFactoryCleaner::ValueFactoryCleaner (class CORBA::ValueFactoryBase* factory, char* repid)
: factory_ (factory), is_registered_(false), repid_(repid)
{
int dummy = 0;
CORBA::ORB_var orb = CORBA::ORB_init (dummy, 0);
// check whether there is already a factory
if (orb->lookup_value_factory( repid ))
{
DEBUG_OUT3("..... factory for ", repid, " already registered");
}
else
{
DEBUG_OUT2( "..... register factory for ", repid );
orb->register_value_factory( repid, factory_ );
is_registered_ = true;
}
}
/**
* start the server for the assembly factory object
*/
int
main (int argc, char** argv)
{
std::cout << "Qedo Assembly Factory " << QEDO_VERSION << std::endl;
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 == "")
{
std::cout << "Missing Environment Variable QEDO" << std::endl;
Qedo::g_qedo_dir.append("./");
}
std::cout << "..... Qedo directory is " << Qedo::g_qedo_dir << std::endl;
//
// init ORB
//
orb = CORBA::ORB_init (argc, argv);
//
// register valuetype factories
//
CORBA::ValueFactoryBase* factory;
factory = new Qedo::CookieFactory_impl();
orb->register_value_factory("IDL:omg.org/Components/Cookie:1.0", factory);
factory = new Qedo::ConfigValueFactory_impl();
orb->register_value_factory("IDL:omg.org/Components/ConfigValue:1.0", factory);
Qedo::AssemblyFactoryImpl* assembly_factory = new Qedo::AssemblyFactoryImpl(orb);
try
{
assembly_factory->initialize();
}
catch (Qedo::AssemblyFactoryImpl::CannotInitialize&)
{
std::cerr << "Cannot initialize Assembly Factory... 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 Assembly Factory Server is up and running ...\n";
orb->run();
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
int status = 0;
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
::Test::vtp_init *vtp_factory = 0;
ACE_NEW_THROW_EX (vtp_factory,
::Test::vtp_init,
CORBA::NO_MEMORY ());
CORBA::ValueFactoryBase_var vtp_factory_owner = vtp_factory;
orb->register_value_factory (vtp_factory->tao_repository_id (),
vtp_factory);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Test::A_var server =
Test::A::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Object reference <%s> is nil\n"),
ior),
1);
}
status |= test_strings (server.in ());
status |= test_sequences (server.in ());
status |= test_arrays (server.in ());
status |= test_structs (server.in ());
status |= test_unions (server.in ());
status |= test_valueboxes (server.in ());
status |= test_valuetypes (server.in (), vtp_factory);
status |= test_exceptions (server.in ());
server->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception in client:");
return 1;
}
return status;
}
/**
* the executable starts a HomeFinder
*/
int
main (int argc, char** argv)
{
// create arguments for ORB_init
char *orb_argv[27];
int orb_argc=argc;
int orb_n = 0;
for (orb_n = 0; orb_n < argc; orb_n++)
{
orb_argv[orb_n] = strdup(argv[orb_n]);
};
// check for Host Name Resolving
std::string resolve = Qedo::ConfigurationReader::instance()->lookup_config_value ("/General/ResolveHostName");
if (!resolve.compare("false"))
{
orb_argv[orb_argc] = "-ORBNoResolve";
orb_argc++;
};
std::cout << "Qedo Home Finder " << QEDO_VERSION << " " << QEDO_REVISION << std::endl;
orb = CORBA::ORB_init (orb_argc, orb_argv);
Qedo::set_ORB(orb);
#ifdef HAVE_LIBPTHREAD
// block SIGINT
// Only the signal thread will handle this signal
sigset_t sigs;
sigset_t osigs;
sigemptyset (&sigs);
sigaddset (&sigs, SIGINT);
assert(pthread_sigmask (SIG_BLOCK, &sigs, &osigs) == 0);
// this thread will do the signal handling
Qedo::QedoThread* signal_thread;
signal_thread = Qedo::qedo_startDetachedThread(signal_handler_thread,0);
#else // HAVE_LIBPTHREAD
#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 // HAVE_SIGACTION
signal ( SIGINT, handle_sigint );
#endif // HAVE_SIGACTION
#endif // HAVE_LIBPTHREAD
//
// register valuetype factories
//
CORBA::ValueFactoryBase* factory;
factory = new Qedo::CookieFactory_impl();
orb->register_value_factory("IDL:omg.org/Components/Cookie:1.0", factory);
Qedo::HomeFinderImpl* home_finder = new Qedo::HomeFinderImpl(orb);
try
{
home_finder->initialize();
}
catch (Qedo::HomeFinderImpl::CannotInitialize&)
{
std::cerr << "Cannot initialize Home Finder... exiting." << std::endl;
orb->destroy();
exit (1);
}
NORMAL_OUT ("Qedo Home Finder is up and running ...")
orb->run();
#ifdef HAVE_LIBPTHREAD
// It is not sure, that only SIGINT will break the orb/run
// so we have to terminate the signal thread here also
signal_handler_thread_stop = true;
signal_thread->stop();
signal_thread->join();
#endif // HAVE_LIBPTHREAD
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;
// Obtain reference to the object
CORBA::Object_var tmp =
orb->string_to_object(ior);
OBV_FactoryTest::Test_var test =
OBV_FactoryTest::Test::_narrow(tmp.in ());
if (CORBA::is_nil (test.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil OBV_FactoryTest::Test reference <%s>\n",
ior),
1);
}
// Check if we get the correct exception with minor code because no
// factory has been set.
if (!no_factory (test.in ()))
return 1;
// Create factories.
OBV_FactoryTest::BaseValue_init *base_factory = 0;
ACE_NEW_RETURN (base_factory,
OBV_FactoryTest::BaseValue_init,
1); // supplied by mapping
orb->register_value_factory (base_factory->tao_repository_id (),
base_factory);
base_factory->_remove_ref (); // release ownership
OBV_FactoryTest::Value1_init *value1_factory = 0;
ACE_NEW_RETURN (value1_factory,
OBV_FactoryTest::Value1_init,
1); // supplied by mapping
orb->register_value_factory (value1_factory->tao_repository_id (),
value1_factory);
value1_factory->_remove_ref ();
OBV_FactoryTest::Value2_init *value2_factory = 0;
ACE_NEW_RETURN (value2_factory,
Value2_init_impl,
1); // custom implementation
orb->register_value_factory (value2_factory->tao_repository_id (),
value2_factory);
value2_factory->_remove_ref ();
// Now perform the test. I don't check return values.
// I just hope to get MARSHAL.
OBV_FactoryTest::BaseValue_var base_value =
test->get_base_value ();
OBV_FactoryTest::Value1_var value1 =
test->get_value1 ();
OBV_FactoryTest::Value2_var value2 =
test->get_value2 ();
// Test factories.
value2 = value2_factory->create_default (1);
OBV_FactoryTest::BaseValue::BV_Data data;
data.value = 2;
value2 = value2_factory->create (1, data);
ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - test finished\n"));
test->shutdown ();
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);
// All factories are kindly provided by
// compiler so we just to put everything in a right order.
// Create and register factory for BaseNode.
BaseNode_init *bn_factory = 0;
ACE_NEW_RETURN (bn_factory,
BaseNode_init,
1);
orb->register_value_factory (bn_factory->tao_repository_id (),
bn_factory);
bn_factory->_remove_ref (); // release ownership
// Create and register factory for TreeController.
TreeController_init *tc_factory = 0;
ACE_NEW_RETURN (tc_factory,
TreeController_init,
1);
orb->register_value_factory (tc_factory->tao_repository_id (),
tc_factory);
tc_factory->_remove_ref (); // release ownership
// Create and register factory for StringNode.
StringNode_init *sn_factory = 0;
ACE_NEW_RETURN (sn_factory,
StringNode_init,
1);
orb->register_value_factory (sn_factory->tao_repository_id (),
sn_factory);
sn_factory->_remove_ref (); // release ownership
//Well, done with factories.
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;
Test_impl *test_impl;
ACE_NEW_RETURN (test_impl,
Test_impl (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(test_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (test_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test_var test = Test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (test.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);
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[])
{
// Register the default factory in the Service Configurator.
// If your platform supports static constructors then you can
// simply using the ACE_STATIC_SVC_DEFINE() macro, unfortunately TAO
// must run on platforms where static constructors do not work well,
// so we have to explicitly invoke this function.
TAO_EC_Default_Factory::init_svcs ();
// The exception macros are described in $ACE_ROOT/docs/exceptions.html
// and defined in $ACE_ROOT/ace/CORBA_macros.h.
// If your platform supports native exceptions, and TAO was compiled
// with native exception support then you can simply use try/catch
// and avoid the argument.
// Unfortunately many embedded systems cannot use exceptions due to
// the space and time overhead.
//
try
{
// **************** HERE STARTS THE ORB SETUP
// Create the ORB, pass the argv list for parsing.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Parse the arguments, you usually want to do this after
// invoking ORB_init() because ORB_init() will remove all the
// -ORB options from the command line.
if (parse_args (argc, argv) == -1)
{
ACE_ERROR ((LM_ERROR,
"Usage: Service [-m udp_mcast_addr]\n"));
return 1;
}
if (valuetype)
{
Hello::ValueTypeData_init *vb_factory = 0;
ACE_NEW_RETURN (vb_factory,
Hello::ValueTypeData_init,
1); // supplied by mapping
orb->register_value_factory (vb_factory->tao_repository_id (),
vb_factory);
vb_factory->_remove_ref (); // release ownership
}
// This is the standard code to get access to the POA and
// activate it.
// The POA starts in the holding state, if it is not activated
// it will not process any requests.
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// **************** THAT COMPLETS THE ORB SETUP
// **************** HERE START THE LOCAL EVENT CHANNEL SETUP
// This structure is used to define the startup time event
// channel configuration.
// This structure is described in
//
// $TAO_ROOT/docs/ec_options.html
//
TAO_EC_Event_Channel_Attributes attributes (poa.in (),
poa.in ());
// Create the Event Channel implementation class
TAO_EC_Event_Channel ec_impl (attributes);
// Activate the Event Channel, depending on the configuration
// that may involve creating some threads.
// But it should always be invoked because several internal data
// structures are initialized at that point.
ec_impl.activate ();
// The event channel is activated as any other CORBA servant.
// In this case we use the simple implicit activation with the
// RootPOA
RtecEventChannelAdmin::EventChannel_var event_channel =
ec_impl._this ();
// **************** THAT COMPLETES THE LOCAL EVENT CHANNEL SETUP
// **************** HERE STARTS THE FEDERATION SETUP
// The next step is to setup the multicast gateways.
// There are two gateways involved, one sends the locally
// generated events to the federated peers, the second gateway
// receives multicast traffic and turns it into local events.
// The sender requires a helper object to select what
// multicast group will carry what traffic, this is the
// so-called 'Address Server'.
// The intention is that advanced applications can use different
// multicast groups for different events, this can exploit
// network interfaces that filter unwanted multicast traffic.
// The helper object is accessed through an IDL interface, so it
// can reside remotely.
// In this example, and in many application, using a fixed
// multicast group is enough, and a local address server is the
// right approach.
// First we convert the string into an INET address, then we
// convert that into the right IDL structure:
ACE_INET_Addr udp_addr (udp_mcast_address);
ACE_DEBUG ((LM_DEBUG,
"udp mcast address is: %s\n",
udp_mcast_address));
// Now we create and activate the servant
AddrServer as_impl (udp_addr);
RtecUDPAdmin::AddrServer_var address_server =
as_impl._this ();
TAO_ECG_Refcounted_Endpoint endpoint(new TAO_ECG_UDP_Out_Endpoint);
// Now we connect the sender as a consumer of events, it will
// receive any event from any source and send it to the "right"
// multicast group, as defined by the address server set above:
RtecEventChannelAdmin::ConsumerQOS sub;
sub.is_gateway = 1;
sub.dependencies.length (1);
sub.dependencies[0].event.header.type =
ACE_ES_EVENT_ANY; // first free event type
sub.dependencies[0].event.header.source =
ACE_ES_EVENT_SOURCE_ANY; // Any source is OK
// To receive events we need to setup an event handler:
PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver =
TAO_ECG_UDP_Receiver::create();
TAO_ECG_Mcast_EH mcast_eh (&(*receiver));
// The event handler uses the ORB reactor to wait for multicast
// traffic:
mcast_eh.reactor (orb->orb_core ()->reactor ());
// The multicast Event Handler needs to know to what multicast
// groups it should listen to. To do so it becomes an observer
// with the event channel, to determine the list of events
// required by all the local consumer.
// Then it register for the multicast groups that carry those
// events:
mcast_eh.open (event_channel.in ());
// Again the receiver connects to the event channel as a
// supplier of events, using the Observer features to detect
// local consumers and their interests:
receiver->init (event_channel.in (),
endpoint,
address_server.in ());
// The Receiver is also a supplier of events. The exact type of
// events is only known to the application, because it depends
// on the traffic carried by all the multicast groups that the
// different event handlers subscribe to.
// In this example we choose to simply describe our publications
// using wilcards, any event from any source. More advanced
// application could use the Observer features in the event
// channel to update this information (and reduce the number of
// multicast groups that each receive subscribes to).
// In a future version the event channel could perform some of
// those tasks automatically
RtecEventChannelAdmin::SupplierQOS pub;
pub.publications.length (1);
pub.publications[0].event.header.type = ACE_ES_EVENT_ANY;
pub.publications[0].event.header.source = ACE_ES_EVENT_SOURCE_ANY;
pub.is_gateway = 1;
receiver->connect (pub);
// **************** THAT COMPLETES THE FEDERATION SETUP
// **************** HERE STARTS THE CLIENT SETUP
// First let us create a consumer and connect it to the event
// channel
Consumer consumer (valuetype);
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
event_channel->for_consumers ();
consumer.connect (consumer_admin.in ());
// **************** THAT COMPLETES THE CLIENT SETUP
// **************** HERE STARTS THE EVENT LOOP
// Wait for events, including incoming multicast data.
// We could also use orb->run(), but that will not let us
// terminate the application in a nice way.
for (int i = 0; i != 100; ++i)
{
CORBA::Boolean there_is_work =
orb->work_pending ();
if (there_is_work)
{
// We use a TAO extension. The CORBA mechanism does not
// provide any decent way to control the duration of
// perform_work() or work_pending(), so just calling
// them results in a spin loop.
ACE_Time_Value tv (0, 50000);
orb->perform_work (tv);
}
ACE_Time_Value tv (0, 100000);
ACE_OS::sleep (tv);
if (consumer.event_count () == 25)
{
break;
}
}
// **************** THAT COMPLETES THE EVENT LOOP
// **************** HERE STARTS THE CLEANUP CODE
consumer.disconnect ();
// Now let us close the Receiver
receiver->shutdown ();
int const r = mcast_eh.shutdown ();
if (r == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Closing MCast event handler\n"), 1);
}
// The event channel must be destroyed, so it can release its
// resources, and inform all the clients that are still
// connected that it is going away.
event_channel->destroy ();
// Deactivating the event channel implementation is not strictly
// required, the POA will do it for us, but it is good manners:
{
// Using _this() activates with the default POA, we must gain
// access to that POA to deactivate the object.
// Notice that we 'know' that the default POA for this servant
// is the root POA, but the code is more robust if we don't
// rely on that.
PortableServer::POA_var poa =
ec_impl._default_POA ();
// Get the Object Id used for the servant..
PortableServer::ObjectId_var oid =
poa->servant_to_id (&ec_impl);
// Deactivate the object
poa->deactivate_object (oid.in ());
}
// Now we can destroy the POA, the flags mean that we want to
// wait until the POA is really destroyed
poa->destroy (1, 1);
// Finally destroy the ORB
orb->destroy ();
// **************** THAT COMPLETES THE CLEANUP CODE
ACE_DEBUG ((LM_DEBUG,
"UDP receiver ready\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Service");
return 1;
}
return 0;
}
int
main (int argc, char** argv)
{
cout << "Test Client for Stream Container" << endl;
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
orb->register_value_factory ("IDL:omg.org/Components/FacetDescription:1.0", new FacetDescriptionFactory_impl());
orb->register_value_factory ("IDL:omg.org/Components/ReceptacleDescription:1.0", new ReceptacleDescriptionFactory_impl());
orb->register_value_factory ("IDL:omg.org/Components/SubscriberDescription:1.0", new SubscriberDescriptionFactory_impl());
orb->register_value_factory ("IDL:omg.org/Components/EmitterDescription:1.0", new EmitterDescriptionFactory_impl());
orb->register_value_factory ("IDL:omg.org/Components/ConsumerDescription:1.0", new ConsumerDescriptionFactory_impl());
orb->register_value_factory ("IDL:omg.org/Components/ComponentPortDescription:1.0", new ComponentPortDescriptionFactory_impl());
orb->register_value_factory ("IDL:omg.org/Components/Cookie:1.0", new CookieFactory_impl());
CosNaming::NamingContext_var ns;
try
{
CORBA::Object_var ns_obj = orb->resolve_initial_references ("NameService");
ns = CosNaming::NamingContext::_narrow (ns_obj);
}
catch (CORBA::ORB::InvalidName&)
{
cerr << "Name Service not found" << endl;
orb->destroy();
exit (1);
}
catch (CORBA::SystemException&)
{
cerr << "Cannot narrow object reference of Name Service" << endl;
orb->destroy();
exit (1);
}
if (CORBA::is_nil (ns))
{
cerr << "Name Service is nil" << endl;
orb->destroy();
exit (1);
}
// Now get the Component Server Activator from the Name Service, use the name TETRA/Activators/<hostname>
char hostname[256];
if (gethostname (hostname, 256))
{
cerr << "Cannot determine my hostname" << endl;
orb->destroy();
exit (1);
}
// Get the Server Activator
Components::Deployment::ServerActivator_var server_activator = get_server_activator (orb, ns, hostname);
// Feed our test deployment into the Component Installer
deploy_test_components (orb, ns, hostname);
//
// Begin tests
//
// Create Component Server
Components::ConfigValues config;
Components::ConfigValues config1;
Components::Deployment::ComponentServer_var component_server;
Components::Deployment::ComponentServer_var component_server1;
Components::Deployment::ComponentServer_var component_server2;
try
{
component_server = server_activator->create_component_server (config1);
}
catch (CORBA::Exception&)
{
cerr << "Exception during test run" << endl;
orb->destroy();
exit (1);
}
if (CORBA::is_nil (component_server))
{
cerr << "I got a nil reference for the created Component Server" << endl;
orb->destroy();
exit (1);
}
#if 0
try
{
component_server1 = server_activator->create_component_server (config1);
}
catch (CORBA::Exception&)
{
cerr << "Exception during test run" << endl;
orb->destroy();
exit (1);
}
if (CORBA::is_nil (component_server1))
{
cerr << "I got a nil reference for the created Component Server" << endl;
orb->destroy();
exit (1);
}
try
{
component_server2 = server_activator->create_component_server (config1);
}
catch (CORBA::Exception&)
{
cerr << "Exception during test run" << endl;
orb->destroy();
exit (1);
}
if (CORBA::is_nil (component_server2))
{
cerr << "I got a nil reference for the created Component Server" << endl;
orb->destroy();
exit (1);
}
#endif
// Create Container
Components::Deployment::Container_var container;
Components::Deployment::Container_var container1;
Components::Deployment::Container_var container2;
config.length (1);
CORBA::Any any;
any <<= "SESSION";
config[0] = new ConfigValue_impl ("CONTAINER_TYPE", any);
try
{
container = component_server->create_container (config);
}
catch (CORBA::SystemException& ex)
{
cerr << "CORBA system exception during creating container : " << ex << endl;
orb->destroy();
exit (1);
}
#if 0
try
{
container1 = component_server1->create_container (config);
}
catch (CORBA::SystemException& ex)
{
cerr << "CORBA system exception during creating container : " << ex << endl;
orb->destroy();
exit (1);
}
try
{
container2 = component_server2->create_container (config);
}
catch (CORBA::SystemException& ex)
{
cerr << "CORBA system exception during creating container : " << ex << endl;
orb->destroy();
exit (1);
}
#endif
//config.length(0);
Components::CCMHome_var home;
home = container->install_home ("PHILOSOPHER", "", config1);
dinner::PhilosopherHome_var p_home = dinner::PhilosopherHome::_narrow (home);
#if 0
home = container1->install_home ("CUTLERY", "", config1);
dinner::CutleryHome_var c_home = dinner::CutleryHome::_narrow (home);
home = container2->install_home ("OBSERVER", "", config1);
dinner::ObserverHome_var o_home = dinner::ObserverHome::_narrow (home);
#else
home = container->install_home ("CUTLERY", "", config1);
dinner::CutleryHome_var c_home = dinner::CutleryHome::_narrow (home);
home = container->install_home ("OBSERVER", "", config1);
dinner::ObserverHome_var o_home = dinner::ObserverHome::_narrow (home);
#endif
dinner::Philosopher_var phil1;
dinner::Philosopher_var phil2;
dinner::Philosopher_var phil3;
dinner::Cutlery_var cut1;
dinner::Cutlery_var cut2;
dinner::Observer_var obs;
dinner::Observer_var obs1;
try
{
phil1 = p_home->create();
phil2 = p_home->create();
phil3 = p_home->create();
cut1 = c_home->create();
cut2 = c_home->create();
obs = o_home->create();
obs1 = o_home->create();
}
catch (Components::CreateFailure&)
{
cerr << "Create Failure exception" << endl;
}
catch (CORBA::SystemException& ex)
{
cerr << ex << endl;
}
try
{
phil1->name ("Frank");
phil2->name ("Bert");
phil3->name ("Harry");
phil1->thinking_seconds (5);
phil2->thinking_seconds (3);
phil3->thinking_seconds (6);
phil1->eating_seconds (4);
phil2->eating_seconds (6);
phil3->eating_seconds (3);
phil1->sleeping_seconds (6);
phil2->sleeping_seconds (7);
phil3->sleeping_seconds (5);
dinner::Fork_var a_fork;
a_fork = cut1->provide_the_fork();
phil1->connect_left_hand (a_fork);
phil2->connect_left_hand (a_fork);
phil3->connect_left_hand (a_fork);
a_fork = cut2->provide_the_fork();
phil1->connect_right_hand (a_fork);
phil2->connect_right_hand (a_fork);
phil3->connect_right_hand (a_fork);
Components::Cookie* ck;
dinner::PhilosopherStateConsumer_var consumer = obs->get_consumer_philosopher_state();
ck = phil1->subscribe_philosopher_state (consumer);
ck = phil2->subscribe_philosopher_state (consumer);
ck = phil3->subscribe_philosopher_state (consumer);
consumer = obs1->get_consumer_philosopher_state();
ck = phil1->subscribe_philosopher_state (consumer);
ck = phil2->subscribe_philosopher_state (consumer);
ck = phil3->subscribe_philosopher_state (consumer);
phil1->configuration_complete();
phil2->configuration_complete();
phil3->configuration_complete();
cut1->configuration_complete();
cut2->configuration_complete();
obs->configuration_complete();
obs1->configuration_complete();
}
catch (CORBA::SystemException& ex)
{
cerr << ex << endl;
}
sleep (30);
try
{
phil1->remove();
phil2->remove();
phil3->remove();
c_home->remove_component (cut1);
c_home->remove_component (cut2);
obs->remove();
obs1->remove();
}
catch (Components::RemoveFailure&)
{
cerr << "Remove Failure during remove_component()" << endl;
}
catch (CORBA::SystemException& ex)
{
cerr << ex << endl;
}
try
{
#if 0
container1->remove_home (c_home);
container2->remove_home (o_home);
#else
container->remove_home (c_home);
container->remove_home (o_home);
#endif
// remove at last because of it was installed first
// registering the valuetype factories
container->remove_home (p_home);
}
catch (Components::RemoveFailure&)
{
cerr << "Remove Failure during removing home" << endl;
}
catch (CORBA::SystemException& ex)
{
cerr << ex << endl;
}
try
{
container->remove();
}
catch (Components::RemoveFailure&)
{
cerr << "Remove Failure during removing container" << endl;
}
catch (CORBA::SystemException& ex)
{
cerr << ex << endl;
}
try
{
component_server->remove();
#if 0
getchar();
component_server1->remove();
getchar();
component_server2->remove();
#endif
}
catch (Components::RemoveFailure&)
{
cerr << "Remove Failure during removing component server" << endl;
}
catch (CORBA::SystemException& ex)
{
cerr << ex << endl;
}
return 0;
}
