public NamingService() 
{

}

 public  void createAlias(String fromName,
    String toName) throws Exception 
{
      Util.createLinkRef(fromName, toName);
      log.info("Created alias " + fromName + "- >" + toName);
}

 public int getBacklog() 
{
      return namingMain.getBacklog();
}

 public String getBindAddress() 
{
      return namingMain.getBindAddress();
}

 public String getBootstrapURL() 
{
      return namingMain.getBootstrapURL();
}

 public boolean getCallByValue() 
{
      return MarshalledValuePair.getEnableCallByReference() == false;
}

Get the call by value flag for jndi lookups.

 public String getClientSocketFactory() 
{
      return namingMain.getClientSocketFactory();
}

 public RMIClientSocketFactory getClientSocketFactoryBean() 
{
      return namingMain.getClientSocketFactoryBean();
}

 public boolean getInstallGlobalService() 
{
      return namingMain.getInstallGlobalService();
}

 public String getJNPServerSocketFactory() 
{
      return namingMain.getJNPServerSocketFactory();
}

 public ServerSocketFactory getJNPServerSocketFactoryBean() 
{
      return namingMain.getJNPServerSocketFactoryBean();
}

 public Exception getLookupListenerException() 
{
      return namingMain.getLookupListenerException();
}

 public Map getMethodMap() 
{
      return marshalledInvocationMapping;
}

Expose the Naming service interface mapping as a read-only attribute

 public NamingBean getNaming() 
{
      return getNamingInfo();
}

 public NamingBean getNamingInfo() 
{
      return namingBean;
}

 public Naming getNamingInstance() 
{
      return namingBean.getNamingInstance();
}

 public Object getNamingProxy() throws Exception 
{
      Object proxy = null;
      if(proxyFactory != null)
         proxy = proxyFactory.getProxy();
      else
         proxy = namingMain.getNamingProxy();
      return proxy;
}

 protected Main getNamingServer() 
{
      return namingMain;
}

The getNamingServer method makes this class extensible, but it is a hack. The NamingServer should be exposed directly as an xmbean, and the startup logic put in either an interceptor, the main class itself, or an auxilliary mbean (for the enc).

 public int getPort() 
{
      return namingMain.getPort();
}

 public String getRmiBindAddress() 
{
      return namingMain.getRmiBindAddress();
}

 public int getRmiPort() 
{
      return namingMain.getRmiPort();
}

 public String getServerSocketFactory() 
{
      return namingMain.getServerSocketFactory();
}

 public RMIServerSocketFactory getServerSocketFactoryBean() 
{
      return namingMain.getServerSocketFactoryBean();
}

 public boolean getUseGlobalService() 
{
      return namingMain.getUseGlobalService();
}

 public Object invoke(Invocation invocation) throws Exception 
{
      Naming theServer = namingMain.getNamingInstance();
      // Set the method hash to Method mapping
      if (invocation instanceof MarshalledInvocation)
      {
         MarshalledInvocation mi = (MarshalledInvocation) invocation;
         mi.setMethodMap(marshalledInvocationMapping);
      }
      // Invoke the Naming method via reflection
      Method method = invocation.getMethod();
      Object[] args = invocation.getArguments();
      Object value = null;
      try
      {
         value = method.invoke(theServer, args);
      }
      catch(InvocationTargetException e)
      {
         Throwable t = e.getTargetException();
         if( t instanceof Exception )
            throw (Exception) t;
         else
            throw new UndeclaredThrowableException(t, method.toString());
      }
      return value;
}

Expose the Naming service via JMX to invokers.

 public  void removeAlias(String name) throws Exception 
{
      log.info("Removing alias " + name);
      Util.removeLinkRef(name);
}

 public  void setBacklog(int backlog) 
{
      namingMain.setBacklog(backlog);
}

 public  void setBindAddress(String host) throws UnknownHostException 
{
      namingMain.setBindAddress(host);
}

 public  void setCallByValue(boolean flag) 
{
      boolean callByValue = ! flag;
      MarshalledValuePair.setEnableCallByReference(callByValue);
}

Set the call by value flag for jndi lookups.

 public  void setClientSocketFactory(String factoryClassName) throws ClassNotFoundException, InstantiationException, IllegalAccessException 
{
      namingMain.setClientSocketFactory(factoryClassName);
}

 public  void setClientSocketFactoryBean(RMIClientSocketFactory factory) 
{
      namingMain.setClientSocketFactoryBean(factory);
}

 public  void setInstallGlobalService(boolean flag) 
{
      namingMain.setInstallGlobalService(flag);
}

 public  void setInvokerProxyFactory(JRMPProxyFactoryMBean proxyFactory) 
{
      this.proxyFactory = proxyFactory;
}

 public  void setJNPServerSocketFactory(String factoryClassName) throws ClassNotFoundException, InstantiationException, IllegalAccessException 
{
      namingMain.setJNPServerSocketFactory(factoryClassName);
}

 public  void setJNPServerSocketFactoryBean(ServerSocketFactory factory) 
{
      namingMain.setJNPServerSocketFactoryBean(factory);
}

 public  void setLookupPool(BasicThreadPoolMBean poolMBean) 
{
      ThreadPool lookupPool = poolMBean.getInstance();
      namingMain.setLookupPool(lookupPool);
}

Set the thread pool used for the bootstrap lookups

 public  void setNaming(NamingBean bean) 
{
      setNamingInfo(bean);
}

 public  void setNamingInfo(NamingBean bean) 
{
      this.namingBean = bean;
      this.namingMain.setNamingInfo(bean);
}

 public  void setNamingProxy(Object proxy) throws IOException 
{
      namingMain.setNamingProxy(proxy);
}

 public  void setPort(int port) 
{
      namingMain.setPort(port);
}

 public  void setRmiBindAddress(String host) throws UnknownHostException 
{
      namingMain.setRmiBindAddress(host);
}

 public  void setRmiPort(int port) 
{
      namingMain.setRmiPort(port);
}

 public  void setServerSocketFactory(String factoryClassName) throws ClassNotFoundException, InstantiationException, IllegalAccessException 
{
      namingMain.setServerSocketFactory(factoryClassName);
}

 public  void setServerSocketFactoryBean(RMIServerSocketFactory factory) 
{
      namingMain.setServerSocketFactoryBean(factory);
}

 public  void setUseGlobalService(boolean flag) 
{
      namingMain.setUseGlobalService(flag);
}

 protected  void startService() throws Exception 
{
      boolean debug = log.isDebugEnabled();
      // Read jndi.properties into system properties
      ClassLoader loader = Thread.currentThread().getContextClassLoader();
      InputStream is = loader.getResourceAsStream("jndi.properties");
      if (is == null)
         throw new RuntimeException("Cannot find jndi.properties, it should be at conf/jndi.properties by default.");
      Properties props = new Properties();
      try
      {
         props.load(is);
      }
      finally
      {
         is.close();
      }
      for (Enumeration keys = props.propertyNames(); keys.hasMoreElements(); )
      {
         String key = (String) keys.nextElement();
         String value = props.getProperty(key);
         if (debug)
         {
            log.debug("System.setProperty, key="+key+", value="+value);
         }
         System.setProperty(key, value);
      }
      if( proxyFactory != null )
         namingMain.setNamingProxy(proxyFactory.getProxy());
      namingMain.start();
      // Build the Naming interface method map
      HashMap tmpMap = new HashMap(13);
      Method[] methods = Naming.class.getMethods();
      for(int m = 0; m <  methods.length; m ++)
      {
         Method method = methods[m];
         Long hash = new Long(MarshalledInvocation.calculateHash(method));
         tmpMap.put(hash, method);
      }
      marshalledInvocationMapping = Collections.unmodifiableMap(tmpMap);
}

 protected  void stopService() throws Exception 
{
      namingMain.stop();
      log.debug("JNP server stopped");
}