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");
if (parse_args (argc, argv) != 0)
return 1;
PortableServer::Servant_var<Server> impl;
{
Server * 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,
Server(orb.in()),
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::Server_var server =
Test::Server::_narrow (object_act.in ());
CORBA::String_var ior =
orb->object_to_string (server.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_Task task(orb.in());
task.activate(THR_NEW_LWP | THR_JOINABLE, 4, 1);
task.wait();
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[])
{
try {
// Initialize orb
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
//Get reference to Root POA
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Activate POA Manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Find the Naming Service
obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root =
CosNaming::NamingContextExt::_narrow(obj.in());
if (CORBA::is_nil(root.in())) {
std::cerr << "Nil Naming Context reference" << std::endl;
return 1;
}
// Bind a new context.
CosNaming::Name name;
name.length( 1 );
name[0].id = CORBA::string_dup( "root.esc-dot" );
name[0].kind = CORBA::string_dup( "kind1" );
try {
obj = root->resolve(name);
}
catch(const CosNaming::NamingContext::NotFound&) {
CosNaming::NamingContext_var dummy = root->bind_new_context(name);
}
name.length( 2 );
name[1].id = CORBA::string_dup( "leaf/esc-slash" );
name[1].kind = CORBA::string_dup( "kind2" );
// Create an object
PortableServer::Servant_var<Messenger_i> servant = new Messenger_i;
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
CORBA::Object_var messenger_obj = poa->id_to_reference(oid.in());
root->rebind(name, messenger_obj.in());
// Also try rebinding to a simple path.
CosNaming::Name_var simp_name = root->to_name("Simple");
try {
obj = root->resolve(simp_name.in());
}
catch(const CosNaming::NamingContext::NotFound&) {
CosNaming::NamingContext_var dummy =
root->bind_new_context(simp_name.in());
}
simp_name = root->to_name("Simple/Messenger");
root->rebind(simp_name.in(), messenger_obj.in());
// Convert Name to String Name.
CORBA::String_var str_name = root->to_string(name);
std::cout << "str_name: " << str_name.in() << std::endl;
CORBA::String_var str_simple = root->to_string(simp_name.in());
std::cout << "simple: " << str_simple.in() << std::endl;
// Convert String Name to Name.
CosNaming::Name_var tname = root->to_name(str_name.in());
std::cout << "converted back to a CosNaming::Name: " << std::endl;
std::cout << " name[0] = " << (* tname)[0].id.in() << " , "
<< (* tname)[0].kind.in() << std::endl;
std::cout << " name[1] = " << (* tname)[1].id.in() << " , "
<< (* tname)[1].kind.in() << std::endl;
// Find the application object by resolve_str.
try {
obj = root->resolve_str(str_name.in());
}
catch(const CosNaming::NamingContext::NotFound&) {
std::cerr<<"Couldn't resolve the string name: " << str_name << std::endl;
return 1;
}
ACE_CString base_address (":");
base_address += ACE_TEXT_ALWAYS_CHAR (hostname);
base_address += ":";
base_address += ACE_TEXT_ALWAYS_CHAR (port);
ACE_CString addr ("");
addr = base_address + "/key/str";
// Create an URL string for application object.
CORBA::String_var address = CORBA::string_dup (addr.c_str());
std::cout << "call to_url(\"" << address.in() << "\"" << std::endl;
std::cout << " ,\"" << str_simple.in() << "\")"<< std::endl;
CORBA::String_var url_string = root->to_url(address.in(), str_simple.in());
std::cout << "to_url result: " << url_string.in() << std::endl;
// Write NS url to a file to let client read NS URL to get
// NamingContext reference.
CORBA::String_var ns_addr = CORBA::string_dup(base_address.c_str());
std::cout << "call to_url(\"" <<ns_addr.in() << "\",\""
<< str_simple.in() << "\")"<< std::endl;
CORBA::String_var url = root->to_url(ns_addr.in(), str_simple.in());
std::cout << "to_url result: " << url.in() << std::endl;
std::ofstream iorFile(ACE_TEXT_ALWAYS_CHAR (ior_output_file));
iorFile << url.in() << std::endl;
iorFile.close();
std::cout << "Naming Service URL written to file " << ior_output_file << std::endl;
// Accept requests
orb->run();
orb->destroy();
}
catch(const CORBA::Exception& ex) {
std::cerr << "Caught a CORBA::Exception: " << ex << std::endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
// Initialize orb
CORBA::ORB_var 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() );
// Activate POA Manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Find the Naming Service
obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContext_var root =
CosNaming::NamingContext::_narrow(obj.in());
if (CORBA::is_nil(root.in())) {
std::cerr << "Nil Naming Context reference" << std::endl;
return 1;
}
// Bind the example Naming Context, if necessary
CosNaming::Name name;
name.length( 1 );
name[0].id = CORBA::string_dup("example");
try {
obj = root->resolve(name);
}
catch(const CosNaming::NamingContext::NotFound&) {
CosNaming::NamingContext_var dummy = root->bind_new_context(name);
}
// Bind the Messenger object
name.length(2);
name[1].id = CORBA::string_dup("Messenger");
// Create an object
PortableServer::Servant_var<Messenger_i> servant = new Messenger_i;
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
obj = poa->id_to_reference(oid.in());
Messenger_var messenger = Messenger::_narrow(obj.in());
root->rebind(name, messenger.in());
std::cout << "Messenger object bound in Naming Service" << std::endl;
// Accept requests
orb->run();
orb->destroy();
}
catch(const CORBA::Exception& ex) {
std::cerr << "server: Caught a CORBA::Exception: " << ex << std::endl;
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
// We may want this to be alive beyond the next block.
PortableServer::Servant_var<Heartbeat_Application> app;
try
{
// Initialize ORB and POA, POA Manager, parse args.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) == -1)
return 1;
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (obj.in ());
if (check_for_nil (poa.in (), "POA") == -1)
return 1;
PortableServer::POAManager_var manager =
poa->the_POAManager ();
// Obtain reference to EC.
obj = orb->resolve_initial_references ("Event_Service");
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow (obj.in ());
if (check_for_nil (ec.in (), "EC") == -1)
return 1;
// Init our application.
app = new Heartbeat_Application;
if (!app.in ())
return 1;
app->init (orb, ec);
// Allow processing of CORBA requests.
manager->activate ();
// Receive events from EC.
orb->run ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception in Heartbeat Application:");
// Since there was an exception, application might not have had
// a chance to shutdown.
app->shutdown ();
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv [])
{
try {
// Initialize orb
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
// Get reference to Root POA.
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Activate POA manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Create an object
PortableServer::Servant_var<Messenger_i> servant = new
Messenger_i(seconds_to_wait, servant_throws_exception);
// Write its stringified reference to stdout
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
obj = poa->id_to_reference(oid.in());
Messenger_var messenger = Messenger::_narrow(obj.in());
CORBA::String_var str = orb->object_to_string(messenger.in());
std::ofstream fout(ACE_TEXT_ALWAYS_CHAR(ior_output_file));
fout << str.in() << std::endl;
fout.close();
std::cout << "IOR written to file " << ACE_TEXT_ALWAYS_CHAR(ior_output_file) << std::endl;
// Accept requests
orb->run();
orb->destroy();
}
catch(const CORBA::Exception& ex) {
std::cerr << "Caught a CORBA::Exception: " << ex << std::endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init( argc, argv );
if (parse_args (argc, argv) != 0)
return 1;
//Get reference to the RootPOA.
CORBA::Object_var obj = orb->resolve_initial_references( "RootPOA" );
PortableServer::POA_var poa = PortableServer::POA::_narrow( obj.in() );
// Activate the POAManager.
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Create a servant.
PortableServer::Servant_var<Messenger_i> servant = new Messenger_i();
// Register the servant with the RootPOA, obtain its object
// reference, stringify it, and write it to a file.
PortableServer::ObjectId_var oid = poa->activate_object( servant.in() );
obj = poa->id_to_reference( oid.in() );
CORBA::String_var str = orb->object_to_string( obj.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(ior_output_file) );
iorFile << str.in() << std::endl;
iorFile.close();
std::cout << "IOR written to file " << ACE_TEXT_ALWAYS_CHAR(ior_output_file) << std::endl;
// Accept requests from clients.
orb->run();
orb->destroy();
return 0;
}
catch(const CORBA::Exception& ex) {
std::cerr << "CORBA exception: " << ex << std::endl;
}
return 1;
}
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;
MessageFactory::register_new_factory(* orb.in());
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var poaman = poa->the_POAManager();
PortableServer::Servant_var<Messenger_i> svt = new Messenger_i;
PortableServer::ObjectId_var id = poa->activate_object(svt.in());
obj = poa->id_to_reference(id.in());
CORBA::String_var ior = orb->object_to_string(obj.in());
write_ior(ior.in());
std::cout << "Starting server." << std::endl;
poaman->activate();
orb->run();
poa->destroy(true, true);
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 MessengerTask::svc()
{
try {
// Get reference to Root POA
CORBA::Object_var obj = orb_->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Activate POA Manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Find the Naming Service
obj = orb_->resolve_initial_references("NameService");
CosNaming::NamingContext_var root =
CosNaming::NamingContext::_narrow(obj.in());
if (CORBA::is_nil(root.in())) {
std::cerr << "Nil Naming Context reference" << std::endl;
return 1;
}
// Bind the example Naming Context, if necessary
CosNaming::Name name;
name.length(1);
name[0].id = CORBA::string_dup("example");
try {
root->resolve(name);
}
catch(const CosNaming::NamingContext::NotFound&) {
root->bind_new_context(name);
}
// Bind the Messenger object
name.length(2);
name[1].id = CORBA::string_dup("Messenger");
// Create an object
PortableServer::Servant_var<Messenger_i> servant = new Messenger_i;
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
obj = poa->id_to_reference(oid.in());
root->rebind(name, obj.in());
std::cout << "Messenger object bound in Naming Service" << std::endl;
// Normally we run the orb and the orb is shutdown by
// calling MessengerTask::end(). To simplify the coordination
// between the main thread and this Messenger thread, specify
// the time period to let the Messenger thread finish by itself.
// Accept requests
ACE_Time_Value tv(1);
orb_->run(tv);
orb_->destroy();
return 0;
}
catch(const CORBA::Exception& ex) {
std::cerr << "CORBA exception: " << ex << std::endl;
}
return -1;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR *ecname = ACE_TEXT ("EventService");
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
ecname = argv[i+1];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
}
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context
= CosNaming::NamingContextExt::_narrow(obj.in());
// Find the EchoEventChannel.
obj = root_context->resolve_str (ACE_TEXT_ALWAYS_CHAR (ecname));
// Downcast the object reference to an EventChannel reference.
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(obj.in());
if (CORBA::is_nil(ec.in())) {
std::cerr << "Could not narrow EchoEventChannel." << std::endl;
return 1;
}
std::cout << "EchoEventConsumerMain.cpp: Found the EchoEventChannel." << std::endl;
// Obtain a reference to the consumer administration object.
RtecEventChannelAdmin::ConsumerAdmin_var admin = ec->for_consumers();
// Obtain a reference to the push supplier proxy.
RtecEventChannelAdmin::ProxyPushSupplier_var supplier =
admin->obtain_push_supplier();
// Get the RootPOA.
obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Instantiate an EchoEventConsumer_i servant and register it
// with the RootPOA
PortableServer::Servant_var<EchoEventConsumer_i> servant =
new EchoEventConsumer_i(orb.in(), supplier.in(), EVENT_LIMIT);
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
CORBA::Object_var consumer_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushConsumer_var consumer =
RtecEventComm::PushConsumer::_narrow(consumer_obj.in());
// Connect as a consumer.
ACE_ConsumerQOS_Factory qos;
qos.start_disjunction_group ();
qos.insert (MY_SOURCE_ID, // Source ID
MY_EVENT_TYPE, // Event Type
0); // handle to the rt_info
supplier->connect_push_consumer (consumer.in (),
qos.get_ConsumerQOS ());
// Activate the POA via its POAManager.
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();
std::cout << "EchoEventConsumerMain.cpp: Ready to receive events..." << std::endl;
// Enter the ORB event loop.
orb->run();
// If we have reached this, we must be shutting down...
// Disconnect the ProxyPushSupplier.
orb->destroy();
std::cout << "Test completed." << std::endl;
return 0;
}
catch(const CORBA::Exception& exc)
{
std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl;
}
return 1;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
const ACE_TCHAR *ecname = ACE_TEXT ("EventService");
const ACE_TCHAR *address = ACE_TEXT ("localhost");
const ACE_TCHAR *iorfile = 0;
u_short port = 12345;
u_short listenport = 12345;
int mcast = 1;
for (int i = 0; argv[i] != 0; i++)
{
if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-ecname")) == 0)
{
if (argv[i+1] != 0)
ecname = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing Event channel name\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-address")) == 0)
{
if (argv[i+1] != 0)
address = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing address\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-port")) == 0)
{
if (argv[i+1] != 0)
port = ACE_OS::atoi(argv[++i]);
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing port\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-listenport")) == 0)
{
if (argv[i+1] != 0)
listenport = ACE_OS::atoi(argv[++i]);
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing port\n"), 0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-iorfile")) == 0)
{
if (argv[i+1] != 0)
iorfile = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing ior file\n"), 0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-udp")) == 0)
mcast = 0;
}
// Get the POA
CORBA::Object_var tmpobj = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (tmpobj.in ());
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
poa_manager->activate ();
// Create a local event channel and register it
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
TAO_EC_Event_Channel ec_impl (attributes);
ec_impl.activate ();
PortableServer::ObjectId_var oid = poa->activate_object(&ec_impl);
tmpobj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(tmpobj.in());
// Find the Naming Service.
tmpobj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context =
CosNaming::NamingContextExt::_narrow(tmpobj.in());
// Bind the Event Channel using Naming Services
CosNaming::Name_var name =
root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a proxy push consumer from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
EchoEventSupplier_i servant(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(&servant);
tmpobj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(tmpobj.in());
// Connect to the EC.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
consumer->connect_push_supplier (supplier.in (), qos.get_SupplierQOS ());
// Initialize the address server with the desired address. This will
// be used by the sender object and the multicast receiver only if
// one is not otherwise available via the naming service.
ACE_INET_Addr send_addr (port, address);
SimpleAddressServer addr_srv_impl (send_addr);
// Create an instance of the addr server for local use
PortableServer::ObjectId_var addr_srv_oid =
poa->activate_object(&addr_srv_impl);
tmpobj =
poa->id_to_reference(addr_srv_oid.in());
RtecUDPAdmin::AddrServer_var addr_srv =
RtecUDPAdmin::AddrServer::_narrow(tmpobj.in());
// Create and initialize the sender object
PortableServer::Servant_var<TAO_ECG_UDP_Sender> sender =
TAO_ECG_UDP_Sender::create();
TAO_ECG_UDP_Out_Endpoint endpoint;
// need to be explicit about the address type when built with
// IPv6 support, otherwise SOCK_DGram::open defaults to ipv6 when
// given a sap_any address. This causes trouble on at least solaris
// and windows, or at most on not-linux.
if (endpoint.dgram ().open (ACE_Addr::sap_any,
send_addr.get_type()) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open send endpoint\n"),
1);
}
// TAO_ECG_UDP_Sender::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the sender will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone (new TAO_ECG_UDP_Out_Endpoint (endpoint));
sender->init (ec.in (), addr_srv.in (), clone);
// Setup the subscription and connect to the EC
ACE_ConsumerQOS_Factory cons_qos_fact;
cons_qos_fact.start_disjunction_group ();
cons_qos_fact.insert (ACE_ES_EVENT_SOURCE_ANY, ACE_ES_EVENT_ANY, 0);
RtecEventChannelAdmin::ConsumerQOS sub = cons_qos_fact.get_ConsumerQOS ();
sender->connect (sub);
// Create and initialize the receiver
PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver =
TAO_ECG_UDP_Receiver::create();
// TAO_ECG_UDP_Receiver::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the receiver will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone2 (new TAO_ECG_UDP_Out_Endpoint (endpoint));
receiver->init (ec.in (), clone2, addr_srv.in ());
// Setup the registration and connect to the event channel
ACE_SupplierQOS_Factory supp_qos_fact;
supp_qos_fact.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
RtecEventChannelAdmin::SupplierQOS pub = supp_qos_fact.get_SupplierQOS ();
receiver->connect (pub);
// Create the appropriate event handler and register it with the reactor
auto_ptr<ACE_Event_Handler> eh;
if (mcast) {
auto_ptr<TAO_ECG_Mcast_EH> mcast_eh(new TAO_ECG_Mcast_EH (receiver.in()));
mcast_eh->reactor (orb->orb_core ()->reactor ());
mcast_eh->open (ec.in());
ACE_auto_ptr_reset(eh,mcast_eh.release());
//eh.reset(mcast_eh.release());
} else {
auto_ptr<TAO_ECG_UDP_EH> udp_eh (new TAO_ECG_UDP_EH (receiver.in()));
udp_eh->reactor (orb->orb_core ()->reactor ());
ACE_INET_Addr local_addr (listenport);
if (udp_eh->open (local_addr) == -1)
ACE_ERROR ((LM_ERROR,"Cannot open EH\n"));
ACE_auto_ptr_reset(eh,udp_eh.release());
//eh.reset(udp_eh.release());
}
// Create an event (just a string in this case).
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
#if !defined (TAO_LACKS_EVENT_CHANNEL_ANY)
// Initialize data fields in event.
const CORBA::String_var eventData =
CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
event[0].data.any_value <<= eventData;
#else
// Use the octet sequence payload instead
char *tmpstr = const_cast<char *>(ACE_TEXT_ALWAYS_CHAR (ecname));
size_t len = ACE_OS::strlen(tmpstr) +1;
event[0].data.payload.replace (
len,
len,
reinterpret_cast<CORBA::Octet *> (tmpstr));
#endif /* !TAO_LACKS_EVENT_CHANNEL_ANY */
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
ACE_DEBUG ((LM_DEBUG,
"Starting main loop\n"));
const int EVENT_DELAY_MS = 1000;
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
}
orb->destroy();
return 0;
}
catch (const CORBA::Exception& exc)
{
ACE_ERROR ((LM_ERROR,
"Caught CORBA::Exception\n%C (%C)\n",
exc._name (),
exc._rep_id () ));
}
return 1;
}
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[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR* ecname = ACE_TEXT ("EventService");
const ACE_TCHAR* address = ACE_TEXT ("localhost");
const ACE_TCHAR* iorfile = 0;
u_short port = 12345;
u_short listenport = 12345;
int mcast = 1;
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
i++;
ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-address")) == 0) {
if (argv[i+1] != 0) {
i++;
address = argv[i];
} else {
std::cerr << "Missing address" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-port")) == 0) {
if (argv[i+1] != 0) {
i++;
port = ACE_OS::atoi(argv[i]);
} else {
std::cerr << "Missing port" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-listenport")) == 0) {
if (argv[i+1] != 0) {
i++;
listenport = ACE_OS::atoi(argv[i]);
} else {
std::cerr << "Missing port" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-iorfile")) == 0) {
if (argv[i+1] != 0) {
i++;
iorfile = argv[i];
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-udp")) == 0) {
mcast = 0;
}
}
// Get the POA
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 ();
// Create a local event channel and register it
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
PortableServer::Servant_var<TAO_EC_Event_Channel> ec_impl =
new TAO_EC_Event_Channel(attributes);
ec_impl->activate ();
PortableServer::ObjectId_var oid = poa->activate_object(ec_impl.in());
CORBA::Object_var ec_obj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in());
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(obj.in());
// Bind the Event Channel using Naming Services
CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a proxy push consumer from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
PortableServer::Servant_var<EchoEventSupplier_i> servant =
new EchoEventSupplier_i(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(servant.in());
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Connect to the EC.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
consumer->connect_push_supplier (supplier.in (), qos.get_SupplierQOS ());
// Initialize the address server with the desired address.
// This will be used by the sender object and the multicast
// receiver.
ACE_INET_Addr send_addr (port, address);
PortableServer::Servant_var<SimpleAddressServer> addr_srv_impl =
new SimpleAddressServer(send_addr);
PortableServer::ObjectId_var addr_srv_oid =
poa->activate_object(addr_srv_impl.in());
CORBA::Object_var addr_srv_obj = poa->id_to_reference(addr_srv_oid.in());
RtecUDPAdmin::AddrServer_var addr_srv =
RtecUDPAdmin::AddrServer::_narrow(addr_srv_obj.in());
// Create and initialize the sender object
PortableServer::Servant_var<TAO_ECG_UDP_Sender> sender =
TAO_ECG_UDP_Sender::create();
TAO_ECG_UDP_Out_Endpoint endpoint;
if (endpoint.dgram ().open (ACE_Addr::sap_any) == -1) {
std::cerr << "Cannot open send endpoint" << std::endl;
return 1;
}
// TAO_ECG_UDP_Sender::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the sender will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone (new TAO_ECG_UDP_Out_Endpoint (endpoint));
sender->init (ec.in (), addr_srv.in (), clone);
// Setup the subscription and connect to the EC
ACE_ConsumerQOS_Factory cons_qos_fact;
cons_qos_fact.start_disjunction_group ();
cons_qos_fact.insert (ACE_ES_EVENT_SOURCE_ANY, ACE_ES_EVENT_ANY, 0);
RtecEventChannelAdmin::ConsumerQOS sub = cons_qos_fact.get_ConsumerQOS ();
sender->connect (sub);
// Create and initialize the receiver
PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver =
TAO_ECG_UDP_Receiver::create();
// TAO_ECG_UDP_Receiver::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the receiver will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone2 (new TAO_ECG_UDP_Out_Endpoint (endpoint));
receiver->init (ec.in (), clone2, addr_srv.in ());
// Setup the registration and connect to the event channel
ACE_SupplierQOS_Factory supp_qos_fact;
supp_qos_fact.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
RtecEventChannelAdmin::SupplierQOS pub = supp_qos_fact.get_SupplierQOS ();
receiver->connect (pub);
// Create the appropriate event handler and register it with the reactor
auto_ptr<ACE_Event_Handler> eh;
if (mcast) {
auto_ptr<TAO_ECG_Mcast_EH> mcast_eh(new TAO_ECG_Mcast_EH (receiver.in()));
mcast_eh->reactor (orb->orb_core ()->reactor ());
mcast_eh->open (ec.in());
ACE_auto_ptr_reset(eh,mcast_eh.release());
//eh.reset(mcast_eh.release());
} else {
auto_ptr<TAO_ECG_UDP_EH> udp_eh (new TAO_ECG_UDP_EH (receiver.in()));
udp_eh->reactor (orb->orb_core ()->reactor ());
ACE_INET_Addr local_addr (listenport);
if (udp_eh->open (local_addr) == -1) {
std::cerr << "Cannot open EH" << std::endl;
}
ACE_auto_ptr_reset(eh,udp_eh.release());
//eh.reset(udp_eh.release());
}
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
event[0].data.any_value <<= eventData;
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
std::cout << "Starting main loop" << std::endl;
const int EVENT_DELAY_MS = 10;
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
}
orb->destroy();
return 0;
}
catch(const CORBA::Exception& exc)
{
std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl;
}
return 1;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR* ecname = ACE_TEXT ("EventService");
const ACE_TCHAR* remote_ecname = 0;
const ACE_TCHAR* iorfile = 0;
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
i++;
ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-gateway")) == 0) {
if (argv[i+1] != 0) {
i++;
remote_ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-iorfile")) == 0) {
if (argv[i+1] != 0) {
i++;
iorfile = argv[i];
}
}
}
// Get the POA
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 ();
// Spawn a thread for the orb
ACE_Thread_Manager *thread_mgr = ACE_Thread_Manager::instance();
thread_mgr->spawn(orb_thread, orb.in());
// Create a local event channel and register it with the RootPOA.
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
PortableServer::Servant_var<TAO_EC_Event_Channel> ec_impl =
new TAO_EC_Event_Channel(attributes);
ec_impl->activate ();
PortableServer::ObjectId_var oid = poa->activate_object(ec_impl.in());
CORBA::Object_var ec_obj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in());
// Find the Naming Service.
object = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(object.in());
CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a SupplierAdmin object from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
// Get a ProxyPushConsumer from the SupplierAdmin.
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
PortableServer::Servant_var<EchoEventSupplier_i> servant =
new EchoEventSupplier_i(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(servant.in());
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Publish the events the supplier provides.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, // Supplier's unique id
MY_EVENT_TYPE, // Event type
0, // handle to the rt_info structure
1); // number of calls
// Connect as a supplier of the published events.
consumer->connect_push_supplier (supplier.in (),
qos.get_SupplierQOS ());
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
event[0].data.any_value <<= eventData;
PortableServer::Servant_var<TAO_EC_Gateway_IIOP> gateway =
new TAO_EC_Gateway_IIOP;
int gateway_initialized = 0;
std::cout << "Supplier starting sending of events.\n";
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
if ((remote_ecname != 0) && (!gateway_initialized)) {
try {
// Get the remote event channel object
CORBA::Object_var obj = root_context->resolve_str (ACE_TEXT_ALWAYS_CHAR (remote_ecname));
RtecEventChannelAdmin::EventChannel_var remote_ec =
RtecEventChannelAdmin::EventChannel::_narrow(obj.in());
int ok = 0;
if (!CORBA::is_nil(remote_ec.in())) {
// Now check if we can talk to it...
try {
RtecEventChannelAdmin::SupplierAdmin_var adm =
remote_ec->for_suppliers();
ok = 1;
} catch(const CORBA::UserException&) {
// What is the correct exception(s) to catch here?
}
}
// There is a good remote event channel so initialize the
// gateway.
if (ok) {
gateway->init(remote_ec.in(), ec.in());
PortableServer::ObjectId_var gateway_oid =
poa->activate_object(gateway.in());
CORBA::Object_var gateway_obj =
poa->id_to_reference(gateway_oid.in());
RtecEventChannelAdmin::Observer_var obs =
RtecEventChannelAdmin::Observer::_narrow(gateway_obj.in());
RtecEventChannelAdmin::Observer_Handle local_ec_obs_handle =
ec->append_observer (obs.in ());
ACE_UNUSED_ARG (local_ec_obs_handle);
gateway_initialized = 1;
std::cout << "Gateway initialized\n";
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
}
} catch(const CosNaming::NamingContext::NotFound&) {
// Try again later...
}
}
}
orb->destroy();
return 0;
}
catch(const CORBA::Exception& exc)
{
std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl;
}
return 1;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
if (CORBA::is_nil(naming_obj.in())) {
std::cerr << "Unable to find naming service" << std::endl;
return 1;
}
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow(naming_obj.in());
CosNaming::Name name(1);
name.length (1);
name[0].id = CORBA::string_dup("NotifyEventChannelFactory");
CORBA::Object_var obj = naming_context->resolve(name);
CosNotifyChannelAdmin::EventChannelFactory_var notify_factory =
CosNotifyChannelAdmin::EventChannelFactory::_narrow(obj.in());
if (CORBA::is_nil(notify_factory.in())) {
std::cerr << "Unable to find notify factory" << std::endl;
return 1;
}
name.length (1);
name[0].id = CORBA::string_dup("MyEventChannel");
CORBA::Object_var ecObj = naming_context->resolve(name);
CosNotifyChannelAdmin::EventChannel_var ec =
CosNotifyChannelAdmin::EventChannel::_narrow(ecObj.in());
if (CORBA::is_nil (ec.in())) {
std::cerr << "Unable to find event channel" << std::endl;
return 1;
}
CosNotifyChannelAdmin::AdminID adminid;
CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
CosNotifyChannelAdmin::AND_OP;
CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->new_for_consumers(ifgop,
adminid);
if (CORBA::is_nil (consumer_admin.in())) {
std::cerr << "Unable to find consumer admin" << std::endl;
return 1;
}
CosNotifyFilter::FilterFactory_var ffact =
ec->default_filter_factory ();
// setup a filter at the consumer admin
CosNotifyFilter::Filter_var ca_filter =
ffact->create_filter (TCL_GRAMMAR);
if (CORBA::is_nil (ca_filter.in())) {
std::cerr << "Unable to create filetr object" << std::endl;
return 1;
}
CosNotifyFilter::ConstraintExpSeq constraint_list (1);
constraint_list.length (1);
constraint_list[0].event_types.length (0);
constraint_list[0].constraint_expr = CORBA::string_dup (CA_FILTER);
ca_filter->add_constraints (constraint_list);
consumer_admin ->add_filter (ca_filter.in());
CosNotification::EventTypeSeq added(1);
CosNotification::EventTypeSeq removed (0);
added.length (1);
removed.length (0);
added[0].domain_name = CORBA::string_dup ("*");
added[0].type_name = CORBA::string_dup ("*");
consumer_admin->subscription_change (added, removed);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in())) {
std::cerr << "Unable to initialize the POA." << std::endl;
return 1;
}
PortableServer::POA_var poa =
PortableServer::POA::_narrow(poa_object.in());
PortableServer::Servant_var<StructuredEventConsumer_i> servant =
new StructuredEventConsumer_i(orb.in());
/*
CosNotifyComm::StructuredPushConsumer_var consumer =
servant->_this();
*/
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
CORBA::Object_var consumer_obj = poa->id_to_reference(oid.in());
CosNotifyComm::StructuredPushConsumer_var consumer =
CosNotifyComm::StructuredPushConsumer::_narrow(consumer_obj.in());
CosNotifyChannelAdmin::ProxyID consumeradmin_proxy_id;
CosNotifyChannelAdmin::ProxySupplier_var proxy_supplier =
consumer_admin->obtain_notification_push_supplier(
CosNotifyChannelAdmin::STRUCTURED_EVENT,
consumeradmin_proxy_id);
// The proxy that we are connected to.
CosNotifyChannelAdmin::StructuredProxyPushSupplier_var supplier_proxy;
supplier_proxy = CosNotifyChannelAdmin::StructuredProxyPushSupplier::
_narrow(proxy_supplier.in());
if (CORBA::is_nil (supplier_proxy.in())) {
std::cerr << "Unable to create structured push supplier proxy" << std::endl;
return 1;
}
supplier_proxy->connect_structured_push_consumer(consumer.in());
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();
orb->run();
orb->destroy ();
}
catch(const CORBA::Exception& ex) {
std::cerr << ex << std::endl;
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;
}
// Create a bidirectional POA
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();
// Policies for the childPOA to be created.
CORBA::PolicyList policies(1);
policies.length(1);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, pol);
// Create POA as child of RootPOA with the above policies. This POA
// will receive request in the same connection in which it sent
// the request
PortableServer::POA_var poa = root_poa->create_POA("bidirPOA", poa_manager.in(), policies);
// Creation of bidirPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0; i < policies.length (); ++i) {
policies[i]->destroy ();
}
poa_manager->activate ();
PortableServer::Servant_var<Simple_i> svt = new Simple_i(orb.in(), callback_count);
// Register and activate Simple servant
PortableServer::ObjectId_var id = poa->activate_object(svt.in());
obj = poa->id_to_reference(id.in());
Simple_var server = Simple::_narrow(obj.in());
CORBA::String_var ior = orb->object_to_string(server.in());
if (ior_output_file != ACE_TEXT("")) {
std::ofstream outfile(ACE_TEXT_ALWAYS_CHAR(ior_output_file.c_str()));
outfile << ior.in();
}
std::cout << "Activated as " << ior.in() << std::endl;
// Our own special orb->run() that knows how to callback clients
while (true) {
// returns 1 as soon as it has successfully called back.
if (svt->call_client()) {
break;
}
// We don't want to check for work pending, because we really want
// to simulate a normal orb->run() while adding the ability to call
// our routine which calls back to the client.
orb->perform_work();
}
std::cout << "Event loop finished." << std::endl;
CORBA::Boolean etherealize = true, wait = true;
poa->destroy(etherealize, wait);
orb->destroy();
return 0;
}
catch(const CORBA::Exception& ex) {
std::cerr << "Caught CORBA::Exception: " << std::endl << ex << std::endl;
}
return 1;
}
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("NameService");
CosNaming::NamingContextExt_var naming_context =
CosNaming::NamingContextExt::_narrow(obj.in());
obj = naming_context->resolve_str("MyEventChannel");
CosNotifyChannelAdmin::EventChannel_var ec =
CosNotifyChannelAdmin::EventChannel::_narrow(obj.in());
CosNotifyChannelAdmin::AdminID adminid;
CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
CosNotifyChannelAdmin::AND_OP;
CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->new_for_consumers(ifgop,
adminid);
obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (obj.in());
PortableServer::Servant_var<EventSequenceConsumer_i> servant =
new EventSequenceConsumer_i(orb.in());
PortableServer::ObjectId_var objectId = poa->activate_object(servant.in());
obj = poa->id_to_reference (objectId.in());
CosNotifyComm::SequencePushConsumer_var consumer =
CosNotifyComm::SequencePushConsumer::_narrow(obj.in());
CosNotifyChannelAdmin::ProxyID consumeradmin_proxy_id;
CosNotifyChannelAdmin::ProxySupplier_var proxy_supplier =
consumer_admin->obtain_notification_push_supplier(
CosNotifyChannelAdmin::SEQUENCE_EVENT,
consumeradmin_proxy_id);
CosNotifyChannelAdmin::SequenceProxyPushSupplier_var supplier_proxy =
CosNotifyChannelAdmin::SequenceProxyPushSupplier::_narrow(proxy_supplier.in());
supplier_proxy->connect_sequence_push_consumer(consumer.in());
CosNotification::EventTypeSeq added (1);
CosNotification::EventTypeSeq removed (1);
added.length (1);
removed.length (1);
added[0].domain_name = CORBA::string_dup ("OCI_TAO");
added[0].type_name = CORBA::string_dup ("examples");
removed[0].domain_name = CORBA::string_dup ("*");
removed[0].type_name = CORBA::string_dup ("*");
supplier_proxy->subscription_change(added, removed);
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();
orb->run();
orb->destroy();
return 0;
}
catch(const CORBA::Exception& ex)
{
std::cerr << "Caught exception: " << ex << std::endl;
}
return 1;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(obj.in());
// Find the EchoEventChannel.
obj = root_context->resolve_str("CosEventService");
// Downcast the object reference to an EventChannel reference.
CosEventChannelAdmin::EventChannel_var echoEC =
CosEventChannelAdmin::EventChannel::_narrow(obj.in());
if (CORBA::is_nil(echoEC.in())) {
std::cerr << "Could not narrow EchoEventChannel." << std::endl;
return 1;
}
std::cout << "Found the EchoEventChannel." << std::endl;
// Get a ConsumerAdmin object from the EventChannel.
CosEventChannelAdmin::ConsumerAdmin_var consumerAdmin =
echoEC->for_consumers();
// Get a ProxyPushSupplier from the ConsumerAdmin.
CosEventChannelAdmin::ProxyPushSupplier_var supplier =
consumerAdmin->obtain_push_supplier();
// Instantiate an EchoEventConsumer_i servant.
PortableServer::Servant_var<EchoEventConsumer_i> servant =
new EchoEventConsumer_i(orb.in(), supplier.in(), EVENTS_TILL_SHUTDOWN);
// Register it with the RootPOA.
obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
CORBA::Object_var consumer_obj = poa->id_to_reference(oid.in());
CosEventComm::PushConsumer_var consumer =
CosEventComm::PushConsumer::_narrow(consumer_obj.in());
// Connect to the ProxyPushSupplier, passing our PushConsumer object
// reference to it.
supplier->connect_push_consumer(consumer.in());
// Activate the POA via its POAManager.
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();
std::cout << "Ready to receive events..." << std::endl;
// Enter the ORB event loop.
orb->run();
// If we have reached this, we must be shutting down...
orb->destroy();
std::cout << "Test complete." << std::endl;
return 0;
}
catch(const CORBA::Exception& ex)
{
std::cerr << "Consumer: Caught CORBA::Exception: " << ex << std::endl;
}
return 1;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv [])
{
// since this file is disabled by default, I guess
DANCE_DISABLE_TRACE ();
DANCE_TRACE ("ACE_TMAIN");
int retval = 0;
try
{
DAnCE::Logger_Service
* dlf = ACE_Dynamic_Service<DAnCE::Logger_Service>::instance ("DAnCE_Logger");
if (dlf)
{
dlf->init (argc, argv);
}
DAnCE::InstallationRepositoryManagerSvc
* dirms = ACE_Dynamic_Service<DAnCE::InstallationRepositoryManagerSvc>::instance ("InstallationRepositoryManager");
if (dirms)
{
dirms->init (argc, argv);
}
DAnCE::ArtifactInstallationHandlerSvc
* dfihs = ACE_Dynamic_Service<DAnCE::ArtifactInstallationHandlerSvc>::instance ("FileInstallationHandler");
if (dfihs)
{
dfihs->init (argc, argv);
}
DAnCE::ArtifactInstallationHandlerSvc
* dhihs = ACE_Dynamic_Service<DAnCE::ArtifactInstallationHandlerSvc>::instance ("HttpInstallationHandler");
if (dhihs)
{
dhihs->init (argc, argv);
}
DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_TRACE, DLINFO
ACE_TEXT("dance_artifact_installation - initializing ORB\n")));
// Need an ORB for the Config handlers
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (!parse_args (argc, argv))
{
return -1;
}
auto_ptr<Deployment::DeploymentPlan> plan;
if (!cdr_encoded_)
{
plan.reset (DAnCE::Convert_Plan::read_xml_plan (input_filename));
}
else
{
plan.reset (DAnCE::Convert_Plan::read_cdr_plan (input_filename));
}
if (plan.get () == 0)
{
DANCE_ERROR_RETURN (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR, DLINFO ACE_TEXT ("dance_artifact_installation - ")
ACE_TEXT ("Unable to convert provided plan into IDL representation\n"))
// @will changed this to use DANCE_ERROR_RETURN and am still
// returning 0 rather than a real error code
, 0);
}
// instantiate artifact installation service
DAnCE::ArtifactInstallation_Impl* installer = 0;
ACE_NEW_RETURN (installer,
DAnCE::ArtifactInstallation_Impl (),
1);
PortableServer::Servant_var<DAnCE::ArtifactInstallation_Impl> pinstaller (installer);
pinstaller->initialize ();
// install artifacts
for (CORBA::ULong i=0;
i < plan->artifact.length ();
++i)
{
pinstaller->install(plan->UUID.in (),
plan->artifact[i]);
}
pinstaller->clear ();
}
catch (const CORBA::Exception &ex)
{
// @will I'm not as familiar with CORBA exceptions, but this appears
// to take control out of our hands for error logging
// this file doesn't seem to be included in default projects
// is this even an issue?
ex._tao_print_exception ("dance_artifact_installation");
retval = 1;
}
catch (...)
{
DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR,
(LM_ERROR,
"dance_artifact_installation - error: unknown c++ exception\n"));
retval = 1;
}
return retval;
}
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_NONE;
CORBA::PolicyList policies(1); policies.length (1);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
if (parse_args (argc, argv) != 0)
return 1;
PortableServer::Servant_var<Echo_Caller> impl;
{
Echo_Caller * 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_Caller(orb.in()),
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_Caller_var server =
Test::Echo_Caller::_narrow (object_act.in ());
CORBA::String_var ior =
orb->object_to_string (server.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 in server:");
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())) {
std::cerr << "Unable to initialize the POA." << std::endl;
return 1;
}
PortableServer::POA_var poa =
PortableServer::POA::_narrow(poa_object.in());
// Activate POA manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
if (CORBA::is_nil(naming_obj.in())) {
std::cerr << "Unable to find naming service" << std::endl;
return 1;
}
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow(naming_obj.in());
CosNaming::Name name(1);
name.length (1);
name[0].id = CORBA::string_dup("MyEventChannel");
CORBA::Object_var ecObj = naming_context->resolve(name);
CosNotifyChannelAdmin::EventChannel_var ec =
CosNotifyChannelAdmin::EventChannel::_narrow(ecObj.in());
if (CORBA::is_nil (ec.in())) {
std::cerr << "Unable to find event channel" << std::endl;
return 1;
}
CosNotifyChannelAdmin::AdminID adminid;
CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
CosNotifyChannelAdmin::AND_OP;
CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->new_for_consumers(ifgop,
adminid);
if (CORBA::is_nil (consumer_admin.in())) {
std::cerr << "Unable to find consumer admin" << std::endl;
return 1;
}
PortableServer::Servant_var<StructuredEventConsumer_i> servant =
new StructuredEventConsumer_i(orb.in());
CosNotifyComm::StructuredPushConsumer_var consumer = servant->_this();
CosNotifyChannelAdmin::ProxyID consumeradmin_proxy_id;
CosNotifyChannelAdmin::ProxySupplier_var proxy_supplier =
consumer_admin->obtain_notification_push_supplier(
CosNotifyChannelAdmin::STRUCTURED_EVENT,
consumeradmin_proxy_id);
// The proxy that we are connected to.
CosNotifyChannelAdmin::StructuredProxyPushSupplier_var supplier_proxy;
supplier_proxy = CosNotifyChannelAdmin::StructuredProxyPushSupplier::
_narrow(proxy_supplier.in());
if (CORBA::is_nil (supplier_proxy.in())) {
std::cerr << "Unable to create structured push supplier proxy" << std::endl;
return 1;
}
supplier_proxy->connect_structured_push_consumer(consumer.in());
CosNotification::EventTypeSeq added (1);
CosNotification::EventTypeSeq removed (1);
added.length (1);
removed.length (1);
added[0].domain_name = CORBA::string_dup ("OCI_TAO");
added[0].type_name = CORBA::string_dup ("examples");
removed[0].domain_name = CORBA::string_dup ("*");
removed[0].type_name = CORBA::string_dup ("*");
supplier_proxy->subscription_change(added, removed);
orb->run();
}
catch(const CORBA::Exception& ex)
{
std::cerr << "MessengerConsumer:: Caught exception: " << ex << std::endl;
return 1;
}
std::cerr << "MessengerConsumer: success" << std::endl;
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow(naming_obj.in());
CosNaming::Name name;
name.length (1);
name[0].id = CORBA::string_dup("MyEventChannel");
CORBA::Object_var ecObj = naming_context->resolve(name);
CosNotifyChannelAdmin::EventChannel_var ec =
CosNotifyChannelAdmin::EventChannel::_narrow(ecObj.in());
CosNotifyChannelAdmin::AdminID adminid;
CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
CosNotifyChannelAdmin::AND_OP;
CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->new_for_consumers(ifgop,
adminid);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in());
CORBA::Object_var rtorb_obj = orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (rtorb_obj.in ());
// Create an RT POA with a lane at the given priority.
CORBA::Policy_var priority_model_policy =
rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
DEFAULT_PRIORITY);
RTCORBA::ThreadpoolLanes lanes (2);
lanes.length (2);
lanes[0].lane_priority = LOW_PRIORITY;
lanes[0].static_threads = 2;
lanes[0].dynamic_threads = 0;
lanes[1].lane_priority = HIGH_PRIORITY;
lanes[1].static_threads = 2;
lanes[1].dynamic_threads = 0;
// Create a thread-pool.
CORBA::ULong stacksize = 0;
CORBA::Boolean allow_request_buffering = 0;
CORBA::ULong max_buffered_requests = 0;
CORBA::ULong max_request_buffer_size = 0;
CORBA::Boolean allow_borrowing = 0;
// Create the thread-pool.
RTCORBA::ThreadpoolId threadpool_id =
rt_orb->create_threadpool_with_lanes (stacksize,
lanes,
allow_borrowing,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
// Create a thread-pool policy.
CORBA::Policy_var lanes_policy =
rt_orb->create_threadpool_policy (threadpool_id);
CORBA::PolicyList poa_policy_list(2);
poa_policy_list.length (2);
poa_policy_list[0] = priority_model_policy;
poa_policy_list[1] = lanes_policy;
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
PortableServer::POA_var rt_poa = poa->create_POA ("RT POA",
poa_manager.in (),
poa_policy_list);
PortableServer::Servant_var<StructuredEventConsumer_i> servant =
new StructuredEventConsumer_i(orb.in());
PortableServer::ObjectId_var objectId =
rt_poa->activate_object (servant.in());
CORBA::Object_var consumer_obj =
rt_poa->id_to_reference (objectId.in ());
CosNotifyComm::StructuredPushConsumer_var consumer =
CosNotifyComm::StructuredPushConsumer::_narrow (consumer_obj.in ());
NotifyExt::ThreadPoolLanesParams tpl_params;
tpl_params.priority_model = NotifyExt::CLIENT_PROPAGATED;
tpl_params.server_priority = DEFAULT_PRIORITY;
tpl_params.stacksize = 0;
tpl_params.allow_borrowing = 0;
tpl_params.allow_request_buffering = 0;
tpl_params.max_buffered_requests = 0;
tpl_params.max_request_buffer_size = 0;
tpl_params.lanes.length (2);
tpl_params.lanes[0].lane_priority = LOW_PRIORITY;
tpl_params.lanes[0].static_threads = 2;
tpl_params.lanes[0].dynamic_threads = 0;
tpl_params.lanes[1].lane_priority = HIGH_PRIORITY;
tpl_params.lanes[1].static_threads = 2;
tpl_params.lanes[1].dynamic_threads = 0;
CosNotification::QoSProperties qos;
qos.length(1);
qos[0].name = CORBA::string_dup (NotifyExt::ThreadPoolLanes);
qos[0].value <<= tpl_params;
consumer_admin->set_qos(qos);
CORBA::Object_var current_obj =
orb->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (current_obj.in ());
current->the_priority(HIGH_PRIORITY);
CosNotifyChannelAdmin::ProxyID consumeradmin_proxy_id;
CosNotifyChannelAdmin::ProxySupplier_var proxy_supplier =
consumer_admin->obtain_notification_push_supplier(
CosNotifyChannelAdmin::STRUCTURED_EVENT,
consumeradmin_proxy_id);
CosNotifyChannelAdmin::StructuredProxyPushSupplier_var supplier_proxy;
supplier_proxy = CosNotifyChannelAdmin::StructuredProxyPushSupplier::
_narrow(proxy_supplier.in());
supplier_proxy->connect_structured_push_consumer(consumer.in());
CosNotification::EventTypeSeq added (1);
CosNotification::EventTypeSeq removed (1);
added.length (1);
removed.length (1);
added[0].domain_name = CORBA::string_dup ("OCI_TAO");
added[0].type_name = CORBA::string_dup ("examples");
removed[0].domain_name = CORBA::string_dup ("*");
removed[0].type_name = CORBA::string_dup ("*");
supplier_proxy->subscription_change(added, removed);
poa_manager->activate();
// Write a file to let the run_test.pl script know we are ready.
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(output_file) );
iorFile << "Ready" << std::endl;
iorFile.close();
orb->run();
}
catch(const CORBA::Exception& ex)
{
std::cerr << "Caught exception: " << ex << std::endl;
return 1;
}
return 0;
}