//
// initialize_poa
//
void Tao_Data_Channel_Service::initialize_poa (::PortableServer::POA_ptr poa)
{
  // Construct the policy list for the LoggingServerPOA.
  ::CORBA::PolicyList policies (6);
  policies.length (6);

  policies[0] = poa->create_thread_policy (PortableServer::ORB_CTRL_MODEL);
  policies[1] = poa->create_servant_retention_policy (PortableServer::RETAIN);
  policies[2] = poa->create_id_assignment_policy (PortableServer::SYSTEM_ID);
  policies[3] = poa->create_id_uniqueness_policy (PortableServer::UNIQUE_ID);
  policies[4] = poa->create_lifespan_policy (PortableServer::TRANSIENT);
  policies[5] = poa->create_request_processing_policy (PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY);

  // Create the child POA for the test logger factory servants.
  this->poa_ =
    poa->create_POA ("DataChannelPOA",
                     ::PortableServer::POAManager::_nil (),
                     policies);

  for (size_t i = 0; i < 6; ++ i)
    policies[i]->destroy ();

  // Activate this POA's manager.
  PortableServer::POAManager_var the_mgr = this->poa_->the_POAManager ();
  the_mgr->activate ();
}
Example #2
0
int main(int argc, char* argv[]) {

//   // Signals staff
//   signal(SIGINT,  handler);
//   signal(SIGTERM, handler);
//   signal(SIGKILL, handler);
  
  // Print the welcome message
  printWelcome();
  
  //
  // Check TIDNaming arguments
  //
  /*
   * Note: this TIDNaming special arguments may be passed to ORB
   * initialization with no problems. Any unknown argument will be ignored
   * by ORB, so no change is needed for argv.
   */
  const char * persistence_dir = "";
  int max_binding_iterators = 40;
  const char * ior_file = "";

  for (int i = 1; i < argc; i++)
  {
    if (strcmp(argv[i], "--help") == 0)
    {
      printUsage(argv[0]);
      _exit(0);
    }

    if (strcmp(argv[i], "--version") == 0)
    {
      cerr << "TIDNaming C++ version " << TIDNaming::st_version << endl;
      _exit(0);
    }
    
    if (strcmp(argv[i], "--persistence-dir") == 0)
     {
       if (i == argc - 1)
       {
         cerr << "Error: --persistence-dir specified but no path given" << endl;
         printUsage(argv[0]);
         _exit(-1);
       }
       persistence_dir = argv[i+1];
     }

    if (strcmp(argv[i], "--max_binding_iterators") == 0) {
      char* ptr;
      long  laux;
      laux = strtol(argv[i+1], &ptr, 10);
      max_binding_iterators = laux;
    }

    if (strcmp(argv[i], "--ior") == 0) {
       if (i == argc - 1)
       {
         cerr << "Error: --ior specified but no file name given" << endl;
         printUsage(argv[0]);
         _exit(-1);
       }
       ior_file = argv[i+1];
    }

  }

  DMSG("Executing in debug mode, a lot of messages will be "\
       "printed to stderr");
  DMSG_P("Using '", persistence_dir, "' as persistence directory"); 
  DMSG_P("Using '", ior_file, "' as ior output file"); 

  char * port = strdup("2809");
  char * ssl_port = strdup("");
  bool port_given = false;
  bool ssl_port_given = false;
  bool ssl_config = false;

  try {
     
     //
     // Start TIDThread library
     //
     TIDThr::init();

     //
     // Check for -ORB_iiop_orb_port to set NameService default
     //
     int new_argc = argc + 2;
     char * new_argv[new_argc];
     for (int i = 1; i < argc; i++)
     {
       new_argv[i] = argv[i]; // No strdup is needed

       if (strcmp(argv[i], "-ORB_iiop_orb_port") == 0)
       {
         port_given = true;
         free(port);
         port = strdup(argv[i+1]);
       }

       if (strcmp(argv[i], "-ORB_ssl_port") == 0)
       {
         ssl_port_given = true; // util??
         free(ssl_port);
         ssl_port = strdup(argv[i+1]);
       }
       if (strcmp(argv[i], "-ORB_ssl_private_key") == 0)
       {
         for (int j = 1; j < argc; j++) {
           if (strcmp(argv[j], "-ORB_ssl_certificate") == 0) {
             ssl_config = true;
             break;
           }
         }
       }
     }
     new_argv[new_argc - 2] = "-ORB_iiop_orb_port";
     new_argv[new_argc - 1] = port;

     int orb_argc     = port_given ? argc : new_argc;
     char ** orb_argv = port_given ? argv : new_argv;

     //
     // ORB initialization
     //
     my_global_orb = CORBA::ORB_init(orb_argc, orb_argv);

     // Get internal ORB 
     TIDorb::core::TIDORB* m_orb = 
       dynamic_cast<TIDorb::core::TIDORB*> (CORBA::ORB::_duplicate(my_global_orb));

     //
     // Getting RootPOA & Manager references
     //
     CORBA::Object_var poa_obj = my_global_orb->resolve_initial_references("RootPOA");
     PortableServer::POA_ptr rootPOA = PortableServer::POA::_narrow(poa_obj);

     PortableServer::POAManager_var manager = rootPOA->the_POAManager();


     //
     // NamingContexts POA creation
     //
     CORBA::PolicyList policies;
     policies.length(4);

     policies[0] = rootPOA->create_servant_retention_policy(PortableServer::RETAIN);
     policies[1] = rootPOA->create_request_processing_policy(
                                                   PortableServer::USE_SERVANT_MANAGER);
     policies[2] = rootPOA->create_id_assignment_policy(PortableServer::USER_ID);
     policies[3] = rootPOA->create_lifespan_policy(PortableServer::PERSISTENT);

     PortableServer::POA_var namingContextsPOA = 
       rootPOA->create_POA("namingContextsPOA", manager, policies);

     PortableServer::POAManager_var namingContextsManager = 
       namingContextsPOA->the_POAManager();


     //
     // BindingIterators POA creation
     //
     CORBA::PolicyList bindingIterators_policies;
     bindingIterators_policies.length(2);

     bindingIterators_policies[0] = 
       rootPOA->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL); 
     bindingIterators_policies[1] = 
       rootPOA->create_id_assignment_policy(PortableServer::USER_ID);

     PortableServer::POA_var bindingIteratorsPOA = 
       namingContextsPOA->create_POA("bindingIteratorsPOA", namingContextsManager, 
                                     bindingIterators_policies);


     // 
     // Creates and sets a new ServantManager
     // 

     TIDNaming::ServantManagerNSImpl* servant_manager = 
       new TIDNaming::ServantManagerNSImpl(my_global_orb, bindingIteratorsPOA,
                                           max_binding_iterators);

     namingContextsPOA->set_servant_manager(servant_manager);


     // Creates the reference to the "root.ctx". Dont create it
     // This fragment of code is not needed anymore. It creates the
     // initial reference to root naming context, now created from
     // PersistenceManager class.
     /*
     PortableServer::ObjectId_var oid =
       PortableServer::string_to_ObjectId("root.ctx"); // Change to "NameService"

     CORBA::Object_var obj = 
       namingContextsPOA->create_reference_with_id(oid,"IDL:omg.org/CosNaming/NamingContextExt:1.0");  
     */

     // Manager activation (ORB/POA staff)
     manager->activate();
     namingContextsManager->activate();


     //
     // Check if has persistence 
     //
     if (strcmp(persistence_dir, "") != 0) {

       if (m_orb->trace != NULL){
         TIDorb::util::StringBuffer msg;
         msg << "Using '" << persistence_dir << "' as persistence directory";
         m_orb->print_trace(TIDorb::util::TR_USER, msg.str().data());
       }

       //
       // Recover the persistent data 
       //
       try {
         TIDNaming::NamingContextFileIOFactory::init(persistence_dir);
       }
       catch (TIDNaming::NamingContextFileIOFactory::InvalidPathException & e) {
         if (m_orb->trace != NULL) {
           TIDorb::util::StringBuffer msg;
           msg << "Error: cannot initialize persistence directory '";
           msg << e.path << "'";
           m_orb->print_trace(TIDorb::util::TR_ERROR, msg.str().data());
         }
         printUsage(argv[0]);
         _exit(-1);
       }

       loadPersistence(namingContextsPOA.inout(), 
                       bindingIteratorsPOA.inout(),
                       ior_file);


     } else {

       //
       // Start without persistent data 
       //     
       try {
         TIDNaming::NamingContextNullIOFactory::init();
       }
       catch (...) {
         printUsage(argv[0]);
         _exit(-1);
       }
       
       if (m_orb->trace != NULL)
         m_orb->print_trace(TIDorb::util::TR_USER, 
                            "No root context found. Initializing a new one... ");

       CosNaming::NamingContext_var root_nc = 
         createNamingContextReference(namingContextsPOA, 
                                      NamingInternals::RootNamingContextOID);

       // Get ssl system assigned port
       if (ssl_config && (!ssl_port_given)) {
         TIDorb::portable::Stub* stub_obj = 
           dynamic_cast<TIDorb::portable::Stub*> ((CORBA::Object*)root_nc);
         TIDorb::core::ObjectDelegateImpl* obj_delegate = 
           dynamic_cast<TIDorb::core::ObjectDelegateImpl*> (stub_obj->_get_delegate());
         TIDorb::core::iop::IOR* ior = obj_delegate->getReference();
         SSLIOP::SSL* _ssl = ior->get_SSL();
         free(ssl_port);
         ssl_port = (char*)malloc(6);
         sprintf(ssl_port, "%d", _ssl->port);         
       }
       registerNameService(my_global_orb, root_nc, ior_file);

       if (m_orb->trace != NULL)
         m_orb->print_trace(TIDorb::util::TR_DEBUG, "Done");
       
       
     }

     //
     // Run the ORB loop forever
     //
     TIDorb::util::StringBuffer msg;
     msg << "Serving at port " << port << "... " << endl;
     if (ssl_config) {
       msg.seekp(0, ios::beg);
       msg << "Serving at SSL port " << ssl_port << "... " << endl;
     }
     if (m_orb->trace != NULL)
       m_orb->print_trace(TIDorb::util::TR_USER,  msg.str().data());
     cerr << msg.str().data();

     my_global_orb->run();

     my_global_orb->destroy();

  }
  catch (const CORBA::INITIALIZE & ex) {
    cerr << "ERROR: cannot initialize Naming Service at port ";
    if (ssl_config) 
      cerr << ssl_port;
    else
      cerr << port;
    cerr << " due to: " << ex << endl;
  }
  catch (const CORBA::Exception& ex) {
    cerr << "ERROR: Naming Server Exception: " << ex << endl << flush;
    exit (1);
  }
  catch (...) {
    cerr << "ERROR: unexpected exception raised" << endl << flush;
    exit (1);
  }

  free(port);
  free(ssl_port);

}
void 
HomeServantBase::initialize
( PortableServer::POA_ptr root_poa
, Components::HomeExecutorBase_ptr home_executor
, ContainerInterfaceImpl* container
, std::string install_dir )
throw (Components::Deployment::InstallationFailure)
{
	home_executor_ = Components::HomeExecutorBase::_duplicate (home_executor);
	container_ = container;
	container_->_add_ref();
	install_dir_ = install_dir;

	// Create a new POA for the components
	CORBA::PolicyList policies;
	policies.length (7);
	policies[0] = root_poa->create_thread_policy (PortableServer::ORB_CTRL_MODEL);
	policies[1] = root_poa->create_lifespan_policy (PortableServer::TRANSIENT);
	policies[2] = root_poa->create_id_uniqueness_policy (PortableServer::UNIQUE_ID);
	policies[3] = root_poa->create_id_assignment_policy (PortableServer::USER_ID);
	policies[4] = root_poa->create_implicit_activation_policy (PortableServer::NO_IMPLICIT_ACTIVATION);
	policies[5] = root_poa->create_servant_retention_policy (PortableServer::NON_RETAIN);
	policies[6] = root_poa->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER);

	static CORBA::ULong poa_name = 0;
	char buffer[17];

	sprintf (buffer, "Qedo_POA_%ld", ++poa_name);
	
	try
	{
		home_poa_ = root_poa->create_POA (buffer, NULL, policies);
	}
	catch (PortableServer::POA::AdapterAlreadyExists&)
	{
		NORMAL_ERR ("HomeServantBase: Fatal internal error - POA already exists???");
		throw Components::Deployment::InstallationFailure();
	}
	catch (PortableServer::POA::InvalidPolicy&)
	{
		NORMAL_ERR ("HomeServantBase: Fatal internal error - Invalid policy during POA creation: ORB not CORBA 2.3 compliant???");
		throw Components::Deployment::InstallationFailure();
	}

	// Set servant locator
	try
	{
	    home_poa_->set_servant_manager (servant_locator_);
	}
	catch (PortableServer::POA::WrongPolicy&)
	{
		// Cannot be, since our POA has the right policies
		NORMAL_ERR ("HomeServantBase: Fatal internal error - Setting servant manager complains about a wrong policy???");
		throw Components::Deployment::InstallationFailure();
	}

	my_home_servant_ = dynamic_cast <PortableServer::Servant> (this);

	if (! my_home_servant_)
	{
		NORMAL_ERR ("HomeServantBase: initialize(): Cannot dynamic_cast this pointer to PortableServer::Servant");
		throw Components::Deployment::InstallationFailure();
	}

	// Activate the POA using the POA manager
	home_poa_manager_ = home_poa_->the_POAManager();

	home_poa_manager_->activate();

	// Create a first object reference, which belongs to this home
	CORBA::Object_var home_obj = this->create_primary_object_reference (repository_id_);
	my_object_id_ = this->reference_to_oid (home_obj);

	// Narrow the object reference for the home (this can involve remote _is_a() calls to the
	// servant, so it must be active at this time)
	my_home_ref_ = Components::CCMHome::_narrow (home_obj);
}