OPENDJ-2413 Create new EmbeddedDirectoryServer class as API entry point

Nicolas Capponi

26.02.2016 256c2bcdd00b78a349feef7e2258364cea0e832f

OPENDJ-2413 Create new EmbeddedDirectoryServer class as API entry point

Create new classes to hold parameters of operations on the directory
server: ConnectionParameters, ImportParameters, RebuildIndexParameters,
ReplicationParameters, SetupParameters, UpgradeParameters

 opendj-server-legacy/pom.xml

@@ -199,13 +199,6 @@
    </dependency>

    <dependency>
      <groupId>org.forgerock.opendj</groupId>
      <artifactId>opendj-core</artifactId>
      <type>test-jar</type>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.freemarker</groupId>
      <artifactId>freemarker</artifactId>
      <version>${freemarker.version}</version>

 opendj-server-legacy/src/main/java/org/opends/server/config/ConfigurationHandler.java

@@ -183,8 +183,9 @@
    {
      if (!configFramework.isInitialized())
      {
        configFramework.initialize();
        configFramework.initialize(serverContext.getServerRoot(), serverContext.getInstanceRoot());
      }
      configFramework.setIsClient(false);
    }
    catch (ConfigException e)
    {

 opendj-server-legacy/src/main/java/org/opends/server/util/EmbeddedUtils.java

@@ -12,7 +12,7 @@
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2008 Sun Microsystems, Inc.
 * Portions Copyright 2014 ForgeRock AS.
 * Portions Copyright 2014-2016 ForgeRock AS.
 */
package org.opends.server.util;

@@ -69,7 +69,7 @@
    if (DirectoryServer.isRunning())
    {
      throw new InitializationException(
              ERR_EMBEDUTILS_SERVER_ALREADY_RUNNING.get());
              ERR_EMBEDUTILS_SERVER_ALREADY_RUNNING.get(config.getServerRootAsString()));
    }

    DirectoryServer directoryServer = DirectoryServer.reinitialize(config);

 opendj-server-legacy/src/main/java/org/opends/server/util/StaticUtils.java

@@ -19,6 +19,7 @@
import static org.opends.messages.UtilityMessages.*;
import static org.opends.server.util.ServerConstants.*;

import java.io.BufferedOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
@@ -43,6 +44,8 @@
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.i18n.LocalizableMessageBuilder;
@@ -89,6 +92,9 @@
  /** The number of bytes of a Java long. A Java int is 64 bits, i.e. 8 bytes. */
  public static final int LONG_SIZE = 8;

  /** Size of buffer used to copy/move/extract files. */
  public static final int BUFFER_SIZE = 8192;

  /**
   * Number of bytes in a Kibibyte.
   * <p>
@@ -2477,5 +2483,64 @@
      return false;
    }
  }

  /**
   * Extracts the provided zip archive to the provided target directory.
   * <p>
   * Archive files ending by "sh" or beginning by "bin" are set as executable files.
   *
   * @param zipFile
   *            The zip file to extract.
   * @param targetDirectory
   *            The target directory for the content of the archive.
   * @throws IOException
   *            If zip archive can't be read or target files can be written.
   */
  public static void extractZipArchive(File zipFile, File targetDirectory) throws IOException
  {
    try (ZipInputStream zipStream = new ZipInputStream(new FileInputStream(zipFile)))
    {
      ZipEntry fileEntry;
      while ((fileEntry = zipStream.getNextEntry()) != null)
      {
        File targetFile = new File(targetDirectory.getPath() + File.separator +  fileEntry.getName());

        if (fileEntry.isDirectory())
        {
          targetFile.mkdir();
          continue;
        }
        extractFileFromZip(zipStream, targetFile);

        if (fileEntry.getName().endsWith("sh") || fileEntry.getName().startsWith("bin"))
        {
          targetFile.setExecutable(true);
        }
      }
    }
  }

  /**
   * Extracts a file from a zip input stream.
   *
   * @param zipInput
   *          The input stream of a zip file.
   * @param targetFile
   *          The destination of the extracted file.
   * @throws IOException
   *           If the zip file can't be read or the target file can't be written
   */
  private static void extractFileFromZip(ZipInputStream zipInput, File targetFile) throws IOException
  {
    try (BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(targetFile)))
    {
      int bytesRead = 0;
      byte[] bytes = new byte[BUFFER_SIZE];
      while ((bytesRead = zipInput.read(bytes)) != -1)
      {
        outputStream.write(bytes, 0, bytesRead);
      }
    }
  }
}


 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/ConfigParameters.java

New file
@@ -0,0 +1,127 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

/**
 * Parameters to configure a directory server.
 */
public final class ConfigParameters
{
  private String serverRootDirectory;
  private String serverInstanceDirectory;
  private String configurationFile;

  private ConfigParameters()
  {
    // private constructor to force usage of the associated Builder
  }

  String getServerRootDirectory()
  {
    return serverRootDirectory;
  }

  String getServerInstanceDirectory()
  {
    // provides the expected default value if not set
    return serverInstanceDirectory != null ? serverInstanceDirectory : serverRootDirectory;
  }

  String getConfigurationFile()
  {
    return configurationFile;
  }

  /**
   * Builder for this class.
   */
  public static final class Builder
  {
    private ConfigParameters params;

    private Builder()
    {
      params = new ConfigParameters();
    }

    /**
     * Creates a builder for the configuration parameters.
     *
     * @return a builder
     */
    public static Builder configParams()
    {
      return new Builder();
    }

    /**
     * Generates the parameters from this builder.
     * <p>
     * After this call, the builder is reset and can be used to generate other parameters.
     *
     * @return the replication parameters
     */
    public ConfigParameters toParams()
    {
      ConfigParameters p = params;
      this.params = new ConfigParameters();
      return p;
    }

    /**
     * Sets the server root directory of the directory server.
     * <p>
     * The server root is the location where the binaries and default configuration is stored.
     *
     * @param dir
     *          the server root directory
     * @return this builder
     */
    public Builder serverRootDirectory(String dir)
    {
      params.serverRootDirectory = dir;
      return this;
    }

    /**
     * Sets the install root directory of the directory server.
     * <p>
     * The install root is the location where the data and live configuration is stored.
     *
     * @param dir
     *          the install root directory
     * @return this builder
     */
    public Builder serverInstanceDirectory(String dir)
    {
      params.serverInstanceDirectory = dir;
      return this;
    }

    /**
     * Sets the path of the configuration file of the directory server.
     *
     * @param file
     *          the configuration file
     * @return this builder
     */
    public Builder configurationFile(String file)
    {
      params.configurationFile = file;
      return this;
    }
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/ConnectionParameters.java

New file
@@ -0,0 +1,198 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

/**
 * Parameters to establish connections to a directory server.
 */
public final class ConnectionParameters
{
  private String adminPassword;
  private Integer adminPort;
  private String adminUid;
  private String bindDn;
  private String bindPassword;
  private String hostname;
  private Integer ldapPort;

  private ConnectionParameters()
  {
    // private constructor to force usage of the associated Builder
  }

  String getAdminPassword()
  {
    return adminPassword;
  }

  Integer getAdminPort()
  {
    return adminPort;
  }

  String getAdminUid()
  {
    return adminUid;
  }

  String getBindDn()
  {
    return bindDn;
  }

  String getBindPassword()
  {
    return bindPassword;
  }

  String getHostname()
  {
    return hostname;
  }

  Integer getLdapPort()
  {
    return ldapPort;
  }

  /**
   * Builder for the ConnectionParameters class.
   */
  public static final class Builder
  {
    private ConnectionParameters params;

    private Builder()
    {
      params = new ConnectionParameters();
    }

    /**
     * Creates a builder for the connection parameters.
     *
     * @return a builder
     */
    public static Builder connectionParams()
    {
      return new Builder();
    }

    /**
     * Generates the parameters from this builder.
     * <p>
     * After this call, the builder is reset and can be used to generate other parameters.
     *
     * @return the replication parameters
     */
    public ConnectionParameters toParams()
    {
      ConnectionParameters p = params;
      this.params = new ConnectionParameters();
      return p;
    }

    /**
     * Sets the password of the Global Administrator to use to bind to the server.
     *
     * @param password
     *          the password
     * @return this builder
     */
    public Builder adminPassword(String password)
    {
      params.adminPassword = password;
      return this;
    }

    /**
     * Sets the port for directory server administration.
     *
     *  @param port
     *          the admin port
     * @return this builder
     */
    public Builder adminPort(int port)
    {
      params.adminPort = port;
      return this;
    }

    /**
     * Sets the user id of the Global Administrator to use to bind to the server.
     *
     * @param uid
     *          the user id
     * @return this builder
     */
    public Builder adminUid(String uid)
    {
      params.adminUid = uid;
      return this;
    }

    /**
     * Sets the Dn to use to bind to the directory server.
     *
     * @param dn
     *          the bind Dn
     * @return this builder
     */
    public Builder bindDn(String dn)
    {
      params.bindDn = dn;
      return this;
    }

    /**
     * Sets the password to use to bind to the directory server.
     *
     * @param password
     *          the bind password
     * @return this builder
     */
    public Builder bindPassword(String password)
    {
      params.bindPassword = password;
      return this;
    }

    /**
     * Sets the the fully-qualified directory server host name.
     *
     * @param hostname
     *          the hostname of the server
     * @return this builder
     */
    public Builder hostname(String hostname)
    {
      params.hostname = hostname;
      return this;
    }

    /**
     * Sets the port on which the directory server listen for LDAP communication.
     *
     * @param port
     *          the LDAP port
     * @return this builder
     */
    public Builder ldapPort(int port)
    {
      params.ldapPort = port;
      return this;
    }
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/EmbeddedDirectoryServer.java

New file
@@ -0,0 +1,591 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

import static org.forgerock.opendj.config.client.ldap.LDAPManagementContext.newManagementContext;
import static org.forgerock.opendj.config.client.ldap.LDAPManagementContext.newLDIFManagementContext;
import static org.opends.messages.UtilityMessages.*;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.opendj.adapter.server3x.Adapters;
import org.forgerock.opendj.config.LDAPProfile;
import org.forgerock.opendj.config.client.ManagementContext;
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.ldap.Connection;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.LDAPConnectionFactory;
import org.forgerock.opendj.server.config.client.RootCfgClient;
import org.forgerock.util.Pair;
import org.opends.quicksetup.TempLogFile;
import org.opends.server.core.DirectoryServer;
import org.opends.server.protocols.internal.InternalClientConnection;
import org.opends.server.tools.ImportLDIF;
import org.opends.server.tools.InstallDS;
import org.opends.server.tools.RebuildIndex;
import org.opends.server.tools.dsreplication.ReplicationCliMain;
import org.opends.server.tools.upgrade.UpgradeCli;
import org.opends.server.types.DirectoryEnvironmentConfig;
import org.opends.server.types.DirectoryException;
import org.opends.server.types.InitializationException;
import org.opends.server.util.ServerConstants;
import org.opends.server.util.StaticUtils;

/**
 * Represents an embedded directory server on which high-level operations
 * are available (setup, upgrade, start, stop, ...).
 */
public class EmbeddedDirectoryServer
{
  private static final String EMBEDDED_OPEN_DJ_PREFIX = "embeddedOpenDJ";

  /** The parameters for install and instance directories, and configuration file of the server. */
  private final ConfigParameters configParams;

  /** The connection parameters for the server. */
  private final ConnectionParameters connectionParams;

  /** The connection factory to get connections to the server. */
  private final LDAPConnectionFactory ldapConnectionFactory;

  /** The output stream used for feedback during operations on server. */
  private final OutputStream outStream;

  /** The error stream used for feedback during operations on server. */
  private final OutputStream errStream;

  /**
   * Defines an embedded directory server, providing the output and error streams used for
   * giving feedback during operations on the server.
   *
   * @param configParams
   *          The basic configuration parameters for the server.
   * @param connParams
   *          The connection parameters for the server.
   * @param out
   *          Output stream used for feedback during operations on server
   * @param err
   *          Error stream used for feedback during operations on server
   */
  private EmbeddedDirectoryServer(ConfigParameters configParams, ConnectionParameters connParams,
      OutputStream out, OutputStream err)
  {
    this.configParams = configParams;
    this.connectionParams = connParams;
    this.outStream = out;
    this.errStream = err;
    this.ldapConnectionFactory = connectionParams != null ?
        new LDAPConnectionFactory(connectionParams.getHostname(), connectionParams.getLdapPort())
        : null;

    System.setProperty("org.opends.quicksetup.Root", configParams.getServerRootDirectory());
    System.setProperty(ServerConstants.PROPERTY_SERVER_ROOT, configParams.getServerRootDirectory());
    System.setProperty(ServerConstants.PROPERTY_INSTANCE_ROOT, configParams.getServerInstanceDirectory());
    // from LicenseFile.java - provided by AM OpenDJUpgrader.java
    System.setProperty("INSTALL_ROOT", configParams.getServerInstanceDirectory());
  }

  /**
   * Defines an embedded directory server.
   * <p>
   * Output/error streams used for giving feedback during operations are default system ones.
   *
   * @param configParams
   *          The basic configuration parameters for the server.
   * @param connParams
   *          The connection parameters for the server.
   */
  private EmbeddedDirectoryServer(ConfigParameters configParams, ConnectionParameters connParams)
  {
    this(configParams, connParams, System.out, System.err);
  }

  /**
   * Defines an embedded directory server for any operation.
   *
   * @param configParams
   *          The basic configuration parameters for the server.
   * @param connParams
   *          The connection parameters for the server.
   * @param out
   *          Output stream used for feedback during operations on server
   * @param err
   *          Error stream used for feedback during operations on server
   * @return the directory server
   */
  public static EmbeddedDirectoryServer defineServer(ConfigParameters configParams,
      ConnectionParameters connParams, OutputStream out, OutputStream err)
  {
    return new EmbeddedDirectoryServer(configParams, connParams, out, err);
  }

  /**
   * Defines an embedded directory server for start/stop operation.
   * <p>
   * To be able to perform any operation on the server, use the alternative {@code defineServer()}
   * method.
   *
   * @param configParams
   *          The basic configuration parameters for the server.
   * @param out
   *          Output stream used for feedback during operations on server
   * @param err
   *          Error stream used for feedback during operations on server
   * @return the directory server
   */
  public static EmbeddedDirectoryServer defineServerForStartStopOperations(ConfigParameters configParams,
      OutputStream out, OutputStream err)
  {
    return new EmbeddedDirectoryServer(configParams, null, out, err);
  }

  /**
   * Displays the replication status on the output stream defined for this server.
   * <p>
   * Displays a list with the basic replication configuration of all base DNs of
   * the servers defined in the registration information.
   *
   * @param parameters
   *            The parameters for the replication.
   * @throws EmbeddedDirectoryServerException
   *            If a problem occurs.
   */
  public void displayReplicationStatus(ReplicationParameters parameters) throws EmbeddedDirectoryServerException
  {
    checkConnectionParameters();
    int returnCode = ReplicationCliMain.mainCLI(
        parameters.toCommandLineArgumentsStatus(configParams.getConfigurationFile(), connectionParams),
        !isRunning(), outStream, errStream);

    if (returnCode != 0)
    {
      throw new EmbeddedDirectoryServerException(
          ERR_EMBEDDED_SERVER_DISPLAY_REPLICATION_STATUS.get(configParams.getServerRootDirectory(), returnCode));
    }
  }

  /**
   * Enables replication between this directory server (first server) and another server
   * (second server).
   * <p>
   * Updates the configuration of the servers to replicate the data under the
   * base DN specified in the parameters.
   *
   * @param parameters
   *            The parameters for the replication.
   * @throws EmbeddedDirectoryServerException
   *            If a problem occurs.
   */
  public void enableReplication(ReplicationParameters parameters) throws EmbeddedDirectoryServerException
  {
    checkConnectionParameters();
    int returnCode = ReplicationCliMain.mainCLI(
        parameters.toCommandLineArgumentsEnable(configParams.getConfigurationFile(), connectionParams),
        !isRunning(), outStream, errStream);

    if (returnCode != 0)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_ENABLE_REPLICATION.get(
          configParams.getServerRootDirectory(), parameters.getReplicationPort1(), parameters.getHostname2(),
          parameters.getReplicationPort2(), returnCode));
    }
  }

  /**
   * Returns an internal connection to the server that will be authenticated as the specified user.
   *
   * @param userDn
   *            The user to be used for authentication to the server
   * @return the connection
   * @throws EmbeddedDirectoryServerException
   *            If the connection can't be returned
   */
  public Connection getInternalConnection(DN userDn) throws EmbeddedDirectoryServerException
  {
    try
    {
      return Adapters.newConnection(new InternalClientConnection(userDn));
    }
    catch (DirectoryException e)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_INTERNAL_CONNECTION.get(userDn));
    }
  }

  /**
   * Imports LDIF data to the directory server, overwriting existing data.
   *
   * @param parameters
   *            The import parameters.
   * @throws EmbeddedDirectoryServerException
   *            If the import fails
   */
  public void importData(ImportParameters parameters) throws EmbeddedDirectoryServerException
  {
    checkConnectionParameters();
    int returnCode = ImportLDIF.mainImportLDIF(
        parameters.toCommandLineArguments(configParams.getConfigurationFile(), connectionParams),
        !isRunning(), outStream, errStream);

    if (returnCode != 0)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_IMPORT_DATA.get(
          parameters.getLdifFile(), configParams.getServerRootDirectory(), returnCode));
    }
  }

  /**
   * Initializes replication between this server and another server.
   *
   * @param parameters
   *            The parameters for the replication.
   * @throws EmbeddedDirectoryServerException
   *            If a problem occurs.
   */
  public void initializeReplication(ReplicationParameters parameters) throws EmbeddedDirectoryServerException
  {
    checkConnectionParameters();
    int returnCode = ReplicationCliMain.mainCLI(
        parameters.toCommandLineArgumentsInitialize(configParams.getConfigurationFile(), connectionParams),
        !isRunning(), outStream, errStream);

    if (returnCode != 0)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_INITIALIZE_REPLICATION.get(
          configParams.getServerRootDirectory(), connectionParams.getAdminPort(), parameters.getHostname2(),
          parameters.getAdminPort2(), returnCode));
    }
  }

  /**
   * Indicates whether this server is currently running.
   *
   * @return {@code true} if the server is currently running, or {@code false} if not.
   */
  public boolean isRunning()
  {
    return DirectoryServer.isRunning();
  }

  /**
   * Reads the configuration of this server with the provided configuration reader.
   * <p>
   * The configuration reader provides access to the root configuration of the directory,
   * which can then be used to read any configuration object and return the result as an
   * arbitrary object.
   * <p>
   * Example:
   * <pre>
   * server.readConfiguration(new DirectoryConfigReader<List<String>>() {
   *   public List<String> read(RootCfgClient rootConfig) {
   *    return Arrays.asList(rootConfig.listSynchronizationProviders());
   *   }
   * });
   * </pre>
   * @param <R>
   *          the type of the returned result
   * @param configReader
   *          the reader of the configuration
   * @return the result of the read
   * @throws EmbeddedDirectoryServerException
   *            If the read fails
   */
  public <R> R readConfiguration(DirectoryConfigReader<R> configReader) throws EmbeddedDirectoryServerException
  {
    checkConnectionParameters();
    Pair<ManagementContext, Connection> contextAndConnection = getManagementContext();
    try
    {
      RootCfgClient rootConfig = contextAndConnection.getFirst().getRootConfiguration();
      return configReader.read(rootConfig);
    }
    catch (Exception e)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_READ_CONFIG.get(
          configParams.getServerRootDirectory(), StaticUtils.stackTraceToSingleLineString(e)));
    }
    finally
    {
      StaticUtils.close(contextAndConnection.getFirst(), contextAndConnection.getSecond());
    }
  }

  /**
   * Setups this server from the root directory.
   *
   * @param parameters
   *            The setup parameters.
   * @throws EmbeddedDirectoryServerException
   *            If the setup fails for any reason.
   */
  public void setup(SetupParameters parameters) throws EmbeddedDirectoryServerException
  {
    checkConnectionParameters();
    int returnCode = InstallDS.mainCLI(parameters.toCommandLineArguments(connectionParams), outStream, errStream,
        TempLogFile.newTempLogFile(EMBEDDED_OPEN_DJ_PREFIX));

    if (returnCode != 0)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_SETUP.get(
          configParams.getServerRootDirectory(),  parameters.getBaseDn(), parameters.getBackendType(), returnCode));
    }
  }

  /**
   * Setups this server from the provided archive.
   *
   * @param openDJZipFile
   *            The OpenDJ server archive.
   * @param parameters
   *            The installation parameters.
   * @throws EmbeddedDirectoryServerException
   *            If the setup fails for any reason.
   */
  public void setupFromArchive(File openDJZipFile, SetupParameters parameters) throws EmbeddedDirectoryServerException
  {
    checkConnectionParameters();
    try
    {
      StaticUtils.extractZipArchive(openDJZipFile, new File(configParams.getServerRootDirectory()));
    }
    catch (IOException e)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_SETUP_EXTRACT_ARCHIVE.get(
          openDJZipFile, configParams.getServerRootDirectory(), StaticUtils.stackTraceToSingleLineString(e)));
    }
    setup(parameters);
  }

  /**
   * Rebuilds all the indexes of this server.
   *
   * @param parameters
   *            The parameters for rebuilding the indexes.
   * @throws EmbeddedDirectoryServerException
   *            If an error occurs.
   */
  public void rebuildIndex(RebuildIndexParameters parameters) throws EmbeddedDirectoryServerException
  {
    int returnCode = RebuildIndex.mainRebuildIndex(
        parameters.toCommandLineArguments(), !isRunning(), outStream, errStream);

    if (returnCode != 0)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_REBUILD_INDEX.get(
          configParams.getServerRootDirectory(), returnCode));
    }
  }

  /**
   * Restarts the directory server.
   * <p>
   * This will perform an in-core restart in which the existing server instance will be shut down, a
   * new instance will be created, and it will be reinitialized and restarted.
   *
   * @param className
   *          The name of the class that initiated the restart.
   * @param reason
   *          A message explaining the reason for the restart.
   */
  public void restartServer(String className, LocalizableMessage reason)
  {
    DirectoryServer.restart(className, reason, DirectoryServer.getEnvironmentConfig());
  }

  /**
   * Starts this server.
   *
   * @throws EmbeddedDirectoryServerException
   *           If the server is already running, or if an error occurs during server initialization
   *           or startup.
   */
  public void start() throws EmbeddedDirectoryServerException
  {
    if (DirectoryServer.isRunning())
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDUTILS_SERVER_ALREADY_RUNNING.get(
          configParams.getServerRootDirectory()));
    }

    try
    {
      DirectoryEnvironmentConfig env = new DirectoryEnvironmentConfig();
      env.setServerRoot(new File(configParams.getServerRootDirectory()));
      env.setInstanceRoot(new File(configParams.getServerInstanceDirectory()));
      env.setForceDaemonThreads(true);
      env.setConfigFile(new File(configParams.getConfigurationFile()));

      DirectoryServer directoryServer = DirectoryServer.reinitialize(env);
      directoryServer.startServer();
    }
    catch (InitializationException | ConfigException e)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_START.get(
          configParams.getServerRootDirectory(), StaticUtils.stackTraceToSingleLineString(e)));
    }
  }

  /**
   * Stops this server.
   *
   * @param className
   *          The name of the class that initiated the shutdown.
   * @param reason
   *          A message explaining the reason for the shutdown.
   */
  public void stop(String className, LocalizableMessage reason)
  {
    DirectoryServer.shutDown(className, reason);
  }

  /**
   * Configures this server with the provided configuration updater.
   * <p>
   * The configuration updater provides access to the root configuration of the directory server,
   * which can then be used to perform one or more modifications on any configuration object.
   * <p>
   * Example:
   * <pre>
   * server.configure(new DirectoryConfigUpdater() {
   *
   *   public void update(RootCfgClient rootConfig) {
   *     JEBackendCfgClient userRoot = (JEBackendCfgClient) rootConfig.getBackend("userRoot");
   *     userRoot.setBaseDN(Arrays.asList(DN.valueOf("dc=example,dc=com")));
   *     userRoot.setDBCachePercent(70);
   *     userRoot.commit();
   *   }
   * });
   * </pre>
   *
   * @param configUpdater
   *            updates the configuration
   * @throws EmbeddedDirectoryServerException
   *            If an error occurs.
   */
  public void updateConfiguration(DirectoryConfigUpdater configUpdater) throws EmbeddedDirectoryServerException
  {
    checkConnectionParameters();
    Pair<ManagementContext, Connection> contextAndConnection = getManagementContext();
    try {
      RootCfgClient rootConfig = contextAndConnection.getFirst().getRootConfiguration();
      configUpdater.update(rootConfig);
    } catch (Exception e) {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_UPDATE_CONFIG.get(
          configParams.getServerRootDirectory(), StaticUtils.stackTraceToSingleLineString(e)));
    }
    finally
    {
      StaticUtils.close(contextAndConnection.getFirst(), contextAndConnection.getSecond());
    }
  }

  /**
   * Upgrades this server.
   * <p>
   * Upgrades the server configuration and application data so that it is compatible
   * with the installed binaries.
   *
   * @param parameters
   *          The upgrade parameters.
   * @throws EmbeddedDirectoryServerException
   *            If the upgrade fails
   */
  public void upgrade(UpgradeParameters parameters) throws EmbeddedDirectoryServerException
  {
    int returnCode = UpgradeCli.main(parameters.toCommandLineArguments(
            configParams.getConfigurationFile()), !isRunning(), outStream, errStream);

    if (returnCode != 0)
    {
      throw new EmbeddedDirectoryServerException(ERR_EMBEDDED_SERVER_UPGRADE.get(
          configParams.getServerRootDirectory(), returnCode));
    }
  }

  /**
   * Interface to update the configuration of the directory server.
   */
  public interface DirectoryConfigUpdater
  {
    /**
     * Updates the configuration, provided the root configuration object of the directory server.
     *
     * @param rootConfig
     *          The root configuration of the server.
     * @throws Exception
     *          If an error occurs.
     */
    public void update(RootCfgClient rootConfig) throws Exception;
  }

  /**
   * Interface to read the configuration of the directory server.
   *
   * @param <R>
   *            The type of the result returned by the read operation.
   */
  public interface DirectoryConfigReader<R>
  {
    /**
     * Reads the configuration, provided the root configuration object of the directory server.
     *
     * @param rootConfig
     *          The root configuration of the server.
     * @return the result of the read operation
     * @throws Exception
     *          If an error occurs.
     */
    public R read(RootCfgClient rootConfig) throws Exception;
  }

  private void checkConnectionParameters() throws EmbeddedDirectoryServerException
  {
    if (connectionParams == null)
    {
      throw new EmbeddedDirectoryServerException(LocalizableMessage.raw("Operation is not permitted"));
    }
  }

  /**
   * Retrieves the management context, and optionally a connection if the server is running, in order to
   * give access to the configuration of the server.
   */
  private Pair<ManagementContext, Connection> getManagementContext() throws EmbeddedDirectoryServerException
  {
    Connection ldapConnection = null;
    ManagementContext ctx = null;
    try
    {
      if (isRunning())
      {
        ldapConnection = ldapConnectionFactory.getConnection();
        ctx = newManagementContext(ldapConnection, LDAPProfile.getInstance());
      }
      else
      {
        ctx = newLDIFManagementContext(new File(configParams.getConfigurationFile()));
      }
      return Pair.of(ctx, ldapConnection);
    }
    catch (IOException e)
    {
      throw new EmbeddedDirectoryServerException(LocalizableMessage.raw("Error when initialising LDIF mgt ctx"));
    }
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/EmbeddedDirectoryServerException.java

New file
@@ -0,0 +1,53 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

import org.forgerock.i18n.LocalizableMessage;
import org.opends.server.types.OpenDsException;

/**
 * Exception that may be thrown by an embedded directory server if a problem occurs while
 * performing an operation on the server.
 */
public final class EmbeddedDirectoryServerException extends OpenDsException
{

  private static final long serialVersionUID = 1L;

  /**
   * Creates a new exception with the provided message.
   *
   * @param message
   *          The message that explains the problem that occurred.
   */
  public EmbeddedDirectoryServerException(LocalizableMessage message)
  {
    super(message);
  }

  /**
   * Creates a new exception with the provided message and root cause.
   *
   * @param message
   *          The message that explains the problem that occurred.
   * @param cause
   *          The exception that was caught to trigger this exception.
   */
  public EmbeddedDirectoryServerException(LocalizableMessage message, Throwable cause)
  {
    super(message, cause);
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/ImportParameters.java

New file
@@ -0,0 +1,116 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

/**
 * Parameters to import LDIF data to a directory server.
 */
public final class ImportParameters
{
  private String backendID;
  private String ldifFile;

  private ImportParameters()
  {
    // private constructor to force usage of the associated Builder
  }

  /**
   * Generates command-line arguments from the parameters.
   *
   * @return command-line arguments
   */
  String[] toCommandLineArguments(String configurationFile, ConnectionParameters connParams)
  {
    return new String[] {
      "--configFile", configurationFile,
      "--backendID", backendID,
      "--bindDN", connParams.getBindDn(),
      "--bindPassword", connParams.getBindPassword(),
      "--ldifFile", ldifFile,
      "--noPropertiesFile",
      "--trustAll"
    };
  }

  String getLdifFile()
  {
    return ldifFile;
  }

  /**
   * Builder for this class.
   */
  public static final class Builder
  {
    private ImportParameters params;

    private Builder()
    {
      params = new ImportParameters();
    }

    /**
     * Creates a builder for the import parameters.
     *
     * @return a builder
     */
    public static Builder importParams()
    {
      return new Builder();
    }

    /**
     * Generates the parameters from this builder.
     * <p>
     * After this call, the builder is reset and can be used to generate other parameters.
     *
     * @return the replication parameters
     */
    public ImportParameters toParams()
    {
      ImportParameters p = params;
      this.params = new ImportParameters();
      return p;
    }

    /**
     * Sets the backend id of the backend to import.
     *
     * @param id
     *          the backend id
     * @return this builder
     */
    public Builder backendId(String id)
    {
      params.backendID = id;
      return this;
    }

    /**
     * Sets the path to the LDIF file to be imported.
     *
     * @param ldifFile
     *          The path to the LDIF file
     * @return this builder
     */
    public Builder ldifFile(String ldifFile)
    {
      params.ldifFile = ldifFile;
      return this;
    }
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/RebuildIndexParameters.java

New file
@@ -0,0 +1,108 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

/**
 * Parameters to rebuild the indexes of a directory server.
 */
public final class RebuildIndexParameters
{
  private String configurationFile;
  private String baseDN;

  private RebuildIndexParameters()
  {
    // private constructor to force usage of the associated Builder
  }

  /**
   * Generates command-line arguments from the parameters.
   *
   * @return command-line arguments
   */
  String[] toCommandLineArguments()
  {
    return new String[] {
      "--configFile", configurationFile,
      "--baseDN", baseDN,
      "--rebuildAll",
      "--noPropertiesFile"
    };
  }

  /**
   * Builder for this class.
   */
  public static final class Builder
  {
    private RebuildIndexParameters params;

    private Builder()
    {
      params = new RebuildIndexParameters();
    }

    /**
     * Creates a builder for the rebuild index parameters.
     *
     * @return a builder
     */
    public static Builder rebuildIndexParams()
    {
      return new Builder();
    }

    /**
     * Generates the parameters from this builder.
     * <p>
     * After this call, the builder is reset and can be used to generate other parameters.
     *
     * @return the rebuild index parameters
     */
    public RebuildIndexParameters toParams()
    {
      RebuildIndexParameters p = params;
      this.params = new RebuildIndexParameters();
      return p;
    }

    /**
     * Sets the configuration file of the server.
     *
     * @param file
     *          the configuration file
     * @return this builder
     */
    public Builder configurationFile(String file)
    {
      params.configurationFile = file;
      return this;
    }

    /**
     * Sets the base Dn for user information in the directory server.
     *
     * @param baseDN
     *          the baseDN
     * @return this builder
     */
    public Builder baseDN(String baseDN)
    {
      params.baseDN = baseDN;
      return this;
    }
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/ReplicationParameters.java

New file
@@ -0,0 +1,219 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

/**
 * Parameters for replication operations on a directory server.
 */
public final class ReplicationParameters
{
  private String baseDn;
  private Integer replicationPort1;
  private Integer replicationPort2;
  private ConnectionParameters connParamsForHost2;

  private ReplicationParameters()
  {
    // private constructor to force usage of the associated Builder
  }

  /**
   * Generates the command-line arguments for enabling replication, from the parameters.
   *
   * @return command-line arguments
   */
  String[] toCommandLineArgumentsEnable(String configurationFile, ConnectionParameters connParams)
  {
    return new String[] {
      "enable",
      "--no-prompt",
      "--configFile", configurationFile,
      "--host1", connParams.getHostname(),
      "--port1", s(connParams.getAdminPort()),
      "--bindDN1", connParams.getBindDn(),
      "--bindPassword1", connParams.getBindPassword(),
      "--replicationPort1", s(replicationPort1),
      "--host2", connParamsForHost2.getHostname(),
      "--port2", s(connParamsForHost2.getAdminPort()),
      "--bindDN2", connParamsForHost2.getBindDn(),
      "--bindPassword2", connParamsForHost2.getBindPassword(),
      "--replicationPort2", s(replicationPort2),
      "--adminUID", connParams.getAdminUid(),
      "--adminPassword", connParams.getAdminPassword(),
      "--baseDN", baseDn,
      "--trustAll",
      "--noPropertiesFile" };
  }

  /**
   * Generates the command-line arguments for initializing replication, from the parameters.
   *
   * @return command-line arguments
   */
  String[] toCommandLineArgumentsInitialize(String configurationFile, ConnectionParameters connParams)
  {
    return new String[] {
      "initialize",
      "--no-prompt",
      "--configFile", configurationFile,
      "--hostSource", connParams.getHostname(),
      "--portSource", s(connParams.getAdminPort()),
      "--hostDestination", connParamsForHost2.getHostname(),
      "--portDestination", s(connParamsForHost2.getAdminPort()),
      "--adminUID", connParams.getAdminUid(),
      "--adminPassword", connParams.getAdminPassword(),
      "--baseDN", baseDn,
      "--trustAll",
      "--noPropertiesFile" };
  }

  /**
   * Generates the command-line arguments for output of the replication status, from the parameters.
   *
   * @return command-line arguments
   */
  String[] toCommandLineArgumentsStatus(String configurationFile, ConnectionParameters connParams)
  {
    return new String[] {
      "status",
      "--no-prompt",
      "--configFile", configurationFile,
      "--hostname", connParams.getHostname(),
      "--port", s(connParams.getAdminPort()),
      "--adminUID", connParams.getAdminUid(),
      "--adminPassword", connParams.getAdminPassword(),
      "--script-friendly",
      "--noPropertiesFile" };
  }

  int getReplicationPort1()
  {
    return replicationPort1;
  }

  int getReplicationPort2()
  {
    return replicationPort2;
  }

  String getHostname2()
  {
    return connParamsForHost2.getHostname();
  }

  int getAdminPort2()
  {
    return connParamsForHost2.getAdminPort();
  }

  /** Convert an integer to a String. */
  private String s(Integer val)
  {
    return String.valueOf(val);
  }

  /**
   * Builder for this class.
   */
  public static final class Builder
  {
    private ReplicationParameters params;

    private Builder()
    {
      params = new ReplicationParameters();
    }

    /**
     * Creates a builder for the replication parameters.
     *
     * @return a builder
     */
    public static Builder replicationParams()
    {
      return new Builder();
    }

    /**
     * Generates the parameters from this builder.
     * <p>
     * After this call, the builder is reset and can be used to generate other parameters.
     *
     * @return the replication parameters
     */
    public ReplicationParameters toParams()
    {
      ReplicationParameters p = params;
      this.params = new ReplicationParameters();
      return p;
    }

    /**
     * Sets the base Dn of the data to be replicated.
     *
     * @param baseDn
     *          the base Dn
     * @return this builder
     */
    public Builder baseDn(String baseDn)
    {
      params.baseDn = baseDn;
      return this;
    }

    /**
     * Sets the replication port of the first server whose contents will be replicated.
     * <p>
     * The first server should correspond to the embedded server on which the replication
     * operation is applied.
     *
     * @param port
     *          the replication port
     * @return this builder
     */
    public Builder replicationPort1(int port)
    {
      params.replicationPort1 = port;
      return this;
    }

    /**
     * Sets the replication port of the second server whose contents will be replicated.
     *
     * @param port
     *          the replication port
     * @return this builder
     */
    public Builder replicationPort2(int port)
    {
      params.replicationPort2 = port;
      return this;
    }

    /**
     * Sets the connection parameters of the second server whose contents will be replicated.
     *
     * @param host2Params
     *          The connection parameters
     * @return this builder
     */
    public Builder connectionParamsForHost2(ConnectionParameters.Builder host2Params)
    {
      params.connParamsForHost2 = host2Params.toParams();
      return this;
    }
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/SetupParameters.java

New file
@@ -0,0 +1,147 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

/**
 * Parameters to setup a directory server.
 */
public final class SetupParameters
{
  private String baseDn;
  private int jmxPort;
  private String backendType;

  private SetupParameters()
  {
    // private constructor to force usage of the associated Builder
  }

  /**
   * Generates command-line arguments from the parameters.
   *
   * @return command-line arguments
   */
  String[] toCommandLineArguments(ConnectionParameters connParams)
  {
    return new String[] {
      "--cli",
      "--noPropertiesFile",
      "--no-prompt",
      "--doNotStart",
      "--skipPortCheck",
      "--baseDN", baseDn,
      "--hostname", connParams.getHostname(),
      "--rootUserDN", connParams.getBindDn(),
      "--rootUserPassword", connParams.getBindPassword(),
      "--ldapPort", s(connParams.getLdapPort()),
      "--adminConnectorPort", s(connParams.getAdminPort()),
      "--jmxPort", s(jmxPort),
      "--backendType", backendType
    };
  }

  String getBaseDn()
  {
    return baseDn;
  }

  String getBackendType()
  {
    return backendType;
  }

  /** Convert an integer to a String. */
  private String s(Integer val)
  {
    return String.valueOf(val);
  }

  /**
   * Builder for this class.
   */
  public static final class Builder
  {
    private SetupParameters params;

    private Builder()
    {
      params = new SetupParameters();
    }

    /**
     * Creates a builder for the setup parameters.
     *
     * @return a builder
     */
    public static Builder setupParams()
    {
      return new Builder();
    }

    /**
     * Generates the parameters from this builder.
     * <p>
     * After this call, the builder is reset and can be used to generate other parameters.
     *
     * @return the replication parameters
     */
    public SetupParameters toParams()
    {
      SetupParameters p = params;
      this.params = new SetupParameters();
      return p;
    }

    /**
     * Sets the base Dn for user information in the directory server.
     *
     * @param baseDn
     *          the base Dn
     * @return this builder
     */
    public Builder baseDn(String baseDn)
    {
      params.baseDn = baseDn;
      return this;
    }

    /**
     * Sets the port on which the directory server should listen for JMX communication.
     *
     * @param jmxPort
     *          the JMX port
     * @return this builder
     */
    public Builder jmxPort(int jmxPort)
    {
      params.jmxPort = jmxPort;
      return this;
    }

    /**
     * Sets the type of the backend containing user information.
     *
     * @param backendType
     *          the backend type (e.g. je, pdb)
     * @return this builder
     */
    public Builder backendType(String backendType)
    {
      params.backendType = backendType;
      return this;
    }
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/UpgradeParameters.java

New file
@@ -0,0 +1,102 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.util.embedded;

import java.util.ArrayList;
import java.util.List;

/**
 * Parameters to upgrade a Directory Server.
 */
public final class UpgradeParameters
{
  private boolean ignoreErrors;

  private UpgradeParameters()
  {
    // private constructor to force usage of the associated Builder
  }

  /**
   * Generates command-line arguments from the parameters.
   *
   * @return command-line arguments
   */
  String[] toCommandLineArguments(String configurationFile)
  {
    List<String> args = new ArrayList<>(6);
    args.add("--acceptLicense");
    args.add("--no-prompt");
    args.add("--force");
    args.add("--configFile");
    args.add(configurationFile);
    if (ignoreErrors) {
      args.add("--ignoreErrors");
    }
    return args.toArray(new String[args.size()]);
  }

  /**
   * Builder for the UpgradeParameters class.
   */
  public static final class Builder
  {
    private UpgradeParameters params;

    private Builder()
    {
      params = new UpgradeParameters();
    }

    /**
     * Starts construction of the upgrade parameters.
     *
     * @return this builder
     */
    public static Builder upgradeParams()
    {
      return new Builder();
    }

    /**
     * Returns the fully initialized parameters.
     *
     * @return the parameters
     */
    public UpgradeParameters toParams()
    {
      UpgradeParameters p = params;
      this.params = new UpgradeParameters();
      return p;
    }

    /**
     * Indicates whether errors should be ignored during the upgrade.
     * <p>
     * This option should be used with caution and may be useful in automated deployments where
     * potential errors are known in advance and resolved after the upgrade has completed
     *
     * @param ignore
     *          indicates whether errors should be ignored
     * @return this builder
     */
    public Builder isIgnoreErrors(boolean ignore)
    {
      params.ignoreErrors = ignore;
      return this;
    }
  }
}

 opendj-server-legacy/src/main/java/org/opends/server/util/embedded/package-info.java

New file
@@ -0,0 +1,19 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
/**
 * Provides support for an embedded directory server.
 */
package org.opends.server.util.embedded;

 opendj-server-legacy/src/messages/org/opends/messages/utility.properties

@@ -210,8 +210,8 @@
 to or replace the file
ERR_LDIF_SKIP_165=Skipping entry %s because the DN is not one that \
 should be included based on the include and exclude branches/filters
ERR_EMBEDUTILS_SERVER_ALREADY_RUNNING_167=The Directory Server cannot \
 be started because it is already running
ERR_EMBEDUTILS_SERVER_ALREADY_RUNNING_167=The embedded server with server \
 root '%s' cannot be started because it is already running.
INFO_EMAIL_TOOL_DESCRIPTION_171=Send an e-mail message via SMTP
INFO_EMAIL_HOST_DESCRIPTION_172=The address of the SMTP server to use to send \
 the message
@@ -406,3 +406,34 @@
ERR_BACKUP_CANNOT_CREATE_SAVE_DIRECTORY_326=An error occurred while \
 attempting to create a save directory with base path %s before restore of \
 backup of %s: %s
ERR_EMBEDDED_SERVER_DISPLAY_REPLICATION_STATUS_327=An error occurred while attempting \
 to display replication status of embedded server with server root '%s'. Error code \
 is: %s
ERR_EMBEDDED_SERVER_ENABLE_REPLICATION_328=An error occurred while attempting \
 to enable replication between embedded server with server root '%s' and replication \
 port1 '%s' and second server with hostname '%s' and replication port2 '%s'. Error code \
 is: %s
ERR_EMBEDDED_SERVER_IMPORT_DATA_329=An error occurred while attempting \
 to import LDIF file '%s' into embedded server with server root '%s'. Error code \
 is: %s
ERR_EMBEDDED_SERVER_INITIALIZE_REPLICATION_330=An error occurred while attempting \
 to initialize replication between embedded server with server root '%s' and admin \
 port1 '%s' and second server with hostname '%s' and admin port2 '%s'. Error code \
 is: %s
ERR_EMBEDDED_SERVER_READ_CONFIG_331=An error occurred while attempting \
 to read configuration of embedded server with server root '%s' : %s
ERR_EMBEDDED_SERVER_SETUP_332=An error occurred while attempting \
 to setup the embedded server with server root '%s', base DN '%s' and backend type '%s'. \
 Error code is: %s
ERR_EMBEDDED_SERVER_SETUP_EXTRACT_ARCHIVE_333=An error occurred while attempting \
 to extract server archive '%s' before setup of embedded server with server root '%s': %s
ERR_EMBEDDED_SERVER_REBUILD_INDEX_334=An error occurred while attempting \
 to rebuild index of embedded server with server root '%s'. Error code is: %s
ERR_EMBEDDED_SERVER_UPDATE_CONFIG_335=An error occurred while attempting \
 to update configuration of embedded server with server root '%s' : %s
ERR_EMBEDDED_SERVER_START_336=An error occurred while attempting \
 to start the embedded server with server root '%s' : %s
ERR_EMBEDDED_SERVER_UPGRADE_337=An error occurred while attempting \
 to upgrade the embedded server with server root '%s' : %s
ERR_EMBEDDED_SERVER_INTERNAL_CONNECTION=An error occurred while attempting to retrieve \
 an internal connection to the server with the user DN '%s'