/** * 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); } }