/** {@inheritDoc} */
@Override
public void configureBackend(Configuration cfg) throws ConfigException {
Validator.ensureNotNull(cfg);
Validator.ensureTrue(cfg instanceof LocalDBBackendCfg);
this.cfg = (LocalDBBackendCfg) cfg;
Set<DN> dnSet = this.cfg.getBaseDN();
baseDNs = new DN[dnSet.size()];
dnSet.toArray(baseDNs);
}
/** {@inheritDoc} */
@Override
public ConfigChangeResult applyConfigurationChange(BackupBackendCfg cfg) {
ResultCode resultCode = ResultCode.SUCCESS;
boolean adminActionRequired = false;
ArrayList<Message> messages = new ArrayList<Message>();
Set<String> values = cfg.getBackupDirectory();
backupDirectories = new LinkedHashSet<File>(values.size());
for (String s : values) {
backupDirectories.add(getFileForPath(s));
}
currentConfig = cfg;
return new ConfigChangeResult(resultCode, adminActionRequired, messages);
}
/** Test invalid int values. */
@Test(dataProvider = "persistentSearchChangeTypeData")
public void checkInvalidIntTest(Map<Integer, String> exceptedValues) throws Exception {
Set<Integer> keys = exceptedValues.keySet();
for (int i = -10; i < 10; i++) {
if (keys.contains(i)) {
continue;
}
try {
PersistentSearchChangeType.valueOf(i);
fail();
} catch (LDAPException e) {
assertThat(e.getMessage())
.contains(
"The provided integer value "
+ i
+ " does not correspond to any persistent search change type");
}
}
}
/** Test int to type. */
@Test(dataProvider = "persistentSearchChangeTypeData")
public void checkIntToTypeTest(Map<Integer, String> exceptedValues) throws Exception {
Set<Integer> keys = exceptedValues.keySet();
Set<PersistentSearchChangeType> expectedTypes = new HashSet<>(4);
for (int i = 1; i <= 15; i++) {
expectedTypes.clear();
for (int key : keys) {
if ((i & key) != 0) {
expectedTypes.add(PersistentSearchChangeType.valueOf(key));
}
}
Set<PersistentSearchChangeType> returnTypes = PersistentSearchChangeType.intToTypes(i);
assertEquals(expectedTypes.size(), returnTypes.size());
for (PersistentSearchChangeType type : expectedTypes) {
assertTrue(returnTypes.contains(type));
}
}
// We should have an exception
try {
PersistentSearchChangeType.intToTypes(0);
fail();
} catch (LDAPException expected) {
assertEquals(
expected.getMessage(),
"The provided integer value indicated that there were no persistent search change types, which is not allowed");
}
// We should have an exception
int i = 16;
try {
PersistentSearchChangeType.intToTypes(i);
fail();
} catch (LDAPException expected) {
assertEquals(
expected.getMessage(),
"The provided integer value "
+ i
+ " was outside the range of acceptable values for an encoded change type set");
}
}
/** {@inheritDoc} */
@Override()
public boolean isIndexed(AttributeType attributeType, IndexType indexType) {
try {
EntryContainer ec = rootContainer.getEntryContainer(baseDNs[0]);
AttributeIndex ai = ec.getAttributeIndex(attributeType);
if (ai == null) {
return false;
}
Set<LocalDBIndexCfgDefn.IndexType> indexTypes = ai.getConfiguration().getIndexType();
switch (indexType) {
case PRESENCE:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.PRESENCE);
case EQUALITY:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.EQUALITY);
case SUBSTRING:
case SUBINITIAL:
case SUBANY:
case SUBFINAL:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.SUBSTRING);
case GREATER_OR_EQUAL:
case LESS_OR_EQUAL:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.ORDERING);
case APPROXIMATE:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.APPROXIMATE);
default:
return false;
}
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
return false;
}
}
private SSLEngine createSSLEngine(LDAPConnectionHandlerCfg config, SSLContext sslContext)
throws DirectoryException {
try {
SSLEngine sslEngine = sslContext.createSSLEngine();
sslEngine.setUseClientMode(false);
final Set<String> protocols = config.getSSLProtocol();
if (!protocols.isEmpty()) {
sslEngine.setEnabledProtocols(protocols.toArray(new String[0]));
}
final Set<String> ciphers = config.getSSLCipherSuite();
if (!ciphers.isEmpty()) {
sslEngine.setEnabledCipherSuites(ciphers.toArray(new String[0]));
}
switch (config.getSSLClientAuthPolicy()) {
case DISABLED:
sslEngine.setNeedClientAuth(false);
sslEngine.setWantClientAuth(false);
break;
case REQUIRED:
sslEngine.setWantClientAuth(true);
sslEngine.setNeedClientAuth(true);
break;
case OPTIONAL:
default:
sslEngine.setNeedClientAuth(false);
sslEngine.setWantClientAuth(true);
break;
}
return sslEngine;
} catch (Exception e) {
logger.traceException(e);
ResultCode resCode = DirectoryServer.getServerErrorResultCode();
LocalizableMessage message =
ERR_CONNHANDLER_SSL_CANNOT_INITIALIZE.get(getExceptionMessage(e));
throw new DirectoryException(resCode, message, 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);
}
}
/** Test PersistentSearchControl. */
@Test(dataProvider = "persistentSearchControl")
public void checkPersistentSearchControlTest(
boolean isCritical, boolean changesOnly, boolean returnECs) throws Exception {
// Test constructor
// CheclPersistentSearchControlTest(Set<PersistentSearchChangeType>
// changeTypes, boolean changesOnly, boolean returnECs
for (int i = 1; i <= 15; i++) {
Set<PersistentSearchChangeType> returnTypes = PersistentSearchChangeType.intToTypes(i);
PersistentSearchControl psc =
new PersistentSearchControl(returnTypes, changesOnly, returnECs);
assertNotNull(psc);
assertEquals(changesOnly, psc.getChangesOnly());
assertEquals(returnECs, psc.getReturnECs());
assertEquals(returnTypes.size(), psc.getChangeTypes().size());
assertEquals(OID_PERSISTENT_SEARCH, psc.getOID());
}
// Test constructor
// CString oid, boolean isCritical,
// Set<PersistentSearchChangeType> changeTypes,
// boolean changesOnly, boolean returnECs
for (int i = 1; i <= 15; i++) {
Set<PersistentSearchChangeType> returnTypes = PersistentSearchChangeType.intToTypes(i);
PersistentSearchControl psc =
new PersistentSearchControl(isCritical, returnTypes, changesOnly, returnECs);
assertNotNull(psc);
assertEquals(isCritical, psc.isCritical());
assertEquals(OID_PERSISTENT_SEARCH, psc.getOID());
assertEquals(changesOnly, psc.getChangesOnly());
assertEquals(returnECs, psc.getReturnECs());
assertEquals(returnTypes.size(), psc.getChangeTypes().size());
}
// Test encode/decode
ByteStringBuilder bsb = new ByteStringBuilder();
ASN1Writer writer = ASN1.getWriter(bsb);
for (int i = 1; i <= 15; i++) {
bsb.clear();
Set<PersistentSearchChangeType> returnTypes = PersistentSearchChangeType.intToTypes(i);
PersistentSearchControl psc =
new PersistentSearchControl(isCritical, returnTypes, changesOnly, returnECs);
psc.write(writer);
LDAPControl control = LDAPReader.readControl(ASN1.getReader(bsb));
psc = PersistentSearchControl.DECODER.decode(control.isCritical(), control.getValue());
assertNotNull(psc);
assertEquals(isCritical, psc.isCritical());
assertEquals(OID_PERSISTENT_SEARCH, psc.getOID());
assertEquals(changesOnly, psc.getChangesOnly());
assertEquals(returnECs, psc.getReturnECs());
assertEquals(returnTypes.size(), psc.getChangeTypes().size());
// Check the toString
String changeTypes = PersistentSearchChangeType.changeTypesToString(psc.getChangeTypes());
String toString =
"PersistentSearchControl(changeTypes=\""
+ changeTypes
+ "\",changesOnly="
+ psc.getChangesOnly()
+ ",returnECs="
+ psc.getReturnECs()
+ ")";
assertEquals(psc.toString(), toString);
// check null value for the control
try {
control = new LDAPControl(OID_PERSISTENT_SEARCH, isCritical);
psc = PersistentSearchControl.DECODER.decode(control.isCritical(), control.getValue());
fail();
} catch (DirectoryException expected) {
assertEquals(expected.getMessage(), CANNOT_DECODE_PERSISTENT_SEARCH_CONTROL_NO_VALUE);
}
// check invalid value for the control
try {
control =
new LDAPControl(OID_PERSISTENT_SEARCH, isCritical, ByteString.valueOf("invalid value"));
psc = PersistentSearchControl.DECODER.decode(control.isCritical(), control.getValue());
fail();
} catch (DirectoryException expected) {
assertThat(expected.getMessage())
.contains("Cannot decode the provided persistent search control");
}
}
}
