All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.unboundid.ldap.sdk.unboundidds.tasks.ExportTask Maven / Gradle / Ivy

Go to download

The UnboundID LDAP SDK for Java is a fast, comprehensive, and easy-to-use Java API for communicating with LDAP directory servers and performing related tasks like reading and writing LDIF, encoding and decoding data using base64 and ASN.1 BER, and performing secure communication. This package contains the Standard Edition of the LDAP SDK, which is a complete, general-purpose library for communicating with LDAPv3 directory servers.

The newest version!
/*
 * Copyright 2008-2024 Ping Identity Corporation
 * All Rights Reserved.
 */
/*
 * Copyright 2008-2024 Ping Identity Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * Copyright (C) 2008-2024 Ping Identity Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License (GPLv2 only)
 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see .
 */
package com.unboundid.ldap.sdk.unboundidds.tasks;



import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import com.unboundid.ldap.sdk.Attribute;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.util.Debug;
import com.unboundid.util.NotMutable;
import com.unboundid.util.NotNull;
import com.unboundid.util.Nullable;
import com.unboundid.util.StaticUtils;
import com.unboundid.util.ThreadSafety;
import com.unboundid.util.ThreadSafetyLevel;
import com.unboundid.util.Validator;

import static com.unboundid.ldap.sdk.unboundidds.tasks.TaskMessages.*;



/**
 * This class defines a Directory Server task that can be used to export the
 * contents of a backend to LDIF.
 * 

 * 

 *   NOTE:  This class, and other classes within the
 *   {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
 *   supported for use against Ping Identity, UnboundID, and
 *   Nokia/Alcatel-Lucent 8661 server products.  These classes provide support
 *   for proprietary functionality or for external specifications that are not
 *   considered stable or mature enough to be guaranteed to work in an
 *   interoperable way with other types of LDAP servers.
 * 

 * 

 * The properties that are available for use with this type of task include:
 * 
    
 *   
  • The backend ID for the backend from which the data is to be exported.
 *       It must be provided when scheduling a task of this type.
    • 
 *   
  • The path (on the server system) and name of the LDIF file to be
 *       written.  It must be provided when scheduling a task of this type.
    • 
 *   
  • A flag that indicates whether to append to any existing file or to
 *       overwrite it.
    • 
 *   
  • An optional list of base DNs for branches that should be included in
 *       the export.
    • 
 *   
  • An optional list of base DNs for branches that should be excluded from
 *       the export.
    • 
 *   
  • An optional list of filters that may be used to determine whether an
 *       entry should be included in the export.
    • 
 *   
  • An optional list of filters that may be used to determine whether an
 *       entry should be excluded from the export.
    • 
 *   
  • An optional list of attributes that should be included in entries that
 *       are exported.
    • 
 *   
  • An optional list of attributes that should be excluded form entries
 *       that are exported.
    • 
 *   
  • An integer value that specifies the column at which long lines should
 *       be wrapped.  A value less than or equal to zero indicates that no
 *       wrapping should be performed.
    • 
 *   
  • A flag that indicates whether to compress the LDIF data as it is
 *       written.
    • 
 *   
  • A flag that indicates whether to encrypt the LDIF data as it is
 *       written.
    • 
 *   
  • A flag that indicates whether to generate a signature for the LDIF data
 *       as it is written.
    • 
 *   
  • The path to a file containing a passphrase to use to generate the
 *       encryption key.
    • 
 *   
  • The ID of the encryption settings definition to use to generate the
 *       encryption key.
    • 
 *   
  • The maximum rate in megabytes per second at which the LDIF file should
 *       be written.
    • 
 * 

 */
@NotMutable()
@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
public final class ExportTask
       extends Task
{
  /**
   * The fully-qualified name of the Java class that is used for the export
   * task.
   */
  @NotNull static final String EXPORT_TASK_CLASS =
       "com.unboundid.directory.server.tasks.ExportTask";



  /**
   * The name of the attribute used to indicate whether to append to an existing
   * file.
   */
  @NotNull private static final String ATTR_APPEND_TO_LDIF =
       "ds-task-export-append-to-ldif";



  /**
   * The name of the attribute used to specify the backend ID of the backend to
   * export.
   */
  @NotNull private static final String ATTR_BACKEND_ID =
       "ds-task-export-backend-id";



  /**
   * The name of the attribute used to indicate whether the exported LDIF should
   * be compressed as it is written.
   */
  @NotNull private static final String ATTR_COMPRESS =
       "ds-task-export-compress-ldif";



  /**
   * The name of the attribute used to indicate whether the exported LDIF should
   * be encrypted as it is written.
   */
  @NotNull private static final String ATTR_ENCRYPT =
       "ds-task-export-encrypt-ldif";



  /**
   * The name of the attribute used to specify the path to a file that contains
   * the passphrase to use to generate the encryption key.
   */
  @NotNull private static final String ATTR_ENCRYPTION_PASSPHRASE_FILE =
       "ds-task-export-encryption-passphrase-file";



  /**
   * The name of the attribute used to specify the path to a file that contains
   * the ID of the encryption settings definition to use to generate the
   * encryption key.
   */
  @NotNull private static final String ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID =
       "ds-task-export-encryption-settings-definition-id";



  /**
   * The name of the attribute used to specify the attributes to exclude from
   * the export.
   */
  @NotNull private static final String ATTR_EXCLUDE_ATTRIBUTE =
       "ds-task-export-exclude-attribute";



  /**
   * The name of the attribute used to specify the base DNs to exclude from the
   * export.
   */
  @NotNull private static final String ATTR_EXCLUDE_BRANCH =
       "ds-task-export-exclude-branch";



  /**
   * The name of the attribute used to specify the filters to use to identify
   * entries to exclude from the export.
   */
  @NotNull private static final String ATTR_EXCLUDE_FILTER =
       "ds-task-export-exclude-filter";



  /**
   * The name of the attribute used to specify the attributes to include in the
   * export.
   */
  @NotNull private static final String ATTR_INCLUDE_ATTRIBUTE =
       "ds-task-export-include-attribute";



  /**
   * The name of the attribute used to specify the base DNs to include in the
   * export.
   */
  @NotNull private static final String ATTR_INCLUDE_BRANCH =
       "ds-task-export-include-branch";



  /**
   * The name of the attribute used to specify the filters to use to identify
   * entries to include in the export.
   */
  @NotNull private static final String ATTR_INCLUDE_FILTER =
       "ds-task-export-include-filter";



  /**
   * The name of the attribute used to specify the path to the LDIF file to be
   * written.
   */
  @NotNull private static final String ATTR_LDIF_FILE =
       "ds-task-export-ldif-file";



  /**
   * The name of the attribute used to specify the maximum LDIF write rate in
   * megabytes per second.
   */
  @NotNull private static final String ATTR_MAX_MEGABYTES_PER_SECOND =
       "ds-task-export-max-megabytes-per-second";



  /**
   * The name of the attribute used to specify the names or DNs of the
   * post-LDIF-export task processors to invoke when the export completes.
   */
  @NotNull private static final String ATTR_POST_EXPORT_PROCESSOR =
       "ds-task-export-post-export-processor";



  /**
   * The name of the attribute used to indicate whether the exported LDIF should
   * include a signed hash of the contents.
   */
  @NotNull private static final String ATTR_SIGN = "ds-task-export-sign-hash";



  /**
   * The name of the attribute used to specify the column at which to wrap long
   * lines in the export.
   */
  @NotNull private static final String ATTR_WRAP_COLUMN =
       "ds-task-export-wrap-column";



  /**
   * The name of the object class used in export task entries.
   */
  @NotNull private static final String OC_EXPORT_TASK = "ds-task-export";



  /**
   * The task property for the backend ID.
   */
  @NotNull private static final TaskProperty PROPERTY_BACKEND_ID =
       new TaskProperty(ATTR_BACKEND_ID, INFO_DISPLAY_NAME_BACKEND_ID.get(),
                        INFO_DESCRIPTION_BACKEND_ID_EXPORT.get(), String.class,
                        true, false, false);



  /**
   * The task property for the LDIF file.
   */
  @NotNull private static final TaskProperty PROPERTY_LDIF_FILE =
       new TaskProperty(ATTR_LDIF_FILE, INFO_DISPLAY_NAME_LDIF_FILE.get(),
                        INFO_DESCRIPTION_LDIF_FILE_EXPORT.get(), String.class,
                        true, false, false);



  /**
   * The task property for the append to LDIF flag.
   */
  @NotNull private static final TaskProperty PROPERTY_APPEND_TO_LDIF =
       new TaskProperty(ATTR_APPEND_TO_LDIF,
                        INFO_DISPLAY_NAME_APPEND_TO_LDIF.get(),
                        INFO_DESCRIPTION_APPEND_TO_LDIF.get(), Boolean.class,
                        false, false, true);



  /**
   * The task property for the include branches.
   */
  @NotNull private static final TaskProperty PROPERTY_INCLUDE_BRANCH =
       new TaskProperty(ATTR_INCLUDE_BRANCH,
                        INFO_DISPLAY_NAME_INCLUDE_BRANCH.get(),
                        INFO_DESCRIPTION_INCLUDE_BRANCH_EXPORT.get(),
                        String.class, false, true, true);



  /**
   * The task property for the exclude branches.
   */
  @NotNull private static final TaskProperty PROPERTY_EXCLUDE_BRANCH =
       new TaskProperty(ATTR_EXCLUDE_BRANCH,
                        INFO_DISPLAY_NAME_EXCLUDE_BRANCH.get(),
                        INFO_DESCRIPTION_EXCLUDE_BRANCH_EXPORT.get(),
                        String.class, false, true, true);



  /**
   * The task property for the include filters.
   */
  @NotNull private static final TaskProperty PROPERTY_INCLUDE_FILTER =
       new TaskProperty(ATTR_INCLUDE_FILTER,
                        INFO_DISPLAY_NAME_INCLUDE_FILTER.get(),
                        INFO_DESCRIPTION_INCLUDE_FILTER_EXPORT.get(),
                        String.class, false, true, true);



  /**
   * The task property for the exclude filters.
   */
  @NotNull private static final TaskProperty PROPERTY_EXCLUDE_FILTER =
       new TaskProperty(ATTR_EXCLUDE_FILTER,
                        INFO_DISPLAY_NAME_EXCLUDE_FILTER.get(),
                        INFO_DESCRIPTION_EXCLUDE_FILTER_EXPORT.get(),
                        String.class, false, true, true);



  /**
   * The task property for the include attributes.
   */
  @NotNull private static final TaskProperty PROPERTY_INCLUDE_ATTRIBUTE =
       new TaskProperty(ATTR_INCLUDE_ATTRIBUTE,
                        INFO_DISPLAY_NAME_INCLUDE_ATTRIBUTE.get(),
                        INFO_DESCRIPTION_INCLUDE_ATTRIBUTE_EXPORT.get(),
                        String.class, false, true, true);



  /**
   * The task property for the exclude attributes.
   */
  @NotNull private static final TaskProperty PROPERTY_EXCLUDE_ATTRIBUTE =
       new TaskProperty(ATTR_EXCLUDE_ATTRIBUTE,
                        INFO_DISPLAY_NAME_EXCLUDE_ATTRIBUTE.get(),
                        INFO_DESCRIPTION_EXCLUDE_ATTRIBUTE_EXPORT.get(),
                        String.class, false, true, true);



  /**
   * The task property for the wrap column.
   */
  @NotNull private static final TaskProperty PROPERTY_WRAP_COLUMN =
       new TaskProperty(ATTR_WRAP_COLUMN, INFO_DISPLAY_NAME_WRAP_COLUMN.get(),
                        INFO_DESCRIPTION_WRAP_COLUMN.get(), Long.class, false,
                        false, true);



  /**
   * The task property for the compress flag.
   */
  @NotNull private static final TaskProperty PROPERTY_COMPRESS =
       new TaskProperty(ATTR_COMPRESS, INFO_DISPLAY_NAME_COMPRESS.get(),
                        INFO_DESCRIPTION_COMPRESS_EXPORT.get(), Boolean.class,
                        false, false, false);



  /**
   * The task property for the encrypt flag.
   */
  @NotNull private static final TaskProperty PROPERTY_ENCRYPT =
       new TaskProperty(ATTR_ENCRYPT, INFO_DISPLAY_NAME_ENCRYPT.get(),
                        INFO_DESCRIPTION_ENCRYPT_EXPORT.get(), Boolean.class,
                        false, false, false);



  /**
   * The task property that will be used for the encryption passphrase file.
   */
  @NotNull private static final TaskProperty
       PROPERTY_ENCRYPTION_PASSPHRASE_FILE = new TaskProperty(
            ATTR_ENCRYPTION_PASSPHRASE_FILE,
            INFO_DISPLAY_NAME_ENCRYPTION_PASSPHRASE_FILE.get(),
            INFO_DESCRIPTION_ENCRYPTION_PASSPHRASE_FILE.get(),
            String.class, false, false, true);



  /**
   * The task property that will be used for the encryption settings definition
   * ID.
   */
  @NotNull private static final TaskProperty
       PROPERTY_ENCRYPTION_SETTINGS_DEFINITION_ID = new TaskProperty(
            ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID,
            INFO_DISPLAY_NAME_ENCRYPTION_SETTINGS_DEFINITION_ID.get(),
            INFO_DESCRIPTION_ENCRYPTION_SETTINGS_DEFINITION_ID.get(),
            String.class, false, false, true);



  /**
   * The task property for the sign flag.
   */
  @NotNull private static final TaskProperty PROPERTY_SIGN =
       new TaskProperty(ATTR_SIGN, INFO_DISPLAY_NAME_SIGN.get(),
                        INFO_DESCRIPTION_SIGN_EXPORT.get(), Boolean.class,
                        false, false, false);



  /**
   * The task property that will be used for the maximum write rate in megabytes
   * per second.
   */
  @NotNull private static final TaskProperty PROPERTY_MAX_MEGABYTES_PER_SECOND =
       new TaskProperty(ATTR_MAX_MEGABYTES_PER_SECOND,
            INFO_DISPLAY_NAME_EXPORT_MAX_MEGABYTES_PER_SECOND.get(),
            INFO_DESCRIPTION_EXPORT_MAX_MEGABYTES_PER_SECOND.get(),
            Long.class, false, false, true);



  /**
   * The task property that will be used for the set of post-LDIF-export task
   * processors to invoke after the export complets.
   */
  @NotNull private static final TaskProperty PROPERTY_POST_EXPORT_PROCESSOR =
       new TaskProperty(ATTR_POST_EXPORT_PROCESSOR,
            INFO_DISPLAY_NAME_POST_EXPORT_PROCESSOR.get(),
            INFO_DESCRIPTION_POST_EXPORT_PROCESSOR.get(),
            String.class, false, true, true);



  /**
   * The serial version UID for this serializable class.
   */
  private static final long serialVersionUID = -6807534587873728959L;



  // Indicates whether to append the data to an existing file.
  private final boolean appendToLDIF;

  // Indicates whether to compress the data.
  private final boolean compress;

  // Indicates whether to encrypt the data.
  private final boolean encrypt;

  // Indicates whether to sign the data.
  private final boolean sign;

  // The column at which to wrap long lines.
  private final int wrapColumn;

  // The maximum write rate in megabytes per second.
  @Nullable private final Integer maxMegabytesPerSecond;

  // The set of attributes to exclude from the export.
  @NotNull private final List excludeAttributes;

  // The set of base DNs to exclude from the export.
  @NotNull private final List excludeBranches;

  // The set of filters to use to identify entries to exclude.
  @NotNull private final List excludeFilters;

  // The set of attributes to include in the export.
  @NotNull private final List includeAttributes;

  // The set of base DNs to include in the export.
  @NotNull private final List includeBranches;

  // The set of filters to use to identify entries to include.
  @NotNull private final List includeFilters;

  // The set of post-LDIF-export task processors to invoke after the export
  // completes.
  @NotNull private final List postExportTaskProcessors;

  // The backend ID of the backend to export.
  @NotNull private final String backendID;

  // The path to a file containing the passphrase to use to generate the
  // encryption key.
  @Nullable private final String encryptionPassphraseFile;

  // The identifier for the encryption settings definition to use to generate
  // the encryption key.
  @Nullable private final String encryptionSettingsDefinitionID;

  // The path to the LDIF file to generate.
  @NotNull private final String ldifFile;



  /**
   * Creates a new uninitialized export task instance which should only be used
   * for obtaining general information about this task, including the task name,
   * description, and supported properties.  Attempts to use a task created with
   * this constructor for any other reason will likely fail.
   */
  public ExportTask()
  {
    appendToLDIF = false;
    compress = false;
    encrypt = false;
    sign = false;
    wrapColumn = -1;
    maxMegabytesPerSecond = null;
    encryptionPassphraseFile = null;
    encryptionSettingsDefinitionID = null;
    excludeAttributes = null;
    excludeBranches = null;
    excludeFilters = null;
    includeAttributes = null;
    includeBranches = null;
    includeFilters = null;
    postExportTaskProcessors = null;
    backendID = null;
    ldifFile = null;
  }



  /**
   * Creates a new export task with the provided information.
   *
   * @param  taskID     The task ID to use for this task.  If it is {@code null}
   *                    then a UUID will be generated for use as the task ID.
   * @param  backendID  The backend ID of the backend containing the data to
   *                    export.  It must not be {@code null}.
   * @param  ldifFile   The path to the LDIF file to create.  It may be an
   *                    absolute path or a path relative to the server install
   *                    root.  It must not be {@code null}.
   */
  public ExportTask(@Nullable final String taskID,
                    @NotNull final String backendID,
                    @NotNull final String ldifFile)
  {
    this(taskID, backendID, ldifFile, false, null, null, null, null, null, null,
         -1, false, false, false, null, null, null, null, null);
  }



  /**
   * Creates a new export task with the provided information.
   *
   * @param  taskID                  The task ID to use for this task.  If it is
   *                                 {@code null} then a UUID will be generated
   *                                 for use as the task ID.
   * @param  backendID               The backend ID of the backend to be
   *                                 exported.  It must not be {@code null}.
   * @param  ldifFile                The path to the LDIF file to be written.
   *                                 It may be an absolute path or one that is
   *                                 relative to the server root.  It must not
   *                                 be {@code null}.
   * @param  appendToLDIF            Indicates whether to an append to any
   *                                 existing file rather than overwriting it.
   * @param  includeBranches         The set of base DNs of entries to include
   *                                 in the export.  It may be {@code null} or
   *                                 empty if no entries should be excluded
   *                                 based on their location.
   * @param  excludeBranches         The set of base DNs of entries to exclude
   *                                 from the export.  It may be {@code null} or
   *                                 empty if no entries should be excluded
   *                                 based on their location.
   * @param  includeFilters          The set of filters to use to match entries
   *                                 that should be included in the export.  It
   *                                 may be {@code null} or empty if no entries
   *                                 should be excluded based on their content.
   * @param  excludeFilters          The set of filters to use to match entries
   *                                 that should be excluded from the export.
   *                                 It may be {@code null} or empty if no
   *                                 entries should be excluded based on their
   *                                 content.
   * @param  includeAttributes       The set of attributes that should be
   *                                 included in exported entries.  It may be
   *                                 {@code null} or empty if all attributes
   *                                 should be included.
   * @param  excludeAttributes       The set of attributes that should be
   *                                 excluded from exported entries.  It may be
   *                                 {@code null} or empty if no attributes
   *                                 should be excluded.
   * @param  wrapColumn              The column at which long lines should be
   *                                 wrapped.  It may be less than or equal to
   *                                 zero to indicate that long lines should not
   *                                 be wrapped.
   * @param  compress                Indicates whether the LDIF data should be
   *                                 compressed as it is written.
   * @param  encrypt                 Indicates whether the LDIF data should be
   *                                 encrypted as it is written.
   * @param  sign                    Indicates whether to include a signed hash
   *                                 of the content in the exported data.
   * @param  scheduledStartTime      The time that this task should start
   *                                 running.
   * @param  dependencyIDs           The list of task IDs that will be required
   *                                 to complete before this task will be
   *                                 eligible to start.
   * @param  failedDependencyAction  Indicates what action should be taken if
   *                                 any of the dependencies for this task do
   *                                 not complete successfully.
   * @param  notifyOnCompletion      The list of e-mail addresses of individuals
   *                                 that should be notified when this task
   *                                 completes.
   * @param  notifyOnError           The list of e-mail addresses of individuals
   *                                 that should be notified if this task does
   *                                 not complete successfully.
   */
  public ExportTask(@Nullable final String taskID,
              @NotNull final String backendID,
              @NotNull final String ldifFile,
              final boolean appendToLDIF,
              @Nullable final List includeBranches,
              @Nullable final List excludeBranches,
              @Nullable final List includeFilters,
              @Nullable final List excludeFilters,
              @Nullable final List includeAttributes,
              @Nullable final List excludeAttributes,
              final int wrapColumn,
              final boolean compress,
              final boolean encrypt,
              final boolean sign,
              @Nullable final Date scheduledStartTime,
              @Nullable final List dependencyIDs,
              @Nullable final FailedDependencyAction failedDependencyAction,
              @Nullable final List notifyOnCompletion,
              @Nullable final List notifyOnError)
  {
    this(taskID, backendID, ldifFile, appendToLDIF, includeBranches,
         excludeBranches, includeFilters, excludeFilters, includeAttributes,
         excludeAttributes, wrapColumn, compress, encrypt, null, null, sign,
         null, scheduledStartTime, dependencyIDs, failedDependencyAction,
         notifyOnCompletion, notifyOnError);
  }



  /**
   * Creates a new export task with the provided information.
   *
   * @param  taskID                          The task ID to use for this task.
   *                                         If it is {@code null} then a UUID
   *                                         will be generated for use as the
   *                                         task ID.
   * @param  backendID                       The backend ID of the backend to be
   *                                         exported.  It must not be
   *                                         {@code null}.
   * @param  ldifFile                        The path to the LDIF file to be
   *                                         written.  It may be an absolute
   *                                         path or one that is relative to the
   *                                         server root.  It must not be
   *                                         {@code null}.
   * @param  appendToLDIF                    Indicates whether to an append to
   *                                         any existing file rather than
   *                                         overwriting it.
   * @param  includeBranches                 The set of base DNs of entries to
   *                                         include in the export.  It may be
   *                                         {@code null} or empty if no entries
   *                                         should be excluded based on their
   *                                         location.
   * @param  excludeBranches                 The set of base DNs of entries to
   *                                         exclude from the export.  It may be
   *                                         {@code null} or empty if no entries
   *                                         should be excluded based on their
   *                                         location.
   * @param  includeFilters                  The set of filters to use to match
   *                                         entries that should be included in
   *                                         the export.  It may be {@code null}
   *                                         or empty if no entries should be
   *                                         excluded based on their content.
   * @param  excludeFilters                  The set of filters to use to match
   *                                         entries that should be excluded
   *                                         from the export.  It may be
   *                                         {@code null} or empty if no entries
   *                                         should be excluded based on their
   *                                         content.
   * @param  includeAttributes               The set of attributes that should
   *                                         be included in exported entries.
   *                                         It may be {@code null} or empty if
   *                                         all attributes should be included.
   * @param  excludeAttributes               The set of attributes that should
   *                                         be excluded from exported entries.
   *                                         It may be {@code null} or empty if
   *                                         no attributes should be excluded.
   * @param  wrapColumn                      The column at which long lines
   *                                         should be wrapped.  It may be less
   *                                         than or equal to zero to indicate
   *                                         that long lines should not be
   *                                         wrapped.
   * @param  compress                        Indicates whether the LDIF data
   *                                         should be compressed as it is
   *                                         written.
   * @param  encrypt                         Indicates whether the LDIF data
   *                                         should be encrypted as it is
   *                                         written.
   * @param  encryptionPassphraseFile        The path to a file containing the
   *                                         passphrase to use to generate the
   *                                         encryption key.  It amy be
   *                                         {@code null} if the LDIF file is
   *                                         not to be encrypted, or if the key
   *                                         should be obtained in some other
   *                                         way.
   * @param  encryptionSettingsDefinitionID  The ID of the encryption settings
   *                                         definition use to generate the
   *                                         encryption key.  It may be
   *                                         {@code null} if the LDIF file is
   *                                         not to be encrypted, or if the key
   *                                         should be obtained in some other
   *                                         way.
   * @param  sign                            Indicates whether to include a
   *                                         signed hash of the content in the
   *                                         exported data.
   * @param  maxMegabytesPerSecond           The maximum rate in megabytes per
   *                                         second at which the LDIF file
   *                                         should be written.
   * @param  scheduledStartTime              The time that this task should
   *                                         start running.
   * @param  dependencyIDs                   The list of task IDs that will be
   *                                         required to complete before this
   *                                         task will be eligible to start.
   * @param  failedDependencyAction          Indicates what action should be
   *                                         taken if any of the dependencies
   *                                         for this task do not complete
   *                                         successfully.
   * @param  notifyOnCompletion              The list of e-mail addresses of
   *                                         individuals that should be notified
   *                                         when this task completes.
   * @param  notifyOnError                   The list of e-mail addresses of
   *                                         individuals that should be notified
   *                                         if this task does not complete
   *                                         successfully.
   */
  public ExportTask(@Nullable final String taskID,
              @NotNull final String backendID,
              @NotNull final String ldifFile,
              final boolean appendToLDIF,
              @Nullable final List includeBranches,
              @Nullable final List excludeBranches,
              @Nullable final List includeFilters,
              @Nullable final List excludeFilters,
              @Nullable final List includeAttributes,
              @Nullable final List excludeAttributes,
              final int wrapColumn,
              final boolean compress, final boolean encrypt,
              @Nullable final String encryptionPassphraseFile,
              @Nullable final String encryptionSettingsDefinitionID,
              final boolean sign,
              @Nullable final Integer maxMegabytesPerSecond,
              @Nullable final Date scheduledStartTime,
              @Nullable final List dependencyIDs,
              @Nullable final FailedDependencyAction failedDependencyAction,
              @Nullable final List notifyOnCompletion,
              @Nullable final List notifyOnError)
  {
    this(taskID, backendID, ldifFile, appendToLDIF, includeBranches,
         excludeBranches, includeFilters, excludeFilters, includeAttributes,
         excludeAttributes, wrapColumn, compress, encrypt,
         encryptionPassphraseFile, encryptionSettingsDefinitionID, sign,
         maxMegabytesPerSecond, scheduledStartTime, dependencyIDs,
         failedDependencyAction, null, notifyOnCompletion, null,
         notifyOnError, null, null, null);
  }



  /**
   * Creates a new export task with the provided information.
   *
   * @param  taskID                          The task ID to use for this task.
   *                                         If it is {@code null} then a UUID
   *                                         will be generated for use as the
   *                                         task ID.
   * @param  backendID                       The backend ID of the backend to be
   *                                         exported.  It must not be
   *                                         {@code null}.
   * @param  ldifFile                        The path to the LDIF file to be
   *                                         written.  It may be an absolute
   *                                         path or one that is relative to the
   *                                         server root.  It must not be
   *                                         {@code null}.
   * @param  appendToLDIF                    Indicates whether to an append to
   *                                         any existing file rather than
   *                                         overwriting it.
   * @param  includeBranches                 The set of base DNs of entries to
   *                                         include in the export.  It may be
   *                                         {@code null} or empty if no entries
   *                                         should be excluded based on their
   *                                         location.
   * @param  excludeBranches                 The set of base DNs of entries to
   *                                         exclude from the export.  It may be
   *                                         {@code null} or empty if no entries
   *                                         should be excluded based on their
   *                                         location.
   * @param  includeFilters                  The set of filters to use to match
   *                                         entries that should be included in
   *                                         the export.  It may be {@code null}
   *                                         or empty if no entries should be
   *                                         excluded based on their content.
   * @param  excludeFilters                  The set of filters to use to match
   *                                         entries that should be excluded
   *                                         from the export.  It may be
   *                                         {@code null} or empty if no entries
   *                                         should be excluded based on their
   *                                         content.
   * @param  includeAttributes               The set of attributes that should
   *                                         be included in exported entries.
   *                                         It may be {@code null} or empty if
   *                                         all attributes should be included.
   * @param  excludeAttributes               The set of attributes that should
   *                                         be excluded from exported entries.
   *                                         It may be {@code null} or empty if
   *                                         no attributes should be excluded.
   * @param  wrapColumn                      The column at which long lines
   *                                         should be wrapped.  It may be less
   *                                         than or equal to zero to indicate
   *                                         that long lines should not be
   *                                         wrapped.
   * @param  compress                        Indicates whether the LDIF data
   *                                         should be compressed as it is
   *                                         written.
   * @param  encrypt                         Indicates whether the LDIF data
   *                                         should be encrypted as it is
   *                                         written.
   * @param  encryptionPassphraseFile        The path to a file containing the
   *                                         passphrase to use to generate the
   *                                         encryption key.  It amy be
   *                                         {@code null} if the LDIF file is
   *                                         not to be encrypted, or if the key
   *                                         should be obtained in some other
   *                                         way.
   * @param  encryptionSettingsDefinitionID  The ID of the encryption settings
   *                                         definition use to generate the
   *                                         encryption key.  It may be
   *                                         {@code null} if the LDIF file is
   *                                         not to be encrypted, or if the key
   *                                         should be obtained in some other
   *                                         way.
   * @param  sign                            Indicates whether to include a
   *                                         signed hash of the content in the
   *                                         exported data.
   * @param  maxMegabytesPerSecond           The maximum rate in megabytes per
   *                                         second at which the LDIF file
   *                                         should be written.
   * @param  scheduledStartTime              The time that this task should
   *                                         start running.
   * @param  dependencyIDs                   The list of task IDs that will be
   *                                         required to complete before this
   *                                         task will be eligible to start.
   * @param  failedDependencyAction          Indicates what action should be
   *                                         taken if any of the dependencies
   *                                         for this task do not complete
   *                                         successfully.
   * @param  notifyOnStart                   The list of e-mail addresses of
   *                                         individuals that should be notified
   *                                         when this task starts running.
   * @param  notifyOnCompletion              The list of e-mail addresses of
   *                                         individuals that should be notified
   *                                         when this task completes.
   * @param  notifyOnSuccess                 The list of e-mail addresses of
   *                                         individuals that should be notified
   *                                         if this task completes
   *                                         successfully.
   * @param  notifyOnError                   The list of e-mail addresses of
   *                                         individuals that should be notified
   *                                         if this task does not complete
   *                                         successfully.
   * @param  alertOnStart                    Indicates whether the server should
   *                                         send an alert notification when
   *                                         this task starts.
   * @param  alertOnSuccess                  Indicates whether the server should
   *                                         send an alert notification if this
   *                                         task completes successfully.
   * @param  alertOnError                    Indicates whether the server should
   *                                         send an alert notification if this
   *                                         task fails to complete
   *                                         successfully.
   */
  public ExportTask(@Nullable final String taskID,
              @NotNull final String backendID,
              @NotNull final String ldifFile,
              final boolean appendToLDIF,
              @Nullable final List includeBranches,
              @Nullable final List excludeBranches,
              @Nullable final List includeFilters,
              @Nullable final List excludeFilters,
              @Nullable final List includeAttributes,
              @Nullable final List excludeAttributes,
              final int wrapColumn,
              final boolean compress, final boolean encrypt,
              @Nullable final String encryptionPassphraseFile,
              @Nullable final String encryptionSettingsDefinitionID,
              final boolean sign,
              @Nullable final Integer maxMegabytesPerSecond,
              @Nullable final Date scheduledStartTime,
              @Nullable final List dependencyIDs,
              @Nullable final FailedDependencyAction failedDependencyAction,
              @Nullable final List notifyOnStart,
              @Nullable final List notifyOnCompletion,
              @Nullable final List notifyOnSuccess,
              @Nullable final List notifyOnError,
              @Nullable final Boolean alertOnStart,
              @Nullable final Boolean alertOnSuccess,
              @Nullable final Boolean alertOnError)
  {
    super(taskID, EXPORT_TASK_CLASS, scheduledStartTime,
         dependencyIDs, failedDependencyAction, notifyOnStart,
         notifyOnCompletion, notifyOnSuccess, notifyOnError, alertOnStart,
         alertOnSuccess, alertOnError);

    Validator.ensureNotNull(backendID, ldifFile);

    this.backendID = backendID;
    this.ldifFile = ldifFile;
    this.appendToLDIF = appendToLDIF;
    this.wrapColumn = wrapColumn;
    this.compress = compress;
    this.encrypt = encrypt;
    this.encryptionPassphraseFile = encryptionPassphraseFile;
    this.encryptionSettingsDefinitionID = encryptionSettingsDefinitionID;
    this.sign = sign;
    this.maxMegabytesPerSecond = maxMegabytesPerSecond;

    if (includeBranches == null)
    {
      this.includeBranches = Collections.emptyList();
    }
    else
    {
      this.includeBranches = Collections.unmodifiableList(includeBranches);
    }

    if (excludeBranches == null)
    {
      this.excludeBranches = Collections.emptyList();
    }
    else
    {
      this.excludeBranches = Collections.unmodifiableList(excludeBranches);
    }

    if (includeFilters == null)
    {
      this.includeFilters = Collections.emptyList();
    }
    else
    {
      this.includeFilters = Collections.unmodifiableList(includeFilters);
    }

    if (excludeFilters == null)
    {
      this.excludeFilters = Collections.emptyList();
    }
    else
    {
      this.excludeFilters = Collections.unmodifiableList(excludeFilters);
    }

    if (includeAttributes == null)
    {
      this.includeAttributes = Collections.emptyList();
    }
    else
    {
      this.includeAttributes = Collections.unmodifiableList(includeAttributes);
    }

    if (excludeAttributes == null)
    {
      this.excludeAttributes = Collections.emptyList();
    }
    else
    {
      this.excludeAttributes = Collections.unmodifiableList(excludeAttributes);
    }

    postExportTaskProcessors = new ArrayList<>();
  }



  /**
   * Creates a new export task with the provided set of properties.
   *
   * @param  properties  The properties to use to create this LDIF export
   *                     task.
   */
  public ExportTask(@NotNull final ExportTaskProperties properties)
  {
    super(properties.getTaskID(), EXPORT_TASK_CLASS,
         properties.getScheduledStartTime(), properties.getDependencyIDs(),
         properties.getFailedDependencyAction(), properties.getNotifyOnStart(),
         properties.getNotifyOnCompletion(), properties.getNotifyOnSuccess(),
         properties.getNotifyOnError(), properties.getAlertOnStart(),
         properties.getAlertOnSuccess(), properties.getAlertOnError());

    appendToLDIF = properties.appendToLDIF();
    compress = properties.compress();
    encrypt = properties.encrypt();
    sign = properties.sign();
    wrapColumn = properties.getWrapColumn();
    maxMegabytesPerSecond = properties.getMaxMegabytesPerSecond();
    excludeAttributes = Collections.unmodifiableList(
         new ArrayList<>(properties.getExcludeAttributes()));
    excludeBranches = Collections.unmodifiableList(
         new ArrayList<>(properties.getExcludeBranches()));
    excludeFilters = Collections.unmodifiableList(
         new ArrayList<>(properties.getExcludeFilters()));
    includeAttributes = Collections.unmodifiableList(
         new ArrayList<>(properties.getIncludeAttributes()));
    includeBranches = Collections.unmodifiableList(
         new ArrayList<>(properties.getIncludeBranches()));
    includeFilters = Collections.unmodifiableList(
         new ArrayList<>(properties.getIncludeFilters()));
    postExportTaskProcessors = Collections.unmodifiableList(
         new ArrayList<>(properties.getPostExportTaskProcessors()));
    backendID = properties.getBackendID();
    encryptionPassphraseFile = properties.getEncryptionPassphraseFile();
    encryptionSettingsDefinitionID =
         properties.getEncryptionSettingsDefinitionID();
    ldifFile = properties.getLDIFFile();
  }



  /**
   * Creates a new export task from the provided entry.
   *
   * @param  entry  The entry to use to create this export task.
   *
   * @throws  TaskException  If the provided entry cannot be parsed as an export
   *                         task entry.
   */
  public ExportTask(@NotNull final Entry entry)
         throws TaskException
  {
    super(entry);


    // Get the backend ID.  It must be present.
    backendID = entry.getAttributeValue(ATTR_BACKEND_ID);
    if (backendID == null)
    {
      throw new TaskException(ERR_EXPORT_TASK_NO_BACKEND_ID.get(
                                   getTaskEntryDN()));
    }


    // Get the LDIF file path.  It must be present.
    ldifFile = entry.getAttributeValue(ATTR_LDIF_FILE);
    if (ldifFile == null)
    {
      throw new TaskException(ERR_EXPORT_TASK_NO_LDIF_FILE.get(
                                   getTaskEntryDN()));
    }


    // Get the appendLDIF flag.  It may be absent.
    appendToLDIF = parseBooleanValue(entry, ATTR_APPEND_TO_LDIF, false);


    // Get the list of include branches.  It may be absent.
    includeBranches = parseStringList(entry, ATTR_INCLUDE_BRANCH);


    // Get the list of exclude branches.  It may be absent.
    excludeBranches = parseStringList(entry, ATTR_EXCLUDE_BRANCH);


    // Get the list of include filters.  It may be absent.
    includeFilters = parseStringList(entry, ATTR_INCLUDE_FILTER);


    // Get the list of exclude filters.  It may be absent.
    excludeFilters = parseStringList(entry, ATTR_EXCLUDE_FILTER);


    // Get the list of include attributes.  It may be absent.
    includeAttributes = parseStringList(entry, ATTR_INCLUDE_ATTRIBUTE);


    // Get the list of exclude attributes.  It may be absent.
    excludeAttributes = parseStringList(entry, ATTR_EXCLUDE_ATTRIBUTE);


    // Get the wrap column.  It may be absent.
    final String wrapStr = entry.getAttributeValue(ATTR_WRAP_COLUMN);
    if (wrapStr == null)
    {
      wrapColumn = -1;
    }
    else
    {
      try
      {
        wrapColumn = Integer.parseInt(wrapStr);
      }
      catch (final Exception e)
      {
        Debug.debugException(e);
        throw new TaskException(ERR_EXPORT_TASK_CANNOT_PARSE_WRAP_COLUMN.get(
                                     getTaskEntryDN(), wrapStr), e);
      }
    }


    // Get the compress flag.  It may be absent.
    compress = parseBooleanValue(entry, ATTR_COMPRESS, false);


    // Get the encrypt flag.  It may be absent.
    encrypt = parseBooleanValue(entry, ATTR_ENCRYPT, false);


    // Get the path to the encryption passphrase file.  It may be absent.
    encryptionPassphraseFile =
         entry.getAttributeValue(ATTR_ENCRYPTION_PASSPHRASE_FILE);


    // Get the encryption settings definition ID.  It may be absent.
    encryptionSettingsDefinitionID =
         entry.getAttributeValue(ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID);


    // Get the sign flag.  It may be absent.
    sign = parseBooleanValue(entry, ATTR_SIGN, false);


    // Get the maximum write rate in megabytes per second.  It may be absent.
    maxMegabytesPerSecond =
         entry.getAttributeValueAsInteger(ATTR_MAX_MEGABYTES_PER_SECOND);


    // Get the names or DNs of the post-LDIF-export task processors that should
    // be invoked.
    postExportTaskProcessors =
         parseStringList(entry, ATTR_POST_EXPORT_PROCESSOR);
  }



  /**
   * Creates a new export task from the provided set of task properties.
   *
   * @param  properties  The set of task properties and their corresponding
   *                     values to use for the task.  It must not be
   *                     {@code null}.
   *
   * @throws  TaskException  If the provided set of properties cannot be used to
   *                         create a valid export task.
   */
  public ExportTask(@NotNull final Map> properties)
         throws TaskException
  {
    super(EXPORT_TASK_CLASS, properties);

    boolean  a         = false;
    boolean  c         = false;
    boolean  e         = false;
    boolean  s         = false;
    Integer  maxMB     = null;
    long     w         = 0;
    String   b         = null;
    String   encID     = null;
    String   encPWFile = null;
    String   l         = null;
    String[] eA        = StaticUtils.NO_STRINGS;
    String[] eB        = StaticUtils.NO_STRINGS;
    String[] eF        = StaticUtils.NO_STRINGS;
    String[] iA        = StaticUtils.NO_STRINGS;
    String[] iB        = StaticUtils.NO_STRINGS;
    String[] iF        = StaticUtils.NO_STRINGS;
    String[] pEP       = StaticUtils.NO_STRINGS;

    for (final Map.Entry> entry :
         properties.entrySet())
    {
      final TaskProperty p = entry.getKey();
      final String attrName = p.getAttributeName();
      final List values = entry.getValue();

      if (attrName.equalsIgnoreCase(ATTR_BACKEND_ID))
      {
        b = parseString(p, values, b);
      }
      else if (attrName.equalsIgnoreCase(ATTR_LDIF_FILE))
      {
        l = parseString(p, values, l);
      }
      else if (attrName.equalsIgnoreCase(ATTR_APPEND_TO_LDIF))
      {
        a = parseBoolean(p, values, a);
      }
      else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_BRANCH))
      {
        iB = parseStrings(p, values, iB);
      }
      else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_BRANCH))
      {
        eB = parseStrings(p, values, eB);
      }
      else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_FILTER))
      {
        iF = parseStrings(p, values, iF);
      }
      else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_FILTER))
      {
        eF = parseStrings(p, values, eF);
      }
      else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_ATTRIBUTE))
      {
        iA = parseStrings(p, values, iA);
      }
      else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_ATTRIBUTE))
      {
        eA = parseStrings(p, values, eA);
      }
      else if (attrName.equalsIgnoreCase(ATTR_WRAP_COLUMN))
      {
        w = parseLong(p, values, w);
      }
      else if (attrName.equalsIgnoreCase(ATTR_COMPRESS))
      {
        c = parseBoolean(p, values, c);
      }
      else if (attrName.equalsIgnoreCase(ATTR_ENCRYPT))
      {
        e = parseBoolean(p, values, e);
      }
      else if (attrName.equalsIgnoreCase(ATTR_ENCRYPTION_PASSPHRASE_FILE))
      {
        encPWFile = parseString(p, values, encPWFile);
      }
      else if (attrName.equalsIgnoreCase(
           ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID))
      {
        encID = parseString(p, values, encID);
      }
      else if (attrName.equalsIgnoreCase(ATTR_SIGN))
      {
        s = parseBoolean(p, values, s);
      }
      else if (attrName.equalsIgnoreCase(ATTR_MAX_MEGABYTES_PER_SECOND))
      {
        final Long maxMBLong = parseLong(p, values, null);
        if (maxMBLong == null)
        {
          maxMB = null;
        }
        else
        {
          maxMB = maxMBLong.intValue();
        }
      }
      else if (attrName.equalsIgnoreCase(ATTR_POST_EXPORT_PROCESSOR))
      {
        pEP = parseStrings(p, values, pEP);
      }
    }

    if (b == null)
    {
      throw new TaskException(ERR_EXPORT_TASK_NO_BACKEND_ID.get(
                                   getTaskEntryDN()));
    }

    if (l == null)
    {
      throw new TaskException(ERR_EXPORT_TASK_NO_LDIF_FILE.get(
                                   getTaskEntryDN()));
    }

    backendID = b;
    ldifFile = l;
    appendToLDIF = a;
    includeAttributes = Collections.unmodifiableList(Arrays.asList(iA));
    excludeAttributes = Collections.unmodifiableList(Arrays.asList(eA));
    includeBranches = Collections.unmodifiableList(Arrays.asList(iB));
    excludeBranches = Collections.unmodifiableList(Arrays.asList(eB));
    includeFilters = Collections.unmodifiableList(Arrays.asList(iF));
    excludeFilters = Collections.unmodifiableList(Arrays.asList(eF));
    wrapColumn = (int) w;
    compress = c;
    encrypt = e;
    encryptionPassphraseFile = encPWFile;
    encryptionSettingsDefinitionID = encID;
    sign = s;
    maxMegabytesPerSecond = maxMB;
    postExportTaskProcessors = Collections.unmodifiableList(Arrays.asList(pEP));
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  @NotNull()
  public String getTaskName()
  {
    return INFO_TASK_NAME_EXPORT.get();
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  @NotNull()
  public String getTaskDescription()
  {
    return INFO_TASK_DESCRIPTION_EXPORT.get();
  }



  /**
   * Retrieves the backend ID of the backend from which the data is to be
   * exported.
   *
   * @return  The backend ID of the backend from which the data is to be
   *          exported.
   */
  @NotNull()
  public String getBackendID()
  {
    return backendID;
  }



  /**
   * Retrieves the path to the LDIF file to which the exported data should be
   * written.  It may be either an absolute path or one that is relative to the
   * server root.
   *
   * @return  The path to the LDIF file to which the exported data should be
   *          written.
   */
  @NotNull()
  public String getLDIFFile()
  {
    return ldifFile;
  }



  /**
   * Indicates whether to append to the LDIF file rather than overwriting it if
   * it already exists.
   *
   * @return  {@code true} if the server should append to an existing LDIF file,
   *          or {@code false} if the server should overwrite it.
   */
  public boolean appendToLDIF()
  {
    return appendToLDIF;
  }



  /**
   * Retrieves a list of base DNs of branches that should be included in the
   * export.
   *
   * @return  A list of base DNs of branches that should be included in the
   *          export, or an empty list if no entries should be excluded based on
   *          their location.
   */
  @NotNull()
  public List getIncludeBranches()
  {
    return includeBranches;
  }



  /**
   * Retrieves a list of base DNs of branches that should be excluded from the
   * export.
   *
   * @return  A list of base DNs of branches that should be excluded from the
   *          export, or an empty list if no entries should be excluded based on
   *          their location.
   */
  @NotNull()
  public List getExcludeBranches()
  {
    return excludeBranches;
  }



  /**
   * Retrieves a list of search filters that should be used to determine which
   * entries should be included in the export.
   *
   * @return  A list of search filters that should be used to determine which
   *          entries should be included in the export, or an empty list if no
   *          entries should be excluded based on their content.
   */
  @NotNull()
  public List getIncludeFilters()
  {
    return includeFilters;
  }



  /**
   * Retrieves a list of search filters that should be used to determine which
   * entries should be excluded from the export.
   *
   * @return  A list of search filters that should be used to determine which
   *          entries should be excluded from the export, or an empty list if no
   *          entries should be excluded based on their content.
   */
  @NotNull()
  public List getExcludeFilters()
  {
    return excludeFilters;
  }



  /**
   * Retrieves a list of the attributes that should be included in exported
   * entries.
   *
   * @return  A list of the attributes that should be included in exported
   *          entries, or an empty list if no attributes should be excluded.
   */
  @NotNull()
  public List getIncludeAttributes()
  {
    return includeAttributes;
  }



  /**
   * Retrieves a list of the attributes that should be excluded from exported
   * entries.
   *
   * @return  A list of the attributes that should be excluded from exported
   *          entries, or an empty list if no attributes should be excluded.
   */
  @NotNull()
  public List getExcludeAttributes()
  {
    return excludeAttributes;
  }



  /**
   * Retrieves the column number at which long lines should be wrapped.
   *
   * @return  The column number at which long lines should be wrapped, or a
   *          value less than or equal to zero to indicate that no wrapping
   *          should be performed.
   */
  public int getWrapColumn()
  {
    return wrapColumn;
  }



  /**
   * Indicates whether the LDIF data should be compressed as it is exported.
   *
   * @return  {@code true} if the LDIF data should be compressed as it is
   *          exported, or {@code false} if not.
   */
  public boolean compress()
  {
    return compress;
  }



  /**
   * Indicates whether the LDIF data should be encrypted as it is exported.
   *
   * @return  {@code true} if the LDIF data should be encrypted as it is
   *          exported, or {@code false} if not.
   */
  public boolean encrypt()
  {
    return encrypt;
  }



  /**
   * Retrieves the path to a file that contains the passphrase to use to
   * generate the encryption key.
   *
   * @return  The path to a file that contains the passphrase to use to
   *          generate the encryption key, or {@code null} if the LDIF file
   *          should not be encrypted or if the encryption key should be
   *          obtained through some other means.
   */
  @Nullable()
  public String getEncryptionPassphraseFile()
  {
    return encryptionPassphraseFile;
  }



  /**
   * Retrieves the identifier of the encryption settings definition to use to
   * generate the encryption key.
   *
   * @return  The identifier of the encryption settings definition to use to
   *          generate the encryption key, or {@code null} if the LDIF file
   *          should not be encrypted or if the encryption key should be
   *          obtained through some other means.
   */
  @Nullable()
  public String getEncryptionSettingsDefinitionID()
  {
    return encryptionSettingsDefinitionID;
  }



  /**
   * Indicates whether the exported LDIF data should include a signed hash.
   *
   * @return  {@code true} if the exported LDIF data should include a signed
   *          hash, or {@code false} if not.
   */
  public boolean sign()
  {
    return sign;
  }



  /**
   * Retrieves the maximum rate, in megabytes per second, at which the LDIF file
   * should be written.
   *
   * @return  The maximum rate, in megabytes per second, at which the LDIF file
   *          should be written, or {@code null} if the writing should not be
   *          rate limited.
   */
  @Nullable()
  public Integer getMaxMegabytesPerSecond()
  {
    return maxMegabytesPerSecond;
  }



  /**
   * Retrieves a list containing the names or DNs of any post-LDIF-export task
   * processors that should be invoked for the export.
   *
   * @return  A list containing the names or DNs of any post-LDIF-export task
   *          processors that should be invoked for the export, or an empty list
   *          if no post-LDIF-export task processors should be invoked.
   */
  @NotNull()
  public List getPostExportTaskProcessors()
  {
    return postExportTaskProcessors;
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  @NotNull()
  protected List getAdditionalObjectClasses()
  {
    return Collections.singletonList(OC_EXPORT_TASK);
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  @NotNull()
  protected List getAdditionalAttributes()
  {
    final ArrayList attrs = new ArrayList<>(20);

    attrs.add(new Attribute(ATTR_BACKEND_ID, backendID));
    attrs.add(new Attribute(ATTR_LDIF_FILE, ldifFile));
    attrs.add(new Attribute(ATTR_APPEND_TO_LDIF, String.valueOf(appendToLDIF)));
    attrs.add(new Attribute(ATTR_COMPRESS, String.valueOf(compress)));
    attrs.add(new Attribute(ATTR_ENCRYPT, String.valueOf(encrypt)));
    attrs.add(new Attribute(ATTR_SIGN, String.valueOf(sign)));

    if (! includeBranches.isEmpty())
    {
      attrs.add(new Attribute(ATTR_INCLUDE_BRANCH, includeBranches));
    }

    if (! excludeBranches.isEmpty())
    {
      attrs.add(new Attribute(ATTR_EXCLUDE_BRANCH, excludeBranches));
    }

    if (! includeAttributes.isEmpty())
    {
      attrs.add(new Attribute(ATTR_INCLUDE_ATTRIBUTE, includeAttributes));
    }

    if (! excludeAttributes.isEmpty())
    {
      attrs.add(new Attribute(ATTR_EXCLUDE_ATTRIBUTE, excludeAttributes));
    }

    if (! includeFilters.isEmpty())
    {
      attrs.add(new Attribute(ATTR_INCLUDE_FILTER, includeFilters));
    }

    if (! excludeFilters.isEmpty())
    {
      attrs.add(new Attribute(ATTR_EXCLUDE_FILTER, excludeFilters));
    }

    if (wrapColumn > 0)
    {
      attrs.add(new Attribute(ATTR_WRAP_COLUMN, String.valueOf(wrapColumn)));
    }

    if (encryptionPassphraseFile != null)
    {
      attrs.add(new Attribute(ATTR_ENCRYPTION_PASSPHRASE_FILE,
           encryptionPassphraseFile));
    }

    if (encryptionSettingsDefinitionID != null)
    {
      attrs.add(new Attribute(ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID,
           encryptionSettingsDefinitionID));
    }

    if (maxMegabytesPerSecond != null)
    {
      attrs.add(new Attribute(ATTR_MAX_MEGABYTES_PER_SECOND,
           String.valueOf(maxMegabytesPerSecond)));
    }

    if (! postExportTaskProcessors.isEmpty())
    {
      attrs.add(new Attribute(ATTR_POST_EXPORT_PROCESSOR,
           postExportTaskProcessors));
    }

    return attrs;
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  @NotNull()
  public List getTaskSpecificProperties()
  {
    final List propList = Arrays.asList(
         PROPERTY_BACKEND_ID,
         PROPERTY_LDIF_FILE,
         PROPERTY_APPEND_TO_LDIF,
         PROPERTY_INCLUDE_BRANCH,
         PROPERTY_EXCLUDE_BRANCH,
         PROPERTY_INCLUDE_FILTER,
         PROPERTY_EXCLUDE_FILTER,
         PROPERTY_INCLUDE_ATTRIBUTE,
         PROPERTY_EXCLUDE_ATTRIBUTE,
         PROPERTY_WRAP_COLUMN,
         PROPERTY_COMPRESS,
         PROPERTY_ENCRYPT,
         PROPERTY_ENCRYPTION_PASSPHRASE_FILE,
         PROPERTY_ENCRYPTION_SETTINGS_DEFINITION_ID,
         PROPERTY_SIGN,
         PROPERTY_MAX_MEGABYTES_PER_SECOND,
         PROPERTY_POST_EXPORT_PROCESSOR);

    return Collections.unmodifiableList(propList);
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  @NotNull()
  public Map> getTaskPropertyValues()
  {
    final LinkedHashMap> props =
         new LinkedHashMap<>(StaticUtils.computeMapCapacity(30));

    props.put(PROPERTY_BACKEND_ID,
              Collections.singletonList(backendID));

    props.put(PROPERTY_LDIF_FILE,
              Collections.singletonList(ldifFile));

    props.put(PROPERTY_APPEND_TO_LDIF,
              Collections.singletonList(appendToLDIF));

    props.put(PROPERTY_INCLUDE_BRANCH,
              Collections.unmodifiableList(includeBranches));

    props.put(PROPERTY_EXCLUDE_BRANCH,
              Collections.unmodifiableList(excludeBranches));

    props.put(PROPERTY_INCLUDE_FILTER,
              Collections.unmodifiableList(includeFilters));

    props.put(PROPERTY_EXCLUDE_FILTER,
              Collections.unmodifiableList(excludeFilters));

    props.put(PROPERTY_INCLUDE_ATTRIBUTE,
              Collections.unmodifiableList(includeAttributes));

    props.put(PROPERTY_EXCLUDE_ATTRIBUTE,
              Collections.unmodifiableList(excludeAttributes));

    props.put(PROPERTY_WRAP_COLUMN,
              Collections.singletonList((long) wrapColumn));

    props.put(PROPERTY_COMPRESS,
              Collections.singletonList(compress));

    props.put(PROPERTY_ENCRYPT,
              Collections.singletonList(encrypt));

    if (encryptionPassphraseFile == null)
    {
      props.put(PROPERTY_ENCRYPTION_PASSPHRASE_FILE, Collections.emptyList());
    }
    else
    {
      props.put(PROPERTY_ENCRYPTION_PASSPHRASE_FILE,
         Collections.singletonList(encryptionPassphraseFile));
    }

    if (encryptionSettingsDefinitionID == null)
    {
      props.put(PROPERTY_ENCRYPTION_SETTINGS_DEFINITION_ID,
           Collections.emptyList());
    }
    else
    {
      props.put(PROPERTY_ENCRYPTION_SETTINGS_DEFINITION_ID,
         Collections.singletonList(encryptionSettingsDefinitionID));
    }

    props.put(PROPERTY_SIGN, Collections.singletonList(sign));

    if (maxMegabytesPerSecond == null)
    {
      props.put(PROPERTY_MAX_MEGABYTES_PER_SECOND, Collections.emptyList());
    }
    else
    {
      props.put(PROPERTY_MAX_MEGABYTES_PER_SECOND,
         Collections.singletonList(maxMegabytesPerSecond.longValue()));
    }

    props.put(PROPERTY_POST_EXPORT_PROCESSOR,
         Collections.unmodifiableList(postExportTaskProcessors));

    props.putAll(super.getTaskPropertyValues());
    return Collections.unmodifiableMap(props);
  }
}
    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy