Embedded OpenDS 1.0.0

I was recently playing with OpenDS LDAP server 1.0.0. As its pure Java implementation it is used in embedded mode in JBoss AS and JBoss Portal testsuites. What is so cool about embedded OpenDS and why you should look at it?

• It requires only two jar files for basic features support
  
• Just few lines of code for management operations are needed.
• Community on the mailing lists is very responsive

There are few good resources describing how to embed OpenDS available on the web:

• https://www.opends.org/wiki/page/UsingOpenDSAsAnEmbeddedApplication
• https://www.opends.org/wiki/attach/OpenDSPresentations/OpenDS_Jazoon08.pdf
  
• http://wiki.interldap.objectweb.org/xwiki/bin/view/Main/EmbeddedLDAP

However as the project evolves rapidly they don't cover the most recent 1.0.0 version. Here are few simple steps needed to bootstrap OpenDS from Java code:

1. Download OpenDS 1.0.0 and unzip it.
2. Fire the 'setup' config script from the main directory and alter the configuration as you need. Remember to shutdown the server if you let to start it.
3. Embedded OpenDS will require a special directory structure to be able to start. All needed files can be copied from the server directory and are shown on the picture below:
   
   The 'db' directory can be left empty if you want to add the root entry manually in the code
   
   
4. Copy OpenDS.jar and je.jar files from OpenDS-1.0.0/lib/ directory and add them to the project classpath
   
5. Edit opends/config/config.ldif and remove following entry:
   
   dn: cn=SNMP Connection Handler,cn=Connection Handlers,cn=config
   objectClass: top
   objectClass: ds-cfg-snmp-connection-handler
   objectClass: ds-cfg-connection-handler
   ds-cfg-listen-port: 161
   ds-cfg-enabled: false
   ds-cfg-trap-port: 162
   ds-cfg-java-class: org.opends.server.snmp.SNMPConnectionHandler
   cn: SNMP Connection Handler
   
   (This entry requires to have OpenDS-1.0.0/lib/extensions/snmp-mib2605.jar file on the classpath)

Now with such prepared directory structure OpenDS can be started directly from the Java code. Belpw there is a very simple class that manages server lifecycle - it just needs two jar files in the classpath (OpenDS.jar and je.jar)

view plainprint?

1. public class OpenDSService  
2. {  
3.   private String serverRoot = "";  
4.   
5.   public DirectoryEnvironmentConfig getConfig()  
6.   {  
7.      DirectoryEnvironmentConfig config = new DirectoryEnvironmentConfig();  
8.   
9.      try  
10.      {  
11.          
12.         // Server root points to the directory with opends configuration  
13.         config.setServerRoot(new File(getServerRoot()));  
14.         config.setForceDaemonThreads(true);  
15.   
16.      }  
17.      catch (InitializationException e)  
18.      {  
19.         e.printStackTrace();  
20.      }  
21.   
22.      return config;  
23.   }  
24.   
25.   
26.   public void start()  
27.   {  
28.      if (!EmbeddedUtils.isRunning())  
29.      {  
30.         try  
31.         {  
32.            EmbeddedUtils.startServer(getConfig());  
33.         }  
34.         catch (Exception e)  
35.         {  
36.            e.printStackTrace();  
37.         }  
38.      }  
39.   }  
40.   
41.   public void stop()  
42.   {  
43.      if (EmbeddedUtils.isRunning())  
44.      {  
45.         EmbeddedUtils.stopServer(this.getClass().getName(), null);  
46.      }  
47.   }  
48.   
49.   public String getServerRoot()  
50.   {  
51.      return serverRoot;  
52.   }  
53.   
54.   public void setServerRoot(String serverRoot)  
55.   {  
56.      this.serverRoot = serverRoot;  
57.   }  
58. }  

public class OpenDSService
{
  private String serverRoot = "";

  public DirectoryEnvironmentConfig getConfig()
  {
     DirectoryEnvironmentConfig config = new DirectoryEnvironmentConfig();

     try
     {
       
        // Server root points to the directory with opends configuration
        config.setServerRoot(new File(getServerRoot()));
        config.setForceDaemonThreads(true);

     }
     catch (InitializationException e)
     {
        e.printStackTrace();
     }

     return config;
  }


  public void start()
  {
     if (!EmbeddedUtils.isRunning())
     {
        try
        {
           EmbeddedUtils.startServer(getConfig());
        }
        catch (Exception e)
        {
           e.printStackTrace();
        }
     }
  }

  public void stop()
  {
     if (EmbeddedUtils.isRunning())
     {
        EmbeddedUtils.stopServer(this.getClass().getName(), null);
     }
  }

  public String getServerRoot()
  {
     return serverRoot;
  }

  public void setServerRoot(String serverRoot)
  {
     this.serverRoot = serverRoot;
  }
}

Here there is a trivial example maven project that starts opends and performs simple JNDI search.