Refactor initialization in tools for OPENDJ-2616 Support protection of plug...

Fabio Pistolesi

23.48.2016 c18591b0bb075c240849ec5d2520a0442dca330d

Refactor initialization in tools for OPENDJ-2616 Support protection of pluggable backend data at rest

Tools have to be able to access cryptographic keys to access and generate backend data.
Keys are stored in the admin backend and ads-truststore, managed themselves as backends, so they must be started for tools to work.
Moreover, each tool had its own server initialization (init) code, so some refactoring was done at that level.
Initialization happens through a DirectoryServer initialization builder, so
that tools can decide which services they need to run.
ImportLDIF, ExportLDIF, RebuildIndex, VerifyIndex, EncodePassword and BackendStat need to access data, so their init was extended to do it.
BackupDB, RestoreDB and ListBackends only init the first part.

 opendj-server-legacy/src/main/java/org/opends/server/backends/pluggable/BackendStat.java

@@ -47,7 +47,6 @@
import org.opends.server.backends.pluggable.spi.ReadableTransaction;
import org.opends.server.backends.pluggable.spi.StorageRuntimeException;
import org.opends.server.backends.pluggable.spi.TreeName;
import org.opends.server.core.CoreConfigManager;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.DirectoryServer.DirectoryServerVersionHandler;
import org.opends.server.core.LockFileManager;
@@ -285,8 +284,6 @@
  /** Flag indicating whether or not the global arguments have already been initialized. */
  private boolean globalArgumentsInitialized;

  private DirectoryServer directoryServer;

  /**
   * Provides the command-line arguments to the main application for
   * processing.
@@ -578,61 +575,24 @@
    }

    // Perform the initial bootstrap of the Directory Server and process the configuration.
    directoryServer = DirectoryServer.getInstance();
    try
    {
      DirectoryServer.bootstrapClient();
      DirectoryServer.initializeJMX();
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getStartUpExceptionMessage(e)));
      return 1;
    }

    try
    {
      directoryServer.initializeConfiguration(configFile.getValue());
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getStartUpExceptionMessage(e)));
      return 1;
    }

    try
    {
      directoryServer.initializeSchema();
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getStartUpExceptionMessage(e)));
      return 1;
    }

    try
    {
      CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext());
      coreConfigManager.initializeCoreConfig();
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getStartUpExceptionMessage(e)));
      return 1;
    }

    try
    {
      directoryServer.initializeCryptoManager();
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(getStartUpExceptionMessage(e)));
      return 1;
    }

    SubCommand subCommand = parser.getSubCommand();
    if (LIST_BACKENDS.equals(subCommand.getName()))
    final String subCommandName = subCommand.getName();
    try
    {
      DirectoryServer.InitializationBuilder initializationBuilder =
          new DirectoryServer.InitializationBuilder(configFile.getValue());
      if (subCommandName.equals(DUMP_INDEX) || subCommandName.equals(SHOW_INDEX_STATUS))
      {
        initializationBuilder.requireCryptoServices();
      }
      initializationBuilder.initialize();
    }
    catch (InitializationException e)
    {
      printWrappedText(err, ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(e.getLocalizedMessage()));
      return 1;
    }
    if (LIST_BACKENDS.equals(subCommandName))
    {
      return listRootContainers();
    }
@@ -648,7 +608,7 @@
    }
    try
    {
      switch (subCommand.getName())
      switch (subCommandName)
      {
      case LIST_BASE_DNS:
        return listBaseDNs(rootContainer);
@@ -668,7 +628,7 @@
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_EXECUTING_COMMAND.get(subCommand.getName(),
      printWrappedText(err, ERR_BACKEND_TOOL_EXECUTING_COMMAND.get(subCommandName,
          StaticUtils.stackTraceToString(e)));
      return 1;
    }
@@ -1053,7 +1013,7 @@
      {
        try
        {
          b.configureBackend(backend.getKey(), directoryServer.getServerContext());
          b.configureBackend(backend.getKey(), DirectoryServer.getInstance().getServerContext());
          return b;
        }
        catch (ConfigException ce)

 opendj-server-legacy/src/main/java/org/opends/server/core/BackendConfigManager.java

@@ -22,10 +22,12 @@
import static org.opends.server.util.CollectionUtils.*;
import static org.opends.server.util.StaticUtils.*;

import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import java.util.concurrent.ConcurrentHashMap;

import org.forgerock.i18n.LocalizableMessage;
@@ -87,8 +89,10 @@
   * @throws InitializationException
   *           If a problem occurs while initializing the backends that is not
   *           related to the server configuration.
   * @param backendIDsToStart
   *           The list of backendID to start. Everything will be started if empty.
   */
  public void initializeBackendConfig()
  public void initializeBackendConfig(Collection<String> backendIDsToStart)
         throws ConfigException, InitializationException
  {
    // Register add and delete listeners.
@@ -132,8 +136,12 @@
      // This will decode and validate its properties.
      BackendCfg backendCfg = root.getBackend(name);

      final String backendID = backendCfg.getBackendId();
      if (!backendIDsToStart.isEmpty() && !backendIDsToStart.contains(backendID))
      {
        continue;
      }
      DN backendDN = backendCfg.dn();
      String backendID = backendCfg.getBackendId();

      // Register as a change listener for this backend so that we can be
      // notified when it is disabled or enabled.
@@ -144,7 +152,7 @@
      {
        // If there is already a backend registered with the specified ID,
        // then log an error and skip it.
        if (DirectoryServer.hasBackend(backendCfg.getBackendId()))
        if (DirectoryServer.hasBackend(backendID))
        {
          logger.warn(WARN_CONFIG_BACKEND_DUPLICATE_BACKEND_ID, backendID, backendDN);
          continue;

 opendj-server-legacy/src/main/java/org/opends/server/core/DirectoryServer.java

@@ -37,8 +37,11 @@
import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
@@ -683,6 +686,279 @@
    }
  }

  /** Initialize the client DirectoryServer singleton by using a fluent interface. */
  public static class InitializationBuilder
  {
    /** Keep track of how subSystemsToInitialize are sequenced. */
    private enum SubSystem
    {
      CLIENT_INIT,
      CORE_CONFIG,
      INIT_CRYPTO,
      ADMIN_BACKEND,
      ADMIN_USERS,
      START_CRYPTO,
      PASSWORD_STORAGE_SCHEME,
      USER_PLUGINS;
    }

    private String configFile;
    private Set<PluginType> pluginTypes = new HashSet<>();
    private static EnumSet<SubSystem> subSystemsToInitialize = EnumSet.noneOf(SubSystem.class);

    /**
     * Initialize the client side of DirectoryServer and the Core Configuration.
     *
     * @param configFile the configuration file
     * @throws InitializationException if client initialization or core Config fails
     */
    public InitializationBuilder(String configFile) throws InitializationException
    {
      this.configFile = configFile;
      subSystemsToInitialize.add(SubSystem.CLIENT_INIT);
      subSystemsToInitialize.add(SubSystem.CORE_CONFIG);
    }

    /**
     * Require to setup and start everything necessary for Crypto Services.
     * Core config should already be initialized through the constructor.
     *
     * @return the initialization object
     * @throws InitializationException if Core Config is not initialized
     */
    public InitializationBuilder requireCryptoServices() throws InitializationException
    {
      Collections.addAll(subSystemsToInitialize,
          SubSystem.INIT_CRYPTO,
          SubSystem.ADMIN_BACKEND,
          SubSystem.ADMIN_USERS,
          SubSystem.START_CRYPTO);
      return this;
    }

    /**
     * Requires to setup and start Password Storage Schemes.
     * Crypto services are needed for Password Storage, so it will also set them up if not already done.
     *
     * @return the initialization object
     * @throws InitializationException if Core Config is not initialized
     */
    public InitializationBuilder requirePasswordStorageSchemes() throws InitializationException
    {
      requireCryptoServices();
      Collections.addAll(subSystemsToInitialize, SubSystem.PASSWORD_STORAGE_SCHEME);
      return this;
    }

    /**
     * Requires to start specified user plugins.
     *
     * @param plugins the plugins to start
     * @return the initialization object
     * @throws InitializationException if Core Config is not initialized
     */
    public InitializationBuilder requireUserPlugins(PluginType... plugins) throws InitializationException
    {
      Collections.addAll(subSystemsToInitialize, SubSystem.USER_PLUGINS);
      this.pluginTypes.addAll(Arrays.asList(plugins));
      return this;
    }

    /**
     * Run all Initialization blocks as configured.
     *
     * @throws InitializationException if one of the initialization steps fails
     */
    public void initialize() throws InitializationException
    {
      for (SubSystem subSystem : subSystemsToInitialize)
      {
        switch (subSystem)
        {
        case CLIENT_INIT:
          clientInit();
          break;
        case CORE_CONFIG:
          initCoreConfig(configFile);
          break;
        case ADMIN_BACKEND:
          setupAdminBackends();
          break;
        case ADMIN_USERS:
          setupAdminUsers();
          break;
        case INIT_CRYPTO:
          initCryptoServices();
          break;
        case PASSWORD_STORAGE_SCHEME:
          startPasswordStorageScheme();
          break;
        case START_CRYPTO:
          startCryptoServices();
          break;
        case USER_PLUGINS:
          startUserPlugin();
          break;
        }
      }
    }

    private static void checkSubsystemIsInitialized(SubSystem subsystem) throws InitializationException
    {
      if (!subSystemsToInitialize.contains(subsystem))
      {
        throw new InitializationException(ERR_CANNOT_SUBSYSTEM_NOT_INITIALIZED.get(subsystem));
      }
    }

    private void clientInit() throws InitializationException
    {
      try
      {
        bootstrapClient();
        initializeJMX();
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_SERVER_BOOTSTRAP_ERROR.get(e.getLocalizedMessage()));
      }
    }

    private void initCoreConfig(String configFile) throws InitializationException
    {
      try
      {
        directoryServer.initializeConfiguration(configFile);
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_LOAD_CONFIG.get(e.getLocalizedMessage()));
      }
      try
      {
        directoryServer.initializeSchema();
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_LOAD_SCHEMA.get(e.getLocalizedMessage()));
      }
      try
      {
        directoryServer.coreConfigManager = new CoreConfigManager(directoryServer.serverContext);
        directoryServer.coreConfigManager.initializeCoreConfig();
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(e.getLocalizedMessage()));
      }
    }

    private void initCryptoServices() throws InitializationException
    {
      try
      {
        directoryServer.initializeCryptoManager();
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(e.getLocalizedMessage()));
      }
    }

    private void startCryptoServices() throws InitializationException
    {
      checkSubsystemIsInitialized(SubSystem.INIT_CRYPTO);
      checkSubsystemIsInitialized(SubSystem.ADMIN_USERS);
      new CryptoManagerSync();
    }

    private void setupAdminBackends() throws InitializationException
    {
      checkSubsystemIsInitialized(SubSystem.CORE_CONFIG);

      try
      {
        directoryServer.initializePlugins(Collections.EMPTY_SET);
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_INITIALIZE_SERVER_PLUGINS.get(e.getLocalizedMessage()));
      }

      try
      {
        directoryServer.initializeBackends(Arrays.asList("adminRoot", "ads-truststore"));
      }
      catch (InitializationException | ConfigException e)
      {
        throw new InitializationException(ERR_CANNOT_INITIALIZE_BACKENDS.get(e.getLocalizedMessage()));
      }

      try
      {
        directoryServer.initializeSubentryManager();
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_INITIALIZE_SUBENTRY_MANAGER.get(e.getLocalizedMessage()));
      }
    }

    private void setupAdminUsers() throws InitializationException
    {
      checkSubsystemIsInitialized(SubSystem.ADMIN_BACKEND);

      try
      {
        directoryServer.initializeRootDNConfigManager();
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_INITIALIZE_ROOTDN_MANAGER.get(e.getLocalizedMessage()));
      }

      try
      {
        directoryServer.initializeAuthenticationPolicyComponents();
        directoryServer.initializeAuthenticatedUsers();
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_INITIALIZE_PWPOLICY.get(e.getLocalizedMessage()));
      }
    }

    private void startUserPlugin() throws InitializationException
    {
      checkSubsystemIsInitialized(SubSystem.ADMIN_USERS);

      try
      {
        directoryServer.pluginConfigManager.initializeUserPlugins(pluginTypes);
      }
      catch (Exception e)
      {
        throw new InitializationException(getExceptionMessage(e));
      }
    }

    private void startPasswordStorageScheme() throws InitializationException
    {
      checkSubsystemIsInitialized(SubSystem.START_CRYPTO);

      try
      {
        directoryServer.storageSchemeConfigManager =
            new PasswordStorageSchemeConfigManager(directoryServer.serverContext);
        directoryServer.storageSchemeConfigManager.initializePasswordStorageSchemes();
      }
      catch (Exception e)
      {
        throw new InitializationException(ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES.get(getExceptionMessage(e)));
      }
    }
  }

  /**
   * Temporary class to provide instance methods instead of static methods for
   * server. Once all static methods related to context are removed from the
@@ -1265,11 +1541,8 @@

      AccessControlConfigManager.getInstance().initializeAccessControl(serverContext);

      // Initialize all the backends and their associated suffixes
      // and initialize the workflows when workflow configuration mode is auto.
      initializeBackends();
      initializeBackends(Collections.<String> emptyList());

      // configure the remaining workflows (rootDSE and config backend).
      createAndRegisterRemainingWorkflows();

      // Check for and initialize user configured entry cache if any.
@@ -1370,8 +1643,7 @@
    }
  }

  /** Initializes authenticated users. */
  public void initializeAuthenticatedUsers()
  private void initializeAuthenticatedUsers()
  {
    directoryServer.authenticatedUsers = new AuthenticatedUsers();
  }
@@ -1425,17 +1697,7 @@
    return directoryServer.authenticatedUsers;
  }

  /**
   * Initializes the crypto manager for the Directory Server.
   *
   * @throws ConfigException
   *           If a configuration problem is identified while initializing the
   *           crypto manager.
   * @throws InitializationException
   *           If a problem occurs while initializing the crypto manager that is
   *           not related to the server configuration.
   */
  public void initializeCryptoManager()
  private void initializeCryptoManager()
         throws ConfigException, InitializationException
  {
    CryptoManagerCfg cryptoManagerCfg = serverContext.getRootConfig().getCryptoManager();
@@ -1589,6 +1851,8 @@
  /**
   * Initializes the set of backends defined in the Directory Server.
   *
   * @param backends The list of backends to initialize. All backends will be initialized
   *                 if empty.
   * @throws  ConfigException  If there is a configuration problem with any of
   *                           the backends.
   *
@@ -1596,10 +1860,10 @@
   *                                   the backends that is not related to the
   *                                   server configuration.
   */
  private void initializeBackends() throws ConfigException, InitializationException
  private void initializeBackends(Collection<String> backends) throws ConfigException, InitializationException
  {
    backendConfigManager = new BackendConfigManager(serverContext);
    backendConfigManager.initializeBackendConfig();
    backendConfigManager.initializeBackendConfig(backends);

    // Make sure to initialize the root DSE backend separately after all other backends.
    RootDSEBackendCfg rootDSECfg;
@@ -1798,8 +2062,7 @@
   *                                 initializing the subentry
   *                                 manager.
   */
  public void initializeSubentryManager()
          throws InitializationException
  private void initializeSubentryManager() throws InitializationException
  {
    try
    {
@@ -1820,6 +2083,8 @@
  /**
   * Initializes the set of authentication policy components for use by the
   * Directory Server.
   * For the time this is mostly PasswordPolicy but new Authentication Policy
   * extensions should be initialized at the same time.
   *
   * @throws ConfigException
   *           If there is a configuration problem with any of the
@@ -1828,7 +2093,7 @@
   *           If a problem occurs while initializing the authentication policy
   *           components that is not related to the server configuration.
   */
  public void initializeAuthenticationPolicyComponents() throws ConfigException, InitializationException
  private void initializeAuthenticationPolicyComponents() throws ConfigException, InitializationException
  {
    storageSchemeConfigManager = new PasswordStorageSchemeConfigManager(serverContext);
    storageSchemeConfigManager.initializePasswordStorageSchemes();
@@ -1866,21 +2131,7 @@
    return directoryServer.configurationHandler;
  }

  /**
   * Initializes the set of plugins defined in the Directory Server.  Only the
   * specified types of plugins will be initialized.
   *
   * @param  pluginTypes  The set of plugin types for the plugins to
   *                      initialize.
   *
   * @throws  ConfigException  If there is a configuration problem with any of
   *                           the Directory Server plugins.
   *
   * @throws  InitializationException  If a problem occurs while initializing
   *                                   the plugins that is not related to the
   *                                   server configuration.
   */
  public void initializePlugins(Set<PluginType> pluginTypes)
  private void initializePlugins(Set<PluginType> pluginTypes)
         throws ConfigException, InitializationException
  {
    pluginConfigManager = new PluginConfigManager(serverContext);
@@ -1895,7 +2146,7 @@
   * @throws InitializationException If a problem occurs initializing the root
   *                                 DN manager.
   */
  public void initializeRootDNConfigManager()
  private void initializeRootDNConfigManager()
         throws ConfigException, InitializationException{
    rootDNConfigManager = new RootDNConfigManager(serverContext);
    rootDNConfigManager.initializeRootDNs();

 opendj-server-legacy/src/main/java/org/opends/server/tools/BackUpDB.java

@@ -41,7 +41,6 @@
import org.forgerock.opendj.server.config.server.BackendCfg;
import org.opends.server.api.Backend;
import org.opends.server.api.Backend.BackendOperation;
import org.opends.server.core.CoreConfigManager;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.LockFileManager;
import org.opends.server.loggers.DebugLogger;
@@ -438,87 +437,16 @@
      incrementalBase = null;
    }

    // Perform the initial bootstrap of the Directory Server and process the
    // configuration.
    DirectoryServer directoryServer = DirectoryServer.getInstance();
    if (initializeServer)
    {
      try
      {
        DirectoryServer.bootstrapClient();
        DirectoryServer.initializeJMX();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e)));
        return 1;
      }

      try
      {
        directoryServer.initializeConfiguration(configFile.getValue());
        new DirectoryServer.InitializationBuilder(configFile.getValue())
            .initialize();
      }
      catch (InitializationException ie)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }



      // Initialize the Directory Server schema elements.
      try
      {
        directoryServer.initializeSchema();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getExceptionMessage(e)));
        return 1;
      }


      // Initialize the Directory Server core configuration.
      try
      {
        CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext());
        coreConfigManager.initializeCoreConfig();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }


      // Initialize the Directory Server crypto manager.
      try
      {
        directoryServer.initializeCryptoManager();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(getExceptionMessage(e)));
        printWrappedText(err, ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(getExceptionMessage(ie)));
        return 1;
      }


 opendj-server-legacy/src/main/java/org/opends/server/tools/EncodePassword.java

@@ -20,7 +20,6 @@
import static com.forgerock.opendj.cli.Utils.*;
import static com.forgerock.opendj.cli.CommonArguments.*;

import static org.opends.messages.ConfigMessages.*;
import static org.opends.messages.ToolMessages.*;
import static org.opends.server.protocols.ldap.LDAPResultCode.*;
import static org.opends.server.util.StaticUtils.*;
@@ -34,22 +33,10 @@
import java.util.concurrent.ConcurrentHashMap;

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.server.config.server.BackendCfg;
import org.forgerock.opendj.server.config.server.LDIFBackendCfg;
import org.forgerock.opendj.server.config.server.RootCfg;
import org.forgerock.opendj.server.config.server.TrustStoreBackendCfg;
import org.opends.server.api.Backend;
import org.opends.server.api.PasswordStorageScheme;
import org.opends.server.config.ConfigConstants;
import org.opends.server.types.Entry;
import org.opends.server.core.CoreConfigManager;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.DirectoryServer.DirectoryServerVersionHandler;
import org.opends.server.core.PasswordStorageSchemeConfigManager;
import org.opends.server.crypto.CryptoManagerSync;
import org.opends.server.loggers.JDKLogging;
import org.opends.server.schema.AuthPasswordSyntax;
import org.opends.server.schema.UserPasswordSyntax;
@@ -297,95 +284,17 @@
    }


    // Perform the initial bootstrap of the Directory Server and process the
    // configuration.
    DirectoryServer directoryServer = DirectoryServer.getInstance();

    if (initializeServer)
    {
      try
      {
        DirectoryServer.bootstrapClient();
        DirectoryServer.initializeJMX();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e)));
        return OPERATIONS_ERROR;
      }

      try
      {
        directoryServer.initializeConfiguration(configFile.getValue());
        new DirectoryServer.InitializationBuilder(configFile.getValue())
            .requirePasswordStorageSchemes()
            .initialize();
      }
      catch (InitializationException ie)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage()));
        return OPERATIONS_ERROR;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e)));
        return OPERATIONS_ERROR;
      }



      // Initialize the Directory Server schema elements.
      try
      {
        directoryServer.initializeSchema();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(e.getMessage()));
        return OPERATIONS_ERROR;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getExceptionMessage(e)));
        return OPERATIONS_ERROR;
      }


      // Initialize the Directory Server core configuration.
      try
      {
        CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext());
        coreConfigManager.initializeCoreConfig();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(e.getMessage()));
        return OPERATIONS_ERROR;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getExceptionMessage(e)));
        return OPERATIONS_ERROR;
      }


      if(!initializeServerComponents(directoryServer, err))
      {
        return -1;
      }

      // Initialize the password storage schemes.
      try
      {
        PasswordStorageSchemeConfigManager storageSchemeConfigManager =
             new PasswordStorageSchemeConfigManager(directoryServer.getServerContext());
        storageSchemeConfigManager.initializePasswordStorageSchemes();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES.get(e.getMessage()));
        return OPERATIONS_ERROR;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES.get(getExceptionMessage(e)));
        printWrappedText(err, ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(getExceptionMessage(ie)));
        return OPERATIONS_ERROR;
      }
    }
@@ -660,100 +569,6 @@
    return INFO_ENCPW_PASSWORDS_DO_NOT_MATCH.get();
  }



  private static boolean initializeServerComponents(DirectoryServer directoryServer, PrintStream err)
  {
      // Initialize the Directory Server crypto manager.
      try
      {
        directoryServer.initializeCryptoManager();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(e.getMessage()));
        return false;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(getExceptionMessage(e)));
        return false;
      }
      //Attempt to bring up enough of the server to process schemes requiring
      //secret keys from the trust store backend (3DES, BLOWFISH, AES, RC4) via
      //the crypto-manager.
      try {
          directoryServer.initializeRootDNConfigManager();
          directoryServer.initializePlugins(Collections.EMPTY_SET);
          initializeServerBackends(directoryServer, err);
          directoryServer.initializeSubentryManager();
          directoryServer.initializeAuthenticationPolicyComponents();
          directoryServer.initializeAuthenticatedUsers();
          new CryptoManagerSync();
    } catch (InitializationException | ConfigException e) {
        printWrappedText(err, ERR_ENCPW_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(getExceptionMessage(e)));
        return false;
    }
    return true;
  }

  private static void initializeServerBackends(DirectoryServer directoryServer, PrintStream err)
  throws InitializationException, ConfigException {
    directoryServer.initializeRootDSE();

    Entry backendRoot;
    try {
      DN configEntryDN = DN.valueOf(ConfigConstants.DN_BACKEND_BASE);
      backendRoot   = DirectoryServer.getConfigEntry(configEntryDN);
    } catch (Exception e) {
      LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_GET_CONFIG_BASE.get(
          getExceptionMessage(e));
      throw new ConfigException(message, e);
    }
    if (backendRoot == null) {
      LocalizableMessage message = ERR_CONFIG_BACKEND_BASE_DOES_NOT_EXIST.get();
      throw new ConfigException(message);
    }

    RootCfg root = directoryServer.getServerContext().getRootConfig();
    for (String name : root.listBackends()) {
      BackendCfg backendCfg = root.getBackend(name);
      String backendID = backendCfg.getBackendId();
      if((backendCfg instanceof TrustStoreBackendCfg
          || backendCfg instanceof LDIFBackendCfg)
          && backendCfg.isEnabled())
      {
        String className = backendCfg.getJavaClass();
        Class<?> backendClass;
        Backend<BackendCfg> backend;
        try {
          backendClass = DirectoryServer.loadClass(className);
          backend = (Backend<BackendCfg>) backendClass.newInstance();
        } catch (Exception e) {
          printWrappedText(err,
              ERR_CONFIG_BACKEND_CANNOT_INSTANTIATE.get(className, backendCfg.dn(), stackTraceToSingleLineString(e)));
          continue;
        }
        backend.setBackendID(backendID);
        backend.setWritabilityMode(WritabilityMode.INTERNAL_ONLY);
        try {
          backend.configureBackend(backendCfg, directoryServer.getServerContext());
          backend.openBackend();
        } catch (Exception e) {
          printWrappedText(err,
              ERR_CONFIG_BACKEND_CANNOT_INITIALIZE.get(className, backendCfg.dn(), stackTraceToSingleLineString(e)));
        }
        try {
          DirectoryServer.registerBackend(backend);
        } catch (Exception e)
        {
          printWrappedText(
              err, WARN_CONFIG_BACKEND_CANNOT_REGISTER_BACKEND.get(backendCfg.getBackendId(), getExceptionMessage(e)));
        }
      }
    }
  }

  /**
   * Get the clear password.
   * @param out The output to ask password.

 opendj-server-legacy/src/main/java/org/opends/server/tools/ExportLDIF.java

@@ -31,12 +31,10 @@
import java.util.Set;

import org.forgerock.i18n.slf4j.LocalizedLogger;
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.server.config.server.BackendCfg;
import org.opends.server.api.Backend;
import org.opends.server.api.Backend.BackendOperation;
import org.opends.server.api.plugin.PluginType;
import org.opends.server.core.CoreConfigManager;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.LockFileManager;
import org.opends.server.loggers.DebugLogger;
@@ -357,113 +355,37 @@
    }
  }

  /** {@inheritDoc} */
  @Override
  public String getTaskObjectclass() {
    return "ds-task-export";
  }

  /** {@inheritDoc} */
  @Override
  public Class<?> getTaskClass() {
    return ExportTask.class;
  }

  /** {@inheritDoc} */
  @Override
  protected int processLocal(boolean initializeServer,
                           PrintStream out,
                           PrintStream err) {

    // Perform the initial bootstrap of the Directory Server and process the
    // configuration.
    DirectoryServer directoryServer = DirectoryServer.getInstance();
  protected int processLocal(boolean initializeServer, PrintStream out, PrintStream err)
  {
    if (initializeServer)
    {
      try
      {
        DirectoryServer.bootstrapClient();
        DirectoryServer.initializeJMX();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e)));
        return 1;
      }

      try
      {
        directoryServer.initializeConfiguration(configFile.getValue());
        new DirectoryServer.InitializationBuilder(configFile.getValue())
            .requireCryptoServices()
            .requireUserPlugins(PluginType.LDIF_EXPORT)
            .initialize();
      }
      catch (InitializationException ie)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage()));
        printWrappedText(err, ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(getExceptionMessage(ie)));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }



      // Initialize the Directory Server schema elements.
      try
      {
        directoryServer.initializeSchema();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getExceptionMessage(e)));
        return 1;
      }


      // Initialize the Directory Server core configuration.
      try
      {
        CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext());
        coreConfigManager.initializeCoreConfig();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }


      // Initialize the Directory Server crypto manager.
      try
      {
        directoryServer.initializeCryptoManager();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(getExceptionMessage(e)));
        return 1;
      }


      try
      {
        ErrorLogPublisher errorLogPublisher =
            TextErrorLogPublisher.getToolStartupTextErrorPublisher(
        ErrorLogPublisher errorLogPublisher = TextErrorLogPublisher.getToolStartupTextErrorPublisher(
            new TextWriter.STREAM(out));
        ErrorLogger.getInstance().addLogPublisher(errorLogPublisher);

@@ -471,32 +393,11 @@
      }
      catch(Exception e)
      {
        err.println("Error installing the custom error logger: " +
                    stackTraceToSingleLineString(e));
      }



      // Make sure that the Directory Server plugin initialization is performed.
      try
      {
        HashSet<PluginType> pluginTypes = new HashSet<>(1);
        pluginTypes.add(PluginType.LDIF_EXPORT);
        directoryServer.initializePlugins(pluginTypes);
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS.get(getExceptionMessage(e)));
        err.println("Error installing the custom error logger: " + stackTraceToSingleLineString(e));
        return 1;
      }
    }


    // See if there were any user-defined sets of include/exclude attributes or
    // filters.  If so, then process them.
    Set<AttributeType> excludeAttributes = toAttributeTypes(excludeAttributeStrings);

 opendj-server-legacy/src/main/java/org/opends/server/tools/ImportLDIF.java

@@ -40,10 +40,8 @@
import org.opends.server.api.Backend;
import org.opends.server.api.Backend.BackendOperation;
import org.opends.server.api.plugin.PluginType;
import org.opends.server.core.CoreConfigManager;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.LockFileManager;
import org.opends.server.core.PluginConfigManager;
import org.opends.server.loggers.ErrorLogPublisher;
import org.opends.server.loggers.ErrorLogger;
import org.opends.server.loggers.JDKLogging;
@@ -495,75 +493,21 @@
                           PrintStream err) {


    // Perform the initial bootstrap of the Directory Server and process the configuration.
    DirectoryServer directoryServer = DirectoryServer.getInstance();
    if (initializeServer)
    {
      DirectoryServer.InitializationBuilder ib;
      try
      {
        DirectoryServer.bootstrapClient();
        DirectoryServer.initializeJMX();
        new DirectoryServer.InitializationBuilder(configFile.getValue())
            .requireCryptoServices()
            .requireUserPlugins(PluginType.LDIF_IMPORT)
            .initialize();
      }
      catch (Exception e)
      catch (InitializationException e)
      {
        printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e)));
        printWrappedText(err, ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(e.getLocalizedMessage()));
        return 1;
      }

      try
      {
        directoryServer.initializeConfiguration(configFile.getValue());
      }
      catch (InitializationException ie)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }



      // Initialize the Directory Server schema elements.
      try
      {
        directoryServer.initializeSchema();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getMessage(e)));
        return 1;
      }


      // Initialize the Directory Server core configuration.
      try
      {
        CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext());
        coreConfigManager.initializeCoreConfig();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getMessage(e)));
        return 1;
      }


      // Initialize the Directory Server crypto manager.
      try
      {
        directoryServer.initializeCryptoManager();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(getMessage(e)));
        return 1;
      }


      if (! quietMode.isPresent())
      {
        try
@@ -577,68 +521,9 @@
        {
          err.println("Error installing the custom error logger: " +
              stackTraceToSingleLineString(e));
        }
      }

      // Initialize the root DNs.
      try
      {
        directoryServer.initializeRootDNConfigManager();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_ROOTDN_MANAGER.get(getMessage(e)));
        return 1;
      }

      // Initialize the plugin manager.
      try
      {
        HashSet<PluginType> pluginTypes = new HashSet<>(1);
        directoryServer.initializePlugins(pluginTypes);
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS.get(getMessage(e)));
        return 1;
      }

      // Initialize the subentry manager.
      try
      {
        directoryServer.initializeSubentryManager();
      }
      catch (InitializationException ie)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_SUBENTRY_MANAGER.get(ie.getMessage()));
        return 1;
      }

      // Initialize all the password policy information.
      try
      {
        directoryServer.initializeAuthenticationPolicyComponents();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY.get(getMessage(e)));
        return 1;
      }
    }

    // Make sure that the plugin initialization is performed.
    try
    {
      HashSet<PluginType> pluginTypes = new HashSet<>(1);
      pluginTypes.add(PluginType.LDIF_IMPORT);
      PluginConfigManager pluginConfigManager =
              DirectoryServer.getPluginConfigManager();
      pluginConfigManager.initializeUserPlugins(pluginTypes);
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS.get(getMessage(e)));
      return 1;
    }

    // See if there were any user-defined sets of include/exclude attributes or

 opendj-server-legacy/src/main/java/org/opends/server/tools/ListBackends.java

@@ -208,53 +208,15 @@
      return 1;
    }

    // Perform the initial bootstrap of the Directory Server and process the
    // configuration.
    DirectoryServer directoryServer = DirectoryServer.getInstance();

    if (initializeServer)
    {
      try
      {
        DirectoryServer.bootstrapClient();
        DirectoryServer.initializeJMX();
        new DirectoryServer.InitializationBuilder(configFile.getValue());
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e)));
        return 1;
      }

      try
      {
        directoryServer.initializeConfiguration(configFile.getValue());
      }
      catch (InitializationException ie)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }



      // Initialize the Directory Server schema elements.
      try
      {
        directoryServer.initializeSchema();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getExceptionMessage(e)));
        printWrappedText(err, e.getLocalizedMessage());
        return 1;
      }
    }

 opendj-server-legacy/src/main/java/org/opends/server/tools/RebuildIndex.java

@@ -37,7 +37,6 @@
import org.opends.server.api.Backend.BackendOperation;
import org.opends.server.backends.RebuildConfig;
import org.opends.server.backends.RebuildConfig.RebuildMode;
import org.opends.server.core.CoreConfigManager;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.LockFileManager;
import org.opends.server.loggers.DebugLogger;
@@ -279,17 +278,12 @@
    argParser.setUsageArgument(displayUsage);
  }

  /** {@inheritDoc} */
  @Override
  protected int processLocal(final boolean initializeServer,
      final PrintStream out, final PrintStream err)
  protected int processLocal(final boolean initializeServer, final PrintStream out, final PrintStream err)
  {
    // Performs the initial bootstrap of the Directory Server and processes the
    // configuration.
    final DirectoryServer directoryServer = DirectoryServer.getInstance();
    if (initializeServer)
    {
      final int init = initializeServer(directoryServer, out, err);
      final int init = initializeServer(out, err);
      if (init != 0)
      {
        return init;
@@ -372,17 +366,8 @@
  }

  /**
   * Initializes the directory server.<br />
   * Processes to :
   * - bootstrapClient
   * - initializeJMX
   * - initializeConfiguration
   * - initializeSchema
   * - coreConfigManager.initializeCoreConfig()
   * - initializeCryptoManager
   * Initializes the directory server.
   *
   * @param directoryServer
   *          The current instance.
   * @param out
   *          The output stream to use for standard output, or {@code null} if
   *          standard output is not needed.
@@ -391,66 +376,21 @@
   *          standard error is not needed.
   * @return The result code.
   */
  private int initializeServer(final DirectoryServer directoryServer,
      final PrintStream out, final PrintStream err)
  private int initializeServer(final PrintStream out, final PrintStream err)
  {
    try
    {
      DirectoryServer.bootstrapClient();
      DirectoryServer.initializeJMX();
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e)));
      return 1;
    }

    try
    {
      directoryServer.initializeConfiguration(configFile.getValue());
    }
    catch (Exception ex)
    {
      printWrappedText(err, toErrorMsg(ERR_CANNOT_LOAD_CONFIG, ex));
      return 1;
    }

    // Initializes the Directory Server schema elements.
    try
    {
      directoryServer.initializeSchema();
    }
    catch (Exception e)
    {
      printWrappedText(err, toErrorMsg(ERR_CANNOT_LOAD_SCHEMA, e));
      return 1;
    }

    // Initializes the Directory Server core configuration.
    try
    {
      final CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext());
      coreConfigManager.initializeCoreConfig();
    }
    catch (Exception ex)
    {
      printWrappedText(err, toErrorMsg(ERR_CANNOT_INITIALIZE_CORE_CONFIG, ex));
      return 1;
    }

    // Initializes the Directory Server crypto manager.
    try
    {
      directoryServer.initializeCryptoManager();
    }
    catch (Exception ex)
    {
      printWrappedText(err, toErrorMsg(ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER, ex));
      return 1;
    }

      new DirectoryServer.InitializationBuilder(configFile.getValue())
          .requireCryptoServices()
          .initialize();
    return 0;
  }
    catch (InitializationException ie)
    {
      printWrappedText(err, ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(ie.getLocalizedMessage()));
      return 1;
    }
  }

  private String toErrorMsg(Arg1<Object> errorMsg, Exception ex)
  {
@@ -658,10 +598,9 @@
        return 1;
      }

      final DirectoryServer directoryServer = DirectoryServer.getInstance();
      if (initializeServer)
      {
        final int init = initializeServer(directoryServer, out, out);
        final int init = initializeServer(out, out);
        if (init != 0)
        {
          return init;

 opendj-server-legacy/src/main/java/org/opends/server/tools/RestoreDB.java

@@ -34,11 +34,9 @@

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.i18n.slf4j.LocalizedLogger;
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.server.config.server.BackendCfg;
import org.opends.server.api.Backend;
import org.opends.server.api.Backend.BackendOperation;
import org.opends.server.core.CoreConfigManager;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.LockFileManager;
import org.opends.server.loggers.DebugLogger;
@@ -282,90 +280,18 @@
                           PrintStream err) {


    // Perform the initial bootstrap of the Directory Server and process the
    // configuration.
    DirectoryServer directoryServer = DirectoryServer.getInstance();
    if (initializeServer)
    {
      try
      {
        DirectoryServer.bootstrapClient();
        DirectoryServer.initializeJMX();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e)));
        return 1;
      }

      try
      {
        directoryServer.initializeConfiguration(configFile.getValue());
        new DirectoryServer.InitializationBuilder(configFile.getValue())
            .initialize();
      }
      catch (InitializationException ie)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage()));
        printWrappedText(err, ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(ie.getLocalizedMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }



      // Initialize the Directory Server schema elements.
      try
      {
        directoryServer.initializeSchema();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getExceptionMessage(e)));
        return 1;
      }


      // Initialize the Directory Server core configuration.
      try
      {
        CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext());
        coreConfigManager.initializeCoreConfig();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }


      // Initialize the Directory Server crypto manager.
      try
      {
        directoryServer.initializeCryptoManager();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(getExceptionMessage(e)));
        return 1;
      }


      try
      {

 opendj-server-legacy/src/main/java/org/opends/server/tools/VerifyIndex.java

@@ -29,13 +29,11 @@
import java.util.List;

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.server.config.server.BackendCfg;
import org.opends.server.api.Backend;
import org.opends.server.api.Backend.BackendOperation;
import org.opends.server.backends.VerifyConfig;
import org.opends.server.core.CoreConfigManager;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.DirectoryServer.DirectoryServerVersionHandler;
import org.opends.server.core.LockFileManager;
@@ -191,88 +189,17 @@
      return 1;
    }

    // Perform the initial bootstrap of the Directory Server and process the
    // configuration.
    DirectoryServer directoryServer = DirectoryServer.getInstance();

    if (initializeServer)
    {
      try
      {
        DirectoryServer.bootstrapClient();
        DirectoryServer.initializeJMX();
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e)));
        return 1;
      }

      try
      {
        directoryServer.initializeConfiguration(configFile.getValue());
        new DirectoryServer.InitializationBuilder(configFile.getValue())
            .requireCryptoServices()
            .initialize();
      }
      catch (InitializationException ie)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }



      // Initialize the Directory Server schema elements.
      try
      {
        directoryServer.initializeSchema();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getExceptionMessage(e)));
        return 1;
      }


      // Initialize the Directory Server core configuration.
      try
      {
        CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext());
        coreConfigManager.initializeCoreConfig();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getExceptionMessage(e)));
        return 1;
      }


      // Initialize the Directory Server crypto manager.
      try
      {
        directoryServer.initializeCryptoManager();
      }
      catch (ConfigException | InitializationException e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(e.getMessage()));
        return 1;
      }
      catch (Exception e)
      {
        printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(getExceptionMessage(e)));
        printWrappedText(err, ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS.get(ie.getLocalizedMessage()));
        return 1;
      }
    }

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

@@ -77,7 +77,7 @@
 Directory Server schema:  %s
ERR_CANNOT_INITIALIZE_CORE_CONFIG_23=An error occurred while trying to \
 initialize the core Directory Server configuration:  %s
ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=An error occurred while \
ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=An error occurred while \
 trying to initialize the Directory Server password storage schemes:  %s
ERR_ENCPW_NO_STORAGE_SCHEMES_25=No password storage schemes have been \
 configured for use in the Directory Server
@@ -566,10 +566,6 @@
 values
INFO_LDIFIMPORT_DESCRIPTION_SKIP_SCHEMA_VALIDATION_339=Skip schema validation \
 during the LDIF import
ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS_340=An error occurred while \
 attempting to initialize the LDIF export plugins:  %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS_341=An error occurred while \
 attempting to initialize the LDIF import plugins:  %s
INFO_DESCRIPTION_ASSERTION_FILTER_342=Use the LDAP assertion control with the \
 provided filter
ERR_LDAP_ASSERTION_INVALID_FILTER_343=The search filter provided for the \
@@ -623,7 +619,7 @@
 scheme "%s" is not configured for use in the Directory Server
ERR_ENCPW_INVALID_ENCODED_AUTHPW_372=The provided password is not a \
 valid encoded authentication password value:  %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY_373=An error occurred while \
ERR_CANNOT_INITIALIZE_PWPOLICY_373=An error occurred while \
 attempting to initialize the password policy components:  %s
INFO_STOPDS_DESCRIPTION_HOST_374=Directory server hostname or IP address
INFO_STOPDS_DESCRIPTION_PORT_375=Directory server administration port number
@@ -2168,9 +2164,8 @@
 already a backup location for backend %s

INFO_RECURRING_TASK_PLACEHOLDER_1651={schedulePattern}
ERR_ENCPW_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=An error occurred \
 while attempting to initialize server components to run the encode \
 password tool:  %s
ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=An error occurred \
 while attempting to initialize server components to run the tool: %s
ERR_LDIFIMPORT_COUNT_REJECTS_REQUIRES_OFFLINE_1653=The %s \
 argument is not supported for online imports
INFO_DESCRIPTION_RECURRING_TASK_1654=Indicates the task is recurring and will \
@@ -2458,7 +2453,10 @@
offHeapSize cannot be parsed: %s
INFO_LDIFIMPORT_DESCRIPTION_OFFHEAP_SIZE_1898=Size expressed in megabytes of the off-heap memory dedicated to the \
phase one buffers.
INFO_LDIFIMPORT_OFFHEAP_SIZE_PLACEHOLDER_1687={size in megabytes}
INFO_LDIFIMPORT_OFFHEAP_SIZE_PLACEHOLDER_1899={size in megabytes}
ERR_CANNOT_INITIALIZE_BACKENDS_1900=An error occurred while initializing server backends: %s
ERR_CANNOT_INITIALIZE_SERVER_PLUGINS_1901=An error occurred while initializing plugins: %s
ERR_CANNOT_SUBSYSTEM_NOT_INITIALIZED_1902=Subsystem %s should be initialized first

# Upgrade tasks
INFO_UPGRADE_TASK_6869_SUMMARY_10000=Fixing de-DE collation matching rule OID

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

@@ -59,7 +59,7 @@
ERR_CANNOT_LOAD_CONFIG_21=Fehler beim Versuch, die Directory-Server-Konfiguration zu laden:  %s
ERR_CANNOT_LOAD_SCHEMA_22=Fehler beim Versuch, das Directory-Server-Schema zu laden:  %s
ERR_CANNOT_INITIALIZE_CORE_CONFIG_23=Fehler beim Versuch, die Directory-Server-Kernkonfiguration zu initialisieren:  %s
ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=Fehler beim Versuch, das Directory-Server-Passwort-Speicherschema zu initialisieren:  %s
ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=Fehler beim Versuch, das Directory-Server-Passwort-Speicherschema zu initialisieren:  %s
ERR_ENCPW_NO_STORAGE_SCHEMES_25=Es sind keine Passwort-Speicherschemen f\u00fcr die Verwendung im Directory-Server konfiguriert
ERR_ENCPW_NO_SUCH_SCHEME_26=Das Passwort-Speicherschema "%s" ist nicht f\u00fcr die Verwendung im Directory-Server konfiguriert
INFO_ENCPW_PASSWORDS_MATCH_27=Das angegebene Klartext-Passwort und das verschl\u00fcsselte Passwort stimmen \u00fcberein
@@ -289,8 +289,6 @@
WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND_337=Fehler beim Versuch, die gemeinsame Sperre f\u00fcr Backend %s freizugeben:  %s.  Diese Sperre sollte automatisch aufgehoben werden, wenn der \u00dcberpr\u00fcfungsprozess vorhanden ist, sodass keine weitere Aktion erforderlich ist
INFO_DESCRIPTION_TYPES_ONLY_338=Nur Attributnamen abfragen, nicht ihre Werte
INFO_LDIFIMPORT_DESCRIPTION_SKIP_SCHEMA_VALIDATION_339=Schema\u00fcberpr\u00fcfung beim LDIF-Import \u00fcberspringen
ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS_340=Fehler beim Versuch, die LDIF-Export-Plugins zu initialisieren:  %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS_341=Fehler beim Versuch, die LDIF-Import-Plugins zu initialisieren:  %s
INFO_DESCRIPTION_ASSERTION_FILTER_342=LDAP-Assertionssteuerung f\u00fcr den angegebenen Filter verwenden
ERR_LDAP_ASSERTION_INVALID_FILTER_343=Der f\u00fcr die LDAP-Assertionssteuerung angegebene Suchfilter ist ung\u00fcltig: %s
INFO_DESCRIPTION_PREREAD_ATTRS_346=LDAP-ReadEntry-Preread-Steuerung verwenden
@@ -317,7 +315,7 @@
INFO_ENCPW_DESCRIPTION_AUTHPW_369=Authentifizierungs-Passwortsyntax statt Benutzer-Passwortsyntax verwenden
ERR_ENCPW_NO_SUCH_AUTH_SCHEME_371=Das Speicherschema des Authentifizierungspassworts "%s" ist nicht f\u00fcr die Verwendung im Directory-Server konfiguriert
ERR_ENCPW_INVALID_ENCODED_AUTHPW_372=Das angegebene Passwort ist kein g\u00fcltiger verschl\u00fcsselter Wert f\u00fcr das Authentifizierungspasswort:  %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY_373=Fehler beim Versuch, die Komponenten der Passwortrichtlinie zu initialisieren:  %s
ERR_CANNOT_INITIALIZE_PWPOLICY_373=Fehler beim Versuch, die Komponenten der Passwortrichtlinie zu initialisieren:  %s
INFO_STOPDS_DESCRIPTION_HOST_374=Directory-Server-Hostname oder -IP-Adresse
INFO_STOPDS_DESCRIPTION_PORT_375=Directory-Server-Administrations-Portnummer
INFO_STOPDS_DESCRIPTION_BINDDN_378=DN f\u00fcr die Verbindung zum Server
@@ -1105,7 +1103,7 @@
ERR_BACKUPDB_CANNOT_BACKUP_IN_DIRECTORY_1650=Ziel-Backend %s konnte nicht im Sicherungsverzeichnis %s gesichert werden: Dieses Verzeichnis ist bereits ein Sicherungsspeicherort f\u00fcr Backend %s

INFO_RECURRING_TASK_PLACEHOLDER_1651={Planungsmuster}
ERR_ENCPW_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=Fehler beim Versuch, Server-Komponenten zu initialisieren, um das Tool zum Verschl\u00fcsseln des Passworts auszuf\u00fchren:  %s
ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=Fehler beim Versuch, Server-Komponenten zu initialisieren, um das Tool auszuf\u00fchren: %s
ERR_LDIFIMPORT_COUNT_REJECTS_REQUIRES_OFFLINE_1653=Das Argument %s wird nicht f\u00fcr Online-Importe unterst\u00fctzt
INFO_DESCRIPTION_RECURRING_TASK_1654=Gibt an, dass sich die Aufgabe wiederholt und geplant wird, gem\u00e4\u00df dem Wertargument in crontab(5), die mit Datum und Uhrzeit kompatibel sind.
INFO_TASK_TOOL_RECURRING_TASK_SCHEDULED_1655=Wiederholte %s-Aufgabe %s erfolgreich geplant

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

@@ -59,7 +59,7 @@
ERR_CANNOT_LOAD_CONFIG_21=Se ha producido un error al tratar de cargar la configuraci\u00f3n del Servidor de directorios: %s
ERR_CANNOT_LOAD_SCHEMA_22=Se ha producido un error al tratar de cargar el esquema del Servidor de directorios: %s
ERR_CANNOT_INITIALIZE_CORE_CONFIG_23=Se ha producido un error al tratar de inicializar la configuraci\u00f3n del Servidor de directorios de base: %s
ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=Se ha producido un error al tratar de inicializar los esquemas de almacenamiento de contrase\u00f1as del Servidor de directorios: %s
ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=Se ha producido un error al tratar de inicializar los esquemas de almacenamiento de contrase\u00f1as del Servidor de directorios: %s
ERR_ENCPW_NO_STORAGE_SCHEMES_25=No se han configurado esquemas de almacenamiento de contrase\u00f1as para su uso en el Servidor de directorios
ERR_ENCPW_NO_SUCH_SCHEME_26=No se ha configurado el esquema de almacenamiento de contrase\u00f1as "%s" para su uso en el Servidor de directorios
INFO_ENCPW_PASSWORDS_MATCH_27=Las contrase\u00f1as de texto sin codificar y codificadas especificadas coinciden
@@ -289,8 +289,6 @@
WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND_337=Se ha producido un error al tratar de desactivar el bloqueo compartido para el backend %s: %s. Este bloqueo deber\u00eda eliminarse autom\u00e1ticamente al cerrarse el proceso de comprobaci\u00f3n, por lo que no deber\u00eda requerirse la realizaci\u00f3n de ninguna operaci\u00f3n adicional
INFO_DESCRIPTION_TYPES_ONLY_338=Recuperar s\u00f3lo los nombres de atributo, pero no sus valores
INFO_LDIFIMPORT_DESCRIPTION_SKIP_SCHEMA_VALIDATION_339=Omitir la validaci\u00f3n de esquemas durante la importaci\u00f3n de LDIF
ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS_340=Se ha producido un error al tratar de inicializar los complementos de exportaci\u00f3n de LDIF: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS_341=Se ha producido un error al tratar de inicializar los complementos de importaci\u00f3n de LDIF: %s
INFO_DESCRIPTION_ASSERTION_FILTER_342=Utilizar el control de aserci\u00f3n LDAP con el filtro especificado
ERR_LDAP_ASSERTION_INVALID_FILTER_343=El filtro de b\u00fasqueda especificado para el control de aserci\u00f3n de LDAP no era v\u00e1lido:  %s
INFO_DESCRIPTION_PREREAD_ATTRS_346=Utilizar el control de pre-lectura ReadEntry de LDAP
@@ -317,7 +315,7 @@
INFO_ENCPW_DESCRIPTION_AUTHPW_369=Utilizar la sintaxis de contrase\u00f1a de autenticaci\u00f3n en lugar de la sintaxis de contrase\u00f1a de usuario
ERR_ENCPW_NO_SUCH_AUTH_SCHEME_371=El esquema de almacenamiento de contrase\u00f1as de autenticaci\u00f3n "%s" no se ha configurado para su uso en el Servidor de directorios
ERR_ENCPW_INVALID_ENCODED_AUTHPW_372=La contrase\u00f1a proporcionada no es un valor de contrase\u00f1a de autenticaci\u00f3n codificada v\u00e1lido: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY_373=Se ha producido un error al tratar de inicializar los componentes de la directiva de contrase\u00f1as:  %s
ERR_CANNOT_INITIALIZE_PWPOLICY_373=Se ha producido un error al tratar de inicializar los componentes de la directiva de contrase\u00f1as:  %s
INFO_STOPDS_DESCRIPTION_HOST_374=Direcci\u00f3n IP o nombre de host de servidor de directorios
INFO_STOPDS_DESCRIPTION_PORT_375=N\u00famero de puerto de administraci\u00f3n de Directory Server
INFO_STOPDS_DESCRIPTION_BINDDN_378=ND que utilizar para enlazar al servidor
@@ -1105,7 +1103,7 @@
ERR_BACKUPDB_CANNOT_BACKUP_IN_DIRECTORY_1650=No puede realizarse una copia de seguridad del backend de destino %s en el directorio de copia de seguridad %s: este directorio ya es una ubicaci\u00f3n de copia de seguridad para el backend %s

INFO_RECURRING_TASK_PLACEHOLDER_1651={schedulePattern}
ERR_ENCPW_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=Se ha producido un error al tratar de inicializar los componentes de servidor para ejecutar la herramienta de codificaci\u00f3n de contrase\u00f1as:  %s
ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=Se ha producido un error al tratar de inicializar los componentes de servidor para ejecutar la herramienta: %s
ERR_LDIFIMPORT_COUNT_REJECTS_REQUIRES_OFFLINE_1653=No se admite el argumento %s para importaciones en l\u00ednea
INFO_DESCRIPTION_RECURRING_TASK_1654=Indica que la tarea es repetitiva y que se programar\u00e1 seg\u00fan el argumento de valor expresado en el patr\u00f3n hora/fecha compatible de crontab(5)
INFO_TASK_TOOL_RECURRING_TASK_SCHEDULED_1655=La %s tarea %s repetitiva se ha programado correctamente

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

@@ -59,7 +59,7 @@
ERR_CANNOT_LOAD_CONFIG_21=Une erreur s'est produite lors de la tentative de chargement de la configuration Directory Server\u00a0: %s
ERR_CANNOT_LOAD_SCHEMA_22=Une erreur s'est produite lors de la tentative de chargement du sch\u00e9ma Directory Server\u00a0: %s
ERR_CANNOT_INITIALIZE_CORE_CONFIG_23=Une erreur s'est produite lors de la tentative d'initialisation de la configuration de serveur de base Directory Server\u00a0: %s
ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=Une erreur s'est produite lors de la tentative d'initialisation des mod\u00e8les de stockage de mot de passe Directory Server\u00a0: %s
ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=Une erreur s'est produite lors de la tentative d'initialisation des mod\u00e8les de stockage de mot de passe Directory Server\u00a0: %s
ERR_ENCPW_NO_STORAGE_SCHEMES_25=Aucun mod\u00e8le de stockage de mot de passe n'est configur\u00e9 pour utilisation dans Directory Server
ERR_ENCPW_NO_SUCH_SCHEME_26=Le mod\u00e8le de stockage de mot de passe "%s" n'est configur\u00e9 pour utilisation dans Directory Server
INFO_ENCPW_PASSWORDS_MATCH_27=Les mots de passe en texte clair et cod\u00e9s indiqu\u00e9s correspondent
@@ -289,8 +289,6 @@
WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND_337=Une erreur s'est produite lors de la tentative de lib\u00e9ration du verrou partag\u00e9 pour le backend %s\u00a0: %s. Ce verrou devrait \u00eatre automatiquement supprim\u00e9 \u00e0 la fermeture du processus de v\u00e9rification et aucune autre action ne devrait \u00eatre n\u00e9cessaire
INFO_DESCRIPTION_TYPES_ONLY_338=R\u00e9cup\u00e9rer uniquement les noms d'attribut, pas leurs valeurs
INFO_LDIFIMPORT_DESCRIPTION_SKIP_SCHEMA_VALIDATION_339=Ignorer la validation de sch\u00e9ma pendant l'importation LDIF
ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS_340=Une erreur s'est produite lors de la tentative d'initialisation des plug-ins d'exportation LDIF\u00a0: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS_341=Une erreur s'est produite lors de la tentative d'initialisation des plug-ins d'importation LDIF\u00a0: %s
INFO_DESCRIPTION_ASSERTION_FILTER_342=Utiliser le contr\u00f4le de l'assertion LDAP avec le filtre fourni
ERR_LDAP_ASSERTION_INVALID_FILTER_343=Le filtre de recherche fourni pour le contr\u00f4le d'assertion LDAP \u00e9tait invalide\u00a0:  %s
INFO_DESCRIPTION_PREREAD_ATTRS_346=Utiliser le contr\u00f4le de pr\u00e9lecture ReadEntry de LDAP
@@ -317,7 +315,7 @@
INFO_ENCPW_DESCRIPTION_AUTHPW_369=Utiliser la syntaxe de mot de passe d'authentification plut\u00f4t que la syntaxe de mot de passe utilisateur
ERR_ENCPW_NO_SUCH_AUTH_SCHEME_371=Le mod\u00e8le de stockage de mot de passe d'authentification "%s" n'est configur\u00e9 pour utilisation dans Directory Server
ERR_ENCPW_INVALID_ENCODED_AUTHPW_372=Le mot de passe fourni n'est pas une valeur de mot de passe d'authentification cod\u00e9 valide\u00a0: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY_373=Une erreur s'est produite lors de la tentative d'initialisation des composants de strat\u00e9gie de mot de passe\u00a0: %s
ERR_CANNOT_INITIALIZE_PWPOLICY_373=Une erreur s'est produite lors de la tentative d'initialisation des composants de strat\u00e9gie de mot de passe\u00a0: %s
INFO_STOPDS_DESCRIPTION_HOST_374=Nom d'h\u00f4te ou adresse IP du serveur d'annuaire
INFO_STOPDS_DESCRIPTION_PORT_375=Num\u00e9ro de port d'administration du serveur d'annuaire
INFO_STOPDS_DESCRIPTION_BINDDN_378=DN \u00e0 utiliser pour effectuer une liaison au serveur
@@ -1105,7 +1103,7 @@
ERR_BACKUPDB_CANNOT_BACKUP_IN_DIRECTORY_1650=Le backend cible %s ne peut pas \u00eatre sauvegard\u00e9 dans le r\u00e9pertoire de sauvegarde %s\u00a0: ce r\u00e9pertoire sert d\u00e9j\u00e0 d'emplacement de sauvegarde au backend %s

INFO_RECURRING_TASK_PLACEHOLDER_1651={motifPlan}
ERR_ENCPW_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=Une erreur s'est produite lors de la tentative d'initialisation des composants serveur pour l'ex\u00e9cution de l'outil de codage du mot de passe\u00a0: %s
ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=Une erreur s'est produite lors de la tentative d'initialisation des composants serveur pour l'ex\u00e9cution de l'outil: %s
ERR_LDIFIMPORT_COUNT_REJECTS_REQUIRES_OFFLINE_1653=L'argument %s n'est pas pris en charge pour les importations en ligne
INFO_DESCRIPTION_RECURRING_TASK_1654=Indique que la t\u00e2che est r\u00e9currente et sera planifi\u00e9e selon l'argument de valeur indiqu\u00e9 dans le motif d'heure/date compatible avec crontab(5)
INFO_TASK_TOOL_RECURRING_TASK_SCHEDULED_1655=%s t\u00e2che %s r\u00e9currente planifi\u00e9e

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

@@ -59,7 +59,7 @@
ERR_CANNOT_LOAD_CONFIG_21=\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u69cb\u6210\u306e\u8aad\u307f\u8fbc\u307f\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
ERR_CANNOT_LOAD_SCHEMA_22=\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u30b9\u30ad\u30fc\u30de\u306e\u8aad\u307f\u8fbc\u307f\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
ERR_CANNOT_INITIALIZE_CORE_CONFIG_23=\u30b3\u30a2\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u69cb\u6210\u306e\u521d\u671f\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u30d1\u30b9\u30ef\u30fc\u30c9\u8a18\u61b6\u30b9\u30ad\u30fc\u30de\u306e\u521d\u671f\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u30d1\u30b9\u30ef\u30fc\u30c9\u8a18\u61b6\u30b9\u30ad\u30fc\u30de\u306e\u521d\u671f\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
ERR_ENCPW_NO_STORAGE_SCHEMES_25=\u30d1\u30b9\u30ef\u30fc\u30c9\u8a18\u61b6\u30b9\u30ad\u30fc\u30de\u304c\u3001\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u3067\u4f7f\u7528\u3059\u308b\u3088\u3046\u306b\u8a2d\u5b9a\u3055\u308c\u3066\u3044\u307e\u305b\u3093
ERR_ENCPW_NO_SUCH_SCHEME_26=\u30d1\u30b9\u30ef\u30fc\u30c9\u8a18\u61b6\u30b9\u30ad\u30fc\u30de "%s" \u304c\u3001\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u3067\u4f7f\u7528\u3059\u308b\u3088\u3046\u306b\u8a2d\u5b9a\u3055\u308c\u3066\u3044\u307e\u305b\u3093
INFO_ENCPW_PASSWORDS_MATCH_27=\u6307\u5b9a\u3055\u308c\u305f\u5e73\u6587\u30c6\u30ad\u30b9\u30c8\u304a\u3088\u3073\u7b26\u53f7\u5316\u3055\u308c\u305f\u30d1\u30b9\u30ef\u30fc\u30c9\u304c\u4e00\u81f4\u3057\u307e\u3059
@@ -289,8 +289,6 @@
WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND_337=\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u306e\u5171\u6709\u30ed\u30c3\u30af\u306e\u89e3\u9664\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s\u3002\u3053\u306e\u30ed\u30c3\u30af\u306f\u691c\u8a3c\u30d7\u30ed\u30bb\u30b9\u306e\u7d42\u4e86\u6642\u306b\u81ea\u52d5\u7684\u306b\u6d88\u53bb\u3055\u308c\u308b\u305f\u3081\u3001\u3053\u308c\u4ee5\u4e0a\u306e\u30a2\u30af\u30b7\u30e7\u30f3\u306f\u5fc5\u8981\u3042\u308a\u307e\u305b\u3093
INFO_DESCRIPTION_TYPES_ONLY_338=\u5c5e\u6027\u540d\u3092\u53d6\u5f97\u3059\u308b\u3060\u3051\u3067\u3001\u305d\u306e\u5024\u306f\u53d6\u5f97\u3057\u307e\u305b\u3093
INFO_LDIFIMPORT_DESCRIPTION_SKIP_SCHEMA_VALIDATION_339=LDIF \u306e\u30a4\u30f3\u30dd\u30fc\u30c8\u6642\u306b\u30b9\u30ad\u30fc\u30de\u306e\u691c\u8a3c\u3092\u30b9\u30ad\u30c3\u30d7\u3057\u307e\u3059
ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS_340=LDIF \u30a8\u30af\u30b9\u30dd\u30fc\u30c8\u30d7\u30e9\u30b0\u30a4\u30f3\u306e\u521d\u671f\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS_341=LDIF \u30a4\u30f3\u30dd\u30fc\u30c8\u30d7\u30e9\u30b0\u30a4\u30f3\u306e\u521d\u671f\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
INFO_DESCRIPTION_ASSERTION_FILTER_342=\u6307\u5b9a\u3055\u308c\u305f\u30d5\u30a3\u30eb\u30bf\u3067 LDAP \u8868\u660e\u5236\u5fa1\u3092\u4f7f\u7528\u3057\u307e\u3059
ERR_LDAP_ASSERTION_INVALID_FILTER_343=LDAP \u8868\u660e\u5236\u5fa1\u306b\u6307\u5b9a\u3055\u308c\u305f\u691c\u7d22\u30d5\u30a3\u30eb\u30bf\u304c\u7121\u52b9\u3067\u3057\u305f:  %s
INFO_DESCRIPTION_PREREAD_ATTRS_346=LDAP ReadEntry \u8aad\u307f\u8fbc\u307f\u524d\u5236\u5fa1\u3092\u4f7f\u7528\u3057\u307e\u3059
@@ -317,7 +315,7 @@
INFO_ENCPW_DESCRIPTION_AUTHPW_369=\u30e6\u30fc\u30b6\u30fc\u30d1\u30b9\u30ef\u30fc\u30c9\u69cb\u6587\u3067\u306f\u306a\u304f\u3001\u8a8d\u8a3c\u30d1\u30b9\u30ef\u30fc\u30c9\u69cb\u6587\u3092\u4f7f\u7528\u3057\u307e\u3059
ERR_ENCPW_NO_SUCH_AUTH_SCHEME_371=\u8a8d\u8a3c\u30d1\u30b9\u30ef\u30fc\u30c9\u8a18\u61b6\u30b9\u30ad\u30fc\u30de "%s" \u304c\u3001\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u3067\u4f7f\u7528\u3059\u308b\u3088\u3046\u306b\u8a2d\u5b9a\u3055\u308c\u3066\u3044\u307e\u305b\u3093
ERR_ENCPW_INVALID_ENCODED_AUTHPW_372=\u6307\u5b9a\u3055\u308c\u305f\u30d1\u30b9\u30ef\u30fc\u30c9\u306f\u3001\u6709\u52b9\u306a\u7b26\u53f7\u5316\u3055\u308c\u305f\u8a8d\u8a3c\u30d1\u30b9\u30ef\u30fc\u30c9\u5024\u3067\u306f\u3042\u308a\u307e\u305b\u3093:  %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY_373=\u30d1\u30b9\u30ef\u30fc\u30c9\u30dd\u30ea\u30b7\u30fc\u30b3\u30f3\u30dd\u30fc\u30cd\u30f3\u30c8\u306e\u521d\u671f\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
ERR_CANNOT_INITIALIZE_PWPOLICY_373=\u30d1\u30b9\u30ef\u30fc\u30c9\u30dd\u30ea\u30b7\u30fc\u30b3\u30f3\u30dd\u30fc\u30cd\u30f3\u30c8\u306e\u521d\u671f\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
INFO_STOPDS_DESCRIPTION_HOST_374=\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u306e\u30db\u30b9\u30c8\u540d\u307e\u305f\u306f IP \u30a2\u30c9\u30ec\u30b9
INFO_STOPDS_DESCRIPTION_PORT_375=\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u306e\u7ba1\u7406\u30dd\u30fc\u30c8\u756a\u53f7
INFO_STOPDS_DESCRIPTION_BINDDN_378=\u30b5\u30fc\u30d0\u30fc\u3078\u306e\u30d0\u30a4\u30f3\u30c9\u306b\u4f7f\u7528\u3059\u308b DN
@@ -1105,7 +1103,7 @@
ERR_BACKUPDB_CANNOT_BACKUP_IN_DIRECTORY_1650=\u30bf\u30fc\u30b2\u30c3\u30c8\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u3092\u30d0\u30c3\u30af\u30a2\u30c3\u30d7\u30c7\u30a3\u30ec\u30af\u30c8\u30ea %s \u306b\u30d0\u30c3\u30af\u30a2\u30c3\u30d7\u3067\u304d\u307e\u305b\u3093: \u3053\u306e\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u306f\u3059\u3067\u306b\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u306e\u30d0\u30c3\u30af\u30a2\u30c3\u30d7\u5834\u6240\u306b\u306a\u3063\u3066\u3044\u307e\u3059

INFO_RECURRING_TASK_PLACEHOLDER_1651={schedulePattern}
ERR_ENCPW_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=\u30b5\u30fc\u30d0\u30fc\u30b3\u30f3\u30dd\u30fc\u30cd\u30f3\u30c8\u3092\u521d\u671f\u5316\u3057\u3066\u7b26\u53f7\u5316\u30d1\u30b9\u30ef\u30fc\u30c9\u30c4\u30fc\u30eb\u3092\u5b9f\u884c\u3057\u3066\u3044\u308b\u3068\u304d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s
ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=\u30fc\u30d0\u30fc\u30b3\u30f3\u30dd\u30fc\u30cd\u30f3\u30c8\u3092\u521d\u671f\u5316\u3057\u3066\u30c4\u30fc\u30eb\u3092\u5b9f\u884c\u3057\u3066\u3044\u308b\u3068\u304d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f\uff1a %s
ERR_LDIFIMPORT_COUNT_REJECTS_REQUIRES_OFFLINE_1653=%s \u5f15\u6570\u306f\u3001\u30aa\u30f3\u30e9\u30a4\u30f3\u306e\u30a4\u30f3\u30dd\u30fc\u30c8\u3067\u306f\u30b5\u30dd\u30fc\u30c8\u3055\u308c\u3066\u3044\u307e\u305b\u3093
INFO_DESCRIPTION_RECURRING_TASK_1654=\u30bf\u30b9\u30af\u304c\u518d\u5e30\u4e2d\u3067\u3001crontab(5) \u4e92\u63db\u306e\u6642\u523b/\u65e5\u4ed8\u30d1\u30bf\u30fc\u30f3\u3067\u8868\u3055\u308c\u305f\u5024\u5f15\u6570\u306b\u5f93\u3063\u3066\u30b9\u30b1\u30b8\u30e5\u30fc\u30ea\u30f3\u30b0\u3055\u308c\u308b\u3053\u3068\u3092\u793a\u3057\u307e\u3059
INFO_TASK_TOOL_RECURRING_TASK_SCHEDULED_1655=\u518d\u5e30\u4e2d\u306e %s \u30bf\u30b9\u30af %s \u304c\u6b63\u5e38\u306b\u30b9\u30b1\u30b8\u30e5\u30fc\u30ea\u30f3\u30b0\u3055\u308c\u307e\u3057\u305f

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

@@ -59,7 +59,7 @@
ERR_CANNOT_LOAD_CONFIG_21=\ub514\ub809\ud1a0\ub9ac \uc11c\ubc84 \uad6c\uc131\uc744 \ub85c\ub4dc\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_CANNOT_LOAD_SCHEMA_22=\ub514\ub809\ud1a0\ub9ac \uc11c\ubc84 \uc2a4\ud0a4\ub9c8\ub97c \ub85c\ub4dc\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_CANNOT_INITIALIZE_CORE_CONFIG_23=\ucf54\uc5b4 \ub514\ub809\ud1a0\ub9ac \uc11c\ubc84 \uad6c\uc131\uc744 \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=\ub514\ub809\ud1a0\ub9ac \uc11c\ubc84 \ube44\ubc00\ubc88\ud638 \uc800\uc7a5\uc18c \uc2a4\ud0a4\ub9c8\ub97c \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=\ub514\ub809\ud1a0\ub9ac \uc11c\ubc84 \ube44\ubc00\ubc88\ud638 \uc800\uc7a5\uc18c \uc2a4\ud0a4\ub9c8\ub97c \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_ENCPW_NO_STORAGE_SCHEMES_25=\ub514\ub809\ud1a0\ub9ac \uc11c\ubc84\uc5d0\uc11c \uc0ac\uc6a9\ud560 \ube44\ubc00\ubc88\ud638 \uc800\uc7a5\uc18c \uc2a4\ud0a4\ub9c8\ub97c \uad6c\uc131\ud558\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4.
ERR_ENCPW_NO_SUCH_SCHEME_26=\ub514\ub809\ud1a0\ub9ac \uc11c\ubc84\uc5d0\uc11c \uc0ac\uc6a9\ud560 \ube44\ubc00\ubc88\ud638 \uc800\uc7a5\uc18c \uc2a4\ud0a4\ub9c8 \"%s\"\uc744(\ub97c) \uad6c\uc131\ud558\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4.
INFO_ENCPW_PASSWORDS_MATCH_27=\uc81c\uacf5\ub41c \uc77c\ubc18 \ud14d\uc2a4\ud2b8\uc640 \uc778\ucf54\ub529\ub41c \ube44\ubc00\ubc88\ud638\uac00 \uc77c\uce58\ud569\ub2c8\ub2e4.
@@ -287,8 +287,6 @@
WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND_337=\ubc31\uc5d4\ub4dc %s\uc5d0 \ub300\ud55c \uacf5\uc720 \uc7a0\uae08\uc744 \ud574\uc81c\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s. \uc774 \uc7a0\uae08\uc740 \ud655\uc778 \ud504\ub85c\uc138\uc2a4\uac00 \uc885\ub8cc\ub418\uba74 \uc790\ub3d9\uc73c\ub85c \uc815\ub9ac\ub418\ubbc0\ub85c \ubcc4\ub3c4\uc758 \uc791\uc5c5\uc774 \ud544\uc694\ud558\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4.
INFO_DESCRIPTION_TYPES_ONLY_338=\uac12\uc740 \uc81c\uc678\ud558\uace0 \uc18d\uc131 \uc774\ub984\ub9cc \uac80\uc0c9\ud569\ub2c8\ub2e4.
INFO_LDIFIMPORT_DESCRIPTION_SKIP_SCHEMA_VALIDATION_339=LDIF \uac00\uc838\uc624\uae30\ub97c \uc218\ud589\ud558\ub294 \ub3d9\uc548 \uc2a4\ud0a4\ub9c8 \ud655\uc778\uc744 \uac74\ub108\ub701\ub2c8\ub2e4.
ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS_340=LDIF \ub0b4\ubcf4\ub0b4\uae30 \ud50c\ub7ec\uadf8\uc778\uc744 \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS_341=LDIF \uac00\uc838\uc624\uae30 \ud50c\ub7ec\uadf8\uc778\uc744 \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
INFO_DESCRIPTION_ASSERTION_FILTER_342=\uc81c\uacf5\ub41c \ud544\ud130\ub97c \uac00\uc9c4 LDAP \uba85\uc81c \uc81c\uc5b4\ub97c \uc0ac\uc6a9\ud569\ub2c8\ub2e4.
ERR_LDAP_ASSERTION_INVALID_FILTER_343=LDAP \uba85\uc81c \uc81c\uc5b4\uc5d0 \ub300\ud574 \uc81c\uacf5\ub41c \uac80\uc0c9 \ud544\ud130\uac00 \uc720\ud6a8\ud558\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4: %s
INFO_DESCRIPTION_PREREAD_ATTRS_346=LDAP ReadEntry pre-read \uc81c\uc5b4\ub97c \uc0ac\uc6a9\ud569\ub2c8\ub2e4.
@@ -315,7 +313,7 @@
INFO_ENCPW_DESCRIPTION_AUTHPW_369=\uc0ac\uc6a9\uc790 \ube44\ubc00\ubc88\ud638 \uad6c\ubb38 \ub300\uc2e0 \uc778\uc99d \ube44\ubc00\ubc88\ud638 \uad6c\ubb38\uc744 \uc0ac\uc6a9\ud569\ub2c8\ub2e4.
ERR_ENCPW_NO_SUCH_AUTH_SCHEME_371=\ub514\ub809\ud1a0\ub9ac \uc11c\ubc84\uc5d0\uc11c \uc0ac\uc6a9\ud560 \uc778\uc99d \ube44\ubc00\ubc88\ud638 \uc800\uc7a5\uc18c \uc2a4\ud0a4\ub9c8 \"%s\"\uc744(\ub97c)\uad6c\uc131\ud558\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4.
ERR_ENCPW_INVALID_ENCODED_AUTHPW_372=\uc81c\uacf5\ub41c \ube44\ubc00\ubc88\ud638\ub294 \uc720\ud6a8\ud55c \uc778\ucf54\ub529\ub41c \uc778\uc99d \ube44\ubc00\ubc88\ud638 \uac12\uc774 \uc544\ub2d9\ub2c8\ub2e4: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY_373=\ube44\ubc00\ubc88\ud638 \uc815\ucc45 \uad6c\uc131\uc694\uc18c\ub97c \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_CANNOT_INITIALIZE_PWPOLICY_373=\ube44\ubc00\ubc88\ud638 \uc815\ucc45 \uad6c\uc131\uc694\uc18c\ub97c \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
INFO_STOPDS_DESCRIPTION_HOST_374=\ub514\ub809\ud1a0\ub9ac \uc11c\ubc84 \ud638\uc2a4\ud2b8 \uc774\ub984 \ub610\ub294 IP \uc8fc\uc18c
INFO_STOPDS_DESCRIPTION_PORT_375=Directory server administration port number
INFO_STOPDS_DESCRIPTION_BINDDN_378=\uc11c\ubc84\uc5d0 \ubc14\uc778\ub4dc\ud558\ub294 \ub370 \uc0ac\uc6a9\ud560 DN

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

@@ -59,7 +59,7 @@
ERR_CANNOT_LOAD_CONFIG_21=\u5728\u5c1d\u8bd5\u88c5\u5165 Directory Server \u914d\u7f6e\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_CANNOT_LOAD_SCHEMA_22=\u5728\u5c1d\u8bd5\u88c5\u5165 Directory Server \u6a21\u5f0f\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_CANNOT_INITIALIZE_CORE_CONFIG_23=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316\u6838\u5fc3 Directory Server \u914d\u7f6e\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316 Directory Server \u5bc6\u7801\u5b58\u50a8\u6a21\u5f0f\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316 Directory Server \u5bc6\u7801\u5b58\u50a8\u6a21\u5f0f\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_ENCPW_NO_STORAGE_SCHEMES_25=\u5c1a\u672a\u914d\u7f6e\u5728 Directory Server \u4e2d\u4f7f\u7528\u7684\u5bc6\u7801\u5b58\u50a8\u6a21\u5f0f
ERR_ENCPW_NO_SUCH_SCHEME_26=\u5bc6\u7801\u5b58\u50a8\u6a21\u5f0f "%s" \u5e76\u975e\u914d\u7f6e\u4e3a\u5728 Directory Server \u4e2d\u4f7f\u7528
INFO_ENCPW_PASSWORDS_MATCH_27=\u63d0\u4f9b\u7684\u660e\u6587\u5bc6\u7801\u548c\u5df2\u7f16\u7801\u5bc6\u7801\u76f8\u5339\u914d
@@ -289,8 +289,6 @@
WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND_337=\u5728\u5c1d\u8bd5\u91ca\u653e\u540e\u7aef %s \u7684\u5171\u4eab\u9501\u5b9a\u65f6\u51fa\u73b0\u9519\u8bef: %s\u3002\u6b64\u9501\u5b9a\u5e94\u5728\u68c0\u9a8c\u8fdb\u7a0b\u9000\u51fa\u65f6\u81ea\u52a8\u6e05\u9664\uff0c\u56e0\u6b64\u5e94\u65e0\u9700\u8fdb\u4e00\u6b65\u64cd\u4f5c
INFO_DESCRIPTION_TYPES_ONLY_338=\u4ec5\u68c0\u7d22\u5c5e\u6027\u540d\u79f0\uff0c\u800c\u4e0d\u68c0\u7d22\u5c5e\u6027\u503c
INFO_LDIFIMPORT_DESCRIPTION_SKIP_SCHEMA_VALIDATION_339=\u5728 LDIF \u5bfc\u5165\u671f\u95f4\u8df3\u8fc7\u6a21\u5f0f\u9a8c\u8bc1
ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS_340=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316 LDIF \u5bfc\u51fa\u63d2\u4ef6\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS_341=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316 LDIF \u5bfc\u5165\u63d2\u4ef6\u65f6\u51fa\u73b0\u9519\u8bef: %s
INFO_DESCRIPTION_ASSERTION_FILTER_342=\u5c06 LDAP \u58f0\u660e\u63a7\u5236\u7528\u4e8e\u63d0\u4f9b\u7684\u8fc7\u6ee4\u5668
ERR_LDAP_ASSERTION_INVALID_FILTER_343=\u4e3a LDAP \u58f0\u660e\u63a7\u5236\u63d0\u4f9b\u7684\u641c\u7d22\u8fc7\u6ee4\u5668\u65e0\u6548: %s
INFO_DESCRIPTION_PREREAD_ATTRS_346=\u4f7f\u7528 LDAP ReadEntry \u9884\u8bfb\u53d6\u63a7\u5236
@@ -317,7 +315,7 @@
INFO_ENCPW_DESCRIPTION_AUTHPW_369=\u4f7f\u7528\u9a8c\u8bc1\u5bc6\u7801\u8bed\u6cd5\uff0c\u800c\u4e0d\u662f\u7528\u6237\u5bc6\u7801\u8bed\u6cd5
ERR_ENCPW_NO_SUCH_AUTH_SCHEME_371=\u9a8c\u8bc1\u5bc6\u7801\u5b58\u50a8\u6a21\u5f0f "%s" \u5e76\u975e\u914d\u7f6e\u4e3a\u5728 Directory Server \u4e2d\u4f7f\u7528
ERR_ENCPW_INVALID_ENCODED_AUTHPW_372=\u63d0\u4f9b\u7684\u5bc6\u7801\u4e0d\u662f\u6709\u6548\u7f16\u7801\u7684\u9a8c\u8bc1\u5bc6\u7801\u503c: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY_373=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316\u5bc6\u7801\u7b56\u7565\u7ec4\u4ef6\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_CANNOT_INITIALIZE_PWPOLICY_373=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316\u5bc6\u7801\u7b56\u7565\u7ec4\u4ef6\u65f6\u51fa\u73b0\u9519\u8bef: %s
INFO_STOPDS_DESCRIPTION_HOST_374=\u76ee\u5f55\u670d\u52a1\u5668\u4e3b\u673a\u540d\u6216 IP \u5730\u5740
INFO_STOPDS_DESCRIPTION_PORT_375=\u76ee\u5f55\u670d\u52a1\u5668\u7ba1\u7406\u7aef\u53e3\u53f7
INFO_STOPDS_DESCRIPTION_BINDDN_378=\u7528\u4e8e\u7ed1\u5b9a\u5230\u670d\u52a1\u5668\u7684 DN
@@ -1105,7 +1103,7 @@
ERR_BACKUPDB_CANNOT_BACKUP_IN_DIRECTORY_1650=\u76ee\u6807\u540e\u7aef %s \u65e0\u6cd5\u5907\u4efd\u5230\u5907\u4efd\u76ee\u5f55 %s\uff1a\u6b64\u76ee\u5f55\u5df2\u7ecf\u662f\u540e\u7aef %s \u7684\u5907\u4efd\u4f4d\u7f6e

INFO_RECURRING_TASK_PLACEHOLDER_1651={schedulePattern}
ERR_ENCPW_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316\u670d\u52a1\u5668\u7ec4\u4ef6\u4ee5\u8fd0\u884c\u7f16\u7801\u5bc6\u7801\u5de5\u5177\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_CANNOT_INITIALIZE_SERVER_COMPONENTS_1652=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316\u670d\u52a1\u5668\u7ec4\u4ef6\u4ee5\u8fd0\u884c\u5de5\u5177\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_LDIFIMPORT_COUNT_REJECTS_REQUIRES_OFFLINE_1653=\u8054\u673a\u5bfc\u5165\u4e0d\u652f\u6301 %s \u53c2\u6570
INFO_DESCRIPTION_RECURRING_TASK_1654=\u6307\u51fa\u4efb\u52a1\u662f\u590d\u53d1\u6027\u7684\u5e76\u5c06\u6839\u636e\u4ee5 crontab(5) \u53ef\u517c\u5bb9\u7684\u65f6\u95f4/\u65e5\u671f\u6a21\u5f0f\u8868\u793a\u7684\u503c\u53c2\u6570\u8fdb\u884c\u9884\u5b9a
INFO_TASK_TOOL_RECURRING_TASK_SCHEDULED_1655=\u5df2\u6210\u529f\u9884\u5b9a\u590d\u53d1\u6027 %s \u4efb\u52a1 %s

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

@@ -59,7 +59,7 @@
ERR_CANNOT_LOAD_CONFIG_21=\u5617\u8a66\u8f09\u5165\u76ee\u9304\u4f3a\u670d\u5668\u914d\u7f6e\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_CANNOT_LOAD_SCHEMA_22=\u5617\u8a66\u8f09\u5165\u76ee\u9304\u4f3a\u670d\u5668\u6a21\u5f0f\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_CANNOT_INITIALIZE_CORE_CONFIG_23=\u5617\u8a66\u521d\u59cb\u5316\u6838\u5fc3\u76ee\u9304\u4f3a\u670d\u5668\u914d\u7f6e\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_ENCPW_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=\u5617\u8a66\u521d\u59cb\u5316\u76ee\u9304\u4f3a\u670d\u5668\u7684\u5bc6\u78bc\u5132\u5b58\u6a5f\u5236\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_CANNOT_INITIALIZE_STORAGE_SCHEMES_24=\u5617\u8a66\u521d\u59cb\u5316\u76ee\u9304\u4f3a\u670d\u5668\u7684\u5bc6\u78bc\u5132\u5b58\u6a5f\u5236\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_ENCPW_NO_STORAGE_SCHEMES_25=\u5c1a\u672a\u914d\u7f6e\u5bc6\u78bc\u5132\u5b58\u6a5f\u5236\uff0c\u4ee5\u4fbf\u7528\u65bc\u76ee\u9304\u4f3a\u670d\u5668\u4e2d
ERR_ENCPW_NO_SUCH_SCHEME_26=\u672a\u914d\u7f6e\u5bc6\u78bc\u5132\u5b58\u6a5f\u5236\u300c%s\u300d\uff0c\u4ee5\u4fbf\u7528\u65bc\u76ee\u9304\u4f3a\u670d\u5668\u4e2d
INFO_ENCPW_PASSWORDS_MATCH_27=\u63d0\u4f9b\u7684\u7d14\u6587\u5b57\u8207\u7de8\u78bc\u5bc6\u78bc\u76f8\u7b26
@@ -287,8 +287,6 @@
WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND_337=\u5617\u8a66\u91cb\u653e\u5f8c\u7aef %s \u7684\u5171\u7528\u9396\u5b9a\u6642\u767c\u751f\u932f\u8aa4: %s\u3002\u6b64\u9396\u5b9a\u61c9\u6703\u5728\u9a57\u8b49\u7a0b\u5e8f\u7d50\u675f\u6642\u81ea\u52d5\u6e05\u9664\uff0c\u6240\u4ee5\u4e0d\u9700\u8981\u5176\u4ed6\u52d5\u4f5c
INFO_DESCRIPTION_TYPES_ONLY_338=\u53ea\u64f7\u53d6\u5c6c\u6027\u540d\u7a31\uff0c\u4f46\u4e0d\u6703\u64f7\u53d6\u5176\u503c
INFO_LDIFIMPORT_DESCRIPTION_SKIP_SCHEMA_VALIDATION_339=\u5728 LDIF \u532f\u5165\u671f\u9593\u7565\u904e\u6a21\u5f0f\u9a57\u8b49
ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS_340=\u5617\u8a66\u521d\u59cb\u5316 LDIF \u532f\u51fa\u5916\u639b\u7a0b\u5f0f\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PLUGINS_341=\u5617\u8a66\u521d\u59cb\u5316 LDIF \u532f\u5165\u5916\u639b\u7a0b\u5f0f\u6642\u767c\u751f\u932f\u8aa4: %s
INFO_DESCRIPTION_ASSERTION_FILTER_342=\u900f\u904e\u6240\u63d0\u4f9b\u7684\u7be9\u9078\u5668\u4f7f\u7528 LDAP \u6307\u5b9a\u63a7\u5236
ERR_LDAP_ASSERTION_INVALID_FILTER_343=\u70ba LDAP \u6307\u5b9a\u63a7\u5236\u63d0\u4f9b\u7684\u641c\u5c0b\u7be9\u9078\u5668\u7121\u6548: %s
INFO_DESCRIPTION_PREREAD_ATTRS_346=\u4f7f\u7528 LDAP ReadEntry \u8b80\u53d6\u524d\u63a7\u5236
@@ -315,7 +313,7 @@
INFO_ENCPW_DESCRIPTION_AUTHPW_369=\u4f7f\u7528\u8a8d\u8b49\u5bc6\u78bc\u8a9e\u6cd5\uff0c\u800c\u975e\u4f7f\u7528\u8005\u5bc6\u78bc\u8a9e\u6cd5
ERR_ENCPW_NO_SUCH_AUTH_SCHEME_371=\u672a\u914d\u7f6e\u8a8d\u8b49\u5bc6\u78bc\u5132\u5b58\u6a5f\u5236\u300c%s\u300d\uff0c\u4ee5\u4fbf\u7528\u65bc\u76ee\u9304\u4f3a\u670d\u5668\u4e2d
ERR_ENCPW_INVALID_ENCODED_AUTHPW_372=\u63d0\u4f9b\u7684\u5bc6\u78bc\u4e0d\u662f\u6709\u6548\u7684\u7de8\u78bc\u8a8d\u8b49\u5bc6\u78bc\u503c: %s
ERR_LDIFIMPORT_CANNOT_INITIALIZE_PWPOLICY_373=\u5617\u8a66\u521d\u59cb\u5316\u5bc6\u78bc\u7b56\u7565\u5143\u4ef6\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_CANNOT_INITIALIZE_PWPOLICY_373=\u5617\u8a66\u521d\u59cb\u5316\u5bc6\u78bc\u7b56\u7565\u5143\u4ef6\u6642\u767c\u751f\u932f\u8aa4: %s
INFO_STOPDS_DESCRIPTION_HOST_374=\u76ee\u9304\u4f3a\u670d\u5668\u4e3b\u6a5f\u540d\u7a31\u6216 IP \u4f4d\u5740
INFO_STOPDS_DESCRIPTION_PORT_375=Directory server administration port number
INFO_STOPDS_DESCRIPTION_BINDDN_378=\u7528\u4ee5\u9023\u7d50\u81f3\u4f3a\u670d\u5668\u7684 DN