/**
* Test the feature of clearing a JEReplicaDB used by a replication server. The clear feature is
* used when a replication server receives a request to reset the generationId of a given domain.
*/
@Test
public void testClear() throws Exception {
ReplicationServer replicationServer = null;
JEReplicaDB replicaDB = null;
try {
TestCaseUtils.startServer();
replicationServer = configureReplicationServer(100, 5000);
replicaDB = newReplicaDB(replicationServer);
CSN[] csns = generateCSNs(1, 0, 3);
// Add the changes and check they are here
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[0], "uid"));
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[1], "uid"));
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[2], "uid"));
assertEquals(csns[0], replicaDB.getOldestCSN());
assertEquals(csns[2], replicaDB.getNewestCSN());
// Clear DB and check it is cleared.
replicaDB.clear();
assertEquals(null, replicaDB.getOldestCSN());
assertEquals(null, replicaDB.getNewestCSN());
} finally {
shutdown(replicaDB);
remove(replicationServer);
}
}
/**
* Test entry.
*
* @throws Exception If the test failed unexpectedly.
*/
@Test()
public void testEntryToAndFromDatabase() throws Exception {
// Make sure that the server is up and running.
TestCaseUtils.startServer();
// Convert the test LDIF string to a byte array
byte[] originalLDIFBytes = StaticUtils.getBytes(ldifString);
LDIFReader reader =
new LDIFReader(new LDIFImportConfig(new ByteArrayInputStream(originalLDIFBytes)));
Entry entryBefore, entryAfter;
while ((entryBefore = reader.readEntry(false)) != null) {
ByteString bytes = ID2Entry.entryToDatabase(entryBefore, new DataConfig(false, false, null));
entryAfter = ID2Entry.entryFromDatabase(bytes, DirectoryServer.getDefaultCompressedSchema());
// check DN and number of attributes
assertEquals(entryBefore.getAttributes().size(), entryAfter.getAttributes().size());
assertEquals(entryBefore.getDN(), entryAfter.getDN());
// check the object classes were not changed
for (String ocBefore : entryBefore.getObjectClasses().values()) {
ObjectClass objectClass = DirectoryServer.getObjectClass(ocBefore.toLowerCase());
if (objectClass == null) {
objectClass = DirectoryServer.getDefaultObjectClass(ocBefore);
}
String ocAfter = entryAfter.getObjectClasses().get(objectClass);
assertEquals(ocBefore, ocAfter);
}
// check the user attributes were not changed
for (AttributeType attrType : entryBefore.getUserAttributes().keySet()) {
List<Attribute> listBefore = entryBefore.getAttribute(attrType);
List<Attribute> listAfter = entryAfter.getAttribute(attrType);
assertTrue(listAfter != null);
assertEquals(listBefore.size(), listAfter.size());
for (Attribute attrBefore : listBefore) {
boolean found = false;
for (Attribute attrAfter : listAfter) {
if (attrAfter.optionsEqual(attrBefore.getOptions())) {
// Found the corresponding attribute
assertEquals(attrBefore, attrAfter);
found = true;
}
}
assertTrue(found);
}
}
}
reader.close();
}
/**
* Ensures that the Directory Server is running.
*
* @throws Exception If an unexpected problem occurs.
*/
@BeforeClass()
public void startServer() throws Exception {
TestCaseUtils.startServer();
entryDNType = DirectoryConfig.getAttributeType("entrydn", false);
assertNotNull(entryDNType);
}
/**
* Once-only initialization.
*
* @throws Exception If an unexpected error occurred.
*/
@BeforeClass
public void setUp() throws Exception {
// This test suite depends on having the schema available, so we'll
// start the server.
TestCaseUtils.startServer();
// Initialize schema bits.
OC_TOP = DirectoryServer.getObjectClass("top");
OC_PERSON = DirectoryServer.getObjectClass("person");
AT_OC = DirectoryServer.getObjectClassAttributeType();
AT_CN = DirectoryServer.getAttributeType("cn");
AT_SN = DirectoryServer.getAttributeType("sn");
AT_DESCR = DirectoryServer.getAttributeType("description");
AT_TELN = DirectoryServer.getAttributeType("telephonenumber");
// Create a temporary file containing an attribute value.
TEMP_FILE = File.createTempFile("tmp", "txt");
OutputStream out = null;
try {
out = new FileOutputStream(TEMP_FILE);
out.write(TEMP_FILE_STRING.getBytes("UTF-8"));
} finally {
if (out != null) {
out.close();
}
}
}
@BeforeClass()
public void setUp() throws Exception {
TestCaseUtils.startServer();
TestCaseUtils.clearJEBackend(false, "userRoot", SUFFIX);
InternalClientConnection connection = InternalClientConnection.getRootConnection();
// Add suffix entry.
DN suffixDN = DN.decode(SUFFIX);
if (DirectoryServer.getEntry(suffixDN) == null) {
Entry suffixEntry = StaticUtils.createEntry(suffixDN);
AddOperation addOperation =
connection.processAdd(
suffixEntry.getDN(),
suffixEntry.getObjectClasses(),
suffixEntry.getUserAttributes(),
suffixEntry.getOperationalAttributes());
assertEquals(addOperation.getResultCode(), ResultCode.SUCCESS);
assertNotNull(DirectoryServer.getEntry(suffixEntry.getDN()));
}
// Add base entry.
DN baseDN = DN.decode(BASE);
if (DirectoryServer.getEntry(baseDN) == null) {
Entry baseEntry = StaticUtils.createEntry(baseDN);
AddOperation addOperation =
connection.processAdd(
baseEntry.getDN(),
baseEntry.getObjectClasses(),
baseEntry.getUserAttributes(),
baseEntry.getOperationalAttributes());
assertEquals(addOperation.getResultCode(), ResultCode.SUCCESS);
assertNotNull(DirectoryServer.getEntry(baseEntry.getDN()));
}
// Add test entry.
Entry testEntry =
TestCaseUtils.makeEntry(
"dn: uid=rogasawara," + BASE,
"objectclass: top",
"objectclass: person",
"objectclass: organizationalPerson",
"objectclass: inetOrgPerson",
"uid: rogasawara",
"userpassword: password",
"mail: [email protected]",
"givenname: Rodney",
"sn: Ogasawara",
"cn: Rodney Ogasawara",
"title: Sales, Director");
AddOperation addOperation =
connection.processAdd(
testEntry.getDN(),
testEntry.getObjectClasses(),
testEntry.getUserAttributes(),
testEntry.getOperationalAttributes());
assertEquals(addOperation.getResultCode(), ResultCode.SUCCESS);
assertNotNull(DirectoryServer.getEntry(testEntry.getDN()));
}
/**
* Sets up tests.
*
* @throws Exception If the server could not be initialized.
*/
@BeforeClass
public void setUp() throws Exception {
// This test suite depends on having the schema available, so
// we'll start the server.
TestCaseUtils.startServer();
builder = BooleanPropertyDefinition.createBuilder(RootCfgDefn.getInstance(), "test-property");
}
@BeforeClass
public void setUp() throws Exception {
// The server must be running for these tests, so that
// it can provide "getServerRoot()".
TestCaseUtils.startServer();
resourcePath =
DirectoryServer.getInstanceRoot() + File.separator + "config" + File.separator + "MakeLDIF";
}
@Test
public void testTrim() throws Exception {
ReplicationServer replicationServer = null;
JEReplicaDB replicaDB = null;
try {
TestCaseUtils.startServer();
replicationServer = configureReplicationServer(100, 5000);
replicaDB = newReplicaDB(replicationServer);
CSN[] csns = generateCSNs(1, 0, 5);
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[0], "uid"));
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[1], "uid"));
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[2], "uid"));
DeleteMsg update4 = new DeleteMsg(TEST_ROOT_DN, csns[3], "uid");
// --
// Iterator tests with changes persisted
assertFoundInOrder(replicaDB, csns[0], csns[1], csns[2]);
assertNotFound(replicaDB, csns[4], AFTER_MATCHING_KEY);
assertEquals(replicaDB.getOldestCSN(), csns[0]);
assertEquals(replicaDB.getNewestCSN(), csns[2]);
// --
// Cursor tests with changes persisted
replicaDB.add(update4);
assertFoundInOrder(replicaDB, csns[0], csns[1], csns[2], csns[3]);
// Test cursor from existing CSN
assertFoundInOrder(replicaDB, csns[2], csns[3]);
assertFoundInOrder(replicaDB, csns[3]);
assertNotFound(replicaDB, csns[4], AFTER_MATCHING_KEY);
replicaDB.purgeUpTo(new CSN(Long.MAX_VALUE, 0, 0));
int count = 0;
boolean purgeSucceeded = false;
final CSN expectedNewestCSN = csns[3];
do {
Thread.sleep(10);
final CSN oldestCSN = replicaDB.getOldestCSN();
final CSN newestCSN = replicaDB.getNewestCSN();
purgeSucceeded = oldestCSN.equals(expectedNewestCSN) && newestCSN.equals(expectedNewestCSN);
count++;
} while (!purgeSucceeded && count < 100);
assertTrue(purgeSucceeded);
} finally {
shutdown(replicaDB);
remove(replicationServer);
}
}
/**
* Make sure that the server is running.
*
* @throws Exception If an unexpected problem occurs.
*/
@BeforeClass()
public void startServer() throws Exception {
TestCaseUtils.startServer();
givenNameType = DirectoryServer.getAttributeType("givenname", false);
assertNotNull(givenNameType);
snType = DirectoryServer.getAttributeType("sn", false);
assertNotNull(snType);
aaccfJohnsonDN = DN.decode("uid=aaccf.johnson,dc=example,dc=com");
aaronZimmermanDN = DN.decode("uid=aaron.zimmerman,dc=example,dc=com");
albertSmithDN = DN.decode("uid=albert.smith,dc=example,dc=com");
albertZimmermanDN = DN.decode("uid=albert.zimmerman,dc=example,dc=com");
lowercaseMcGeeDN = DN.decode("uid=lowercase.mcgee,dc=example,dc=com");
margaretJonesDN = DN.decode("uid=margaret.jones,dc=example,dc=com");
maryJonesDN = DN.decode("uid=mary.jones,dc=example,dc=com");
samZweckDN = DN.decode("uid=sam.zweck,dc=example,dc=com");
zorroDN = DN.decode("uid=zorro,dc=example,dc=com");
}
/**
* Tests the entry encoding and decoding process the version 1 encoding.
*
* @throws Exception If the test failed unexpectedly.
*/
@Test()
public void testEntryToAndFromDatabaseV1() throws Exception {
// Make sure that the server is up and running.
TestCaseUtils.startServer();
// Convert the test LDIF string to a byte array
byte[] originalLDIFBytes = StaticUtils.getBytes(ldifString);
LDIFReader reader =
new LDIFReader(new LDIFImportConfig(new ByteArrayInputStream(originalLDIFBytes)));
Entry entryBefore, entryAfterV1;
while ((entryBefore = reader.readEntry(false)) != null) {
ByteStringBuilder bsb = new ByteStringBuilder();
encodeV1(entryBefore, bsb);
entryAfterV1 = Entry.decode(bsb.asReader());
assertEquals(entryBefore, entryAfterV1);
}
reader.close();
}
/**
* Test the cursor with all acceptable strategies combination. Creation of a replication server is
* costly so it is created only once on first test and cleaned after the last test using the stop
* line in data to do so.
*/
@Test(dataProvider = "cursorData")
public void testGenerateCursor(
CSN[] csns,
CSN startCsn,
KeyMatchingStrategy matchingStrategy,
PositionStrategy positionStrategy,
int startIndex,
int endIndex)
throws Exception {
DBCursor<UpdateMsg> cursor = null;
try {
if (replicationServer == null) {
// initialize only once
TestCaseUtils.startServer();
replicationServer = configureReplicationServer(100000, 10);
replicaDB = newReplicaDB(replicationServer);
for (CSN csn : csns) {
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csn, "uid"));
}
}
if (csns == null) {
return; // stop line, time to clean replication artefacts
}
cursor = replicaDB.generateCursorFrom(startCsn, matchingStrategy, positionStrategy);
if (startIndex != -1) {
assertThatCursorCanBeFullyReadFromStart(cursor, csns, startIndex, endIndex);
} else {
assertThatCursorIsExhausted(cursor);
}
} finally {
close(cursor);
if (csns == null) {
// stop line, stop and remove replication
shutdown(replicaDB);
remove(replicationServer);
}
}
}
/**
* Tests the entry encoding and decoding process the version 1 encoding.
*
* @throws Exception If the test failed unexpectedly.
*/
@Test(dataProvider = "encodeConfigs")
public void testEntryToAndFromDatabaseV3(EntryEncodeConfig config) throws Exception {
// Make sure that the server is up and running.
TestCaseUtils.startServer();
// Convert the test LDIF string to a byte array
byte[] originalLDIFBytes = StaticUtils.getBytes(ldifString);
LDIFReader reader =
new LDIFReader(new LDIFImportConfig(new ByteArrayInputStream(originalLDIFBytes)));
Entry entryBefore, entryAfterV3;
while ((entryBefore = reader.readEntry(false)) != null) {
ByteStringBuilder bsb = new ByteStringBuilder();
entryBefore.encode(bsb, config);
entryAfterV3 = Entry.decode(bsb.asReader());
if (config.excludeDN()) {
entryAfterV3.setDN(entryBefore.getDN());
}
assertEquals(entryBefore, entryAfterV3);
}
reader.close();
}
/**
* Ensures that the Directory Server is running before executing the testcases.
*
* @throws Exception If an unexpected problem occurs.
*/
@BeforeClass()
public void startServer() throws Exception {
TestCaseUtils.startServer();
TestCaseUtils.initializeTestBackend(true);
}
/**
* Ensures that the Directory Server is running.
*
* @throws Exception If an unexpected problem occurs.
*/
@BeforeClass()
public void startServer() throws Exception {
TestCaseUtils.startServer();
}
private void testGetOldestNewestCSNs(final int max, final int counterWindow) throws Exception {
String tn = "testDBCount(" + max + "," + counterWindow + ")";
debugInfo(tn, "Starting test");
File testRoot = null;
ReplicationServer replicationServer = null;
ReplicationDbEnv dbEnv = null;
JEReplicaDB replicaDB = null;
try {
TestCaseUtils.startServer();
replicationServer = configureReplicationServer(100000, 10);
testRoot = createCleanDir();
dbEnv = new ReplicationDbEnv(testRoot.getPath(), replicationServer);
replicaDB = new JEReplicaDB(1, TEST_ROOT_DN, replicationServer, dbEnv);
replicaDB.setCounterRecordWindowSize(counterWindow);
// Populate the db with 'max' msg
int mySeqnum = 1;
CSN csns[] = new CSN[2 * (max + 1)];
long now = System.currentTimeMillis();
for (int i = 1; i <= max; i++) {
csns[i] = new CSN(now + i, mySeqnum, 1);
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[i], "uid"));
mySeqnum += 2;
}
assertEquals(replicaDB.getOldestCSN(), csns[1], "Wrong oldest CSN");
assertEquals(replicaDB.getNewestCSN(), csns[max], "Wrong newest CSN");
// Now we want to test that after closing and reopening the db, the
// counting algo is well reinitialized and when new messages are added
// the new counter are correctly generated.
debugInfo(tn, "SHUTDOWN replicaDB and recreate");
replicaDB.shutdown();
replicaDB = new JEReplicaDB(1, TEST_ROOT_DN, replicationServer, dbEnv);
replicaDB.setCounterRecordWindowSize(counterWindow);
assertEquals(replicaDB.getOldestCSN(), csns[1], "Wrong oldest CSN");
assertEquals(replicaDB.getNewestCSN(), csns[max], "Wrong newest CSN");
// Populate the db with 'max' msg
for (int i = max + 1; i <= 2 * max; i++) {
csns[i] = new CSN(now + i, mySeqnum, 1);
replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[i], "uid"));
mySeqnum += 2;
}
assertEquals(replicaDB.getOldestCSN(), csns[1], "Wrong oldest CSN");
assertEquals(replicaDB.getNewestCSN(), csns[2 * max], "Wrong newest CSN");
replicaDB.purgeUpTo(new CSN(Long.MAX_VALUE, 0, 0));
String testcase = "AFTER PURGE (oldest, newest)=";
debugInfo(tn, testcase + replicaDB.getOldestCSN() + replicaDB.getNewestCSN());
assertEquals(replicaDB.getNewestCSN(), csns[2 * max], "Newest=");
// Clear ...
debugInfo(tn, "clear:");
replicaDB.clear();
// Check the db is cleared.
assertEquals(null, replicaDB.getOldestCSN());
assertEquals(null, replicaDB.getNewestCSN());
debugInfo(tn, "Success");
} finally {
shutdown(replicaDB);
if (dbEnv != null) {
dbEnv.shutdown();
}
remove(replicationServer);
TestCaseUtils.deleteDirectory(testRoot);
}
}
private void ensureServerIsUpAndRunning() throws Exception {
TestCaseUtils.startServer();
}
@BeforeClass
public final void setUp() throws Exception {
TestCaseUtils.startServer();
registerListeners();
}
/**
* Set up the environment for performing the tests in this suite.
*
* @throws Exception If the environment could not be set up.
*/
@BeforeClass
public void setUp() throws Exception {
// This test suite depends on having the schema available, so we'll start
// the server.
TestCaseUtils.startServer();
}
