001 /* 002 * Copyright 2008-2015 UnboundID Corp. 003 * All Rights Reserved. 004 */ 005 /* 006 * Copyright (C) 2015 UnboundID Corp. 007 * 008 * This program is free software; you can redistribute it and/or modify 009 * it under the terms of the GNU General Public License (GPLv2 only) 010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 011 * as published by the Free Software Foundation. 012 * 013 * This program is distributed in the hope that it will be useful, 014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 016 * GNU General Public License for more details. 017 * 018 * You should have received a copy of the GNU General Public License 019 * along with this program; if not, see <http://www.gnu.org/licenses>. 020 */ 021 package com.unboundid.ldap.sdk.unboundidds.tasks; 022 023 024 025 import java.util.ArrayList; 026 import java.util.Arrays; 027 import java.util.Collections; 028 import java.util.Date; 029 import java.util.LinkedHashMap; 030 import java.util.List; 031 import java.util.Map; 032 033 import com.unboundid.ldap.sdk.Attribute; 034 import com.unboundid.ldap.sdk.Entry; 035 import com.unboundid.util.NotMutable; 036 import com.unboundid.util.StaticUtils; 037 import com.unboundid.util.ThreadSafety; 038 import com.unboundid.util.ThreadSafetyLevel; 039 040 import static com.unboundid.ldap.sdk.unboundidds.tasks.TaskMessages.*; 041 import static com.unboundid.util.Validator.*; 042 043 044 045 /** 046 * <BLOCKQUOTE> 047 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 048 * LDAP SDK for Java. It is not available for use in applications that 049 * include only the Standard Edition of the LDAP SDK, and is not supported for 050 * use in conjunction with non-UnboundID products. 051 * </BLOCKQUOTE> 052 * This class defines a Directory Server task that can be used to import LDIF 053 * content into a backend. The properties that are available for use with this 054 * type of task include: 055 * <UL> 056 * <LI>The paths (on the server system) to the LDIF files containing the data 057 * to be imported. At least one LDIF file path must be provided.</LI> 058 * <LI>The backend ID for the backend into which the data should be 059 * imported. It may be omitted only if at least one include branch is 060 * provided.</LI> 061 * <LI>A flag that indicates whether to append to the existing data in the 062 * backend rather than destroying any existing data before beginning the 063 * import.</LI> 064 * <LI>A flag that indicates whether to replace entries that already exist 065 * when operating in append mode.</LI> 066 * <LI>An optional path (on the server system) to a file to which the server 067 * should write copies of any entries that are rejected, along with a 068 * message explaining why they were rejected.</LI> 069 * <LI>A flag that indicates whether to overwrite the reject file rather than 070 * append to it if it already exists.</LI> 071 * <LI>A flag that indicates whether to clear the entire contents of the 072 * backend even if it has multiple base DNs but only a subset of them 073 * were provided in the set of include branches.</LI> 074 * <LI>An optional list of base DNs for branches to include in the 075 * import.</LI> 076 * <LI>An optional list of base DNs for branches to exclude from the 077 * import.</LI> 078 * <LI>An optional list of search filters that may be used to determine 079 * whether an entry should be included in the import.</LI> 080 * <LI>An optional list of search filters that may be used to determine 081 * whether an entry should be excluded from the import.</LI> 082 * <LI>An optional list of attributes that should be included in the entries 083 * that are imported.</LI> 084 * <LI>An optional list of attributes that should be excluded from the entries 085 * that are imported.</LI> 086 * <LI>A flag that indicates whether the LDIF data to import is 087 * compressed.</LI> 088 * <LI>A flag that indicates whether the LDIF data to import is 089 * encrypted.</LI> 090 * <LI>A flag that indicates whether to skip schema validation for the data 091 * that is imported.</LI> 092 * </UL> 093 */ 094 @NotMutable() 095 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 096 public final class ImportTask 097 extends Task 098 { 099 /** 100 * The fully-qualified name of the Java class that is used for the import 101 * task. 102 */ 103 static final String IMPORT_TASK_CLASS = 104 "com.unboundid.directory.server.tasks.ImportTask"; 105 106 107 108 /** 109 * The name of the attribute used to indicate whether to append to an existing 110 * database rather than overwriting its content. 111 */ 112 private static final String ATTR_APPEND = 113 "ds-task-import-append"; 114 115 116 117 /** 118 * The name of the attribute used to specify the backend ID for the backend 119 * into which to import the data. 120 */ 121 private static final String ATTR_BACKEND_ID = "ds-task-import-backend-id"; 122 123 124 125 /** 126 * The name of the attribute used to indicate whether to clear the entire 127 * backend when importing based on base DN. 128 */ 129 private static final String ATTR_CLEAR_BACKEND = 130 "ds-task-import-clear-backend"; 131 132 133 134 /** 135 * The name of the attribute used to specify the attributes to exclude from 136 * entries being imported. 137 */ 138 private static final String ATTR_EXCLUDE_ATTRIBUTE = 139 "ds-task-import-exclude-attribute"; 140 141 142 143 /** 144 * The name of the attribute used to specify the base DNs of branches to 145 * exclude from the import. 146 */ 147 private static final String ATTR_EXCLUDE_BRANCH = 148 "ds-task-import-exclude-branch"; 149 150 151 152 /** 153 * The name of the attribute used to specify the filters used to determine 154 * whether to exclude an entry from the import. 155 */ 156 private static final String ATTR_EXCLUDE_FILTER = 157 "ds-task-import-exclude-filter"; 158 159 160 161 /** 162 * The name of the attribute used to specify the attributes to include in 163 * entries being imported. 164 */ 165 private static final String ATTR_INCLUDE_ATTRIBUTE = 166 "ds-task-import-include-attribute"; 167 168 169 170 /** 171 * The name of the attribute used to specify the base DNs of branches to 172 * include in the import. 173 */ 174 private static final String ATTR_INCLUDE_BRANCH = 175 "ds-task-import-include-branch"; 176 177 178 179 /** 180 * The name of the attribute used to specify the filters used to determine 181 * whether to include an entry in the import. 182 */ 183 private static final String ATTR_INCLUDE_FILTER = 184 "ds-task-import-include-filter"; 185 186 187 188 /** 189 * The name of the attribute used to indicate whether the LDIF data is 190 * compressed. 191 */ 192 private static final String ATTR_IS_COMPRESSED = 193 "ds-task-import-is-compressed"; 194 195 196 197 /** 198 * The name of the attribute used to indicate whether the LDIF data is 199 * encrypted. 200 */ 201 private static final String ATTR_IS_ENCRYPTED = 202 "ds-task-import-is-encrypted"; 203 204 205 206 /** 207 * The name of the attribute used to specify the paths to the LDIF files to be 208 * imported. 209 */ 210 private static final String ATTR_LDIF_FILE = "ds-task-import-ldif-file"; 211 212 213 214 /** 215 * The name of the attribute used to indicate whether to overwrite an existing 216 * reject file. 217 */ 218 private static final String ATTR_OVERWRITE_REJECTS = 219 "ds-task-import-overwrite-rejects"; 220 221 222 223 /** 224 * The name of the attribute used to specify the path to the reject file. 225 */ 226 private static final String ATTR_REJECT_FILE = "ds-task-import-reject-file"; 227 228 229 230 /** 231 * The name of the attribute used to indicate whether to replace existing 232 * entries when appending to a database rather than overwriting it. 233 */ 234 private static final String ATTR_REPLACE_EXISTING = 235 "ds-task-import-replace-existing"; 236 237 238 239 /** 240 * The name of the attribute used to indicate whether to skip schema 241 * validation for the import. 242 */ 243 private static final String ATTR_SKIP_SCHEMA_VALIDATION = 244 "ds-task-import-skip-schema-validation"; 245 246 247 248 /** 249 * The name of the attribute used to indicate whether to strip illegal 250 * trailing spaces from LDIF records rather than rejecting those records. 251 */ 252 private static final String ATTR_STRIP_TRAILING_SPACES = 253 "ds-task-import-strip-trailing-spaces"; 254 255 256 257 /** 258 * The task property for the backend ID. 259 */ 260 private static final TaskProperty PROPERTY_BACKEND_ID = 261 new TaskProperty(ATTR_BACKEND_ID, INFO_DISPLAY_NAME_BACKEND_ID.get(), 262 INFO_DESCRIPTION_BACKEND_ID_IMPORT.get(), String.class, 263 false, false, false); 264 265 266 267 /** 268 * The task property for the LDIF files. 269 */ 270 private static final TaskProperty PROPERTY_LDIF_FILE = 271 new TaskProperty(ATTR_LDIF_FILE, INFO_DISPLAY_NAME_LDIF_FILE.get(), 272 INFO_DESCRIPTION_LDIF_FILE_IMPORT.get(), String.class, 273 true, true, false); 274 275 276 277 /** 278 * The task property for the append flag. 279 */ 280 private static final TaskProperty PROPERTY_APPEND = 281 new TaskProperty(ATTR_APPEND, INFO_DISPLAY_NAME_APPEND_TO_DB.get(), 282 INFO_DESCRIPTION_APPEND_TO_DB.get(), Boolean.class, 283 false, false, true); 284 285 286 287 /** 288 * The task property for the replace existing flag. 289 */ 290 private static final TaskProperty PROPERTY_REPLACE_EXISTING = 291 new TaskProperty(ATTR_REPLACE_EXISTING, 292 INFO_DISPLAY_NAME_REPLACE_EXISTING.get(), 293 INFO_DESCRIPTION_REPLACE_EXISTING.get(), Boolean.class, 294 false, false, true); 295 296 297 298 /** 299 * The task property for the reject file. 300 */ 301 private static final TaskProperty PROPERTY_REJECT_FILE = 302 new TaskProperty(ATTR_REJECT_FILE, 303 INFO_DISPLAY_NAME_REJECT_FILE.get(), 304 INFO_DESCRIPTION_REJECT_FILE.get(), String.class, 305 false, false, false); 306 307 308 309 /** 310 * The task property for the overwrite rejects flag. 311 */ 312 private static final TaskProperty PROPERTY_OVERWRITE_REJECTS = 313 new TaskProperty(ATTR_OVERWRITE_REJECTS, 314 INFO_DISPLAY_NAME_OVERWRITE_REJECTS.get(), 315 INFO_DESCRIPTION_OVERWRITE_REJECTS.get(), Boolean.class, 316 false, false, true); 317 318 319 320 /** 321 * The task property for the clear backend flag. 322 */ 323 private static final TaskProperty PROPERTY_CLEAR_BACKEND = 324 new TaskProperty(ATTR_CLEAR_BACKEND, 325 INFO_DISPLAY_NAME_CLEAR_BACKEND.get(), 326 INFO_DESCRIPTION_CLEAR_BACKEND.get(), Boolean.class, 327 false, false, true); 328 329 330 331 /** 332 * The task property for the include branches. 333 */ 334 private static final TaskProperty PROPERTY_INCLUDE_BRANCH = 335 new TaskProperty(ATTR_INCLUDE_BRANCH, 336 INFO_DISPLAY_NAME_INCLUDE_BRANCH.get(), 337 INFO_DESCRIPTION_INCLUDE_BRANCH_IMPORT.get(), 338 String.class, false, true, true); 339 340 341 342 /** 343 * The task property for the exclude branches. 344 */ 345 private static final TaskProperty PROPERTY_EXCLUDE_BRANCH = 346 new TaskProperty(ATTR_EXCLUDE_BRANCH, 347 INFO_DISPLAY_NAME_EXCLUDE_BRANCH.get(), 348 INFO_DESCRIPTION_EXCLUDE_BRANCH_IMPORT.get(), 349 String.class, false, true, true); 350 351 352 353 /** 354 * The task property for the include filters. 355 */ 356 private static final TaskProperty PROPERTY_INCLUDE_FILTER = 357 new TaskProperty(ATTR_INCLUDE_FILTER, 358 INFO_DISPLAY_NAME_INCLUDE_FILTER.get(), 359 INFO_DESCRIPTION_INCLUDE_FILTER_IMPORT.get(), 360 String.class, false, true, true); 361 362 363 364 /** 365 * The task property for the exclude filters. 366 */ 367 private static final TaskProperty PROPERTY_EXCLUDE_FILTER = 368 new TaskProperty(ATTR_EXCLUDE_FILTER, 369 INFO_DISPLAY_NAME_EXCLUDE_FILTER.get(), 370 INFO_DESCRIPTION_EXCLUDE_FILTER_IMPORT.get(), 371 String.class, false, true, true); 372 373 374 375 /** 376 * The task property for the include attributes. 377 */ 378 private static final TaskProperty PROPERTY_INCLUDE_ATTRIBUTE = 379 new TaskProperty(ATTR_INCLUDE_ATTRIBUTE, 380 INFO_DISPLAY_NAME_INCLUDE_ATTRIBUTE.get(), 381 INFO_DESCRIPTION_INCLUDE_ATTRIBUTE_IMPORT.get(), 382 String.class, false, true, true); 383 384 385 386 /** 387 * The task property for the exclude attributes. 388 */ 389 private static final TaskProperty PROPERTY_EXCLUDE_ATTRIBUTE = 390 new TaskProperty(ATTR_EXCLUDE_ATTRIBUTE, 391 INFO_DISPLAY_NAME_EXCLUDE_ATTRIBUTE.get(), 392 INFO_DESCRIPTION_EXCLUDE_ATTRIBUTE_IMPORT.get(), 393 String.class, false, true, true); 394 395 396 397 /** 398 * The task property for the is compressed flag. 399 */ 400 private static final TaskProperty PROPERTY_IS_COMPRESSED = 401 new TaskProperty(ATTR_IS_COMPRESSED, 402 INFO_DISPLAY_NAME_IS_COMPRESSED_IMPORT.get(), 403 INFO_DESCRIPTION_IS_COMPRESSED_IMPORT.get(), 404 Boolean.class, false, false, false); 405 406 407 408 /** 409 * The task property for the is encrypted flag. 410 */ 411 private static final TaskProperty PROPERTY_IS_ENCRYPTED = 412 new TaskProperty(ATTR_IS_ENCRYPTED, 413 INFO_DISPLAY_NAME_IS_ENCRYPTED_IMPORT.get(), 414 INFO_DESCRIPTION_IS_ENCRYPTED_IMPORT.get(), 415 Boolean.class, false, false, false); 416 417 418 419 /** 420 * The task property for the skip schema validation flag. 421 */ 422 private static final TaskProperty PROPERTY_SKIP_SCHEMA_VALIDATION = 423 new TaskProperty(ATTR_SKIP_SCHEMA_VALIDATION, 424 INFO_DISPLAY_NAME_SKIP_SCHEMA_VALIDATION.get(), 425 INFO_DESCRIPTION_SKIP_SCHEMA_VALIDATION.get(), 426 Boolean.class, false, false, false); 427 428 429 430 /** 431 * The task property for the strip trailing spaces flag. 432 */ 433 private static final TaskProperty PROPERTY_STRIP_TRAILING_SPACES = 434 new TaskProperty(ATTR_STRIP_TRAILING_SPACES, 435 INFO_DISPLAY_NAME_STRIP_TRAILING_SPACES.get(), 436 INFO_DESCRIPTION_STRIP_TRAILING_SPACES.get(), 437 Boolean.class, false, false, false); 438 439 440 441 /** 442 * The name of the object class used in import task entries. 443 */ 444 private static final String OC_IMPORT_TASK = "ds-task-import"; 445 446 447 448 /** 449 * The serial version UID for this serializable class. 450 */ 451 private static final long serialVersionUID = -8451067488894354839L; 452 453 454 455 // Indicates whether to append to the database rather than overwriting it. 456 private final boolean append; 457 458 // Indicates whether to clear the entire backend when importing by base DN. 459 private final boolean clearBackend; 460 461 // Indicates whether the LDIF data is compressed. 462 private final boolean isCompressed; 463 464 // Indicates whether the LDIF data is encrypted. 465 private final boolean isEncrypted; 466 467 // Indicates whether to overwrite an existing reject file. 468 private final boolean overwriteRejects; 469 470 // Indicates whether to replace existing entries when appending to the DB. 471 private final boolean replaceExisting; 472 473 // Indicates whether to skip schema validation for the import. 474 private final boolean skipSchemaValidation; 475 476 // Indicates whether to strip illegal trailing spaces from LDIF records rather 477 // than rejecting them. 478 private final boolean stripTrailingSpaces; 479 480 // The set of exclude attributes for the import. 481 private final List<String> excludeAttributes; 482 483 // The set of exclude branches for the import. 484 private final List<String> excludeBranches; 485 486 // The set of exclude filters for the import. 487 private final List<String> excludeFilters; 488 489 // The set of include attributes for the import. 490 private final List<String> includeAttributes; 491 492 // The set of include branches for the import. 493 private final List<String> includeBranches; 494 495 // The set of include filters for the import. 496 private final List<String> includeFilters; 497 498 // The paths to the LDIF files to be imported. 499 private final List<String> ldifFiles; 500 501 // The backend ID of the backend to import. 502 private final String backendID; 503 504 // The path to the reject file to write. 505 private final String rejectFile; 506 507 508 509 /** 510 * Creates a new uninitialized import task instance which should only be used 511 * for obtaining general information about this task, including the task name, 512 * description, and supported properties. Attempts to use a task created with 513 * this constructor for any other reason will likely fail. 514 */ 515 public ImportTask() 516 { 517 append = false; 518 clearBackend = false; 519 isCompressed = false; 520 isEncrypted = false; 521 overwriteRejects = false; 522 replaceExisting = false; 523 skipSchemaValidation = false; 524 stripTrailingSpaces = false; 525 excludeAttributes = null; 526 excludeBranches = null; 527 excludeFilters = null; 528 includeAttributes = null; 529 includeBranches = null; 530 includeFilters = null; 531 ldifFiles = null; 532 backendID = null; 533 rejectFile = null; 534 } 535 536 537 538 /** 539 * Creates a new import task with the provided backend. It will overwrite 540 * the contents of the backend with the data in the provided LDIF file. 541 * 542 * @param taskID The task ID to use for this task. If it is {@code null} 543 * then a UUID will be generated for use as the task ID. 544 * @param backendID The backend ID of the backend into which the data should 545 * be imported. It must not be {@code null}. 546 * @param ldifFile The path to the LDIF file containing the data to be 547 * imported. It may be an absolute path or a path relative 548 * to the server install root. It must not be 549 * {@code null}. 550 */ 551 public ImportTask(final String taskID, final String backendID, 552 final String ldifFile) 553 { 554 this(taskID, Arrays.asList(ldifFile), backendID, false, false, null, false, 555 true, null, null, null, null, null, null, false, false, false, null, 556 null, null, null, null); 557 558 ensureNotNull(ldifFile); 559 } 560 561 562 563 /** 564 * Creates a new import task with the provided information. 565 * 566 * @param taskID The task ID to use for this task. If it is 567 * {@code null} then a UUID will be generated 568 * for use as the task ID. 569 * @param ldifFiles The paths to the LDIF file containing the 570 * data to be imported. The paths may be 571 * either absolute or relative to the server 572 * install root. It must not be {@code null} 573 * or empty.. 574 * @param backendID The backend ID of the backend into which 575 * the data should be imported. It may be 576 * {@code null} only if one or more include 577 * branches was specified. 578 * @param append Indicates whether to append to the existing 579 * data rather than overwriting it. 580 * @param replaceExisting Indicates whether to replace existing 581 * entries when appending to the database. 582 * @param rejectFile The path to a file into which information 583 * will be written about rejected entries. It 584 * may be {@code null} if no reject file is to 585 * be maintained. 586 * @param overwriteRejects Indicates whether to overwrite an existing 587 * rejects file rather than appending to it. 588 * @param clearBackend Indicates whether to clear data below all 589 * base DNs in the backend. It must be 590 * {@code true} if the backend was specified 591 * using a backend ID and no include branches 592 * are specified and {@code append} is 593 * {@code false}. If include branches were 594 * specified, or if data is being appended to 595 * the backend, then it may be either 596 * {@code true} or {@code false}. 597 * @param includeBranches The set of base DNs below which to import 598 * the data. It may be {@code null} or empty 599 * if a backend ID was specified and data 600 * should be imported below all base DNs 601 * defined in the backend. Otherwise, at 602 * least one include branch must be provided, 603 * and any data not under one of the include 604 * branches will be excluded from the import. 605 * All include branches must be within the 606 * scope of the same backend. 607 * @param excludeBranches The set of base DNs to exclude from the 608 * import. It may be {@code null} or empty if 609 * no data is to be excluded based on its 610 * location. 611 * @param includeFilters The set of filters to use to determine 612 * which entries should be included in the 613 * import. It may be {@code null} or empty if 614 * no data is to be excluded based on its 615 * content. 616 * @param excludeFilters The set of filters to use to determine 617 * which entries should be excluded from the 618 * import. It may be {@code null} or empty if 619 * no data is to be excluded based on its 620 * content. 621 * @param includeAttributes The set of attributes to include in the 622 * entries being imported. It may be 623 * {@code null} or empty if no attributes 624 * should be excluded from the import. 625 * @param excludeAttributes The set of attributes to exclude from the 626 * entries being imported. It may be 627 * {@code null} or empty if no attributes 628 * should be excluded from the import. 629 * @param isCompressed Indicates whether the data in the LDIF 630 * file(s) is compressed. 631 * @param isEncrypted Indicates whether the data in the LDIF 632 * file(s) is encrypted. 633 * @param skipSchemaValidation Indicates whether to skip schema validation 634 * during the import. 635 * @param scheduledStartTime The time that this task should start 636 * running. 637 * @param dependencyIDs The list of task IDs that will be required 638 * to complete before this task will be 639 * eligible to start. 640 * @param failedDependencyAction Indicates what action should be taken if 641 * any of the dependencies for this task do 642 * not complete successfully. 643 * @param notifyOnCompletion The list of e-mail addresses of individuals 644 * that should be notified when this task 645 * completes. 646 * @param notifyOnError The list of e-mail addresses of individuals 647 * that should be notified if this task does 648 * not complete successfully. 649 */ 650 public ImportTask(final String taskID, final List<String> ldifFiles, 651 final String backendID, final boolean append, 652 final boolean replaceExisting, final String rejectFile, 653 final boolean overwriteRejects, final boolean clearBackend, 654 final List<String> includeBranches, 655 final List<String> excludeBranches, 656 final List<String> includeFilters, 657 final List<String> excludeFilters, 658 final List<String> includeAttributes, 659 final List<String> excludeAttributes, 660 final boolean isCompressed, final boolean isEncrypted, 661 final boolean skipSchemaValidation, 662 final Date scheduledStartTime, 663 final List<String> dependencyIDs, 664 final FailedDependencyAction failedDependencyAction, 665 final List<String> notifyOnCompletion, 666 final List<String> notifyOnError) 667 { 668 this(taskID, ldifFiles, backendID, append, replaceExisting, rejectFile, 669 overwriteRejects, clearBackend, includeBranches, excludeBranches, 670 includeFilters, excludeFilters, includeAttributes, excludeAttributes, 671 isCompressed, isEncrypted, skipSchemaValidation, false, 672 scheduledStartTime, dependencyIDs, failedDependencyAction, 673 notifyOnCompletion, notifyOnError); 674 } 675 676 677 678 /** 679 * Creates a new import task with the provided information. 680 * 681 * @param taskID The task ID to use for this task. If it is 682 * {@code null} then a UUID will be generated 683 * for use as the task ID. 684 * @param ldifFiles The paths to the LDIF file containing the 685 * data to be imported. The paths may be 686 * either absolute or relative to the server 687 * install root. It must not be {@code null} 688 * or empty.. 689 * @param backendID The backend ID of the backend into which 690 * the data should be imported. It may be 691 * {@code null} only if one or more include 692 * branches was specified. 693 * @param append Indicates whether to append to the existing 694 * data rather than overwriting it. 695 * @param replaceExisting Indicates whether to replace existing 696 * entries when appending to the database. 697 * @param rejectFile The path to a file into which information 698 * will be written about rejected entries. It 699 * may be {@code null} if no reject file is to 700 * be maintained. 701 * @param overwriteRejects Indicates whether to overwrite an existing 702 * rejects file rather than appending to it. 703 * @param clearBackend Indicates whether to clear data below all 704 * base DNs in the backend. It must be 705 * {@code true} if the backend was specified 706 * using a backend ID and no include branches 707 * are specified and {@code append} is 708 * {@code false}. If include branches were 709 * specified, or if data is being appended to 710 * the backend, then it may be either 711 * {@code true} or {@code false}. 712 * @param includeBranches The set of base DNs below which to import 713 * the data. It may be {@code null} or empty 714 * if a backend ID was specified and data 715 * should be imported below all base DNs 716 * defined in the backend. Otherwise, at 717 * least one include branch must be provided, 718 * and any data not under one of the include 719 * branches will be excluded from the import. 720 * All include branches must be within the 721 * scope of the same backend. 722 * @param excludeBranches The set of base DNs to exclude from the 723 * import. It may be {@code null} or empty if 724 * no data is to be excluded based on its 725 * location. 726 * @param includeFilters The set of filters to use to determine 727 * which entries should be included in the 728 * import. It may be {@code null} or empty if 729 * no data is to be excluded based on its 730 * content. 731 * @param excludeFilters The set of filters to use to determine 732 * which entries should be excluded from the 733 * import. It may be {@code null} or empty if 734 * no data is to be excluded based on its 735 * content. 736 * @param includeAttributes The set of attributes to include in the 737 * entries being imported. It may be 738 * {@code null} or empty if no attributes 739 * should be excluded from the import. 740 * @param excludeAttributes The set of attributes to exclude from the 741 * entries being imported. It may be 742 * {@code null} or empty if no attributes 743 * should be excluded from the import. 744 * @param isCompressed Indicates whether the data in the LDIF 745 * file(s) is compressed. 746 * @param isEncrypted Indicates whether the data in the LDIF 747 * file(s) is encrypted. 748 * @param skipSchemaValidation Indicates whether to skip schema validation 749 * during the import. 750 * @param stripTrailingSpaces Indicates whether to strip illegal trailing 751 * spaces found in LDIF records rather than 752 * rejecting those records. 753 * @param scheduledStartTime The time that this task should start 754 * running. 755 * @param dependencyIDs The list of task IDs that will be required 756 * to complete before this task will be 757 * eligible to start. 758 * @param failedDependencyAction Indicates what action should be taken if 759 * any of the dependencies for this task do 760 * not complete successfully. 761 * @param notifyOnCompletion The list of e-mail addresses of individuals 762 * that should be notified when this task 763 * completes. 764 * @param notifyOnError The list of e-mail addresses of individuals 765 * that should be notified if this task does 766 * not complete successfully. 767 */ 768 public ImportTask(final String taskID, final List<String> ldifFiles, 769 final String backendID, final boolean append, 770 final boolean replaceExisting, final String rejectFile, 771 final boolean overwriteRejects, final boolean clearBackend, 772 final List<String> includeBranches, 773 final List<String> excludeBranches, 774 final List<String> includeFilters, 775 final List<String> excludeFilters, 776 final List<String> includeAttributes, 777 final List<String> excludeAttributes, 778 final boolean isCompressed, final boolean isEncrypted, 779 final boolean skipSchemaValidation, 780 final boolean stripTrailingSpaces, 781 final Date scheduledStartTime, 782 final List<String> dependencyIDs, 783 final FailedDependencyAction failedDependencyAction, 784 final List<String> notifyOnCompletion, 785 final List<String> notifyOnError) 786 { 787 super(taskID, IMPORT_TASK_CLASS, scheduledStartTime, 788 dependencyIDs, failedDependencyAction, notifyOnCompletion, 789 notifyOnError); 790 791 ensureNotNull(ldifFiles); 792 ensureFalse(ldifFiles.isEmpty(), 793 "ImportTask.ldifFiles must not be empty."); 794 ensureFalse((backendID == null) && 795 ((includeBranches == null) || includeBranches.isEmpty())); 796 ensureTrue(clearBackend || append || 797 ((includeBranches != null) && (! includeBranches.isEmpty()))); 798 799 this.ldifFiles = Collections.unmodifiableList(ldifFiles); 800 this.backendID = backendID; 801 this.append = append; 802 this.replaceExisting = replaceExisting; 803 this.rejectFile = rejectFile; 804 this.overwriteRejects = overwriteRejects; 805 this.clearBackend = clearBackend; 806 this.isCompressed = isCompressed; 807 this.isEncrypted = isEncrypted; 808 this.skipSchemaValidation = skipSchemaValidation; 809 this.stripTrailingSpaces = stripTrailingSpaces; 810 811 if (includeBranches == null) 812 { 813 this.includeBranches = Collections.emptyList(); 814 } 815 else 816 { 817 this.includeBranches = Collections.unmodifiableList(includeBranches); 818 } 819 820 if (excludeBranches == null) 821 { 822 this.excludeBranches = Collections.emptyList(); 823 } 824 else 825 { 826 this.excludeBranches = Collections.unmodifiableList(excludeBranches); 827 } 828 829 if (includeFilters == null) 830 { 831 this.includeFilters = Collections.emptyList(); 832 } 833 else 834 { 835 this.includeFilters = Collections.unmodifiableList(includeFilters); 836 } 837 838 if (excludeFilters == null) 839 { 840 this.excludeFilters = Collections.emptyList(); 841 } 842 else 843 { 844 this.excludeFilters = Collections.unmodifiableList(excludeFilters); 845 } 846 847 if (includeAttributes == null) 848 { 849 this.includeAttributes = Collections.emptyList(); 850 } 851 else 852 { 853 this.includeAttributes = Collections.unmodifiableList(includeAttributes); 854 } 855 856 if (excludeAttributes == null) 857 { 858 this.excludeAttributes = Collections.emptyList(); 859 } 860 else 861 { 862 this.excludeAttributes = Collections.unmodifiableList(excludeAttributes); 863 } 864 } 865 866 867 868 /** 869 * Creates a new import task from the provided entry. 870 * 871 * @param entry The entry to use to create this import task. 872 * 873 * @throws TaskException If the provided entry cannot be parsed as an import 874 * task entry. 875 */ 876 public ImportTask(final Entry entry) 877 throws TaskException 878 { 879 super(entry); 880 881 882 // Get the set of LDIF files. It must be present. 883 final String[] files = entry.getAttributeValues(ATTR_LDIF_FILE); 884 if ((files == null) || (files.length == 0)) 885 { 886 throw new TaskException(ERR_IMPORT_TASK_NO_LDIF.get(getTaskEntryDN())); 887 } 888 else 889 { 890 ldifFiles = Collections.unmodifiableList(Arrays.asList(files)); 891 } 892 893 894 // Get the backend ID. It may be absent. 895 backendID = entry.getAttributeValue(ATTR_BACKEND_ID); 896 897 898 // Get the append flag. It may be absent. 899 append = parseBooleanValue(entry, ATTR_APPEND, false); 900 901 902 // Get the replaceExisting flag. It may be absent. 903 replaceExisting = parseBooleanValue(entry, ATTR_REPLACE_EXISTING, false); 904 905 906 // Get the reject file. It may be absent. 907 rejectFile = entry.getAttributeValue(ATTR_REJECT_FILE); 908 909 910 // Get the overwriteRejects flag. It may be absent. 911 overwriteRejects = parseBooleanValue(entry, ATTR_OVERWRITE_REJECTS, false); 912 913 914 // Get the clearBackend flag. It may be absent. 915 clearBackend = parseBooleanValue(entry, ATTR_CLEAR_BACKEND, false); 916 917 918 // Get the list of include branches. It may be absent. 919 includeBranches = parseStringList(entry, ATTR_INCLUDE_BRANCH); 920 921 922 // Get the list of exclude branches. It may be absent. 923 excludeBranches = parseStringList(entry, ATTR_EXCLUDE_BRANCH); 924 925 926 // Get the list of include filters. It may be absent. 927 includeFilters = parseStringList(entry, ATTR_INCLUDE_FILTER); 928 929 930 // Get the list of exclude filters. It may be absent. 931 excludeFilters = parseStringList(entry, ATTR_EXCLUDE_FILTER); 932 933 934 // Get the list of include attributes. It may be absent. 935 includeAttributes = parseStringList(entry, ATTR_INCLUDE_ATTRIBUTE); 936 937 938 // Get the list of exclude attributes. It may be absent. 939 excludeAttributes = parseStringList(entry, ATTR_EXCLUDE_ATTRIBUTE); 940 941 942 // Get the isCompressed flag. It may be absent. 943 isCompressed = parseBooleanValue(entry, ATTR_IS_COMPRESSED, false); 944 945 946 // Get the isEncrypted flag. It may be absent. 947 isEncrypted = parseBooleanValue(entry, ATTR_IS_ENCRYPTED, false); 948 949 950 // Get the skipSchemaValidation flag. It may be absent. 951 skipSchemaValidation = parseBooleanValue(entry, ATTR_SKIP_SCHEMA_VALIDATION, 952 false); 953 954 955 // Get the stripTrailingSpaces flag. It may be absent. 956 stripTrailingSpaces = parseBooleanValue(entry, ATTR_STRIP_TRAILING_SPACES, 957 false); 958 } 959 960 961 962 /** 963 * Creates a new import task from the provided set of task properties. 964 * 965 * @param properties The set of task properties and their corresponding 966 * values to use for the task. It must not be 967 * {@code null}. 968 * 969 * @throws TaskException If the provided set of properties cannot be used to 970 * create a valid import task. 971 */ 972 public ImportTask(final Map<TaskProperty,List<Object>> properties) 973 throws TaskException 974 { 975 super(IMPORT_TASK_CLASS, properties); 976 977 boolean a = false; 978 boolean c = false; 979 boolean cB = true; 980 boolean e = false; 981 boolean o = false; 982 boolean r = false; 983 boolean ss = false; 984 boolean st = false; 985 String b = null; 986 String rF = null; 987 String[] eA = StaticUtils.NO_STRINGS; 988 String[] eB = StaticUtils.NO_STRINGS; 989 String[] eF = StaticUtils.NO_STRINGS; 990 String[] iA = StaticUtils.NO_STRINGS; 991 String[] iB = StaticUtils.NO_STRINGS; 992 String[] iF = StaticUtils.NO_STRINGS; 993 String[] l = StaticUtils.NO_STRINGS; 994 995 for (final Map.Entry<TaskProperty,List<Object>> entry : 996 properties.entrySet()) 997 { 998 final TaskProperty p = entry.getKey(); 999 final String attrName = p.getAttributeName(); 1000 final List<Object> values = entry.getValue(); 1001 1002 if (attrName.equalsIgnoreCase(ATTR_BACKEND_ID)) 1003 { 1004 b = parseString(p, values, b); 1005 } 1006 else if (attrName.equalsIgnoreCase(ATTR_LDIF_FILE)) 1007 { 1008 l = parseStrings(p, values, l); 1009 } 1010 else if (attrName.equalsIgnoreCase(ATTR_APPEND)) 1011 { 1012 a = parseBoolean(p, values, a); 1013 } 1014 else if (attrName.equalsIgnoreCase(ATTR_REPLACE_EXISTING)) 1015 { 1016 r = parseBoolean(p, values, r); 1017 } 1018 else if (attrName.equalsIgnoreCase(ATTR_REJECT_FILE)) 1019 { 1020 rF = parseString(p, values, rF); 1021 } 1022 else if (attrName.equalsIgnoreCase(ATTR_OVERWRITE_REJECTS)) 1023 { 1024 o = parseBoolean(p, values, o); 1025 } 1026 else if (attrName.equalsIgnoreCase(ATTR_CLEAR_BACKEND)) 1027 { 1028 cB = parseBoolean(p, values, cB); 1029 } 1030 else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_BRANCH)) 1031 { 1032 iB = parseStrings(p, values, iB); 1033 } 1034 else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_BRANCH)) 1035 { 1036 eB = parseStrings(p, values, eB); 1037 } 1038 else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_FILTER)) 1039 { 1040 iF = parseStrings(p, values, iF); 1041 } 1042 else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_FILTER)) 1043 { 1044 eF = parseStrings(p, values, eF); 1045 } 1046 else if (attrName.equalsIgnoreCase(ATTR_INCLUDE_ATTRIBUTE)) 1047 { 1048 iA = parseStrings(p, values, iA); 1049 } 1050 else if (attrName.equalsIgnoreCase(ATTR_EXCLUDE_ATTRIBUTE)) 1051 { 1052 eA = parseStrings(p, values, eA); 1053 } 1054 else if (attrName.equalsIgnoreCase(ATTR_IS_COMPRESSED)) 1055 { 1056 c = parseBoolean(p, values, c); 1057 } 1058 else if (attrName.equalsIgnoreCase(ATTR_IS_ENCRYPTED)) 1059 { 1060 e = parseBoolean(p, values, e); 1061 } 1062 else if (attrName.equalsIgnoreCase(ATTR_SKIP_SCHEMA_VALIDATION)) 1063 { 1064 ss = parseBoolean(p, values, ss); 1065 } 1066 else if (attrName.equalsIgnoreCase(ATTR_STRIP_TRAILING_SPACES)) 1067 { 1068 st = parseBoolean(p, values, st); 1069 } 1070 } 1071 1072 if ((b == null) && (iB.length == 0)) 1073 { 1074 throw new TaskException( 1075 ERR_IMPORT_TASK_NO_BACKEND_ID_OR_INCLUDE_BRANCHES.get( 1076 getTaskEntryDN())); 1077 } 1078 1079 if (l == null) 1080 { 1081 throw new TaskException(ERR_IMPORT_TASK_NO_LDIF.get( 1082 getTaskEntryDN())); 1083 } 1084 1085 backendID = b; 1086 ldifFiles = Collections.unmodifiableList(Arrays.asList(l)); 1087 append = a; 1088 replaceExisting = r; 1089 rejectFile = rF; 1090 overwriteRejects = o; 1091 clearBackend = cB; 1092 includeAttributes = Collections.unmodifiableList(Arrays.asList(iA)); 1093 excludeAttributes = Collections.unmodifiableList(Arrays.asList(eA)); 1094 includeBranches = Collections.unmodifiableList(Arrays.asList(iB)); 1095 excludeBranches = Collections.unmodifiableList(Arrays.asList(eB)); 1096 includeFilters = Collections.unmodifiableList(Arrays.asList(iF)); 1097 excludeFilters = Collections.unmodifiableList(Arrays.asList(eF)); 1098 isCompressed = c; 1099 isEncrypted = e; 1100 skipSchemaValidation = ss; 1101 stripTrailingSpaces = st; 1102 } 1103 1104 1105 1106 /** 1107 * {@inheritDoc} 1108 */ 1109 @Override() 1110 public String getTaskName() 1111 { 1112 return INFO_TASK_NAME_IMPORT.get(); 1113 } 1114 1115 1116 1117 /** 1118 * {@inheritDoc} 1119 */ 1120 @Override() 1121 public String getTaskDescription() 1122 { 1123 return INFO_TASK_DESCRIPTION_IMPORT.get(); 1124 } 1125 1126 1127 1128 /** 1129 * Retrieves the paths to the LDIF files containing the data to be imported. 1130 * The paths may be absolute or relative to the server root. 1131 * 1132 * @return The paths to the LDIF files containing the data to be imported. 1133 */ 1134 public List<String> getLDIFFiles() 1135 { 1136 return ldifFiles; 1137 } 1138 1139 1140 1141 /** 1142 * Retrieves the backend ID of the backend into which the data should be 1143 * imported. 1144 * 1145 * @return The backend ID of the backend into which the data should be 1146 * imported, or {@code null} if no backend ID was specified and the 1147 * backend will be identified from the include branches. 1148 */ 1149 public String getBackendID() 1150 { 1151 return backendID; 1152 } 1153 1154 1155 1156 /** 1157 * Indicates whether the import should append to the data in the backend 1158 * rather than clearing the backend before performing the import. 1159 * 1160 * @return {@code true} if the contents of the existing backend should be 1161 * retained and the new data appended to it, or {@code false} if the 1162 * existing content should be cleared prior to performing the import. 1163 */ 1164 public boolean append() 1165 { 1166 return append; 1167 } 1168 1169 1170 1171 /** 1172 * Indicates whether to replace existing entries when appending data to the 1173 * backend. This is only applicable if {@code append()} returns {@code true}. 1174 * 1175 * @return {@code true} if entries already present in the backend should be 1176 * replaced if that entry is also present in the LDIF file, or 1177 * {@code false} if entries already present in the backend should be 1178 * retained and the corresponding entry contained in the LDIF should 1179 * be skipped. 1180 */ 1181 public boolean replaceExistingEntries() 1182 { 1183 return replaceExisting; 1184 } 1185 1186 1187 1188 /** 1189 * Retrieves the path to a file to which rejected entries should be written. 1190 * 1191 * @return The path to a file to which rejected entries should be written, or 1192 * {@code null} if a rejected entries file should not be maintained. 1193 */ 1194 public String getRejectFile() 1195 { 1196 return rejectFile; 1197 } 1198 1199 1200 1201 /** 1202 * Indicates whether an existing reject file should be overwritten rather than 1203 * appending to it. 1204 * 1205 * @return {@code true} if an existing reject file should be overwritten, or 1206 * {@code false} if the server should append to it. 1207 */ 1208 public boolean overwriteRejectFile() 1209 { 1210 return overwriteRejects; 1211 } 1212 1213 1214 1215 /** 1216 * Indicates whether data below all base DNs defined in the backend should be 1217 * cleared before performing the import. This is not applicable if the import 1218 * is to append to the backend, or if the backend only has a single base DN. 1219 * 1220 * @return {@code true} if data below all base DNs in the backend should be 1221 * cleared, or {@code false} if only data below the base DNs that 1222 * correspond to the configured include branches should be cleared. 1223 */ 1224 public boolean clearBackend() 1225 { 1226 return clearBackend; 1227 } 1228 1229 1230 1231 /** 1232 * Retrieves the list of base DNs for branches that should be included in the 1233 * import. 1234 * 1235 * @return The set of base DNs for branches that should be included in the 1236 * import, or an empty list if data should be imported from all base 1237 * DNs in the associated backend. 1238 */ 1239 public List<String> getIncludeBranches() 1240 { 1241 return includeBranches; 1242 } 1243 1244 1245 1246 /** 1247 * Retrieves the list of base DNs of branches that should be excluded from the 1248 * import. 1249 * 1250 * @return The list of base DNs of branches that should be excluded from the 1251 * import, or an empty list if no entries should be excluded from the 1252 * import based on their location. 1253 */ 1254 public List<String> getExcludeBranches() 1255 { 1256 return excludeBranches; 1257 } 1258 1259 1260 1261 /** 1262 * Retrieves the list of search filters that may be used to identify which 1263 * entries should be included in the import. 1264 * 1265 * @return The list of search filters that may be used to identify which 1266 * entries should be included in the import, or an empty list if no 1267 * entries should be excluded from the import based on their content. 1268 */ 1269 public List<String> getIncludeFilters() 1270 { 1271 return includeFilters; 1272 } 1273 1274 1275 1276 /** 1277 * Retrieves the list of search filters that may be used to identify which 1278 * entries should be excluded from the import. 1279 * 1280 * @return The list of search filters that may be used to identify which 1281 * entries should be excluded from the import, or an empty list if no 1282 * entries should be excluded from the import based on their content. 1283 */ 1284 public List<String> getExcludeFilters() 1285 { 1286 return excludeFilters; 1287 } 1288 1289 1290 1291 /** 1292 * Retrieves the list of attributes that should be included in the imported 1293 * entries. 1294 * 1295 * @return The list of attributes that should be included in the imported 1296 * entries, or an empty list if no attributes should be excluded. 1297 */ 1298 public List<String> getIncludeAttributes() 1299 { 1300 return includeAttributes; 1301 } 1302 1303 1304 1305 /** 1306 * Retrieves the list of attributes that should be excluded from the imported 1307 * entries. 1308 * 1309 * @return The list of attributes that should be excluded from the imported 1310 * entries, or an empty list if no attributes should be excluded. 1311 */ 1312 public List<String> getExcludeAttributes() 1313 { 1314 return excludeAttributes; 1315 } 1316 1317 1318 1319 /** 1320 * Indicates whether the LDIF data to import is compressed. 1321 * 1322 * @return {@code true} if the LDIF data to import is compressed, or 1323 * {@code false} if not. 1324 */ 1325 public boolean isCompressed() 1326 { 1327 return isCompressed; 1328 } 1329 1330 1331 1332 /** 1333 * Indicates whether the LDIF data to import is encrypted. 1334 * 1335 * @return {@code true} if the LDIF data to import is encrypted, or 1336 * {@code false} if not. 1337 */ 1338 public boolean isEncrypted() 1339 { 1340 return isEncrypted; 1341 } 1342 1343 1344 1345 /** 1346 * Indicates whether the server should skip schema validation processing when 1347 * performing the import. 1348 * 1349 * @return {@code true} if the server should skip schema validation 1350 * processing when performing the import, or {@code false} if not. 1351 */ 1352 public boolean skipSchemaValidation() 1353 { 1354 return skipSchemaValidation; 1355 } 1356 1357 1358 1359 /** 1360 * Indicates whether the server should strip off any illegal trailing spaces 1361 * found in LDIF records rather than rejecting those records. 1362 * 1363 * @return {@code true} if the server should strip off any illegal trailing 1364 * spaces found in LDIF records, or {@code false} if it should reject 1365 * any records containing illegal trailing spaces. 1366 */ 1367 public boolean stripTrailingSpaces() 1368 { 1369 return stripTrailingSpaces; 1370 } 1371 1372 1373 1374 /** 1375 * {@inheritDoc} 1376 */ 1377 @Override() 1378 protected List<String> getAdditionalObjectClasses() 1379 { 1380 return Arrays.asList(OC_IMPORT_TASK); 1381 } 1382 1383 1384 1385 /** 1386 * {@inheritDoc} 1387 */ 1388 @Override() 1389 protected List<Attribute> getAdditionalAttributes() 1390 { 1391 final ArrayList<Attribute> attrs = new ArrayList<Attribute>(16); 1392 1393 attrs.add(new Attribute(ATTR_LDIF_FILE, ldifFiles)); 1394 attrs.add(new Attribute(ATTR_APPEND, String.valueOf(append))); 1395 attrs.add(new Attribute(ATTR_REPLACE_EXISTING, 1396 String.valueOf(replaceExisting))); 1397 attrs.add(new Attribute(ATTR_OVERWRITE_REJECTS, 1398 String.valueOf(overwriteRejects))); 1399 attrs.add(new Attribute(ATTR_CLEAR_BACKEND, String.valueOf(clearBackend))); 1400 attrs.add(new Attribute(ATTR_IS_COMPRESSED, String.valueOf(isCompressed))); 1401 attrs.add(new Attribute(ATTR_IS_ENCRYPTED, String.valueOf(isEncrypted))); 1402 attrs.add(new Attribute(ATTR_SKIP_SCHEMA_VALIDATION, 1403 String.valueOf(skipSchemaValidation))); 1404 1405 if (stripTrailingSpaces) 1406 { 1407 attrs.add(new Attribute(ATTR_STRIP_TRAILING_SPACES, 1408 String.valueOf(stripTrailingSpaces))); 1409 } 1410 1411 if (backendID != null) 1412 { 1413 attrs.add(new Attribute(ATTR_BACKEND_ID, backendID)); 1414 } 1415 1416 if (rejectFile != null) 1417 { 1418 attrs.add(new Attribute(ATTR_REJECT_FILE, rejectFile)); 1419 } 1420 1421 if (! includeBranches.isEmpty()) 1422 { 1423 attrs.add(new Attribute(ATTR_INCLUDE_BRANCH, includeBranches)); 1424 } 1425 1426 if (! excludeBranches.isEmpty()) 1427 { 1428 attrs.add(new Attribute(ATTR_EXCLUDE_BRANCH, excludeBranches)); 1429 } 1430 1431 if (! includeAttributes.isEmpty()) 1432 { 1433 attrs.add(new Attribute(ATTR_INCLUDE_ATTRIBUTE, includeAttributes)); 1434 } 1435 1436 if (! excludeAttributes.isEmpty()) 1437 { 1438 attrs.add(new Attribute(ATTR_EXCLUDE_ATTRIBUTE, excludeAttributes)); 1439 } 1440 1441 if (! includeFilters.isEmpty()) 1442 { 1443 attrs.add(new Attribute(ATTR_INCLUDE_FILTER, includeFilters)); 1444 } 1445 1446 if (! excludeFilters.isEmpty()) 1447 { 1448 attrs.add(new Attribute(ATTR_EXCLUDE_FILTER, excludeFilters)); 1449 } 1450 1451 return attrs; 1452 } 1453 1454 1455 1456 /** 1457 * {@inheritDoc} 1458 */ 1459 @Override() 1460 public List<TaskProperty> getTaskSpecificProperties() 1461 { 1462 final List<TaskProperty> propList = Arrays.asList( 1463 PROPERTY_BACKEND_ID, 1464 PROPERTY_LDIF_FILE, 1465 PROPERTY_APPEND, 1466 PROPERTY_REPLACE_EXISTING, 1467 PROPERTY_REJECT_FILE, 1468 PROPERTY_OVERWRITE_REJECTS, 1469 PROPERTY_CLEAR_BACKEND, 1470 PROPERTY_INCLUDE_BRANCH, 1471 PROPERTY_EXCLUDE_BRANCH, 1472 PROPERTY_INCLUDE_FILTER, 1473 PROPERTY_EXCLUDE_FILTER, 1474 PROPERTY_INCLUDE_ATTRIBUTE, 1475 PROPERTY_EXCLUDE_ATTRIBUTE, 1476 PROPERTY_IS_COMPRESSED, 1477 PROPERTY_IS_ENCRYPTED, 1478 PROPERTY_SKIP_SCHEMA_VALIDATION, 1479 PROPERTY_STRIP_TRAILING_SPACES); 1480 1481 return Collections.unmodifiableList(propList); 1482 } 1483 1484 1485 1486 /** 1487 * {@inheritDoc} 1488 */ 1489 @Override() 1490 public Map<TaskProperty,List<Object>> getTaskPropertyValues() 1491 { 1492 final LinkedHashMap<TaskProperty,List<Object>> props = 1493 new LinkedHashMap<TaskProperty,List<Object>>(); 1494 1495 if (backendID == null) 1496 { 1497 props.put(PROPERTY_BACKEND_ID, Collections.emptyList()); 1498 } 1499 else 1500 { 1501 props.put(PROPERTY_BACKEND_ID, 1502 Collections.<Object>unmodifiableList(Arrays.asList(backendID))); 1503 } 1504 1505 props.put(PROPERTY_LDIF_FILE, 1506 Collections.<Object>unmodifiableList(ldifFiles)); 1507 1508 props.put(PROPERTY_APPEND, 1509 Collections.<Object>unmodifiableList(Arrays.asList(append))); 1510 1511 props.put(PROPERTY_REPLACE_EXISTING, 1512 Collections.<Object>unmodifiableList(Arrays.asList( 1513 replaceExisting))); 1514 1515 if (rejectFile == null) 1516 { 1517 props.put(PROPERTY_REJECT_FILE, Collections.emptyList()); 1518 } 1519 else 1520 { 1521 props.put(PROPERTY_REJECT_FILE, 1522 Collections.<Object>unmodifiableList(Arrays.asList( 1523 rejectFile))); 1524 } 1525 1526 props.put(PROPERTY_OVERWRITE_REJECTS, 1527 Collections.<Object>unmodifiableList(Arrays.asList( 1528 overwriteRejects))); 1529 1530 props.put(PROPERTY_CLEAR_BACKEND, 1531 Collections.<Object>unmodifiableList(Arrays.asList( 1532 clearBackend))); 1533 1534 props.put(PROPERTY_INCLUDE_BRANCH, 1535 Collections.<Object>unmodifiableList(includeBranches)); 1536 1537 props.put(PROPERTY_EXCLUDE_BRANCH, 1538 Collections.<Object>unmodifiableList(excludeBranches)); 1539 1540 props.put(PROPERTY_INCLUDE_FILTER, 1541 Collections.<Object>unmodifiableList(includeFilters)); 1542 1543 props.put(PROPERTY_EXCLUDE_FILTER, 1544 Collections.<Object>unmodifiableList(excludeFilters)); 1545 1546 props.put(PROPERTY_INCLUDE_ATTRIBUTE, 1547 Collections.<Object>unmodifiableList(includeAttributes)); 1548 1549 props.put(PROPERTY_EXCLUDE_ATTRIBUTE, 1550 Collections.<Object>unmodifiableList(excludeAttributes)); 1551 1552 props.put(PROPERTY_IS_COMPRESSED, 1553 Collections.<Object>unmodifiableList(Arrays.asList( 1554 isCompressed))); 1555 1556 props.put(PROPERTY_IS_ENCRYPTED, 1557 Collections.<Object>unmodifiableList(Arrays.asList( 1558 isEncrypted))); 1559 1560 props.put(PROPERTY_SKIP_SCHEMA_VALIDATION, 1561 Collections.<Object>unmodifiableList(Arrays.asList( 1562 skipSchemaValidation))); 1563 1564 props.put(PROPERTY_STRIP_TRAILING_SPACES, 1565 Collections.<Object>unmodifiableList(Arrays.asList( 1566 stripTrailingSpaces))); 1567 1568 props.putAll(super.getTaskPropertyValues()); 1569 return Collections.unmodifiableMap(props); 1570 } 1571 }