How to use

createTailer

method

in

net.openhft.chronicle.queue.ChronicleQueue

  @NotNull
  public MethodReader createReader(JDBCResult result) {
    return out.createTailer().methodReader(result);
  }
}

ParallelQueueObserver(@NotNull ChronicleQueue queue) {
  documentsRead = 0;
  tailer = queue.createTailer();
}

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

@NotNull
public MethodReader outputReader(Object... impls) {
  ChronicleQueue queue = outputQueue();
  MethodReader reader = queue.createTailer().methodReader(impls);
  reader.closeIn(true);
  return reader;
}

private void attemptToMoveToTail(final ChronicleQueue queue) {
  final SingleChronicleQueueExcerpts.StoreTailer tailer =
      (SingleChronicleQueueExcerpts.StoreTailer) queue.createTailer();
  try {
    tailer.toEnd();
  } catch (IllegalStateException e) {
    e.printStackTrace();
    failedToMoveToEnd.set(true);
  }
}

private void testQueue(@NotNull ChronicleQueue queue) {
  @NotNull ExcerptTailer tailer = queue.createTailer();
  try (DocumentContext dc = tailer.readingDocument()) {
    assertFalse(dc.isPresent());
  }
}

@Test
public void shouldDetermineQueueDirectoryFromQueueFile() {
  final Path path = Paths.get(OS.USER_DIR, TEST_QUEUE_FILE);
  try (final ChronicleQueue queue =
         ChronicleQueue.singleBuilder(path)
             .testBlockSize()
             .build()) {
    assertThat(queue.createTailer().readingDocument().isPresent(), is(false));
  } finally {
    IOTools.deleteDirWithFiles(path.toFile(), 20);
  }
}

private static long countEntries(final ChronicleQueue queue) {
  final ExcerptTailer tailer = queue.createTailer();
  tailer.toStart().direction(TailerDirection.FORWARD);
  long entryCount = 0L;
  while (true) {
    try (final DocumentContext ctx = tailer.readingDocument()) {
      if (!ctx.isPresent()) {
        break;
      }
      entryCount++;
    }
  }
  return entryCount;
}

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

@Test(expected = IllegalArgumentException.class)
public void dontPassQueueToReader() {
  try (ChronicleQueue queue = binary(getTmpDir()).build()) {
    queue.createTailer().afterLastWritten(queue).methodReader();
  }
}

@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 testTextReadWrite() {
  File tmpDir = getTmpDir();
  try (final ChronicleQueue queue =
         builder(tmpDir, wireType)
             .build()) {
    queue.acquireAppender().writeText("hello world");
    Assert.assertEquals("hello world", queue.createTailer().readText());
  }
}

@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 shouldHandleLargeEpoch() {
  try (final ChronicleQueue chronicle = builder(getTmpDir(), this.wireType)
      .epoch(System.currentTimeMillis())
      .epoch(1284739200000L)
      .rollCycle(DAILY)
      .build()) {
    final ExcerptAppender appender = chronicle.acquireAppender();
    appender.writeDocument(wire -> wire.write(() -> "key").text("value=v"));
    final ExcerptTailer excerptTailer = chronicle.createTailer().toStart();
    assertThat(excerptTailer.readingDocument().isPresent(), is(true));
  }
}

@Test
public void shouldBeAbleToReadFromQueueWithNonZeroEpoch() {
  try (final ChronicleQueue chronicle = builder(getTmpDir(), this.wireType)
      .epoch(System.currentTimeMillis())
      .rollCycle(RollCycles.DAILY)
      .build()) {
    final ExcerptAppender appender = chronicle.acquireAppender();
    appender.writeDocument(wire -> wire.write(() -> "key").text("value=v"));
    Assert.assertTrue(appender.cycle() == 0);
    final ExcerptTailer excerptTailer = chronicle.createTailer().toStart();
    assertThat(excerptTailer.readingDocument().isPresent(), is(true));
  }
}

@Test
public void testNegativeEPOC() {
  for (int h = -14; h <= 14; h++) {
    try (final ChronicleQueue chronicle = builder(getTmpDir(), wireType)
        .epoch(TimeUnit.HOURS.toMillis(h))
        .build()) {
      final ExcerptAppender appender = chronicle.acquireAppender();
      appender.writeDocument(wire -> wire.write(() -> "key").text("value=v"));
      chronicle.createTailer()
          .readDocument(wire -> {
            assertEquals("value=v", wire.read("key").text());
          });
    }
  }
}

@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 testSimpleWire() {
  try (final ChronicleQueue chronicle = builder(getTmpDir(), this.wireType)
      .build()) {
    final ExcerptAppender appender = chronicle.acquireAppender();
    appender.writeDocument(wire -> wire.write(() -> "FirstName").text("Steve"));
    appender.writeDocument(wire -> wire.write(() -> "Surname").text("Jobs"));
    StringBuilder first = new StringBuilder();
    StringBuilder surname = new StringBuilder();
    final ExcerptTailer tailer = chronicle.createTailer();
    tailer.readDocument(wire -> wire.read(() -> "FirstName").text(first));
    tailer.readDocument(wire -> wire.read(() -> "Surname").text(surname));
    Assert.assertEquals("Steve Jobs", first + " " + surname);
  }
}

  @Test(expected = TimeoutException.class)
  public void shouldHandleEmptyFile() {
    Assume.assumeFalse(OS.isWindows());
    try (final ChronicleQueue queue =
           ChronicleQueue.singleBuilder(tmpDir)
               .testBlockSize()
               .timeoutMS(100)
               .readOnly(true)
               .build()) {
      ExcerptTailer tailer = queue.createTailer();
      assertFalse(tailer.readingDocument().isPresent());
    }
  }
}

@Test
public void test() {
  File dir = getTmpDir();
  try (final ChronicleQueue queue = SingleChronicleQueueBuilder.builder(dir, wireType)
      .testBlockSize()
      .build()) {
    final ExcerptTailer tailer = queue.createTailer();
    assertFalse(tailer.readDocument(r -> r.read(TestKey.test).int32()));
    final ExcerptAppender appender = queue.acquireAppender();
    appender.writeDocument(w -> w.write(TestKey.test).int32(1));
    Jvm.pause(100);
    assertTrue(tailer.readDocument(r -> r.read(TestKey.test).int32()));
  }
}