Remove StorageLevel.MEMORY

This enum is defunct and results in DISK being used. Remove it.

JIRA: CONTROLLER-2101
Change-Id: Ibc6f6916f20e5b0fc0f3c8fe6651e65f24074d53
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/atomix-storage/src/main/java/io/atomix/storage/journal/StorageLevel.java b/atomix-storage/src/main/java/io/atomix/storage/journal/StorageLevel.java
index 230fbb5ad06d0318873425658601fa7c54497d1a..9cf1ff793326de6538f27227e186a280ed5667a5 100644 (file)
--- a/atomix-storage/src/main/java/io/atomix/storage/journal/StorageLevel.java
+++ b/atomix-storage/src/main/java/io/atomix/storage/journal/StorageLevel.java
@@ -19,21 +19,12 @@ package io.atomix.storage.journal;
  * Storage level configuration values which control how logs are stored on disk or in memory.
  */
 public enum StorageLevel {
-
-  /**
-   * Stores data in memory only.
-   */
-  @Deprecated
-  MEMORY,
-
-  /**
-   * Stores data in a memory-mapped file.
-   */
-  MAPPED,
-
-  /**
-   * Stores data on disk.
-   */
-  DISK
-
+    /**
+     * Stores data in a memory-mapped file.
+     */
+    MAPPED,
+    /**
+     * Stores data on disk.
+     */
+    DISK
 }

diff --git a/atomix-storage/src/test/java/io/atomix/storage/journal/AbstractJournalTest.java b/atomix-storage/src/test/java/io/atomix/storage/journal/AbstractJournalTest.java
index f574f900b145de2f4889158bb9bfbb9b154acd70..5f94b4541a4ba5213e4dd763799c0fec3faaf54c 100644 (file)
--- a/atomix-storage/src/test/java/io/atomix/storage/journal/AbstractJournalTest.java
+++ b/atomix-storage/src/test/java/io/atomix/storage/journal/AbstractJournalTest.java
@@ -44,344 +44,381 @@ import org.junit.runners.Parameterized;
  */
 @RunWith(Parameterized.class)
 public abstract class AbstractJournalTest {
-  private static final JournalSerdes NAMESPACE = JournalSerdes.builder()
-      .register(new TestEntrySerdes(), TestEntry.class)
-      .register(new ByteArraySerdes(), byte[].class)
-      .build();
-
-  protected static final TestEntry ENTRY = new TestEntry(32);
-  private static final Path PATH = Paths.get("target/test-logs/");
-
-  private final int maxSegmentSize;
-  protected final int entriesPerSegment;
-
-  protected AbstractJournalTest(final int maxSegmentSize) {
-    this.maxSegmentSize = maxSegmentSize;
-    int entryLength = NAMESPACE.serialize(ENTRY).length + 8;
-    entriesPerSegment = (maxSegmentSize - 64) / entryLength;
-  }
-
-  protected abstract StorageLevel storageLevel();
-
-  @Parameterized.Parameters
-  public static List<Object[]> primeNumbers() {
-    List<Object[]> runs = new ArrayList<>();
-    for (int i = 1; i <= 10; i++) {
-      for (int j = 1; j <= 10; j++) {
-        runs.add(new Object[]{64 + i * (NAMESPACE.serialize(ENTRY).length + 8) + j});
-      }
-    }
-    return runs;
-  }
-
-  protected SegmentedJournal<TestEntry> createJournal() {
-    return SegmentedJournal.<TestEntry>builder()
-        .withName("test")
-        .withDirectory(PATH.toFile())
-        .withNamespace(NAMESPACE)
-        .withStorageLevel(storageLevel())
-        .withMaxSegmentSize(maxSegmentSize)
-        .withIndexDensity(.2)
+    private static final JournalSerdes NAMESPACE = JournalSerdes.builder()
+        .register(new TestEntrySerdes(), TestEntry.class)
+        .register(new ByteArraySerdes(), byte[].class)
         .build();
-  }
-
-  @Test
-  public void testCloseMultipleTimes() {
-    // given
-    final Journal<TestEntry> journal = createJournal();
-
-    // when
-    journal.close();
-
-    // then
-    journal.close();
-  }
-
-  @Test
-  public void testWriteRead() throws Exception {
-    try (Journal<TestEntry> journal = createJournal()) {
-      JournalWriter<TestEntry> writer = journal.writer();
-      JournalReader<TestEntry> reader = journal.openReader(1);
-
-      // Append a couple entries.
-      Indexed<TestEntry> indexed;
-      assertEquals(1, writer.getNextIndex());
-      indexed = writer.append(ENTRY);
-      assertEquals(1, indexed.index());
-
-      assertEquals(2, writer.getNextIndex());
-      writer.append(ENTRY);
-      reader.reset(2);
-      indexed = reader.next();
-      assertEquals(2, indexed.index());
-      assertFalse(reader.hasNext());
-
-      // Test reading an entry
-      Indexed<TestEntry> entry1;
-      reader.reset();
-      entry1 = reader.next();
-      assertEquals(1, entry1.index());
-      assertEquals(entry1, reader.getCurrentEntry());
-      assertEquals(1, reader.getCurrentIndex());
-
-      // Test reading a second entry
-      Indexed<TestEntry> entry2;
-      assertTrue(reader.hasNext());
-      assertEquals(2, reader.getNextIndex());
-      entry2 = reader.next();
-      assertEquals(2, entry2.index());
-      assertEquals(entry2, reader.getCurrentEntry());
-      assertEquals(2, reader.getCurrentIndex());
-      assertFalse(reader.hasNext());
-
-      // Test opening a new reader and reading from the journal.
-      reader = journal.openReader(1);
-      assertTrue(reader.hasNext());
-      entry1 = reader.next();
-      assertEquals(1, entry1.index());
-      assertEquals(entry1, reader.getCurrentEntry());
-      assertEquals(1, reader.getCurrentIndex());
-      assertTrue(reader.hasNext());
-
-      assertTrue(reader.hasNext());
-      assertEquals(2, reader.getNextIndex());
-      entry2 = reader.next();
-      assertEquals(2, entry2.index());
-      assertEquals(entry2, reader.getCurrentEntry());
-      assertEquals(2, reader.getCurrentIndex());
-      assertFalse(reader.hasNext());
-
-      // Reset the reader.
-      reader.reset();
-
-      // Test opening a new reader and reading from the journal.
-      reader = journal.openReader(1);
-      assertTrue(reader.hasNext());
-      entry1 = reader.next();
-      assertEquals(1, entry1.index());
-      assertEquals(entry1, reader.getCurrentEntry());
-      assertEquals(1, reader.getCurrentIndex());
-      assertTrue(reader.hasNext());
-
-      assertTrue(reader.hasNext());
-      assertEquals(2, reader.getNextIndex());
-      entry2 = reader.next();
-      assertEquals(2, entry2.index());
-      assertEquals(entry2, reader.getCurrentEntry());
-      assertEquals(2, reader.getCurrentIndex());
-      assertFalse(reader.hasNext());
-
-      // Truncate the journal and write a different entry.
-      writer.truncate(1);
-      assertEquals(2, writer.getNextIndex());
-      writer.append(ENTRY);
-      reader.reset(2);
-      indexed = reader.next();
-      assertEquals(2, indexed.index());
-
-      // Reset the reader to a specific index and read the last entry again.
-      reader.reset(2);
-
-      assertNotNull(reader.getCurrentEntry());
-      assertEquals(1, reader.getCurrentIndex());
-      assertEquals(1, reader.getCurrentEntry().index());
-      assertTrue(reader.hasNext());
-      assertEquals(2, reader.getNextIndex());
-      entry2 = reader.next();
-      assertEquals(2, entry2.index());
-      assertEquals(entry2, reader.getCurrentEntry());
-      assertEquals(2, reader.getCurrentIndex());
-      assertFalse(reader.hasNext());
+
+    protected static final TestEntry ENTRY = new TestEntry(32);
+    private static final Path PATH = Paths.get("target/test-logs/");
+
+    private final StorageLevel storageLevel;
+    private final int maxSegmentSize;
+    protected final int entriesPerSegment;
+
+    protected AbstractJournalTest(final StorageLevel storageLevel, final int maxSegmentSize) {
+        this.storageLevel = storageLevel;
+        this.maxSegmentSize = maxSegmentSize;
+        int entryLength = NAMESPACE.serialize(ENTRY).length + 8;
+        entriesPerSegment = (maxSegmentSize - 64) / entryLength;
     }
-  }
-
-  @Test
-  public void testResetTruncateZero() throws Exception {
-    try (SegmentedJournal<TestEntry> journal = createJournal()) {
-      JournalWriter<TestEntry> writer = journal.writer();
-      JournalReader<TestEntry> reader = journal.openReader(1);
-
-      assertEquals(0, writer.getLastIndex());
-      writer.append(ENTRY);
-      writer.append(ENTRY);
-      writer.reset(1);
-      assertEquals(0, writer.getLastIndex());
-      writer.append(ENTRY);
-      assertEquals(1, reader.next().index());
-      writer.reset(1);
-      assertEquals(0, writer.getLastIndex());
-      writer.append(ENTRY);
-      assertEquals(1, writer.getLastIndex());
-      assertEquals(1, writer.getLastEntry().index());
-
-      assertTrue(reader.hasNext());
-      assertEquals(1, reader.next().index());
-
-      writer.truncate(0);
-      assertEquals(0, writer.getLastIndex());
-      assertNull(writer.getLastEntry());
-      writer.append(ENTRY);
-      assertEquals(1, writer.getLastIndex());
-      assertEquals(1, writer.getLastEntry().index());
-
-      assertTrue(reader.hasNext());
-      assertEquals(1, reader.next().index());
+
+    @Parameterized.Parameters
+    public static List<Object[]> primeNumbers() {
+        var runs = new ArrayList<Object[]>();
+        for (int i = 1; i <= 10; i++) {
+            for (int j = 1; j <= 10; j++) {
+                runs.add(new Object[]{64 + i * (NAMESPACE.serialize(ENTRY).length + 8) + j});
+            }
+        }
+        return runs;
     }
-  }
 
-  @Test
-  public void testTruncateRead() throws Exception {
-    int i = 10;
-    try (Journal<TestEntry> journal = createJournal()) {
-      JournalWriter<TestEntry> writer = journal.writer();
-      JournalReader<TestEntry> reader = journal.openReader(1);
+    protected SegmentedJournal<TestEntry> createJournal() {
+        return SegmentedJournal.<TestEntry>builder()
+            .withName("test")
+            .withDirectory(PATH.toFile())
+            .withNamespace(NAMESPACE)
+            .withStorageLevel(storageLevel)
+            .withMaxSegmentSize(maxSegmentSize)
+            .withIndexDensity(.2)
+            .build();
+    }
 
-      for (int j = 1; j <= i; j++) {
-        assertEquals(j, writer.append(new TestEntry(32)).index());
-      }
+    @Test
+    public void testCloseMultipleTimes() {
+        // given
+        final Journal<TestEntry> journal = createJournal();
 
-      for (int j = 1; j <= i - 2; j++) {
-        assertTrue(reader.hasNext());
-        assertEquals(j, reader.next().index());
-      }
+        // when
+        journal.close();
 
-      writer.truncate(i - 2);
+        // then
+        journal.close();
+    }
 
-      assertFalse(reader.hasNext());
-      assertEquals(i - 1, writer.append(new TestEntry(32)).index());
-      assertEquals(i, writer.append(new TestEntry(32)).index());
+    @Test
+    public void testWriteRead() throws Exception {
+        try (Journal<TestEntry> journal = createJournal()) {
+            JournalWriter<TestEntry> writer = journal.writer();
+            JournalReader<TestEntry> reader = journal.openReader(1);
+
+            // Append a couple entries.
+            Indexed<TestEntry> indexed;
+            assertEquals(1, writer.getNextIndex());
+            indexed = writer.append(ENTRY);
+            assertEquals(1, indexed.index());
+
+            assertEquals(2, writer.getNextIndex());
+            writer.append(ENTRY);
+            reader.reset(2);
+            indexed = reader.next();
+            assertEquals(2, indexed.index());
+            assertFalse(reader.hasNext());
+
+            // Test reading an entry
+            Indexed<TestEntry> entry1;
+            reader.reset();
+            entry1 = reader.next();
+            assertEquals(1, entry1.index());
+            assertEquals(entry1, reader.getCurrentEntry());
+            assertEquals(1, reader.getCurrentIndex());
+
+            // Test reading a second entry
+            Indexed<TestEntry> entry2;
+            assertTrue(reader.hasNext());
+            assertEquals(2, reader.getNextIndex());
+            entry2 = reader.next();
+            assertEquals(2, entry2.index());
+            assertEquals(entry2, reader.getCurrentEntry());
+            assertEquals(2, reader.getCurrentIndex());
+            assertFalse(reader.hasNext());
+
+            // Test opening a new reader and reading from the journal.
+            reader = journal.openReader(1);
+            assertTrue(reader.hasNext());
+            entry1 = reader.next();
+            assertEquals(1, entry1.index());
+            assertEquals(entry1, reader.getCurrentEntry());
+            assertEquals(1, reader.getCurrentIndex());
+            assertTrue(reader.hasNext());
+
+            assertTrue(reader.hasNext());
+            assertEquals(2, reader.getNextIndex());
+            entry2 = reader.next();
+            assertEquals(2, entry2.index());
+            assertEquals(entry2, reader.getCurrentEntry());
+            assertEquals(2, reader.getCurrentIndex());
+            assertFalse(reader.hasNext());
+
+            // Reset the reader.
+            reader.reset();
+
+            // Test opening a new reader and reading from the journal.
+            reader = journal.openReader(1);
+            assertTrue(reader.hasNext());
+            entry1 = reader.next();
+            assertEquals(1, entry1.index());
+            assertEquals(entry1, reader.getCurrentEntry());
+            assertEquals(1, reader.getCurrentIndex());
+            assertTrue(reader.hasNext());
+
+            assertTrue(reader.hasNext());
+            assertEquals(2, reader.getNextIndex());
+            entry2 = reader.next();
+            assertEquals(2, entry2.index());
+            assertEquals(entry2, reader.getCurrentEntry());
+            assertEquals(2, reader.getCurrentIndex());
+            assertFalse(reader.hasNext());
+
+            // Truncate the journal and write a different entry.
+            writer.truncate(1);
+            assertEquals(2, writer.getNextIndex());
+            writer.append(ENTRY);
+            reader.reset(2);
+            indexed = reader.next();
+            assertEquals(2, indexed.index());
+
+            // Reset the reader to a specific index and read the last entry again.
+            reader.reset(2);
+
+            assertNotNull(reader.getCurrentEntry());
+            assertEquals(1, reader.getCurrentIndex());
+            assertEquals(1, reader.getCurrentEntry().index());
+            assertTrue(reader.hasNext());
+            assertEquals(2, reader.getNextIndex());
+            entry2 = reader.next();
+            assertEquals(2, entry2.index());
+            assertEquals(entry2, reader.getCurrentEntry());
+            assertEquals(2, reader.getCurrentIndex());
+            assertFalse(reader.hasNext());
+        }
+    }
 
-      assertTrue(reader.hasNext());
-      Indexed<TestEntry> entry = reader.next();
-      assertEquals(i - 1, entry.index());
-      assertTrue(reader.hasNext());
-      entry = reader.next();
-      assertEquals(i, entry.index());
+    @Test
+    public void testResetTruncateZero() throws Exception {
+        try (SegmentedJournal<TestEntry> journal = createJournal()) {
+            JournalWriter<TestEntry> writer = journal.writer();
+            JournalReader<TestEntry> reader = journal.openReader(1);
+
+            assertEquals(0, writer.getLastIndex());
+            writer.append(ENTRY);
+            writer.append(ENTRY);
+            writer.reset(1);
+            assertEquals(0, writer.getLastIndex());
+            writer.append(ENTRY);
+            assertEquals(1, reader.next().index());
+            writer.reset(1);
+            assertEquals(0, writer.getLastIndex());
+            writer.append(ENTRY);
+            assertEquals(1, writer.getLastIndex());
+            assertEquals(1, writer.getLastEntry().index());
+
+            assertTrue(reader.hasNext());
+            assertEquals(1, reader.next().index());
+
+            writer.truncate(0);
+            assertEquals(0, writer.getLastIndex());
+            assertNull(writer.getLastEntry());
+            writer.append(ENTRY);
+            assertEquals(1, writer.getLastIndex());
+            assertEquals(1, writer.getLastEntry().index());
+
+            assertTrue(reader.hasNext());
+            assertEquals(1, reader.next().index());
+        }
     }
-  }
 
-  @Test
-  public void testWriteReadEntries() throws Exception {
-    try (Journal<TestEntry> journal = createJournal()) {
-      JournalWriter<TestEntry> writer = journal.writer();
-      JournalReader<TestEntry> reader = journal.openReader(1);
+    @Test
+    public void testTruncateRead() throws Exception {
+        int i = 10;
+        try (Journal<TestEntry> journal = createJournal()) {
+            JournalWriter<TestEntry> writer = journal.writer();
+            JournalReader<TestEntry> reader = journal.openReader(1);
+
+            for (int j = 1; j <= i; j++) {
+                assertEquals(j, writer.append(new TestEntry(32)).index());
+            }
+
+            for (int j = 1; j <= i - 2; j++) {
+                assertTrue(reader.hasNext());
+                assertEquals(j, reader.next().index());
+            }
+
+            writer.truncate(i - 2);
+
+            assertFalse(reader.hasNext());
+            assertEquals(i - 1, writer.append(new TestEntry(32)).index());
+            assertEquals(i, writer.append(new TestEntry(32)).index());
+
+            assertTrue(reader.hasNext());
+            Indexed<TestEntry> entry = reader.next();
+            assertEquals(i - 1, entry.index());
+            assertTrue(reader.hasNext());
+            entry = reader.next();
+            assertEquals(i, entry.index());
+        }
+    }
 
-      for (int i = 1; i <= entriesPerSegment * 5; i++) {
-        writer.append(ENTRY);
-        assertTrue(reader.hasNext());
-        Indexed<TestEntry> entry;
-        entry = reader.next();
-        assertEquals(i, entry.index());
-        assertEquals(32, entry.entry().bytes().length);
-        reader.reset(i);
-        entry = reader.next();
-        assertEquals(i, entry.index());
-        assertEquals(32, entry.entry().bytes().length);
-
-        if (i > 6) {
-          reader.reset(i - 5);
-          assertNotNull(reader.getCurrentEntry());
-          assertEquals(i - 6, reader.getCurrentIndex());
-          assertEquals(i - 6, reader.getCurrentEntry().index());
-          assertEquals(i - 5, reader.getNextIndex());
-          reader.reset(i + 1);
+    @Test
+    public void testWriteReadEntries() throws Exception {
+        try (Journal<TestEntry> journal = createJournal()) {
+            JournalWriter<TestEntry> writer = journal.writer();
+            JournalReader<TestEntry> reader = journal.openReader(1);
+
+            for (int i = 1; i <= entriesPerSegment * 5; i++) {
+                writer.append(ENTRY);
+                assertTrue(reader.hasNext());
+                Indexed<TestEntry> entry;
+                entry = reader.next();
+                assertEquals(i, entry.index());
+                assertEquals(32, entry.entry().bytes().length);
+                reader.reset(i);
+                entry = reader.next();
+                assertEquals(i, entry.index());
+                assertEquals(32, entry.entry().bytes().length);
+
+                if (i > 6) {
+                    reader.reset(i - 5);
+                    assertNotNull(reader.getCurrentEntry());
+                    assertEquals(i - 6, reader.getCurrentIndex());
+                    assertEquals(i - 6, reader.getCurrentEntry().index());
+                    assertEquals(i - 5, reader.getNextIndex());
+                    reader.reset(i + 1);
+                }
+
+                writer.truncate(i - 1);
+                writer.append(ENTRY);
+
+                assertTrue(reader.hasNext());
+                reader.reset(i);
+                assertTrue(reader.hasNext());
+                entry = reader.next();
+                assertEquals(i, entry.index());
+                assertEquals(32, entry.entry().bytes().length);
+            }
         }
+    }
 
-        writer.truncate(i - 1);
-        writer.append(ENTRY);
+    @Test
+    public void testWriteReadCommittedEntries() throws Exception {
+        try (Journal<TestEntry> journal = createJournal()) {
+            JournalWriter<TestEntry> writer = journal.writer();
+            JournalReader<TestEntry> reader = journal.openReader(1, JournalReader.Mode.COMMITS);
+
+            for (int i = 1; i <= entriesPerSegment * 5; i++) {
+                writer.append(ENTRY);
+                assertFalse(reader.hasNext());
+                writer.commit(i);
+                assertTrue(reader.hasNext());
+                Indexed<TestEntry> entry;
+                entry = reader.next();
+                assertEquals(i, entry.index());
+                assertEquals(32, entry.entry().bytes().length);
+                reader.reset(i);
+                entry = reader.next();
+                assertEquals(i, entry.index());
+                assertEquals(32, entry.entry().bytes().length);
+            }
+        }
+    }
 
-        assertTrue(reader.hasNext());
-        reader.reset(i);
-        assertTrue(reader.hasNext());
-        entry = reader.next();
-        assertEquals(i, entry.index());
-        assertEquals(32, entry.entry().bytes().length);
-      }
+    @Test
+    public void testReadAfterCompact() throws Exception {
+        try (SegmentedJournal<TestEntry> journal = createJournal()) {
+            JournalWriter<TestEntry> writer = journal.writer();
+            JournalReader<TestEntry> uncommittedReader = journal.openReader(1, JournalReader.Mode.ALL);
+            JournalReader<TestEntry> committedReader = journal.openReader(1, JournalReader.Mode.COMMITS);
+
+            for (int i = 1; i <= entriesPerSegment * 10; i++) {
+                assertEquals(i, writer.append(ENTRY).index());
+            }
+
+            assertEquals(1, uncommittedReader.getNextIndex());
+            assertTrue(uncommittedReader.hasNext());
+            assertEquals(1, committedReader.getNextIndex());
+            assertFalse(committedReader.hasNext());
+
+            writer.commit(entriesPerSegment * 9);
+
+            assertTrue(uncommittedReader.hasNext());
+            assertTrue(committedReader.hasNext());
+
+            for (int i = 1; i <= entriesPerSegment * 2.5; i++) {
+                assertEquals(i, uncommittedReader.next().index());
+                assertEquals(i, committedReader.next().index());
+            }
+
+            journal.compact(entriesPerSegment * 5 + 1);
+
+            assertNull(uncommittedReader.getCurrentEntry());
+            assertEquals(0, uncommittedReader.getCurrentIndex());
+            assertTrue(uncommittedReader.hasNext());
+            assertEquals(entriesPerSegment * 5 + 1, uncommittedReader.getNextIndex());
+            assertEquals(entriesPerSegment * 5 + 1, uncommittedReader.next().index());
+
+            assertNull(committedReader.getCurrentEntry());
+            assertEquals(0, committedReader.getCurrentIndex());
+            assertTrue(committedReader.hasNext());
+            assertEquals(entriesPerSegment * 5 + 1, committedReader.getNextIndex());
+            assertEquals(entriesPerSegment * 5 + 1, committedReader.next().index());
+        }
     }
-  }
 
-  @Test
-  public void testWriteReadCommittedEntries() throws Exception {
-    try (Journal<TestEntry> journal = createJournal()) {
-      JournalWriter<TestEntry> writer = journal.writer();
-      JournalReader<TestEntry> reader = journal.openReader(1, JournalReader.Mode.COMMITS);
+    /**
+     * Tests reading from a compacted journal.
+     */
+    @Test
+    public void testCompactAndRecover() throws Exception {
+        SegmentedJournal<TestEntry> journal = createJournal();
+
+        // Write three segments to the journal.
+        JournalWriter<TestEntry> writer = journal.writer();
+        for (int i = 0; i < entriesPerSegment * 3; i++) {
+            writer.append(ENTRY);
+        }
+
+        // Commit the entries and compact the first segment.
+        writer.commit(entriesPerSegment * 3);
+        journal.compact(entriesPerSegment + 1);
 
-      for (int i = 1; i <= entriesPerSegment * 5; i++) {
+        // Close the journal.
+        journal.close();
+
+        // Reopen the journal and create a reader.
+        journal = createJournal();
+        writer = journal.writer();
+        JournalReader<TestEntry> reader = journal.openReader(1, JournalReader.Mode.COMMITS);
+        writer.append(ENTRY);
         writer.append(ENTRY);
-        assertFalse(reader.hasNext());
-        writer.commit(i);
+        writer.commit(entriesPerSegment * 3);
+
+        // Ensure the reader starts at the first physical index in the journal.
+        assertEquals(entriesPerSegment + 1, reader.getNextIndex());
+        assertEquals(reader.getFirstIndex(), reader.getNextIndex());
         assertTrue(reader.hasNext());
-        Indexed<TestEntry> entry;
-        entry = reader.next();
-        assertEquals(i, entry.index());
-        assertEquals(32, entry.entry().bytes().length);
-        reader.reset(i);
-        entry = reader.next();
-        assertEquals(i, entry.index());
-        assertEquals(32, entry.entry().bytes().length);
-      }
-    }
-  }
-
-  @Test
-  public void testReadAfterCompact() throws Exception {
-    try (SegmentedJournal<TestEntry> journal = createJournal()) {
-      JournalWriter<TestEntry> writer = journal.writer();
-      JournalReader<TestEntry> uncommittedReader = journal.openReader(1, JournalReader.Mode.ALL);
-      JournalReader<TestEntry> committedReader = journal.openReader(1, JournalReader.Mode.COMMITS);
-
-      for (int i = 1; i <= entriesPerSegment * 10; i++) {
-        assertEquals(i, writer.append(ENTRY).index());
-      }
-
-      assertEquals(1, uncommittedReader.getNextIndex());
-      assertTrue(uncommittedReader.hasNext());
-      assertEquals(1, committedReader.getNextIndex());
-      assertFalse(committedReader.hasNext());
-
-      writer.commit(entriesPerSegment * 9);
-
-      assertTrue(uncommittedReader.hasNext());
-      assertTrue(committedReader.hasNext());
-
-      for (int i = 1; i <= entriesPerSegment * 2.5; i++) {
-        assertEquals(i, uncommittedReader.next().index());
-        assertEquals(i, committedReader.next().index());
-      }
-
-      journal.compact(entriesPerSegment * 5 + 1);
-
-      assertNull(uncommittedReader.getCurrentEntry());
-      assertEquals(0, uncommittedReader.getCurrentIndex());
-      assertTrue(uncommittedReader.hasNext());
-      assertEquals(entriesPerSegment * 5 + 1, uncommittedReader.getNextIndex());
-      assertEquals(entriesPerSegment * 5 + 1, uncommittedReader.next().index());
-
-      assertNull(committedReader.getCurrentEntry());
-      assertEquals(0, committedReader.getCurrentIndex());
-      assertTrue(committedReader.hasNext());
-      assertEquals(entriesPerSegment * 5 + 1, committedReader.getNextIndex());
-      assertEquals(entriesPerSegment * 5 + 1, committedReader.next().index());
+        assertEquals(entriesPerSegment + 1, reader.getNextIndex());
+        assertEquals(reader.getFirstIndex(), reader.getNextIndex());
+        assertEquals(entriesPerSegment + 1, reader.next().index());
     }
-  }
-
-  @Before
-  @After
-  public void cleanupStorage() throws IOException {
-    if (Files.exists(PATH)) {
-      Files.walkFileTree(PATH, new SimpleFileVisitor<Path>() {
-        @Override
-        public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
-          Files.delete(file);
-          return FileVisitResult.CONTINUE;
-        }
 
-        @Override
-        public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException {
-          Files.delete(dir);
-          return FileVisitResult.CONTINUE;
+    @Before
+    @After
+    public void cleanupStorage() throws IOException {
+        if (Files.exists(PATH)) {
+            Files.walkFileTree(PATH, new SimpleFileVisitor<Path>() {
+                @Override
+                public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
+                    Files.delete(file);
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException {
+                    Files.delete(dir);
+                    return FileVisitResult.CONTINUE;
+                }
+            });
         }
-      });
     }
-  }
 }

diff --git a/atomix-storage/src/test/java/io/atomix/storage/journal/DiskJournalTest.java b/atomix-storage/src/test/java/io/atomix/storage/journal/DiskJournalTest.java
index 2b3216e87c2301b0e9d4d4d9ba484e7a2ffd8a3e..cb56ef03f408b6d3fb5030fcf75eb16b100c81db 100644 (file)
--- a/atomix-storage/src/test/java/io/atomix/storage/journal/DiskJournalTest.java
+++ b/atomix-storage/src/test/java/io/atomix/storage/journal/DiskJournalTest.java
@@ -18,13 +18,8 @@ package io.atomix.storage.journal;
 /**
  * Disk journal test.
  */
-public class DiskJournalTest extends PersistentJournalTest {
-  public DiskJournalTest(int maxSegmentSize) {
-    super(maxSegmentSize);
-  }
-
-  @Override
-  protected StorageLevel storageLevel() {
-    return StorageLevel.DISK;
-  }
+public class DiskJournalTest extends AbstractJournalTest {
+    public DiskJournalTest(final int maxSegmentSize) {
+        super(StorageLevel.DISK, maxSegmentSize);
+    }
 }

diff --git a/atomix-storage/src/test/java/io/atomix/storage/journal/MappedJournalTest.java b/atomix-storage/src/test/java/io/atomix/storage/journal/MappedJournalTest.java
index 7ccfe3d8f4d223656c61df69a3eb1621ed44d9ec..82e91a5c27452f55192b62567109be7916332978 100644 (file)
--- a/atomix-storage/src/test/java/io/atomix/storage/journal/MappedJournalTest.java
+++ b/atomix-storage/src/test/java/io/atomix/storage/journal/MappedJournalTest.java
@@ -18,13 +18,8 @@ package io.atomix.storage.journal;
 /**
  * Memory mapped journal test.
  */
-public class MappedJournalTest extends PersistentJournalTest {
-  public MappedJournalTest(int maxSegmentSize) {
-    super(maxSegmentSize);
-  }
-
-  @Override
-  protected StorageLevel storageLevel() {
-    return StorageLevel.MAPPED;
-  }
+public class MappedJournalTest extends AbstractJournalTest {
+    public MappedJournalTest(final int maxSegmentSize) {
+        super(StorageLevel.MAPPED, maxSegmentSize);
+    }
 }

diff --git a/atomix-storage/src/test/java/io/atomix/storage/journal/MemoryJournalTest.java b/atomix-storage/src/test/java/io/atomix/storage/journal/MemoryJournalTest.java
deleted file mode 100644 (file)
index 7689718..0000000
--- a/atomix-storage/src/test/java/io/atomix/storage/journal/MemoryJournalTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.atomix.storage.journal;
-
-/**
- * Memory journal test.
- */
-@Deprecated
-public class MemoryJournalTest extends AbstractJournalTest {
-  public MemoryJournalTest(int maxSegmentSize) {
-    super(maxSegmentSize);
-  }
-
-  @Override
-  protected StorageLevel storageLevel() {
-    return StorageLevel.MEMORY;
-  }
-}

diff --git a/atomix-storage/src/test/java/io/atomix/storage/journal/PersistentJournalTest.java b/atomix-storage/src/test/java/io/atomix/storage/journal/PersistentJournalTest.java
deleted file mode 100644 (file)
index c257340..0000000
--- a/atomix-storage/src/test/java/io/atomix/storage/journal/PersistentJournalTest.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright 2017-present Open Networking Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.atomix.storage.journal;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Persistent journal test base.
- */
-public abstract class PersistentJournalTest extends AbstractJournalTest {
-  protected PersistentJournalTest(int maxSegmentSize) {
-    super(maxSegmentSize);
-  }
-
-  /**
-   * Tests reading from a compacted journal.
-   */
-  @Test
-  public void testCompactAndRecover() throws Exception {
-    SegmentedJournal<TestEntry> journal = createJournal();
-
-    // Write three segments to the journal.
-    JournalWriter<TestEntry> writer = journal.writer();
-    for (int i = 0; i < entriesPerSegment * 3; i++) {
-      writer.append(ENTRY);
-    }
-
-    // Commit the entries and compact the first segment.
-    writer.commit(entriesPerSegment * 3);
-    journal.compact(entriesPerSegment + 1);
-
-    // Close the journal.
-    journal.close();
-
-    // Reopen the journal and create a reader.
-    journal = createJournal();
-    writer = journal.writer();
-    JournalReader<TestEntry> reader = journal.openReader(1, JournalReader.Mode.COMMITS);
-    writer.append(ENTRY);
-    writer.append(ENTRY);
-    writer.commit(entriesPerSegment * 3);
-
-    // Ensure the reader starts at the first physical index in the journal.
-    assertEquals(entriesPerSegment + 1, reader.getNextIndex());
-    assertEquals(reader.getFirstIndex(), reader.getNextIndex());
-    assertTrue(reader.hasNext());
-    assertEquals(entriesPerSegment + 1, reader.getNextIndex());
-    assertEquals(reader.getFirstIndex(), reader.getNextIndex());
-    assertEquals(entriesPerSegment + 1, reader.next().index());
-  }
-}