Esempio n. 1
0
CosNotifyChannelAdmin::AdminID
IdAssignment::create_supplier_admin (CosNotifyChannelAdmin::ChannelID channel_id)
{
  CosNotifyChannelAdmin::AdminID adminid;
  CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
    CosNotifyChannelAdmin::OR_OP;

  CosNotifyChannelAdmin::EventChannel_var ec =
    this->notify_factory_->get_event_channel (channel_id);


  if (CORBA::is_nil (ec.in ()))
    {
      ACE_ERROR((LM_ERROR,
                 " (%P|%t) Unable to find event channel\n"));
      return 0;
    }

  CosNotifyChannelAdmin::SupplierAdmin_var supplier_admin =
    ec->new_for_suppliers (ifgop,
                           adminid);

  if (CORBA::is_nil (supplier_admin.in ()))
    ACE_ERROR_RETURN ((LM_ERROR,
                       " (%P|%t) Unable to create supplier admin\n"),0);

  if (TAO_debug_level)
    ACE_DEBUG ((LM_DEBUG,
                "created supplier admin\n"));

  return adminid;
}
Esempio n. 2
0
void
TAO_Notify_Lanes_Supplier_Client::initialize (void)
{
  PortableServer::POAManager_var poa_manager =
    this->orb_objects_.root_poa_->the_POAManager ();

  poa_manager->activate ();

  CosNotifyChannelAdmin::EventChannel_var ec = this->create_ec ();

  // Create a Supplier Admin
  CosNotifyChannelAdmin::AdminID adminid = 0;

  CosNotifyChannelAdmin::SupplierAdmin_var supplier_admin =
    ec->new_for_suppliers (CosNotifyChannelAdmin::AND_OP, adminid);

  ACE_ASSERT (!CORBA::is_nil (supplier_admin.in ()));

  // Create a Supplier
  this->supplier_ = new TAO_Notify_Lanes_Supplier (this->orb_objects_);

  // Initialize it.
  this->supplier_->init (supplier_admin, this->consumer_count_);
}
Esempio n. 3
0
int ACE_TMAIN(int argc, ACE_TCHAR * argv[])
{
  try
  {
     CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
     CORBA::Object_var rootObj = orb->resolve_initial_references("NameService");
     CosNaming::NamingContext_var rootNC =
       CosNaming::NamingContext::_narrow(rootObj.in());

     // 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 Event Channel factory.
     CosNotifyChannelAdmin::EventChannelFactory_var notify_factory =
       TAO_Notify_EventChannelFactory_i::create(poa.in());
     ACE_ASSERT (!CORBA::is_nil (notify_factory.in ()));

     // Create an Event Channel.
     CosNotifyChannelAdmin::ChannelID id;
     CosNotification::QoSProperties initial_qos;
     CosNotification::AdminProperties initial_admin;
     CosNotifyChannelAdmin::EventChannel_var ec =
       notify_factory->create_channel (initial_qos, initial_admin, id);

     // Bind it in the Naming Service.
     CosNaming::Name name(1);
     name.length(1);
     name[0].id = CORBA::string_dup("MyEventChannel");
     rootNC->rebind(name, ec.in());

     // Become a structured push supplier.
     CosNotifyChannelAdmin::AdminID adminid;
     CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
       CosNotifyChannelAdmin::AND_OP;
     CosNotifyChannelAdmin::SupplierAdmin_var supplier_admin =
       ec->new_for_suppliers (ifgop, adminid);

     CosNotifyChannelAdmin::ProxyID supplieradmin_proxy_id;
     CosNotifyChannelAdmin::ProxyConsumer_var proxy_consumer =
     supplier_admin->obtain_notification_push_consumer(
       CosNotifyChannelAdmin::STRUCTURED_EVENT,
       supplieradmin_proxy_id);

     StructuredEventSupplier_i *servant =
       new StructuredEventSupplier_i(orb.in());
     CosNotifyComm::StructuredPushSupplier_var supplier = servant->_this();

     CosNotifyChannelAdmin::StructuredProxyPushConsumer_var consumer_proxy =
       CosNotifyChannelAdmin::StructuredProxyPushConsumer::_narrow(
         proxy_consumer.in());
     consumer_proxy->connect_structured_push_supplier(supplier.in());

     // Set up events to push.
     CosNotification::StructuredEvent event;
     event.header.fixed_header.event_type.domain_name =
     CORBA::string_dup("OCI_TAO");

    event.header.fixed_header.event_type.type_name =
      CORBA::string_dup("examples");
    event.header.fixed_header.event_name = CORBA::string_dup("myevent");
    event.filterable_data.length (1);
    event.filterable_data[0].name = CORBA::string_dup("Message from:");
    event.filterable_data[0].value <<= (const char *)user_name;
    event.filterable_data.length (2);
    event.filterable_data[1].name = CORBA::string_dup("Subject:");
    event.filterable_data[1].value <<= (const char *)subject;
    event.filterable_data.length (3);
    event.filterable_data[2].name = CORBA::string_dup("Message:");
    event.filterable_data[2].value <<= (const char *)message;

    // Push events.
    while (1) {
      std::cout << "pushing " << std::endl;
      consumer_proxy->push_structured_event (event);
      ACE_OS::sleep (1);
    }
  }
  catch(const CORBA::Exception& ex) {
    return 1;
  }

  return 0;
}
Esempio n. 4
0
Messenger_i::Messenger_i (CORBA::ORB_ptr orb)
  : orb_ (CORBA::ORB::_duplicate (orb))
{

  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 ("NotifyEventChannelFactory");

  CORBA::Object_var obj = naming_context->resolve (name);

  CosNotifyChannelAdmin::EventChannelFactory_var notify_factory =
    CosNotifyChannelAdmin::EventChannelFactory::_narrow (obj.in ());

  CosNotifyChannelAdmin::ChannelID id;
  CosNotification::QoSProperties initial_qos;
  CosNotification::AdminProperties initial_admin;

  CosNotifyChannelAdmin::EventChannel_var ec =
    notify_factory->create_channel (initial_qos,
                                    initial_admin,
                                    id);

  name[0].id = CORBA::string_dup ("MyEventChannel");

  naming_context->rebind (name, ec.in());

  CosNotifyChannelAdmin::AdminID adminid;
  CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
    CosNotifyChannelAdmin::OR_OP;

  CosNotifyChannelAdmin::SupplierAdmin_var supplier_admin =
    ec->new_for_suppliers (ifgop, adminid);

  CosNotifyChannelAdmin::ProxyID supplieradmin_proxy_id;

  CosNotifyChannelAdmin::ProxyConsumer_var proxy_consumer =
    supplier_admin->obtain_notification_push_consumer(
                                 CosNotifyChannelAdmin::STRUCTURED_EVENT,
                                 supplieradmin_proxy_id);

  StructuredEventSupplier_i *servant =
    new StructuredEventSupplier_i(orb_.in());

  CORBA::Object_var poa_obj = orb_->resolve_initial_references ("RootPOA");
  PortableServer::POA_var poa = PortableServer::POA::_narrow (poa_obj.in ());
  PortableServer::POAManager_var mgr = poa->the_POAManager ();

  mgr->activate ();
  PortableServer::ObjectId_var objectId = poa->activate_object (servant);

  CORBA::Object_var supplier_obj = poa->id_to_reference (objectId.in ());

  CosNotifyComm::StructuredPushSupplier_var supplier =
    CosNotifyComm::StructuredPushSupplier::_narrow (supplier_obj.in ());

  consumer_proxy_ =
    CosNotifyChannelAdmin::StructuredProxyPushConsumer::_narrow (proxy_consumer.in());

  consumer_proxy_->
    connect_structured_push_supplier (supplier.in());
}
Esempio n. 5
0
int main(int argc, char* argv[]) {

  char aux1[1000];
  time_t seconds;

  signal(SIGINT, TerminarEjecucion);

  time(&seconds);
  srand((unsigned int) seconds);

  try {

    // Inicializacion del ORB 
    CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "");

    // Recoge la referencia al canal
    cin >> aux1;   
    CORBA::Object_var obj = orb->string_to_object(aux1);

    // Obtiene el canal
    CosNotifyChannelAdmin::EventChannel_var channel;
    channel = CosNotifyChannelAdmin::EventChannel::_narrow(obj);
    if (CORBA::is_nil(channel)) { 
      cerr << "[supplier2] ERROR: canal nulo " << endl;
      return -1; 
    } 

    // Obtiene el SupplierAdmin
    CosNotifyChannelAdmin::AdminID id;
    _supplier_admin = 
      channel->new_for_suppliers(CosNotifyChannelAdmin::AND_OP, id);
    cerr << "[supplier2] SupplierAdminId = " << id << endl;


    CosNotifyChannelAdmin::ProxyID proxy_id;
    CosNotifyChannelAdmin::ProxyConsumer_var proxy_consumer = 
      _supplier_admin->obtain_notification_push_consumer(
                                          CosNotifyChannelAdmin::STRUCTURED_EVENT,
                                          proxy_id);
    cerr << "[supplier2] ProxyId = " << proxy_id << endl;


    // Obtiene el StructuredProxyPushConsumer
    _consumer = 
      CosNotifyChannelAdmin::StructuredProxyPushConsumer::_narrow(proxy_consumer);

    try{
      CosNotifyComm::StructuredPushSupplier_var supplier = 
        CosNotifyComm::StructuredPushSupplier::_nil();
      _consumer->connect_structured_push_supplier(supplier);
      if (_consumer == NULL)  cerr << "[supplier2] consumer NULO 5" << endl;

    } catch (CORBA::Exception& exc) {
      cerr << "[supplier2] Exception in _consumer->connect_push_supplier(...)";
      cerr << exc << endl;
    } catch (...) {
      cerr << "[supplier2] Unknowed exception ";
      cerr << "in _consumer->connect_push_supplier(...)";
    }



#ifdef _TAO
    sleep(1);
#elif defined _TIDORB
    TIDThr::Thread::sleep(1000); // 1 ''
#endif

    cerr << "[supplier2] Crea un structured event" << flush << endl;

    try{
        
      CosNotification::StructuredEvent* event = NULL;
      int rnd = 0;
        
      for(int i=0; i < 200; i++) {

        rnd = rand();

        TimeBase::UtcT current_utc = TIDorb::core::util::Time::currentUtcT();
        TimeBase::UtcT future_utc  = TIDorb::core::util::Time::currentUtcT();
        TimeBase::UtcT pass_utc    = TIDorb::core::util::Time::currentUtcT();
        future_utc.time += (5 * 10000000); // now + 5 ''
        pass_utc.time   -= (5 * 10000000); // now - 5 ''



        // Rellenamos la informacion del evento   
        event = new CosNotification::StructuredEvent();
        event->header.fixed_header.event_name = 
          (rnd % 2) ? CORBA::string_dup("event_name") : CORBA::string_dup("other");
        event->header.fixed_header.event_type.domain_name = 
          (rnd % 2) ? CORBA::string_dup("domain_name") : CORBA::string_dup("other");
        event->header.fixed_header.event_type.type_name  = 
          (rnd % 2) ? CORBA::string_dup("type_name") : CORBA::string_dup("other");

        event->header.variable_header.length(5); 
        event->header.variable_header[0].name = CORBA::string_dup("EventReliability");
        event->header.variable_header[0].value <<= (CORBA::Short) 0;
        event->header.variable_header[1].name = CORBA::string_dup("Priority");
        event->header.variable_header[1].value <<= (CORBA::Short) 0;
        event->header.variable_header[2].name = CORBA::string_dup("StartTime");
        event->header.variable_header[2].value <<= current_utc;
        event->header.variable_header[3].name = CORBA::string_dup("StopTime");
        event->header.variable_header[3].value <<= pass_utc;
        event->header.variable_header[4].name = CORBA::string_dup("Timeout");
        event->header.variable_header[4].value <<= (TimeBase::TimeT) 0;

        event->filterable_data.length(2);
        event->filterable_data[0].name = CORBA::string_dup("int");
        event->filterable_data[0].value <<= ( rnd * 1000 ) ;
        event->filterable_data[1].name = CORBA::string_dup("string");
        event->filterable_data[1].value <<= ( (rnd % 2) ? 
                                              (const char*)"greater" : 
                                              (const char*)"smaller" );
        event->remainder_of_body <<= (const char*) "remainder_of_body";
        CORBA::Long my_long;
        event->filterable_data[0].value >>= my_long;


        cout << "Enviando mensage " << my_long;
        cout << ": " << event->header.fixed_header.event_type.domain_name << ", ";
        cout << event->header.fixed_header.event_type.type_name << endl; 
          
          
        // Envia el evento
        _consumer->push_structured_event(*event);


        delete event;
        event = NULL;
      } // for
      
      cerr << "[supplier2] Desconectando... " << flush << endl;
      _consumer->disconnect_structured_push_consumer();      

    } catch(...){
      cerr << "[supplier2] Excepcion " << endl;
    }
    _supplier_admin->destroy();    

    cerr << "[supplier2] Terminando" << flush << endl;
    orb->shutdown(true);
    orb->destroy();


  } catch(CORBA::Exception& exc) {
    cerr << "[supplier2] Excepcion: " << exc << endl;
    return 1;
  }

}
Esempio n. 6
0
Messenger_i::Messenger_i (CORBA::ORB_ptr orb)
              : orb_(CORBA::ORB::_duplicate(orb))
{
  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;
  }

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

  CosNaming::NamingContext_var naming_context =
    CosNaming::NamingContext::_narrow(naming_obj.in());

  CosNaming::Name name;
  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;
  }

  CosNotifyChannelAdmin::ChannelID id;
  CosNotification::QoSProperties initial_qos;
  CosNotification::AdminProperties initial_admin;

  CosNotifyChannelAdmin::EventChannel_var ec =
    notify_factory->create_channel (initial_qos,
            initial_admin,
            id);

  if (CORBA::is_nil (ec.in())) {
    std::cerr << "Unable to crete event channel" << std::endl;
  }

  // name.length(1);
  name[0].id = CORBA::string_dup("MyEventChannel");

  naming_context->rebind(name, ec.in());

  CosNotifyChannelAdmin::AdminID adminid;
  CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
    CosNotifyChannelAdmin::AND_OP;

  CosNotifyChannelAdmin::SupplierAdmin_var supplier_admin =
    ec->new_for_suppliers (ifgop, adminid);

  if (CORBA::is_nil (supplier_admin.in())) {
    std::cerr << "Unable to find supplier admin" << std::endl;
  }

  CosNotifyChannelAdmin::ProxyID supplieradmin_proxy_id;

  CosNotifyChannelAdmin::ProxyConsumer_var proxy_consumer =
    supplier_admin->obtain_notification_push_consumer(
         CosNotifyChannelAdmin::STRUCTURED_EVENT,
         supplieradmin_proxy_id);

  StructuredEventSupplier_i *servant =
    new StructuredEventSupplier_i(orb_.in());

  CosNotifyComm::StructuredPushSupplier_var supplier =
    servant->_this();

  s_proxy_consumer_ =
  CosNotifyChannelAdmin::StructuredProxyPushConsumer::
    _narrow(proxy_consumer.in());

  if (CORBA::is_nil (s_proxy_consumer_.in())) {
    std::cerr << "Unable to find structured proxy push consumer" << std::endl;
  }

  s_proxy_consumer_->
    connect_structured_push_supplier(supplier.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 ("*");

  s_proxy_consumer_->offer_change(added, removed);
}
int main(int argc, char * argv[])
{
  CORBA::Object_var obj;

  //----------------------------------------------------------------------------
  // initialize ORB

  CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);

  //----------------------------------------------------------------------------
  // initialize POA

  obj = orb->resolve_initial_references("RootPOA");
  assert(!CORBA::is_nil(obj));
  PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj);
  PortableServer::POAManager_var poa_manager = root_poa->the_POAManager();
  poa_manager->activate();

  //----------------------------------------------------------------------------
  // get naming service reference

  obj = orb->resolve_initial_references("NameService");
  assert(!CORBA::is_nil(obj));
  CosNaming::NamingContext_var naming_service =
    CosNaming::NamingContext::_narrow(obj);

  //----------------------------------------------------------------------------
  // get event channel reference

  // resolving name in robots naming context
  assert(argc >= 2);
  std::string naming_context = argv[1];

  CosNaming::Name name;
  name.length(2);
  name[0].id = naming_context.c_str();
  name[1].id = string("NotifyEventChannel").c_str();

  obj = naming_service->resolve(name);

  // The event channel
  CosNotifyChannelAdmin::EventChannel_var ec =
    CosNotifyChannelAdmin::EventChannel::_narrow(obj);

  //----------------------------------------------------------------------------
  // creating a notification service supplier admin

  // The group operator between admin-proxy's.
  CosNotifyChannelAdmin::InterFilterGroupOperator ifgop = 
    CosNotifyChannelAdmin::OR_OP;
  // The id of the created adin.
  CosNotifyChannelAdmin::AdminID admin_id;
  // The supplier admin used by supplier.
  CosNotifyChannelAdmin::SupplierAdmin_var supplier_admin;

  supplier_admin = ec->new_for_suppliers(ifgop, admin_id);

  //----------------------------------------------------------------------------
  // create a notification service proxy consumer, to send events to

  // This proxy's id.
  CosNotifyChannelAdmin::ProxyID proxy_id;
   // The proxy that we are connected to.
  CosNotifyChannelAdmin::StructuredProxyPushConsumer_var proxy_consumer;


  obj = supplier_admin->
    obtain_notification_push_consumer(CosNotifyChannelAdmin::STRUCTURED_EVENT,
				      proxy_id);
  assert(!CORBA::is_nil(obj));

  // narrow
  proxy_consumer = 
    CosNotifyChannelAdmin::StructuredProxyPushConsumer::_narrow(obj);

  //----------------------------------------------------------------------------
  // offer/subscription management

  // don't call us on subscription changes
  CosNotification::EventTypeSeq_var events = 
    proxy_consumer->
    obtain_subscription_types(CosNotifyChannelAdmin::NONE_NOW_UPDATES_OFF);

  // register the events we gonna offer
  CosNotification::EventTypeSeq added;
  CosNotification::EventTypeSeq removed;

  added.length(1);
  added[0].domain_name = string("Robot_Name").c_str();
  added[0].type_name = string("Event_Name").c_str();
  // remove default offer
  removed.length(1);
  removed[0].domain_name = string("*").c_str();
  removed[0].type_name = string("*").c_str();
  supplier_admin->offer_change(added, removed);

  //----------------------------------------------------------------------------
  // create and connect a supplier class
  
  class MySupplier : public POA_CosNotifyComm::StructuredPushSupplier
  {
  protected:
    void subscription_change(CosNotification::EventTypeSeq const& added,
			     CosNotification::EventTypeSeq const& removed)
      throw(CosNotifyComm::InvalidEventType) {
      cerr << "subscription_change() called" << endl;
    }
    void disconnect_structured_push_supplier() throw() {
      cerr << "disconnect_structured_push_supplier() called" << endl;
    }
  };

  MySupplier * supplier = new MySupplier();

  // activate supplier with poa
  CosNotifyComm::StructuredPushSupplier_var objref = supplier->_this();
  // connect
  proxy_consumer->connect_structured_push_supplier(objref);

  //----------------------------------------------------------------------------
  // sending an event

  CosNotification::StructuredEvent event;
  event.header.fixed_header.event_type.domain_name =
    CORBA::string_dup("Robot_Name");
  event.header.fixed_header.event_type.type_name =
    string("Event_Name").c_str();

  proxy_consumer->push_structured_event(event);

  proxy_consumer->disconnect_structured_push_consumer();
  supplier_admin->destroy();

  return 0;
}
Esempio n. 8
0
Messenger_i::Messenger_i (CORBA::ORB_ptr orb)
: orb_ (CORBA::ORB::_duplicate(orb))

{
  try
  {
    CORBA::Object_var poa_obj = orb->resolve_initial_references("RootPOA");
    PortableServer::POA_var poa = PortableServer::POA::_narrow(poa_obj.in());

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

    CosNaming::NamingContext_var naming_context =
      CosNaming::NamingContext::_narrow(naming_obj.in());


    //
    //  Create an instance of TAO's notification event channel
    //

    CosNotifyChannelAdmin::EventChannelFactory_var notify_factory =
      TAO_Notify_EventChannelFactory_i::create(poa.in());

    if (CORBA::is_nil (notify_factory.in ())) {
      std::cerr << "Unable to create the notify event channel" << std::endl;
      return;
    }

    CosNotifyChannelAdmin::ChannelID id;
    CosNotification::QoSProperties initial_qos;
    CosNotification::AdminProperties initial_admin;

    CosNotifyChannelAdmin::EventChannel_var ec =
      notify_factory->create_channel (initial_qos,
      initial_admin,
      id);

    if (CORBA::is_nil (ec.in())) {
      std::cerr << "Unable to create event channel" << std::endl;
      return;
    }


    CosNaming::Name name(1);
    name.length(1);
    name[0].id = CORBA::string_dup("MyEventChannel");

    naming_context->rebind(name, ec.in());

    CosNotifyChannelAdmin::AdminID adminid;
    CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
      CosNotifyChannelAdmin::AND_OP;

    CosNotifyChannelAdmin::SupplierAdmin_var supplier_admin =
      ec->new_for_suppliers (ifgop, adminid);

    if (CORBA::is_nil (supplier_admin.in())) {
      std::cerr << "Unable to find supplier admin" << std::endl;
    }

    CosNotifyChannelAdmin::ProxyID supplieradmin_proxy_id;

    CosNotifyChannelAdmin::ProxyConsumer_var proxy_consumer =
      supplier_admin->obtain_notification_push_consumer(
      CosNotifyChannelAdmin::STRUCTURED_EVENT,
      supplieradmin_proxy_id);

    StructuredEventSupplier_i *servant =
      new StructuredEventSupplier_i(orb_.in());

    PortableServer::ObjectId_var oid = poa->activate_object(servant);
    CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
    CosNotifyComm::StructuredPushSupplier_var supplier =
      CosNotifyComm::StructuredPushSupplier::_narrow(supplier_obj.in());

    consumer_proxy_ =
      CosNotifyChannelAdmin::StructuredProxyPushConsumer::
      _narrow(proxy_consumer.in());

    if (CORBA::is_nil (consumer_proxy_.in())) {
      std::cerr << "Unable to find structured proxy push consumer" << std::endl;
    }

    consumer_proxy_->connect_structured_push_supplier(supplier.in());

  }
  catch(const CORBA::Exception& ex) {
    std::cerr << ex << std::endl;
  }

}