How to use

ChronicleQueue

in

net.openhft.chronicle.queue

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

/**
 * @deprecated to be remove in version 4.6 or later use {@link ChronicleQueue#acquireAppender()}
 */
@NotNull
@Deprecated
default ExcerptAppender createAppender() {
  return acquireAppender();
}

private static void closeQueues(final ChronicleQueue... queues) {
  for (ChronicleQueue queue : queues) {
    if (queue != null) {
      queue.close();
    }
  }
}

private void appendToQueue(final ChronicleQueue queue) {
  for (int i = 0; i < 31; i++) {
    final ExcerptAppender appender = queue.acquireAppender();
    if (queue.isClosed())
      return;
    try (final DocumentContext dc = appender.writingDocument()) {
      dc.wire().write("foo");
    }
  }
}

@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);
  }
}

@Ignore("long running test")
@Test
public void testReadAtIndex4MB() {
  try (final ChronicleQueue queue = SingleChronicleQueueBuilder.builder(getTmpDir(), this.wireType).rollCycle(SMALL_DAILY)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    System.out.print("Percent written=");
    for (long i = 0; i < TIMES; i++) {
      final long j = i;
      appender.writeDocument(wire -> wire.write(() -> "key").text("value=" + j));
      if (i % (TIMES / 20) == 0) {
        System.out.println("" + (i * 100 / TIMES) + "%, ");
      }
    }
    long lastIndex = appender.lastIndexAppended();
    final int cycle = queue.rollCycle().toCycle(lastIndex);
    final ExcerptTailer tailer = queue.createTailer();
    //   QueueDumpMain.dump(file, new PrintWriter(System.out));
    StringBuilder sb = new StringBuilder();
    for (long i = 0; i < (4L << 20L); i++) {
      assertTrue(tailer.moveToIndex(queue.rollCycle().toIndex(cycle, i)));
      tailer.readDocument(wire -> wire.read(() -> "key").text(sb));
      Assert.assertEquals("value=" + i, sb.toString());
      if (i % (TIMES / 20) == 0) {
        System.out.println("Percent read= " + (i * 100 / TIMES) + "%");
      }
    }
  }
}

  .rollCycle(RollCycles.TEST_DAILY)
  .build()) {
ExcerptAppender appender = queue.acquireAppender();
appender.writeMap(map);
    "...\n" +
    "# 130556 bytes remaining\n";
assertEquals(expectedEager, queue.dump());
@NotNull ExcerptTailer tailer = queue.createTailer();
Map<String, Object> map2 = tailer.readMap();
Map<String, Object> map3 = tailer.readMap();

@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());
  }
}

File basePath = DirectoryUtils.tempDir("tailerForwardBackwardBeyondCycle");
SetTimeProvider timeProvider = new SetTimeProvider();
ChronicleQueue queue = ChronicleQueue.singleBuilder(basePath)
    .testBlockSize()
    .timeProvider(timeProvider)
    .build();
ExcerptAppender appender = queue.acquireAppender();
ExcerptTailer tailer = queue.createTailer()
    .direction(TailerDirection.BACKWARD)
    .toEnd();
  assertEquals("[Backward] Wrong message " + i, msg, readNextEntry(tailer));
queue.close();

@Test
public void testMyData() {
  @NotNull File dir = getTmpDir();
  ClassAliasPool.CLASS_ALIASES.addAlias(MyData.class);
  try (@NotNull ChronicleQueue queue = binary(dir)
      .rollCycle(RollCycles.TEST_DAILY)
      .blockSize(ChronicleQueue.TEST_BLOCK_SIZE).build()) {
    @NotNull ExcerptAppender appender = queue.acquireAppender();
    try (DocumentContext dc = appender.writingDocument()) {
      @NotNull MyData name = new MyData("name", 12345, 1.2, 111);
      System.out.println(name);
      name.writeMarshallable(dc.wire());
      @NotNull MyData name2 = new MyData("name2", 12346, 1.3, 112);
      System.out.println(name2);
      name2.writeMarshallable(dc.wire());
    }
    String dump = queue.dump();
    assertTrue(dump, dump.contains("--- !!meta-data #binary\n" +
        "index: [\n" +
        "  # length: 8, used: 1\n" +
        "  384,\n" +
        "  0, 0, 0, 0, 0, 0, 0\n" +
        "]"));
  }
}

@Test
public void test() {
  File file = getTmpDir();
  try (ChronicleQueue queue = ChronicleQueue.singleBuilder(file)
      .testBlockSize()
      .rollCycle(TEST_DAILY).build()) {
    SomeListener someListener = queue.acquireAppender().methodWriter(SomeListener.class);
    SomeManager someManager = new SomeManager();
    MethodReader reader = queue.createTailer().methodReader(someManager);
    LOG.debug("Writing to queue");
    someListener.methodWithOneParam(1);
    someListener.methodWithoutParams();
    LOG.debug("Reading from queue");
    assertTrue(reader.readOne());
    assertTrue(reader.readOne());
    assertFalse(reader.readOne());
    assertTrue(someManager.methodWithOneParamInvoked);       // one param method was invoked
    assertTrue(someManager.methodWithoutParamsInvoked);      // no params method was NOT invoked
    LOG.warn(queue.dump());
  }
}

File tmpDir = getTmpDir();
File[] files;
try (ChronicleQueue writeQ = ChronicleQueue.singleBuilder(tmpDir).build()) {
  ExcerptAppender appender = writeQ.acquireAppender();
  long wp;
  Wire wire;
  File dir = new File(appender.queue().fileAbsolutePath());
  files = dir.listFiles(pathname -> pathname.getAbsolutePath().endsWith(".cq4"));
file.delete();
try (ChronicleQueue q = ChronicleQueue.singleBuilder(tmpDir).build()) {
  ExcerptTailer excerptTailer = q.createTailer().toEnd();
  q.acquireAppender()
      .writeText(EXPECTED);
  Assert.assertEquals(EXPECTED, excerptTailer.readText());

      .build()) {
    final ExcerptTailer tailer = rqueue.createTailer();
    long last = -1;
      .build();
  final ExcerptAppender appender = wqueue.acquireAppender();
      return;
  wqueue.close();
});
submit.get();

  .build()) {
ExcerptAppender appender = queue.acquireAppender();
System.out.println("first index : " + queue.firstIndex());
Assert.assertEquals(Long.MAX_VALUE, queue.firstIndex());
long firstIndex = queue.firstIndex();
ExcerptTailer excerptTailer = queue.createTailer();
for (int i = 0; i < 10; i++) {
  Assert.assertEquals("test", excerptTailer.readText());
queue.refreshDirectlyListing();
Assert.assertEquals(queue.firstIndex(), firstIndexOfSecondCycle);
ExcerptTailer excerptTailer2 = queue.createTailer();
System.out.println("index before reading 5: " + excerptTailer2.index());

public static void main(String[] args) {
  long start = System.currentTimeMillis();
  final TLogEntry entry = new TLogEntry();
  entry.setSessionId(321234L);
  entry.setLogLevel(77);
  entry.setSecurityLevel(1234);
  entry.setPosixTimestamp(6141234321L);
  entry.setMessage("This is a test message for the system................................ A");
  final LogEntryOutput output = new LogEntryOutput(1024);
  output.setMarshallable(entry);
  final ChronicleQueue queue = ChronicleQueue.singleBuilder(
      OS.TARGET + "/test-" + System.nanoTime())
      .rollCycle(RollCycles.HOURLY)
      .build();
  final ExcerptAppender appender = queue.acquireAppender();
  Jvm.setExceptionHandlers(Slf4jExceptionHandler.FATAL, Slf4jExceptionHandler.WARN, Slf4jExceptionHandler.WARN);
  for (int j = 0; j < 100; ++j) {
    for (int i = 0; i < 100000; ++i) {
      appender.writeBytes(output);
    }
    System.out.println((j + 1) * 100000);
    // Jvm.pause(100L);
  }
  queue.close();
  System.out.println("took " + (System.currentTimeMillis() - start) / 1e3);
}

  .build()) {
final ExcerptAppender appender2 = q2.acquireAppender();
final ExcerptTailer tailer1 = q1.createTailer();
final ExcerptTailer tailer2 = q2.createTailer();
Assert.assertTrue(q1.file().equals(q2.file()));

@Test
public void testLastWrittenIndexPerAppender() {
  try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    appender.writeDocument(wire -> wire.write(() -> "key").text("test"));
    Assert.assertEquals(0, queue.rollCycle().toSequenceNumber(appender.lastIndexAppended()));
  }
}

String file = OS.TARGET + "/deleteme-" + System.nanoTime();
try (ChronicleQueue chronicle = single(file).blockSize(64 << 20).build()) {
  ExcerptAppender appender = chronicle.createAppender();
  UncheckedBytes bytes = new UncheckedBytes(NoBytesStore.NO_BYTES);
  for (int i = 0; i < count; i++) {
  ExcerptTailer tailer = chronicle.createTailer();
  for (int i = 0; i < count; i++) {
    long start2 = System.nanoTime();

@Test
public void testReadFromReadOnlyChronicle() {
  try (ChronicleQueue out = SingleChronicleQueueBuilder
      .binary(chroniclePath)
      .testBlockSize()
      .readOnly(!OS.isWindows())
      .build()) {
    // check dump
    assertTrue(out.dump().length() > 1);
    // and tailer
    ExcerptTailer tailer = out.createTailer();
    assertEquals(STR1, tailer.readText());
    try (DocumentContext dc = tailer.readingDocument()) {
      assertEquals(STR2, dc.wire().bytes().readUtf8());
      // even though this is read-only we can still call dc.wire().bytes().write... which causes java.lang.InternalError
      // Fixing this in a type-safe manner would require on Read/WriteDocumentContext to return WireIn/WireOut
    }
  }
}

  @Test
  public void testTailAfterClose() {
    final ChronicleQueue queue =
        SingleChronicleQueueBuilder.builder(getTmpDir(), WireType.BINARY).
            build();
    final ExcerptAppender appender = queue.acquireAppender();
    appender.writeDocument(w -> w.write(TestKey.test).int32(1));
    queue.close();
    try {
      appender.writeDocument(w -> w.write(TestKey.test).int32(2));
      Assert.fail();
    } catch (IllegalStateException e) {
      // ok
    }
  }
}