001/*
002 * Copyright 2008-2022 Ping Identity Corporation
003 * All Rights Reserved.
004 */
005/*
006 * Copyright 2008-2022 Ping Identity Corporation
007 *
008 * Licensed under the Apache License, Version 2.0 (the "License");
009 * you may not use this file except in compliance with the License.
010 * You may obtain a copy of the License at
011 *
012 *    http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing, software
015 * distributed under the License is distributed on an "AS IS" BASIS,
016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017 * See the License for the specific language governing permissions and
018 * limitations under the License.
019 */
020/*
021 * Copyright (C) 2008-2022 Ping Identity Corporation
022 *
023 * This program is free software; you can redistribute it and/or modify
024 * it under the terms of the GNU General Public License (GPLv2 only)
025 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
026 * as published by the Free Software Foundation.
027 *
028 * This program is distributed in the hope that it will be useful,
029 * but WITHOUT ANY WARRANTY; without even the implied warranty of
030 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
031 * GNU General Public License for more details.
032 *
033 * You should have received a copy of the GNU General Public License
034 * along with this program; if not, see <http://www.gnu.org/licenses>.
035 */
036package com.unboundid.ldap.sdk.unboundidds.tasks;
037
038
039
040import java.util.ArrayList;
041import java.util.Arrays;
042import java.util.Collections;
043import java.util.Date;
044import java.util.LinkedHashMap;
045import java.util.List;
046import java.util.Map;
047
048import com.unboundid.ldap.sdk.Attribute;
049import com.unboundid.ldap.sdk.Entry;
050import com.unboundid.util.Debug;
051import com.unboundid.util.NotMutable;
052import com.unboundid.util.NotNull;
053import com.unboundid.util.Nullable;
054import com.unboundid.util.StaticUtils;
055import com.unboundid.util.ThreadSafety;
056import com.unboundid.util.ThreadSafetyLevel;
057import com.unboundid.util.Validator;
058
059import static com.unboundid.ldap.sdk.unboundidds.tasks.TaskMessages.*;
060
061
062
063/**
064 * This class defines a Directory Server task that can be used to export the
065 * contents of a backend to LDIF.
066 * <BR>
067 * <BLOCKQUOTE>
068 *   <B>NOTE:</B>  This class, and other classes within the
069 *   {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
070 *   supported for use against Ping Identity, UnboundID, and
071 *   Nokia/Alcatel-Lucent 8661 server products.  These classes provide support
072 *   for proprietary functionality or for external specifications that are not
073 *   considered stable or mature enough to be guaranteed to work in an
074 *   interoperable way with other types of LDAP servers.
075 * </BLOCKQUOTE>
076 * <BR>
077 * The properties that are available for use with this type of task include:
078 * <UL>
079 *   <LI>The backend ID for the backend from which the data is to be exported.
080 *       It must be provided when scheduling a task of this type.</LI>
081 *   <LI>The path (on the server system) and name of the LDIF file to be
082 *       written.  It must be provided when scheduling a task of this type.</LI>
083 *   <LI>A flag that indicates whether to append to any existing file or to
084 *       overwrite it.</LI>
085 *   <LI>An optional list of base DNs for branches that should be included in
086 *       the export.</LI>
087 *   <LI>An optional list of base DNs for branches that should be excluded from
088 *       the export.</LI>
089 *   <LI>An optional list of filters that may be used to determine whether an
090 *       entry should be included in the export.</LI>
091 *   <LI>An optional list of filters that may be used to determine whether an
092 *       entry should be excluded from the export.</LI>
093 *   <LI>An optional list of attributes that should be included in entries that
094 *       are exported.</LI>
095 *   <LI>An optional list of attributes that should be excluded form entries
096 *       that are exported.</LI>
097 *   <LI>An integer value that specifies the column at which long lines should
098 *       be wrapped.  A value less than or equal to zero indicates that no
099 *       wrapping should be performed.</LI>
100 *   <LI>A flag that indicates whether to compress the LDIF data as it is
101 *       written.</LI>
102 *   <LI>A flag that indicates whether to encrypt the LDIF data as it is
103 *       written.</LI>
104 *   <LI>A flag that indicates whether to generate a signature for the LDIF data
105 *       as it is written.</LI>
106 *   <LI>The path to a file containing a passphrase to use to generate the
107 *       encryption key.</LI>
108 *   <LI>The ID of the encryption settings definition to use to generate the
109 *       encryption key.</LI>
110 *   <LI>The maximum rate in megabytes per second at which the LDIF file should
111 *       be written.</LI>
112 * </UL>
113 */
114@NotMutable()
115@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
116public final class ExportTask
117       extends Task
118{
119  /**
120   * The fully-qualified name of the Java class that is used for the export
121   * task.
122   */
123  @NotNull static final String EXPORT_TASK_CLASS =
124       "com.unboundid.directory.server.tasks.ExportTask";
125
126
127
128  /**
129   * The name of the attribute used to indicate whether to append to an existing
130   * file.
131   */
132  @NotNull private static final String ATTR_APPEND_TO_LDIF =
133       "ds-task-export-append-to-ldif";
134
135
136
137  /**
138   * The name of the attribute used to specify the backend ID of the backend to
139   * export.
140   */
141  @NotNull private static final String ATTR_BACKEND_ID =
142       "ds-task-export-backend-id";
143
144
145
146  /**
147   * The name of the attribute used to indicate whether the exported LDIF should
148   * be compressed as it is written.
149   */
150  @NotNull private static final String ATTR_COMPRESS =
151       "ds-task-export-compress-ldif";
152
153
154
155  /**
156   * The name of the attribute used to indicate whether the exported LDIF should
157   * be encrypted as it is written.
158   */
159  @NotNull private static final String ATTR_ENCRYPT =
160       "ds-task-export-encrypt-ldif";
161
162
163
164  /**
165   * The name of the attribute used to specify the path to a file that contains
166   * the passphrase to use to generate the encryption key.
167   */
168  @NotNull private static final String ATTR_ENCRYPTION_PASSPHRASE_FILE =
169       "ds-task-export-encryption-passphrase-file";
170
171
172
173  /**
174   * The name of the attribute used to specify the path to a file that contains
175   * the ID of the encryption settings definition to use to generate the
176   * encryption key.
177   */
178  @NotNull private static final String ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID =
179       "ds-task-export-encryption-settings-definition-id";
180
181
182
183  /**
184   * The name of the attribute used to specify the attributes to exclude from
185   * the export.
186   */
187  @NotNull private static final String ATTR_EXCLUDE_ATTRIBUTE =
188       "ds-task-export-exclude-attribute";
189
190
191
192  /**
193   * The name of the attribute used to specify the base DNs to exclude from the
194   * export.
195   */
196  @NotNull private static final String ATTR_EXCLUDE_BRANCH =
197       "ds-task-export-exclude-branch";
198
199
200
201  /**
202   * The name of the attribute used to specify the filters to use to identify
203   * entries to exclude from the export.
204   */
205  @NotNull private static final String ATTR_EXCLUDE_FILTER =
206       "ds-task-export-exclude-filter";
207
208
209
210  /**
211   * The name of the attribute used to specify the attributes to include in the
212   * export.
213   */
214  @NotNull private static final String ATTR_INCLUDE_ATTRIBUTE =
215       "ds-task-export-include-attribute";
216
217
218
219  /**
220   * The name of the attribute used to specify the base DNs to include in the
221   * export.
222   */
223  @NotNull private static final String ATTR_INCLUDE_BRANCH =
224       "ds-task-export-include-branch";
225
226
227
228  /**
229   * The name of the attribute used to specify the filters to use to identify
230   * entries to include in the export.
231   */
232  @NotNull private static final String ATTR_INCLUDE_FILTER =
233       "ds-task-export-include-filter";
234
235
236
237  /**
238   * The name of the attribute used to specify the path to the LDIF file to be
239   * written.
240   */
241  @NotNull private static final String ATTR_LDIF_FILE =
242       "ds-task-export-ldif-file";
243
244
245
246  /**
247   * The name of the attribute used to specify the maximum LDIF write rate in
248   * megabytes per second.
249   */
250  @NotNull private static final String ATTR_MAX_MEGABYTES_PER_SECOND =
251       "ds-task-export-max-megabytes-per-second";
252
253
254
255  /**
256   * The name of the attribute used to indicate whether the exported LDIF should
257   * include a signed hash of the contents.
258   */
259  @NotNull private static final String ATTR_SIGN = "ds-task-export-sign-hash";
260
261
262
263  /**
264   * The name of the attribute used to specify the column at which to wrap long
265   * lines in the export.
266   */
267  @NotNull private static final String ATTR_WRAP_COLUMN =
268       "ds-task-export-wrap-column";
269
270
271
272  /**
273   * The name of the object class used in export task entries.
274   */
275  @NotNull private static final String OC_EXPORT_TASK = "ds-task-export";
276
277
278
279  /**
280   * The task property for the backend ID.
281   */
282  @NotNull private static final TaskProperty PROPERTY_BACKEND_ID =
283       new TaskProperty(ATTR_BACKEND_ID, INFO_DISPLAY_NAME_BACKEND_ID.get(),
284                        INFO_DESCRIPTION_BACKEND_ID_EXPORT.get(), String.class,
285                        true, false, false);
286
287
288
289  /**
290   * The task property for the LDIF file.
291   */
292  @NotNull private static final TaskProperty PROPERTY_LDIF_FILE =
293       new TaskProperty(ATTR_LDIF_FILE, INFO_DISPLAY_NAME_LDIF_FILE.get(),
294                        INFO_DESCRIPTION_LDIF_FILE_EXPORT.get(), String.class,
295                        true, false, false);
296
297
298
299  /**
300   * The task property for the append to LDIF flag.
301   */
302  @NotNull private static final TaskProperty PROPERTY_APPEND_TO_LDIF =
303       new TaskProperty(ATTR_APPEND_TO_LDIF,
304                        INFO_DISPLAY_NAME_APPEND_TO_LDIF.get(),
305                        INFO_DESCRIPTION_APPEND_TO_LDIF.get(), Boolean.class,
306                        false, false, true);
307
308
309
310  /**
311   * The task property for the include branches.
312   */
313  @NotNull private static final TaskProperty PROPERTY_INCLUDE_BRANCH =
314       new TaskProperty(ATTR_INCLUDE_BRANCH,
315                        INFO_DISPLAY_NAME_INCLUDE_BRANCH.get(),
316                        INFO_DESCRIPTION_INCLUDE_BRANCH_EXPORT.get(),
317                        String.class, false, true, true);
318
319
320
321  /**
322   * The task property for the exclude branches.
323   */
324  @NotNull private static final TaskProperty PROPERTY_EXCLUDE_BRANCH =
325       new TaskProperty(ATTR_EXCLUDE_BRANCH,
326                        INFO_DISPLAY_NAME_EXCLUDE_BRANCH.get(),
327                        INFO_DESCRIPTION_EXCLUDE_BRANCH_EXPORT.get(),
328                        String.class, false, true, true);
329
330
331
332  /**
333   * The task property for the include filters.
334   */
335  @NotNull private static final TaskProperty PROPERTY_INCLUDE_FILTER =
336       new TaskProperty(ATTR_INCLUDE_FILTER,
337                        INFO_DISPLAY_NAME_INCLUDE_FILTER.get(),
338                        INFO_DESCRIPTION_INCLUDE_FILTER_EXPORT.get(),
339                        String.class, false, true, true);
340
341
342
343  /**
344   * The task property for the exclude filters.
345   */
346  @NotNull private static final TaskProperty PROPERTY_EXCLUDE_FILTER =
347       new TaskProperty(ATTR_EXCLUDE_FILTER,
348                        INFO_DISPLAY_NAME_EXCLUDE_FILTER.get(),
349                        INFO_DESCRIPTION_EXCLUDE_FILTER_EXPORT.get(),
350                        String.class, false, true, true);
351
352
353
354  /**
355   * The task property for the include attributes.
356   */
357  @NotNull private static final TaskProperty PROPERTY_INCLUDE_ATTRIBUTE =
358       new TaskProperty(ATTR_INCLUDE_ATTRIBUTE,
359                        INFO_DISPLAY_NAME_INCLUDE_ATTRIBUTE.get(),
360                        INFO_DESCRIPTION_INCLUDE_ATTRIBUTE_EXPORT.get(),
361                        String.class, false, true, true);
362
363
364
365  /**
366   * The task property for the exclude attributes.
367   */
368  @NotNull private static final TaskProperty PROPERTY_EXCLUDE_ATTRIBUTE =
369       new TaskProperty(ATTR_EXCLUDE_ATTRIBUTE,
370                        INFO_DISPLAY_NAME_EXCLUDE_ATTRIBUTE.get(),
371                        INFO_DESCRIPTION_EXCLUDE_ATTRIBUTE_EXPORT.get(),
372                        String.class, false, true, true);
373
374
375
376  /**
377   * The task property for the wrap column.
378   */
379  @NotNull private static final TaskProperty PROPERTY_WRAP_COLUMN =
380       new TaskProperty(ATTR_WRAP_COLUMN, INFO_DISPLAY_NAME_WRAP_COLUMN.get(),
381                        INFO_DESCRIPTION_WRAP_COLUMN.get(), Long.class, false,
382                        false, true);
383
384
385
386  /**
387   * The task property for the compress flag.
388   */
389  @NotNull private static final TaskProperty PROPERTY_COMPRESS =
390       new TaskProperty(ATTR_COMPRESS, INFO_DISPLAY_NAME_COMPRESS.get(),
391                        INFO_DESCRIPTION_COMPRESS_EXPORT.get(), Boolean.class,
392                        false, false, false);
393
394
395
396  /**
397   * The task property for the encrypt flag.
398   */
399  @NotNull private static final TaskProperty PROPERTY_ENCRYPT =
400       new TaskProperty(ATTR_ENCRYPT, INFO_DISPLAY_NAME_ENCRYPT.get(),
401                        INFO_DESCRIPTION_ENCRYPT_EXPORT.get(), Boolean.class,
402                        false, false, false);
403
404
405
406  /**
407   * The task property that will be used for the encryption passphrase file.
408   */
409  @NotNull private static final TaskProperty
410       PROPERTY_ENCRYPTION_PASSPHRASE_FILE = new TaskProperty(
411            ATTR_ENCRYPTION_PASSPHRASE_FILE,
412            INFO_DISPLAY_NAME_ENCRYPTION_PASSPHRASE_FILE.get(),
413            INFO_DESCRIPTION_ENCRYPTION_PASSPHRASE_FILE.get(),
414            String.class, false, false, true);
415
416
417
418  /**
419   * The task property that will be used for the encryption settings definition
420   * ID.
421   */
422  @NotNull private static final TaskProperty
423       PROPERTY_ENCRYPTION_SETTINGS_DEFINITION_ID = new TaskProperty(
424            ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID,
425            INFO_DISPLAY_NAME_ENCRYPTION_SETTINGS_DEFINITION_ID.get(),
426            INFO_DESCRIPTION_ENCRYPTION_SETTINGS_DEFINITION_ID.get(),
427            String.class, false, false, true);
428
429
430
431  /**
432   * The task property for the sign flag.
433   */
434  @NotNull private static final TaskProperty PROPERTY_SIGN =
435       new TaskProperty(ATTR_SIGN, INFO_DISPLAY_NAME_SIGN.get(),
436                        INFO_DESCRIPTION_SIGN_EXPORT.get(), Boolean.class,
437                        false, false, false);
438
439
440
441  /**
442   * The task property that will be used for the maximum write rate in megabytes
443   * per second.
444   */
445  @NotNull private static final TaskProperty PROPERTY_MAX_MEGABYTES_PER_SECOND =
446       new TaskProperty(ATTR_MAX_MEGABYTES_PER_SECOND,
447            INFO_DISPLAY_NAME_EXPORT_MAX_MEGABYTES_PER_SECOND.get(),
448            INFO_DESCRIPTION_EXPORT_MAX_MEGABYTES_PER_SECOND.get(),
449            Long.class, false, false, true);
450
451
452
453  /**
454   * The serial version UID for this serializable class.
455   */
456  private static final long serialVersionUID = -6807534587873728959L;
457
458
459
460  // Indicates whether to append the data to an existing file.
461  private final boolean appendToLDIF;
462
463  // Indicates whether to compress the data.
464  private final boolean compress;
465
466  // Indicates whether to encrypt the data.
467  private final boolean encrypt;
468
469  // Indicates whether to sign the data.
470  private final boolean sign;
471
472  // The column at which to wrap long lines.
473  private final int wrapColumn;
474
475  // The maximum write rate in megabytes per second.
476  @Nullable private final Integer maxMegabytesPerSecond;
477
478  // The set of attributes to exclude from the export.
479  @NotNull private final List<String> excludeAttributes;
480
481  // The set of base DNs to exclude from the export.
482  @NotNull private final List<String> excludeBranches;
483
484  // The set of filters to use to identify entries to exclude.
485  @NotNull private final List<String> excludeFilters;
486
487  // The set of attributes to include in the export.
488  @NotNull private final List<String> includeAttributes;
489
490  // The set of base DNs to include in the export.
491  @NotNull private final List<String> includeBranches;
492
493  // The set of filters to use to identify entries to include.
494  @NotNull private final List<String> includeFilters;
495
496  // The backend ID of the backend to export.
497  @NotNull private final String backendID;
498
499  // The path to a file containing the passphrase to use to generate the
500  // encryption key.
501  @Nullable private final String encryptionPassphraseFile;
502
503  // The identifier for the encryption settings definition to use to generate
504  // the encryption key.
505  @Nullable private final String encryptionSettingsDefinitionID;
506
507  // The path to the LDIF file to generate.
508  @NotNull private final String ldifFile;
509
510
511
512  /**
513   * Creates a new uninitialized export task instance which should only be used
514   * for obtaining general information about this task, including the task name,
515   * description, and supported properties.  Attempts to use a task created with
516   * this constructor for any other reason will likely fail.
517   */
518  public ExportTask()
519  {
520    appendToLDIF = false;
521    compress = false;
522    encrypt = false;
523    sign = false;
524    wrapColumn = -1;
525    maxMegabytesPerSecond = null;
526    encryptionPassphraseFile = null;
527    encryptionSettingsDefinitionID = null;
528    excludeAttributes = null;
529    excludeBranches = null;
530    excludeFilters = null;
531    includeAttributes = null;
532    includeBranches = null;
533    includeFilters = null;
534    backendID = null;
535    ldifFile = null;
536  }
537
538
539
540  /**
541   * Creates a new export task with the provided information.
542   *
543   * @param  taskID     The task ID to use for this task.  If it is {@code null}
544   *                    then a UUID will be generated for use as the task ID.
545   * @param  backendID  The backend ID of the backend containing the data to
546   *                    export.  It must not be {@code null}.
547   * @param  ldifFile   The path to the LDIF file to create.  It may be an
548   *                    absolute path or a path relative to the server install
549   *                    root.  It must not be {@code null}.
550   */
551  public ExportTask(@Nullable final String taskID,
552                    @NotNull final String backendID,
553                    @NotNull final String ldifFile)
554  {
555    this(taskID, backendID, ldifFile, false, null, null, null, null, null, null,
556         -1, false, false, false, null, null, null, null, null);
557  }
558
559
560
561  /**
562   * Creates a new export task with the provided information.
563   *
564   * @param  taskID                  The task ID to use for this task.  If it is
565   *                                 {@code null} then a UUID will be generated
566   *                                 for use as the task ID.
567   * @param  backendID               The backend ID of the backend to be
568   *                                 exported.  It must not be {@code null}.
569   * @param  ldifFile                The path to the LDIF file to be written.
570   *                                 It may be an absolute path or one that is
571   *                                 relative to the server root.  It must not
572   *                                 be {@code null}.
573   * @param  appendToLDIF            Indicates whether to an append to any
574   *                                 existing file rather than overwriting it.
575   * @param  includeBranches         The set of base DNs of entries to include
576   *                                 in the export.  It may be {@code null} or
577   *                                 empty if no entries should be excluded
578   *                                 based on their location.
579   * @param  excludeBranches         The set of base DNs of entries to exclude
580   *                                 from the export.  It may be {@code null} or
581   *                                 empty if no entries should be excluded
582   *                                 based on their location.
583   * @param  includeFilters          The set of filters to use to match entries
584   *                                 that should be included in the export.  It
585   *                                 may be {@code null} or empty if no entries
586   *                                 should be excluded based on their content.
587   * @param  excludeFilters          The set of filters to use to match entries
588   *                                 that should be excluded from the export.
589   *                                 It may be {@code null} or empty if no
590   *                                 entries should be excluded based on their
591   *                                 content.
592   * @param  includeAttributes       The set of attributes that should be
593   *                                 included in exported entries.  It may be
594   *                                 {@code null} or empty if all attributes
595   *                                 should be included.
596   * @param  excludeAttributes       The set of attributes that should be
597   *                                 excluded from exported entries.  It may be
598   *                                 {@code null} or empty if no attributes
599   *                                 should be excluded.
600   * @param  wrapColumn              The column at which long lines should be
601   *                                 wrapped.  It may be less than or equal to
602   *                                 zero to indicate that long lines should not
603   *                                 be wrapped.
604   * @param  compress                Indicates whether the LDIF data should be
605   *                                 compressed as it is written.
606   * @param  encrypt                 Indicates whether the LDIF data should be
607   *                                 encrypted as it is written.
608   * @param  sign                    Indicates whether to include a signed hash
609   *                                 of the content in the exported data.
610   * @param  scheduledStartTime      The time that this task should start
611   *                                 running.
612   * @param  dependencyIDs           The list of task IDs that will be required
613   *                                 to complete before this task will be
614   *                                 eligible to start.
615   * @param  failedDependencyAction  Indicates what action should be taken if
616   *                                 any of the dependencies for this task do
617   *                                 not complete successfully.
618   * @param  notifyOnCompletion      The list of e-mail addresses of individuals
619   *                                 that should be notified when this task
620   *                                 completes.
621   * @param  notifyOnError           The list of e-mail addresses of individuals
622   *                                 that should be notified if this task does
623   *                                 not complete successfully.
624   */
625  public ExportTask(@Nullable final String taskID,
626              @NotNull final String backendID,
627              @NotNull final String ldifFile,
628              final boolean appendToLDIF,
629              @Nullable final List<String> includeBranches,
630              @Nullable final List<String> excludeBranches,
631              @Nullable final List<String> includeFilters,
632              @Nullable final List<String> excludeFilters,
633              @Nullable final List<String> includeAttributes,
634              @Nullable final List<String> excludeAttributes,
635              final int wrapColumn,
636              final boolean compress,
637              final boolean encrypt,
638              final boolean sign,
639              @Nullable final Date scheduledStartTime,
640              @Nullable final List<String> dependencyIDs,
641              @Nullable final FailedDependencyAction failedDependencyAction,
642              @Nullable final List<String> notifyOnCompletion,
643              @Nullable final List<String> notifyOnError)
644  {
645    this(taskID, backendID, ldifFile, appendToLDIF, includeBranches,
646         excludeBranches, includeFilters, excludeFilters, includeAttributes,
647         excludeAttributes, wrapColumn, compress, encrypt, null, null, sign,
648         null, scheduledStartTime, dependencyIDs, failedDependencyAction,
649         notifyOnCompletion, notifyOnError);
650  }
651
652
653
654  /**
655   * Creates a new export task with the provided information.
656   *
657   * @param  taskID                          The task ID to use for this task.
658   *                                         If it is {@code null} then a UUID
659   *                                         will be generated for use as the
660   *                                         task ID.
661   * @param  backendID                       The backend ID of the backend to be
662   *                                         exported.  It must not be
663   *                                         {@code null}.
664   * @param  ldifFile                        The path to the LDIF file to be
665   *                                         written.  It may be an absolute
666   *                                         path or one that is relative to the
667   *                                         server root.  It must not be
668   *                                         {@code null}.
669   * @param  appendToLDIF                    Indicates whether to an append to
670   *                                         any existing file rather than
671   *                                         overwriting it.
672   * @param  includeBranches                 The set of base DNs of entries to
673   *                                         include in the export.  It may be
674   *                                         {@code null} or empty if no entries
675   *                                         should be excluded based on their
676   *                                         location.
677   * @param  excludeBranches                 The set of base DNs of entries to
678   *                                         exclude from the export.  It may be
679   *                                         {@code null} or empty if no entries
680   *                                         should be excluded based on their
681   *                                         location.
682   * @param  includeFilters                  The set of filters to use to match
683   *                                         entries that should be included in
684   *                                         the export.  It may be {@code null}
685   *                                         or empty if no entries should be
686   *                                         excluded based on their content.
687   * @param  excludeFilters                  The set of filters to use to match
688   *                                         entries that should be excluded
689   *                                         from the export.  It may be
690   *                                         {@code null} or empty if no entries
691   *                                         should be excluded based on their
692   *                                         content.
693   * @param  includeAttributes               The set of attributes that should
694   *                                         be included in exported entries.
695   *                                         It may be {@code null} or empty if
696   *                                         all attributes should be included.
697   * @param  excludeAttributes               The set of attributes that should
698   *                                         be excluded from exported entries.
699   *                                         It may be {@code null} or empty if
700   *                                         no attributes should be excluded.
701   * @param  wrapColumn                      The column at which long lines
702   *                                         should be wrapped.  It may be less
703   *                                         than or equal to zero to indicate
704   *                                         that long lines should not be
705   *                                         wrapped.
706   * @param  compress                        Indicates whether the LDIF data
707   *                                         should be compressed as it is
708   *                                         written.
709   * @param  encrypt                         Indicates whether the LDIF data
710   *                                         should be encrypted as it is
711   *                                         written.
712   * @param  encryptionPassphraseFile        The path to a file containing the
713   *                                         passphrase to use to generate the
714   *                                         encryption key.  It amy be
715   *                                         {@code null} if the LDIF file is
716   *                                         not to be encrypted, or if the key
717   *                                         should be obtained in some other
718   *                                         way.
719   * @param  encryptionSettingsDefinitionID  The ID of the encryption settings
720   *                                         definition use to generate the
721   *                                         encryption key.  It may be
722   *                                         {@code null} if the LDIF file is
723   *                                         not to be encrypted, or if the key
724   *                                         should be obtained in some other
725   *                                         way.
726   * @param  sign                            Indicates whether to include a
727   *                                         signed hash of the content in the
728   *                                         exported data.
729   * @param  maxMegabytesPerSecond           The maximum rate in megabytes per
730   *                                         second at which the LDIF file
731   *                                         should be written.
732   * @param  scheduledStartTime              The time that this task should
733   *                                         start running.
734   * @param  dependencyIDs                   The list of task IDs that will be
735   *                                         required to complete before this
736   *                                         task will be eligible to start.
737   * @param  failedDependencyAction          Indicates what action should be
738   *                                         taken if any of the dependencies
739   *                                         for this task do not complete
740   *                                         successfully.
741   * @param  notifyOnCompletion              The list of e-mail addresses of
742   *                                         individuals that should be notified
743   *                                         when this task completes.
744   * @param  notifyOnError                   The list of e-mail addresses of
745   *                                         individuals that should be notified
746   *                                         if this task does not complete
747   *                                         successfully.
748   */
749  public ExportTask(@Nullable final String taskID,
750              @NotNull final String backendID,
751              @NotNull final String ldifFile,
752              final boolean appendToLDIF,
753              @Nullable final List<String> includeBranches,
754              @Nullable final List<String> excludeBranches,
755              @Nullable final List<String> includeFilters,
756              @Nullable final List<String> excludeFilters,
757              @Nullable final List<String> includeAttributes,
758              @Nullable final List<String> excludeAttributes,
759              final int wrapColumn,
760              final boolean compress, final boolean encrypt,
761              @Nullable final String encryptionPassphraseFile,
762              @Nullable final String encryptionSettingsDefinitionID,
763              final boolean sign,
764              @Nullable final Integer maxMegabytesPerSecond,
765              @Nullable final Date scheduledStartTime,
766              @Nullable final List<String> dependencyIDs,
767              @Nullable final FailedDependencyAction failedDependencyAction,
768              @Nullable final List<String> notifyOnCompletion,
769              @Nullable final List<String> notifyOnError)
770  {
771    this(taskID, backendID, ldifFile, appendToLDIF, includeBranches,
772         excludeBranches, includeFilters, excludeFilters, includeAttributes,
773         excludeAttributes, wrapColumn, compress, encrypt,
774         encryptionPassphraseFile, encryptionSettingsDefinitionID, sign,
775         maxMegabytesPerSecond, scheduledStartTime, dependencyIDs,
776         failedDependencyAction, null, notifyOnCompletion, null,
777         notifyOnError, null, null, null);
778  }
779
780
781
782  /**
783   * Creates a new export task with the provided information.
784   *
785   * @param  taskID                          The task ID to use for this task.
786   *                                         If it is {@code null} then a UUID
787   *                                         will be generated for use as the
788   *                                         task ID.
789   * @param  backendID                       The backend ID of the backend to be
790   *                                         exported.  It must not be
791   *                                         {@code null}.
792   * @param  ldifFile                        The path to the LDIF file to be
793   *                                         written.  It may be an absolute
794   *                                         path or one that is relative to the
795   *                                         server root.  It must not be
796   *                                         {@code null}.
797   * @param  appendToLDIF                    Indicates whether to an append to
798   *                                         any existing file rather than
799   *                                         overwriting it.
800   * @param  includeBranches                 The set of base DNs of entries to
801   *                                         include in the export.  It may be
802   *                                         {@code null} or empty if no entries
803   *                                         should be excluded based on their
804   *                                         location.
805   * @param  excludeBranches                 The set of base DNs of entries to
806   *                                         exclude from the export.  It may be
807   *                                         {@code null} or empty if no entries
808   *                                         should be excluded based on their
809   *                                         location.
810   * @param  includeFilters                  The set of filters to use to match
811   *                                         entries that should be included in
812   *                                         the export.  It may be {@code null}
813   *                                         or empty if no entries should be
814   *                                         excluded based on their content.
815   * @param  excludeFilters                  The set of filters to use to match
816   *                                         entries that should be excluded
817   *                                         from the export.  It may be
818   *                                         {@code null} or empty if no entries
819   *                                         should be excluded based on their
820   *                                         content.
821   * @param  includeAttributes               The set of attributes that should
822   *                                         be included in exported entries.
823   *                                         It may be {@code null} or empty if
824   *                                         all attributes should be included.
825   * @param  excludeAttributes               The set of attributes that should
826   *                                         be excluded from exported entries.
827   *                                         It may be {@code null} or empty if
828   *                                         no attributes should be excluded.
829   * @param  wrapColumn                      The column at which long lines
830   *                                         should be wrapped.  It may be less
831   *                                         than or equal to zero to indicate
832   *                                         that long lines should not be
833   *                                         wrapped.
834   * @param  compress                        Indicates whether the LDIF data
835   *                                         should be compressed as it is
836   *                                         written.
837   * @param  encrypt                         Indicates whether the LDIF data
838   *                                         should be encrypted as it is
839   *                                         written.
840   * @param  encryptionPassphraseFile        The path to a file containing the
841   *                                         passphrase to use to generate the
842   *                                         encryption key.  It amy be
843   *                                         {@code null} if the LDIF file is
844   *                                         not to be encrypted, or if the key
845   *                                         should be obtained in some other
846   *                                         way.
847   * @param  encryptionSettingsDefinitionID  The ID of the encryption settings
848   *                                         definition use to generate the
849   *                                         encryption key.  It may be
850   *                                         {@code null} if the LDIF file is
851   *                                         not to be encrypted, or if the key
852   *                                         should be obtained in some other
853   *                                         way.
854   * @param  sign                            Indicates whether to include a
855   *                                         signed hash of the content in the
856   *                                         exported data.
857   * @param  maxMegabytesPerSecond           The maximum rate in megabytes per
858   *                                         second at which the LDIF file
859   *                                         should be written.
860   * @param  scheduledStartTime              The time that this task should
861   *                                         start running.
862   * @param  dependencyIDs                   The list of task IDs that will be
863   *                                         required to complete before this
864   *                                         task will be eligible to start.
865   * @param  failedDependencyAction          Indicates what action should be
866   *                                         taken if any of the dependencies
867   *                                         for this task do not complete
868   *                                         successfully.
869   * @param  notifyOnStart                   The list of e-mail addresses of
870   *                                         individuals that should be notified
871   *                                         when this task starts running.
872   * @param  notifyOnCompletion              The list of e-mail addresses of
873   *                                         individuals that should be notified
874   *                                         when this task completes.
875   * @param  notifyOnSuccess                 The list of e-mail addresses of
876   *                                         individuals that should be notified
877   *                                         if this task completes
878   *                                         successfully.
879   * @param  notifyOnError                   The list of e-mail addresses of
880   *                                         individuals that should be notified
881   *                                         if this task does not complete
882   *                                         successfully.
883   * @param  alertOnStart                    Indicates whether the server should
884   *                                         send an alert notification when
885   *                                         this task starts.
886   * @param  alertOnSuccess                  Indicates whether the server should
887   *                                         send an alert notification if this
888   *                                         task completes successfully.
889   * @param  alertOnError                    Indicates whether the server should
890   *                                         send an alert notification if this
891   *                                         task fails to complete
892   *                                         successfully.
893   */
894  public ExportTask(@Nullable final String taskID,
895              @NotNull final String backendID,
896              @NotNull final String ldifFile,
897              final boolean appendToLDIF,
898              @Nullable final List<String> includeBranches,
899              @Nullable final List<String> excludeBranches,
900              @Nullable final List<String> includeFilters,
901              @Nullable final List<String> excludeFilters,
902              @Nullable final List<String> includeAttributes,
903              @Nullable final List<String> excludeAttributes,
904              final int wrapColumn,
905              final boolean compress, final boolean encrypt,
906              @Nullable final String encryptionPassphraseFile,
907              @Nullable final String encryptionSettingsDefinitionID,
908              final boolean sign,
909              @Nullable final Integer maxMegabytesPerSecond,
910              @Nullable final Date scheduledStartTime,
911              @Nullable final List<String> dependencyIDs,
912              @Nullable final FailedDependencyAction failedDependencyAction,
913              @Nullable final List<String> notifyOnStart,
914              @Nullable final List<String> notifyOnCompletion,
915              @Nullable final List<String> notifyOnSuccess,
916              @Nullable final List<String> notifyOnError,
917              @Nullable final Boolean alertOnStart,
918              @Nullable final Boolean alertOnSuccess,
919              @Nullable final Boolean alertOnError)
920  {
921    super(taskID, EXPORT_TASK_CLASS, scheduledStartTime,
922         dependencyIDs, failedDependencyAction, notifyOnStart,
923         notifyOnCompletion, notifyOnSuccess, notifyOnError, alertOnStart,
924         alertOnSuccess, alertOnError);
925
926    Validator.ensureNotNull(backendID, ldifFile);
927
928    this.backendID = backendID;
929    this.ldifFile = ldifFile;
930    this.appendToLDIF = appendToLDIF;
931    this.wrapColumn = wrapColumn;
932    this.compress = compress;
933    this.encrypt = encrypt;
934    this.encryptionPassphraseFile = encryptionPassphraseFile;
935    this.encryptionSettingsDefinitionID = encryptionSettingsDefinitionID;
936    this.sign = sign;
937    this.maxMegabytesPerSecond = maxMegabytesPerSecond;
938
939    if (includeBranches == null)
940    {
941      this.includeBranches = Collections.emptyList();
942    }
943    else
944    {
945      this.includeBranches = Collections.unmodifiableList(includeBranches);
946    }
947
948    if (excludeBranches == null)
949    {
950      this.excludeBranches = Collections.emptyList();
951    }
952    else
953    {
954      this.excludeBranches = Collections.unmodifiableList(excludeBranches);
955    }
956
957    if (includeFilters == null)
958    {
959      this.includeFilters = Collections.emptyList();
960    }
961    else
962    {
963      this.includeFilters = Collections.unmodifiableList(includeFilters);
964    }
965
966    if (excludeFilters == null)
967    {
968      this.excludeFilters = Collections.emptyList();
969    }
970    else
971    {
972      this.excludeFilters = Collections.unmodifiableList(excludeFilters);
973    }
974
975    if (includeAttributes == null)
976    {
977      this.includeAttributes = Collections.emptyList();
978    }
979    else
980    {
981      this.includeAttributes = Collections.unmodifiableList(includeAttributes);
982    }
983
984    if (excludeAttributes == null)
985    {
986      this.excludeAttributes = Collections.emptyList();
987    }
988    else
989    {
990      this.excludeAttributes = Collections.unmodifiableList(excludeAttributes);
991    }
992  }
993
994
995
996  /**
997   * Creates a new export task from the provided entry.
998   *
999   * @param  entry  The entry to use to create this export task.
1000   *
1001   * @throws  TaskException  If the provided entry cannot be parsed as an export
1002   *                         task entry.
1003   */
1004  public ExportTask(@NotNull final Entry entry)
1005         throws TaskException
1006  {
1007    super(entry);
1008
1009
1010    // Get the backend ID.  It must be present.
1011    backendID = entry.getAttributeValue(ATTR_BACKEND_ID);
1012    if (backendID == null)
1013    {
1014      throw new TaskException(ERR_EXPORT_TASK_NO_BACKEND_ID.get(
1015                                   getTaskEntryDN()));
1016    }
1017
1018
1019    // Get the LDIF file path.  It must be present.
1020    ldifFile = entry.getAttributeValue(ATTR_LDIF_FILE);
1021    if (ldifFile == null)
1022    {
1023      throw new TaskException(ERR_EXPORT_TASK_NO_LDIF_FILE.get(
1024                                   getTaskEntryDN()));
1025    }
1026
1027
1028    // Get the appendLDIF flag.  It may be absent.
1029    appendToLDIF = parseBooleanValue(entry, ATTR_APPEND_TO_LDIF, false);
1030
1031
1032    // Get the list of include branches.  It may be absent.
1033    includeBranches = parseStringList(entry, ATTR_INCLUDE_BRANCH);
1034
1035
1036    // Get the list of exclude branches.  It may be absent.
1037    excludeBranches = parseStringList(entry, ATTR_EXCLUDE_BRANCH);
1038
1039
1040    // Get the list of include filters.  It may be absent.
1041    includeFilters = parseStringList(entry, ATTR_INCLUDE_FILTER);
1042
1043
1044    // Get the list of exclude filters.  It may be absent.
1045    excludeFilters = parseStringList(entry, ATTR_EXCLUDE_FILTER);
1046
1047
1048    // Get the list of include attributes.  It may be absent.
1049    includeAttributes = parseStringList(entry, ATTR_INCLUDE_ATTRIBUTE);
1050
1051
1052    // Get the list of exclude attributes.  It may be absent.
1053    excludeAttributes = parseStringList(entry, ATTR_EXCLUDE_ATTRIBUTE);
1054
1055
1056    // Get the wrap column.  It may be absent.
1057    final String wrapStr = entry.getAttributeValue(ATTR_WRAP_COLUMN);
1058    if (wrapStr == null)
1059    {
1060      wrapColumn = -1;
1061    }
1062    else
1063    {
1064      try
1065      {
1066        wrapColumn = Integer.parseInt(wrapStr);
1067      }
1068      catch (final Exception e)
1069      {
1070        Debug.debugException(e);
1071        throw new TaskException(ERR_EXPORT_TASK_CANNOT_PARSE_WRAP_COLUMN.get(
1072                                     getTaskEntryDN(), wrapStr), e);
1073      }
1074    }
1075
1076
1077    // Get the compress flag.  It may be absent.
1078    compress = parseBooleanValue(entry, ATTR_COMPRESS, false);
1079
1080
1081    // Get the encrypt flag.  It may be absent.
1082    encrypt = parseBooleanValue(entry, ATTR_ENCRYPT, false);
1083
1084
1085    // Get the path to the encryption passphrase file.  It may be absent.
1086    encryptionPassphraseFile =
1087         entry.getAttributeValue(ATTR_ENCRYPTION_PASSPHRASE_FILE);
1088
1089
1090    // Get the encryption settings definition ID.  It may be absent.
1091    encryptionSettingsDefinitionID =
1092         entry.getAttributeValue(ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID);
1093
1094
1095    // Get the sign flag.  It may be absent.
1096    sign = parseBooleanValue(entry, ATTR_SIGN, false);
1097
1098
1099    // Get the maximum write rate in megabytes per second.  It may be absent.
1100    maxMegabytesPerSecond =
1101         entry.getAttributeValueAsInteger(ATTR_MAX_MEGABYTES_PER_SECOND);
1102  }
1103
1104
1105
1106  /**
1107   * Creates a new export task from the provided set of task properties.
1108   *
1109   * @param  properties  The set of task properties and their corresponding
1110   *                     values to use for the task.  It must not be
1111   *                     {@code null}.
1112   *
1113   * @throws  TaskException  If the provided set of properties cannot be used to
1114   *                         create a valid export task.
1115   */
1116  public ExportTask(@NotNull final Map<TaskProperty,List<Object>> properties)
1117         throws TaskException
1118  {
1119    super(EXPORT_TASK_CLASS, properties);
1120
1121    boolean  a         = false;
1122    boolean  c         = false;
1123    boolean  e         = false;
1124    boolean  s         = false;
1125    Integer  maxMB     = null;
1126    long     w         = 0;
1127    String   b         = null;
1128    String   encID     = null;
1129    String   encPWFile = null;
1130    String   l         = null;
1131    String[] eA        = StaticUtils.NO_STRINGS;
1132    String[] eB        = StaticUtils.NO_STRINGS;
1133    String[] eF        = StaticUtils.NO_STRINGS;
1134    String[] iA        = StaticUtils.NO_STRINGS;
1135    String[] iB        = StaticUtils.NO_STRINGS;
1136    String[] iF        = StaticUtils.NO_STRINGS;
1137
1138    for (final Map.Entry<TaskProperty,List<Object>> entry :
1139         properties.entrySet())
1140    {
1141      final TaskProperty p = entry.getKey();
1142      final String attrName = p.getAttributeName();
1143      final List<Object> values = entry.getValue();
1144
1145      if (attrName.equalsIgnoreCase(ATTR_BACKEND_ID))
1146      {
1147        b = parseString(p, values, b);
1148      }
1149      else if (attrName.equalsIgnoreCase(ATTR_LDIF_FILE))
1150      {
1151        l = parseString(p, values, l);
1152      }
1153      else if (attrName.equalsIgnoreCase(ATTR_APPEND_TO_LDIF))
1154      {
1155        a = parseBoolean(p, values, a);
1156      }
1157      else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_BRANCH))
1158      {
1159        iB = parseStrings(p, values, iB);
1160      }
1161      else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_BRANCH))
1162      {
1163        eB = parseStrings(p, values, eB);
1164      }
1165      else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_FILTER))
1166      {
1167        iF = parseStrings(p, values, iF);
1168      }
1169      else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_FILTER))
1170      {
1171        eF = parseStrings(p, values, eF);
1172      }
1173      else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_ATTRIBUTE))
1174      {
1175        iA = parseStrings(p, values, iA);
1176      }
1177      else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_ATTRIBUTE))
1178      {
1179        eA = parseStrings(p, values, eA);
1180      }
1181      else if (attrName.equalsIgnoreCase(ATTR_WRAP_COLUMN))
1182      {
1183        w = parseLong(p, values, w);
1184      }
1185      else if (attrName.equalsIgnoreCase(ATTR_COMPRESS))
1186      {
1187        c = parseBoolean(p, values, c);
1188      }
1189      else if (attrName.equalsIgnoreCase(ATTR_ENCRYPT))
1190      {
1191        e = parseBoolean(p, values, e);
1192      }
1193      else if (attrName.equalsIgnoreCase(ATTR_ENCRYPTION_PASSPHRASE_FILE))
1194      {
1195        encPWFile = parseString(p, values, encPWFile);
1196      }
1197      else if (attrName.equalsIgnoreCase(
1198           ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID))
1199      {
1200        encID = parseString(p, values, encID);
1201      }
1202      else if (attrName.equalsIgnoreCase(ATTR_SIGN))
1203      {
1204        s = parseBoolean(p, values, s);
1205      }
1206      else if (attrName.equalsIgnoreCase(ATTR_MAX_MEGABYTES_PER_SECOND))
1207      {
1208        final Long maxMBLong = parseLong(p, values, null);
1209        if (maxMBLong == null)
1210        {
1211          maxMB = null;
1212        }
1213        else
1214        {
1215          maxMB = maxMBLong.intValue();
1216        }
1217      }
1218    }
1219
1220    if (b == null)
1221    {
1222      throw new TaskException(ERR_EXPORT_TASK_NO_BACKEND_ID.get(
1223                                   getTaskEntryDN()));
1224    }
1225
1226    if (l == null)
1227    {
1228      throw new TaskException(ERR_EXPORT_TASK_NO_LDIF_FILE.get(
1229                                   getTaskEntryDN()));
1230    }
1231
1232    backendID = b;
1233    ldifFile = l;
1234    appendToLDIF = a;
1235    includeAttributes = Collections.unmodifiableList(Arrays.asList(iA));
1236    excludeAttributes = Collections.unmodifiableList(Arrays.asList(eA));
1237    includeBranches = Collections.unmodifiableList(Arrays.asList(iB));
1238    excludeBranches = Collections.unmodifiableList(Arrays.asList(eB));
1239    includeFilters = Collections.unmodifiableList(Arrays.asList(iF));
1240    excludeFilters = Collections.unmodifiableList(Arrays.asList(eF));
1241    wrapColumn = (int) w;
1242    compress = c;
1243    encrypt = e;
1244    encryptionPassphraseFile = encPWFile;
1245    encryptionSettingsDefinitionID = encID;
1246    sign = s;
1247    maxMegabytesPerSecond = maxMB;
1248  }
1249
1250
1251
1252  /**
1253   * {@inheritDoc}
1254   */
1255  @Override()
1256  @NotNull()
1257  public String getTaskName()
1258  {
1259    return INFO_TASK_NAME_EXPORT.get();
1260  }
1261
1262
1263
1264  /**
1265   * {@inheritDoc}
1266   */
1267  @Override()
1268  @NotNull()
1269  public String getTaskDescription()
1270  {
1271    return INFO_TASK_DESCRIPTION_EXPORT.get();
1272  }
1273
1274
1275
1276  /**
1277   * Retrieves the backend ID of the backend from which the data is to be
1278   * exported.
1279   *
1280   * @return  The backend ID of the backend from which the data is to be
1281   *          exported.
1282   */
1283  @NotNull()
1284  public String getBackendID()
1285  {
1286    return backendID;
1287  }
1288
1289
1290
1291  /**
1292   * Retrieves the path to the LDIF file to which the exported data should be
1293   * written.  It may be either an absolute path or one that is relative to the
1294   * server root.
1295   *
1296   * @return  The path to the LDIF file to which the exported data should be
1297   *          written.
1298   */
1299  @NotNull()
1300  public String getLDIFFile()
1301  {
1302    return ldifFile;
1303  }
1304
1305
1306
1307  /**
1308   * Indicates whether to append to the LDIF file rather than overwriting it if
1309   * it already exists.
1310   *
1311   * @return  {@code true} if the server should append to an existing LDIF file,
1312   *          or {@code false} if the server should overwrite it.
1313   */
1314  public boolean appendToLDIF()
1315  {
1316    return appendToLDIF;
1317  }
1318
1319
1320
1321  /**
1322   * Retrieves a list of base DNs of branches that should be included in the
1323   * export.
1324   *
1325   * @return  A list of base DNs of branches that should be included in the
1326   *          export, or an empty list if no entries should be excluded based on
1327   *          their location.
1328   */
1329  @NotNull()
1330  public List<String> getIncludeBranches()
1331  {
1332    return includeBranches;
1333  }
1334
1335
1336
1337  /**
1338   * Retrieves a list of base DNs of branches that should be excluded from the
1339   * export.
1340   *
1341   * @return  A list of base DNs of branches that should be excluded from the
1342   *          export, or an empty list if no entries should be excluded based on
1343   *          their location.
1344   */
1345  @NotNull()
1346  public List<String> getExcludeBranches()
1347  {
1348    return excludeBranches;
1349  }
1350
1351
1352
1353  /**
1354   * Retrieves a list of search filters that should be used to determine which
1355   * entries should be included in the export.
1356   *
1357   * @return  A list of search filters that should be used to determine which
1358   *          entries should be included in the export, or an empty list if no
1359   *          entries should be excluded based on their content.
1360   */
1361  @NotNull()
1362  public List<String> getIncludeFilters()
1363  {
1364    return includeFilters;
1365  }
1366
1367
1368
1369  /**
1370   * Retrieves a list of search filters that should be used to determine which
1371   * entries should be excluded from the export.
1372   *
1373   * @return  A list of search filters that should be used to determine which
1374   *          entries should be excluded from the export, or an empty list if no
1375   *          entries should be excluded based on their content.
1376   */
1377  @NotNull()
1378  public List<String> getExcludeFilters()
1379  {
1380    return excludeFilters;
1381  }
1382
1383
1384
1385  /**
1386   * Retrieves a list of the attributes that should be included in exported
1387   * entries.
1388   *
1389   * @return  A list of the attributes that should be included in exported
1390   *          entries, or an empty list if no attributes should be excluded.
1391   */
1392  @NotNull()
1393  public List<String> getIncludeAttributes()
1394  {
1395    return includeAttributes;
1396  }
1397
1398
1399
1400  /**
1401   * Retrieves a list of the attributes that should be excluded from exported
1402   * entries.
1403   *
1404   * @return  A list of the attributes that should be excluded from exported
1405   *          entries, or an empty list if no attributes should be excluded.
1406   */
1407  @NotNull()
1408  public List<String> getExcludeAttributes()
1409  {
1410    return excludeAttributes;
1411  }
1412
1413
1414
1415  /**
1416   * Retrieves the column number at which long lines should be wrapped.
1417   *
1418   * @return  The column number at which long lines should be wrapped, or a
1419   *          value less than or equal to zero to indicate that no wrapping
1420   *          should be performed.
1421   */
1422  public int getWrapColumn()
1423  {
1424    return wrapColumn;
1425  }
1426
1427
1428
1429  /**
1430   * Indicates whether the LDIF data should be compressed as it is exported.
1431   *
1432   * @return  {@code true} if the LDIF data should be compressed as it is
1433   *          exported, or {@code false} if not.
1434   */
1435  public boolean compress()
1436  {
1437    return compress;
1438  }
1439
1440
1441
1442  /**
1443   * Indicates whether the LDIF data should be encrypted as it is exported.
1444   *
1445   * @return  {@code true} if the LDIF data should be encrypted as it is
1446   *          exported, or {@code false} if not.
1447   */
1448  public boolean encrypt()
1449  {
1450    return encrypt;
1451  }
1452
1453
1454
1455  /**
1456   * Retrieves the path to a file that contains the passphrase to use to
1457   * generate the encryption key.
1458   *
1459   * @return  The path to a file that contains the passphrase to use to
1460   *          generate the encryption key, or {@code null} if the LDIF file
1461   *          should not be encrypted or if the encryption key should be
1462   *          obtained through some other means.
1463   */
1464  @Nullable()
1465  public String getEncryptionPassphraseFile()
1466  {
1467    return encryptionPassphraseFile;
1468  }
1469
1470
1471
1472  /**
1473   * Retrieves the identifier of the encryption settings definition to use to
1474   * generate the encryption key.
1475   *
1476   * @return  The identifier of the encryption settings definition to use to
1477   *          generate the encryption key, or {@code null} if the LDIF file
1478   *          should not be encrypted or if the encryption key should be
1479   *          obtained through some other means.
1480   */
1481  @Nullable()
1482  public String getEncryptionSettingsDefinitionID()
1483  {
1484    return encryptionSettingsDefinitionID;
1485  }
1486
1487
1488
1489  /**
1490   * Indicates whether the exported LDIF data should include a signed hash.
1491   *
1492   * @return  {@code true} if the exported LDIF data should include a signed
1493   *          hash, or {@code false} if not.
1494   */
1495  public boolean sign()
1496  {
1497    return sign;
1498  }
1499
1500
1501
1502  /**
1503   * Retrieves the maximum rate, in megabytes per second, at which the LDIF file
1504   * should be written.
1505   *
1506   * @return  The maximum rate, in megabytes per second, at which the LDIF file
1507   *          should be written, or {@code null} if the writing should not be
1508   *          rate limited.
1509   */
1510  @Nullable()
1511  public Integer getMaxMegabytesPerSecond()
1512  {
1513    return maxMegabytesPerSecond;
1514  }
1515
1516
1517
1518  /**
1519   * {@inheritDoc}
1520   */
1521  @Override()
1522  @NotNull()
1523  protected List<String> getAdditionalObjectClasses()
1524  {
1525    return Collections.singletonList(OC_EXPORT_TASK);
1526  }
1527
1528
1529
1530  /**
1531   * {@inheritDoc}
1532   */
1533  @Override()
1534  @NotNull()
1535  protected List<Attribute> getAdditionalAttributes()
1536  {
1537    final ArrayList<Attribute> attrs = new ArrayList<>(20);
1538
1539    attrs.add(new Attribute(ATTR_BACKEND_ID, backendID));
1540    attrs.add(new Attribute(ATTR_LDIF_FILE, ldifFile));
1541    attrs.add(new Attribute(ATTR_APPEND_TO_LDIF, String.valueOf(appendToLDIF)));
1542    attrs.add(new Attribute(ATTR_COMPRESS, String.valueOf(compress)));
1543    attrs.add(new Attribute(ATTR_ENCRYPT, String.valueOf(encrypt)));
1544    attrs.add(new Attribute(ATTR_SIGN, String.valueOf(sign)));
1545
1546    if (! includeBranches.isEmpty())
1547    {
1548      attrs.add(new Attribute(ATTR_INCLUDE_BRANCH, includeBranches));
1549    }
1550
1551    if (! excludeBranches.isEmpty())
1552    {
1553      attrs.add(new Attribute(ATTR_EXCLUDE_BRANCH, excludeBranches));
1554    }
1555
1556    if (! includeAttributes.isEmpty())
1557    {
1558      attrs.add(new Attribute(ATTR_INCLUDE_ATTRIBUTE, includeAttributes));
1559    }
1560
1561    if (! excludeAttributes.isEmpty())
1562    {
1563      attrs.add(new Attribute(ATTR_EXCLUDE_ATTRIBUTE, excludeAttributes));
1564    }
1565
1566    if (! includeFilters.isEmpty())
1567    {
1568      attrs.add(new Attribute(ATTR_INCLUDE_FILTER, includeFilters));
1569    }
1570
1571    if (! excludeFilters.isEmpty())
1572    {
1573      attrs.add(new Attribute(ATTR_EXCLUDE_FILTER, excludeFilters));
1574    }
1575
1576    if (wrapColumn > 0)
1577    {
1578      attrs.add(new Attribute(ATTR_WRAP_COLUMN, String.valueOf(wrapColumn)));
1579    }
1580
1581    if (encryptionPassphraseFile != null)
1582    {
1583      attrs.add(new Attribute(ATTR_ENCRYPTION_PASSPHRASE_FILE,
1584           encryptionPassphraseFile));
1585    }
1586
1587    if (encryptionSettingsDefinitionID != null)
1588    {
1589      attrs.add(new Attribute(ATTR_ENCRYPTION_SETTINGS_DEFINITION_ID,
1590           encryptionSettingsDefinitionID));
1591    }
1592
1593    if (maxMegabytesPerSecond != null)
1594    {
1595      attrs.add(new Attribute(ATTR_MAX_MEGABYTES_PER_SECOND,
1596           String.valueOf(maxMegabytesPerSecond)));
1597    }
1598
1599    return attrs;
1600  }
1601
1602
1603
1604  /**
1605   * {@inheritDoc}
1606   */
1607  @Override()
1608  @NotNull()
1609  public List<TaskProperty> getTaskSpecificProperties()
1610  {
1611    final List<TaskProperty> propList = Arrays.asList(
1612         PROPERTY_BACKEND_ID,
1613         PROPERTY_LDIF_FILE,
1614         PROPERTY_APPEND_TO_LDIF,
1615         PROPERTY_INCLUDE_BRANCH,
1616         PROPERTY_EXCLUDE_BRANCH,
1617         PROPERTY_INCLUDE_FILTER,
1618         PROPERTY_EXCLUDE_FILTER,
1619         PROPERTY_INCLUDE_ATTRIBUTE,
1620         PROPERTY_EXCLUDE_ATTRIBUTE,
1621         PROPERTY_WRAP_COLUMN,
1622         PROPERTY_COMPRESS,
1623         PROPERTY_ENCRYPT,
1624         PROPERTY_ENCRYPTION_PASSPHRASE_FILE,
1625         PROPERTY_ENCRYPTION_SETTINGS_DEFINITION_ID,
1626         PROPERTY_SIGN,
1627         PROPERTY_MAX_MEGABYTES_PER_SECOND);
1628
1629    return Collections.unmodifiableList(propList);
1630  }
1631
1632
1633
1634  /**
1635   * {@inheritDoc}
1636   */
1637  @Override()
1638  @NotNull()
1639  public Map<TaskProperty,List<Object>> getTaskPropertyValues()
1640  {
1641    final LinkedHashMap<TaskProperty,List<Object>> props =
1642         new LinkedHashMap<>(StaticUtils.computeMapCapacity(30));
1643
1644    props.put(PROPERTY_BACKEND_ID,
1645              Collections.<Object>singletonList(backendID));
1646
1647    props.put(PROPERTY_LDIF_FILE,
1648              Collections.<Object>singletonList(ldifFile));
1649
1650    props.put(PROPERTY_APPEND_TO_LDIF,
1651              Collections.<Object>singletonList(appendToLDIF));
1652
1653    props.put(PROPERTY_INCLUDE_BRANCH,
1654              Collections.<Object>unmodifiableList(includeBranches));
1655
1656    props.put(PROPERTY_EXCLUDE_BRANCH,
1657              Collections.<Object>unmodifiableList(excludeBranches));
1658
1659    props.put(PROPERTY_INCLUDE_FILTER,
1660              Collections.<Object>unmodifiableList(includeFilters));
1661
1662    props.put(PROPERTY_EXCLUDE_FILTER,
1663              Collections.<Object>unmodifiableList(excludeFilters));
1664
1665    props.put(PROPERTY_INCLUDE_ATTRIBUTE,
1666              Collections.<Object>unmodifiableList(includeAttributes));
1667
1668    props.put(PROPERTY_EXCLUDE_ATTRIBUTE,
1669              Collections.<Object>unmodifiableList(excludeAttributes));
1670
1671    props.put(PROPERTY_WRAP_COLUMN,
1672              Collections.<Object>singletonList((long) wrapColumn));
1673
1674    props.put(PROPERTY_COMPRESS,
1675              Collections.<Object>singletonList(compress));
1676
1677    props.put(PROPERTY_ENCRYPT,
1678              Collections.<Object>singletonList(encrypt));
1679
1680    if (encryptionPassphraseFile == null)
1681    {
1682      props.put(PROPERTY_ENCRYPTION_PASSPHRASE_FILE, Collections.emptyList());
1683    }
1684    else
1685    {
1686      props.put(PROPERTY_ENCRYPTION_PASSPHRASE_FILE,
1687         Collections.<Object>singletonList(encryptionPassphraseFile));
1688    }
1689
1690    if (encryptionSettingsDefinitionID == null)
1691    {
1692      props.put(PROPERTY_ENCRYPTION_SETTINGS_DEFINITION_ID,
1693           Collections.emptyList());
1694    }
1695    else
1696    {
1697      props.put(PROPERTY_ENCRYPTION_SETTINGS_DEFINITION_ID,
1698         Collections.<Object>singletonList(encryptionSettingsDefinitionID));
1699    }
1700
1701    props.put(PROPERTY_SIGN, Collections.<Object>singletonList(sign));
1702
1703    if (maxMegabytesPerSecond == null)
1704    {
1705      props.put(PROPERTY_MAX_MEGABYTES_PER_SECOND, Collections.emptyList());
1706    }
1707    else
1708    {
1709      props.put(PROPERTY_MAX_MEGABYTES_PER_SECOND,
1710         Collections.<Object>singletonList(maxMegabytesPerSecond.longValue()));
1711    }
1712
1713    props.putAll(super.getTaskPropertyValues());
1714    return Collections.unmodifiableMap(props);
1715  }
1716}