How to use

toEnd

method

in

net.openhft.chronicle.queue.ExcerptTailer

private long getCurrentTailIndex(ChronicleQueue queue) {
  return queue.createTailer().toEnd().index();
}

private void moveToSpecifiedPosition(final ChronicleQueue ic, final ExcerptTailer tailer, final boolean isFirstIteration) {
  if (isSet(startIndex) && isFirstIteration) {
    if (startIndex < ic.firstIndex()) {
      throw new IllegalArgumentException(String.format("startIndex %d is less than first index %d",
          startIndex, ic.firstIndex()));
    }
    messageSink.accept("Waiting for startIndex " + startIndex);
    for (; ; ) {
      if (tailer.moveToIndex(startIndex))
        break;
      Jvm.pause(100);
    }
  }
  if (isSet(maxHistoryRecords) && isFirstIteration) {
    tailer.toEnd();
    tailer.moveToIndex(Math.max(ic.firstIndex(), tailer.index() - maxHistoryRecords));
  } else if (tailInputSource && isFirstIteration) {
    tailer.toEnd();
  }
}

/**
 * Counts the number of messages in this queue instance.
 *
 * @return the number of document excerpts
 */
public long entryCount() {
  final ExcerptTailer tailer = createTailer();
  tailer.toEnd();
  return countExcerpts(firstIndex(), tailer.index());
}

final ExcerptTailer tailer = q.createTailer();
final long start = tailer.toStart().index();
final long end = tailer.toEnd().index();

@Test
public void testInvalidFile() throws FileNotFoundException {
  @NotNull File dir = new File(OS.TARGET + "/deleteme-" + System.nanoTime());
  dir.mkdir();
  try (@NotNull MappedBytes bytes = MappedBytes.mappedBytes(new File(dir, "19700102" + SingleChronicleQueue.SUFFIX), 64 << 10)) {
    bytes.write8bit("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>");
    try (@NotNull RollingChronicleQueue queue = binary(dir)
        .rollCycle(RollCycles.TEST4_DAILY)
        .testBlockSize()
        .build()) {
      assertEquals(1, queue.firstCycle());
      assertEquals(1, queue.lastCycle());
      try {
        @NotNull ExcerptTailer tailer = queue.createTailer();
        tailer.toEnd();
        fail();
      } catch (Exception e) {
        assertEquals("java.io.StreamCorruptedException: Unexpected magic number 783f3c37",
            e.toString());
      }
    }
  }
  System.gc();
  try {
    IOTools.shallowDeleteDirWithFiles(dir.getAbsolutePath());
  } catch (Exception e) {
    e.printStackTrace();
  }
}

@Test
public void shouldNotReceiveDuplicateMessages() throws Exception {
  final File location = DirectoryUtils.tempDir(DuplicateMessageReadTest.class.getSimpleName());
  final ChronicleQueue chronicleQueue = SingleChronicleQueueBuilder
      .binary(location)
      .rollCycle(QUEUE_CYCLE)
      .build();
  final ExcerptAppender appender = chronicleQueue.acquireAppender();
  appender.pretouch();
  final List<Data> expected = new ArrayList<>();
  for (int i = 50; i < 60; i++) {
    expected.add(new Data(i));
  }
  final ExcerptTailer tailer = chronicleQueue.createTailer();
  tailer.toEnd(); // move to end of chronicle before writing
  for (final Data data : expected) {
    write(appender, data);
  }
  final List<Data> actual = new ArrayList<>();
  Data data;
  while ((data = read(tailer)) != null) {
    actual.add(data);
  }
  assertThat(actual, is(expected));
}

@Test
public void shouldAccessMessageHistoryWhenTailerIsMovedToEnd() throws Exception {
  try (final ChronicleQueue inputQueue = createQueue(inputQueueDir, 1);
     final ChronicleQueue outputQueue = createQueue(outputQueueDir, 2)) {
    generateTestData(inputQueue, outputQueue);
    final ExcerptTailer tailer = outputQueue.createTailer();
    tailer.direction(TailerDirection.BACKWARD).toEnd();
    final ValidatingSecond validatingSecond = new ValidatingSecond();
    final MethodReader validator = tailer.methodReader(validatingSecond);
    assertThat(validator.readOne(), is(true));
    assertThat(validatingSecond.messageHistoryPresent(), is(true));
  }
}

@Test
public void toEndBeforeWriteTest() {
  File baseDir = DirectoryUtils.tempDir("toEndBeforeWriteTest");
  IOTools.shallowDeleteDirWithFiles(baseDir);
  try (ChronicleQueue queue = SingleChronicleQueueBuilder.binary(baseDir)
      .testBlockSize()
      .build()) {
    checkOneFile(baseDir);
    // if this appender isn't created, the tailer toEnd doesn't cause a roll.
    ExcerptAppender appender = queue.acquireAppender();
    checkOneFile(baseDir);
    ExcerptTailer tailer = queue.createTailer();
    checkOneFile(baseDir);
    ExcerptTailer tailer2 = queue.createTailer();
    checkOneFile(baseDir);
    tailer.toEnd();
    checkOneFile(baseDir);
    tailer2.toEnd();
    checkOneFile(baseDir);
  }
  System.gc();
  /*for (int i = 0; i < 10; i++) {
    final int j = i;
    appender.writeDocument(wire -> wire.write(() -> "msg").int32(j));
  }*/
  pathsToDelete.add(baseDir);
}

@Test
public void testToEndOnReadOnly() {
  try (ChronicleQueue out = SingleChronicleQueueBuilder
      .binary(chroniclePath)
      .testBlockSize()
      .readOnly(true)
      .build()) {
    ExcerptTailer tailer = out.createTailer();
    tailer.toEnd();
    long index = tailer.index();
    assertTrue(index != 0);
  }
}

@Test
public void testToEndOnDeletedQueueFiles() throws IOException {
  if (OS.isWindows()) {
    System.err.println("#460 Cannot test delete after close on windows");
    return;
  }
  File dir = getTmpDir();
  try (ChronicleQueue q = builder(dir, wireType).build()) {
    ExcerptAppender append = q.acquireAppender();
    append.writeDocument(w -> w.write(() -> "test").text("before text"));
    ExcerptTailer tailer = q.createTailer();
    // move to the end even though it doesn't exist yet.
    tailer.toEnd();
    append.writeDocument(w -> w.write(() -> "test").text("text"));
    assertTrue(tailer.readDocument(w -> w.read(() -> "test").text("text", Assert::assertEquals)));
    Files.find(dir.toPath(), 1, (p, basicFileAttributes) -> p.toString().endsWith("cq4"), FileVisitOption.FOLLOW_LINKS)
        .forEach(path -> assertTrue(path.toFile().delete()));
    ChronicleQueue q2 = builder(dir, wireType).build();
    tailer = q2.createTailer();
    tailer.toEnd();
    assertEquals(TailerState.UNINITIALISED, tailer.state());
    append = q2.acquireAppender();
    append.writeDocument(w -> w.write(() -> "test").text("before text"));
    assertTrue(tailer.readDocument(w -> w.read(() -> "test").text("before text", Assert::assertEquals)));
  }
}

  private void read(@NotNull ChronicleQueue aChronicle, int expected) {
    final ExcerptTailer myTailer = aChronicle.createTailer();
    final int myLast = HOURLY.toCycle(myTailer.toEnd().index());
    final int myFirst = HOURLY.toCycle(myTailer.toStart().index());
    int myCycle = myFirst - 1;
    long myIndex = HOURLY.toIndex(myCycle, 0);
    int count = 0;
    while (myCycle <= myLast) {
//            System.out.println(Long.toHexString(myIndex));
      if (myTailer.moveToIndex(myIndex)) {
        while (myTailer.readDocument(read())) {
          count++;
        }
      }
      myIndex = HOURLY.toIndex(++myCycle, 0);
    }
    Assert.assertEquals(expected, count);
  }

@Test
public void shouldReadBackwardFromEndOfQueueWhenDirectionIsSetAfterMoveToEnd() {
  try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType)
      .rollCycle(TEST2_DAILY)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    appender.writeDocument(w -> w.writeEventName("hello").text("world"));
    final ExcerptTailer tailer = queue.createTailer();
    tailer.toEnd();
    tailer.direction(TailerDirection.BACKWARD);
    assertThat(tailer.readingDocument().isPresent(), is(true));
  }
}

@Test
public void shouldHandleCycleRollWhenInReadOnlyMode() {
  final MutableTimeProvider timeProvider = new MutableTimeProvider();
  final ChronicleQueue queue = build(createQueue(dataDirectory, RollCycles.MINUTELY, 0, "cycleRoll", false).
      timeProvider(timeProvider));
  final StringEvents events = queue.acquireAppender().methodWriterBuilder(StringEvents.class).build();
  timeProvider.setTime(System.currentTimeMillis());
  events.onEvent("firstEvent");
  timeProvider.addTime(2, TimeUnit.MINUTES);
  events.onEvent("secondEvent");
  final ChronicleQueue readerQueue = build(createQueue(dataDirectory, RollCycles.MINUTELY, 0, "cycleRoll", true).
      timeProvider(timeProvider));
  final ExcerptTailer tailer = readerQueue.createTailer();
  tailer.toStart();
  try (final DocumentContext context = tailer.readingDocument()) {
    assertThat(context.isPresent(), is(true));
  }
  tailer.toEnd();
  try (final DocumentContext context = tailer.readingDocument()) {
    assertThat(context.isPresent(), is(false));
  }
}

void readBackward(@NotNull ChronicleQueue chronicle, int entries) {
  ExcerptTailer backwardTailer = chronicle.createTailer()
      .direction(TailerDirection.BACKWARD)
      .toEnd();
  for (int i = entries - 1; i >= 0; i--) {
    try (DocumentContext documentContext = backwardTailer.readingDocument()) {
      assertTrue(documentContext.isPresent());
      final long index = documentContext.index();
      assertEquals("index: " + index, i, (int) index);
      Assert.assertEquals(i, RollCycles.DAILY.toSequenceNumber(index));
      Assert.assertTrue(documentContext.isPresent());
      StringBuilder sb = Wires.acquireStringBuilder();
      ValueIn valueIn = documentContext.wire().readEventName(sb);
      Assert.assertTrue("hello".contentEquals(sb));
      String actual = valueIn.text();
      Assert.assertEquals("world" + i, actual);
    }
  }
  try (DocumentContext documentContext = backwardTailer.readingDocument()) {
    assertFalse(documentContext.isPresent());
  }
}

@Test
public void testToEndBeforeWrite() {
  try (ChronicleQueue chronicle = builder(getTmpDir(), wireType)
      .rollCycle(TEST2_DAILY)
      .build()) {
    ExcerptAppender appender = chronicle.acquireAppender();
    ExcerptTailer tailer = chronicle.createTailer();
    int entries = chronicle.rollCycle().defaultIndexSpacing() * 2 + 2;
    for (int i = 0; i < entries; i++) {
      tailer.toEnd();
      int finalI = i;
      appender.writeDocument(w -> w.writeEventName("hello").text("world" + finalI));
      tailer.readDocument(w -> w.read().text("world" + finalI, Assert::assertEquals));
    }
  }
}

private void test(final int pause) {
  SetTimeProvider timeProvider = new SetTimeProvider();
  timeProvider.currentTimeMillis(System.currentTimeMillis());
  File tmpDir = getTmpDir();
  SingleChronicleQueue queue = SingleChronicleQueueBuilder.binary(tmpDir).timeProvider(timeProvider).rollCycle(RollCycles.TEST_SECONDLY).build();
  ExcerptAppender excerptAppender = queue.acquireAppender();
  try (DocumentContext dc = excerptAppender.writingDocument()) {
    dc.wire().write("hello").text("world");
  }
  timeProvider.advanceMillis(pause);
  {
    ExcerptTailer tailer = queue.createTailer().direction(TailerDirection.BACKWARD);
    tailer.toEnd();
    try (DocumentContext dc = tailer.readingDocument()) {
      assertEquals("world", dc.wire().read("hello").text());
    }
  }
  // pretouch to create next cycle file  ----- IF YOU COMMENT THIS LINE THE TEST PASSES
  excerptAppender.pretouch();
  {
    ExcerptTailer tailer = queue.createTailer().direction(TailerDirection.BACKWARD);
    tailer.toEnd();
    try (DocumentContext dc = tailer.readingDocument()) {
      assertTrue(dc.isPresent());
      assertEquals("world", dc.wire().read("hello").text());
    }
  }
}

@Test
public void testToEnd2() {
  File dir = getTmpDir();
  try (ChronicleQueue chronicle = builder(dir, wireType)
      .build();
     ChronicleQueue chronicle2 = builder(dir, wireType)
         .build()) {
    ExcerptAppender append = chronicle2.acquireAppender();
    append.writeDocument(w -> w.write(() -> "test").text("before text"));
    ExcerptTailer tailer = chronicle.createTailer();
    // move to the end even though it doesn't exist yet.
    tailer.toEnd();
    append.writeDocument(w -> w.write(() -> "test").text("text"));
    assertTrue(tailer.readDocument(w -> w.read(() -> "test").text("text", Assert::assertEquals)));
  }
}

@Test
public void testReadingWritingWhenCycleIsSkippedBackwards() throws Exception {
  final File dir = DirectoryUtils.tempDir(testName.getMethodName());
  final RollCycles rollCycle = RollCycles.TEST_SECONDLY;
  // write first message
  try (ChronicleQueue queue =
         binary(dir)
             .rollCycle(rollCycle).build()) {
    queue.acquireAppender().writeText("first message");
  }
  //TODO: this test fails when converted to use a TimeProvider. Need to work out why
  Thread.sleep(2100);
  // write second message
  try (ChronicleQueue queue =
         binary(dir)
             .rollCycle(rollCycle).build()) {
    queue.acquireAppender().writeText("second message");
  }
  // read both messages
  try (ChronicleQueue queue =
         binary(dir)
             .rollCycle(rollCycle).build()) {
    ExcerptTailer tailer = queue.createTailer();
    ExcerptTailer excerptTailer = tailer.direction(TailerDirection.BACKWARD).toEnd();
    Assert.assertEquals("second message", excerptTailer.readText());
    Assert.assertEquals("first message", excerptTailer.readText());
  }
}

@Test
public void testToEnd() throws InterruptedException {
  File dir = getTmpDir();
  try (ChronicleQueue queue = builder(dir, wireType)
      .rollCycle(RollCycles.HOURLY)
      .build()) {
    ExcerptTailer tailer = queue.createTailer();
    // move to the end even though it doesn't exist yet.
    tailer.toEnd();
    try (ChronicleQueue chronicle2 = builder(dir, wireType)
        .rollCycle(RollCycles.HOURLY)
        .build()) {
      ExcerptAppender append = chronicle2.acquireAppender();
      append.writeDocument(w -> w.write(() -> "test").text("text"));
    }
    // this is needed to avoid caching of first and last cycle, see SingleChronicleQueue#setFirstAndLastCycle
    Thread.sleep(1);
    try (DocumentContext dc = tailer.readingDocument()) {
      String message = "dump: " + builder(dir, wireType).rollCycle(RollCycles.HOURLY).build().dump();
      assertTrue(message, dc.isPresent());
      assertEquals(message, "text", dc.wire().read("test").text());
    }
  }
}

@Test
public void testAppendedBeforeToEnd() {
  File dir = getTmpDir();
  try (ChronicleQueue chronicle = builder(dir, this.wireType)
      .rollCycle(RollCycles.TEST_SECONDLY)
      .build();
     ChronicleQueue chronicle2 = builder(dir, this.wireType)
         .rollCycle(RollCycles.TEST_SECONDLY)
         .build()) {
    ExcerptTailer tailer = chronicle.createTailer();
    ExcerptAppender append = chronicle2.acquireAppender();
    append.writeDocument(w -> w.write(() -> "test").text("text"));
    while (tailer.state() == TailerState.UNINITIALISED)
      tailer.toEnd();
    try (DocumentContext dc = tailer.readingDocument()) {
      assertFalse(tailer.index() + " " + tailer.state(), dc.isPresent());
    }
    append.writeDocument(w -> w.write(() -> "test").text("text2"));
    try (DocumentContext dc = tailer.readingDocument()) {
      assertTrue(dc.isPresent());
      assertEquals("text2", dc.wire().read("test").text());
    }
  }
}