/**
* Generates an entry for a backup directory based on the provided DN. The DN must contain an RDN
* component that specifies the path to the backup directory, and that directory must exist and be
* a valid backup directory.
*
* @param entryDN The DN of the backup directory entry to retrieve.
* @return The requested backup directory entry.
* @throws DirectoryException If the specified directory does not exist or is not a valid backup
* directory, or if the DN does not specify any backup directory.
*/
private Entry getBackupDirectoryEntry(DN entryDN) throws DirectoryException {
// Make sure that the DN specifies a backup directory.
AttributeType t = DirectoryServer.getAttributeType(ATTR_BACKUP_DIRECTORY_PATH, true);
AttributeValue v = entryDN.getRDN().getAttributeValue(t);
if (v == null) {
Message message = ERR_BACKUP_DN_DOES_NOT_SPECIFY_DIRECTORY.get(String.valueOf(entryDN));
throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message, backupBaseDN, null);
}
// Get a handle to the backup directory and the information that it
// contains.
BackupDirectory backupDirectory;
try {
backupDirectory = BackupDirectory.readBackupDirectoryDescriptor(v.getValue().toString());
} catch (ConfigException ce) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, ce);
}
Message message =
ERR_BACKUP_INVALID_BACKUP_DIRECTORY.get(String.valueOf(entryDN), ce.getMessage());
throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message);
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
Message message = ERR_BACKUP_ERROR_GETTING_BACKUP_DIRECTORY.get(getExceptionMessage(e));
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
// Construct the backup directory entry to return.
LinkedHashMap<ObjectClass, String> ocMap = new LinkedHashMap<ObjectClass, String>(2);
ocMap.put(DirectoryServer.getTopObjectClass(), OC_TOP);
ObjectClass backupDirOC = DirectoryServer.getObjectClass(OC_BACKUP_DIRECTORY, true);
ocMap.put(backupDirOC, OC_BACKUP_DIRECTORY);
LinkedHashMap<AttributeType, List<Attribute>> opAttrs =
new LinkedHashMap<AttributeType, List<Attribute>>(0);
LinkedHashMap<AttributeType, List<Attribute>> userAttrs =
new LinkedHashMap<AttributeType, List<Attribute>>(3);
ArrayList<Attribute> attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(t, v));
userAttrs.put(t, attrList);
t = DirectoryServer.getAttributeType(ATTR_BACKUP_BACKEND_DN, true);
attrList = new ArrayList<Attribute>(1);
attrList.add(
Attributes.create(
t, AttributeValues.create(t, backupDirectory.getConfigEntryDN().toString())));
userAttrs.put(t, attrList);
Entry e = new Entry(entryDN, ocMap, userAttrs, opAttrs);
e.processVirtualAttributes();
return e;
}
/** Test for escaped characters in templates, check LDIF output. */
@Test(
dataProvider = "templatesToTestLDIFOutput",
dependsOnMethods = {"testParsingEscapeCharInTemplate"})
public void testLDIFOutputFromTemplate(
String testName, String[] lines, String attrName, String expectedValue) throws Exception {
File tmpFile = File.createTempFile(testName, "out.ldif");
tmpFile.deleteOnExit();
String outLdifFilePath = tmpFile.getAbsolutePath();
LdifFileWriter.makeLdif(outLdifFilePath, resourcePath, lines);
LDIFImportConfig ldifConfig = new LDIFImportConfig(outLdifFilePath);
ldifConfig.setValidateSchema(false);
LDIFReader reader = new LDIFReader(ldifConfig);
Entry top = reader.readEntry();
Entry e = reader.readEntry();
reader.close();
assertNotNull(top);
assertNotNull(e);
List<Attribute> attrs = e.getAttribute(attrName);
assertFalse(attrs.isEmpty());
Attribute a = attrs.get(0);
Attribute expectedRes = Attributes.create(attrName, expectedValue);
assertEquals(a, expectedRes);
}
/**
* Attempt to read a change containing a file-based attribute.
*
* @throws Exception If the test failed unexpectedly.
*/
@Test(dependsOnMethods = {"testReadChangeMultiple"})
public void testReadChangeWithFileBaseAttribute() throws Exception {
StringBuilder buffer = new StringBuilder(TEMP_FILE_LDIF);
buffer.append(TEMP_FILE.getCanonicalPath());
buffer.append("\n");
LDIFReader reader = createLDIFReader(buffer.toString());
try {
ChangeRecordEntry change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof AddChangeRecordEntry);
AddChangeRecordEntry add = (AddChangeRecordEntry) change;
DN dn = DN.decode("cn=john smith, dc=com");
Assert.assertEquals(add.getDN(), dn);
Attribute attr = Attributes.create("description", TEMP_FILE_STRING);
Assert.assertTrue(add.getAttributes().contains(attr));
// Check final state.
Assert.assertNull(reader.readChangeRecord(false));
} finally {
reader.close();
}
}
/**
* Generates an entry for a backup based on the provided DN. The DN must have an RDN component
* that specifies the backup ID, and the parent DN must have an RDN component that specifies the
* backup directory.
*
* @param entryDN The DN of the backup entry to retrieve.
* @return The requested backup entry.
* @throws DirectoryException If the specified backup does not exist or is invalid.
*/
private Entry getBackupEntry(DN entryDN) throws DirectoryException {
// First, get the backup ID from the entry DN.
AttributeType idType = DirectoryServer.getAttributeType(ATTR_BACKUP_ID, true);
AttributeValue idValue = entryDN.getRDN().getAttributeValue(idType);
if (idValue == null) {
Message message = ERR_BACKUP_NO_BACKUP_ID_IN_DN.get(String.valueOf(entryDN));
throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message);
}
String backupID = idValue.getValue().toString();
// Next, get the backup directory from the parent DN.
DN parentDN = entryDN.getParentDNInSuffix();
if (parentDN == null) {
Message message = ERR_BACKUP_NO_BACKUP_PARENT_DN.get(String.valueOf(entryDN));
throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message);
}
AttributeType t = DirectoryServer.getAttributeType(ATTR_BACKUP_DIRECTORY_PATH, true);
AttributeValue v = parentDN.getRDN().getAttributeValue(t);
if (v == null) {
Message message = ERR_BACKUP_NO_BACKUP_DIR_IN_DN.get(String.valueOf(entryDN));
throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message);
}
BackupDirectory backupDirectory;
try {
backupDirectory = BackupDirectory.readBackupDirectoryDescriptor(v.getValue().toString());
} catch (ConfigException ce) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, ce);
}
Message message =
ERR_BACKUP_INVALID_BACKUP_DIRECTORY.get(String.valueOf(entryDN), ce.getMessageObject());
throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message);
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
Message message = ERR_BACKUP_ERROR_GETTING_BACKUP_DIRECTORY.get(getExceptionMessage(e));
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
BackupInfo backupInfo = backupDirectory.getBackupInfo(backupID);
if (backupInfo == null) {
Message message = ERR_BACKUP_NO_SUCH_BACKUP.get(backupID, backupDirectory.getPath());
throw new DirectoryException(ResultCode.NO_SUCH_OBJECT, message, parentDN, null);
}
// Construct the backup entry to return.
LinkedHashMap<ObjectClass, String> ocMap = new LinkedHashMap<ObjectClass, String>(3);
ocMap.put(DirectoryServer.getTopObjectClass(), OC_TOP);
ObjectClass oc = DirectoryServer.getObjectClass(OC_BACKUP_INFO, true);
ocMap.put(oc, OC_BACKUP_INFO);
oc = DirectoryServer.getObjectClass(OC_EXTENSIBLE_OBJECT_LC, true);
ocMap.put(oc, OC_EXTENSIBLE_OBJECT);
LinkedHashMap<AttributeType, List<Attribute>> opAttrs =
new LinkedHashMap<AttributeType, List<Attribute>>(0);
LinkedHashMap<AttributeType, List<Attribute>> userAttrs =
new LinkedHashMap<AttributeType, List<Attribute>>();
ArrayList<Attribute> attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(idType, idValue));
userAttrs.put(idType, attrList);
backupInfo.getBackupDirectory();
attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(t, v));
userAttrs.put(t, attrList);
Date backupDate = backupInfo.getBackupDate();
if (backupDate != null) {
t = DirectoryServer.getAttributeType(ATTR_BACKUP_DATE, true);
attrList = new ArrayList<Attribute>(1);
attrList.add(
Attributes.create(
t, AttributeValues.create(t, GeneralizedTimeSyntax.format(backupDate))));
userAttrs.put(t, attrList);
}
t = DirectoryServer.getAttributeType(ATTR_BACKUP_COMPRESSED, true);
attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(t, BooleanSyntax.createBooleanValue(backupInfo.isCompressed())));
userAttrs.put(t, attrList);
t = DirectoryServer.getAttributeType(ATTR_BACKUP_ENCRYPTED, true);
attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(t, BooleanSyntax.createBooleanValue(backupInfo.isEncrypted())));
userAttrs.put(t, attrList);
t = DirectoryServer.getAttributeType(ATTR_BACKUP_INCREMENTAL, true);
attrList = new ArrayList<Attribute>(1);
attrList.add(
Attributes.create(t, BooleanSyntax.createBooleanValue(backupInfo.isIncremental())));
userAttrs.put(t, attrList);
HashSet<String> dependencies = backupInfo.getDependencies();
if (dependencies != null && !dependencies.isEmpty()) {
t = DirectoryServer.getAttributeType(ATTR_BACKUP_DEPENDENCY, true);
AttributeBuilder builder = new AttributeBuilder(t);
for (String s : dependencies) {
builder.add(AttributeValues.create(t, s));
}
attrList = new ArrayList<Attribute>(1);
attrList.add(builder.toAttribute());
userAttrs.put(t, attrList);
}
byte[] signedHash = backupInfo.getSignedHash();
if (signedHash != null) {
t = DirectoryServer.getAttributeType(ATTR_BACKUP_SIGNED_HASH, true);
attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(t, AttributeValues.create(t, ByteString.wrap(signedHash))));
userAttrs.put(t, attrList);
}
byte[] unsignedHash = backupInfo.getUnsignedHash();
if (unsignedHash != null) {
t = DirectoryServer.getAttributeType(ATTR_BACKUP_UNSIGNED_HASH, true);
attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(t, AttributeValues.create(t, ByteString.wrap(unsignedHash))));
userAttrs.put(t, attrList);
}
HashMap<String, String> properties = backupInfo.getBackupProperties();
if (properties != null && !properties.isEmpty()) {
for (Map.Entry<String, String> e : properties.entrySet()) {
t = DirectoryServer.getAttributeType(toLowerCase(e.getKey()), true);
attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(t, AttributeValues.create(t, e.getValue())));
userAttrs.put(t, attrList);
}
}
Entry e = new Entry(entryDN, ocMap, userAttrs, opAttrs);
e.processVirtualAttributes();
return e;
}
/** {@inheritDoc} */
@Override
public void initializeBackend() throws ConfigException, InitializationException {
// Create the set of base DNs that we will handle. In this case, it's just
// the DN of the base backup entry.
try {
backupBaseDN = DN.decode(DN_BACKUP_ROOT);
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
Message message =
ERR_BACKEND_CANNOT_DECODE_BACKEND_ROOT_DN.get(getExceptionMessage(e), getBackendID());
throw new InitializationException(message, e);
}
// FIXME -- Deal with this more correctly.
this.baseDNs = new DN[] {backupBaseDN};
// Determine the set of backup directories that we will use by default.
Set<String> values = currentConfig.getBackupDirectory();
backupDirectories = new LinkedHashSet<File>(values.size());
for (String s : values) {
backupDirectories.add(getFileForPath(s));
}
// Construct the backup base entry.
LinkedHashMap<ObjectClass, String> objectClasses = new LinkedHashMap<ObjectClass, String>(2);
objectClasses.put(DirectoryServer.getTopObjectClass(), OC_TOP);
ObjectClass untypedOC = DirectoryServer.getObjectClass(OC_UNTYPED_OBJECT_LC, true);
objectClasses.put(untypedOC, OC_UNTYPED_OBJECT);
LinkedHashMap<AttributeType, List<Attribute>> opAttrs =
new LinkedHashMap<AttributeType, List<Attribute>>(0);
LinkedHashMap<AttributeType, List<Attribute>> userAttrs =
new LinkedHashMap<AttributeType, List<Attribute>>(1);
RDN rdn = backupBaseDN.getRDN();
int numAVAs = rdn.getNumValues();
for (int i = 0; i < numAVAs; i++) {
AttributeType attrType = rdn.getAttributeType(i);
ArrayList<Attribute> attrList = new ArrayList<Attribute>(1);
attrList.add(Attributes.create(attrType, rdn.getAttributeValue(i)));
userAttrs.put(attrType, attrList);
}
backupBaseEntry = new Entry(backupBaseDN, objectClasses, userAttrs, opAttrs);
currentConfig.addBackupChangeListener(this);
// Register the backup base as a private suffix.
try {
DirectoryServer.registerBaseDN(backupBaseDN, this, true);
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
Message message =
ERR_BACKEND_CANNOT_REGISTER_BASEDN.get(backupBaseDN.toString(), getExceptionMessage(e));
throw new InitializationException(message, e);
}
}
private Attribute createAttribute(String name, Object value) {
return Attributes.create(name, String.valueOf(value));
}
/**
* Attempt to read multiple changes.
*
* @throws Exception If the test failed unexpectedly.
*/
@Test(dependsOnMethods = {"testChangeRecordEmptyStream"})
public void testReadChangeMultiple() throws Exception {
LDIFReader reader = createLDIFReader(VALID_LDIF);
try {
ChangeRecordEntry change;
AddChangeRecordEntry add;
DeleteChangeRecordEntry delete;
ModifyChangeRecordEntry modify;
ModifyDNChangeRecordEntry modifyDN;
DN dn;
RDN rdn;
Iterator<RawModification> i;
Modification mod;
Attribute attr;
// Change record #1.
change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof AddChangeRecordEntry);
add = (AddChangeRecordEntry) change;
dn = DN.decode("cn=Fiona Jensen, ou=Marketing, dc=airius, dc=com");
Assert.assertEquals(add.getDN(), dn);
List<Attribute> attrs = new ArrayList<Attribute>();
AttributeBuilder builder = new AttributeBuilder(AT_OC, "objectclass");
builder.add(AttributeValues.create(AT_OC, "top"));
builder.add(AttributeValues.create(AT_OC, "person"));
builder.add(AttributeValues.create(AT_OC, "organizationalPerson"));
attrs.add(builder.toAttribute());
attrs.add(Attributes.create("cn", "Fiona Jensen"));
attrs.add(Attributes.create("sn", "Jensen"));
attrs.add(Attributes.create("uid", "fiona"));
attrs.add(Attributes.create("telephonenumber", "+1 408 555 1212"));
Assert.assertTrue(add.getAttributes().containsAll(attrs));
// Change record #2.
change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof DeleteChangeRecordEntry);
delete = (DeleteChangeRecordEntry) change;
dn = DN.decode("cn=Robert Jensen, ou=Marketing, dc=airius, dc=com");
Assert.assertEquals(delete.getDN(), dn);
// Change record #3.
change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof ModifyDNChangeRecordEntry);
modifyDN = (ModifyDNChangeRecordEntry) change;
dn = DN.decode("cn=Paul Jensen, ou=Product Development, dc=airius, dc=com");
Assert.assertEquals(modifyDN.getDN(), dn);
rdn = RDN.decode("cn=paula jensen");
Assert.assertEquals(modifyDN.getNewRDN(), rdn);
Assert.assertNull(modifyDN.getNewSuperiorDN());
Assert.assertTrue(modifyDN.deleteOldRDN());
// Change record #4.
change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof ModifyDNChangeRecordEntry);
modifyDN = (ModifyDNChangeRecordEntry) change;
dn = DN.decode("ou=PD Accountants, ou=Product Development, dc=airius, dc=com");
Assert.assertEquals(modifyDN.getDN(), dn);
rdn = RDN.decode("ou=Product Development Accountants");
Assert.assertEquals(modifyDN.getNewRDN(), rdn);
dn = DN.decode("ou=Accounting, dc=airius, dc=com");
Assert.assertEquals(modifyDN.getNewSuperiorDN(), dn);
Assert.assertFalse(modifyDN.deleteOldRDN());
// Change record #5.
change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof ModifyChangeRecordEntry);
modify = (ModifyChangeRecordEntry) change;
dn = DN.decode("cn=Paula Jensen, ou=Product Development, dc=airius, dc=com");
Assert.assertEquals(modify.getDN(), dn);
i = modify.getModifications().iterator();
Assert.assertTrue(i.hasNext());
mod = i.next().toModification();
Assert.assertEquals(mod.getModificationType(), ModificationType.ADD);
attr = Attributes.create("postaladdress", "123 Anystreet $ Sunnyvale, CA $ 94086");
Assert.assertEquals(mod.getAttribute(), attr);
Assert.assertTrue(i.hasNext());
mod = i.next().toModification();
Assert.assertEquals(mod.getModificationType(), ModificationType.DELETE);
attr = Attributes.empty(AT_DESCR);
Assert.assertEquals(mod.getAttribute(), attr);
Assert.assertTrue(i.hasNext());
mod = i.next().toModification();
Assert.assertEquals(mod.getModificationType(), ModificationType.REPLACE);
builder = new AttributeBuilder(AT_TELN, "telephonenumber");
builder.add(AttributeValues.create(AT_TELN, "+1 408 555 1234"));
builder.add(AttributeValues.create(AT_TELN, "+1 408 555 5678"));
Assert.assertEquals(mod.getAttribute(), builder.toAttribute());
Assert.assertTrue(i.hasNext());
mod = i.next().toModification();
Assert.assertEquals(mod.getModificationType(), ModificationType.DELETE);
attr = Attributes.create("facsimiletelephonenumber", "+1 408 555 9876");
Assert.assertEquals(mod.getAttribute(), attr);
Assert.assertFalse(i.hasNext());
// Change record #6.
change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof ModifyChangeRecordEntry);
modify = (ModifyChangeRecordEntry) change;
dn = DN.decode("cn=Ingrid Jensen, ou=Product Support, dc=airius, dc=com");
Assert.assertEquals(modify.getDN(), dn);
i = modify.getModifications().iterator();
Assert.assertTrue(i.hasNext());
mod = i.next().toModification();
Assert.assertEquals(mod.getModificationType(), ModificationType.REPLACE);
attr = Attributes.empty(DirectoryServer.getAttributeType("postaladdress"));
Assert.assertEquals(mod.getAttribute(), attr);
// Change record #7.
change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof ModifyChangeRecordEntry);
modify = (ModifyChangeRecordEntry) change;
Assert.assertTrue(modify.getDN().isNullDN());
i = modify.getModifications().iterator();
Assert.assertTrue(i.hasNext());
mod = i.next().toModification();
Assert.assertEquals(mod.getModificationType(), ModificationType.DELETE);
attr = Attributes.empty(AT_DESCR);
Assert.assertEquals(mod.getAttribute(), attr);
// Change record #8.
change = reader.readChangeRecord(false);
Assert.assertTrue(change instanceof ModifyChangeRecordEntry);
modify = (ModifyChangeRecordEntry) change;
dn = DN.decode("uid=rogasawara, ou=\u55b6\u696d\u90e8, o=airius");
Assert.assertEquals(modify.getDN(), dn);
i = modify.getModifications().iterator();
Assert.assertTrue(i.hasNext());
mod = i.next().toModification();
Assert.assertEquals(mod.getModificationType(), ModificationType.DELETE);
attr = Attributes.empty(AT_DESCR);
Assert.assertEquals(mod.getAttribute(), attr);
Assert.assertFalse(i.hasNext());
// Check final state.
Assert.assertNull(reader.readChangeRecord(false));
Assert.assertEquals(reader.getEntriesIgnored(), 0);
Assert.assertEquals(reader.getEntriesRead(), 0);
Assert.assertEquals(reader.getEntriesRejected(), 0);
Assert.assertEquals(reader.getLastEntryLineNumber(), 72);
} finally {
reader.close();
}
}
