Example #1
0
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
  try
  {
    long retryCount = 0;
    const ACE_TCHAR *ior_arg = ACE_TEXT("manager.ior");
    CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);

    ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("r:o:"));
    int c;
    while ((c = get_opts ()) != -1)
    {
      switch (c)
      {
      case 'r':
        retryCount = ACE_OS::atoi(get_opts.opt_arg());
        break;
      case 'o':
        ior_arg = get_opts.opt_arg();
        break;
      case '?':
      default:
        cout << "Usage:  " << argv[0] << " [-r retryCount]"
             << " [-o iorfile]" << endl;
        break;
      }
    }

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

    PortableServer::POAManager_var mgr = poa->the_POAManager();

    Manager_i servant(retryCount);
    PortableServer::ObjectId_var oid = poa->activate_object(&servant);
    obj = poa->id_to_reference(oid.in());
    {
      CORBA::String_var ior = orb->object_to_string(obj.in());
      ofstream iorFile(ACE_TEXT_ALWAYS_CHAR(ior_arg));
      iorFile << ior.in() << endl;
    }

    cout << "IMR Test Manager activated (servers retry = " << retryCount << ")." << endl;

    mgr->activate();

    orb->run();

    poa->destroy(1, 1);
    orb->destroy();
    return 0;
  }
  catch (const CORBA::Exception& ex)
  {
    cerr << "Manager: " << ex << endl;
  }
  return 1;
}
Example #2
0
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
  int result = 0;

  try
    {
      ACE_DEBUG((LM_INFO,"(%P|%t) SERVER START\n"));

      orb_ = CORBA::ORB_init (argc, argv);

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

      ACE_DEBUG((LM_INFO,"(%P|%t) ORB initialized\n"));

      Test_Idl_SharedIntf_i* intf_i = new Test_Idl_SharedIntf_i(orb_.in());

      PortableServer::ServantBase_var base_var = intf_i;
      PortableServer::ObjectId_var intfId_var =
        poa->activate_object(base_var.in());

      obj = poa->id_to_reference(intfId_var.in());
      Test_Idl::SharedIntf_var intf_var = Test_Idl::SharedIntf::_narrow(obj.in());
      CORBA::String_var intfString_var = orb_->object_to_string(intf_var.in());

      // Output the IOR to the <ior_output_file>
      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
      if (output_file == 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Cannot open output file for writing IOR: %s\n",
                           ior_output_file),
                          1);
      ACE_OS::fprintf (output_file, "%s", intfString_var.in ());
      ACE_OS::fclose (output_file);

      intf_i->set_upper (upper_ior);

      // Running ORB in separate thread
      Worker worker;
      if (worker.activate () != 0)
      ACE_ERROR_RETURN ((LM_ERROR,
                         "(%P|%t) %p\n", "Cannot activate server thread(s)"),
                        -1);

      worker.thr_mgr()->wait ();
      orb_->destroy();
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Error: Exception caught:");
    }

  ACE_OS::unlink (ior_output_file);
  return result;
}
Example #3
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;

    // Find the Naming Service.
    CORBA::Object_var rootObj =  orb->resolve_initial_references("NameService");
    CosNaming::NamingContext_var rootNC =
      CosNaming::NamingContext::_narrow(rootObj.in());

    // Get the  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 our Messenger servant.
    PortableServer::Servant_var<Messenger_i> messenger_servant =
      new Messenger_i(orb.in());

    // Register it with the RootPOA.
    PortableServer::ObjectId_var oid =
      poa->activate_object( messenger_servant.in() );
    CORBA::Object_var messenger_obj = poa->id_to_reference( oid.in() );

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

    CORBA::String_var str = orb->object_to_string (messenger_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 " << ior_output_file << std::endl;

    // Accept requests
    orb->run();
    orb->destroy();

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

}
Example #4
0
int
main (int argc, char *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,
					   " (%N|%l) Panic: nil RootPOA\n"),
					  1);

		PortableServer::POAManager_var poa_manager = root_poa->the_POAManager ();

		Hello *hello_impl;
		ACE_NEW_RETURN (hello_impl,
				Hello (orb.in ()),
				1);
		PortableServer::ServantBase_var owner_transfer(hello_impl);

		Test::Hello_var hello =	hello_impl->_this ();

		//
		// Register the server object in the IOR table
		//

		// Turn the object reference into an IOR string
		CORBA::String_var ior_string = orb->object_to_string(hello.in());

		// Get a reference to the IOR Table and bind the hello object
		CORBA::Object_var table_obj = orb->resolve_initial_references("IORTable");
		IORTable::Table_var ior_table = IORTable::Table::_narrow(table_obj.in());
		ior_table->bind(::Test::Hello::IOR_TABLE_KEY, ior_string.in());

		poa_manager->activate ();

		ACE_DEBUG ((LM_DEBUG, "(%N|%l) server - event loop beginning\n"));

		orb->run ();

		ACE_DEBUG ((LM_DEBUG, "(%N|%l) 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;
}
Example #5
0
int main(int argc, char** argv)
{
  try {
    CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "omniORB3");

    CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
    PortableServer::POA_var poa = PortableServer::POA::_narrow(obj);

    HelloWorld_i* myhello = new HelloWorld_i();
    PortableServer::ObjectId_var myhelloid = poa->activate_object(myhello);
    
    obj = myhello->_this();
    CORBA::String_var sior(orb->object_to_string(obj));
    
    const char* myRef = argv[1];
    ofstream out(myRef);
    if(out.fail())
    {
      cerr << argv[0] << ": can't open `" << myRef << "': "
           << strerror(errno) << endl;
      return EXIT_FAILURE;
    }
    out << sior << endl;
    out.close();
    
    myhello->_remove_ref();

    PortableServer::POAManager_var pman = poa->the_POAManager();
    pman->activate();

    orb->run();
    	
    orb->destroy();
  }
  catch(CORBA::COMM_FAILURE& ex) {
    cerr << "Caught system exception COMM_FAILURE -- unable to contact the "
         << "object." << endl;
  }
  catch(CORBA::SystemException&) {
    cerr << "Caught CORBA::SystemException." << endl;
  }
  catch(CORBA::Exception&) {
    cerr << "Caught CORBA::Exception." << endl;
  }
  catch(omniORB::fatalException& fe) {
    cerr << "Caught omniORB::fatalException:" << endl;
    cerr << "  file: " << fe.file() << endl;
    cerr << "  line: " << fe.line() << endl;
    cerr << "  mesg: " << fe.errmsg() << endl;
  }
  catch(...) {
    cerr << "Caught unknown exception." << endl;
  }

  return 0;
}
Example #6
0
File: main.cpp Project: manut/TAO
CORBA::Boolean
Foo_Impl::match_references ()
{
  CORBA::Object_var o = _this ();
  CORBA::ORB_var orb = o->_get_orb ();
  CORBA::String_var ior_from_upcall = orb->object_to_string (o.in());

  CORBA::Boolean r1 = equal_func (this->ior_from_main_.in(), ior_from_upcall.in());

  return r1;
}
Example #7
0
char *
Task::locate (const char *)
{
  CORBA::Object_var fwdObj = orb_->string_to_object(anotherIOR);
  CORBA::String_var fwdString = orb_->object_to_string(fwdObj.in ());

  ACE_DEBUG ((LM_DEBUG,
              "IN LOCATOR!  Forwarding client to: %C\n",
              fwdString.in ()));

  return fwdString._retn();
}
Example #8
0
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
  try {
    // Initialize the ORB.
    CORBA::ORB_var orb = CORBA::ORB_init( argc, argv );

    //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();

    if (parse_args (argc, argv) != 0)
      return 1;

    // Create a servant.
    PortableServer::Servant_var<Messenger_i> messenger_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( messenger_servant.in() );
    CORBA::Object_var messenger_obj = poa->id_to_reference( oid.in() );
    CORBA::String_var str = orb->object_to_string( messenger_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;

    // 3. Create and activate threads for the thread pool.
    ORB_Task task (orb.in());
    int retval = task.activate (THR_NEW_LWP | THR_JOINABLE, nthreads);
    if (retval != 0) {
      std::cerr << "Failed to activate " << nthreads << " threads." << std::endl;
      return 1;
    }

    // 4. Wait for threads to finish.
    task.wait();

    // Clean up.
    orb->destroy();
  }
  catch(const CORBA::Exception& ex) {
    std::cerr << "CORBA exception: " << ex << std::endl;
    return 1;
  }

  return 0;
}
Example #9
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 ();

        // Create a controller and set static m_ctrl member
        // for thermostats and thermometers.
        Controller_impl ctrl_servant;
        Thermometer_impl::m_ctrl = &ctrl_servant;

        // Write controller stringified reference to stdout
        CCS::Controller_var ctrl = ctrl_servant._this ();
        CORBA::String_var str = orb->object_to_string (ctrl.in ());
        std::cout << str.in () << std::endl << std::endl;

        // Create a few devices. (Thermometers have odd asset
        // numbers, thermostats have even asset numbers.)
        Thermometer_impl thermo1 (2029, "Deep Thought");
        Thermometer_impl thermo2 (8053, "HAL");
        Thermometer_impl thermo3 (1027, "ENIAC");

        Thermostat_impl tmstat1 (3032, "Colossus", 68);
        Thermostat_impl tmstat2 (4026, "ENIAC", 60);
        Thermostat_impl tmstat3 (4088, "ENIAC", 50);
        Thermostat_impl tmstat4 (8042, "HAL", 40);

        // Accept requests
        orb->run ();
    }
    catch (const CORBA::Exception & e) {
        std::cerr << "Uncaught CORBA exception: "
                  << e
                  << std::endl;
        return 1;
    }
    catch (...) {
        assert (0);  // Unexpected exception, dump core
    }
    return 0;
}
Example #10
0
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
  try
    {
      CORBA::ORB_var orb =
        CORBA::ORB_init (argc, argv);

      CORBA::Object_var poa_object =
        orb->resolve_initial_references("RootPOA");

      PortableServer::POA_var root_poa =
        PortableServer::POA::_narrow (poa_object.in ());

      if (CORBA::is_nil (root_poa.in ()))
        ACE_ERROR_RETURN ((LM_ERROR,
                           " (%P|%t) Panic: nil RootPOA\n"),
                          1);

      if (parse_args (argc, argv) != 0)
        return 1;

      Test::Hello_var hello = prepare_tests (orb.in (), root_poa.in ());

      CORBA::String_var ior = orb->object_to_string (hello.in ());

      // Output the IOR to the <ior_output_file>
      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
      if (output_file == 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Cannot open output file for writing IOR: %s\n",
                           ior_output_file),
                           1);
      ACE_OS::fprintf (output_file, "%s", ior.in ());
      ACE_OS::fclose (output_file);

      orb->run ();

      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));

      root_poa->destroy (1, 1);

      orb->destroy ();
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Exception caught:");
      return 1;
    }

  return 0;
}
Example #11
0
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
  try {
    PortableInterceptor::ORBInitializer_var orb_initializer =
      new ServerInitializer;

    PortableInterceptor::register_orb_initializer (orb_initializer.in ());

    // 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> messenger_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( messenger_servant.in() );
    CORBA::Object_var messenger_obj = poa->id_to_reference( oid.in() );
    CORBA::String_var str = orb->object_to_string( messenger_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
    orb->run();
    orb->destroy();
  }

  catch(const CORBA::Exception& ex)
    {
      std::cerr << "Exception in MessengerServer: " << ex << std::endl;
      return 1;
    }

  return 0;
}
Example #12
0
int main (int argc, char *argv[])
{
    try 
    {
      // Initialize orb
      printf("orb init\n");
      CORBA::ORB_var orb = CORBA::ORB_init (argc, (char**)argv);
        
      // Get reference to Root POA.
      printf("resolve_initial_references\n");

      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
      HelloWorld_impl HelloWorld_servant;

      // Write its stringified reference to stdout
      perf::jitter::HelloWorld_var myInterface = HelloWorld_servant._this ();
      CORBA::String_var str = orb->object_to_string (myInterface.in ());

      FILE* outFile = fopen("ior.txt", "w");
      if (outFile == NULL)
      {
          printf("Error: Cannot open IOR file for writing\n");
      }
      else
      {
          if (fprintf(outFile, "%s\n", str.in ()) <= 0)
          {
              printf("Error: Could not write IOR string to file\n");
          }

          fclose(outFile);
          
          printf("Listening for CORBA requests...\n");
          orb->run();
      }
    }
    catch (const CORBA::Exception &) 
    {
      printf("Uncaught CORBA exception");
    }
	
	return 0;
}
Example #13
0
//int testClient (char* orbName, char* ior)
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
  try
    {
      CORBA::ORB_var orb =
          CORBA::ORB_init (argc,
                           argv,
                           "ORB_Test_Client");

      if (parse_args (argc, argv) != 0)
        return 1;

      CORBA::Object_var object =
        orb->string_to_object (ior);

      Simple_Server_var server =
        Simple_Server::_narrow (object.in ());

      if (CORBA::is_nil (server.in ()))
        {
          ACE_ERROR_RETURN ((LM_ERROR,
                             "Object reference <%s> is nil.\n",
                             ior),
                            1);
        }

      CORBA::String_var string =
        orb->object_to_string (server.in ());

      ACE_DEBUG ((LM_DEBUG,
                  "Client: orb->object_to_string: <%C>\n",
                  string.in ()));

      Client client (server.in (), niter);

      client.svc ();

      //ACE_DEBUG ((LM_DEBUG, "threads finished\n"));

      orb->destroy ();
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Caught exception:");
      return 1;
    }

  return 0;
}
Example #14
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
    Messenger_i messenger_servant (orb.in ());

    // 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( &messenger_servant );
    CORBA::Object_var messenger_obj = poa->id_to_reference( oid.in() );
    CORBA::String_var str = orb->object_to_string( messenger_obj.in() );
    FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
    if (output_file == 0)
      ACE_ERROR_RETURN ((LM_ERROR,
                          "Cannot open output file for writing IOR: %s\n",
                          ior_output_file),
                          1);
    ACE_OS::fprintf (output_file, "%s", str.in ());
    ACE_OS::fclose (output_file);

    // Accept requests
    orb->run();
    orb->destroy();
  }
  catch( const CORBA::Exception & ex)
  {
    ex._tao_print_exception ("Caught CORBA exception: ");
    return 1;
  }

  return 0;
}
Example #15
0
ACE_CString
TAO_Notify_PushConsumer::get_ior (void) const
{
    ACE_CString result;
    CORBA::ORB_var orb = TAO_Notify_PROPERTIES::instance()->orb();
    try
    {
        CORBA::String_var ior = orb->object_to_string(this->push_consumer_.in());
        result = static_cast<const char*> (ior.in ());
    }
    catch (const CORBA::Exception&)
    {
        result.fast_clear();
    }
    return result;
}
Example #16
0
void
FactoryClient::find_channel_id (CosEventChannelAdmin::EventChannel_ptr channel)
{
  CORBA::String_var str =
    orb_->object_to_string (channel);

  ACE_DEBUG ((LM_DEBUG,
              "trying to find the Channel %s\n",
              str.in ()));

  char *channel_id =
    this->factory_->find_channel_id (channel);

  ACE_DEBUG ((LM_DEBUG,
              "find returned %s\n", channel_id));
}
void
RepDCIManagerSessionImpl::register_node(const char* node_name, DCI::NodeManager_ptr node_manager)
	throw(CORBA::SystemException, ::Components::InvalidName, ::DCI::AlreadyRegistered)
{
// BEGIN USER INSERT SECTION RepDCIManagerSessionImpl::register_node
	/*
    * Add a node manager.
    *
    * @param node_name The name of the node manager.
    * @param node_manager The reference to the node manager.
    *
    * @return void.
    *
    */
	DEBUG_OUT2( "RepDCIManagerSessionImpl::register_node(): start... node=", node_name);
	//convert reference
	// TODO: CORBA::ORB_var orb = context_->resolve_service_reference("ORB");
	int dummy = 0;
	CORBA::ORB_var orb = CORBA::ORB_init (dummy, 0);
	char * node_manager_ref = orb->object_to_string( node_manager );

	//get connection to repository Runtime Model
	MDE::Deployment::NodeManagerClass_var node_ref = this->get_rep_root()->node_manager_ref();
	if ( CORBA::is_nil ( node_ref ) ) {
		NORMAL_ERR("RepDCIManagerSessionImpl::register_node(): NodeClass reference nil!");
		throw CORBA::SystemException();
	}
	//lookup node
	MDE::Deployment::NodeManager_var rep_node = node_ref->lookup(node_name);
	if(rep_node) {
		NORMAL_ERR("RepDCIManagerSessionImpl::register_node(): AlreadyRegistered ?!");
		//throw DCI::AlreadyRegistered();
		DEBUG_OUT("RepDCIManagerSessionImpl::register_node(): update reference");
		rep_node->set_ref(node_manager_ref);
	}
	else {
		//add Node
		try {
			rep_node = node_ref->create_node_manager(node_manager_ref, node_name, true);
		}
		catch(...) {
			NORMAL_ERR2("RepDCIManagerSessionImpl::register_node(): error while creating node in repo; node=", node_name);
		}
	}
	DEBUG_OUT( "RepDCIManagerSessionImpl::register_node(): ...end");
// END USER INSERT SECTION RepDCIManagerSessionImpl::register_node
}
Example #18
0
void OmniORBThread::run()
{
  try {
    CORBA::ORB_var orb = CORBA::ORB_init(_argc, _argv);

    CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
    PortableServer::POA_var poa = PortableServer::POA::_narrow(obj);

    Echo_i* myecho = new Echo_i();

    PortableServer::ObjectId_var myechoid = poa->activate_object(myecho);

    // Obtain a reference to the object, and register it in
    // the naming service.
    obj = myecho->_this();

    CORBA::String_var x;
    x = orb->object_to_string(obj);
    cout << x << endl;

    if( !bindObjectToName(orb, obj) )
      return;

    myecho->_remove_ref();

    PortableServer::POAManager_var pman = poa->the_POAManager();
    pman->activate();

    orb->run();
  }
  catch(CORBA::SystemException& ex) {
    cerr << "Caught CORBA::" << ex._name() << endl;
  }
  catch(CORBA::Exception& ex) {
    cerr << "Caught CORBA::Exception: " << ex._name() << endl;
  }
  catch(omniORB::fatalException& fe) {
    cerr << "Caught omniORB::fatalException:" << endl;
    cerr << "  file: " << fe.file() << endl;
    cerr << "  line: " << fe.line() << endl;
    cerr << "  mesg: " << fe.errmsg() << endl;
  }

  //emit finished();
}
Example #19
0
template <class Servant> int
Server<Servant>::register_name (const char *name)
{
  CORBA::ORB_var orb = this->orb_manager_.orb ();

  if (this->naming_client_.init (orb.in ()) == -1)
    return -1;

  // create the name for the naming service
  CosNaming::Name bindName;
  bindName.length (1);
  bindName[0].id = CORBA::string_dup (name);

  // (re)Bind the object.
  try
    {
      CORBA::Object_var object = servant_->_this ();

      this->orb_manager_.activate_poa_manager ();

      naming_client_->rebind (bindName,
                              object.in());

      // Test for INS.
      if (this->ins_)
        {
          CORBA::String_var ior =
            orb->object_to_string (object.in ());
          if (this->test_for_ins (ior.in ()) != 0)
            ACE_ERROR_RETURN ((LM_ERROR,
                               ACE_TEXT ("test_for_ins (): failed\n")),
                              -1);
        }
    }
  catch (const CosNaming::NamingContext::AlreadyBound&)
    {
      ACE_ERROR_RETURN ((LM_ERROR,
                         ACE_TEXT ("Unable to bind %C\n"),
                         name),
                        -1);
    }

  return 0;
}
Example #20
0
int
main( int argc, char *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() );

      PortableServer::POAManager_var mgr = poa->the_POAManager();

      // Activate POA Manager
      mgr->activate();

      // Create an object
      GoodDay_i servant;

      // Register the servant with the RootPOA, obtain its object
      // reference, stringify it, and write it to a file.
      obj = poa->servant_to_reference( &servant );

      CORBA::String_var str = orb->object_to_string( obj.in() );
      ofstream iorFile( "IOR" );
      iorFile << str.in() << endl;
      iorFile.close();

      cout << "IOR written to file IOR" << endl;

      // Accept requests
      orb->run();
      orb->destroy();
    }

  catch( const CORBA::Exception &ex )
    {
      cerr << "Uncaught CORBA exception: " << ex <<endl;
      return 1;
    }

  return 0;
}
Example #21
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> messenger_servant =
      new Messenger_i;

    // Write its stringified reference to a file
    PortableServer::ObjectId_var oid = poa->activate_object(messenger_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 << "CORBA::Exception " << ex << std::endl;
    return 1;
  }

  return 0;
}
Example #22
0
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
  try
    {
      CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);

      TestShutdown killer (orb.in ());

      if (parse_args (argc, argv) != 0)
        return 1;

      CORBA::Object_var pPoaObj =
        orb->resolve_initial_references ("RootPOA");
      PortableServer::POA_var poa =
        PortableServer::POA::_narrow (pPoaObj.in ());
      PortableServer::POAManager_var pMgr = poa->the_POAManager ();
      pMgr->activate ();

      SimpleNamingService_i* servant = new SimpleNamingService_i;
      PortableServer::ObjectId_var oid = poa->activate_object (servant);
      CORBA::Object_var obj = poa->id_to_reference (oid.in ());
      CORBA::String_var str = orb->object_to_string (obj.in ());

      FILE *output_file= ACE_OS::fopen (iorFileName, "w");
      if (output_file == 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Cannot open output file for writing IOR: %s\n",
                           iorFileName),
                           1);
      ACE_OS::fprintf (output_file, "%s", str.in ());
      ACE_OS::fclose (output_file);

      orb->run ();
    }
  catch (CORBA::Exception& ex)
    {
      ACE_DEBUG ((LM_ERROR, "Corba Exception: %s\n", ex._info ().c_str ()));
      return 1;
    }

  return 0;
}
Example #23
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 a reference to Root POA.
    CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
    PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());

    // Activate the POA manager.
    PortableServer::POAManager_var mgr = poa->the_POAManager();
    mgr->activate();

    // Create a Logger_i servant.
    PortableServer::Servant_var<Logger_i> logger_servant = new Logger_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(logger_servant.in());
    CORBA::Object_var logger_obj = poa->id_to_reference(oid.in());
    CORBA::String_var str = orb->object_to_string(logger_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();

    // Release resources.
    orb->destroy();
  }
  catch(const CORBA::Exception& ex) {
    std::cerr << "Caught a CORBA exception:" << ex << std::endl;
    return 1;
  }
  return 0;
}
Example #24
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 rootObj = orb->resolve_initial_references("NameService");
      CosNaming::NamingContext_var rootNC =
      CosNaming::NamingContext::_narrow(rootObj.in());

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

      PortableServer::Servant_var<Messenger_i> messenger_servant =
        new Messenger_i(orb.in ());
      PortableServer::ObjectId_var oid = poa->activate_object (messenger_servant.in());
      CORBA::Object_var messenger_obj = poa->id_to_reference (oid.in ());
      CORBA::String_var str = orb->object_to_string (messenger_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 " << ior_output_file << std::endl;

      orb->run ();
      orb->destroy ();
    }

  catch(const CORBA::Exception& ex)
  {
      std::cerr << "Caught exception: " << ex << std::endl;
      return 1;
  }

  return 0;
}
Example #25
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;

      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;
}
Example #26
0
int main (int argc, char* argv[])
{
    CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);

    CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
    PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj);
    PortableServer::POAManager_var manager = root_poa->the_POAManager();
    manager->activate();

    Writer* writer = new Writer();
    PortableServer::ObjectId_var oid = root_poa->activate_object(writer);
    rawdata::writer_var ref = writer->_this();
    CORBA::String_var ior = orb->object_to_string(ref);
    std::cout << ior << std::endl;

    orb->run();

    orb->shutdown(true);

    orb->destroy();
}
Example #27
0
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
  try {
    // First initialize the ORB, that will remove some arguments...
    CORBA::ORB_var orb =
      CORBA::ORB_init (argc, argv);
    CORBA::Object_var poa_object =
      orb->resolve_initial_references ("RootPOA");
    PortableServer::POA_var poa =
      PortableServer::POA::_narrow (poa_object.in ());
    PortableServer::POAManager_var poa_manager =
      poa->the_POAManager ();
    poa_manager->activate ();

    // Create the servant
    Quoter_Stock_Factory_i stock_factory_i;

    // Activate it to obtain the object reference
    Quoter::Stock_Factory_var stock_factory =
      stock_factory_i._this ();

    // Put the object reference as an IOR string
    CORBA::String_var ior = orb->object_to_string (stock_factory.in ());

    // Print it out!
    cout << ior.in () << endl;

    orb->run ();

    // Destroy the POA, waiting until the destruction terminates
    poa->destroy (1, 1);
    orb->destroy ();
  }
  catch (CORBA::Exception &) {
    cerr << "CORBA exception raised!" << endl;
  }
  return 0;
}
Example #28
0
File: server.cpp Project: CCJY/ATCD
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 poa_object =
        orb->resolve_initial_references("RootPOA");
        PortableServer::POA_var root_poa =
        PortableServer::POA::_narrow (poa_object.in ());
        PortableServer::POAManager_var poa_manager =
        root_poa->the_POAManager ();
        poa_manager->activate ();

        Server_impl* server_obj = new Server_impl(orb.in());
        PortableServer::ServantBase_var owner (server_obj);
        server_var server = server_obj->_this();
        CORBA::String_var ior = orb->object_to_string (server.in ());

        FILE *output_file = ACE_OS::fopen (ACE_TEXT_ALWAYS_CHAR(ior_output_file), "w");
        ACE_OS::fprintf (output_file, "%s", ior.in ());
        ACE_OS::fclose (output_file);

        orb->run ();
        orb->destroy ();
    }
  catch(...)
    {
        return 1;
    }

    return 0;
}
Example #29
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 ();

      // Create an object
      Time_impl time_servant;

      // Write its stringified reference to stdout
      Time_var tm = time_servant._this ();
      CORBA::String_var str = orb->object_to_string (tm.in ());
      cout << str.in () << endl;

      // Accept requests
      orb->run ();
    }
  catch (const CORBA::Exception &)
    {
      cerr << "Uncaught CORBA exception" << endl;
      return 1;
    }
  return 0;
}
Example #30
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;

        Test_i servant (orb.in ());
        // Obtain RootPOA.
        CORBA::Object_var object =
            orb->resolve_initial_references ("RootPOA");

        PortableServer::POA_var root_poa =
            PortableServer::POA::_narrow (object.in ());


        // Get the POAManager of the RootPOA.
        PortableServer::POAManager_var poa_manager =
            root_poa->the_POAManager ();

        PortableServer::ObjectId_var id =
            root_poa->activate_object (&servant);

        CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());

        Test_var Test_object =
            Test::_narrow (object_act.in ());

        CORBA::String_var ior =
            orb->object_to_string (Test_object.in ());

        // If the ior_output_file exists, output the ior to it
        if (ior_output_file != 0)
        {
            FILE *output_file =
                ACE_OS::fopen (ior_output_file, "w");

            if (output_file == 0)
                ACE_ERROR_RETURN ((LM_ERROR,
                                   "Cannot open output file for writing IOR: %s",
                                   ior_output_file),
                                  1);

            ACE_OS::fprintf (output_file,
                             "%s",
                             ior.in ());
            ACE_OS::fclose (output_file);
        }

        poa_manager->activate ();

        orb->run ();

        ACE_DEBUG ((LM_DEBUG,
                    "event loop finished\n"));

        root_poa->destroy (true, true);

        orb->destroy ();
    }
    catch (const CORBA::Exception& ex)
    {
        ex._tao_print_exception ("Exception in setting up server");
        ACE_ASSERT (0);
    }
    return 0;
}