/**
* Decodes the provided list of strings as the representation of a backup info structure.
*
* @param backupDirectory The reference to the backup directory with which the backup info is
* associated.
* @param encodedInfo The list of strings that comprise the string representation of the backup
* info structure.
* @return The decoded backup info structure.
* @throws ConfigException If a problem occurs while attempting to decode the backup info data.
*/
public static BackupInfo decode(BackupDirectory backupDirectory, LinkedList<String> encodedInfo)
throws ConfigException {
String backupID = null;
Date backupDate = null;
boolean isIncremental = false;
boolean isCompressed = false;
boolean isEncrypted = false;
byte[] unsignedHash = null;
byte[] signedHash = null;
HashSet<String> dependencies = new HashSet<String>();
HashMap<String, String> backupProperties = new HashMap<String, String>();
String backupPath = backupDirectory.getPath();
try {
for (String line : encodedInfo) {
int equalPos = line.indexOf('=');
if (equalPos < 0) {
Message message = ERR_BACKUPINFO_NO_DELIMITER.get(line, backupPath);
throw new ConfigException(message);
} else if (equalPos == 0) {
Message message = ERR_BACKUPINFO_NO_NAME.get(line, backupPath);
throw new ConfigException(message);
}
String name = line.substring(0, equalPos);
String value = line.substring(equalPos + 1);
if (name.equals(PROPERTY_BACKUP_ID)) {
if (backupID == null) {
backupID = value;
} else {
Message message = ERR_BACKUPINFO_MULTIPLE_BACKUP_IDS.get(backupPath, backupID, value);
throw new ConfigException(message);
}
} else if (name.equals(PROPERTY_BACKUP_DATE)) {
SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT_GMT_TIME);
dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
backupDate = dateFormat.parse(value);
} else if (name.equals(PROPERTY_IS_INCREMENTAL)) {
isIncremental = Boolean.valueOf(value);
} else if (name.equals(PROPERTY_IS_COMPRESSED)) {
isCompressed = Boolean.valueOf(value);
} else if (name.equals(PROPERTY_IS_ENCRYPTED)) {
isEncrypted = Boolean.valueOf(value);
} else if (name.equals(PROPERTY_UNSIGNED_HASH)) {
unsignedHash = Base64.decode(value);
} else if (name.equals(PROPERTY_SIGNED_HASH)) {
signedHash = Base64.decode(value);
} else if (name.equals(PROPERTY_DEPENDENCY)) {
dependencies.add(value);
} else if (name.startsWith(PROPERTY_CUSTOM_PREFIX)) {
String propertyName = name.substring(PROPERTY_CUSTOM_PREFIX.length());
backupProperties.put(propertyName, value);
} else {
Message message = ERR_BACKUPINFO_UNKNOWN_PROPERTY.get(backupPath, name, value);
throw new ConfigException(message);
}
}
} catch (ConfigException ce) {
throw ce;
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
Message message = ERR_BACKUPINFO_CANNOT_DECODE.get(backupPath, getExceptionMessage(e));
throw new ConfigException(message, e);
}
// There must have been at least a backup ID and backup date
// specified.
if (backupID == null) {
Message message = ERR_BACKUPINFO_NO_BACKUP_ID.get(backupPath);
throw new ConfigException(message);
}
if (backupDate == null) {
Message message = ERR_BACKUPINFO_NO_BACKUP_DATE.get(backupID, backupPath);
throw new ConfigException(message);
}
return new BackupInfo(
backupDirectory,
backupID,
backupDate,
isIncremental,
isCompressed,
isEncrypted,
unsignedHash,
signedHash,
dependencies,
backupProperties);
}
/**
* 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;
}