/**
* 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
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);
}
}
/**
* 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);
}
}
}
private void assertNotFound(
JEReplicaDB replicaDB, final CSN startCSN, final PositionStrategy positionStrategy)
throws ChangelogException {
DBCursor<UpdateMsg> cursor =
replicaDB.generateCursorFrom(startCSN, GREATER_THAN_OR_EQUAL_TO_KEY, positionStrategy);
try {
final SoftAssertions softly = new SoftAssertions();
softly.assertThat(cursor.next()).isFalse();
softly.assertThat(cursor.getRecord()).isNull();
softly.assertAll();
} finally {
close(cursor);
}
}
private void assertFoundInOrder(
JEReplicaDB replicaDB, final PositionStrategy positionStrategy, CSN... csns)
throws ChangelogException {
DBCursor<UpdateMsg> cursor =
replicaDB.generateCursorFrom(csns[0], GREATER_THAN_OR_EQUAL_TO_KEY, positionStrategy);
try {
assertNull(cursor.getRecord(), "Cursor should point to a null record initially");
for (int i = positionStrategy == ON_MATCHING_KEY ? 0 : 1; i < csns.length; i++) {
final String msg = "i=" + i + ", csns[i]=" + csns[i].toStringUI();
final SoftAssertions softly = new SoftAssertions();
softly.assertThat(cursor.next()).as(msg).isTrue();
softly.assertThat(cursor.getRecord().getCSN()).as(msg).isEqualTo(csns[i]);
softly.assertAll();
}
final SoftAssertions softly = new SoftAssertions();
softly.assertThat(cursor.next()).isFalse();
softly.assertThat(cursor.getRecord()).isNull();
softly.assertAll();
} finally {
close(cursor);
}
}
private void shutdown(JEReplicaDB replicaDB) {
if (replicaDB != null) {
replicaDB.shutdown();
}
}
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);
}
}