OPENDJ-1791 Implement a tool like dbtest for the pluggable backend

Fabio Pistolesi

07.27.2015 36e213444660f0a74ed415adeab490a5f3d50a6f

OPENDJ-1791 Implement a tool like dbtest for the pluggable backend

Implement debugging tool for pluggable backend on the same lines as dbtest, adding storage and backend level information.
 When dumping trees at seen from the backend, also try to print keys and values according to their meaning.

 opendj-core/src/main/java/org/forgerock/opendj/ldap/ByteString.java

@@ -443,6 +443,29 @@
        }
    }

    /**
     * Returns a 7-bit ASCII string representation.
     * Non-ASCII characters will be expanded to percent (%) hexadecimal value.
     * @return a 7-bit ASCII string representation
     */
    public String toASCIIString() {
        if (length == 0) {
            return "";
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            byte b = buffer[offset + i];
            if (StaticUtils.isPrintable(b)) {
                sb.append((char) b);
            } else {
                sb.append('%');
                sb.append(StaticUtils.byteToHex(b));
            }
        }
        return sb.toString();
    }

    private static byte hexToByte(final String value, final char c1, final char c2) {
        byte b;
        switch (c1) {

 opendj-core/src/main/java/org/forgerock/opendj/ldap/DN.java

@@ -912,6 +912,16 @@
    }

    /**
     * Returns an ASCII printable string representation.
     *
     * @param seq a normalized DN
     * @return an ASCII printable string representation
     */
    public static String normalizedToASCII(ByteSequence seq) {
        return seq.toByteString().toASCIIString();
    }

    /**
     * Retrieves a normalized string representation of this DN.
     * <p>
     * This representation is safe to use in an URL or in a file name.

 opendj-core/src/main/java/org/forgerock/opendj/ldap/schema/DistinguishedNameEqualityMatchingRuleImpl.java

@@ -57,6 +57,6 @@

    @Override
    public String keyToHumanReadableString(ByteSequence key) {
        return key.toString();
        return key.toByteString().toASCIIString();
    }
}

 opendj-server-legacy/pom.xml

@@ -1583,6 +1583,15 @@
                    </tool>

                    <tool>
                      <name>backendtool</name>
                      <application>org.opends.server.backends.pluggable.BackendTool</application>
                      <trailingSectionPaths>
                        <trailingSectionPath>exit-codes-0-gt0.xml</trailingSectionPath>
                        <trailingSectionPath>backendtool-examples.xml</trailingSectionPath>
                      </trailingSectionPaths>
                    </tool>

                    <tool>
                     <name>dbtest</name>
                     <application>org.opends.server.backends.jeb.DBTest</application>
                     <trailingSectionPaths>

 opendj-server-legacy/resource/bin/backendtool

New file
@@ -0,0 +1,36 @@
#!/bin/sh
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License, Version 1.0 only
# (the "License").  You may not use this file except in compliance
# with the License.
#
# You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
# or http://forgerock.org/license/CDDLv1.0.html.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at legal-notices/CDDLv1_0.txt.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information:
#      Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
#      Portions Copyright 2015 ForgeRock AS


# This script may be used to debug Pluggable backends in the Directory Server.
OPENDJ_INVOKE_CLASS="org.opends.server.backends.pluggable.BackendTool"
export OPENDJ_INVOKE_CLASS

SCRIPT_NAME="backendtool"
export SCRIPT_NAME

SCRIPT_DIR=`dirname "${0}"`
"${SCRIPT_DIR}/../lib/_server-script.sh" "${@}"

 opendj-server-legacy/resource/bin/backendtool.bat

New file
@@ -0,0 +1,32 @@

@echo off
rem CDDL HEADER START
rem
rem The contents of this file are subject to the terms of the
rem Common Development and Distribution License, Version 1.0 only
rem (the "License").  You may not use this file except in compliance
rem with the License.
rem
rem You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
rem or http://forgerock.org/license/CDDLv1.0.html.
rem See the License for the specific language governing permissions
rem and limitations under the License.
rem
rem When distributing Covered Code, include this CDDL HEADER in each
rem file and include the License file at legal-notices/CDDLv1_0.txt.
rem If applicable, add the following below this CDDL HEADER, with the
rem fields enclosed by brackets "[]" replaced with your own identifying
rem information:
rem      Portions Copyright [yyyy] [name of copyright owner]
rem
rem CDDL HEADER END
rem
rem
rem      Portions Copyright 2015 ForgeRock AS

setlocal

set OPENDJ_INVOKE_CLASS="org.opends.server.backends.pluggable.BackendTool"
set SCRIPT_NAME=backendtool
for %%i in (%~sf0) do call "%%~dPsi\..\lib\_server-script.bat" %*


 opendj-server-legacy/src/main/docbkx/man-pages/backendtool-examples.xml

New file
@@ -0,0 +1,53 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
  ! CDDL HEADER START
  !
  ! The contents of this file are subject to the terms of the
  ! Common Development and Distribution License, Version 1.0 only
  ! (the "License").  You may not use this file except in compliance
  ! with the License.
  !
  ! You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
  ! or http://forgerock.org/license/CDDLv1.0.html.
  ! See the License for the specific language governing permissions
  ! and limitations under the License.
  !
  ! When distributing Covered Code, include this CDDL HEADER in each
  ! file and include the License file at legal-notices/CDDLv1_0.txt.
  ! If applicable, add the following below this CDDL HEADER, with the
  ! fields enclosed by brackets "[]" replaced with your own identifying
  ! information:
  !      Portions Copyright [yyyy] [name of copyright owner]
  !
  ! CDDL HEADER END
  !
  !      Copyright 2015 ForgeRock AS.
  !
-->
<refsect1 xmlns="http://docbook.org/ns/docbook"
          version="5.0" xml:lang="en"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://docbook.org/ns/docbook
                              http://docbook.org/xml/5.0/xsd/docbook.xsd">
 <title>Examples</title>

 <para>
  The following example displays index information.
 </para>

 <screen>
$ <userinput>bin/backendtool dump-tree  -n userRoot -b dc=example,dc=com -t id2childrencount </userinput>
<computeroutput>
    Key (len 2): 1#52
    Value (len 8): 1
    Key (len 2): 2#52
    Value (len 8): 500000
    Key (len 9): Total Children Count
    Value (len 8): 500001

    Total Records: 3
    Total / Average Key Size: 13 bytes / 4 bytes
    Total / Average Data Size: 24 bytes / 8 bytes
</computeroutput>
 </screen>
</refsect1>

 opendj-server-legacy/src/main/docbkx/man-pages/index.xml

@@ -63,6 +63,9 @@
  <xinclude:include href="man-backup.xml">
   <xinclude:fallback><!-- Failed to include page --></xinclude:fallback>
  </xinclude:include>
  <xinclude:include href="man-backendtool.xml">
   <xinclude:fallback><!-- Failed to include page --></xinclude:fallback>
  </xinclude:include>
  <xinclude:include href="man-base64.xml">
   <xinclude:fallback><!-- Failed to include page --></xinclude:fallback>
  </xinclude:include>

 opendj-server-legacy/src/main/docbkx/man-pages/variablelist-backendtool-index-status.xml

New file
@@ -0,0 +1,124 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
  ! CDDL HEADER START
  !
  ! The contents of this file are subject to the terms of the
  ! Common Development and Distribution License, Version 1.0 only
  ! (the "License").  You may not use this file except in compliance
  ! with the License.
  !
  ! You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
  ! or http://forgerock.org/license/CDDLv1.0.html.
  ! See the License for the specific language governing permissions
  ! and limitations under the License.
  !
  ! When distributing Covered Code, include this CDDL HEADER in each
  ! file and include the License file at legal-notices/CDDLv1_0.txt.
  ! If applicable, add the following below this CDDL HEADER, with the
  ! fields enclosed by brackets "[]" replaced with your own identifying
  ! information:
  !      Portions Copyright [yyyy] [name of copyright owner]
  !
  ! CDDL HEADER END
  !
  !      Copyright 2015 ForgeRock AS.
  !
-->
<variablelist
              xmlns='http://docbook.org/ns/docbook' version='5.0' xml:lang='en'
              xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
              xsi:schemaLocation='http://docbook.org/ns/docbook
                                  http://docbook.org/xml/5.0/xsd/docbook.xsd'>

 <para>
  When you run the 'list-index-status' command, the result is a table, followed by a "Total",
  which is the total number of indexes, followed by a list of indexes with "Over index-entry-limit keys" to
  show the values for which the number of entries exceeded the index entry limit.
  The table has the following columns.
 </para>

 <varlistentry>
  <term>Index Name</term>
  <listitem>
   <para>
    Name of the index, which takes the form <replaceable>attr.type</replaceable> for attribute indexes,
    and vlv.<replaceable>name</replaceable> for VLV indexes.
    Some indexes are for OpenDJ directory server's internal use.
   </para>

   <para>
    Example: <literal>givenName.caseIgnoreSubstringsMatch:6</literal>
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Tree Name</term>
  <listitem>
   <para>
    Name of the backend tree, which reflects how OpenDJ directory server organizes the data in the database.
   </para>

   <para>
    Example: <literal>/dc=example,dc=com/givenName.caseIgnoreSubstringsMatch:6</literal>
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Index Valid</term>
  <listitem>
   <para>
    This is <literal>true</literal> for valid indexes. If this is <literal>false</literal>, the index might be degraded.
    Verify the index, and rebuild the index if necessary.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Record Count</term>
  <listitem>
   <para>
    Number of indexed keys.
    Use the <command>backendtool dump-tree</command> command to see how many entry IDs correspond to each key.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Over Index Entry Limit</term>
  <listitem>
   <para>
    Number of keys for which there are too many values to maintain an index, based on the index entry limit.
    This is recorded as <literal>-</literal> for VLV indexes.
   </para>

   <para>
    In other words, with the default index entry limit of 4000, if every user in your large directory has
    an email address ending in <literal>@example.com</literal>, and a substring index with default substring
    length of 6 is maintained for <literal>mail</literal>, then OpenDJ directory server does not maintain indexes
    for keys corresponding to substrings in <literal>@example.com</literal>.
   </para>

   <para>
    As a result, an LDAP search with the filter <literal>"(mail=*@example.com)"</literal> becomes an unindexed search
    even though a substring index exists for the mail attribute.
    By default OpenDJ directory server does not allow unindexed searches except by privileged users.
    This is usually exactly the behavior you want in order to prevent client applications
    from sending searches that return every user in the directory for example.
    Clients should refine their search filters instead.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>95&#x25;, 90&#x25;, 85&#x25;</term>
  <listitem>
   <para>
    Number of keys for which the number of values is approaching the index entry limit, having at least the specified
    percentage.
    This is a measure of how full the entry ID lists are.
   </para>
  </listitem>
 </varlistentry>
</variablelist>

 opendj-server-legacy/src/main/java/org/opends/server/backends/jeb/DBTest.java

@@ -85,7 +85,7 @@

/**
 * This program provides a utility that may be used to debug a JE backend. This
 * tool provides the ability list various containers in the backend as well as
 * tool provides the ability to list various containers in the backend as well as
 * dump the contents of database containers. This will be
 * a process that is intended to run separate from Directory Server and not
 * internally within the server process (e.g., via the tasks interface).
@@ -248,11 +248,11 @@


      sub = new SubCommand(parser, "list-entry-containers",
                    INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS.get());
                    INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS.get());
      backendID =
          new StringArgument("backendid", 'n', "backendID", true, false, true,
                             INFO_BACKENDNAME_PLACEHOLDER.get(), null, null,
                             INFO_DESCRIPTION_DBTEST_BACKEND_ID.get());
                             INFO_DESCRIPTION_BACKEND_DEBUG_BACKEND_ID.get());
      sub.addArgument(backendID);


@@ -261,13 +261,13 @@
      backendID =
          new StringArgument("backendid", 'n', "backendID", true, false, true,
                             INFO_BACKENDNAME_PLACEHOLDER.get(), null, null,
                             INFO_DESCRIPTION_DBTEST_BACKEND_ID.get());
                             INFO_DESCRIPTION_BACKEND_DEBUG_BACKEND_ID.get());
      sub.addArgument(backendID);
      baseDN =
          new StringArgument("basedn", 'b', "baseDN", false,
                             false, true, INFO_BASEDN_PLACEHOLDER.get(), null,
                             null,
                             INFO_DESCRIPTION_DBTEST_BASE_DN.get());
                             INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN.get());
      sub.addArgument(baseDN);


@@ -276,71 +276,71 @@
      backendID =
          new StringArgument("backendid", 'n', "backendID", true, false, true,
                             INFO_BACKENDNAME_PLACEHOLDER.get(), null, null,
                             INFO_DESCRIPTION_DBTEST_BACKEND_ID.get());
                             INFO_DESCRIPTION_BACKEND_DEBUG_BACKEND_ID.get());
      sub.addArgument(backendID);
      baseDN =
          new StringArgument("basedn", 'b', "baseDN", true,
                             false, true, INFO_BASEDN_PLACEHOLDER.get(), null,
                             null,
                             INFO_DESCRIPTION_DBTEST_BASE_DN.get());
                             INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN.get());
      sub.addArgument(baseDN);
      databaseName =
          new StringArgument("databasename", 'd', "databaseName", true,
                             false, true, INFO_DATABASE_NAME_PLACEHOLDER.get(),
                             null, null,
                             INFO_DESCRIPTION_DBTEST_DATABASE_NAME.get());
                             INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME.get());
      sub.addArgument(databaseName);
      skipDecode =
          new BooleanArgument("skipdecode", 'p', "skipDecode",
                              INFO_DESCRIPTION_DBTEST_SKIP_DECODE.get());
                              INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE.get());
      sub.addArgument(skipDecode);
      statsOnly =
          new BooleanArgument("statsonly", 'q', "statsOnly",
                              INFO_DESCRIPTION_DBTEST_STATS_ONLY.get());
                              INFO_DESCRIPTION_BACKEND_DEBUG_STATS_ONLY.get());
      sub.addArgument(statsOnly);
      maxKeyValue = new StringArgument("maxkeyvalue", 'K', "maxKeyValue", false,
                                       false, true,
                                       INFO_MAX_KEY_VALUE_PLACEHOLDER.get(),
                                       null, null,
                                   INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE.get());
                                   INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE.get());
      sub.addArgument(maxKeyValue);
      minKeyValue = new StringArgument("minkeyvalue", 'k', "minKeyValue", false,
                                       false, true,
                                       INFO_MIN_KEY_VALUE_PLACEHOLDER.get(),
                                       null,
                                       null,
                                   INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE.get());
                                   INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE.get());
      sub.addArgument(minKeyValue);
      maxDataSize = new IntegerArgument("maxdatasize", 'S', "maxDataSize",
                                        false, false, true,
                                        INFO_MAX_DATA_SIZE_PLACEHOLDER.get(),
                                        -1,
                                        null,
                                   INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE.get());
                                   INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE.get());
      sub.addArgument(maxDataSize);
      minDataSize = new IntegerArgument("mindatasize", 's', "minDataSize",
                                        false, false, true,
                                        INFO_MIN_DATA_SIZE_PLACEHOLDER.get(),
                                        -1,
                                        null,
                                   INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE.get());
                                   INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE.get());
      sub.addArgument(minDataSize);


      sub = new SubCommand(parser, "list-index-status",
                        INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS.get());
                        INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS.get());
      sub.setDocDescriptionSupplement(
              SUPPLEMENT_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS.get());
      backendID =
          new StringArgument("backendid", 'n', "backendID", true, false, true,
                             INFO_BACKENDNAME_PLACEHOLDER.get(), null, null,
                             INFO_DESCRIPTION_DBTEST_BACKEND_ID.get());
                             INFO_DESCRIPTION_BACKEND_DEBUG_BACKEND_ID.get());
      sub.addArgument(backendID);
      baseDN =
          new StringArgument("basedn", 'b', "baseDN", true,
                             true, true, INFO_BASEDN_PLACEHOLDER.get(), null,
                             null,
                             INFO_DESCRIPTION_DBTEST_BASE_DN.get());
                             INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN.get());
      sub.addArgument(baseDN);

      subCommandsInitialized = true;
@@ -489,7 +489,7 @@
    // Make sure that we have a sub-command.
    if (parser.getSubCommand() == null)
    {
      parser.displayMessageAndUsageReference(err, ERR_DBTEST_MISSING_SUBCOMMAND.get());
      parser.displayMessageAndUsageReference(err, ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND.get());
      return 1;
    }

@@ -541,7 +541,7 @@
    // Create a table of their properties.
    TableBuilder builder = new TableBuilder();

    builder.appendHeading(INFO_LABEL_DBTEST_BACKEND_ID.get());
    builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_BACKEND_ID.get());
    builder.appendHeading(INFO_LABEL_DBTEST_DB_DIRECTORY.get());

    for(Map.Entry<LocalDBBackendCfg, BackendImpl> backend :
@@ -575,13 +575,13 @@
      StringBuilder failureReason = new StringBuilder();
      if (! LockFileManager.acquireSharedLock(lockFile, failureReason))
      {
        printWrappedText(err, ERR_DBTEST_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        return 1;
      }
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_DBTEST_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      return 1;
    }

@@ -603,9 +603,9 @@
      TableBuilder builder = new TableBuilder();
      int count = 0;

      builder.appendHeading(INFO_LABEL_DBTEST_BASE_DN.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_BASE_DN.get());
      builder.appendHeading(INFO_LABEL_DBTEST_JE_DATABASE_PREFIX.get());
      builder.appendHeading(INFO_LABEL_DBTEST_ENTRY_COUNT.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_ENTRY_COUNT.get());

      for(EntryContainer ec : rc.getEntryContainers())
      {
@@ -651,7 +651,7 @@
      }
      catch(DirectoryException de)
      {
        printWrappedText(err, ERR_DBTEST_DECODE_BASE_DN.get(baseDN.getValue(), getExceptionMessage(de)));
        printWrappedText(err, ERR_BACKEND_DEBUG_DECODE_BASE_DN.get(baseDN.getValue(), getExceptionMessage(de)));
        return 1;
      }
    }
@@ -663,13 +663,13 @@
      StringBuilder failureReason = new StringBuilder();
      if (! LockFileManager.acquireSharedLock(lockFile, failureReason))
      {
        printWrappedText(err, ERR_DBTEST_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        return 1;
      }
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_DBTEST_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      return 1;
    }

@@ -695,14 +695,14 @@
      builder.appendHeading(INFO_LABEL_DBTEST_DATABASE_NAME.get());
      builder.appendHeading(INFO_LABEL_DBTEST_DATABASE_TYPE.get());
      builder.appendHeading(INFO_LABEL_DBTEST_JE_DATABASE_NAME.get());
      builder.appendHeading(INFO_LABEL_DBTEST_ENTRY_COUNT.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_ENTRY_COUNT.get());

      if(base != null)
      {
        EntryContainer ec = rc.getEntryContainer(base);
        if(ec == null)
        {
          printWrappedText(err, ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN.get(base, backend.getBackendID()));
          printWrappedText(err, ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN.get(base, backend.getBackendID()));
          return 1;
        }

@@ -773,12 +773,13 @@
      StringBuilder failureReason = new StringBuilder();
      if (!LockFileManager.releaseLock(lockFile, failureReason))
      {
        printWrappedText(err, WARN_DBTEST_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), failureReason));
        printWrappedText(err, WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), failureReason));
      }
    }
    catch (Exception e)
    {
      printWrappedText(err, WARN_DBTEST_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      printWrappedText(err, WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND.get(
          backend.getBackendID(), getExceptionMessage(e)));
    }
  }

@@ -804,7 +805,7 @@
        return null;
      }
    }
    printWrappedText(err, ERR_DBTEST_NO_BACKENDS_FOR_ID.get(backendID));
    printWrappedText(err, ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID.get(backendID));
    return null;
  }

@@ -825,7 +826,7 @@
      }
      catch(DirectoryException de)
      {
        printWrappedText(err, ERR_DBTEST_DECODE_BASE_DN.get(baseDN.getValue(), getExceptionMessage(de)));
        printWrappedText(err, ERR_BACKEND_DEBUG_DECODE_BASE_DN.get(baseDN.getValue(), getExceptionMessage(de)));
        return 1;
      }
    }
@@ -837,13 +838,13 @@
      StringBuilder failureReason = new StringBuilder();
      if (! LockFileManager.acquireSharedLock(lockFile, failureReason))
      {
        printWrappedText(err, ERR_DBTEST_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        return 1;
      }
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_DBTEST_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      return 1;
    }

@@ -866,11 +867,11 @@
      TableBuilder builder = new TableBuilder();
      int count = 0;

      builder.appendHeading(INFO_LABEL_DBTEST_INDEX_NAME.get());
      builder.appendHeading(INFO_LABEL_DBTEST_INDEX_TYPE.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_INDEX_NAME.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE.get());
      builder.appendHeading(INFO_LABEL_DBTEST_JE_DATABASE_NAME.get());
      builder.appendHeading(INFO_LABEL_DBTEST_INDEX_STATUS.get());
      builder.appendHeading(INFO_LABEL_DBTEST_JE_RECORD_COUNT.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_RECORD_COUNT.get());
      builder.appendHeading(
          INFO_LABEL_DBTEST_INDEX_UNDEFINED_RECORD_COUNT.get());
      builder.appendHeading(LocalizableMessage.raw("95%"));
@@ -881,7 +882,7 @@
      EntryContainer ec = rc.getEntryContainer(base);
      if(ec == null)
      {
        printWrappedText(err, ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN.get(base, backend.getBackendID()));
        printWrappedText(err, ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN.get(base, backend.getBackendID()));
        return 1;
      }

@@ -1023,7 +1024,7 @@
    }
    catch(DirectoryException de)
    {
      printWrappedText(err, ERR_DBTEST_DECODE_BASE_DN.get(baseDN.getValue(), getExceptionMessage(de)));
      printWrappedText(err, ERR_BACKEND_DEBUG_DECODE_BASE_DN.get(baseDN.getValue(), getExceptionMessage(de)));
      return 1;
    }

@@ -1034,13 +1035,13 @@
      StringBuilder failureReason = new StringBuilder();
      if (! LockFileManager.acquireSharedLock(lockFile, failureReason))
      {
        printWrappedText(err, ERR_DBTEST_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        return 1;
      }
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_DBTEST_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), getExceptionMessage(e)));
      return 1;
    }

@@ -1061,7 +1062,7 @@
      EntryContainer ec = rc.getEntryContainer(base);
      if(ec == null)
      {
        printWrappedText(err, ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN.get(base, backend.getBackendID()));
        printWrappedText(err, ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN.get(base, backend.getBackendID()));
        return 1;
      }


 opendj-server-legacy/src/main/java/org/opends/server/backends/pdb/PDBStorage.java

@@ -697,7 +697,7 @@

  private Exchange getNewExchange(final TreeName treeName, final boolean create) throws PersistitException
  {
    return db.getExchange(volume, mangleTreeName(treeName), create);
    return db.getExchange(volume, treeName.toString(), create);
  }

  private StorageImpl newStorageImpl() {
@@ -894,23 +894,6 @@
    return new ImporterImpl();
  }

  private static String mangleTreeName(final TreeName treeName)
  {
    String name = treeName.toString();

    StringBuilder mangled = new StringBuilder(name.length());
    for (int idx = 0; idx < name.length(); idx++)
    {
      char ch = name.charAt(idx);
      if (ch == '=' || ch == ',')
      {
        ch = '_';
      }
      mangled.append(ch);
    }
    return mangled.toString();
  }

  @Override
  public void write(final WriteOperation operation) throws Exception
  {
@@ -1129,7 +1112,10 @@
      final Set<TreeName> results = new HashSet<>(treeNames.length);
      for (String treeName : treeNames)
      {
        results.add(TreeName.valueOf(treeName));
        if (!treeName.equals("_classIndex"))
        {
          results.add(TreeName.valueOf(treeName));
        }
      }
      return results;
    }

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

@@ -26,6 +26,7 @@
 */
package org.opends.server.backends.pluggable;

import org.forgerock.opendj.ldap.ByteString;
import org.opends.server.backends.pluggable.spi.ReadableTransaction;
import org.opends.server.backends.pluggable.spi.StorageRuntimeException;
import org.opends.server.backends.pluggable.spi.TreeName;
@@ -87,4 +88,23 @@
  {
    return name.compareTo(o.getName());
  }

  @Override
  public String keyToString(ByteString key)
  {
    return key.toString();
  }

  @Override
  public String valueToString(ByteString value)
  {
    return value.toString();
  }

  @Override
  public ByteString generateKey(String key)
  {
    return ByteString.valueOf(key.getBytes());
  }
}


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

@@ -188,6 +188,27 @@
        }
      }
    }

    @Override
    public String keyToString(ByteString key)
    {
      return indexer.keyToHumanReadableString(key);
    }

    @Override
    public ByteString generateKey(String key)
    {
      try
      {
        SortedSet<ByteString> keys = new TreeSet<>();
        indexer.createKeys(Schema.getDefaultSchema(), ByteString.valueOf(key.getBytes()), keys);
        return keys.first();
      }
      catch (DecodeException e)
      {
        return super.generateKey(key);
      }
    }
  }

  /** The key bytes used for the presence index as a {@link ByteString}. */

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

@@ -1006,8 +1006,7 @@
   *                                   that is not related to the server
   *                                   configuration.
   */
  private final RootContainer getReadOnlyRootContainer()
      throws ConfigException, InitializationException
  RootContainer getReadOnlyRootContainer() throws ConfigException, InitializationException
  {
    return newRootContainer(AccessMode.READ_ONLY);
  }

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

New file
@@ -0,0 +1,1455 @@
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at legal-notices/CDDLv1_0.txt.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Portions Copyright 2015 ForgeRock AS.
 */
package org.opends.server.backends.pluggable;

import static org.opends.messages.ToolMessages.*;
import static org.opends.server.util.StaticUtils.*;

import static com.forgerock.opendj.cli.ArgumentConstants.*;
import static com.forgerock.opendj.cli.Utils.*;

import java.io.OutputStream;
import java.io.PrintStream;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.opendj.config.SizeUnit;
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.util.Option;
import org.forgerock.util.Options;
import org.opends.server.admin.std.server.BackendCfg;
import org.opends.server.admin.std.server.PluggableBackendCfg;
import org.opends.server.api.Backend;
import org.opends.server.backends.pluggable.spi.Cursor;
import org.opends.server.backends.pluggable.spi.ReadOperation;
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;
import org.opends.server.extensions.ConfigFileHandler;
import org.opends.server.loggers.JDKLogging;
import org.opends.server.tools.BackendToolUtils;
import org.opends.server.types.DN;
import org.opends.server.types.DirectoryException;
import org.opends.server.types.InitializationException;
import org.opends.server.types.NullOutputStream;
import org.opends.server.util.BuildVersion;
import org.opends.server.util.StaticUtils;

import com.forgerock.opendj.cli.Argument;
import com.forgerock.opendj.cli.ArgumentException;
import com.forgerock.opendj.cli.BooleanArgument;
import com.forgerock.opendj.cli.CommonArguments;
import com.forgerock.opendj.cli.IntegerArgument;
import com.forgerock.opendj.cli.StringArgument;
import com.forgerock.opendj.cli.SubCommand;
import com.forgerock.opendj.cli.SubCommandArgumentParser;
import com.forgerock.opendj.cli.TableBuilder;
import com.forgerock.opendj.cli.TextTablePrinter;

/**
 * This program provides a utility that may be used to debug a Pluggable Backend.
 * This tool provides the ability to:
 * <ul>
 * <li>list root containers</li>
 * <li>list entry containers</li>
 * <li>list Trees in a Backend or Storage</li>
 * <li>gather information about Backend indexes</li>
 * <li>dump the contents of a Tree either at the Backend or the Storage layer.</li>
 * </ul>
 * This will be a process that is intended to run outside of Directory Server and not
 * internally within the server process (e.g., via the tasks interface); it still
 * requires configuration information and access to Directory Server instance data.
 */
public class BackendTool
{
  /**
   * Collects all necessary interaction interfaces with either a Backend using TreeNames
   * or a storage using Trees.
   */
  interface TreeKeyValue
  {
    /**
     * Returns a key given a string representation of it.
     *
     * @param data a string representation of the key.
     *             Prefixing with "0x" will interpret the rest of the string as an hex dump
     *             of the intended value.
     * @return a key given a string representation of it
     */
    ByteString getTreeKey(String data);

    /**
     * Returns a printable string for the given key.
     *
     * @param key a key from the Tree
     * @return a printable string for the given key
     */
    String keyDecoder(ByteString key);

    /**
     * Returns a printable string for the given value.
     *
     * @param value a value from the tree
     * @return a printable string for the given value
     */
    String valueDecoder(ByteString value);

    /**
     * Returns the TreeName for this storage Tree.
     *
     * @return the TreeName for this storage Tree
     */
    TreeName getTreeName();
  }

  /** Stays at the storage level when cursoring Trees. */
  static class StorageTreeKeyValue implements TreeKeyValue
  {
    private TreeName treeName;

    public StorageTreeKeyValue(TreeName treeName)
    {
      this.treeName = treeName;
    }

    @Override
    public TreeName getTreeName()
    {
      return treeName;
    }

    @Override
    public ByteString getTreeKey(String data)
    {
      return ByteString.valueOf(data);
    }

    @Override
    public String keyDecoder(ByteString key)
    {
      throw new UnsupportedOperationException(ERR_BACKEND_TOOL_DECODER_NOT_AVAILABLE.get().toString());
    }

    @Override
    public String valueDecoder(ByteString value)
    {
      throw new UnsupportedOperationException(ERR_BACKEND_TOOL_DECODER_NOT_AVAILABLE.get().toString());
    }
  }

  /** Delegate key semantics to the backend. */
  static class BackendTreeKeyValue implements TreeKeyValue
  {
    private TreeName name;
    private Tree tree;

    public BackendTreeKeyValue(Tree tree)
    {
      this.tree = tree;
      this.name = tree.getName();
    }

    @Override
    public ByteString getTreeKey(String data)
    {
      if (data.length() == 0)
      {
        return ByteString.empty();
      }
      return tree.generateKey(data);
    }

    @Override
    public String keyDecoder(ByteString key)
    {
      return tree.keyToString(key);
    }

    @Override
    public String valueDecoder(ByteString value)
    {
      return tree.valueToString(value);
    }

    @Override
    public TreeName getTreeName()
    {
      return name;
    }
  }

  /** Statistics collector. */
  class TreeStats
  {
    final long count;
    final long totalKeySize;
    final long totalDataSize;

    TreeStats(long count, long tks, long tds)
    {
      this.count = count;
      this.totalKeySize = tks;
      this.totalDataSize = tds;
    }
  }

  private static final Option<Boolean> DUMP_DECODE_VALUE = Option.withDefault(true);
  private static final Option<Boolean> DUMP_STATS_ONLY = Option.withDefault(false);
  private static final Option<Boolean> DUMP_SINGLE_LINE = Option.withDefault(false);
  private static final Option<Argument> DUMP_MIN_KEY_VALUE = Option.of(Argument.class, null);
  private static final Option<Argument> DUMP_MAX_KEY_VALUE = Option.of(Argument.class, null);
  private static final Option<Boolean> DUMP_MIN_KEY_VALUE_IS_HEX = Option.withDefault(false);
  private static final Option<Boolean> DUMP_MAX_KEY_VALUE_IS_HEX = Option.withDefault(false);
  private static final Option<Integer> DUMP_MIN_DATA_SIZE = Option.of(Integer.class, 0);
  private static final Option<Integer> DUMP_MAX_DATA_SIZE = Option.of(Integer.class, Integer.MAX_VALUE);
  private static final Option<Integer> DUMP_INDENT = Option.of(Integer.class, 4);

  private static final String LIST_STORAGE_TREES = "list-storage-trees";
  private static final String DUMP_STORAGE_TREE = "dump-storage-tree";
  private static final String LIST_BACKEND_TREES = "list-trees";
  private static final String DUMP_TREE = "dump-tree";
  private static final String LIST_ROOT_CONTAINERS = "list-root-containers";
  private static final String LIST_ENTRY_CONTAINERS = "list-entry-containers";
  private static final String LIST_INDEX_STATUS = "list-index-status";
  private static final String BACKENDID_NAME = "backendid";
  private static final String BACKENDID = "backendID";
  private static final String BASEDN_NAME = "basedn";
  private static final String BASEDN = "baseDN";
  private static final String USESIUNITS_NAME = "usesiunits";
  private static final String USESIUNITS = "useSIUnits";
  private static final String MAXDATASIZE_NAME = "maxdatasize";
  private static final String MAXDATASIZE = "maxDataSize";
  private static final String MAXKEYVALUE_NAME = "maxkeyvalue";
  private static final String MAXKEYVALUE = "maxKeyValue";
  private static final String MAXHEXKEYVALUE_NAME = "maxhexkeyvalue";
  private static final String MAXHEXKEYVALUE = "maxHexKeyValue";
  private static final String MINDATASIZE_NAME = "mindatasize";
  private static final String MINDATASIZE = "minDataSize";
  private static final String MINKEYVALUE_NAME = "minkeyvalue";
  private static final String MINKEYVALUE = "minKeyValue";
  private static final String MINHEXKEYVALUE_NAME = "minhexkeyvalue";
  private static final String MINHEXKEYVALUE = "minHexKeyValue";
  private static final String SKIPDECODE_NAME = "skipdecode";
  private static final String SKIPDECODE = "skipDecode";
  private static final String STATSONLY_NAME = "statsonly";
  private static final String STATSONLY = "statsOnly";
  private static final String TREENAME_NAME = "treename";
  private static final String TREENAME = "treeName";
  private static final String SINGLELINE_NAME = "singleline";
  private static final String SINGLELINE = "singleLine";

  private static final int INDENT = 4;
  private static final String HEXDUMP_LINE_FORMAT = "%s%s %s%n";

  /** The error stream which this application should use. */
  private final PrintStream err;
  /** The output stream which this application should use. */
  private final PrintStream out;

  /** The command-line argument parser. */
  private final SubCommandArgumentParser parser;
  /** The argument which should be used to request usage information. */
  private BooleanArgument showUsageArgument;
  /** The argument which should be used to specify the config class. */
  private StringArgument configClass;
  /** The argument which should be used to specify the config file. */
  private StringArgument configFile;

  /** Flag indicating whether or not the sub-commands have already been initialized. */
  private boolean subCommandsInitialized;
  /** 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.
   *
   * @param args The set of command-line arguments provided to this
   *             program.
   */
  public static void main(String[] args)
  {
    int exitCode = main(args, System.out, System.err);
    if (exitCode != 0)
    {
      System.exit(filterExitCode(exitCode));
    }
  }

  /**
   * Provides the command-line arguments to the main application for
   * processing and returns the exit code as an integer.
   *
   * @param args      The set of command-line arguments provided to this
   *                  program.
   * @param outStream The output stream for standard output.
   * @param errStream The output stream for standard error.
   * @return Zero to indicate that the program completed successfully,
   * or non-zero to indicate that an error occurred.
   */
  public static int main(String[] args, OutputStream outStream, OutputStream errStream)
  {
    BackendTool app = new BackendTool(outStream, errStream);
    return app.run(args);
  }

  /**
   * Creates a new dsconfig application instance.
   *
   * @param out The application output stream.
   * @param err The application error stream.
   */
  public BackendTool(OutputStream out, OutputStream err)
  {
    this.out = NullOutputStream.wrapOrNullStream(out);
    this.err = NullOutputStream.wrapOrNullStream(err);
    JDKLogging.disableLogging();

    LocalizableMessage toolDescription = INFO_DESCRIPTION_BACKEND_TOOL.get();
    this.parser = new SubCommandArgumentParser(getClass().getName(), toolDescription, false);
    this.parser.setShortToolDescription(REF_SHORT_DESC_BACKEND_TOOL.get());
    this.parser.setVersionHandler(new DirectoryServerVersionHandler());
  }

  /**
   * Registers the global arguments with the argument parser.
   *
   * @throws ArgumentException If a global argument could not be registered.
   */
  private void initializeGlobalArguments() throws ArgumentException
  {
    if (!globalArgumentsInitialized)
    {
      configClass =
          new StringArgument("configclass", OPTION_SHORT_CONFIG_CLASS, OPTION_LONG_CONFIG_CLASS, true, false, true,
              INFO_CONFIGCLASS_PLACEHOLDER.get(), ConfigFileHandler.class.getName(), null,
              INFO_DESCRIPTION_CONFIG_CLASS.get());
      configClass.setHidden(true);

      configFile =
          new StringArgument("configfile", 'f', "configFile", true, false, true, INFO_CONFIGFILE_PLACEHOLDER.get(),
              null, null, INFO_DESCRIPTION_CONFIG_FILE.get());
      configFile.setHidden(true);

      showUsageArgument = CommonArguments.getShowUsage();

      // Register the global arguments.
      parser.addGlobalArgument(showUsageArgument);
      parser.setUsageArgument(showUsageArgument, out);
      parser.addGlobalArgument(configClass);
      parser.addGlobalArgument(configFile);

      globalArgumentsInitialized = true;
    }
  }

  /**
   * Registers the sub-commands with the argument parser.
   *
   * @throws ArgumentException If a sub-command could not be created.
   */
  private void initializeSubCommands() throws ArgumentException
  {
    if (!subCommandsInitialized)
    {
      SubCommand sub;

      sub = new SubCommand(parser, LIST_ROOT_CONTAINERS,
          INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS.get());

      sub = new SubCommand(parser, LIST_ENTRY_CONTAINERS,
          INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS.get());
      addBackendArgument(sub);

      sub = new SubCommand(parser, LIST_STORAGE_TREES, INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_STORAGE_TREES.get());
      addBackendArgument(sub);
      BooleanArgument useSIUnits =
          new BooleanArgument(USESIUNITS_NAME, 'u', USESIUNITS, INFO_DESCRIPTION_BACKEND_TOOL_USE_SI_UNITS.get());
      sub.addArgument(useSIUnits);

      sub = new SubCommand(parser, LIST_BACKEND_TREES, INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_TREES.get());
      addBackendBaseDNArguments(sub, false, false, true);

      sub = new SubCommand(parser, DUMP_STORAGE_TREE, INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_DUMP_STORAGE_TREE.get());
      addBackendArgument(sub);
      addDumpSubCommandArguments(sub);
      BooleanArgument singleLine =
          new BooleanArgument(SINGLELINE_NAME, 'l', SINGLELINE, INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_SINGLE_LINE.get());
      sub.addArgument(singleLine);

      sub = new SubCommand(parser, DUMP_TREE, INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_DUMP_TREE.get());
      addBackendBaseDNArguments(sub, true, false, true);
      addDumpSubCommandArguments(sub);
      BooleanArgument skipDecode =
          new BooleanArgument(SKIPDECODE_NAME, 'p', SKIPDECODE, INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE.get());
      sub.addArgument(skipDecode);

      sub = new SubCommand(parser, LIST_INDEX_STATUS, INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS.get());
      sub.setDocDescriptionSupplement(SUPPLEMENT_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_INDEX_STATUS.get());
      addBackendBaseDNArguments(sub, true, true, true);

      subCommandsInitialized = true;
    }
  }

  private void addBackendArgument(SubCommand sub) throws ArgumentException
  {
    sub.addArgument(
        new StringArgument(BACKENDID_NAME, 'n', BACKENDID, true, false, true, INFO_BACKENDNAME_PLACEHOLDER.get(), null,
            null, INFO_DESCRIPTION_BACKEND_DEBUG_BACKEND_ID.get()));
  }

  private void addBackendBaseDNArguments(SubCommand sub, boolean isRequired, boolean isMultiValued, boolean needsValue)
      throws ArgumentException
  {
    addBackendArgument(sub);
    sub.addArgument(new StringArgument(BASEDN_NAME, 'b', BASEDN, isRequired, isMultiValued, needsValue,
        INFO_BASEDN_PLACEHOLDER.get(), null, null, INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN.get()));
  }

  private void addDumpSubCommandArguments(SubCommand sub) throws ArgumentException
  {
    sub.addArgument(
        new StringArgument(TREENAME_NAME, 't', TREENAME, true, false, true, INFO_DATABASE_NAME_PLACEHOLDER.get(), null,
            null, INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME.get()));
    sub.addArgument(new BooleanArgument(STATSONLY_NAME, 'q', STATSONLY,
        INFO_DESCRIPTION_BACKEND_DEBUG_STATS_ONLY.get()));
    sub.addArgument(newMaxKeyValueArg());
    sub.addArgument(newMinKeyValueArg());
    sub.addArgument(new StringArgument(MAXHEXKEYVALUE_NAME, 'X', MAXHEXKEYVALUE, false, false, true,
        INFO_MAX_KEY_VALUE_PLACEHOLDER.get(), null, null, INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE.get()));
    sub.addArgument(new StringArgument(MINHEXKEYVALUE_NAME, 'x', MINHEXKEYVALUE, false, false, true,
        INFO_MIN_KEY_VALUE_PLACEHOLDER.get(), null, null, INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE.get()));
    sub.addArgument(new IntegerArgument(MAXDATASIZE_NAME, 'S', MAXDATASIZE, false, false, true,
        INFO_MAX_DATA_SIZE_PLACEHOLDER.get(), -1, null, INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE.get()));
    sub.addArgument(new IntegerArgument(MINDATASIZE_NAME, 's', MINDATASIZE, false, false, true,
        INFO_MIN_DATA_SIZE_PLACEHOLDER.get(), -1, null, INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE.get()));
  }

  private StringArgument newMinKeyValueArg() throws ArgumentException
  {
    return new StringArgument(MINKEYVALUE_NAME, 'k', MINKEYVALUE, false, false, true,
        INFO_MIN_KEY_VALUE_PLACEHOLDER.get(), null, null, INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE.get());
  }

  private StringArgument newMaxKeyValueArg() throws ArgumentException
  {
    return new StringArgument(MAXKEYVALUE_NAME, 'K', MAXKEYVALUE, false, false, true,
        INFO_MAX_KEY_VALUE_PLACEHOLDER.get(), null, null, INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE.get());
  }

  /**
   * Parses the provided command-line arguments and makes the
   * appropriate changes to the Directory Server configuration.
   *
   * @param args The command-line arguments provided to this program.
   * @return The exit code from the configuration processing. A
   * nonzero value indicates that there was some kind of
   * problem during the configuration processing.
   */
  private int run(String[] args)
  {
    // Register global arguments and sub-commands.
    try
    {
      initializeGlobalArguments();
      initializeSubCommands();
    }
    catch (ArgumentException e)
    {
      printWrappedText(err, ERR_CANNOT_INITIALIZE_ARGS.get(e.getMessage()));
      return 1;
    }

    try
    {
      parser.parseArguments(args);
    }
    catch (ArgumentException ae)
    {
      parser.displayMessageAndUsageReference(err, ERR_ERROR_PARSING_ARGS.get(ae.getMessage()));
      return 1;
    }

    if (parser.usageOrVersionDisplayed())
    {
      return 0;
    }

    if (parser.getSubCommand() == null)
    {
      parser.displayMessageAndUsageReference(err, ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND.get());
      return 1;
    }

    try
    {
      BuildVersion.checkVersionMismatch();
    }
    catch (InitializationException e)
    {
      printWrappedText(err, e.getMessageObject());
      return 1;
    }

    // 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(configClass.getValue(), 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_ROOT_CONTAINERS.equals(subCommand.getName()))
    {
      return listRootContainers();
    }
    BackendImpl backend = getBackendById(subCommand.getArgument(BACKENDID_NAME));
    if (backend == null)
    {
      return 1;
    }
    RootContainer rootContainer = getAndLockRootContainer(backend);
    if (rootContainer == null)
    {
      return 1;
    }
    try
    {
      switch (subCommand.getName())
      {
      case LIST_ENTRY_CONTAINERS:
        return listEntryContainers(rootContainer);
      case LIST_STORAGE_TREES:
        return listStorageTrees(rootContainer, subCommand.getArgument(USESIUNITS_NAME));
      case LIST_BACKEND_TREES:
        return listBackendTrees(rootContainer, backend, subCommand.getArgument(BASEDN_NAME));
      case DUMP_STORAGE_TREE:
        return dumpTree(rootContainer, backend, subCommand, false);
      case DUMP_TREE:
        return dumpTree(rootContainer, backend, subCommand, true);
      case LIST_INDEX_STATUS:
        return listIndexStatus(rootContainer, backend, subCommand.getArgument(BASEDN_NAME));
      default:
        return 1;
      }
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_EXECUTING_COMMAND.get(subCommand.getName(),
          StaticUtils.stackTraceToString(e)));
      return 1;
    }
    finally
    {
      close(rootContainer);
      releaseExclusiveLock(backend);
    }
  }

  private String getStartUpExceptionMessage(Exception e)
  {
    if (e instanceof ConfigException || e instanceof InitializationException)
    {
      return e.getMessage();
    }
    return getExceptionMessage(e).toString();
  }

  private int dumpTree(RootContainer rc, BackendImpl backend, SubCommand subCommand, boolean isBackendTree)
      throws ArgumentException, DirectoryException
  {
    Options options = Options.defaultOptions();
    if (!setDumpTreeOptionArguments(subCommand, options))
    {
      return 1;
    }
    if (isBackendTree)
    {
      return dumpBackendTree(rc, backend, subCommand.getArgument(BASEDN_NAME), subCommand.getArgument(TREENAME_NAME),
          options);
    }
    return dumpStorageTree(rc, backend, subCommand.getArgument(TREENAME_NAME), options);
  }

  private boolean setDumpTreeOptionArguments(SubCommand subCommand, Options options) throws ArgumentException
  {
    try
    {
      Argument arg = subCommand.getArgument(SINGLELINE_NAME);
      if (arg != null && arg.isPresent())
      {
        options.set(DUMP_SINGLE_LINE, true);
      }
      if (subCommand.getArgument(STATSONLY_NAME).isPresent())
      {
        options.set(DUMP_STATS_ONLY, true);
      }
      arg = subCommand.getArgument(SKIPDECODE_NAME);
      if (arg == null || arg.isPresent())
      {
        options.set(DUMP_DECODE_VALUE, false);
      }
      if (subCommand.getArgument(MINDATASIZE_NAME).isPresent())
      {
        options.set(DUMP_MIN_DATA_SIZE, subCommand.getArgument(MINDATASIZE_NAME).getIntValue());
      }
      if (subCommand.getArgument(MAXDATASIZE_NAME).isPresent())
      {
        options.set(DUMP_MAX_DATA_SIZE, subCommand.getArgument(MAXDATASIZE_NAME).getIntValue());
      }

      options.set(DUMP_MIN_KEY_VALUE, subCommand.getArgument(MINKEYVALUE_NAME));
      if (subCommand.getArgument(MINHEXKEYVALUE_NAME).isPresent())
      {
        if (subCommand.getArgument(MINKEYVALUE_NAME).isPresent())
        {
          printWrappedText(err, ERR_BACKEND_TOOL_ONLY_ONE_MIN_KEY.get());
          return false;
        }
        options.set(DUMP_MIN_KEY_VALUE_IS_HEX, true);
        options.set(DUMP_MIN_KEY_VALUE, subCommand.getArgument(MINHEXKEYVALUE_NAME));
      }

      options.set(DUMP_MAX_KEY_VALUE, subCommand.getArgument(MAXKEYVALUE_NAME));
      if (subCommand.getArgument(MAXHEXKEYVALUE_NAME).isPresent())
      {
        if (subCommand.getArgument(MAXKEYVALUE_NAME).isPresent())
        {
          printWrappedText(err, ERR_BACKEND_TOOL_ONLY_ONE_MAX_KEY.get());
          return false;
        }
        options.set(DUMP_MAX_KEY_VALUE_IS_HEX, true);
        options.set(DUMP_MAX_KEY_VALUE, subCommand.getArgument(MAXHEXKEYVALUE_NAME));
      }
      return true;
    }
    catch (ArgumentException ae)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_PROCESSING_ARGUMENT.get(StaticUtils.stackTraceToString(ae)));
      throw ae;
    }
  }

  private int listRootContainers()
  {
    TableBuilder builder = new TableBuilder();

    builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_BACKEND_ID.get());
    builder.appendHeading(INFO_LABEL_BACKEND_TOOL_STORAGE.get());

    final Map<PluggableBackendCfg, BackendImpl> pluggableBackends = getPluggableBackends();
    for (Map.Entry<PluggableBackendCfg, BackendImpl> backend : pluggableBackends.entrySet())
    {
      builder.startRow();
      builder.appendCell(backend.getValue().getBackendID());
      builder.appendCell(backend.getKey().getJavaClass());
    }

    builder.print(new TextTablePrinter(out));
    out.format(INFO_LABEL_BACKEND_TOOL_TOTAL.get(pluggableBackends.size()).toString());

    return 0;
  }

  private int listEntryContainers(RootContainer rc)
  {
    try
    {
      TableBuilder builder = new TableBuilder();
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_BASE_DN.get());
      Collection<EntryContainer> entryContainers = rc.getEntryContainers();
      for (EntryContainer ec : entryContainers)
      {
        builder.startRow();
        builder.appendCell(ec.getBaseDN());
      }

      builder.print(new TextTablePrinter(out));
      out.format(INFO_LABEL_BACKEND_TOOL_TOTAL.get(entryContainers.size()).toString());

      return 0;
    }
    catch (StorageRuntimeException de)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_READING_ENTRY_CONTAINERS.get(stackTraceToSingleLineString(de)));
      return 1;
    }
  }

  private int listStorageTrees(RootContainer rc, Argument useSIUnits)
  {
    try
    {
      TableBuilder builder = new TableBuilder();

      builder.appendHeading(INFO_LABEL_BACKEND_TOOL_STORAGE_TREE_NAME.get());
      builder.appendHeading(INFO_LABEL_BACKEND_TOOL_TOTAL_KEYS.get());
      builder.appendHeading(INFO_LABEL_BACKEND_TOOL_KEYS_SIZE.get());
      builder.appendHeading(INFO_LABEL_BACKEND_TOOL_VALUES_SIZE.get());
      builder.appendHeading(INFO_LABEL_BACKEND_TOOL_TOTAL_SIZES.get());

      SortedSet<TreeName> treeNames = new TreeSet<>(rc.getStorage().listTrees());
      for (TreeName tree: treeNames)
      {
        builder.startRow();
        builder.appendCell(tree);
        appendStorageTreeStats(builder, rc, new StorageTreeKeyValue(tree), useSIUnits.isPresent());
      }

      builder.print(new TextTablePrinter(out));
      out.format(INFO_LABEL_BACKEND_TOOL_TOTAL.get(treeNames.size()).toString());

      return 0;
    }
    catch (StorageRuntimeException de)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_LISTING_TREES.get(stackTraceToSingleLineString(de)));
      return 1;
    }
  }

  private void appendStorageTreeStats(TableBuilder builder, RootContainer rc, TreeKeyValue targetTree,
      boolean useSIUnit)
  {
    Options options = Options.defaultOptions();
    options.set(DUMP_STATS_ONLY, true);
    try
    {
      options.set(DUMP_MIN_KEY_VALUE, newMinKeyValueArg());
      options.set(DUMP_MAX_KEY_VALUE, newMaxKeyValueArg());
      TreeStats treeStats = cursorTreeToDump(rc, targetTree, options);
      builder.appendCell(treeStats.count);
      builder.appendCell(appendKeyValueSize(treeStats.totalKeySize, useSIUnit));
      builder.appendCell(appendKeyValueSize(treeStats.totalDataSize, useSIUnit));
      builder.appendCell(appendKeyValueSize(treeStats.totalKeySize + treeStats.totalDataSize, useSIUnit));
    }
    catch (Exception e)
    {
      appendStatsNoData(builder, 3);
    }
  }

  private String appendKeyValueSize(long size, boolean useSIUnit)
  {
    if (useSIUnit && size > SizeUnit.KILO_BYTES.getSize())
    {
      NumberFormat format = NumberFormat.getNumberInstance();
      format.setMaximumFractionDigits(2);
      SizeUnit unit = SizeUnit.getBestFitUnit(size);
      return format.format(unit.fromBytes(size)) + " " + unit;
    }
    else
    {
      return String.valueOf(size);
    }
  }

  private int listBackendTrees(RootContainer rc, BackendImpl backend, Argument baseDNArg) throws DirectoryException
  {
    DN base = null;
    if (baseDNArg.isPresent())
    {
      base = getBaseDNFromArg(baseDNArg);
    }

    try
    {
      TableBuilder builder = new TableBuilder();
      int count = 0;

      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_INDEX_NAME.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_RECORD_COUNT.get());
      builder.appendHeading(INFO_LABEL_BACKEND_TOOL_BACKEND_TREE_NAME.get());

      if (base != null)
      {
        EntryContainer ec = rc.getEntryContainer(base);
        if (ec == null)
        {
          return printEntryContainerError(backend, base);
        }
        count = appendTreeRows(builder, ec);
      }
      else
      {
        for (EntryContainer ec : rc.getEntryContainers())
        {
          builder.startRow();
          builder.appendCell("Base DN: " + ec.getBaseDN());
          count += appendTreeRows(builder, ec);
        }
      }

      builder.print(new TextTablePrinter(out));
      out.format(INFO_LABEL_BACKEND_TOOL_TOTAL.get(count).toString());

      return 0;
    }
    catch (StorageRuntimeException de)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_LISTING_TREES.get(stackTraceToSingleLineString(de)));
      return 1;
    }
  }

  private int printEntryContainerError(BackendImpl backend, DN base)
  {
    printWrappedText(err, ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN.get(base, backend.getBackendID()));
    return 1;
  }

  private DN getBaseDNFromArg(Argument baseDNArg) throws DirectoryException
  {
    try
    {
      return DN.valueOf(baseDNArg.getValue());
    }
    catch (DirectoryException de)
    {
      printWrappedText(err, ERR_BACKEND_DEBUG_DECODE_BASE_DN.get(baseDNArg.getValue(), getExceptionMessage(de)));
      throw de;
    }
  }

  private RootContainer getAndLockRootContainer(BackendImpl backend)
  {
    try
    {
      String lockFile = LockFileManager.getBackendLockFileName(backend);
      StringBuilder failureReason = new StringBuilder();
      if (!LockFileManager.acquireExclusiveLock(lockFile, failureReason))
      {
        printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), failureReason));
        return null;
      }
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), StaticUtils
          .getExceptionMessage(e)));
      return null;
    }

    try
    {
      return backend.getReadOnlyRootContainer();
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND.get(backend.getBackendID(),
          stackTraceToSingleLineString(e)));
      return null;
    }
  }

  private int appendTreeRows(TableBuilder builder, EntryContainer ec)
  {
    int count = 0;
    for (final Tree tree : ec.listTrees())
    {
      builder.startRow();
      builder.appendCell(tree.getName().getIndexId());
      builder.appendCell(tree.getClass().getSimpleName());
      builder.appendCell(getTreeRecordCount(ec, tree));
      builder.appendCell(tree.getName());
      count++;
    }
    return count;
  }

  private long getTreeRecordCount(EntryContainer ec, final Tree tree)
  {
    try
    {
      return ec.getRootContainer().getStorage().read(new ReadOperation<Long>()
      {
        @Override
        public Long run(ReadableTransaction txn) throws Exception
        {
          return tree.getRecordCount(txn);
        }
      });
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_READING_TREE.get(stackTraceToSingleLineString(e)));
      return -1;
    }
  }

  private void close(RootContainer rc)
  {
    try
    {
      rc.close();
    }
    catch (StorageRuntimeException ignored)
    {
      // Ignore.
    }
  }

  private void releaseExclusiveLock(BackendImpl backend)
  {
    try
    {
      String lockFile = LockFileManager.getBackendLockFileName(backend);
      StringBuilder failureReason = new StringBuilder();
      if (!LockFileManager.releaseLock(lockFile, failureReason))
      {
        printWrappedText(err, WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), failureReason));
      }
    }
    catch (Exception e)
    {
      printWrappedText(err, WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(),
          StaticUtils.getExceptionMessage(e)));
    }
  }

  private BackendImpl getBackendById(Argument backendIdArg)
  {
    final String backendID = backendIdArg.getValue();
    final Map<PluggableBackendCfg, BackendImpl> pluggableBackends = getPluggableBackends();

    for (Map.Entry<PluggableBackendCfg, BackendImpl> backend : pluggableBackends.entrySet())
    {
      final BackendImpl b = backend.getValue();
      if (b.getBackendID().equalsIgnoreCase(backendID))
      {
        try
        {
          b.configureBackend(backend.getKey(), directoryServer.getServerContext());
          return b;
        }
        catch (ConfigException ce)
        {
          printWrappedText(err, ERR_BACKEND_TOOL_CANNOT_CONFIGURE_BACKEND.get(backendID, ce));
          return null;
        }
      }
    }

    printWrappedText(err, ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID.get(backendID));
    return null;
  }

  private int listIndexStatus(RootContainer rc, BackendImpl backend, Argument baseDNArg) throws DirectoryException
  {
    DN base = getBaseDNFromArg(baseDNArg);

    try
    {
      // Create a table of their properties.
      TableBuilder builder = new TableBuilder();
      int count = 0;

      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_INDEX_NAME.get());
      builder.appendHeading(INFO_LABEL_BACKEND_TOOL_BACKEND_TREE_NAME.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS.get());
      builder.appendHeading(INFO_LABEL_BACKEND_DEBUG_RECORD_COUNT.get());
      builder.appendHeading(INFO_LABEL_BACKEND_TOOL_INDEX_UNDEFINED_RECORD_COUNT.get());
      builder.appendHeading(LocalizableMessage.raw("95%"));
      builder.appendHeading(LocalizableMessage.raw("90%"));
      builder.appendHeading(LocalizableMessage.raw("85%"));

      EntryContainer ec = rc.getEntryContainer(base);
      if (ec == null)
      {
        return printEntryContainerError(backend, base);
      }

      Map<Index, StringBuilder> undefinedKeys = new HashMap<>();
      for (AttributeIndex attrIndex : ec.getAttributeIndexes())
      {
        for (AttributeIndex.MatchingRuleIndex index : attrIndex.getNameToIndexes().values())
        {
          builder.startRow();
          builder.appendCell(index.getName().getIndexId());
          builder.appendCell(index.getName());
          builder.appendCell(index.isTrusted());
          if (index.isTrusted())
          {
            appendIndexStats(builder, ec, index, undefinedKeys);
          }
          else
          {
            appendStatsNoData(builder, 5);
          }
          count++;
        }
      }

      for (VLVIndex vlvIndex : ec.getVLVIndexes())
      {
        builder.startRow();
        builder.appendCell(vlvIndex.getName().getIndexId());
        builder.appendCell(vlvIndex.getName());
        builder.appendCell(vlvIndex.isTrusted());
        builder.appendCell(getTreeRecordCount(ec, vlvIndex));
        appendStatsNoData(builder, 4);
        count++;
      }

      builder.print(new TextTablePrinter(out));
      out.format(INFO_LABEL_BACKEND_TOOL_TOTAL.get(count).toString());
      for (Map.Entry<Index, StringBuilder> e : undefinedKeys.entrySet())
      {
        out.format(INFO_LABEL_BACKEND_TOOL_INDEX.get(e.getKey().getName()).toString());
        out.format(INFO_LABEL_BACKEND_TOOL_OVER_INDEX_LIMIT_KEYS.get(e.getValue()).toString());
      }
      return 0;
    }
    catch (StorageRuntimeException de)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_READING_TREE.get(stackTraceToSingleLineString(de)));
      return 1;
    }
  }

  private void appendStatsNoData(TableBuilder builder, int columns)
  {
    while (columns > 0)
    {
      builder.appendCell("-");
      columns--;
    }
  }

  private void appendIndexStats(final TableBuilder builder, EntryContainer ec, final Index index,
      final Map<Index, StringBuilder> undefinedKeys)
  {
    final long entryLimit = index.getIndexEntryLimit();

    try
    {
      ec.getRootContainer().getStorage().read(new ReadOperation<Void>()
      {
        @Override
        public Void run(ReadableTransaction txn) throws Exception
        {
          long eighty = 0;
          long ninety = 0;
          long ninetyFive = 0;
          long invalidIDSet = 0;
          long undefined = 0;
          long count = 0;
          BackendTreeKeyValue keyDecoder = new BackendTreeKeyValue(index);
          try (Cursor<ByteString, EntryIDSet> cursor = index.openCursor(txn))
          {
            while (cursor.next())
            {
              count++;
              EntryIDSet entryIDSet = null;
              try
              {
                entryIDSet = cursor.getValue();
              }
              catch (Exception e)
              {
                invalidIDSet++;
                continue;
              }

              if (entryIDSet.isDefined())
              {
                if (entryIDSet.size() >= entryLimit * 0.8)
                {
                  if (entryIDSet.size() >= entryLimit * 0.95)
                  {
                    ninetyFive++;
                  }
                  else if (entryIDSet.size() >= entryLimit * 0.9)
                  {
                    ninety++;
                  }
                  else
                  {
                    eighty++;
                  }
                }
              }
              else
              {
                undefined++;
                StringBuilder keyList = undefinedKeys.get(index);
                if (keyList == null)
                {
                  keyList = new StringBuilder();
                  undefinedKeys.put(index, keyList);
                }
                else
                {
                  keyList.append(" ");
                }
                keyList.append("[").append(keyDecoder.keyDecoder(cursor.getKey())).append("]");
              }
            }
          }
          builder.appendCell(count);
          builder.appendCell(undefined);
          builder.appendCell(ninetyFive);
          builder.appendCell(ninety);
          builder.appendCell(eighty);
          return null;
        }
      });
    }
    catch (Exception e)
    {
      appendStatsNoData(builder, 5);
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_READING_TREE.get(index.getName()));
    }
  }

  private int dumpStorageTree(RootContainer rc, BackendImpl backend, Argument treeNameArg, Options options)
  {
    TreeName targetTree = getStorageTreeName(treeNameArg, rc);
    if (targetTree == null)
    {
      printWrappedText(err,
          ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_IN_STORAGE.get(treeNameArg.getValue(), backend.getBackendID()));
      return 1;
    }

    try
    {
      dumpActualTree(rc, new StorageTreeKeyValue(targetTree), options);
      return 0;
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_READING_TREE.get(stackTraceToSingleLineString(e)));
      return 1;
    }
  }

  private TreeName getStorageTreeName(Argument treeNameArg, RootContainer rc)
  {
    for (TreeName tree : rc.getStorage().listTrees())
    {
      if (treeNameArg.getValue().equals(tree.toString()))
      {
        return tree;
      }
    }
    return null;
  }

  private int dumpBackendTree(RootContainer rc, BackendImpl backend, Argument baseDNArg, Argument treeNameArg,
      Options options) throws DirectoryException
  {
    DN base = getBaseDNFromArg(baseDNArg);

    EntryContainer ec = rc.getEntryContainer(base);
    if (ec == null)
    {
      return printEntryContainerError(backend, base);
    }

    Tree targetTree = getBackendTree(treeNameArg, ec);
    if (targetTree == null)
    {
      printWrappedText(err,
          ERR_BACKEND_TOOL_NO_TREE_FOR_NAME.get(treeNameArg.getValue(), base, backend.getBackendID()));
      return 1;
    }

    try
    {
      dumpActualTree(rc, new BackendTreeKeyValue(targetTree), options);
      return 0;
    }
    catch (Exception e)
    {
      printWrappedText(err, ERR_BACKEND_TOOL_ERROR_READING_TREE.get(stackTraceToSingleLineString(e)));
      return 1;
    }
  }

  private Tree getBackendTree(Argument treeNameArg, EntryContainer ec)
  {
    for (Tree tree : ec.listTrees())
    {
      if (treeNameArg.getValue().contains(tree.getName().getIndexId())
          || treeNameArg.getValue().equals(tree.getName().toString()))
      {
        return tree;
      }
    }
    return null;
  }

  private void dumpActualTree(RootContainer rc, final TreeKeyValue target, final Options options) throws Exception
  {
    TreeStats treeStats =  cursorTreeToDump(rc, target, options);
    out.format(INFO_LABEL_BACKEND_TOOL_TOTAL_RECORDS.get(treeStats.count).toString());
    if (treeStats.count > 0)
    {
      out.format(INFO_LABEL_BACKEND_TOOL_TOTAL_KEY_SIZE_AND_AVG.get(
          treeStats.totalKeySize, treeStats.totalKeySize / treeStats.count).toString());
      out.format(INFO_LABEL_BACKEND_TOOL_TOTAL_DATA_SIZE_AND_AVG.get(
          treeStats.totalDataSize, treeStats.totalDataSize / treeStats.count).toString());
    }
  }

  private TreeStats cursorTreeToDump(RootContainer rc, final TreeKeyValue target, final Options options)
      throws Exception
  {
    return rc.getStorage().read(new ReadOperation<TreeStats>()
      {
        @Override
        public TreeStats run(ReadableTransaction txn) throws Exception
        {
          long count = 0;
          long totalKeySize = 0;
          long totalDataSize = 0;
          try (final Cursor<ByteString, ByteString> cursor = txn.openCursor(target.getTreeName()))
          {
            ByteString key;
            ByteString maxKey = null;
            ByteString value;
            boolean maxKeyReached = false;

            if (options.get(DUMP_MIN_KEY_VALUE).isPresent())
            {
              key = getMinOrMaxKey(options, DUMP_MIN_KEY_VALUE, DUMP_MIN_KEY_VALUE_IS_HEX);
              if (!cursor.positionToKeyOrNext(key))
              {
                return new TreeStats(0, 0, 0);
              }
            }
            else
            {
              if (!cursor.next())
              {
                return new TreeStats(0, 0, 0);
              }
            }

            if (options.get(DUMP_MAX_KEY_VALUE).isPresent())
            {
              maxKey = getMinOrMaxKey(options, DUMP_MAX_KEY_VALUE, DUMP_MAX_KEY_VALUE_IS_HEX);
            }

            do
            {
              key = cursor.getKey();
              maxKeyReached = key.equals(maxKey);
              value = cursor.getValue();
              long valueLen = value.length();
              if (options.get(DUMP_MIN_DATA_SIZE) <= valueLen && valueLen <= options.get(DUMP_MAX_DATA_SIZE))
              {
                count++;
                int keyLen = key.length();
                totalKeySize += keyLen;
                totalDataSize += valueLen;
                if (!options.get(DUMP_STATS_ONLY))
                {
                  if (options.get(DUMP_DECODE_VALUE))
                  {
                    String k = target.keyDecoder(key);
                    String v = target.valueDecoder(value);
                    out.format(INFO_LABEL_BACKEND_TOOL_KEY_FORMAT.get(keyLen) + " %s%n"
                        + INFO_LABEL_BACKEND_TOOL_VALUE_FORMAT.get(valueLen) + " %s%n", k, v);
                  }
                  else
                  {
                    hexDumpRecord(key, value, out, options);
                  }
                }
              }
            }
            while (cursor.next() && !maxKeyReached);
          }
          catch (Exception e)
          {
            out.format(ERR_BACKEND_TOOL_CURSOR_AT_KEY_NUMBER.get(count, e.getCause()).toString());
            e.printStackTrace(out);
            out.format("%n");
            throw e;
          }
          return new TreeStats(count, totalKeySize, totalDataSize);
        }

      private ByteString getMinOrMaxKey(Options options, Option<Argument> keyOpt, Option<Boolean> isHexKey)
      {
        ByteString key;
        if (options.get(isHexKey))
        {
          key = ByteString.valueOfHex(options.get(keyOpt).getValue());
        }
        else
        {
          key = target.getTreeKey(options.get(keyOpt).getValue());
        }
        return key;
      }
    });
  }

  final void hexDumpRecord(ByteString key, ByteString value, PrintStream out, Options options)
  {
    if (options.get(DUMP_SINGLE_LINE))
    {
      out.format(INFO_LABEL_BACKEND_TOOL_KEY_FORMAT.get(key.length()) + " ");
      toHexDumpSingleLine(out, key);
      out.format(INFO_LABEL_BACKEND_TOOL_VALUE_FORMAT.get(value.length()) + " ");
      toHexDumpSingleLine(out, value);
    }
    else
    {
      out.format(INFO_LABEL_BACKEND_TOOL_KEY_FORMAT.get(key.length()) + "%n");
      toHexDumpWithAsciiCompact(key, options.get(DUMP_INDENT), out);
      out.format(INFO_LABEL_BACKEND_TOOL_VALUE_FORMAT.get(value.length()) + "%n");
      toHexDumpWithAsciiCompact(value, options.get(DUMP_INDENT), out);
    }
  }

  final void toHexDumpSingleLine(PrintStream out, ByteString data)
  {
    for (int i = 0; i < data.length(); i++)
    {
      out.format("%s", StaticUtils.byteToHex(data.byteAt(i)));
    }
    out.format("%n");
  }

  final void toHexDumpWithAsciiCompact(ByteString data, int indent, PrintStream out)
  {
    StringBuilder hexDump = new StringBuilder();
    StringBuilder indentBuilder = new StringBuilder();
    StringBuilder asciiDump = new StringBuilder();
    for (int i = 0; i < indent; i++)
    {
      indentBuilder.append(' ');
    }
    int pos = 0;
    while (pos < data.length())
    {
      byte val = data.byteAt(pos);
      hexDump.append(StaticUtils.byteToHex(val));
      hexDump.append(' ');
      asciiDump.append(val >= ' ' ? (char)val : ".");
      pos++;
      if (pos % 16 == 0)
      {
        out.format(HEXDUMP_LINE_FORMAT, indentBuilder.toString(), hexDump.toString(), asciiDump.toString());
        hexDump.setLength(0);
        asciiDump.setLength(0);
      }
    }
    while (pos % 16 != 0)
    {
      hexDump.append("   ");
      pos++;
    }
    out.format(HEXDUMP_LINE_FORMAT, indentBuilder.toString(), hexDump.toString(), asciiDump.toString());
  }

  private static Map<PluggableBackendCfg, BackendImpl> getPluggableBackends()
  {
    ArrayList<Backend> backendList = new ArrayList<>();
    ArrayList<BackendCfg> entryList = new ArrayList<>();
    ArrayList<List<DN>> dnList = new ArrayList<>();
    BackendToolUtils.getBackends(backendList, entryList, dnList);

    final Map<PluggableBackendCfg, BackendImpl> pluggableBackends = new LinkedHashMap<>();
    for (int i = 0; i < backendList.size(); i++)
    {
      Backend<?> backend = backendList.get(i);
      if (backend instanceof BackendImpl)
      {
        pluggableBackends.put((PluggableBackendCfg) entryList.get(i), (BackendImpl) backend);
      }
    }
    return pluggableBackends;
  }
}

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

@@ -209,6 +209,31 @@
    return nbSeparator == 1;
  }

  @Override
  public String keyToString(ByteString key)
  {
    return key.length() > 0 ? keyToDNString(key) : baseDN.toString();
  }

  @Override
  public String valueToString(ByteString value)
  {
    return new EntryID(value).toString();
  }

  @Override
  public ByteString generateKey(String key)
  {
    try
    {
      return toKey(DN.valueOf(key));
    }
    catch (Exception e)
    {
      return ByteString.valueOf(key.getBytes());
    }
  }

  /**
   * Decorator overriding the next() behavior to iterate through children of the entry pointed by the given cursor at
   * creation.

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

@@ -419,6 +419,31 @@
    }
  }

  @Override
  public String keyToString(ByteString key)
  {
    return key.toString();
  }

  @Override public String valueToString(ByteString value)
  {
    final Map.Entry<DN, List<String>> dnAndUris = decode(value);
    return dnAndUris.getValue().toString();
  }

  @Override
  public ByteString generateKey(String key)
  {
    try
    {
      return toKey(DN.valueOf(key));
    }
    catch (DirectoryException e)
    {
      return ByteString.empty();
    }
  }

  /**
   * Checks whether the target of an operation is a referral entry and throws
   * a Directory referral exception if it is.

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

@@ -109,6 +109,23 @@
  }

  @Override
  public String valueToString(ByteString value)
  {
    StringBuilder sb = new StringBuilder();
    final EntryIDSet eIDSet = decodeValue(ByteString.empty(), value);
    eIDSet.toString(sb);
    if (eIDSet.isDefined())
    {
      for(EntryID entryID : eIDSet)
      {
        sb.append(" ");
        sb.append(entryID);
      }
    }
    return sb.toString();
  }

  @Override
  public final Cursor<ByteString, EntryIDSet> openCursor(ReadableTransaction txn)
  {
    checkNotNull(txn, "txn must not be null");

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

@@ -26,6 +26,8 @@
 */
package org.opends.server.backends.pluggable;

import static org.forgerock.opendj.ldap.DN.normalizedToASCII;

import org.forgerock.opendj.ldap.ByteSequence;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.ByteStringBuilder;
@@ -58,7 +60,7 @@
    // and find the first unescaped NORMALIZED_RDN_SEPARATOR
    for (int i = dnKey.length() - 1; i >= 0; i--)
    {
      if (dnKey.byteAt(i) == DN.NORMALIZED_RDN_SEPARATOR && i - 1 >= 0 && dnKey.byteAt(i - 1) != DN.NORMALIZED_ESC_BYTE)
      if (positionIsRDNSeparator(dnKey, i))
      {
        return i;
      }
@@ -86,6 +88,22 @@
    return builder.toByteString();
  }

  /**
   * Returns a best effort conversion from key to a human readable DN.
   * @param key the index key
   * @return a best effort conversion from key to a human readable DN.
   */
  static String keyToDNString(ByteString key)
  {
    return normalizedToASCII(key);
  }

  private static boolean positionIsRDNSeparator(ByteSequence key, int index)
  {
    return index > 0
        && key.byteAt(index) == DN.NORMALIZED_RDN_SEPARATOR && key.byteAt(index - 1) != DN.NORMALIZED_ESC_BYTE;
  }

  static ByteStringBuilder beforeKey(final ByteSequence key)
  {
    final ByteStringBuilder beforeKey = new ByteStringBuilder(key.length() + 1);

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

@@ -25,10 +25,11 @@
package org.opends.server.backends.pluggable;

import org.forgerock.opendj.ldap.ByteSequence;
import org.forgerock.opendj.ldap.ByteSequenceReader;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.ByteStringBuilder;
import org.forgerock.util.Function;
import org.forgerock.util.Reject;
import org.forgerock.util.Function;
import org.forgerock.util.promise.NeverThrowsException;
import org.opends.server.backends.pluggable.spi.Cursor;
import org.opends.server.backends.pluggable.spi.Importer;
@@ -145,6 +146,28 @@
    return value.toLong();
  }

  @Override
  public String keyToString(ByteString key)
  {
    ByteSequenceReader keyReader = key.asReader();
    long keyID = keyReader.getCompactUnsigned();
    long shardBucket = keyReader.getCompactUnsigned();
    return (keyID == TOTAL_COUNT_ENTRY_ID.longValue() ? "Total Children Count" : keyID) + "#" + shardBucket;
  }

  @Override
  public String valueToString(ByteString value)
  {
    return String.valueOf(fromValue(value));
  }

  @Override
  public ByteString generateKey(String data)
  {
    EntryID entryID = new EntryID(Long.parseLong(data));
    return entryID.toByteString();
  }

  /**
   * Get the counter value for the specified key
   * @param txn The transaction

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

@@ -376,13 +376,13 @@
   * @throws StorageRuntimeException If an error occurs in the storage.
   */
  public boolean containsEntryID(ReadableTransaction txn, EntryID entryID)
 {
  {
    checkNotNull(txn, "txn must not be null");
    checkNotNull(entryID, "entryID must not be null");
    try(final Cursor<ByteString, ByteString> cursor = txn.openCursor(getName())) {
      return cursor.positionToKey(entryID.toByteString());
    }
 }
  }

  private Entry get0(EntryID entryID, ByteString value) throws DirectoryException
  {
@@ -414,4 +414,30 @@
  {
    this.dataConfig = dataConfig;
  }

  @Override
  public String keyToString(ByteString key)
  {
    return new EntryID(key).toString();
  }

  @Override
  public String valueToString(ByteString value)
  {
    try
    {
      return "\n" + get0(new EntryID(-1), value).toString();
    }
    catch (Exception e)
    {
      return e.getMessage();
    }
  }

  @Override
  public ByteString generateKey(String data)
  {
    EntryID entryID = new EntryID(Long.parseLong(data));
    return entryID.toByteString();
  }
}

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

@@ -27,6 +27,7 @@
package org.opends.server.backends.pluggable;

import static org.forgerock.util.Reject.*;
import static org.forgerock.util.Utils.joinAsString;

import java.util.Arrays;
import java.util.Collection;
@@ -50,7 +51,7 @@
{
  /**
   * Use COMPACTED serialization for new indexes.
   * @see {@link EntryIDSet.EntryIDSetCompactCodec}
   * @see {@link EntryIDSet.EntryIDSetCodecV2}
   */
  private static final Collection<IndexFlag> DEFAULT_FLAGS = Collections.unmodifiableCollection(Arrays
      .asList(IndexFlag.COMPACTED));
@@ -182,6 +183,12 @@
    });
  }

  @Override
  public String valueToString(ByteString value)
  {
    return joinAsString(" ", decodeFlagsOrGetDefault(value));
  }

  /**
   * Remove a record from the entry tree.
   *

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

@@ -26,6 +26,7 @@
 */
package org.opends.server.backends.pluggable;

import org.forgerock.opendj.ldap.ByteString;
import org.opends.server.backends.pluggable.spi.ReadableTransaction;
import org.opends.server.backends.pluggable.spi.StorageRuntimeException;
import org.opends.server.backends.pluggable.spi.TreeName;
@@ -76,4 +77,30 @@
   * @return name for this tree.
   */
  TreeName getName();

  /**
   * Returns a printable, semantically meaningful if possible, representation of a Tree key.
   *
   * @param key a key as used by the Tree
   * @return a printable, semantically meaningful if possible, representation of a Tree key.
   */
  String keyToString(ByteString key);

  /**
   * Returns a printable, semantically meaningful if possible, representation of a Tree key.
   *
   * @param value a key as used by the Tree
   * @return a printable, semantically meaningful if possible, representation of a Tree key.
   */
  String valueToString(ByteString value);

  /**
   * Returns a key given a string representation of a value.
   * Since the key is typically used for cursoring, out of many possible keys only one is needed,
   * potentially the lowest key.
   *
   * @param key the specified key as a string
   * @return a key given a string representation of a value
   */
  ByteString generateKey(String key);
}

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

@@ -848,6 +848,18 @@
    builder.append(separator);
  }

  @Override
  public String keyToString(ByteString key)
  {
    return String.valueOf(decodeEntryIDFromVLVKey(key));
  }

  @Override
  public String valueToString(ByteString value)
  {
    return "N/A";
  }

  void closeAndDelete(WriteableTransaction txn)
  {
    close();

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

@@ -25,6 +25,8 @@
 */
package org.opends.server.backends.pluggable.spi;

import org.forgerock.util.Reject;

/**
 * Represents the name of a tree (key-value store) in a database.
 * A tree name is made of the baseDN it is part of, and the identifier of the index it represents.
@@ -60,8 +62,11 @@
   */
  public static TreeName valueOf(String treeName)
  {
    final String[] split = treeName.split("/");
    return new TreeName(split[0], split[1]);
    int lastSlash = treeName.lastIndexOf('/');
    Reject.ifTrue(lastSlash < 2 || treeName.charAt(0) != '/', "TreeName is not of the form /<name>/<name>");
    String baseDN = treeName.substring(1, lastSlash);
    String indexId = treeName.substring(lastSlash + 1);
    return new TreeName(baseDN, indexId);
  }

  /**
@@ -123,4 +128,4 @@
  {
    return s.compareTo(o.s);
  }
}
}

 opendj-server-legacy/src/main/java/org/opends/server/replication/plugin/HistoricalCsnOrderingMatchingRuleImpl.java

@@ -41,6 +41,7 @@
import org.forgerock.opendj.ldap.spi.IndexQueryFactory;
import org.forgerock.opendj.ldap.spi.Indexer;
import org.forgerock.opendj.ldap.spi.IndexingOptions;
import org.opends.server.replication.common.CSN;

import static org.forgerock.opendj.ldap.Assertion.*;
import static org.opends.messages.ReplicationMessages.*;
@@ -73,7 +74,12 @@
    @Override
    public String keyToHumanReadableString(ByteSequence key)
    {
      return key.toString();
      ByteStringBuilder bsb = new ByteStringBuilder();
      bsb.append(key.subSequence(2, 10));
      bsb.append(key.subSequence(0, 2));
      bsb.append(key.subSequence(10, 14));
      CSN csn = CSN.valueOf(bsb.toByteString());
      return csn.toStringUI();
    }
  }


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

@@ -1844,47 +1844,43 @@
 generate the RC script:  %s
ERR_DSCFG_ERROR_QUIET_AND_INTERACTIVE_INCOMPATIBLE_1326=If you specify \
 the {%s} argument you must also specify {%s}
INFO_DESCRIPTION_DBTEST_TOOL_1327=This utility can be used to debug the JE \
  database
INFO_DESCRIPTION_DBTEST_TOOL_1327=This utility can be used to debug the JE database
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=List the root \
  containers used by all JE backends
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=List the entry \
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=List the entry \
  containers for a root container
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=Dump records from \
  a database container. Depending on database size, \
  this subcommand can generate lots of output
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=The backend ID of the JE backend to \
  debug
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=The base DN of the entry container to debug
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=The name of the database container \
  to debug
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=Do not try to decode the JE data to \
INFO_DESCRIPTION_BACKEND_DEBUG_BACKEND_ID_1331=The backend ID of the backend to debug
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=The base DN of the entry container to debug
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=The name of the index to debug
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=Do not try to decode backend data to \
  their appropriate types
ERR_DBTEST_DECODE_FAIL_1335=An error occurred while decoding data: %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=List the status of \
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=List the status of \
  indexes in an entry container. \
  This subcommand can take a long time to complete, \
  as it reads all indexes for all backends
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=Only show records with keys that \
  This subcommand can take a long time to complete, as it reads all indexes for all backends
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=Only show records with keys that \
  should be ordered before the provided value using the comparator for the \
  database container
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=Only show records with keys that \
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=Only show records with keys that \
  should be ordered after the provided value using the comparator for the \
  database container
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=Only show records whose data is no \
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=Only show records whose data is no \
  larger than the provided value
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=Only show records whose data is no \
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=Only show records whose data is no \
  smaller than the provided value
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=List the database \
  containers for an entry container
INFO_LABEL_DBTEST_BACKEND_ID_1342=Backend ID
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=Backend ID
INFO_LABEL_DBTEST_DB_DIRECTORY_1343=Database Directory
INFO_LABEL_DBTEST_BASE_DN_1344=Base DN
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=Base DN
INFO_LABEL_DBTEST_JE_DATABASE_PREFIX_1345=JE Database Prefix
INFO_LABEL_DBTEST_ENTRY_COUNT_1346=Entry Count
ERR_DBTEST_NO_BACKENDS_FOR_ID_1347=None of the Directory Server \
INFO_LABEL_BACKEND_DEBUG_ENTRY_COUNT_1346=Entry Count
ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID_1347=None of the Directory Server \
  backends are configured with the requested backend ID %s
ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=None of the entry \
ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=None of the entry \
  containers are configured with the requested base DN %s in backend %s
ERR_DBTEST_NO_DATABASE_CONTAINERS_FOR_NAME_1349=No database container \
  exists with the requested name %s in entry container %s and backend %s
@@ -1892,22 +1888,22 @@
  while attempting to initialize the JE backend %s: %s
ERR_DBTEST_ERROR_READING_DATABASE_1351=An unexpected error occurred \
  while attempting to read and/or decode records from the database: %s
ERR_DBTEST_DECODE_BASE_DN_1352=Unable to decode base DN string "%s" as \
ERR_BACKEND_DEBUG_DECODE_BASE_DN_1352=Unable to decode base DN string "%s" as \
  a valid distinguished name:  %s
INFO_LABEL_DBTEST_DATABASE_NAME_1353=Database Name
INFO_LABEL_DBTEST_DATABASE_TYPE_1354=Database Type
INFO_LABEL_DBTEST_JE_DATABASE_NAME_1355=JE Database Name
INFO_LABEL_DBTEST_JE_RECORD_COUNT_1356=Record Count
INFO_LABEL_DBTEST_INDEX_NAME_1357=Index Name
INFO_LABEL_DBTEST_INDEX_TYPE_1358=Index Type
INFO_LABEL_DBTEST_INDEX_STATUS_1359=Index Valid
INFO_LABEL_BACKEND_DEBUG_RECORD_COUNT_1356=Record Count
INFO_LABEL_BACKEND_DEBUG_INDEX_NAME_1357=Index Name
INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE_1358=Index Type
INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS_1359=Index Valid
INFO_LABEL_DBTEST_KEY_1360=Key
INFO_LABEL_DBTEST_DATA_1361=Data
WARN_DBTEST_CANNOT_UNLOCK_BACKEND_1362=An error occurred while \
WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND_1362=An error occurred while \
 attempting to release the shared lock for backend %s:  %s.  This lock should \
 automatically be cleared when the process exits, so no further action \
 should be required
ERR_DBTEST_CANNOT_LOCK_BACKEND_1363=An error occurred while \
ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND_1363=An error occurred while \
 attempting to acquire a shared lock for backend %s:  %s.  This generally \
 means that some other process has exclusive access to this backend (e.g., a \
 restore or an LDIF import)
@@ -1926,7 +1922,7 @@
INFO_LABEL_DBTEST_VLV_INDEX_LAST_SORT_KEYS_1371=Last Sort Keys
ERR_DBTEST_CANNOT_DECODE_SIZE_1372=An error occurred while parsing the \
  min/max data size %s as a integer: %s
ERR_DBTEST_MISSING_SUBCOMMAND_1374=A sub-command must be specified
ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND_1374=A sub-command must be specified
INFO_CREATERC_USER_DESCRIPTION_1375=The name of the user account under which \
 the server should run
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=The path to the Java installation \
@@ -2430,7 +2426,7 @@
ERR_WINDOWS_SERVICE_ENABLING_ERROR_STARTING_SERVER_1709=The Windows \
 Service was successfully configured but there was an error starting it.  \
 Error code starting Windows Service: %d
INFO_DESCRIPTION_DBTEST_STATS_ONLY_1710=Do not display the JE data, \
INFO_DESCRIPTION_BACKEND_DEBUG_STATS_ONLY_1710=Do not display backend data, \
just statistics
INFO_TIMEOUT_PLACEHOLDER_1711={timeout}
INFO_DESCRIPTION_CONNECTION_TIMEOUT_1712=Maximum length of time (in \
@@ -2570,6 +2566,49 @@
'%s' to avoid compatibility issues
ERR_UPGRADE_DSJAVAPROPERTIES_FAILED_1853=The dsjavaproperties tool failed to run. \
Please rerun dsjavaproperties manually
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=List the root containers used by all backends
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_STORAGE_TREES_1855=List indexes for a root container storage. \
  Depending on index size, this subcommand can generate lots of output
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_TREES_1866=List indexes for an entry container \
  This subcommand may take a long time to complete, as it reads all data for all indexes
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_DUMP_TREE_1857=Dump records from an index decoding keys and values. \
  Depending on index size, this subcommand can generate lots of output
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_DUMP_STORAGE_TREE_1858=Dump records in hexadecimal format from an index using \
  the storage engine. Depending on index size, this subcommand can generate lots of output
INFO_LABEL_BACKEND_TOOL_STORAGE_TREE_NAME_1861=Index Storage Name
ERR_BACKEND_TOOL_ERROR_READING_ENTRY_CONTAINERS_1863=An error occurred while gathering entry containers: %s
ERR_BACKEND_TOOL_ERROR_LISTING_TREES_1864=An error occurred while listing indexes: %s
ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND_1865=An unexpected error occurred \
  while attempting to initialize the backend %s: %s
ERR_BACKEND_TOOL_ERROR_READING_TREE_1866=An unexpected error occurred \
  while attempting to read and/or decode records from an index: %s
INFO_LABEL_BACKEND_TOOL_INDEX_UNDEFINED_RECORD_COUNT_1867=Over Entry Limit
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_1868=No index exists with the requested name %s in entry container %s and backend %s
ERR_BACKEND_TOOL_ONLY_ONE_MIN_KEY_1869=Cannot specify a minimum key both as a string and as an hexadecimal string
ERR_BACKEND_TOOL_ONLY_ONE_MAX_KEY_1870=Cannot specify a maximum key both as a string and as an hexadecimal string
ERR_BACKEND_TOOL_PROCESSING_ARGUMENT_1871=An error occurred while processing arguments: %s
ERR_BACKEND_TOOL_EXECUTING_COMMAND_1872=An error occurred while trying to execute %s: %s
INFO_LABEL_BACKEND_TOOL_TOTAL_KEYS_1873=Total Keys
INFO_LABEL_BACKEND_TOOL_KEYS_SIZE_1874=Keys Size
INFO_LABEL_BACKEND_TOOL_VALUES_SIZE_1875=Values Size
INFO_LABEL_BACKEND_TOOL_TOTAL_SIZES_1876=Total Size
INFO_DESCRIPTION_BACKEND_TOOL_USE_SI_UNITS_1877=Uses SI Units for printing sizes
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_SINGLE_LINE_1878=Write hexadecimal data on a single line instead of pretty format
INFO_LABEL_BACKEND_TOOL_STORAGE_1879=Storage
INFO_LABEL_BACKEND_TOOL_TOTAL_1880=%nTotal: %d%n
ERR_BACKEND_TOOL_CANNOT_CONFIGURE_BACKEND_1881=Cannot configure backend %s: %s
INFO_LABEL_BACKEND_TOOL_INDEX_1882=%nIndex: %s%n
INFO_LABEL_BACKEND_TOOL_OVER_INDEX_LIMIT_KEYS_1883=Over index-entry-limit keys: %s%n
INFO_LABEL_BACKEND_TOOL_TOTAL_RECORDS_1884=%nTotal Records: %d%n
INFO_LABEL_BACKEND_TOOL_TOTAL_KEY_SIZE_AND_AVG_1885=Total / Average Key Size: %d bytes / %d bytes%n
INFO_LABEL_BACKEND_TOOL_TOTAL_DATA_SIZE_AND_AVG_1886=Total / Average Data Size: %d bytes / %d bytes%n
ERR_BACKEND_TOOL_CURSOR_AT_KEY_NUMBER_1887=At key number %d, %s:
INFO_LABEL_BACKEND_TOOL_KEY_FORMAT_1888=Key (len %d):
INFO_LABEL_BACKEND_TOOL_VALUE_FORMAT_1889=Value (len %d):
ERR_BACKEND_TOOL_DECODER_NOT_AVAILABLE_1890=Data decoder for printing is not available, should use hex dump
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_IN_STORAGE_1891=No storage index exists with the requested name %s in backend %s
INFO_LABEL_BACKEND_TOOL_BACKEND_TREE_NAME_1892=Index Backend Name
INFO_DESCRIPTION_BACKEND_TOOL_1893=This utility can be used to debug a backend

# Upgrade tasks
INFO_UPGRADE_TASK_6869_SUMMARY_10000=Fixing de-DE collation matching rule OID
@@ -2625,7 +2664,7 @@
REF_SHORT_DESC_BASE64_15001=encode and decode base64 strings
REF_SHORT_DESC_CONTROL_PANEL_15002=start the OpenDJ graphical admin interface
REF_SHORT_DESC_CREATE_RC_SCRIPT_15003=script to manage OpenDJ as a service on UNIX
REF_SHORT_DESC_DBTEST_15004=gather OpenDJ backend database debugging information
REF_SHORT_DESC_DBTEST_15004=gather OpenDJ backend JE database debugging information
REF_SHORT_DESC_DSJAVAPROPERTIES_15005=apply OpenDJ Java home and JVM settings
REF_SHORT_DESC_DSREPLICATION_15006=manage OpenDJ directory data replication
REF_SHORT_DESC_ENCODE_PASSWORD_15007=encode a password with an OpenDJ storage scheme
@@ -2653,6 +2692,7 @@
REF_SHORT_DESC_VERIFY_INDEX_15029=check index for consistency or errors
REF_SHORT_DESC_WINDOWS_SERVICE_15030=register OpenDJ as a Windows Service
UPGRADE_TASK_DELETE_FILE_10035=Removing file '%s'
REF_SHORT_DESC_BACKEND_TOOL_15031=gather OpenDJ backend debugging information

# Supplements to descriptions for generated reference documentation.
SUPPLEMENT_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_20001=\
@@ -2677,3 +2717,5 @@
 have permissions to access it.
ERR_SEARCH_INVALID_DEREFERENCE_POLICY_20014=Invalid deref alias specified: %s
ERR_FILE_NOT_FULLY_READABLE_20015=Could not completely read file '%s'
SUPPLEMENT_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_INDEX_STATUS_20016=\
  <xinclude:include href="variablelist-backendtool-index-status.xml" />

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

@@ -311,17 +311,17 @@
INFO_CREATERC_OUTFILE_DESCRIPTION_1323=La ruta al fitxer de sortida a crear
INFO_DESCRIPTION_DBTEST_TOOL_1327=Aquesta utilitat pot utilitzar-se per a depurar la base de dades JE
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=Llistar els contenidors arrel utilitzats per totes les infraestructures de fons (Backends) JE
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=Llistar els contenidors d'entrades per a un contenidor arrel
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=Llistar els contenidors d'entrades per a un contenidor arrel
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=Bolcar registres des del contenidor de la base de dades
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=ID Backend per a la infraestructura de fons (Backend) JE a depurar
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=El DN base del contenidor d'entrada a depurar
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=El nom del contenidor de la base de dades a depurar
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=No intentar descodificar les dades JE i els seus tipus apropiats
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=Llistar l'estat dels \u00edndexs en un contenidor d'entrades
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=Mostrar \u00fanicament els registres amb claus que han de ser ordenades abans que el valor proporcionat mitjan\u00e7ant el comparador pel contenidor de la base de dades
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=Mostrar \u00fanicament els registres amb claus que han de ser ordenades despr\u00e9s que el valor proporcionat mitjan\u00e7ant el comparador pel contenidor de la base de dades
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=Mostrar \u00fanicament els registres les dades dels quals no s\u00f3n m\u00e9s grans que el valor proporcionat
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=Mostrar \u00fanicament els registres les dades dels quals no s\u00f3n m\u00e9s petits que el valor proporcionat
INFO_BACKEND_DEBUG_BACKEND_ID_1331=ID Backend per a la infraestructura de fons (Backend) JE a depurar
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=El DN base del contenidor d'entrada a depurar
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=El nom del contenidor de la base de dades a depurar
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=No intentar descodificar les dades JE i els seus tipus apropiats
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=Llistar l'estat dels \u00edndexs en un contenidor d'entrades
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=Mostrar \u00fanicament els registres amb claus que han de ser ordenades abans que el valor proporcionat mitjan\u00e7ant el comparador pel contenidor de la base de dades
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=Mostrar \u00fanicament els registres amb claus que han de ser ordenades despr\u00e9s que el valor proporcionat mitjan\u00e7ant el comparador pel contenidor de la base de dades
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=Mostrar \u00fanicament els registres les dades dels quals no s\u00f3n m\u00e9s grans que el valor proporcionat
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=Mostrar \u00fanicament els registres les dades dels quals no s\u00f3n m\u00e9s petits que el valor proporcionat
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=Llistar els contenidors de base de dades per a un contenidors d'entrades
INFO_CREATERC_USER_DESCRIPTION_1375=el nom del compte d'usuari sota el qual els servidor s'ha d'executar
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=La ruta a la instal3laci\u00f3 Java que ha d'utilitzar-se per executar el servidor
@@ -490,3 +490,5 @@
INFO_LDIFDIFF_DESCRIPTION_CHECK_SCHEMA_1674=T\u00e9 en compte la sintaxis dels atributs de com estan definits en l'esquema per fer la comparaci\u00f3 de valor.  Els fitxers LDIF proporcionats ha de ser conformes a l'esquema del servidor
INFO_INSTALLDS_PROVIDE_BASE_DN_PROMPT_1700=Voleu  crear DNs base al servidor?
ERR_INSTALLDS_NO_BASE_DN_AND_CONFLICTING_ARG_1701=Heu especificat no crear un DN base.  Si no es crea cap DN base no es pot especificar l'argument '%s'
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=Llistar els contenidors arrel utilitzats per totes les infraestructures de fons (Backends) Pluggable
INFO_DESCRIPTION_BACKEND_TOOL_1893=Aquesta utilitat pot utilitzar-se per a depurar una infraestructura de fons

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

@@ -895,41 +895,41 @@
ERR_DSCFG_ERROR_QUIET_AND_INTERACTIVE_INCOMPATIBLE_1326=Wenn Sie das Argument {%s} angeben, m\u00fcssen Sie auch {%s} angeben
INFO_DESCRIPTION_DBTEST_TOOL_1327=Dieses Dienstprogramm dient zur Fehlerbehebung f\u00fcr die JE-Datenbank
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=Root-Container auflisten, die von allen JE-Backends verwendet werden
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=Alle Eintragscontainer f\u00fcr einen Root-Container auflisten
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=Alle Eintragscontainer f\u00fcr einen Root-Container auflisten
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=Datensatzabbild von einem Datenbankcontainer erstellen
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=Backend-ID des JE-Backends, f\u00fcr das eine Fehlerbehebung ausgef\u00fchrt werden soll
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=Basis-DN des Eintragcontainers, f\u00fcr den eine Fehlerbehebung ausgef\u00fchrt werden soll
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=Name des Datenbankcontainers, f\u00fcr den eine Fehlerbehebung ausgef\u00fchrt werden soll
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=Nicht versuchen, die JE-Daten nach deren dazugeh\u00f6rigen Typen zu dekodieren
INFO_BACKEND_DEBUG_BACKEND_ID_1331=Backend-ID des JE-Backends, f\u00fcr das eine Fehlerbehebung ausgef\u00fchrt werden soll
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=Basis-DN des Eintragcontainers, f\u00fcr den eine Fehlerbehebung ausgef\u00fchrt werden soll
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=Name des Datenbankcontainers, f\u00fcr den eine Fehlerbehebung ausgef\u00fchrt werden soll
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=Nicht versuchen, die JE-Daten nach deren dazugeh\u00f6rigen Typen zu dekodieren
ERR_DBTEST_DECODE_FAIL_1335=Fehler bei der Datenentschl\u00fcsselung: %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=Status der Indizes in einem Eintragscontainer auflisten
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=Nur Datens\u00e4tze mit Schl\u00fcsseln anzeigen, die mit dem Vergleichsoperator f\u00fcr den Datenbankcontainer vor dem angegebenen Wert angeordnet werden sollen
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=Nur Datens\u00e4tze mit Schl\u00fcsseln anzeigen, die mit dem Vergleichsoperator f\u00fcr den Datenbankcontainer hinter dem angegebenen Wert angeordnet werden sollen
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=Nur Datens\u00e4tze anzeigen, deren Daten nicht gr\u00f6\u00dfer als der angegebene Wert sind
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=Nur Datens\u00e4tze anzeigen, deren Daten nicht kleiner als der angegebene Wert sind
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=Status der Indizes in einem Eintragscontainer auflisten
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=Nur Datens\u00e4tze mit Schl\u00fcsseln anzeigen, die mit dem Vergleichsoperator f\u00fcr den Datenbankcontainer vor dem angegebenen Wert angeordnet werden sollen
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=Nur Datens\u00e4tze mit Schl\u00fcsseln anzeigen, die mit dem Vergleichsoperator f\u00fcr den Datenbankcontainer hinter dem angegebenen Wert angeordnet werden sollen
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=Nur Datens\u00e4tze anzeigen, deren Daten nicht gr\u00f6\u00dfer als der angegebene Wert sind
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=Nur Datens\u00e4tze anzeigen, deren Daten nicht kleiner als der angegebene Wert sind
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=Datenbankcontainer f\u00fcr einen Eintragscontainer auflisten
INFO_LABEL_DBTEST_BACKEND_ID_1342=Backend-ID
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=Backend-ID
INFO_LABEL_DBTEST_DB_DIRECTORY_1343=Datenbankverzeichnis
INFO_LABEL_DBTEST_BASE_DN_1344=Basis-DN
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=Basis-DN
INFO_LABEL_DBTEST_JE_DATABASE_PREFIX_1345=JE-Datenbank-Pr\u00e4fix
INFO_LABEL_DBTEST_ENTRY_COUNT_1346=Anzahl der Eintr\u00e4ge
ERR_DBTEST_NO_BACKENDS_FOR_ID_1347=Keines der Directory-Server-Backends ist mit der angeforderten Backend-ID %s konfiguriert
ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=Keiner der Eintragscontainer ist mit dem angeforderten Basis-DN %s in Backend %s konfiguriert
ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID_1347=Keines der Directory-Server-Backends ist mit der angeforderten Backend-ID %s konfiguriert
ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=Keiner der Eintragscontainer ist mit dem angeforderten Basis-DN %s in Backend %s konfiguriert
ERR_DBTEST_NO_DATABASE_CONTAINERS_FOR_NAME_1349=Kein Datenbankcontainer ist mit dem angeforderten Namen %s in Eintragscontainer %s und Backend %s vorhanden
ERR_DBTEST_ERROR_INITIALIZING_BACKEND_1350=Unerwarteter Fehler beim Versuch, das JE-Backend %s zu initialisieren: %s
ERR_DBTEST_ERROR_READING_DATABASE_1351=Unerwarteter Fehler beim Versuch, Datens\u00e4tze aus der Datenbank zu lesen und/oder zu entschl\u00fcsseln: %s
ERR_DBTEST_DECODE_BASE_DN_1352=Die Basis-DN-Zeichenfolge "%s" kann nicht als g\u00fcltiger Distinguished Name entschl\u00fcsselt werden:  %s
ERR_BACKEND_DEBUG_DECODE_BASE_DN_1352=Die Basis-DN-Zeichenfolge "%s" kann nicht als g\u00fcltiger Distinguished Name entschl\u00fcsselt werden:  %s
INFO_LABEL_DBTEST_DATABASE_NAME_1353=Datenbankname
INFO_LABEL_DBTEST_DATABASE_TYPE_1354=Datenbanktyp
INFO_LABEL_DBTEST_JE_DATABASE_NAME_1355=JE-Datenbankname
INFO_LABEL_DBTEST_JE_RECORD_COUNT_1356=Anzahl der Datens\u00e4tze
INFO_LABEL_DBTEST_INDEX_NAME_1357=Indexname
INFO_LABEL_DBTEST_INDEX_TYPE_1358=Indextyp
INFO_LABEL_DBTEST_INDEX_STATUS_1359=Indexstatus
INFO_LABEL_DBTEST_RECORD_COUNT_1356=Anzahl der Datens\u00e4tze
INFO_LABEL_BACKEND_DEBUG_INDEX_NAME_1357=Indexname
INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE_1358=Indextyp
INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS_1359=Indexstatus
INFO_LABEL_DBTEST_KEY_1360=Schl\u00fcssel
INFO_LABEL_DBTEST_DATA_1361=Daten
WARN_DBTEST_CANNOT_UNLOCK_BACKEND_1362=Fehler beim Versuch, die gemeinsame Sperre f\u00fcr Backend %s freizugeben:  %s.  Diese Sperre sollte automatisch aufgehoben werden, wenn der Prozess vorhanden ist, sodass keine weitere Aktion erforderlich ist
ERR_DBTEST_CANNOT_LOCK_BACKEND_1363=Fehler beim Versuch, eine gemeinsame Sperre f\u00fcr Backend %s abzurufen:  %s.  Dies bedeutet in der Regel, dass ein anderer Prozess \u00fcber einen exklusiven Zugriff auf dieses Backend verf\u00fcgt (z. B. eine Wiederherstellung oder ein LDIF-Import)
WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND_1362=Fehler beim Versuch, die gemeinsame Sperre f\u00fcr Backend %s freizugeben:  %s.  Diese Sperre sollte automatisch aufgehoben werden, wenn der Prozess vorhanden ist, sodass keine weitere Aktion erforderlich ist
ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND_1363=Fehler beim Versuch, eine gemeinsame Sperre f\u00fcr Backend %s abzurufen:  %s.  Dies bedeutet in der Regel, dass ein anderer Prozess \u00fcber einen exklusiven Zugriff auf dieses Backend verf\u00fcgt (z. B. eine Wiederherstellung oder ein LDIF-Import)
ERR_DBTEST_CANNOT_DECODE_KEY_1364=Fehler beim Entschl\u00fcsseln des min./max. Schl\u00fcsselwertes %s: %s. Werte mit dem Pr\u00e4fix "0x" werden als Rohbytes in hex. entschl\u00fcsselt. Bei der Erstellung eines Speicherauszugs der DN2ID-Datenbank muss der Wert ein g\u00fcltiger Distinguished Name sein. Bei der Erstellung eines Speicherauszugs der D2Entry-Datenbank wird der Wert als Eintrags-ID entschl\u00fcsselt. Bei der Erstellung eines Speicherauszugs aller anderen Datenbanken wird der Wert als eine Zeichenkette entschl\u00fcsselt
INFO_LABEL_DBTEST_ENTRY_1365=Eintrag
INFO_LABEL_DBTEST_ENTRY_ID_1366=Eintrags-ID
@@ -939,7 +939,7 @@
INFO_LABEL_DBTEST_INDEX_ENTRY_ID_LIST_1370=Eintrags-ID-Liste
INFO_LABEL_DBTEST_VLV_INDEX_LAST_SORT_KEYS_1371=Letzte Sortierschl\u00fcssel
ERR_DBTEST_CANNOT_DECODE_SIZE_1372=Fehler beim Analysieren der min./max. Datengr\u00f6\u00dfe %s als eine Ganzzahl: %s
ERR_DBTEST_MISSING_SUBCOMMAND_1374=Es muss ein Unterbefehl angegeben werden
ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND_1374=Es muss ein Unterbefehl angegeben werden
INFO_CREATERC_USER_DESCRIPTION_1375=Name des Benutzerkontos, unter dem der Server ausgef\u00fchrt werden soll
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=Pfad zur Java-Installation, die zum Ausf\u00fchren des Servers verwendet werden soll
INFO_CREATERC_JAVA_ARGS_DESCRIPTION_1377=Reihe von Argumenten, die an die JVM beim Ausf\u00fchren des Servers geleitet werden sollen
@@ -1271,10 +1271,15 @@
INFO_DESCRIPTION_REFRESH_PERIOD_1706=Wenn dieses Argument angegeben ist, zeigt der Statusbefehl seinen Inhalt regelm\u00e4\u00dfig an.  Wird verwendet, um den Zeitraum (in Sekunden) zwischen zwei Statusanzeigen anzugeben
INFO_INSTALLDS_PRINT_EQUIVALENT_COMMAND_LINE_1708=Drucken der \u00e4quivalenten nicht interaktiven Befehlszeile
ERR_WINDOWS_SERVICE_ENABLING_ERROR_STARTING_SERVER_1709=Der Windows-Dienst wurde erfolgreich konfiguriert, aber beim Starten des Dienstes ist ein Fehler aufgetreten.  Fehlercode beim Starten des Windows-Dienstes: %d
INFO_DESCRIPTION_DBTEST_STATS_ONLY_1710=JE-Daten nicht anzeigen, nur Statistiken
INFO_DESCRIPTION_BACKEND_DEBUG_STATS_ONLY_1710=JE-Daten nicht anzeigen, nur Statistiken
INFO_TIMEOUT_PLACEHOLDER_1711={Zeit\u00fcberschreitung}
INFO_DESCRIPTION_CONNECTION_TIMEOUT_1712=Maximale Dauer (in Millisekunden), die die Verbindungsherstellung in Anspruch nehmen kann
ERR_MAKELDIF_CANNOT_WRITE_ENTRY_WITHOUT_DN_1713=Ein Fehler ist beim Versuch, den Eintrag in LDIF zu schreiben, aufgetreten:  Der DN konnte nicht f\u00fcr den Eintrag berechnet werden (kein Wert wurde f\u00fcr RDN-Attribut %s gefunden)
ERR_CLIENT_SIDE_TIMEOUT_1714=Ein Laufzeitfehler auf Client-Seite ist aufgetreten.%nZus\u00e4tzliche Informationen:  %s
INFO_LABEL_DBTEST_INDEX_UNDEFINED_RECORD_COUNT_1715=Nicht definiert
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=Root-Container auflisten, die von allen Backends verwendet werde
ERR_BACKEND_TOOL_ERROR_READING_TREE_1866=Unerwarteter Fehler beim Versuch, Datens\u00e4tze aus der index zu lesen und/oder zu entschl\u00fcsseln: %s
ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND_1865=Unerwarteter Fehler beim Versuch, das Backend %s zu initialisieren: %s
INFO_DESCRIPTION_BACKEND_TOOL_1893=Dieses Dienstprogramm dient zur Fehlerbehebung f\u00fcr eine Backend
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_1868=Kein index ist mit dem angeforderten Namen %s in Eintragscontainer %s und Backend %s vorhanden


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

@@ -895,41 +895,41 @@
ERR_DSCFG_ERROR_QUIET_AND_INTERACTIVE_INCOMPATIBLE_1326=Si se especifica el argumento {%s}, tambi\u00e9n debe especificarse {%s}
INFO_DESCRIPTION_DBTEST_TOOL_1327=Esta utilidad se puede utilizar para depurar la base de datos JE
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=Muestra los contenedores ra\u00edz utilizados por todos los servidores de fondo JE
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=Muestra los contenedores de entrada de un contenedor ra\u00edz
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=Muestra los contenedores de entrada de un contenedor ra\u00edz
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=Volcar registros desde un contenedor de base de datos
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=El Id. de servidor de fondo del servidor de fondo JE que depurar
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=El ND de base del contenedor de entradas que depurar
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=El nombre del contenedor de base de datos que depurar
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=No intentar descodificar los datos de JE seg\u00fan los tipos adecuados
INFO_BACKEND_DEBUG_BACKEND_ID_1331=El Id. de servidor de fondo del servidor de fondo JE que depurar
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=El ND de base del contenedor de entradas que depurar
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=El nombre del contenedor de base de datos que depurar
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=No intentar descodificar los datos de JE seg\u00fan los tipos adecuados
ERR_DBTEST_DECODE_FAIL_1335=Se ha producido un error al descodificar datos:  %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=Muestra el estado de \u00edndices en un contenedor de entradas
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=Mostrar s\u00f3lo los registros con claves que se deben ordenar antes del valor especificado mediante el comparador del contenedor de base de datos
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=Mostrar s\u00f3lo los registros con claves que se deben ordenar despu\u00e9s del valor especificado mediante el comparador del contenedor de base de datos
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=Mostrar s\u00f3lo los registros cuyos datos no sean mayores que el valor especificado
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=Mostrar s\u00f3lo los registros cuyos datos no sean menores que el valor especificado
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=Muestra el estado de \u00edndices en un contenedor de entradas
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=Mostrar s\u00f3lo los registros con claves que se deben ordenar antes del valor especificado mediante el comparador del contenedor de base de datos
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=Mostrar s\u00f3lo los registros con claves que se deben ordenar despu\u00e9s del valor especificado mediante el comparador del contenedor de base de datos
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=Mostrar s\u00f3lo los registros cuyos datos no sean mayores que el valor especificado
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=Mostrar s\u00f3lo los registros cuyos datos no sean menores que el valor especificado
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=Muestra los contenedores de base de datos para un contenedor de entradas
INFO_LABEL_DBTEST_BACKEND_ID_1342=Id. de servidor de fondo
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=Id. de servidor de fondo
INFO_LABEL_DBTEST_DB_DIRECTORY_1343=Directorio de base de datos
INFO_LABEL_DBTEST_BASE_DN_1344=ND base
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=ND base
INFO_LABEL_DBTEST_JE_DATABASE_PREFIX_1345=Prefijo de base de datos JE
INFO_LABEL_DBTEST_ENTRY_COUNT_1346=Recuento de entradas
ERR_DBTEST_NO_BACKENDS_FOR_ID_1347=Ning\u00fan backend del Servidor de directorios est\u00e1 configurado con el Id. de backend solicitado %s
ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=Ninguno de los contenedores de entradas est\u00e1 configurado con el ND de base solicitado %s en el backend %s
ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID_1347=Ning\u00fan backend del Servidor de directorios est\u00e1 configurado con el Id. de backend solicitado %s
ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=Ninguno de los contenedores de entradas est\u00e1 configurado con el ND de base solicitado %s en el backend %s
ERR_DBTEST_NO_DATABASE_CONTAINERS_FOR_NAME_1349=No existe ning\u00fan contenedor de base de datos con el nombre solicitado %s ni en el contenedor de entradas %s ni en el backend %s
ERR_DBTEST_ERROR_INITIALIZING_BACKEND_1350=Se ha producido un error inesperado al tratar de inicializar el backend de JE %s: %s
ERR_DBTEST_ERROR_READING_DATABASE_1351=Se ha producido un error al tratar de leer y/o descodificar registros de la base de datos: %s
ERR_DBTEST_DECODE_BASE_DN_1352=No se puede descodificar la cadena de ND de base "%s" como un nombre distinguido v\u00e1lido:  %s
ERR_BACKEND_DEBUG_DECODE_BASE_DN_1352=No se puede descodificar la cadena de ND de base "%s" como un nombre distinguido v\u00e1lido:  %s
INFO_LABEL_DBTEST_DATABASE_NAME_1353=Nombre de base de datos
INFO_LABEL_DBTEST_DATABASE_TYPE_1354=Tipo de base de datos
INFO_LABEL_DBTEST_JE_DATABASE_NAME_1355=Nombre de base de datos JE
INFO_LABEL_DBTEST_JE_RECORD_COUNT_1356=Recuento de registros
INFO_LABEL_DBTEST_INDEX_NAME_1357=Nombre de \u00edndice
INFO_LABEL_DBTEST_INDEX_TYPE_1358=Tipo de \u00edndice
INFO_LABEL_DBTEST_INDEX_STATUS_1359=Estado de \u00edndice
INFO_LABEL_DBTEST_RECORD_COUNT_1356=Recuento de registros
INFO_LABEL_BACKEND_DEBUG_INDEX_NAME_1357=Nombre de \u00edndice
INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE_1358=Tipo de \u00edndice
INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS_1359=Estado de \u00edndice
INFO_LABEL_DBTEST_KEY_1360=Clave
INFO_LABEL_DBTEST_DATA_1361=Datos
WARN_DBTEST_CANNOT_UNLOCK_BACKEND_1362=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, por lo que no deber\u00eda requerirse la realizaci\u00f3n de ninguna operaci\u00f3n adicional
ERR_DBTEST_CANNOT_LOCK_BACKEND_1363=Se ha producido un error al tratar de adquirir un bloqueo compartido para el backend %s: %s. Generalmente, esto significa que otro proceso tiene acceso exclusivo a este backend (p. ej., una restauraci\u00f3n o una importaci\u00f3n de LDIF)
WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND_1362=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, por lo que no deber\u00eda requerirse la realizaci\u00f3n de ninguna operaci\u00f3n adicional
ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND_1363=Se ha producido un error al tratar de adquirir un bloqueo compartido para el backend %s: %s. Generalmente, esto significa que otro proceso tiene acceso exclusivo a este backend (p. ej., una restauraci\u00f3n o una importaci\u00f3n de LDIF)
ERR_DBTEST_CANNOT_DECODE_KEY_1364=Se ha producido un error al descodificar el valor de clave m\u00edn./m\u00e1x. %s: %s. Los valores prefijados con "Ox" se descodificar\u00e1n como bytes no procesados en hexadecimal. Al volcar la base de datos DN2ID, el valor debe ser un nombre distinguido v\u00e1lido. Al volcar la base de datos ID2Entry, el valor se descodificar\u00e1 como un Id. de entrada. Al volcar las bases de datos restantes, el valor se descodificar\u00e1 como una cadena
INFO_LABEL_DBTEST_ENTRY_1365=Entrada
INFO_LABEL_DBTEST_ENTRY_ID_1366=Id. de entrada
@@ -939,7 +939,7 @@
INFO_LABEL_DBTEST_INDEX_ENTRY_ID_LIST_1370=Lista de Id. de entrada
INFO_LABEL_DBTEST_VLV_INDEX_LAST_SORT_KEYS_1371=\u00daltimas claves de ordenaci\u00f3n
ERR_DBTEST_CANNOT_DECODE_SIZE_1372=Se ha producido un error al analizar el tama\u00f1o de datos m\u00edn./m\u00e1x. %s como un n\u00famero entero: %s
ERR_DBTEST_MISSING_SUBCOMMAND_1374=Debe especificar un subcomando
ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND_1374=Debe especificar un subcomando
INFO_CREATERC_USER_DESCRIPTION_1375=El nombre de la cuenta de usuario bajo la que se ejecutar\u00eda el servidor
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=La ruta a la instalaci\u00f3n Java que se utilizar\u00eda para ejecutar el servidor
INFO_CREATERC_JAVA_ARGS_DESCRIPTION_1377=Se debe transferir un conjunto de argumentos al JVM al ejecutar el servidor
@@ -1271,7 +1271,7 @@
INFO_DESCRIPTION_REFRESH_PERIOD_1706=Si se especifica este argumento, el comando de estado mostrar\u00e1 sus contenidos peri\u00f3dicamente.  Usado para especificar el periodo (en segundos) entre dos representaciones del estado
INFO_INSTALLDS_PRINT_EQUIVALENT_COMMAND_LINE_1708=Imprima la l\u00ednea de comandos no interactiva equivalente
ERR_WINDOWS_SERVICE_ENABLING_ERROR_STARTING_SERVER_1709=El servicio de Windows se ha configurado satisfactoriamente, pero se ha producido un error al iniciarlo.  C\u00f3digo de error al iniciar el servicio de Windows: %d
INFO_DESCRIPTION_DBTEST_STATS_ONLY_1710=No mostrar los datos JE, s\u00f3lo estad\u00edsticas
INFO_DESCRIPTION_BACKEND_DEBUG_STATS_ONLY_1710=No mostrar los datos JE, s\u00f3lo estad\u00edsticas
INFO_TIMEOUT_PLACEHOLDER_1711={timeout}
INFO_DESCRIPTION_CONNECTION_TIMEOUT_1712=La duraci\u00f3n m\u00e1xima de tiempo (en mil\u00e9simas de segundo) que puede tardarse en establecer una conexi\u00f3n
ERR_MAKELDIF_CANNOT_WRITE_ENTRY_WITHOUT_DN_1713=Se ha producido un error al tratar de escribir una entrada en LDIF: no ha podido calcularse el DN para la entrada (no se ha encontrado ning\u00fan valor para el atributo RDN %s)
@@ -1279,3 +1279,8 @@
INFO_LABEL_DBTEST_INDEX_UNDEFINED_RECORD_COUNT_1715=No definido
INFO_LDIFDIFF_DESCRIPTION_USE_COMPARE_RESULT_1735=Utilice los resultados de comparaci\u00f3n de LDAP como un c\u00f3digo de salida para se\\u00F1alar diferencias entre los dos archivos LDIF
INFO_LDAPCOMPARE_DESCRIPTION_USE_COMPARE_RESULT_1736=Utilice los resultados de comparaci\u00f3n de LDAP como un c\u00f3digo de salida para las comparaci\u00f3nes LDAP
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=Muestra los contenedores ra\u00edz utilizados por todos los servidores de fondo
ERR_BACKEND_TOOL_ERROR_READING_TREE_1866=Se ha producido un error al tratar de leer y/o descodificar registros del \u00edndice: %s
ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND_1865=Se ha producido un error inesperado al tratar de inicializar el backend %s: %
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_1868=No existe ning\u00fan \u00edndice con el nombre solicitado %s ni en el contenedor de entradas %s ni en el backend %s
INFO_DESCRIPTION_BACKEND_TOOL_1893=Esta utilidad se puede utilizar para depurar un servidore de fondo Pluggable

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

@@ -895,41 +895,41 @@
ERR_DSCFG_ERROR_QUIET_AND_INTERACTIVE_INCOMPATIBLE_1326=Si vous sp\u00e9cifiez l'argument {%s}, vous devez aussi sp\u00e9cifier {%s}
INFO_DESCRIPTION_DBTEST_TOOL_1327=Cet utilitaire permet de d\u00e9boguer la base de donn\u00e9es JE
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=R\u00e9pertorier les conteneurs racine utilis\u00e9s par tous les backends JE
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=R\u00e9pertorier les conteneurs d'entr\u00e9es pour un conteneur racine
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=R\u00e9pertorier les conteneurs d'entr\u00e9es pour un conteneur racine
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=Vider les enregistrements d'un conteneur de base de donn\u00e9es
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=L'ID de backend du backend de JE \u00e0 d\u00e9boguer
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=Le DN de base du conteneur d'entr\u00e9es \u00e0 d\u00e9boguer
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=Le nom du conteneur de bases de donn\u00e9es \u00e0 d\u00e9boguer
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=N'essayez pas de d\u00e9coder les donn\u00e9es JE de leurs types appropri\u00e9s
INFO_BACKEND_DEBUG_BACKEND_ID_1331=L'ID de backend du backend de JE \u00e0 d\u00e9boguer
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=Le DN de base du conteneur d'entr\u00e9es \u00e0 d\u00e9boguer
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=Le nom du conteneur de bases de donn\u00e9es \u00e0 d\u00e9boguer
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=N'essayez pas de d\u00e9coder les donn\u00e9es JE de leurs types appropri\u00e9s
ERR_DBTEST_DECODE_FAIL_1335=Une erreur s'est produite lors de la tentative de d\u00e9codage des donn\u00e9es\u00a0: %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=R\u00e9pertorier l'\u00e9tat des index dans un conteneur d'entr\u00e9es
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=Afficher seulement les enregistrements avec des cl\u00e9s devant \u00eatre ordonn\u00e9s avant la valeur indiqu\u00e9e utilisant le comparateur pour le conteneur de bases de donn\u00e9es
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=Afficher seulement les enregistrements avec des cl\u00e9s devant \u00eatre ordonn\u00e9s apr\u00e8s la valeur indiqu\u00e9e utilisant le comparateur pour le conteneur de bases de donn\u00e9es
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=Afficher seulement les enregistrements dont les donn\u00e9es ne sont pas sup\u00e9rieures \u00e0 la valeur indiqu\u00e9e
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=Afficher seulement les enregistrements dont les donn\u00e9es ne sont pas inf\u00e9rieures \u00e0 la valeur indiqu\u00e9e
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=R\u00e9pertorier l'\u00e9tat des index dans un conteneur d'entr\u00e9es
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=Afficher seulement les enregistrements avec des cl\u00e9s devant \u00eatre ordonn\u00e9s avant la valeur indiqu\u00e9e utilisant le comparateur pour le conteneur de bases de donn\u00e9es
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=Afficher seulement les enregistrements avec des cl\u00e9s devant \u00eatre ordonn\u00e9s apr\u00e8s la valeur indiqu\u00e9e utilisant le comparateur pour le conteneur de bases de donn\u00e9es
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=Afficher seulement les enregistrements dont les donn\u00e9es ne sont pas sup\u00e9rieures \u00e0 la valeur indiqu\u00e9e
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=Afficher seulement les enregistrements dont les donn\u00e9es ne sont pas inf\u00e9rieures \u00e0 la valeur indiqu\u00e9e
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=R\u00e9pertorier les conteneurs de bases de donn\u00e9es pour un conteneur d'entr\u00e9es
INFO_LABEL_DBTEST_BACKEND_ID_1342=Identifiant du backend
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=Identifiant du backend
INFO_LABEL_DBTEST_DB_DIRECTORY_1343=R\u00e9pertoire de bases de donn\u00e9es
INFO_LABEL_DBTEST_BASE_DN_1344=DN de base
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=DN de base
INFO_LABEL_DBTEST_JE_DATABASE_PREFIX_1345=Pr\u00e9fixe de base de donn\u00e9es JE
INFO_LABEL_DBTEST_ENTRY_COUNT_1346=Nombre d'entr\u00e9es
ERR_DBTEST_NO_BACKENDS_FOR_ID_1347=Aucun des backends Directory Server n'est configur\u00e9 avec l'ID de backend demand\u00e9 (%s)
ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=Aucun des conteneurs d'entr\u00e9es n'est configur\u00e9 avec le DN de base demand\u00e9 (%s) dans le backend %s
ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID_1347=Aucun des backends Directory Server n'est configur\u00e9 avec l'ID de backend demand\u00e9 (%s)
ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=Aucun des conteneurs d'entr\u00e9es n'est configur\u00e9 avec le DN de base demand\u00e9 (%s) dans le backend %s
ERR_DBTEST_NO_DATABASE_CONTAINERS_FOR_NAME_1349=Aucun des conteneurs de base de donn\u00e9es ne porte le nom demand\u00e9 (%s) dans le conteneur d'entr\u00e9es %s et le backend %s
ERR_DBTEST_ERROR_INITIALIZING_BACKEND_1350=Une erreur inattendue s'est produite lors de la tentative d'initialisation du backend de JE %s\u00a0: %s
ERR_DBTEST_ERROR_READING_DATABASE_1351=Une erreur inattendue s'est produite lors de la tentative de lecture et/ou de d\u00e9codage d'enregistrements dans la base de donn\u00e9es\u00a0: %s
ERR_DBTEST_DECODE_BASE_DN_1352=Impossible de d\u00e9coder la cha\u00eene de DN de base "%s" en tant que nom distinctif valide\u00a0: %s
ERR_BACKEND_DEBUG_DECODE_BASE_DN_1352=Impossible de d\u00e9coder la cha\u00eene de DN de base "%s" en tant que nom distinctif valide\u00a0: %s
INFO_LABEL_DBTEST_DATABASE_NAME_1353=Nom de base de donn\u00e9es
INFO_LABEL_DBTEST_DATABASE_TYPE_1354=Type de base de donn\u00e9es
INFO_LABEL_DBTEST_JE_DATABASE_NAME_1355=Nom de base de donn\u00e9es JE
INFO_LABEL_DBTEST_JE_RECORD_COUNT_1356=Nombre d'enregistrements
INFO_LABEL_DBTEST_INDEX_NAME_1357=Nom d'index
INFO_LABEL_DBTEST_INDEX_TYPE_1358=Type d'index
INFO_LABEL_DBTEST_INDEX_STATUS_1359=\u00c9tat d'index
INFO_LABEL_DBTEST_RECORD_COUNT_1356=Nombre d'enregistrements
INFO_LABEL_BACKEND_DEBUG_INDEX_NAME_1357=Nom d'index
INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE_1358=Type d'index
INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS_1359=\u00c9tat d'index
INFO_LABEL_DBTEST_KEY_1360=Cl\u00e9
INFO_LABEL_DBTEST_DATA_1361=Donn\u00e9es
WARN_DBTEST_CANNOT_UNLOCK_BACKEND_1362=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 et aucune autre action ne devrait \u00eatre n\u00e9cessaire
ERR_DBTEST_CANNOT_LOCK_BACKEND_1363=Une erreur s'est produite lors de la tentative d'acquisition d'un verrou partag\u00e9 pour le backend %s\u00a0: %s. Cela signifie g\u00e9n\u00e9ralement qu'un autre processus (par exemple, une restauration ou une importation LDIF) dispose d'un acc\u00e8s exclusif \u00e0 ce backend
WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND_1362=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 et aucune autre action ne devrait \u00eatre n\u00e9cessaire
ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND_1363=Une erreur s'est produite lors de la tentative d'acquisition d'un verrou partag\u00e9 pour le backend %s\u00a0: %s. Cela signifie g\u00e9n\u00e9ralement qu'un autre processus (par exemple, une restauration ou une importation LDIF) dispose d'un acc\u00e8s exclusif \u00e0 ce backend
ERR_DBTEST_CANNOT_DECODE_KEY_1364=Une erreur s'est produite lors du d\u00e9codage de la valeur de cl\u00e9 min/max %s\u00a0: %s. Les valeurs portant le pr\u00e9fixe "0x" seront d\u00e9cod\u00e9es en tant qu'octets de donn\u00e9es brutes au format hexad\u00e9cimal. Lors du vidage de la base de donn\u00e9es DN2ID, la valeur doit \u00eatre un nom distinctif valide. Lors du vidage de la base de donn\u00e9es ID2Entry, la valeur est d\u00e9cod\u00e9e en tant qu'ID d'entr\u00e9e. Lors du vidage de toutes les autres bases de donn\u00e9es, la valeur est d\u00e9cod\u00e9e en tant que cha\u00eene
INFO_LABEL_DBTEST_ENTRY_1365=Entr\u00e9e
INFO_LABEL_DBTEST_ENTRY_ID_1366=ID d'entr\u00e9e
@@ -939,7 +939,7 @@
INFO_LABEL_DBTEST_INDEX_ENTRY_ID_LIST_1370=Liste d'ID d'entr\u00e9es
INFO_LABEL_DBTEST_VLV_INDEX_LAST_SORT_KEYS_1371=Cl\u00e9s du dernier tri
ERR_DBTEST_CANNOT_DECODE_SIZE_1372=Une erreur s'est produite lors de l'analyser de la taille de donn\u00e9es min/max %s en tant qu'entier\u00a0: %s
ERR_DBTEST_MISSING_SUBCOMMAND_1374=Une sous-commande doit \u00eatre sp\u00e9cifi\u00e9e
ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND_1374=Une sous-commande doit \u00eatre sp\u00e9cifi\u00e9e
INFO_CREATERC_USER_DESCRIPTION_1375=Le nom du compte utilisateur sous lequel le serveur doit tourner
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=Le chemin vers l'installation Java \u00e0 utiliser pour faire tourner le serveur
INFO_CREATERC_JAVA_ARGS_DESCRIPTION_1377=Un jeu d'arguments que la JVM doit accepter quand le serveur tourne
@@ -1271,11 +1271,16 @@
INFO_DESCRIPTION_REFRESH_PERIOD_1706=Lorsque vous sp\u00e9cifiez cet argument, la commande d'\u00e9tat affiche son contenu \u00e0 intervalle r\u00e9gulier.  Permet de sp\u00e9cifier la p\u00e9riode (en secondes) qui s\u00e9pare deux affichages de l'\u00e9tat
INFO_INSTALLDS_PRINT_EQUIVALENT_COMMAND_LINE_1708=Imprimer la ligne de commande \u00e9quivalente non interactive
ERR_WINDOWS_SERVICE_ENABLING_ERROR_STARTING_SERVER_1709=Le service Windows a \u00e9t\u00e9 correctement configur\u00e9 mais une erreur s'est produite lors de son d\u00e9marrage.  Code d'erreur au d\u00e9marrage du service Windows\u00a0: %d
INFO_DESCRIPTION_DBTEST_STATS_ONLY_1710=Impossible d'afficher les donn\u00e9es JE, uniquement les statistiques
INFO_DESCRIPTION_BACKEND_DEBUG_STATS_ONLY_1710=Impossible d'afficher les donn\u00e9es JE, uniquement les statistiques
INFO_TIMEOUT_PLACEHOLDER_1711={Temporisation}
INFO_DESCRIPTION_CONNECTION_TIMEOUT_1712=Dur\u00e9e maximale (en millisecondes) qui peut \u00eatre n\u00e9cessaire pour \u00e9tablir une connexion
ERR_MAKELDIF_CANNOT_WRITE_ENTRY_WITHOUT_DN_1713=Une erreur est survenue lors de la tentative d'\u00e9criture d'une entr\u00e9e dans LDIF : Impossible de calculer le DN de l'entr\u00e9e (aucune valeur trouv\u00e9e pour l'attribut RDN %s)
ERR_CLIENT_SIDE_TIMEOUT_1714=Une expiration du d\u00e9lai s'est produite c\u00f4t\u00e9 client.%nInformations suppl\u00e9mentaires\u00a0:  %s
INFO_LABEL_DBTEST_INDEX_UNDEFINED_RECORD_COUNT_1715=Non d\u00e9fini
INFO_LDIFDIFF_DESCRIPTION_USE_COMPARE_RESULT_1735=Utiliser le r\u00e9sultat de comparaison LDAP en tant que code de sortie pour signaler les diff\u00e9rences entre deux fichiers LDIF
INFO_LDAPCOMPARE_DESCRIPTION_USE_COMPARE_RESULT_1736=Utiliser le r\u00e9sultat de comparaison LDAP en tant que code de sortie pour les comparaisons LDAP
INFO_LDAPCOMPARE_DESCRIPTION_USE_COMPARE_RESULT_1736=Utiliser le r\u00e9sultat de comparaison LDAP en tant que code de sortie pour les comparaisons LDAP
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=R\u00e9pertorier les conteneurs racine utilis\u00e9s par tous les backends
ERR_BACKEND_TOOL_ERROR_READING_TREE_1866=Une erreur inattendue s'est produite lors de la tentative de lecture et/ou de d\u00e9codage d'enregistrements dans l' index: %s
ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND_1865=Une erreur inattendue s'est produite lors de la tentative d'initialisation du backend %s\u00a0: %s
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_1868=Aucun des indexes ne porte le nom demand\u00e9 (%s) dans le conteneur d'entr\u00e9es %s et le backend %s
INFO_DESCRIPTION_BACKEND_TOOL_1893=Cet utilitaire permet de d\u00e9boguer un backend

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

@@ -895,41 +895,41 @@
ERR_DSCFG_ERROR_QUIET_AND_INTERACTIVE_INCOMPATIBLE_1326={%s} \u5f15\u6570\u3092\u6307\u5b9a\u3059\u308b\u5834\u5408\u3001{%s} \u3082\u6307\u5b9a\u3059\u308b\u5fc5\u8981\u304c\u3042\u308a\u307e\u3059
INFO_DESCRIPTION_DBTEST_TOOL_1327=\u3053\u306e\u30e6\u30fc\u30c6\u30a3\u30ea\u30c6\u30a3\u30fc\u3092\u4f7f\u3063\u3066 JE \u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u3092\u30c7\u30d0\u30c3\u30b0\u3067\u304d\u307e\u3059
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=\u3059\u3079\u3066\u306e JE \u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u3067\u4f7f\u7528\u3055\u308c\u308b\u30eb\u30fc\u30c8\u30b3\u30f3\u30c6\u30ca\u3092\u4e00\u89a7\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=\u30eb\u30fc\u30c8\u30b3\u30f3\u30c6\u30ca\u7528\u306e\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u3092\u4e00\u89a7\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=\u30eb\u30fc\u30c8\u30b3\u30f3\u30c6\u30ca\u7528\u306e\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u3092\u4e00\u89a7\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u304b\u3089\u30ec\u30b3\u30fc\u30c9\u3092\u30c0\u30f3\u30d7\u3057\u307e\u3059
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=\u30c7\u30d0\u30c3\u30b0\u3059\u308b JE \u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u306e\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 ID
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=\u30c7\u30d0\u30c3\u30b0\u3059\u308b\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u306e\u30d9\u30fc\u30b9 DN
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=\u30c7\u30d0\u30c3\u30b0\u3059\u308b\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u306e\u540d\u524d
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=JE \u30c7\u30fc\u30bf\u3092\u305d\u306e\u9069\u5207\u306a\u578b\u3078\u5fa9\u53f7\u5316\u3059\u308b\u3053\u3068\u3092\u8a66\u307f\u307e\u305b\u3093
INFO_BACKEND_DEBUG_BACKEND_ID_1331=\u30c7\u30d0\u30c3\u30b0\u3059\u308b JE \u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u306e\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 ID
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=\u30c7\u30d0\u30c3\u30b0\u3059\u308b\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u306e\u30d9\u30fc\u30b9 DN
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=\u30c7\u30d0\u30c3\u30b0\u3059\u308b\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u306e\u540d\u524d
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=JE \u30c7\u30fc\u30bf\u3092\u305d\u306e\u9069\u5207\u306a\u578b\u3078\u5fa9\u53f7\u5316\u3059\u308b\u3053\u3068\u3092\u8a66\u307f\u307e\u305b\u3093
ERR_DBTEST_DECODE_FAIL_1335=\u30c7\u30fc\u30bf\u306e\u5fa9\u53f7\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f: %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u5185\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u306e\u72b6\u614b\u3092\u4e00\u89a7\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=\u9806\u5e8f\u4ed8\u304d\u306e\u9375\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u3046\u3061\u6307\u5b9a\u3055\u308c\u305f\u5024\u3088\u308a\u524d\u306e\u9375\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u307f\u3092\u8868\u793a\u3057\u307e\u3059\u3002\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u306e\u6bd4\u8f03\u6f14\u7b97\u5b50\u304c\u4f7f\u7528\u3055\u308c\u307e\u3059
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=\u9806\u5e8f\u4ed8\u304d\u306e\u9375\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u3046\u3061\u6307\u5b9a\u3055\u308c\u305f\u5024\u3088\u308a\u3042\u3068\u306e\u9375\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u307f\u3092\u8868\u793a\u3057\u307e\u3059\u3002\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u306e\u6bd4\u8f03\u6f14\u7b97\u5b50\u304c\u4f7f\u7528\u3055\u308c\u307e\u3059
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=\u6307\u5b9a\u3055\u308c\u305f\u5024\u4ee5\u4e0b\u306e\u30c7\u30fc\u30bf\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u307f\u3092\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=\u6307\u5b9a\u3055\u308c\u305f\u5024\u4ee5\u4e0a\u306e\u30c7\u30fc\u30bf\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u307f\u3092\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u5185\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u306e\u72b6\u614b\u3092\u4e00\u89a7\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=\u9806\u5e8f\u4ed8\u304d\u306e\u9375\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u3046\u3061\u6307\u5b9a\u3055\u308c\u305f\u5024\u3088\u308a\u524d\u306e\u9375\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u307f\u3092\u8868\u793a\u3057\u307e\u3059\u3002\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u306e\u6bd4\u8f03\u6f14\u7b97\u5b50\u304c\u4f7f\u7528\u3055\u308c\u307e\u3059
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=\u9806\u5e8f\u4ed8\u304d\u306e\u9375\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u3046\u3061\u6307\u5b9a\u3055\u308c\u305f\u5024\u3088\u308a\u3042\u3068\u306e\u9375\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u307f\u3092\u8868\u793a\u3057\u307e\u3059\u3002\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u306e\u6bd4\u8f03\u6f14\u7b97\u5b50\u304c\u4f7f\u7528\u3055\u308c\u307e\u3059
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=\u6307\u5b9a\u3055\u308c\u305f\u5024\u4ee5\u4e0b\u306e\u30c7\u30fc\u30bf\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u307f\u3092\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=\u6307\u5b9a\u3055\u308c\u305f\u5024\u4ee5\u4e0a\u306e\u30c7\u30fc\u30bf\u3092\u6301\u3064\u30ec\u30b3\u30fc\u30c9\u306e\u307f\u3092\u8868\u793a\u3057\u307e\u3059
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u7528\u306e\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u3092\u4e00\u89a7\u8868\u793a\u3057\u307e\u3059
INFO_LABEL_DBTEST_BACKEND_ID_1342=\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 ID
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 ID
INFO_LABEL_DBTEST_DB_DIRECTORY_1343=\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30c7\u30a3\u30ec\u30af\u30c8\u30ea
INFO_LABEL_DBTEST_BASE_DN_1344=\u30d9\u30fc\u30b9 DN
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=\u30d9\u30fc\u30b9 DN
INFO_LABEL_DBTEST_JE_DATABASE_PREFIX_1345=JE \u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u306e\u30d7\u30ec\u30d5\u30a3\u30c3\u30af\u30b9
INFO_LABEL_DBTEST_ENTRY_COUNT_1346=\u30a8\u30f3\u30c8\u30ea\u6570
ERR_DBTEST_NO_BACKENDS_FOR_ID_1347=\u8981\u6c42\u3055\u308c\u305f\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 ID %s \u3067\u69cb\u6210\u3055\u308c\u305f\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u304c\u3042\u308a\u307e\u305b\u3093\u3002
ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %2$s \u5185\u306e\u8981\u6c42\u3055\u308c\u305f\u30d9\u30fc\u30b9 DN %1$s \u3067\u69cb\u6210\u3055\u308c\u305f\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u304c\u3042\u308a\u307e\u305b\u3093\u3002
ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID_1347=\u8981\u6c42\u3055\u308c\u305f\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 ID %s \u3067\u69cb\u6210\u3055\u308c\u305f\u30c7\u30a3\u30ec\u30af\u30c8\u30ea\u30b5\u30fc\u30d0\u30fc\u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u304c\u3042\u308a\u307e\u305b\u3093\u3002
ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %2$s \u5185\u306e\u8981\u6c42\u3055\u308c\u305f\u30d9\u30fc\u30b9 DN %1$s \u3067\u69cb\u6210\u3055\u308c\u305f\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca\u304c\u3042\u308a\u307e\u305b\u3093\u3002
ERR_DBTEST_NO_DATABASE_CONTAINERS_FOR_NAME_1349=\u8981\u6c42\u3055\u308c\u305f\u540d\u524d %s \u306e\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u30b3\u30f3\u30c6\u30ca\u306f\u3001\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca %s \u304a\u3088\u3073\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u306b\u5b58\u5728\u3057\u307e\u305b\u3093
ERR_DBTEST_ERROR_INITIALIZING_BACKEND_1350=JE \u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u306e\u521d\u671f\u5316\u4e2d\u306b\u4e88\u671f\u3057\u306a\u3044\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f: %s
ERR_DBTEST_ERROR_READING_DATABASE_1351=\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u304b\u3089\u306e\u30ec\u30b3\u30fc\u30c9\u3092\u8aad\u307f\u53d6\u308a\u307e\u305f\u306f\u5fa9\u53f7\u5316\u3001\u3042\u308b\u3044\u306f\u305d\u306e\u4e21\u65b9\u3092\u884c\u3063\u3066\u3044\u308b\u3068\u304d\u306b\u4e88\u671f\u3057\u306a\u3044\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f: %s
ERR_DBTEST_DECODE_BASE_DN_1352=\u30d9\u30fc\u30b9 DN \u6587\u5b57\u5217 "%s" \u3092\u6709\u52b9\u306a\u8b58\u5225\u540d\u3068\u3057\u3066\u5fa9\u53f7\u5316\u3067\u304d\u307e\u305b\u3093:  %s
ERR_BACKEND_DEBUG_DECODE_BASE_DN_1352=\u30d9\u30fc\u30b9 DN \u6587\u5b57\u5217 "%s" \u3092\u6709\u52b9\u306a\u8b58\u5225\u540d\u3068\u3057\u3066\u5fa9\u53f7\u5316\u3067\u304d\u307e\u305b\u3093:  %s
INFO_LABEL_DBTEST_DATABASE_NAME_1353=\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u540d
INFO_LABEL_DBTEST_DATABASE_TYPE_1354=\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u306e\u30bf\u30a4\u30d7
INFO_LABEL_DBTEST_JE_DATABASE_NAME_1355=JE \u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u540d
INFO_LABEL_DBTEST_JE_RECORD_COUNT_1356=\u30ec\u30b3\u30fc\u30c9\u6570
INFO_LABEL_DBTEST_INDEX_NAME_1357=\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u540d
INFO_LABEL_DBTEST_INDEX_TYPE_1358=\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u306e\u30bf\u30a4\u30d7
INFO_LABEL_DBTEST_INDEX_STATUS_1359=\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u306e\u72b6\u614b
INFO_LABEL_DBTEST_RECORD_COUNT_1356=\u30ec\u30b3\u30fc\u30c9\u6570
INFO_LABEL_BACKEND_DEBUG_INDEX_NAME_1357=\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u540d
INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE_1358=\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u306e\u30bf\u30a4\u30d7
INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS_1359=\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u306e\u72b6\u614b
INFO_LABEL_DBTEST_KEY_1360=\u9375
INFO_LABEL_DBTEST_DATA_1361=\u30c7\u30fc\u30bf
WARN_DBTEST_CANNOT_UNLOCK_BACKEND_1362=\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\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
ERR_DBTEST_CANNOT_LOCK_BACKEND_1363=\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u306e\u5171\u6709\u30ed\u30c3\u30af\u306e\u53d6\u5f97\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s\u3002\u3053\u308c\u306f\u901a\u5e38\u3001\u307b\u304b\u306e\u30d7\u30ed\u30bb\u30b9\u304c\u3053\u306e\u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u3078\u306e\u6392\u4ed6\u7684\u30a2\u30af\u30bb\u30b9 (\u5fa9\u5143\u3084 LDIF \u30a4\u30f3\u30dd\u30fc\u30c8\u306a\u3069) \u3092\u884c\u3063\u3066\u3044\u308b\u305f\u3081\u3067\u3059
WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND_1362=\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\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
ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND_1363=\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u306e\u5171\u6709\u30ed\u30c3\u30af\u306e\u53d6\u5f97\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  %s\u3002\u3053\u308c\u306f\u901a\u5e38\u3001\u307b\u304b\u306e\u30d7\u30ed\u30bb\u30b9\u304c\u3053\u306e\u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u3078\u306e\u6392\u4ed6\u7684\u30a2\u30af\u30bb\u30b9 (\u5fa9\u5143\u3084 LDIF \u30a4\u30f3\u30dd\u30fc\u30c8\u306a\u3069) \u3092\u884c\u3063\u3066\u3044\u308b\u305f\u3081\u3067\u3059
ERR_DBTEST_CANNOT_DECODE_KEY_1364=\u6700\u5c0f/\u6700\u5927\u9375\u5024 %s \u306e\u5fa9\u53f7\u5316\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f: %s\u3002"0x" \u306e\u63a5\u982d\u8f9e\u304c\u4ed8\u3044\u305f\u5024\u306f\u300116 \u9032\u6570\u306e raw \u30d0\u30a4\u30c8\u3068\u3057\u3066\u5fa9\u53f7\u5316\u3055\u308c\u307e\u3059\u3002DN2ID \u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u3092\u30c0\u30f3\u30d7\u3059\u308b\u5834\u5408\u3001\u5024\u306f\u6709\u52b9\u306a\u8b58\u5225\u540d\u306b\u3059\u308b\u5fc5\u8981\u304c\u3042\u308a\u307e\u3059\u3002ID2Entry \u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u3092\u30c0\u30f3\u30d7\u3059\u308b\u5834\u5408\u3001\u5024\u306f\u30a8\u30f3\u30c8\u30ea ID \u3068\u3057\u3066\u5fa9\u53f7\u5316\u3055\u308c\u307e\u3059\u3002\u307b\u304b\u306e\u3059\u3079\u3066\u306e\u30c7\u30fc\u30bf\u30d9\u30fc\u30b9\u3092\u30c0\u30f3\u30d7\u3059\u308b\u5834\u5408\u306f\u3001\u5024\u306f\u6587\u5b57\u5217\u3068\u3057\u3066\u5fa9\u53f7\u5316\u3055\u308c\u307e\u3059
INFO_LABEL_DBTEST_ENTRY_1365=\u30a8\u30f3\u30c8\u30ea
INFO_LABEL_DBTEST_ENTRY_ID_1366=\u30a8\u30f3\u30c8\u30ea ID
@@ -939,7 +939,7 @@
INFO_LABEL_DBTEST_INDEX_ENTRY_ID_LIST_1370=\u30a8\u30f3\u30c8\u30ea ID \u30ea\u30b9\u30c8
INFO_LABEL_DBTEST_VLV_INDEX_LAST_SORT_KEYS_1371=\u524d\u56de\u306e\u30bd\u30fc\u30c8\u30ad\u30fc
ERR_DBTEST_CANNOT_DECODE_SIZE_1372=\u6700\u5c0f/\u6700\u5927\u30c7\u30fc\u30bf\u30b5\u30a4\u30ba %s \u3092\u6574\u6570\u3068\u3057\u3066\u89e3\u6790\u3057\u3066\u3044\u308b\u3068\u304d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f: %s
ERR_DBTEST_MISSING_SUBCOMMAND_1374=\u30b5\u30d6\u30b3\u30de\u30f3\u30c9\u3092\u6307\u5b9a\u3057\u3066\u304f\u3060\u3055\u3044
ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND_1374=\u30b5\u30d6\u30b3\u30de\u30f3\u30c9\u3092\u6307\u5b9a\u3057\u3066\u304f\u3060\u3055\u3044
INFO_CREATERC_USER_DESCRIPTION_1375=\u30b5\u30fc\u30d0\u30fc\u3092\u5b9f\u884c\u3059\u308b\u30e6\u30fc\u30b6\u30fc\u30a2\u30ab\u30a6\u30f3\u30c8\u306e\u540d\u524d
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=\u30b5\u30fc\u30d0\u30fc\u306e\u5b9f\u884c\u306b\u4f7f\u7528\u3059\u308b Java \u30a4\u30f3\u30b9\u30c8\u30fc\u30eb\u3078\u306e\u30d1\u30b9
INFO_CREATERC_JAVA_ARGS_DESCRIPTION_1377=\u30b5\u30fc\u30d0\u30fc\u306e\u5b9f\u884c\u6642\u306b JVM \u306b\u6e21\u3059\u5f15\u6570\u306e\u30bb\u30c3\u30c8
@@ -1271,10 +1271,22 @@
INFO_DESCRIPTION_REFRESH_PERIOD_1706=\u3053\u306e\u5f15\u6570\u304c\u6307\u5b9a\u3055\u308c\u305f\u5834\u5408\u3001\u30b9\u30c6\u30fc\u30bf\u30b9\u30b3\u30de\u30f3\u30c9\u306b\u306f\u305d\u306e\u5185\u5bb9\u304c\u5b9a\u671f\u7684\u306b\u8868\u793a\u3055\u308c\u307e\u3059\u3002\u30b9\u30c6\u30fc\u30bf\u30b9\u306e\u8868\u793a\u9593\u9694 (\u79d2\u5358\u4f4d) \u3092\u6307\u5b9a\u3059\u308b\u305f\u3081\u306b\u4f7f\u7528\u3055\u308c\u307e\u3059
INFO_INSTALLDS_PRINT_EQUIVALENT_COMMAND_LINE_1708=\u7b49\u4fa1\u306e\u975e\u5bfe\u8a71\u578b\u30b3\u30de\u30f3\u30c9\u884c\u3092\u5370\u5237\u3057\u307e\u3059
ERR_WINDOWS_SERVICE_ENABLING_ERROR_STARTING_SERVER_1709=Windows \u30b5\u30fc\u30d3\u30b9\u306f\u6b63\u3057\u304f\u69cb\u6210\u3055\u308c\u307e\u3057\u305f\u304c\u3001\u305d\u306e\u8d77\u52d5\u6642\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f\u3002Windows \u30b5\u30fc\u30d3\u30b9\u306e\u8d77\u52d5\u3067\u306e\u30a8\u30e9\u30fc\u30b3\u30fc\u30c9: %d
INFO_DESCRIPTION_DBTEST_STATS_ONLY_1710=JE \u30c7\u30fc\u30bf\u306f\u8868\u793a\u3057\u307e\u305b\u3093\u3002\u7d71\u8a08\u60c5\u5831\u306e\u307f\u3067\u3059
INFO_DESCRIPTION_BACKEND_DEBUG_STATS_ONLY_1710=JE \u30c7\u30fc\u30bf\u306f\u8868\u793a\u3057\u307e\u305b\u3093\u3002\u7d71\u8a08\u60c5\u5831\u306e\u307f\u3067\u3059
INFO_TIMEOUT_PLACEHOLDER_1711={timeout}
INFO_DESCRIPTION_CONNECTION_TIMEOUT_1712=\u63a5\u7d9a\u3092\u78ba\u7acb\u3059\u308b\u305f\u3081\u306b\u304b\u3051\u3089\u308c\u308b\u6700\u5927\u6642\u9593 (\u30df\u30ea\u79d2)
ERR_MAKELDIF_CANNOT_WRITE_ENTRY_WITHOUT_DN_1713=\u30a8\u30f3\u30c8\u30ea\u3092 LDIF \u306b\u66f8\u304d\u8fbc\u307f\u4e2d\u306b\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f:  \u30a8\u30f3\u30c8\u30ea\u306e DN \u3092\u8a08\u7b97\u3067\u304d\u307e\u305b\u3093\u3067\u3057\u305f (RDN \u5c5e\u6027 %s \u306e\u5024\u304c\u898b\u3064\u304b\u308a\u307e\u305b\u3093)
ERR_CLIENT_SIDE_TIMEOUT_1714=\u30af\u30e9\u30a4\u30a2\u30f3\u30c8\u5074\u306e\u30bf\u30a4\u30e0\u30a2\u30a6\u30c8\u304c\u767a\u751f\u3057\u307e\u3057\u305f\u3002%n\u8ffd\u52a0\u60c5\u5831:  %s
INFO_LABEL_DBTEST_INDEX_UNDEFINED_RECORD_COUNT_1715=\u672a\u5b9a\u7fa9
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=\u3059\u3079\u3066\u306e\u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u3067\u4f7f\u7528\u3055\u308c\u308b\u30eb\u30fc\u30c8\u30b3\u30f3\u30c6\u30ca\u3092\u4e00\u89a7\u8868\u793a\u3057\u307e\u3059
ERR_BACKEND_TOOL_ERROR_READING_TREE_1866=\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u304b\u3089\u306e\u30ec\u30b3\u30fc\u30c9\u3092\u8aad\u307f\u53d6\u308a\u307e\u305f\u306f\u5fa9\u53f7\u5316\u3001\u3042\u308b\u3044\u306f\u305d\u306e\u4e21\u65b9\u3092\u884c\u3063\u3066\u3044\u308b\u3068\u304d\u306b\u4e88\u671f\u3057\u306a\u3044\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f: %s
ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND_1865=\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u306e\u521d\u671f\u5316\u4e2d\u306b\u4e88\u671f\u3057\u306a\u3044\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f: %s
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_1868=\u8981\u6c42\u3055\u308c\u305f\u540d\u524d %s \u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u306f\u3001\u30a8\u30f3\u30c8\u30ea\u30b3\u30f3\u30c6\u30ca %s \u304a\u3088\u3073\u30d0\u30c3\u30af\u30a8\u30f3\u30c9 %s \u306b\u5b58\u5728\u3057\u307e\u305b\u3093
INFO_DESCRIPTION_BACKEND_TOOL_1893=\u3053\u306e\u30e6\u30fc\u30c6\u30a3\u30ea\u30c6\u30a3\u30fc\u3092\u4f7f\u3063\u3066\u30d0\u30c3\u30af\u30a8\u30f3\u30c9\u3092\u30c7\u30d0\u30c3\u30b0\u3067\u304d\u307e\u3059
INFO_LABEL_BACKEND_DEBUG_ENTRY_COUNT_1346=
INFO_LABEL_BACKEND_TOOL_TREE_NAME_1859=
INFO_LABEL_BACKEND_TOOL_STORAGE_TREE_NAME_1861=
INFO_DESCRIPTION_BACKEND_TOOL_TREE_NAME_1862=
ERR_BACKEND_TOOL_ONLY_ONE_MIN_KEY_1869=
ERR_BACKEND_TOOL_ONLY_ONE_MAX_KEY_1870=
ERR_BACKEND_TOOL_EXECUTING_COMMAND_1872=


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

@@ -893,41 +893,41 @@
ERR_DSCFG_ERROR_QUIET_AND_INTERACTIVE_INCOMPATIBLE_1326={%s} \uc778\uc218\ub97c \uc9c0\uc815\ud560 \uacbd\uc6b0 {%s}\ub3c4 \ud568\uaed8 \uc9c0\uc815\ud574\uc57c \ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_TOOL_1327=\uc774 \uc720\ud2f8\ub9ac\ud2f0\ub97c \uc0ac\uc6a9\ud558\uc5ec JE \ub370\uc774\ud130\ubca0\uc774\uc2a4\ub97c \ub514\ubc84\uae45\ud560 \uc218 \uc788\uc2b5\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=\ubaa8\ub4e0 JE \ubc31\uc5d4\ub4dc\uc5d0 \uc0ac\uc6a9\ub418\ub294 \ub8e8\ud2b8 \ucee8\ud14c\uc774\ub108\ub97c \ub098\uc5f4\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=\ub8e8\ud2b8 \ucee8\ud14c\uc774\ub108\uc5d0 \ub300\ud55c \ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\ub97c \ub098\uc5f4\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=\ub8e8\ud2b8 \ucee8\ud14c\uc774\ub108\uc5d0 \ub300\ud55c \ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\ub97c \ub098\uc5f4\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=\ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\uc5d0\uc11c \ub808\ucf54\ub4dc\ub97c \ub364\ud504\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=\ub514\ubc84\uae45\ud560 JE \ubc31\uc5d4\ub4dc\uc758 \ubc31\uc5d4\ub4dc \uc544\uc774\ub514
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=\ub514\ubc84\uae45\ud560 \ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\uc758 \uae30\ubcf8 DN
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=\ub514\ubc84\uae45\ud560 \ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\uc758 \uc774\ub984
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=JE \ub370\uc774\ud130\ub97c \uc801\uc808\ud55c \uc720\ud615\uc73c\ub85c \ud574\ub3c5\ud558\uc9c0 \ub9c8\uc2ed\uc2dc\uc624.
INFO_BACKEND_DEBUG_BACKEND_ID_1331=\ub514\ubc84\uae45\ud560 JE \ubc31\uc5d4\ub4dc\uc758 \ubc31\uc5d4\ub4dc \uc544\uc774\ub514
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=\ub514\ubc84\uae45\ud560 \ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\uc758 \uae30\ubcf8 DN
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=\ub514\ubc84\uae45\ud560 \ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\uc758 \uc774\ub984
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=JE \ub370\uc774\ud130\ub97c \uc801\uc808\ud55c \uc720\ud615\uc73c\ub85c \ud574\ub3c5\ud558\uc9c0 \ub9c8\uc2ed\uc2dc\uc624.
ERR_DBTEST_DECODE_FAIL_1335=\ub370\uc774\ud130\ub97c \ud574\ub3c5\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=\ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\uc758 \uc0c9\uc778 \uc0c1\ud0dc\ub97c \ub098\uc5f4\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=\ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\uc5d0 \ub300\ud55c \ube44\uad50 \uc5f0\uc0b0\uc790\ub97c \uc0ac\uc6a9\ud558\uc5ec \uc81c\uacf5\ub41c \uac12\ubcf4\ub2e4 \uc55e\uc5d0 \uc788\uc5b4\uc57c \ud560 \ud0a4\ub97c \uac00\uc9c4 \ub808\ucf54\ub4dc\ub9cc \ud45c\uc2dc\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=\ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\uc5d0 \ub300\ud55c \ube44\uad50 \uc5f0\uc0b0\uc790\ub97c \uc0ac\uc6a9\ud558\uc5ec \uc81c\uacf5\ub41c \uac12\ubcf4\ub2e4 \ub4a4\uc5d0 \uc788\uc5b4\uc57c \ud560 \ud0a4\ub97c \uac00\uc9c4 \ub808\ucf54\ub4dc\ub9cc \ud45c\uc2dc\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=\ub370\uc774\ud130\uac00 \uc81c\uacf5\ub41c \uac12\ubcf4\ub2e4 \ud06c\uc9c0 \uc54a\uc740 \ub808\ucf54\ub4dc\ub9cc \ud45c\uc2dc\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=\ub370\uc774\ud130\uac00 \uc81c\uacf5\ub41c \uac12\ubcf4\ub2e4 \uc791\uc9c0 \uc54a\uc740 \ub808\ucf54\ub4dc\ub9cc \ud45c\uc2dc\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=\ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\uc758 \uc0c9\uc778 \uc0c1\ud0dc\ub97c \ub098\uc5f4\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=\ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\uc5d0 \ub300\ud55c \ube44\uad50 \uc5f0\uc0b0\uc790\ub97c \uc0ac\uc6a9\ud558\uc5ec \uc81c\uacf5\ub41c \uac12\ubcf4\ub2e4 \uc55e\uc5d0 \uc788\uc5b4\uc57c \ud560 \ud0a4\ub97c \uac00\uc9c4 \ub808\ucf54\ub4dc\ub9cc \ud45c\uc2dc\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=\ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\uc5d0 \ub300\ud55c \ube44\uad50 \uc5f0\uc0b0\uc790\ub97c \uc0ac\uc6a9\ud558\uc5ec \uc81c\uacf5\ub41c \uac12\ubcf4\ub2e4 \ub4a4\uc5d0 \uc788\uc5b4\uc57c \ud560 \ud0a4\ub97c \uac00\uc9c4 \ub808\ucf54\ub4dc\ub9cc \ud45c\uc2dc\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=\ub370\uc774\ud130\uac00 \uc81c\uacf5\ub41c \uac12\ubcf4\ub2e4 \ud06c\uc9c0 \uc54a\uc740 \ub808\ucf54\ub4dc\ub9cc \ud45c\uc2dc\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=\ub370\uc774\ud130\uac00 \uc81c\uacf5\ub41c \uac12\ubcf4\ub2e4 \uc791\uc9c0 \uc54a\uc740 \ub808\ucf54\ub4dc\ub9cc \ud45c\uc2dc\ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=\ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\uc5d0 \ub300\ud55c \ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\ub97c \ub098\uc5f4\ud569\ub2c8\ub2e4.
INFO_LABEL_DBTEST_BACKEND_ID_1342=\ubc31\uc5d4\ub4dc \uc544\uc774\ub514
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=\ubc31\uc5d4\ub4dc \uc544\uc774\ub514
INFO_LABEL_DBTEST_DB_DIRECTORY_1343=\ub370\uc774\ud130\ubca0\uc774\uc2a4 \ub514\ub809\ud1a0\ub9ac
INFO_LABEL_DBTEST_BASE_DN_1344=\uae30\ubcf8 DN
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=\uae30\ubcf8 DN
INFO_LABEL_DBTEST_JE_DATABASE_PREFIX_1345=JE \ub370\uc774\ud130\ubca0\uc774\uc2a4 \uc811\ub450\uc5b4
INFO_LABEL_DBTEST_ENTRY_COUNT_1346=\ud56d\ubaa9 \uac1c\uc218
ERR_DBTEST_NO_BACKENDS_FOR_ID_1347=\uc694\uccad\ud55c \ubc31\uc5d4\ub4dc \uc544\uc774\ub514 %s\uc744(\ub97c) \uac00\uc9c4 \ub514\ub809\ud1a0\ub9ac \uc11c\ubc84 \ubc31\uc5d4\ub4dc\uac00 \uad6c\uc131\ub418\uc5b4 \uc788\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4.
ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=\uc694\uccad\ud55c \uae30\ubcf8 DN %s\uc744(\ub97c) \uac00\uc9c4 \ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\uac00 \ubc31\uc5d4\ub4dc %s\uc5d0 \uad6c\uc131\ub418\uc5b4 \uc788\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4.
ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID_1347=\uc694\uccad\ud55c \ubc31\uc5d4\ub4dc \uc544\uc774\ub514 %s\uc744(\ub97c) \uac00\uc9c4 \ub514\ub809\ud1a0\ub9ac \uc11c\ubc84 \ubc31\uc5d4\ub4dc\uac00 \uad6c\uc131\ub418\uc5b4 \uc788\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4.
ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=\uc694\uccad\ud55c \uae30\ubcf8 DN %s\uc744(\ub97c) \uac00\uc9c4 \ud56d\ubaa9 \ucee8\ud14c\uc774\ub108\uac00 \ubc31\uc5d4\ub4dc %s\uc5d0 \uad6c\uc131\ub418\uc5b4 \uc788\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4.
ERR_DBTEST_NO_DATABASE_CONTAINERS_FOR_NAME_1349=\uc694\uccad\ud55c \uc774\ub984 %s\uc744(\ub97c) \uac00\uc9c4 \ub370\uc774\ud130\ubca0\uc774\uc2a4 \ucee8\ud14c\uc774\ub108\uac00 \ud56d\ubaa9 \ucee8\ud14c\uc774\ub108 %s \ubc0f \ubc31\uc5d4\ub4dc %s\uc5d0 \uc5c6\uc2b5\ub2c8\ub2e4.
ERR_DBTEST_ERROR_INITIALIZING_BACKEND_1350=JE \ubc31\uc5d4\ub4dc %s\uc744(\ub97c) \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc608\uae30\uce58 \uc54a\uc740 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_DBTEST_ERROR_READING_DATABASE_1351=\ub370\uc774\ud130\ubca0\uc774\uc2a4\uc5d0\uc11c \ub808\ucf54\ub4dc\ub97c \uc77d\uac70\ub098 \ud574\ub3c5\ud558\ub294 \ub3d9\uc548 \uc608\uae30\uce58 \uc54a\uc740 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_DBTEST_DECODE_BASE_DN_1352=\uae30\ubcf8 DN \ubb38\uc790\uc5f4 \"%s\"\uc744(\ub97c) \uc720\ud6a8\ud55c \uace0\uc720 \uc774\ub984\uc73c\ub85c \ud574\ub3c5\ud560 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4: %s
ERR_BACKEND_DEBUG_DECODE_BASE_DN_1352=\uae30\ubcf8 DN \ubb38\uc790\uc5f4 \"%s\"\uc744(\ub97c) \uc720\ud6a8\ud55c \uace0\uc720 \uc774\ub984\uc73c\ub85c \ud574\ub3c5\ud560 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4: %s
INFO_LABEL_DBTEST_DATABASE_NAME_1353=\ub370\uc774\ud130\ubca0\uc774\uc2a4 \uc774\ub984
INFO_LABEL_DBTEST_DATABASE_TYPE_1354=\ub370\uc774\ud130\ubca0\uc774\uc2a4 \uc720\ud615
INFO_LABEL_DBTEST_JE_DATABASE_NAME_1355=JE \ub370\uc774\ud130\ubca0\uc774\uc2a4 \uc774\ub984
INFO_LABEL_DBTEST_JE_RECORD_COUNT_1356=\ub808\ucf54\ub4dc \uac1c\uc218
INFO_LABEL_DBTEST_INDEX_NAME_1357=\uc0c9\uc778 \uc774\ub984
INFO_LABEL_DBTEST_INDEX_TYPE_1358=\uc0c9\uc778 \uc720\ud615
INFO_LABEL_DBTEST_INDEX_STATUS_1359=\uc0c9\uc778 \uc0c1\ud0dc
INFO_LABEL_DBTEST_RECORD_COUNT_1356=\ub808\ucf54\ub4dc \uac1c\uc218
INFO_LABEL_BACKEND_DEBUG_INDEX_NAME_1357=\uc0c9\uc778 \uc774\ub984
INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE_1358=\uc0c9\uc778 \uc720\ud615
INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS_1359=\uc0c9\uc778 \uc0c1\ud0dc
INFO_LABEL_DBTEST_KEY_1360=\ud0a4
INFO_LABEL_DBTEST_DATA_1361=\ub370\uc774\ud130
WARN_DBTEST_CANNOT_UNLOCK_BACKEND_1362=\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 \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.
ERR_DBTEST_CANNOT_LOCK_BACKEND_1363=\ubc31\uc5d4\ub4dc %s\uc5d0 \ub300\ud55c \uacf5\uc720 \uc7a0\uae08\uc744 \uac00\uc838\uc624\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s. \uc774\uac83\uc740 \uc77c\ubc18\uc801\uc73c\ub85c \ub2e4\ub978 \ud504\ub85c\uc138\uc2a4\uac00 \uc774 \ubc31\uc5d4\ub4dc\uc5d0 \ub2e8\ub3c5\uc73c\ub85c \uc561\uc138\uc2a4\ud558\uace0 \uc788\uc74c\uc744 \uc758\ubbf8\ud569\ub2c8\ub2e4(\uc608: \ubcf5\uc6d0 \ub610\ub294 LDIF \uac00\uc838\uc624\uae30).
WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND_1362=\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 \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.
ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND_1363=\ubc31\uc5d4\ub4dc %s\uc5d0 \ub300\ud55c \uacf5\uc720 \uc7a0\uae08\uc744 \uac00\uc838\uc624\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s. \uc774\uac83\uc740 \uc77c\ubc18\uc801\uc73c\ub85c \ub2e4\ub978 \ud504\ub85c\uc138\uc2a4\uac00 \uc774 \ubc31\uc5d4\ub4dc\uc5d0 \ub2e8\ub3c5\uc73c\ub85c \uc561\uc138\uc2a4\ud558\uace0 \uc788\uc74c\uc744 \uc758\ubbf8\ud569\ub2c8\ub2e4(\uc608: \ubcf5\uc6d0 \ub610\ub294 LDIF \uac00\uc838\uc624\uae30).
ERR_DBTEST_CANNOT_DECODE_KEY_1364=\ucd5c\uc18c/\ucd5c\ub300 \ud0a4 \uac12 %s\uc744(\ub97c) \ud574\ub3c5\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s. \uc811\ub450\uc5b4\uac00 "0x"\uc778 \uac12\uc740 16\uc9c4\uc218 \uc6d0\uc2dc \ubc14\uc774\ud2b8\ub85c \ud574\ub3c5\ub429\ub2c8\ub2e4. DN2ID \ub370\uc774\ud130\ubca0\uc774\uc2a4\ub97c \ub364\ud504\ud560 \uacbd\uc6b0 \uac12\uc740 \uc720\ud6a8\ud55c \uace0\uc720 \uc774\ub984\uc774\uc5b4\uc57c \ud569\ub2c8\ub2e4. ID2Entry \ub370\uc774\ud130\ubca0\uc774\uc2a4\ub97c \ub364\ud504\ud560 \uacbd\uc6b0 \uac12\uc740 \ud56d\ubaa9 \uc544\uc774\ub514\ub85c \ud574\ub3c5\ub429\ub2c8\ub2e4. \ubaa8\ub4e0 \ub2e4\ub978 \ub370\uc774\ud130\ubca0\uc774\uc2a4\ub97c \ub364\ud504\ud560 \uacbd\uc6b0 \uac12\uc740 \ubb38\uc790\uc5f4\ub85c \ud574\ub3c5\ub429\ub2c8\ub2e4.
INFO_LABEL_DBTEST_ENTRY_1365=\ud56d\ubaa9
INFO_LABEL_DBTEST_ENTRY_ID_1366=\ud56d\ubaa9 \uc544\uc774\ub514
@@ -937,7 +937,7 @@
INFO_LABEL_DBTEST_INDEX_ENTRY_ID_LIST_1370=\ud56d\ubaa9 \uc544\uc774\ub514 \ubaa9\ub85d
INFO_LABEL_DBTEST_VLV_INDEX_LAST_SORT_KEYS_1371=\ub9c8\uc9c0\ub9c9 \uc815\ub82c \ud0a4
ERR_DBTEST_CANNOT_DECODE_SIZE_1372=\ucd5c\uc18c/\ucd5c\ub300 \ub370\uc774\ud130 \ud06c\uae30 %s\uc744(\ub97c) \uc815\uc218\ub85c \uad6c\ubb38 \ubd84\uc11d\ud558\ub294 \ub3d9\uc548 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_DBTEST_MISSING_SUBCOMMAND_1374=\ud558\uc704 \uba85\ub839\uc744 \uc9c0\uc815\ud574\uc57c \ud569\ub2c8\ub2e4.
ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND_1374=\ud558\uc704 \uba85\ub839\uc744 \uc9c0\uc815\ud574\uc57c \ud569\ub2c8\ub2e4.
INFO_CREATERC_USER_DESCRIPTION_1375=\uc11c\ubc84\ub97c \uc2e4\ud589\ud560 \uc0ac\uc6a9\uc790 \uacc4\uc815\uc758 \uc774\ub984
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=\uc11c\ubc84\ub97c \uc2e4\ud589\ud558\ub294 \ub370 \uc0ac\uc6a9\ub420 Java \uc124\uce58 \uacbd\ub85c
INFO_CREATERC_JAVA_ARGS_DESCRIPTION_1377=\uc11c\ubc84\ub97c \uc2e4\ud589\ud560 \ub54c JVM\uc5d0 \uc804\ub2ec\ub420 \uc778\uc218 \uc9d1\ud569
@@ -1179,3 +1179,8 @@
INFO_PROMPT_YES_COMPLETE_ANSWER_1663=\uc608
INFO_PROMPT_NO_COMPLETE_ANSWER_1665=\uc544\ub2c8\uc694
ERR_DSCFG_ERROR_BATCH_FILE_AND_INTERACTIVE_INCOMPATIBLE_1679={%s} \uc778\uc218\ub97c \uc9c0\uc815\ud560 \uacbd\uc6b0 {%s}\ub3c4 \ud568\uaed8 \uc9c0\uc815\ud574\uc57c \ud569\ub2c8\ub2e4.
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=\ubaa8\ub4e0\ubc31\uc5d4\ub4dc\uc5d0 \uc0ac\uc6a9\ub418\ub294 \ub8e8\ud2b8 \ucee8\ud14c\uc774\ub108\ub97c \ub098\uc5f4\ud569\ub2c8\ub2e4
ERR_BACKEND_TOOL_ERROR_READING_TREE_1866=\uc0c9\uc778 \uc5d0\uc11c \ub808\ucf54\ub4dc\ub97c \uc77d\uac70\ub098 \ud574\ub3c5\ud558\ub294 \ub3d9\uc548 \uc608\uae30\uce58 \uc54a\uc740 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND_1865=\ubc31\uc5d4\ub4dc %s\uc744(\ub97c) \ucd08\uae30\ud654\ud558\ub294 \ub3d9\uc548 \uc608\uae30\uce58 \uc54a\uc740 \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4: %s
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_1868=\uc694\uccad\ud55c \uc774\ub984 %s\uc744(\ub97c) \uac00\uc9c4 \uc0c9\uc778 \uac00 \ud56d\ubaa9 \ucee8\ud14c\uc774\ub108 %s \ubc0f \ubc31\uc5d4\ub4dc %s\uc5d0 \uc5c6\uc2b5\ub2c8\ub2e4.
INFO_DESCRIPTION_BACKEND_TOOL_1893=\uc774 \uc720\ud2f8\ub9ac\ud2f0\ub97c \uc0ac\uc6a9\ud558\uc5ec\ubc31\uc5d4\ub4dc\ub97c \ub514\ubc84\uae45\ud560 \uc218 \uc788\uc2b5\ub2c8\ub2e4

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

@@ -84,7 +84,7 @@
INFO_LDIFSEARCH_DESCRIPTION_OVERWRITE_EXISTING_421=Jakikolwiek istniej\u0105cy plik zostanie nadpisany zamiast do\u0142\u0105czania do niego
INFO_STOPDS_DESCRIPTION_SASLOPTIONS_381=Opcje SASL po\u0142\u0105czenia
INFO_LDIFDIFF_DESCRIPTION_IGNORE_ATTRS_1612=Plik zawieraj\u0105cy list\u0119 atrybut\u00f3w ignorowanych przy obliczaniu r\u00f3\u017cnicy
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=ID zaplecza JE do debugowania
INFO_BACKEND_DEBUG_BACKEND_ID_1331=ID zaplecza JE do debugowania
INFO_DESCRIPTION_VLV_878=U\u017cyj wirtualnej kontroli widoku listy do odebrania podanej strony wynik\u00f3w
INFO_LDIFDIFF_DESCRIPTION_SOURCE_LDIF_443=Plik LDIF do u\u017cycia jako \u017ar\u00f3d\u0142o danych
INFO_DESCRIPTION_NO_PROP_FILE_1462=Nie zostanie u\u017cyty \u017caden plik z domy\u015blnymi argumentami komendy wiersza polece\u0144
@@ -139,7 +139,7 @@
INFO_STOPDS_DESCRIPTION_BINDPW_379=Has\u0142o do po\u0142\u0105czenia z serwerem
INFO_LDIFEXPORT_DESCRIPTION_APPEND_TO_LDIF_34=Do\u0142\u0105cz do istniej\u0105cego pliku LDIF zamiast nadpisywania go
INFO_SEARCH_DESCRIPTION_TIME_LIMIT_133=Maksymalny czas w sekundach przeznaczony na operacj\u0119 szukania
INFO_LABEL_DBTEST_BASE_DN_1344=Podstawowy DN
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=Podstawowy DN
INFO_INSTALLDS_POPULATE_OPTION_GENERATE_SAMPLE_758=\u0141aduj wygenerowane automatycznie przykladowe dane
INFO_DESCRIPTION_TASK_FAILED_DEPENDENCY_ACTION_1472=Akcja jak\u0105 wykona to zadanie, je\u017celi jedno z zada\u0144 zale\u017cnych nie powiedzie si\u0119.  Warto\u015b\u0107 musi by\u0107 jednym z %s. Je\u015bli nie podano, u\u017cyta zostanie warto\u015b\u0107 domy\u015blna %s
ERR_ERROR_PARSING_ARGS_17=Wyst\u0105pi\u0142 b\u0142\u0105d podczas przetwarzania argument\u00f3w wiersza polece\u0144:  %s
@@ -167,7 +167,7 @@
INFO_LDIFIMPORT_DESCRIPTION_CLEAR_BACKEND_1251=Usu\u0144 wszystkie wpisy wszystkich bazowych DN w zapleczu przed importowaniem
INFO_INSTALLDS_PROMPT_CONFIRM_ROOT_PASSWORD_515=Prosz\u0119 ponownie wprowadzi\u0107 has\u0142o dla potwierdzenia:
INFO_DESCRIPTION_ASSERTION_FILTER_342=U\u017cyj kontroli za\u0142o\u017ce\u0144 LDAP za pomoc\u0105 podanego filtra
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=Poka\u017c tylko te rekordy, kt\u00f3rych warto\u015b\u0107 jest nie mniejsza ni\u017c podana warto\u015b\u0107
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=Poka\u017c tylko te rekordy, kt\u00f3rych warto\u015b\u0107 jest nie mniejsza ni\u017c podana warto\u015b\u0107
INFO_LDIFSEARCH_DESCRIPTION_BASEDN_415=Bazowa DN do wyszukania  Wiele bazowych DN mo\u017ce zosta\u0107 wyszczeg\u00f3lnionych poprzez podanie opcji wiele razy.  Je\u015bli nie podano bazowej DN, wtedy g\u0142\u00f3wna DSE zostanie u\u017cyta
INFO_LDAPMODIFY_TOOL_DESCRIPTION_691=To narz\u0119dzie mo\u017ce by\u0107 u\u017cyte do przeprowadzenia operacji modyfikacji, dodania, usuni\u0119cia LDAP i modyfikacji DN na Directory Server
INFO_INSTALLDS_DESCRIPTION_ENABLE_STARTTLS_1397=W\u0142\u0105cz StartTLS aby zapewni\u0107 bezpieczn\u0105 komunikacj\u0119 z serwerem u\u017cywaj\u0105c portu LDAP
@@ -189,14 +189,14 @@
INFO_DESCRIPTION_CONTINUE_ON_ERROR_124=Kontynuuj prztwarzanie nawet je\u015bli wyst\u0105pi\u0142y b\u0142\u0119dy
ERR_LDIFIMPORT_ERROR_DURING_IMPORT_96=Wyst\u0105pi\u0142 b\u0142\u0105d podczas pr\u00f3by przetworzenia importu LDIF:  %s
INFO_INSTALLDS_DESCRIPTION_ADMINCONNECTORPORT_1619=Port na kt\u00f3rym Administrator Connector powinien nas\u0142uchiwa\u0107 w celu komunikacji
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=Nie pr\u00f3buj dekodowa\u0107 danych JE do ich odpowiednich typ\u00f3w
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=Nie pr\u00f3buj dekodowa\u0107 danych JE do ich odpowiednich typ\u00f3w
INFO_LDIFEXPORT_DESCRIPTION_EXCLUDE_FILTER_40=Filtr identyfikuj\u0105cy wpisy wy\u0142\u0105czone z eksportu do LDIF
INFO_DESCRIPTION_PSEARCH_INFO_355=U\u017cyj kontroli uporczywego szukania
INFO_PWPSTATE_DESCRIPTION_TSFILE_1108=\u015acie\u017cka sk\u0142adu zaufania certyfikatu
INFO_TASK_TOOL_TASK_SUCESSFULL_1608=%s zadanie %s zako\u0144czono pomy\u015blnie
INFO_LDIFIMPORT_DESCRIPTION_IS_COMPRESSED_80=Plik LDIF jest skompresowany
ERR_TOOL_RESULT_CODE_810=Kod Rezultatu: %d (%s)
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=Poka\u017c tylko te rekordy z kluczami, kt\u00f3re powinny by\u0107 uporz\u0105dkowane za podan\u0105 warto\u015bci\u0105 u\u017cywaj\u0105c komparatora dla kontenera bazy danych
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=Poka\u017c tylko te rekordy z kluczami, kt\u00f3re powinny by\u0107 uporz\u0105dkowane za podan\u0105 warto\u015bci\u0105 u\u017cywaj\u0105c komparatora dla kontenera bazy danych
ERR_PWPSTATE_CANNOT_CONNECT_1189=ERROR:  Cannot establish a connection to the Directory Server %s.  Verify that the server is running and that the provided credentials are valid.  Szczeg\u00f3\u0142y: %s
INFO_STOPDS_DESCRIPTION_PORT_375=Numer portu administracyjnego serwera us\u0142ug katalogowych
INFO_INSTALLDS_DESCRIPTION_LDAPSPORT_1398=Port na kt\u00f3rym Directory Serwer powinien nas\u0142uchiwa\u0107 komunikacji LDAPS  Port LDAPS b\u0119dzie skonfigurowany i SSL zostanie w\u0142\u0105czony tylko je\u017celi ten argument jest wyra\u017anie okre\u015blony
@@ -211,7 +211,7 @@
INFO_RESTOREDB_DESCRIPTION_BACKUP_DIR_293=\u015acie\u017cka do katalogu zawieraj\u0105cego plik(i) backupu
INFO_DESCRIPTION_PWPSTATE_GET_GRACE_LOGIN_USE_TIMES_1146=Wy\u015bwietl ilo\u015b\u0107 \u0142askawych logowa\u0144 (grace login) wykorzystanych przez u\u017cytkownika
INFO_LDAPSEARCH_TOOL_DESCRIPTION_693=To narz\u0119dzie mo\u017ce by\u0107 u\u017cyte do przeprowadzenia operacji szukania LDAP na Directory Server
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=Poka\u017c tylko te rekordy z kluczami, kt\u00f3re powinny by\u0107 uporz\u0105dkowane przed podan\u0105 warto\u015bci\u0105 u\u017cywaj\u0105c komparatora dla kontenera bazy danych
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=Poka\u017c tylko te rekordy z kluczami, kt\u00f3re powinny by\u0107 uporz\u0105dkowane przed podan\u0105 warto\u015bci\u0105 u\u017cywaj\u0105c komparatora dla kontenera bazy danych
INFO_INSTALLDS_DESCRIPTION_BASEDN_490=Bazowa DN informacji o u\u017cytkownikach w Directory Server.  Wiele bazowych DN mo\u017ce zosta\u0107 wyszczeg\u00f3lnionych poprzez podanie opcji wiele razy.
INFO_LDIFIMPORT_DESCRIPTION_EXCLUDE_BRANCH_73=Bazowa DN ga\u0142\u0119zi, kt\u00f3ra ma by\u0107 pomini\u0119ta podczas importu z LDIF
INFO_CREATERC_JAVA_ARGS_DESCRIPTION_1377=Zbi\u00f3r argument\u00f3w, kt\u00f3re powinny by\u0107 przekazane JVM podczas uruchamiania serwera
@@ -272,7 +272,7 @@
INFO_LISTBACKENDS_DESCRIPTION_BASE_DN_727=Bazowy DN dla kt\u00f3rego nale\u017cy wy\u015bwietli\u0107 ID zapleczy
INFO_STOPDS_DESCRIPTION_TSPW_390=PIN sk\u0142adu zaufania certyfikatu
INFO_STOPDS_DESCRIPTION_STOP_REASON_383=Pow\u00f3d dla kt\u00f3rego serwer jest zatrzymywany lub restartowany
INFO_LABEL_DBTEST_BACKEND_ID_1342=ID Zaplecza
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=ID Zaplecza
INFO_LDIFIMPORT_DESCRIPTION_BACKEND_ID_72=ID zaplecza do importu
INFO_DESCRIPTION_PWPSTATE_GET_SECONDS_UNTIL_PASSWORD_EXP_1129=Wy\u015bwietl okres czasu w sekundach do momentu gdy wyga\u015bnie has\u0142o u\u017cytkownika
INFO_CONFIGDS_TOOL_DESCRIPTION_684=To narz\u0119dzie mo\u017ce by\u0107 u\u017cyte do okre\u015blenia bazowej konfiguracji dla Directory Server
@@ -307,7 +307,7 @@
INFO_INSTALLDS_PROMPT_KEYSTORE_PASSWORD_1385=PIN sk\u0142adu klucza:
INFO_PWPSTATE_DESCRIPTION_BINDPWFILE_1101=\u015acie\u017cka pliku zawieraj\u0105cego has\u0142o do po\u0142\u0105czenia z serwerem
INFO_DELETE_DESCRIPTION_DELETE_SUBTREE_129=Usu\u0144 podany wpis i wszystkie wpisy poni\u017cej niego
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=Poka\u017c tylko te rekordy, kt\u00f3rych warto\u015b\u0107 jest nie wi\u0119ksza ni\u017c podana warto\u015b\u0107
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=Poka\u017c tylko te rekordy, kt\u00f3rych warto\u015b\u0107 jest nie wi\u0119ksza ni\u017c podana warto\u015b\u0107
INFO_DESCRIPTION_PWPSTATE_CLEAR_ACCOUNT_DISABLED_STATE_1117=Wyczy\u015b\u0107 informacje na temat zablokowania z konta u\u017cytkownika
INFO_ENCPW_DESCRIPTION_AUTHPW_369=U\u017cyj sk\u0142adni has\u0142a autentykacji zamiast sk\u0142adni has\u0142a u\u017cytkownika
INFO_DESCRIPTION_USE_PWP_CONTROL_411=U\u017cyj polityki kontroli \u017c\u0105dania has\u0142a
@@ -324,7 +324,7 @@
INFO_LDIFIMPORT_DESCRIPTION_EXCLUDE_FILTER_77=Filtr identyfikuj\u0105cy wpisy wy\u0142\u0105czone z importu z LDIF
INFO_DESCRIPTION_PWPSTATE_GET_PASSWORD_HISTORY_1202=Wy\u015bwietl warto\u015bci stanu historii hase\u0142 dla u\u017cytkownika
ERR_CANNOT_INITIALIZE_ARGS_16=Nieoczekiwany b\u0142\u0105d wyst\u0105pi\u0142 podczas pr\u00f3by inicjalizacji argument\u00f3w wiersza polece\u0144:  %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=Wypisz status indeks\u00f3w w kontenerze wpis\u00f3w
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=Wypisz status indeks\u00f3w w kontenerze wpis\u00f3w
INFO_VERIFYINDEX_TOOL_DESCRIPTION_700=To narz\u0119dzie mo\u017ce by\u0107 u\u017cyte do sprawdzenia czy dane indeks\u00f3w s\u0105 sp\u00f3jne w obr\u0119bie zaplecza opartego o Berkeley DB Java Edition
INFO_INSTALLDS_DESCRIPTION_ROOTPWFILE_497=\u015acie\u017cka pliku zawieraj\u0105cego has\u0142o dla pocz\u0105tkowego u\u017cytkownia root dla Directory Server
INFO_PWPSTATE_DESCRIPTION_PORT_1096=Port administracyjny Directory Servera
@@ -345,7 +345,7 @@
ERR_INSTALLDS_NO_ROOT_PASSWORD_513=B\u0141\u0104D:  Nie podano has\u0142a dla pocz\u0105tkowego u\u017cytkownika root.  Podczas przeprowadzania instalacji nieinteraktywnej, musi ono zosta\u0107 podane u\u017cywaj\u0105c argumentu %s lub %s
INFO_INSTALLDS_CONFIRM_INSTALL_1604=Ustaw serwer z powy\u017cszymi parametrami
INFO_DESCRIPTION_TASK_ERROR_NOTIFICATION_1470=Adres email odbiorcy informowanego o b\u0142\u0119dach w wyst\u0119puj\u0105cych przy uruchomieniu tego zadania.  Ta opcja mo\u017ce by\u0107 wybrana wi\u0119cej ni\u017c raz
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=Nazwa kontenera bazy danych do debugowania
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=Nazwa kontenera bazy danych do debugowania
INFO_INSTALLDS_DESCRIPTION_USE_SELF_SIGNED_1399=Wygeneruj podpisany przez siebie certyfikat, kt\u00f3ry serwer powinien u\u017cy\u0107 podczas akceptowania po\u0142\u0105cze\u0144 SSL lub podczas negocjacji StartTLS
INFO_DESCRIPTION_KEYSTOREPATH_117=\u015acie\u017cka sk\u0142adu klucza certyfikatu
INFO_VERIFYINDEX_DESCRIPTION_VERIFY_CLEAN_209=Okre\u015bla, \u017ce pojedy\u0144czy indeks powinien by\u0107 zweryfikowany pod wzgl\u0119dem czysto\u015bci.  Indeks jest czysty je\u015bli ka\u017cda warto\u015b\u0107 indeksu wskazuje tylko wpisy zawieraj\u0105ce t\u0105 wartos\u0107  Tylko jeden indeks w danym momencie mo\u017ce by\u0107 weryfikowany w ten spos\u00f3b
@@ -367,7 +367,7 @@
INFO_DESCRIPTION_ENCODING_115=U\u017cyj nast\u0119puj\u0105cego zestawu znak\u00f3w dla wejscia wiersza polece\u0144
INFO_DESCRIPTION_SORT_ORDER_876=Sortuj wyniki u\u017cywaj\u0105c podanej kolejno\u015bci sortowania
INFO_LDIFSEARCH_DESCRIPTION_OUTPUT_FILE_420=\u015acie\u017cka pliku, do kt\u00f3rego zostan\u0105 zapisane pasuj\u0105ce wpisy.  Je\u015bli nie podano, wtedy dane zostan\u0105 wypisane na standardowym wyj\u015bciu
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=Wypisz kontenery wpis\u00f3w dla g\u0142\u00f3wnych kontener\u00f3w
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=Wypisz kontenery wpis\u00f3w dla g\u0142\u00f3wnych kontener\u00f3w
INFO_STOPDS_DESCRIPTION_KSPWFILE_388=Plik PIN sk\u0142adu klucza certyfikatu
INFO_INSTALLDS_DO_NOT_START_SERVER_1601=Nie uruchamiaj Serwera po zako\u0144czeniu konfiguracji
INFO_LDIFIMPORT_DESCRIPTION_LDIF_FILE_69=\u015acie\u017cka do pliku LDIF, kt\u00f3ry ma by\u0107 zaimportowany
@@ -385,7 +385,7 @@
ERR_INSTALLDS_PASSWORDS_DONT_MATCH_530=B\u0141\u0104D:  Podane warto\u015bci hase\u0142 nie zgadzaj\u0105 si\u0119
INFO_INSTALLDS_DESCRIPTION_REJECTED_FILE_1479=Zapisz odrzucone wpisy do podanego pliku
INFO_DESCRIPTION_TRUSTSTOREPATH_118=\u015acie\u017cka sk\u0142adu zaufania certyfikatu
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=Bazowa DN kontenera wpis\u00f3w do debugowania
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=Bazowa DN kontenera wpis\u00f3w do debugowania
ERR_INSTALLDS_INVALID_DN_RESPONSE_527=B\u0141\u0104D:  Podana odpowied\u017a nie mog\u0142a by\u0107 zinterpretowana jako DN LDAP
INFO_PWPSTATE_DESCRIPTION_TSPWFILE_1110=Plik zawieraj\u0105cy PIN sk\u0142adu zaufania certyfikatu
INFO_LDIFIMPORT_DESCRIPTION_OVERWRITE_79=Nadpisz istniej\u0105cy plik zawieraj\u0105cy odrzucone wpisy i/lub pomi\u0144 plik zamiast do\u0142\u0105czania do niego
@@ -395,3 +395,5 @@
INFO_CONFIGURE_WINDOWS_SERVICE_DESCRIPTION_SHOWUSAGE_817=Wy\u015bwietl informacje o u\u017cyciu
INFO_VERIFYINDEX_DESCRIPTION_COUNT_ERRORS_1199=Licz ilo\u015b\u0107 b\u0142\u0119d\u00f3w jakie pojawi\u0142y si\u0119 podczas weryfikacji i zwr\u00f3\u0107 j\u0105 jako kod wyj\u015bcia (warto\u015bci > 255 b\u0119d\u0105 obci\u0119te do 255 z powodu ogranicze\u0144 kodu wyj\u015bcia)
INFO_LDAPPWMOD_TOOL_DESCRIPTION_692=To narz\u0119dzie mo\u017ce by\u0107 u\u017cyte do przeprowadzenia operacji modyfikacji has\u0142a LDAP na Directory Server
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=Wypsiz g\u0142\u00f3wne kontenery u\u017cywane przez wszystkie zaplecza
INFO_DESCRIPTION_BACKEND_TOOL_1893=To narz\u0119dzie mo\u017ce by\u0107 wykorzystane do debugowania zaplecza

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

@@ -895,41 +895,41 @@
ERR_DSCFG_ERROR_QUIET_AND_INTERACTIVE_INCOMPATIBLE_1326=\u5982\u679c\u6307\u5b9a {%s} \u53c2\u6570\uff0c\u8fd8\u5fc5\u987b\u6307\u5b9a {%s}
INFO_DESCRIPTION_DBTEST_TOOL_1327=\u6b64\u5b9e\u7528\u7a0b\u5e8f\u53ef\u7528\u4e8e\u8c03\u8bd5 JE \u6570\u636e\u5e93
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=\u5217\u51fa\u6240\u6709 JE \u540e\u7aef\u4f7f\u7528\u7684\u6839\u5bb9\u5668
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=\u5217\u51fa\u6839\u5bb9\u5668\u7684\u6761\u76ee\u5bb9\u5668
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=\u5217\u51fa\u6839\u5bb9\u5668\u7684\u6761\u76ee\u5bb9\u5668
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=\u8f6c\u50a8\u6570\u636e\u5e93\u5bb9\u5668\u4e2d\u7684\u8bb0\u5f55
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=\u8981\u8c03\u8bd5\u7684 JE \u540e\u7aef\u7684 ID
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=\u8981\u8c03\u8bd5\u7684\u6761\u76ee\u5bb9\u5668\u7684\u57fa DN
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=\u8981\u8c03\u8bd5\u7684\u6570\u636e\u5e93\u5bb9\u5668\u7684\u540d\u79f0
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=\u4e0d\u8981\u5c1d\u8bd5\u5c06 JE \u6570\u636e\u89e3\u7801\u4e3a\u5176\u76f8\u5e94\u7c7b\u578b
INFO_BACKEND_DEBUG_BACKEND_ID_1331=\u8981\u8c03\u8bd5\u7684 JE \u540e\u7aef\u7684 ID
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=\u8981\u8c03\u8bd5\u7684\u6761\u76ee\u5bb9\u5668\u7684\u57fa DN
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=\u8981\u8c03\u8bd5\u7684\u6570\u636e\u5e93\u5bb9\u5668\u7684\u540d\u79f0
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=\u4e0d\u8981\u5c1d\u8bd5\u5c06 JE \u6570\u636e\u89e3\u7801\u4e3a\u5176\u76f8\u5e94\u7c7b\u578b
ERR_DBTEST_DECODE_FAIL_1335=\u5728\u5bf9\u6570\u636e\u8fdb\u884c\u89e3\u7801\u65f6\u51fa\u73b0\u9519\u8bef: %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=\u5217\u51fa\u6761\u76ee\u5bb9\u5668\u4e2d\u7684\u7d22\u5f15\u72b6\u6001
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=\u4ec5\u663e\u793a\u952e\u5e94\u6392\u5728\u63d0\u4f9b\u7684\u503c\u524d\u9762\u7684\u8bb0\u5f55\uff08\u4f7f\u7528\u6570\u636e\u5e93\u5bb9\u5668\u7684\u6bd4\u8f83\u5668\uff09
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=\u4ec5\u663e\u793a\u952e\u5e94\u6392\u5728\u63d0\u4f9b\u7684\u503c\u540e\u9762\u7684\u8bb0\u5f55\uff08\u4f7f\u7528\u6570\u636e\u5e93\u5bb9\u5668\u7684\u6bd4\u8f83\u5668\uff09
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=\u4ec5\u663e\u793a\u6570\u636e\u4e0d\u5927\u4e8e\u63d0\u4f9b\u7684\u503c\u7684\u8bb0\u5f55
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=\u4ec5\u663e\u793a\u6570\u636e\u4e0d\u5c0f\u4e8e\u63d0\u4f9b\u7684\u503c\u7684\u8bb0\u5f55
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=\u5217\u51fa\u6761\u76ee\u5bb9\u5668\u4e2d\u7684\u7d22\u5f15\u72b6\u6001
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=\u4ec5\u663e\u793a\u952e\u5e94\u6392\u5728\u63d0\u4f9b\u7684\u503c\u524d\u9762\u7684\u8bb0\u5f55\uff08\u4f7f\u7528\u6570\u636e\u5e93\u5bb9\u5668\u7684\u6bd4\u8f83\u5668\uff09
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=\u4ec5\u663e\u793a\u952e\u5e94\u6392\u5728\u63d0\u4f9b\u7684\u503c\u540e\u9762\u7684\u8bb0\u5f55\uff08\u4f7f\u7528\u6570\u636e\u5e93\u5bb9\u5668\u7684\u6bd4\u8f83\u5668\uff09
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=\u4ec5\u663e\u793a\u6570\u636e\u4e0d\u5927\u4e8e\u63d0\u4f9b\u7684\u503c\u7684\u8bb0\u5f55
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=\u4ec5\u663e\u793a\u6570\u636e\u4e0d\u5c0f\u4e8e\u63d0\u4f9b\u7684\u503c\u7684\u8bb0\u5f55
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=\u5217\u51fa\u6761\u76ee\u5bb9\u5668\u7684\u6570\u636e\u5e93\u5bb9\u5668
INFO_LABEL_DBTEST_BACKEND_ID_1342=\u540e\u7aef ID
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=\u540e\u7aef ID
INFO_LABEL_DBTEST_DB_DIRECTORY_1343=\u6570\u636e\u5e93\u76ee\u5f55
INFO_LABEL_DBTEST_BASE_DN_1344=\u57fa DN
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=\u57fa DN
INFO_LABEL_DBTEST_JE_DATABASE_PREFIX_1345=JE \u6570\u636e\u5e93\u524d\u7f00
INFO_LABEL_DBTEST_ENTRY_COUNT_1346=\u6761\u76ee\u8ba1\u6570
ERR_DBTEST_NO_BACKENDS_FOR_ID_1347=\u6ca1\u6709 Directory Server \u540e\u7aef\u4f7f\u7528\u8bf7\u6c42\u7684\u540e\u7aef ID %s \u8fdb\u884c\u914d\u7f6e
ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=\u6ca1\u6709\u4f7f\u7528\u540e\u7aef %2$s \u4e2d\u8bf7\u6c42\u7684\u57fa DN %1$s \u914d\u7f6e\u7684\u6761\u76ee\u5bb9\u5668
ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID_1347=\u6ca1\u6709 Directory Server \u540e\u7aef\u4f7f\u7528\u8bf7\u6c42\u7684\u540e\u7aef ID %s \u8fdb\u884c\u914d\u7f6e
ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=\u6ca1\u6709\u4f7f\u7528\u540e\u7aef %2$s \u4e2d\u8bf7\u6c42\u7684\u57fa DN %1$s \u914d\u7f6e\u7684\u6761\u76ee\u5bb9\u5668
ERR_DBTEST_NO_DATABASE_CONTAINERS_FOR_NAME_1349=\u4e0d\u5b58\u5728\u4f7f\u7528\u6761\u76ee\u5bb9\u5668 %2$s \u548c\u540e\u7aef %3$s \u4e2d\u8bf7\u6c42\u7684\u540d\u79f0 %1$s \u7684\u6570\u636e\u5e93\u5bb9\u5668
ERR_DBTEST_ERROR_INITIALIZING_BACKEND_1350=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316 JE \u540e\u7aef %s \u65f6\u51fa\u73b0\u610f\u5916\u9519\u8bef: %s
ERR_DBTEST_ERROR_READING_DATABASE_1351=\u5728\u5c1d\u8bd5\u4ece\u6570\u636e\u5e93\u8bfb\u53d6\u548c/\u6216\u89e3\u7801\u8bb0\u5f55\u65f6\u51fa\u73b0\u610f\u5916\u9519\u8bef: %s
ERR_DBTEST_DECODE_BASE_DN_1352=\u65e0\u6cd5\u5c06\u57fa DN \u5b57\u7b26\u4e32 "%s" \u89e3\u7801\u4e3a\u6709\u6548\u7684\u6807\u8bc6\u540d: %s
ERR_BACKEND_DEBUG_DECODE_BASE_DN_1352=\u65e0\u6cd5\u5c06\u57fa DN \u5b57\u7b26\u4e32 "%s" \u89e3\u7801\u4e3a\u6709\u6548\u7684\u6807\u8bc6\u540d: %s
INFO_LABEL_DBTEST_DATABASE_NAME_1353=\u6570\u636e\u5e93\u540d\u79f0
INFO_LABEL_DBTEST_DATABASE_TYPE_1354=\u6570\u636e\u5e93\u7c7b\u578b
INFO_LABEL_DBTEST_JE_DATABASE_NAME_1355=JE \u6570\u636e\u5e93\u540d\u79f0
INFO_LABEL_DBTEST_JE_RECORD_COUNT_1356=\u8bb0\u5f55\u8ba1\u6570
INFO_LABEL_DBTEST_INDEX_NAME_1357=\u7d22\u5f15\u540d\u79f0
INFO_LABEL_DBTEST_INDEX_TYPE_1358=\u7d22\u5f15\u7c7b\u578b
INFO_LABEL_DBTEST_INDEX_STATUS_1359=\u7d22\u5f15\u72b6\u6001
INFO_LABEL_DBTEST_RECORD_COUNT_1356=\u8bb0\u5f55\u8ba1\u6570
INFO_LABEL_BACKEND_DEBUG_INDEX_NAME_1357=\u7d22\u5f15\u540d\u79f0
INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE_1358=\u7d22\u5f15\u7c7b\u578b
INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS_1359=\u7d22\u5f15\u72b6\u6001
INFO_LABEL_DBTEST_KEY_1360=\u952e
INFO_LABEL_DBTEST_DATA_1361=\u6570\u636e
WARN_DBTEST_CANNOT_UNLOCK_BACKEND_1362=\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\u8fdb\u7a0b\u9000\u51fa\u65f6\u81ea\u52a8\u6e05\u9664\uff0c\u56e0\u6b64\u5e94\u65e0\u9700\u8fdb\u4e00\u6b65\u64cd\u4f5c
ERR_DBTEST_CANNOT_LOCK_BACKEND_1363=\u5728\u5c1d\u8bd5\u83b7\u53d6\u540e\u7aef %s \u7684\u5171\u4eab\u9501\u5b9a\u65f6\u51fa\u73b0\u9519\u8bef: %s\u3002\u8fd9\u901a\u5e38\u610f\u5473\u7740\u67d0\u4e9b\u5176\u4ed6\u8fdb\u7a0b\u62e5\u6709\u6b64\u540e\u7aef\u7684\u4e92\u65a5\u8bbf\u95ee\u6743\u9650\uff08\u4f8b\u5982\uff0c\u6062\u590d\u6216 LDIF \u5bfc\u5165\uff09
WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND_1362=\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\u8fdb\u7a0b\u9000\u51fa\u65f6\u81ea\u52a8\u6e05\u9664\uff0c\u56e0\u6b64\u5e94\u65e0\u9700\u8fdb\u4e00\u6b65\u64cd\u4f5c
ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND_1363=\u5728\u5c1d\u8bd5\u83b7\u53d6\u540e\u7aef %s \u7684\u5171\u4eab\u9501\u5b9a\u65f6\u51fa\u73b0\u9519\u8bef: %s\u3002\u8fd9\u901a\u5e38\u610f\u5473\u7740\u67d0\u4e9b\u5176\u4ed6\u8fdb\u7a0b\u62e5\u6709\u6b64\u540e\u7aef\u7684\u4e92\u65a5\u8bbf\u95ee\u6743\u9650\uff08\u4f8b\u5982\uff0c\u6062\u590d\u6216 LDIF \u5bfc\u5165\uff09
ERR_DBTEST_CANNOT_DECODE_KEY_1364=\u5728\u89e3\u7801\u6700\u5c0f/\u6700\u5927\u5bc6\u94a5\u503c %s \u65f6\u51fa\u73b0\u9519\u8bef: %s\u3002\u5177\u6709\u524d\u7f00 "0x" \u7684\u503c\u5c06\u88ab\u89e3\u7801\u4e3a\u5341\u516d\u8fdb\u5236\u7684\u539f\u59cb\u5b57\u8282\u3002\u8f6c\u50a8 DN2ID \u6570\u636e\u5e93\u65f6\uff0c\u8be5\u503c\u5fc5\u987b\u4e3a\u6709\u6548\u7684\u6807\u8bc6\u540d\u3002\u8f6c\u50a8 ID2Entry \u6570\u636e\u5e93\u65f6\uff0c\u8be5\u503c\u5c06\u88ab\u89e3\u7801\u4e3a\u6761\u76ee ID\u3002\u8f6c\u50a8\u6240\u6709\u5176\u4ed6\u6570\u636e\u5e93\u65f6\uff0c\u8be5\u503c\u5c06\u88ab\u89e3\u7801\u4e3a\u5b57\u7b26\u4e32
INFO_LABEL_DBTEST_ENTRY_1365=\u6761\u76ee
INFO_LABEL_DBTEST_ENTRY_ID_1366=\u6761\u76ee ID
@@ -939,7 +939,7 @@
INFO_LABEL_DBTEST_INDEX_ENTRY_ID_LIST_1370=\u6761\u76ee ID \u5217\u8868
INFO_LABEL_DBTEST_VLV_INDEX_LAST_SORT_KEYS_1371=\u4e0a\u6b21\u6392\u5e8f\u952e
ERR_DBTEST_CANNOT_DECODE_SIZE_1372=\u5728\u5c06\u6700\u5c0f/\u6700\u5927\u6570\u636e\u5927\u5c0f %s \u89e3\u6790\u4e3a\u6574\u6570\u65f6\u51fa\u73b0\u9519\u8bef: %s
ERR_DBTEST_MISSING_SUBCOMMAND_1374=\u5fc5\u987b\u6307\u5b9a\u4e00\u4e2a\u5b50\u547d\u4ee4
ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND_1374=\u5fc5\u987b\u6307\u5b9a\u4e00\u4e2a\u5b50\u547d\u4ee4
INFO_CREATERC_USER_DESCRIPTION_1375=\u8fd0\u884c\u670d\u52a1\u5668\u65f6\u5e94\u4f7f\u7528\u7684\u7528\u6237\u5e10\u6237\u540d\u79f0
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=\u8fd0\u884c\u670d\u52a1\u5668\u65f6\u5e94\u4f7f\u7528\u7684 Java \u5b89\u88c5\u8def\u5f84
INFO_CREATERC_JAVA_ARGS_DESCRIPTION_1377=\u8fd0\u884c\u670d\u52a1\u5668\u65f6\u5e94\u4f20\u9012\u7ed9 JVM \u7684\u4e00\u7ec4\u53c2\u6570
@@ -1271,10 +1271,14 @@
INFO_DESCRIPTION_REFRESH_PERIOD_1706=\u6307\u5b9a\u6b64\u53c2\u6570\u65f6\uff0c\u72b6\u6001\u547d\u4ee4\u5c06\u5b9a\u671f\u663e\u793a\u5176\u5185\u5bb9\u3002\u7528\u4e8e\u6307\u5b9a\u4e24\u6b21\u72b6\u6001\u663e\u793a\u4e4b\u95f4\u7684\u95f4\u9694\u65f6\u95f4\uff08\u4ee5\u79d2\u4e3a\u5355\u4f4d\uff09
INFO_INSTALLDS_PRINT_EQUIVALENT_COMMAND_LINE_1708=\u6253\u5370\u7b49\u6548\u7684\u975e\u4ea4\u4e92\u547d\u4ee4\u884c
ERR_WINDOWS_SERVICE_ENABLING_ERROR_STARTING_SERVER_1709=\u5df2\u6210\u529f\u914d\u7f6e Windows \u670d\u52a1\uff0c\u4f46\u542f\u52a8\u8be5\u670d\u52a1\u65f6\u51fa\u9519\u3002\u542f\u52a8 Windows \u670d\u52a1\u65f6\u51fa\u73b0\u9519\u8bef\u4ee3\u7801: %d
INFO_DESCRIPTION_DBTEST_STATS_ONLY_1710=\u4e0d\u663e\u793a JE \u6570\u636e\uff0c\u53ea\u663e\u793a\u7edf\u8ba1\u4fe1\u606f
INFO_DESCRIPTION_BACKEND_DEBUG_STATS_ONLY_1710=\u4e0d\u663e\u793a JE \u6570\u636e\uff0c\u53ea\u663e\u793a\u7edf\u8ba1\u4fe1\u606f
INFO_TIMEOUT_PLACEHOLDER_1711={timeout}
INFO_DESCRIPTION_CONNECTION_TIMEOUT_1712=\u5efa\u7acb\u8fde\u63a5\u6240\u80fd\u5360\u7528\u7684\u6700\u5927\u65f6\u95f4\u957f\u5ea6\uff08\u4ee5\u6beb\u79d2\u4e3a\u5355\u4f4d\uff09
ERR_MAKELDIF_CANNOT_WRITE_ENTRY_WITHOUT_DN_1713=\u5c1d\u8bd5\u5411 LDIF \u5199\u5165\u6761\u76ee\u65f6\u51fa\u73b0\u9519\u8bef\uff1a\u65e0\u6cd5\u8ba1\u7b97\u6761\u76ee\u7684 DN\uff08\u627e\u4e0d\u5230 RDN \u5c5e\u6027 %s \u7684\u503c\uff09
ERR_CLIENT_SIDE_TIMEOUT_1714=\u51fa\u73b0\u5ba2\u6237\u7aef\u8d85\u65f6\u3002%n\u5176\u4ed6\u4fe1\u606f: %s
INFO_LABEL_DBTEST_INDEX_UNDEFINED_RECORD_COUNT_1715=\u672a\u5b9a\u4e49

INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=\u5217\u51fa\u6240\u6709\u540e\u7aef\u4f7f\u7528\u7684\u6839\u5bb9\u5668
ERR_BACKEND_TOOL_ERROR_READING_TREE_1866=\u5728\u5c1d\u8bd5\u4ece\u7d22\u5f15\u8bfb\u53d6\u548c/\u6216\u89e3\u7801\u8bb0\u5f55\u65f6\u51fa\u73b0\u610f\u5916\u9519\u8bef: %s
ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND_1865=\u5728\u5c1d\u8bd5\u521d\u59cb\u5316\u540e\u7aef %s \u65f6\u51fa\u73b0\u610f\u5916\u9519\u8bef: %s
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_1868=\u4e0d\u5b58\u5728\u4f7f\u7528\u6761\u76ee\u5bb9\u5668 %2$s \u548c\u540e\u7aef %3$s \u4e2d\u8bf7\u6c42\u7684\u540d\u79f0 %1$s \u7684 \u7d22\u5f15
INFO_DESCRIPTION_BACKEND_TOOL_1893=\u6b64\u5b9e\u7528\u7a0b\u5e8f\u53ef\u7528\u4e8e\u8c03\u8bd5 Pluggable \u540e\u7aef\u7684

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

@@ -893,41 +893,41 @@
ERR_DSCFG_ERROR_QUIET_AND_INTERACTIVE_INCOMPATIBLE_1326=\u82e5\u6307\u5b9a\u4e86 {%s} \u5f15\u6578\uff0c\u5247\u5fc5\u9808\u540c\u6642\u6307\u5b9a {%s}
INFO_DESCRIPTION_DBTEST_TOOL_1327=\u6b64\u516c\u7528\u7a0b\u5f0f\u53ef\u7528\u65bc\u5c0d JE \u8cc7\u6599\u5eab\u9032\u884c\u9664\u932f
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ROOT_CONTAINERS_1328=\u5217\u51fa\u6240\u6709 JE \u5f8c\u7aef\u4f7f\u7528\u7684\u6839\u5bb9\u5668
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_ENTRY_CONTAINERS_1329=\u5217\u51fa\u6839\u5bb9\u5668\u7684\u9805\u76ee\u5bb9\u5668
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_ENTRY_CONTAINERS_1329=\u5217\u51fa\u6839\u5bb9\u5668\u7684\u9805\u76ee\u5bb9\u5668
INFO_DESCRIPTION_DBTEST_SUBCMD_DUMP_DATABASE_CONTAINER_1330=\u50be\u5370\u8cc7\u6599\u5eab\u5bb9\u5668\u4e2d\u7684\u8a18\u9304
INFO_DESCRIPTION_DBTEST_BACKEND_ID_1331=\u8981\u9664\u932f\u4e4b JE \u5f8c\u7aef\u7684\u5f8c\u7aef ID
INFO_DESCRIPTION_DBTEST_BASE_DN_1332=\u8981\u9664\u932f\u4e4b\u9805\u76ee\u5bb9\u5668\u7684\u57fa\u5e95 DN
INFO_DESCRIPTION_DBTEST_DATABASE_NAME_1333=\u8981\u9664\u932f\u4e4b\u8cc7\u6599\u5eab\u5bb9\u5668\u7684\u540d\u7a31
INFO_DESCRIPTION_DBTEST_SKIP_DECODE_1334=\u8acb\u52ff\u5617\u8a66\u5c07 JE \u8cc7\u6599\u89e3\u78bc\u70ba\u5176\u9069\u7576\u7684\u985e\u578b
INFO_BACKEND_DEBUG_BACKEND_ID_1331=\u8981\u9664\u932f\u4e4b JE \u5f8c\u7aef\u7684\u5f8c\u7aef ID
INFO_DESCRIPTION_BACKEND_DEBUG_BASE_DN_1332=\u8981\u9664\u932f\u4e4b\u9805\u76ee\u5bb9\u5668\u7684\u57fa\u5e95 DN
INFO_DESCRIPTION_BACKEND_DEBUG_INDEX_NAME_1333=\u8981\u9664\u932f\u4e4b\u8cc7\u6599\u5eab\u5bb9\u5668\u7684\u540d\u7a31
INFO_DESCRIPTION_BACKEND_DEBUG_SKIP_DECODE_1334=\u8acb\u52ff\u5617\u8a66\u5c07 JE \u8cc7\u6599\u89e3\u78bc\u70ba\u5176\u9069\u7576\u7684\u985e\u578b
ERR_DBTEST_DECODE_FAIL_1335=\u89e3\u78bc\u8cc7\u6599\u6642\u767c\u751f\u932f\u8aa4: %s
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_INDEX_STATUS_1336=\u5217\u51fa\u9805\u76ee\u5bb9\u5668\u4e2d\u7684\u7d22\u5f15\u72c0\u614b
INFO_DESCRIPTION_DBTEST_MAX_KEY_VALUE_1337=\u50c5\u986f\u793a\u91d1\u9470\u61c9\u4ee5\u8cc7\u6599\u5eab\u5bb9\u5668\u7684\u6bd4\u8f03\u5b50\u6392\u5e8f\u5728\u6240\u63d0\u4f9b\u503c\u4e4b\u524d\u7684\u8a18\u9304
INFO_DESCRIPTION_DBTEST_MIN_KEY_VALUE_1338=\u50c5\u986f\u793a\u91d1\u9470\u61c9\u4ee5\u8cc7\u6599\u5eab\u5bb9\u5668\u7684\u6bd4\u8f03\u5b50\u6392\u5e8f\u5728\u6240\u63d0\u4f9b\u503c\u4e4b\u5f8c\u7684\u8a18\u9304
INFO_DESCRIPTION_DBTEST_MAX_DATA_SIZE_1339=\u50c5\u986f\u793a\u5176\u8cc7\u6599\u5c0f\u65bc\u6216\u7b49\u65bc\u6240\u63d0\u4f9b\u503c\u7684\u8a18\u9304
INFO_DESCRIPTION_DBTEST_MIN_DATA_SIZE_1340=\u50c5\u986f\u793a\u5176\u8cc7\u6599\u5927\u65bc\u6216\u7b49\u65bc\u6240\u63d0\u4f9b\u503c\u7684\u8a18\u9304
INFO_DESCRIPTION_BACKEND_DEBUG_SUBCMD_LIST_INDEX_STATUS_1336=\u5217\u51fa\u9805\u76ee\u5bb9\u5668\u4e2d\u7684\u7d22\u5f15\u72c0\u614b
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_KEY_VALUE_1337=\u50c5\u986f\u793a\u91d1\u9470\u61c9\u4ee5\u8cc7\u6599\u5eab\u5bb9\u5668\u7684\u6bd4\u8f03\u5b50\u6392\u5e8f\u5728\u6240\u63d0\u4f9b\u503c\u4e4b\u524d\u7684\u8a18\u9304
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_KEY_VALUE_1338=\u50c5\u986f\u793a\u91d1\u9470\u61c9\u4ee5\u8cc7\u6599\u5eab\u5bb9\u5668\u7684\u6bd4\u8f03\u5b50\u6392\u5e8f\u5728\u6240\u63d0\u4f9b\u503c\u4e4b\u5f8c\u7684\u8a18\u9304
INFO_DESCRIPTION_BACKEND_DEBUG_MAX_DATA_SIZE_1339=\u50c5\u986f\u793a\u5176\u8cc7\u6599\u5c0f\u65bc\u6216\u7b49\u65bc\u6240\u63d0\u4f9b\u503c\u7684\u8a18\u9304
INFO_DESCRIPTION_BACKEND_DEBUG_MIN_DATA_SIZE_1340=\u50c5\u986f\u793a\u5176\u8cc7\u6599\u5927\u65bc\u6216\u7b49\u65bc\u6240\u63d0\u4f9b\u503c\u7684\u8a18\u9304
INFO_DESCRIPTION_DBTEST_SUBCMD_LIST_DATABASE_CONTAINERS_1341=\u5217\u51fa\u9805\u76ee\u5bb9\u5668\u7684\u8cc7\u6599\u5eab\u5bb9\u5668
INFO_LABEL_DBTEST_BACKEND_ID_1342=\u5f8c\u7aef ID
INFO_LABEL_BACKEND_DEBUG_BACKEND_ID_1342=\u5f8c\u7aef ID
INFO_LABEL_DBTEST_DB_DIRECTORY_1343=\u8cc7\u6599\u5eab\u76ee\u9304
INFO_LABEL_DBTEST_BASE_DN_1344=\u57fa\u5e95 DN
INFO_LABEL_BACKEND_DEBUG_BASE_DN_1344=\u57fa\u5e95 DN
INFO_LABEL_DBTEST_JE_DATABASE_PREFIX_1345=JE \u8cc7\u6599\u5eab\u524d\u7db4
INFO_LABEL_DBTEST_ENTRY_COUNT_1346=\u9805\u76ee\u8a08\u6578
ERR_DBTEST_NO_BACKENDS_FOR_ID_1347=\u6c92\u6709\u4efb\u4f55\u76ee\u9304\u4f3a\u670d\u5668\u5f8c\u7aef\u4ee5\u8acb\u6c42\u7684\u5f8c\u7aef ID %s \u9032\u884c\u914d\u7f6e
ERR_DBTEST_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=\u6c92\u6709\u4efb\u4f55\u9805\u76ee\u5bb9\u5668\u4ee5\u5f8c\u7aef %2$s \u4e2d\u8acb\u6c42\u7684\u57fa\u5e95 DN %1$s \u9032\u884c\u914d\u7f6e
ERR_BACKEND_DEBUG_NO_BACKENDS_FOR_ID_1347=\u6c92\u6709\u4efb\u4f55\u76ee\u9304\u4f3a\u670d\u5668\u5f8c\u7aef\u4ee5\u8acb\u6c42\u7684\u5f8c\u7aef ID %s \u9032\u884c\u914d\u7f6e
ERR_BACKEND_DEBUG_NO_ENTRY_CONTAINERS_FOR_BASE_DN_1348=\u6c92\u6709\u4efb\u4f55\u9805\u76ee\u5bb9\u5668\u4ee5\u5f8c\u7aef %2$s \u4e2d\u8acb\u6c42\u7684\u57fa\u5e95 DN %1$s \u9032\u884c\u914d\u7f6e
ERR_DBTEST_NO_DATABASE_CONTAINERS_FOR_NAME_1349=\u9805\u76ee\u5bb9\u5668 %2$s \u8207\u5f8c\u7aef %3$s \u4e2d\uff0c\u90fd\u6c92\u6709\u4efb\u4f55\u8acb\u6c42\u7684\u540d\u7a31\u70ba %1$s \u7684\u8cc7\u6599\u5eab\u5bb9\u5668\u5b58\u5728
ERR_DBTEST_ERROR_INITIALIZING_BACKEND_1350=\u5617\u8a66\u521d\u59cb\u5316 JE \u5f8c\u7aef %s \u6642\uff0c\u767c\u751f\u672a\u9810\u671f\u7684\u932f\u8aa4: %s
ERR_DBTEST_ERROR_READING_DATABASE_1351=\u5617\u8a66\u8b80\u53d6\u53ca (\u6216) \u89e3\u78bc\u8cc7\u6599\u5eab\u4e2d\u7684\u8a18\u9304\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_DBTEST_DECODE_BASE_DN_1352=\u7121\u6cd5\u5c07\u57fa\u5e95 DN \u5b57\u4e32\u300c%s\u300d\u89e3\u78bc\u70ba\u6709\u6548\u7684\u8fa8\u5225\u540d\u7a31: %s
ERR_BACKEND_DEBUG_DECODE_BASE_DN_1352=\u7121\u6cd5\u5c07\u57fa\u5e95 DN \u5b57\u4e32\u300c%s\u300d\u89e3\u78bc\u70ba\u6709\u6548\u7684\u8fa8\u5225\u540d\u7a31: %s
INFO_LABEL_DBTEST_DATABASE_NAME_1353=\u8cc7\u6599\u5eab\u540d\u7a31
INFO_LABEL_DBTEST_DATABASE_TYPE_1354=\u8cc7\u6599\u5eab\u985e\u578b
INFO_LABEL_DBTEST_JE_DATABASE_NAME_1355=JE \u8cc7\u6599\u5eab\u540d\u7a31
INFO_LABEL_DBTEST_JE_RECORD_COUNT_1356=\u8a18\u9304\u8a08\u6578
INFO_LABEL_DBTEST_INDEX_NAME_1357=\u7d22\u5f15\u540d\u7a31
INFO_LABEL_DBTEST_INDEX_TYPE_1358=\u7d22\u5f15\u985e\u578b
INFO_LABEL_DBTEST_INDEX_STATUS_1359=\u7d22\u5f15\u72c0\u614b
INFO_LABEL_DBTEST_RECORD_COUNT_1356=\u8a18\u9304\u8a08\u6578
INFO_LABEL_BACKEND_DEBUG_INDEX_NAME_1357=\u7d22\u5f15\u540d\u7a31
INFO_LABEL_BACKEND_DEBUG_INDEX_TYPE_1358=\u7d22\u5f15\u985e\u578b
INFO_LABEL_BACKEND_DEBUG_INDEX_STATUS_1359=\u7d22\u5f15\u72c0\u614b
INFO_LABEL_DBTEST_KEY_1360=\u91d1\u9470
INFO_LABEL_DBTEST_DATA_1361=\u8cc7\u6599
WARN_DBTEST_CANNOT_UNLOCK_BACKEND_1362=\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\u7a0b\u5e8f\u7d50\u675f\u6642\u81ea\u52d5\u6e05\u9664\uff0c\u6240\u4ee5\u4e0d\u9700\u8981\u5176\u4ed6\u52d5\u4f5c
ERR_DBTEST_CANNOT_LOCK_BACKEND_1363=\u5617\u8a66\u53d6\u5f97\u5f8c\u7aef %s \u7684\u5171\u7528\u9396\u5b9a\u6642\u767c\u751f\u932f\u8aa4: %s\u3002\u9019\u901a\u5e38\u8868\u793a\u67d0\u4e9b\u5176\u4ed6\u7a0b\u5e8f\u5177\u6709\u6b64\u5f8c\u7aef\u7684\u5c08\u7528\u5b58\u53d6 (\u4f8b\u5982\u5fa9\u539f\u6216 LDIF \u532f\u5165)
WARN_BACKEND_DEBUG_CANNOT_UNLOCK_BACKEND_1362=\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\u7a0b\u5e8f\u7d50\u675f\u6642\u81ea\u52d5\u6e05\u9664\uff0c\u6240\u4ee5\u4e0d\u9700\u8981\u5176\u4ed6\u52d5\u4f5c
ERR_BACKEND_DEBUG_CANNOT_LOCK_BACKEND_1363=\u5617\u8a66\u53d6\u5f97\u5f8c\u7aef %s \u7684\u5171\u7528\u9396\u5b9a\u6642\u767c\u751f\u932f\u8aa4: %s\u3002\u9019\u901a\u5e38\u8868\u793a\u67d0\u4e9b\u5176\u4ed6\u7a0b\u5e8f\u5177\u6709\u6b64\u5f8c\u7aef\u7684\u5c08\u7528\u5b58\u53d6 (\u4f8b\u5982\u5fa9\u539f\u6216 LDIF \u532f\u5165)
ERR_DBTEST_CANNOT_DECODE_KEY_1364=\u89e3\u78bc\u6700\u5927/\u6700\u5c0f\u91d1\u9470\u503c %s \u6642\u767c\u751f\u932f\u8aa4: %s\u3002\u4ee5\u300c0x\u300d\u505a\u70ba\u524d\u7db4\u7684\u503c\u5c07\u6703\u89e3\u78bc\u70ba\u5341\u516d\u9032\u5236\u7684\u539f\u59cb\u4f4d\u5143\u7d44\u3002\u50be\u5370 DN2ID \u8cc7\u6599\u5eab\u6642\uff0c\u6b64\u503c\u5fc5\u9808\u662f\u6709\u6548\u7684\u8fa8\u5225\u540d\u7a31\u3002\u50be\u5370 ID2Entry \u8cc7\u6599\u5eab\u6642\uff0c\u6b64\u503c\u5c07\u6703\u89e3\u78bc\u70ba\u9805\u76ee ID\u3002\u50be\u5370\u6240\u6709\u5176\u4ed6\u8cc7\u6599\u5eab\u6642\uff0c\u6b64\u503c\u5c07\u6703\u89e3\u78bc\u70ba\u5b57\u4e32\u3002
INFO_LABEL_DBTEST_ENTRY_1365=\u9805\u76ee
INFO_LABEL_DBTEST_ENTRY_ID_1366=\u9805\u76ee ID
@@ -937,7 +937,7 @@
INFO_LABEL_DBTEST_INDEX_ENTRY_ID_LIST_1370=\u9805\u76ee ID \u6e05\u55ae
INFO_LABEL_DBTEST_VLV_INDEX_LAST_SORT_KEYS_1371=\u6700\u5f8c\u4e00\u500b\u6392\u5e8f\u91d1\u9470
ERR_DBTEST_CANNOT_DECODE_SIZE_1372=\u5c07\u6700\u5c0f/\u6700\u5927\u8cc7\u6599\u5927\u5c0f %s \u5256\u6790\u70ba\u6574\u6578\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_DBTEST_MISSING_SUBCOMMAND_1374=\u5fc5\u9808\u6307\u5b9a\u5b50\u6307\u4ee4
ERR_BACKEND_DEBUG_MISSING_SUBCOMMAND_1374=\u5fc5\u9808\u6307\u5b9a\u5b50\u6307\u4ee4
INFO_CREATERC_USER_DESCRIPTION_1375=\u57f7\u884c\u4f3a\u670d\u5668\u6642\u6240\u61c9\u4f7f\u7528\u7684\u4f7f\u7528\u8005\u5e33\u865f\u540d\u7a31
INFO_CREATERC_JAVA_HOME_DESCRIPTION_1376=\u57f7\u884c\u4f3a\u670d\u5668\u6642\u6240\u61c9\u4f7f\u7528\u4e4b Java \u5b89\u88dd\u7684\u8def\u5f91
INFO_CREATERC_JAVA_ARGS_DESCRIPTION_1377=\u57f7\u884c\u4f3a\u670d\u5668\u6642\u61c9\u50b3\u9001\u81f3 JVM \u7684\u4e00\u7d44\u5f15\u6578
@@ -1179,3 +1179,8 @@
INFO_PROMPT_YES_COMPLETE_ANSWER_1663=\u662f
INFO_PROMPT_NO_COMPLETE_ANSWER_1665=\u5426
ERR_DSCFG_ERROR_BATCH_FILE_AND_INTERACTIVE_INCOMPATIBLE_1679=\u82e5\u6307\u5b9a\u4e86 {%s} \u5f15\u6578\uff0c\u5247\u5fc5\u9808\u540c\u6642\u6307\u5b9a {%s}
INFO_DESCRIPTION_BACKEND_TOOL_SUBCMD_LIST_ROOT_CONTAINERS_1854=\u5217\u51fa\u6240\u6709\u5f8c\u7aef\u4f7f\u7528\u7684\u6839\u5bb9\u566
ERR_BACKEND_TOOL_ERROR_READING_TREE_1866=\u5617\u8a66\u8b80\u53d6\u53ca (\u6216) \u7d22\u5f15\u89e3\u78bc\u4e2d\u7684\u8a18\u9304\u6642\u767c\u751f\u932f\u8aa4: %s
ERR_BACKEND_TOOL_ERROR_INITIALIZING_BACKEND_1865=\u5617\u8a66\u521d\u59cb\u5316\u5f8c\u7aef %s \u6642\uff0c\u767c\u751f\u672a\u9810\u671f\u7684\u932f\u8aa4: %s
ERR_BACKEND_TOOL_NO_TREE_FOR_NAME_1868=\u9805\u76ee\u5bb9\u5668 %2$s \u8207\u5f8c\u7aef %3$s \u4e2d\uff0c\u90fd\u6c92\u6709\u4efb\u4f55\u8acb\u6c42\u7684\u540d\u7a31\u70ba %1$s \u7684\u7d22\u5f15\u5b58\u5728
INFO_DESCRIPTION_BACKEND_TOOL_1893=\u6b64\u516c\u7528\u7a0b\u5f0f\u53ef\u7528\u65bc\u5c0d Pluggable \u5f8c\u7aef\u9032\u884c\u9664\u932f

 opendj-server-legacy/src/test/java/org/opends/server/backends/pluggable/OnDiskMergeImporterTest.java

@@ -127,7 +127,7 @@
  @SuppressWarnings(value = { "unchecked", "resource" })
  public void testAddLongCollector()
  {
    final ID2Count id2count = new ID2Count(TreeName.valueOf("dummy/dummy"));
    final ID2Count id2count = new ID2Count(TreeName.valueOf("/dummy/dummy"));
    final MeteredCursor<String, ByteString> source = cursorOf(
        Pair.of("key1", id2count.toValue(10)),
        Pair.of("key1", id2count.toValue(20)),