*/
ImportFractionalContext importFractionalContext =
importSessionContexts.get(importConfig);
DN entryDn = entry.getDN();
FractionalConfig localFractionalConfig = null;
// If no context, create it
if (importFractionalContext == null)
{
synchronized(importSessionContexts)
{
// Insure antoher thread was not creating the context at the same time
// (we would create it for the second time which is useless)
importFractionalContext = importSessionContexts.get(importConfig);
if (importFractionalContext == null)
{
/*
* Create context
*/
/**
* Retrieve the replicated domain this entry belongs to. Try to
* retrieve replication domain instance first. If we are in an online
* server, we should get it (if we are treating an entry that belongs
* to a replicated domain), otherwise the domain is not replicated or
* we are in an offline server context (import-ldif command run with
* offline server) and we must retrieve the fractional configuration
* directly from the configuration management system.
*/
LDAPReplicationDomain domain =
MultimasterReplication.findDomain(entryDn, null);
// Get the fractional configuration extracted from the local server
// configuration for the currently imported domain
if (domain == null)
{
// Server may be offline, attempt to find fractional configuration
// from config sub-system
try
{
localFractionalConfig =
getStaticReplicationDomainFractionalConfig(entry);
} catch (Exception ex)
{
Message message = ERR_FRACTIONAL_COULD_NOT_RETRIEVE_CONFIG.get(
entry.toString());
return PluginResult.ImportLDIF.stopEntryProcessing(message);
}
} else
{
// Found a live domain, retrieve the fractional configuration from
// it.
localFractionalConfig = domain.getFractionalConfig();
}
// Create context and store it
importFractionalContext =
new ImportFractionalContext(localFractionalConfig, domain);
importSessionContexts.put(importConfig, importFractionalContext);
}
}
}
// Extract the fractional configuration from the context
localFractionalConfig = importFractionalContext.getFractionalConfig();
if (localFractionalConfig == null)
{
// Not part of a replicated domain : nothing to do
return PluginResult.ImportLDIF.continueEntryProcessing();
}
/**
* At this point, either the domain instance has been found and we use its
* fractional configuration, or the server is offline and we use the parsed
* fractional configuration. We differentiate both cases testing if domain
* is null. We are also for sure handling an entry of a replicated suffix.
*/
// Is the entry to handle the root entry of the domain ? If yes, analyze the
// fractional configuration in it and compare with local fractional
// configuration. Stop the import if some inconsistency is detected
DN replicatedDomainBaseDn = localFractionalConfig.getBaseDn();
if (replicatedDomainBaseDn.equals(entryDn))
{
/*
* This is the root entry, try to read a fractional configuration from it
*/
Iterator<String> exclIt = null;
AttributeType fractionalExcludeType =
DirectoryServer.getAttributeType(
LDAPReplicationDomain.REPLICATION_FRACTIONAL_EXCLUDE);
List<Attribute> exclAttrs =
entry.getAttribute(fractionalExcludeType);
Attribute exclAttr = null;
if (exclAttrs != null)
{
exclAttr = exclAttrs.get(0);
if (exclAttr != null)
{
exclIt = new AttributeValueStringIterator(exclAttr.iterator());
}
}
Iterator<String> inclIt = null;
AttributeType fractionalIncludeType =
DirectoryServer.getAttributeType(
LDAPReplicationDomain.REPLICATION_FRACTIONAL_INCLUDE);
List<Attribute> inclAttrs =
entry.getAttribute(fractionalIncludeType);
Attribute inclAttr = null;
if (inclAttrs != null)
{
inclAttr = inclAttrs.get(0);
if (inclAttr != null)
{
inclIt = new AttributeValueStringIterator(inclAttr.iterator());
}
}
// Compare backend and local fractional configuration
boolean sameConfig = LDAPReplicationDomain.
isFractionalConfigConsistent(localFractionalConfig, exclIt, inclIt);
if (localFractionalConfig.isFractional())
{
// Local domain is fractional
if (sameConfig)
{
// Both local and remote fractional configuration are equivalent :