Java Code Examples for com.sun.corba.se.spi.orb.ORB#resolve_initial_references()

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}
 

/**
 * Main startup routine for the bootstrap server.
 * It first determines the port on which to listen, checks that the
 * specified file is available, and then creates the resolver
 * that will be used to service the requests in the
 * BootstrapServerRequestDispatcher.
 * @param args the command-line arguments to the main program.
 */
public static final void main(String[] args)
{
    String propertiesFilename = null;
    int initialPort = ORBConstants.DEFAULT_INITIAL_PORT;

    // Process arguments
    for (int i=0;i<args.length;i++) {
        // Look for the filename
        if (args[i].equals("-InitialServicesFile") && i < args.length -1) {
            propertiesFilename = args[i+1];
        }

        // Was the initial port specified? If so, override
        // This property normally is applied for the client side
        // configuration of resolvers.  Here we are using it to
        // define the server port that the with which the resolvers
        // communicate.
        if (args[i].equals("-ORBInitialPort") && i < args.length-1) {
            initialPort = java.lang.Integer.parseInt(args[i+1]);
        }
    }

    if (propertiesFilename == null) {
        System.out.println( CorbaResourceUtil.getText("bootstrap.usage",
            "BootstrapServer"));
        return;
    }

    // Create a file
    File file = new File(propertiesFilename);

    // Verify that if it exists, it is readable
    if (file.exists() == true && file.canRead() == false) {
        System.err.println(CorbaResourceUtil.getText(
            "bootstrap.filenotreadable", file.getAbsolutePath()));
        return;
    }

    // Success: start up
    System.out.println(CorbaResourceUtil.getText(
        "bootstrap.success", Integer.toString(initialPort),
        file.getAbsolutePath()));

    Properties props = new Properties() ;

    // Use the SERVER_PORT to create an Acceptor using the
    // old legacy code in ORBConfiguratorImpl.  When (if?)
    // the legacy support is removed, this code will need
    // to create an Acceptor directly.
    props.put( ORBConstants.SERVER_PORT_PROPERTY,
        Integer.toString( initialPort ) ) ;

    ORB orb = (ORB) org.omg.CORBA.ORB.init(args,props);

    LocalResolver lres = orb.getLocalResolver() ;
    Resolver fres = ResolverDefault.makeFileResolver( orb, file ) ;
    Resolver cres = ResolverDefault.makeCompositeResolver( fres, lres ) ;
    LocalResolver sres = ResolverDefault.makeSplitLocalResolver( cres, lres ) ;

    orb.setLocalResolver( sres ) ;

    try {
        // This causes the acceptors to start listening.
        orb.resolve_initial_references(ORBConstants.ROOT_POA_NAME);
    } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
        RuntimeException rte = new RuntimeException("This should not happen");
        rte.initCause(e);
        throw rte;
    }

    orb.run() ;
}
 

/**
 * Create NameService which starts the Root Naming Context in Persistent CosNaming
 * @param orb an ORB object.
 * @param logDir a File
 * @exception java.lang.Exception a Java exception.
 */
public NameService(ORB orb, File logDir)
    throws Exception
{
    theorb = orb;

    // Moved this to the creation of the ORB that is passed into this
    // constructor.
    //
    // This is required for creating Persistent Servants under this ORB
    // Right now the Persistent NameService and ORBD are launched together
    // Find out a better way of doing this, Since ORBD is an important
    // process which should not be killed because of some external process
    // orb.setPersistentServerId( (int) 1000 );

    // get and activate the root naming POA
    POA rootPOA = (POA)orb.resolve_initial_references(
        ORBConstants.ROOT_POA_NAME ) ;
    rootPOA.the_POAManager().activate();

    // create a new POA for persistent Naming Contexts
    // With Non-Retain policy, So that every time Servant Manager
    // will be contacted when the reference is made for the context
    // The id assignment is made by the NameServer, The Naming Context
    // id's will be in the format NC<Index>
    int i=0;
    Policy[] poaPolicy = new Policy[4];
    poaPolicy[i++] = rootPOA.create_lifespan_policy(
                     LifespanPolicyValue.PERSISTENT);
    poaPolicy[i++] = rootPOA.create_request_processing_policy(
                     RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
    poaPolicy[i++] = rootPOA.create_id_assignment_policy(
                     IdAssignmentPolicyValue.USER_ID);
    poaPolicy[i++] = rootPOA.create_servant_retention_policy(
                     ServantRetentionPolicyValue.NON_RETAIN);


    nsPOA = rootPOA.create_POA("NameService", null, poaPolicy);
    nsPOA.the_POAManager().activate( );

    // create and set the servant manager
    contextMgr = new
        ServantManagerImpl(orb, logDir, this );

    // The RootObject key will be NC0
    String rootKey = contextMgr.getRootObjectKey( );
    // initialize the root Naming Context
    NamingContextImpl nc =
            new NamingContextImpl( orb, rootKey, this, contextMgr );
    nc = contextMgr.addContext( rootKey, nc );
    nc.setServantManagerImpl( contextMgr );
    nc.setORB( orb );
    nc.setRootNameService( this );

    nsPOA.set_servant_manager(contextMgr);
    rootContext = NamingContextHelper.narrow(
    nsPOA.create_reference_with_id( rootKey.getBytes( ),
    NamingContextHelper.id( ) ) );
}