/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at legal-notices/CDDLv1_0.txt.
|
* If applicable, add the following below this CDDL HEADER, with the
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
* information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Copyright 2006-2009 Sun Microsystems, Inc.
|
* Portions Copyright 2013-2014 ForgeRock AS
|
*/
|
package org.opends.server.tasks;
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.opends.messages.TaskMessages;
|
|
import static org.opends.messages.TaskMessages.*;
|
import static org.opends.messages.ToolMessages.*;
|
import org.forgerock.i18n.slf4j.LocalizedLogger;
|
import org.opends.server.tools.makeldif.TemplateFile;
|
import static org.opends.server.util.StaticUtils.*;
|
import static org.opends.server.config.ConfigConstants.*;
|
import static org.opends.server.core.DirectoryServer.getAttributeType;
|
|
import org.opends.server.backends.task.Task;
|
import org.opends.server.backends.task.TaskState;
|
import org.opends.server.core.DirectoryServer;
|
import org.opends.server.core.LockFileManager;
|
import org.opends.server.api.Backend;
|
import org.opends.server.api.ClientConnection;
|
import org.opends.server.types.Attribute;
|
import org.opends.server.types.AttributeType;
|
import org.opends.server.types.DirectoryException;
|
import org.opends.server.types.DN;
|
import org.opends.server.types.Entry;
|
|
|
import org.opends.server.types.ExistingFileBehavior;
|
import org.opends.server.types.LDIFImportConfig;
|
import org.opends.server.types.Operation;
|
import org.opends.server.types.Privilege;
|
import org.opends.server.types.ResultCode;
|
import org.opends.server.types.SearchFilter;
|
|
import java.io.File;
|
import java.util.HashSet;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.HashMap;
|
import java.util.Random;
|
|
/**
|
* This class provides an implementation of a Directory Server task that can
|
* be used to import data from an LDIF file into a backend.
|
*/
|
public class ImportTask extends Task
|
{
|
private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();
|
|
|
/**
|
* Stores mapping between configuration attribute name and its label.
|
*/
|
static private Map<String,LocalizableMessage> argDisplayMap =
|
new HashMap<String,LocalizableMessage>();
|
|
static {
|
argDisplayMap.put(
|
ATTR_IMPORT_LDIF_FILE,
|
INFO_IMPORT_ARG_LDIF_FILE.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_TEMPLATE_FILE,
|
INFO_IMPORT_ARG_TEMPLATE_FILE.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_RANDOM_SEED,
|
INFO_IMPORT_ARG_RANDOM_SEED.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_APPEND,
|
INFO_IMPORT_ARG_APPEND.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_REPLACE_EXISTING,
|
INFO_IMPORT_ARG_REPLACE_EXISTING.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_BACKEND_ID,
|
INFO_IMPORT_ARG_BACKEND_ID.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_INCLUDE_BRANCH,
|
INFO_IMPORT_ARG_INCL_BRANCH.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_EXCLUDE_BRANCH,
|
INFO_IMPORT_ARG_EXCL_BRANCH.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_INCLUDE_ATTRIBUTE,
|
INFO_IMPORT_ARG_INCL_ATTR.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_EXCLUDE_ATTRIBUTE,
|
INFO_IMPORT_ARG_EXCL_ATTR.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_INCLUDE_FILTER,
|
INFO_IMPORT_ARG_INCL_FILTER.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_EXCLUDE_FILTER,
|
INFO_IMPORT_ARG_EXCL_FILTER.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_REJECT_FILE,
|
INFO_IMPORT_ARG_REJECT_FILE.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_SKIP_FILE,
|
INFO_IMPORT_ARG_SKIP_FILE.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_OVERWRITE,
|
INFO_IMPORT_ARG_OVERWRITE.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_SKIP_SCHEMA_VALIDATION,
|
INFO_IMPORT_ARG_SKIP_SCHEMA_VALIDATION.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_IS_COMPRESSED,
|
INFO_IMPORT_ARG_IS_COMPRESSED.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_IS_ENCRYPTED,
|
INFO_IMPORT_ARG_IS_ENCRYPTED.get());
|
|
argDisplayMap.put(
|
ATTR_IMPORT_CLEAR_BACKEND,
|
INFO_IMPORT_ARG_CLEAR_BACKEND.get());
|
}
|
|
|
private boolean append = false;
|
private boolean isCompressed = false;
|
private boolean isEncrypted = false;
|
private boolean overwrite = false;
|
private boolean replaceExisting = false;
|
private boolean skipSchemaValidation = false;
|
private boolean clearBackend = false;
|
private boolean skipDNValidation = false;
|
private String tmpDirectory = null;
|
private int threadCount = 0;
|
private String backendID = null;
|
private String rejectFile = null;
|
private String skipFile = null;
|
private ArrayList<String> excludeAttributeStrings = null;
|
private ArrayList<String> excludeBranchStrings = null;
|
private ArrayList<String> excludeFilterStrings = null;
|
private ArrayList<String> includeAttributeStrings = null;
|
private ArrayList<String> includeBranchStrings = null;
|
private ArrayList<String> includeFilterStrings = null;
|
private ArrayList<String> ldifFiles = null;
|
private String templateFile = null;
|
private int randomSeed = 0;
|
private LDIFImportConfig importConfig;
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public LocalizableMessage getDisplayName() {
|
return INFO_TASK_IMPORT_NAME.get();
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public LocalizableMessage getAttributeDisplayName(String name) {
|
return argDisplayMap.get(name);
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override public void initializeTask() throws DirectoryException
|
{
|
// If the client connection is available, then make sure the associated
|
// client has the LDIF_IMPORT privilege.
|
Operation operation = getOperation();
|
if (operation != null)
|
{
|
ClientConnection clientConnection = operation.getClientConnection();
|
if (! clientConnection.hasPrivilege(Privilege.LDIF_IMPORT, operation))
|
{
|
LocalizableMessage message = ERR_TASK_LDIFIMPORT_INSUFFICIENT_PRIVILEGES.get();
|
throw new DirectoryException(ResultCode.INSUFFICIENT_ACCESS_RIGHTS,
|
message);
|
}
|
}
|
|
|
Entry taskEntry = getTaskEntry();
|
|
AttributeType typeLdifFile;
|
AttributeType typeTemplateFile;
|
AttributeType typeAppend;
|
AttributeType typeReplaceExisting;
|
AttributeType typeBackendID;
|
AttributeType typeIncludeBranch;
|
AttributeType typeExcludeBranch;
|
AttributeType typeIncludeAttribute;
|
AttributeType typeExcludeAttribute;
|
AttributeType typeIncludeFilter;
|
AttributeType typeExcludeFilter;
|
AttributeType typeRejectFile;
|
AttributeType typeSkipFile;
|
AttributeType typeOverwrite;
|
AttributeType typeSkipSchemaValidation;
|
AttributeType typeIsCompressed;
|
AttributeType typeIsEncrypted;
|
AttributeType typeClearBackend;
|
AttributeType typeRandomSeed;
|
AttributeType typeThreadCount;
|
AttributeType typeTmpDirectory;
|
AttributeType typeDNCheckPhase2;
|
|
typeLdifFile =
|
getAttributeType(ATTR_IMPORT_LDIF_FILE, true);
|
typeTemplateFile =
|
getAttributeType(ATTR_IMPORT_TEMPLATE_FILE, true);
|
typeAppend =
|
getAttributeType(ATTR_IMPORT_APPEND, true);
|
typeReplaceExisting =
|
getAttributeType(ATTR_IMPORT_REPLACE_EXISTING, true);
|
typeBackendID =
|
getAttributeType(ATTR_IMPORT_BACKEND_ID, true);
|
typeIncludeBranch =
|
getAttributeType(ATTR_IMPORT_INCLUDE_BRANCH, true);
|
typeExcludeBranch =
|
getAttributeType(ATTR_IMPORT_EXCLUDE_BRANCH, true);
|
typeIncludeAttribute =
|
getAttributeType(ATTR_IMPORT_INCLUDE_ATTRIBUTE, true);
|
typeExcludeAttribute =
|
getAttributeType(ATTR_IMPORT_EXCLUDE_ATTRIBUTE, true);
|
typeIncludeFilter =
|
getAttributeType(ATTR_IMPORT_INCLUDE_FILTER, true);
|
typeExcludeFilter =
|
getAttributeType(ATTR_IMPORT_EXCLUDE_FILTER, true);
|
typeRejectFile =
|
getAttributeType(ATTR_IMPORT_REJECT_FILE, true);
|
typeSkipFile =
|
getAttributeType(ATTR_IMPORT_SKIP_FILE, true);
|
typeOverwrite =
|
getAttributeType(ATTR_IMPORT_OVERWRITE, true);
|
typeSkipSchemaValidation =
|
getAttributeType(ATTR_IMPORT_SKIP_SCHEMA_VALIDATION, true);
|
typeIsCompressed =
|
getAttributeType(ATTR_IMPORT_IS_COMPRESSED, true);
|
typeIsEncrypted =
|
getAttributeType(ATTR_IMPORT_IS_ENCRYPTED, true);
|
typeClearBackend =
|
getAttributeType(ATTR_IMPORT_CLEAR_BACKEND, true);
|
typeRandomSeed =
|
getAttributeType(ATTR_IMPORT_RANDOM_SEED, true);
|
typeThreadCount =
|
getAttributeType(ATTR_IMPORT_THREAD_COUNT, true);
|
typeTmpDirectory =
|
getAttributeType(ATTR_IMPORT_TMP_DIRECTORY, true);
|
typeDNCheckPhase2 =
|
getAttributeType(ATTR_IMPORT_SKIP_DN_VALIDATION, true);
|
|
List<Attribute> attrList;
|
|
attrList = taskEntry.getAttribute(typeLdifFile);
|
ArrayList<String> ldifFilestmp = TaskUtils.getMultiValueString(attrList);
|
ldifFiles = new ArrayList<String>(ldifFilestmp.size());
|
for (String s : ldifFilestmp)
|
{
|
File f = new File (s);
|
if (!f.isAbsolute())
|
{
|
f = new File(DirectoryServer.getInstanceRoot(), s);
|
try
|
{
|
s = f.getCanonicalPath();
|
}
|
catch (Exception ex)
|
{
|
s = f.getAbsolutePath();
|
}
|
ldifFiles.add(s);
|
}
|
else
|
{
|
ldifFiles.add(s);
|
}
|
}
|
|
attrList = taskEntry.getAttribute(typeTemplateFile);
|
templateFile = TaskUtils.getSingleValueString(attrList);
|
if (templateFile != null)
|
{
|
File f = new File(templateFile);
|
if (!f.isAbsolute())
|
{
|
templateFile = new File(DirectoryServer.getInstanceRoot(), templateFile)
|
.getAbsolutePath();
|
}
|
}
|
|
attrList = taskEntry.getAttribute(typeAppend);
|
append = TaskUtils.getBoolean(attrList, false);
|
|
attrList = taskEntry.getAttribute(typeDNCheckPhase2);
|
skipDNValidation = TaskUtils.getBoolean(attrList, false);
|
|
attrList = taskEntry.getAttribute(typeTmpDirectory);
|
tmpDirectory = TaskUtils.getSingleValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeReplaceExisting);
|
replaceExisting = TaskUtils.getBoolean(attrList, false);
|
|
attrList = taskEntry.getAttribute(typeBackendID);
|
backendID = TaskUtils.getSingleValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeIncludeBranch);
|
includeBranchStrings = TaskUtils.getMultiValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeExcludeBranch);
|
excludeBranchStrings = TaskUtils.getMultiValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeIncludeAttribute);
|
includeAttributeStrings = TaskUtils.getMultiValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeExcludeAttribute);
|
excludeAttributeStrings = TaskUtils.getMultiValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeIncludeFilter);
|
includeFilterStrings = TaskUtils.getMultiValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeExcludeFilter);
|
excludeFilterStrings = TaskUtils.getMultiValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeRejectFile);
|
rejectFile = TaskUtils.getSingleValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeSkipFile);
|
skipFile = TaskUtils.getSingleValueString(attrList);
|
|
attrList = taskEntry.getAttribute(typeOverwrite);
|
overwrite = TaskUtils.getBoolean(attrList, false);
|
|
attrList = taskEntry.getAttribute(typeSkipSchemaValidation);
|
skipSchemaValidation = TaskUtils.getBoolean(attrList, false);
|
|
attrList = taskEntry.getAttribute(typeIsCompressed);
|
isCompressed = TaskUtils.getBoolean(attrList, false);
|
|
attrList = taskEntry.getAttribute(typeIsEncrypted);
|
isEncrypted = TaskUtils.getBoolean(attrList, false);
|
|
attrList = taskEntry.getAttribute(typeClearBackend);
|
clearBackend = TaskUtils.getBoolean(attrList, false);
|
|
attrList = taskEntry.getAttribute(typeRandomSeed);
|
randomSeed = TaskUtils.getSingleValueInteger(attrList, 0);
|
|
attrList = taskEntry.getAttribute(typeThreadCount);
|
threadCount = TaskUtils.getSingleValueInteger(attrList, 0);
|
|
// Make sure that either the "includeBranchStrings" argument or the
|
// "backendID" argument was provided.
|
if(includeBranchStrings.isEmpty() && backendID == null)
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_MISSING_BACKEND_ARGUMENT.get(
|
typeIncludeBranch.getNameOrOID(), typeBackendID.getNameOrOID());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
|
Backend backend = null;
|
ArrayList<DN> defaultIncludeBranches;
|
ArrayList<DN> excludeBranches =
|
new ArrayList<DN>(excludeBranchStrings.size());
|
ArrayList<DN> includeBranches =
|
new ArrayList<DN>(includeBranchStrings.size());
|
|
for (String s : includeBranchStrings)
|
{
|
DN includeBranch;
|
try
|
{
|
includeBranch = DN.valueOf(s);
|
}
|
catch (DirectoryException de)
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get(
|
s, de.getMessageObject());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
catch (Exception e)
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get(
|
s, getExceptionMessage(e));
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
|
if(! includeBranches.contains(includeBranch))
|
{
|
includeBranches.add(includeBranch);
|
}
|
}
|
for (String s : excludeBranchStrings)
|
{
|
DN excludeBranch;
|
try
|
{
|
excludeBranch = DN.valueOf(s);
|
}
|
catch (DirectoryException de)
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE.get(
|
s, de.getMessageObject());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
catch (Exception e)
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE.get(
|
s, getExceptionMessage(e));
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
|
if (! excludeBranches.contains(excludeBranch))
|
{
|
excludeBranches.add(excludeBranch);
|
}
|
}
|
|
for (String filterString : excludeFilterStrings)
|
{
|
try
|
{
|
SearchFilter.createFilterFromString(filterString);
|
}
|
catch (DirectoryException de)
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_EXCLUDE_FILTER.get(
|
filterString, de.getMessageObject());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
}
|
|
for (String filterString : includeFilterStrings)
|
{
|
try
|
{
|
SearchFilter.createFilterFromString(filterString);
|
}
|
catch (DirectoryException de)
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_INCLUDE_FILTER.get(
|
filterString, de.getMessageObject());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
}
|
|
if(backendID != null)
|
{
|
backend = DirectoryServer.getBackend(backendID);
|
if (backend == null)
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_NO_BACKENDS_FOR_ID.get();
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
else if (! backend.supportsLDIFImport())
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_IMPORT.get(backendID);
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
// Make sure that if the "backendID" argument was provided, no include
|
// base was included, and the "append" option was not provided, the
|
// "clearBackend" argument was also provided if there are more then one
|
// baseDNs for the backend being imported.
|
else if(!append && includeBranchStrings.isEmpty() &&
|
backend.getBaseDNs().length > 1 && !clearBackend)
|
{
|
StringBuilder builder = new StringBuilder();
|
for(DN dn : backend.getBaseDNs())
|
{
|
builder.append(dn.toNormalizedString());
|
builder.append(" ");
|
}
|
LocalizableMessage message = ERR_LDIFIMPORT_MISSING_CLEAR_BACKEND.get(
|
builder.toString(), typeClearBackend.getNameOrOID());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
}
|
else
|
{
|
// Find the backend that includes all the branches.
|
for(DN includeBranch : includeBranches)
|
{
|
Backend locatedBackend = DirectoryServer.getBackend(includeBranch);
|
if(locatedBackend != null)
|
{
|
if(backend == null)
|
{
|
backend = locatedBackend;
|
}
|
else if(backend != locatedBackend)
|
{
|
// The include branches span across multiple backends.
|
LocalizableMessage message = ERR_LDIFIMPORT_INVALID_INCLUDE_BASE.get(
|
includeBranch.toNormalizedString(), backend.getBackendID());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM,
|
message);
|
}
|
}
|
else
|
{
|
// The include branch is not associated with any backend.
|
LocalizableMessage message =
|
ERR_NO_BACKENDS_FOR_BASE.get(includeBranch
|
.toNormalizedString());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM,
|
message);
|
}
|
}
|
}
|
|
// Make sure the selected backend will handle all the include branches
|
defaultIncludeBranches = new ArrayList<DN>(backend.getBaseDNs().length);
|
for (DN dn : backend.getBaseDNs())
|
{
|
defaultIncludeBranches.add(dn);
|
}
|
|
for(DN includeBranch : includeBranches)
|
{
|
if (! Backend.handlesEntry(includeBranch, defaultIncludeBranches,
|
excludeBranches))
|
{
|
LocalizableMessage message = ERR_LDIFIMPORT_INVALID_INCLUDE_BASE.get(
|
includeBranch.toNormalizedString(), backend.getBackendID());
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message);
|
}
|
}
|
}
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public void interruptTask(TaskState interruptState, LocalizableMessage interruptReason)
|
{
|
if (TaskState.STOPPED_BY_ADMINISTRATOR.equals(interruptState) &&
|
importConfig != null)
|
{
|
addLogMessage(TaskMessages.INFO_TASK_STOPPED_BY_ADMIN.get(
|
interruptReason));
|
setTaskInterruptState(interruptState);
|
importConfig.cancel();
|
}
|
}
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public boolean isInterruptable()
|
{
|
return true;
|
}
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
protected TaskState runTask()
|
{
|
// See if there were any user-defined sets of include/exclude attributes or
|
// filters. If so, then process them.
|
HashSet<AttributeType> excludeAttributes =
|
new HashSet<AttributeType>(excludeAttributeStrings.size());
|
for (String attrName : excludeAttributeStrings)
|
{
|
String lowerName = attrName.toLowerCase();
|
AttributeType attrType = DirectoryServer.getAttributeType(lowerName);
|
if (attrType == null)
|
{
|
attrType = DirectoryServer.getDefaultAttributeType(attrName);
|
}
|
|
excludeAttributes.add(attrType);
|
}
|
|
HashSet<AttributeType> includeAttributes =
|
new HashSet<AttributeType>(includeAttributeStrings.size());
|
for (String attrName : includeAttributeStrings)
|
{
|
String lowerName = attrName.toLowerCase();
|
AttributeType attrType = DirectoryServer.getAttributeType(lowerName);
|
if (attrType == null)
|
{
|
attrType = DirectoryServer.getDefaultAttributeType(attrName);
|
}
|
|
includeAttributes.add(attrType);
|
}
|
|
ArrayList<SearchFilter> excludeFilters =
|
new ArrayList<SearchFilter>(excludeFilterStrings.size());
|
for (String filterString : excludeFilterStrings)
|
{
|
try
|
{
|
excludeFilters.add(SearchFilter.createFilterFromString(filterString));
|
}
|
catch (DirectoryException de)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, de.getMessageObject());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
}
|
|
ArrayList<SearchFilter> includeFilters =
|
new ArrayList<SearchFilter>(includeFilterStrings.size());
|
for (String filterString : includeFilterStrings)
|
{
|
try
|
{
|
includeFilters.add(SearchFilter.createFilterFromString(filterString));
|
}
|
catch (DirectoryException de)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, de.getMessageObject());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
}
|
|
|
// Get the backend into which the LDIF should be imported.
|
Backend backend = null;
|
ArrayList<DN> defaultIncludeBranches;
|
ArrayList<DN> excludeBranches =
|
new ArrayList<DN>(excludeBranchStrings.size());
|
ArrayList<DN> includeBranches =
|
new ArrayList<DN>(includeBranchStrings.size());
|
|
for (String s : includeBranchStrings)
|
{
|
DN includeBranch;
|
try
|
{
|
includeBranch = DN.valueOf(s);
|
}
|
catch (DirectoryException de)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, de.getMessageObject());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
catch (Exception e)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, getExceptionMessage(e));
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
|
if(! includeBranches.contains(includeBranch))
|
{
|
includeBranches.add(includeBranch);
|
}
|
}
|
|
if(backendID != null)
|
{
|
backend = DirectoryServer.getBackend(backendID);
|
|
if (backend == null)
|
{
|
logger.error(ERR_LDIFIMPORT_NO_BACKENDS_FOR_ID);
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
else if (! backend.supportsLDIFImport())
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_IMPORT, backendID);
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
// Make sure that if the "backendID" argument was provided, no include
|
// base was included, and the "append" ption was not provided, the
|
// "clearBackend" argument was also provided if there are more then one
|
// baseDNs for the backend being imported.
|
else if(!append && includeBranches.isEmpty() &&
|
backend.getBaseDNs().length > 1 && !clearBackend)
|
{
|
StringBuilder builder = new StringBuilder();
|
builder.append(backend.getBaseDNs()[0].toNormalizedString());
|
for(int i = 1; i < backend.getBaseDNs().length; i++)
|
{
|
builder.append(" / ");
|
builder.append(backend.getBaseDNs()[i].toNormalizedString());
|
}
|
logger.error(ERR_LDIFIMPORT_MISSING_CLEAR_BACKEND, builder, ATTR_IMPORT_CLEAR_BACKEND);
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
}
|
else
|
{
|
// Find the backend that includes all the branches.
|
for(DN includeBranch : includeBranches)
|
{
|
Backend locatedBackend = DirectoryServer.getBackend(includeBranch);
|
if(locatedBackend != null)
|
{
|
if(backend == null)
|
{
|
backend = locatedBackend;
|
}
|
else if(backend != locatedBackend)
|
{
|
// The include branches span across multiple backends.
|
logger.error(ERR_LDIFIMPORT_INVALID_INCLUDE_BASE, includeBranch
|
.toNormalizedString(), backend.getBackendID());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
}
|
}
|
}
|
|
// Find backends with subordinate base DNs that should be excluded from the
|
// import.
|
|
defaultIncludeBranches = new ArrayList<DN>(backend.getBaseDNs().length);
|
for (DN dn : backend.getBaseDNs())
|
{
|
defaultIncludeBranches.add(dn);
|
}
|
|
if (backend.getSubordinateBackends() != null)
|
{
|
for (Backend subBackend : backend.getSubordinateBackends())
|
{
|
for (DN baseDN : subBackend.getBaseDNs())
|
{
|
for (DN importBase : defaultIncludeBranches)
|
{
|
if (baseDN.isDescendantOf(importBase) &&
|
(! baseDN.equals(importBase)))
|
{
|
if (! excludeBranches.contains(baseDN))
|
{
|
excludeBranches.add(baseDN);
|
}
|
|
break;
|
}
|
}
|
}
|
}
|
}
|
|
for (String s : excludeBranchStrings)
|
{
|
DN excludeBranch;
|
try
|
{
|
excludeBranch = DN.valueOf(s);
|
}
|
catch (DirectoryException de)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE, s, de.getMessageObject());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
catch (Exception e)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE, s, getExceptionMessage(e));
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
|
if (! excludeBranches.contains(excludeBranch))
|
{
|
excludeBranches.add(excludeBranch);
|
}
|
}
|
|
if (includeBranchStrings.isEmpty())
|
{
|
includeBranches = defaultIncludeBranches;
|
}
|
else
|
{
|
// Make sure the selected backend will handle all the include branches
|
for(DN includeBranch : includeBranches)
|
{
|
if (! Backend.handlesEntry(includeBranch, defaultIncludeBranches,
|
excludeBranches))
|
{
|
logger.error(ERR_LDIFIMPORT_INVALID_INCLUDE_BASE, includeBranch.toNormalizedString(), backend.getBackendID());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
}
|
}
|
|
// Create the LDIF import configuration to use when reading the LDIF.
|
if (templateFile != null)
|
{
|
Random random;
|
try
|
{
|
random = new Random(randomSeed);
|
}
|
catch (Exception e)
|
{
|
random = new Random();
|
}
|
|
String resourcePath = DirectoryServer.getInstanceRoot() + File.separator +
|
PATH_MAKELDIF_RESOURCE_DIR;
|
TemplateFile tf = new TemplateFile(resourcePath, random);
|
|
ArrayList<LocalizableMessage> warnings = new ArrayList<LocalizableMessage>();
|
try
|
{
|
tf.parse(templateFile, warnings);
|
}
|
catch (Exception e)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_TEMPLATE_FILE, templateFile, e.getMessage());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
|
importConfig = new LDIFImportConfig(tf);
|
}
|
else
|
{
|
ArrayList<String> fileList = new ArrayList<String>(ldifFiles);
|
importConfig = new LDIFImportConfig(fileList);
|
}
|
if(tmpDirectory == null)
|
{
|
tmpDirectory = "import-tmp";
|
}
|
importConfig.setAppendToExistingData(append);
|
importConfig.setReplaceExistingEntries(replaceExisting);
|
importConfig.setCompressed(isCompressed);
|
importConfig.setEncrypted(isEncrypted);
|
importConfig.setClearBackend(clearBackend);
|
importConfig.setExcludeAttributes(excludeAttributes);
|
importConfig.setExcludeBranches(excludeBranches);
|
importConfig.setExcludeFilters(excludeFilters);
|
importConfig.setIncludeAttributes(includeAttributes);
|
importConfig.setIncludeBranches(includeBranches);
|
importConfig.setIncludeFilters(includeFilters);
|
importConfig.setValidateSchema(!skipSchemaValidation);
|
importConfig.setSkipDNValidation(skipDNValidation);
|
importConfig.setTmpDirectory(tmpDirectory);
|
importConfig.setThreadCount(threadCount);
|
|
// FIXME -- Should this be conditional?
|
importConfig.setInvokeImportPlugins(true);
|
|
if (rejectFile != null)
|
{
|
try
|
{
|
ExistingFileBehavior existingBehavior;
|
if (overwrite)
|
{
|
existingBehavior = ExistingFileBehavior.OVERWRITE;
|
}
|
else
|
{
|
existingBehavior = ExistingFileBehavior.APPEND;
|
}
|
|
importConfig.writeRejectedEntries(rejectFile, existingBehavior);
|
}
|
catch (Exception e)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_OPEN_REJECTS_FILE, rejectFile, getExceptionMessage(e));
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
}
|
|
if (skipFile != null)
|
{
|
try
|
{
|
ExistingFileBehavior existingBehavior;
|
if (overwrite)
|
{
|
existingBehavior = ExistingFileBehavior.OVERWRITE;
|
}
|
else
|
{
|
existingBehavior = ExistingFileBehavior.APPEND;
|
}
|
importConfig.writeSkippedEntries(skipFile, existingBehavior);
|
}
|
catch (Exception e)
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_OPEN_SKIP_FILE, skipFile, getExceptionMessage(e));
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
}
|
|
// Get the set of base DNs for the backend as an array.
|
DN[] baseDNs = new DN[defaultIncludeBranches.size()];
|
defaultIncludeBranches.toArray(baseDNs);
|
|
// Notify the task listeners that an import is going to start
|
// this must be done before disabling the backend to allow
|
// listeners to get access to the backend configuration
|
// and to take appropriate actions.
|
DirectoryServer.notifyImportBeginning(backend, importConfig);
|
|
// Disable the backend.
|
try
|
{
|
TaskUtils.disableBackend(backend.getBackendID());
|
}
|
catch (DirectoryException e)
|
{
|
logger.traceException(e);
|
|
logger.error(e.getMessageObject());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
|
|
try
|
{
|
// Acquire an exclusive lock for the backend.
|
try
|
{
|
String lockFile = LockFileManager.getBackendLockFileName(backend);
|
StringBuilder failureReason = new StringBuilder();
|
if (! LockFileManager.acquireExclusiveLock(lockFile, failureReason))
|
{
|
logger.error(ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason));
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
}
|
catch (Exception e)
|
{
|
logger.traceException(e);
|
|
logger.error(ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e));
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
|
|
// Launch the import.
|
try
|
{
|
backend.importLDIF(importConfig);
|
}
|
catch (DirectoryException de)
|
{
|
logger.traceException(de);
|
|
DirectoryServer.notifyImportEnded(backend, importConfig, false);
|
LocalizableMessage message = null;
|
if (de.getResultCode() == ResultCode.CONSTRAINT_VIOLATION)
|
{
|
message =
|
ERR_LDIFIMPORT_ERROR_DURING_IMPORT
|
.get(ERR_LDIFIMPORT_ERROR_CONSTRAINT_VIOLATION.get());
|
}
|
else
|
{
|
message = ERR_LDIFIMPORT_ERROR_DURING_IMPORT.get(
|
de.getMessageObject());
|
}
|
logger.error(message);
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
catch (Exception e)
|
{
|
logger.traceException(e);
|
|
DirectoryServer.notifyImportEnded(backend, importConfig, false);
|
logger.error(ERR_LDIFIMPORT_ERROR_DURING_IMPORT, getExceptionMessage(e));
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
finally
|
{
|
// Release the exclusive lock on the backend.
|
try
|
{
|
String lockFile = LockFileManager.getBackendLockFileName(backend);
|
StringBuilder failureReason = new StringBuilder();
|
if (! LockFileManager.releaseLock(lockFile, failureReason))
|
{
|
logger.warn(WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason));
|
return TaskState.COMPLETED_WITH_ERRORS;
|
}
|
}
|
catch (Exception e)
|
{
|
logger.traceException(e);
|
|
logger.warn(WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e));
|
return TaskState.COMPLETED_WITH_ERRORS;
|
}
|
|
}
|
}
|
finally
|
{
|
// Enable the backend.
|
try
|
{
|
TaskUtils.enableBackend(backend.getBackendID());
|
// It is necessary to retrieve the backend structure again
|
// because disabling and enabling it again may have resulted
|
// in a new backend being registered to the server.
|
backend = DirectoryServer.getBackend(backend.getBackendID());
|
}
|
catch (DirectoryException e)
|
{
|
logger.traceException(e);
|
|
logger.error(e.getMessageObject());
|
return TaskState.STOPPED_BY_ERROR;
|
}
|
DirectoryServer.notifyImportEnded(backend, importConfig, true);
|
}
|
|
|
// Clean up after the import by closing the import config.
|
importConfig.close();
|
return getFinalTaskState();
|
}
|
}
|
