private String extraInfo(@NotNull ExcerptTailer tailer, @NotNull VanillaMessageHistory messageHistory) { return String.format( ". That sourceIndex was determined fom the last entry written to queue %s " + "(message index %s, message history %s). If source queue is replicated then " + "sourceIndex may not have been replicated yet", tailer.queue().fileAbsolutePath(), Long.toHexString(tailer.index()), WireType.TEXT.asString(messageHistory)); }
private long getCurrentTailIndex(ChronicleQueue queue) { return queue.createTailer().toEnd().index(); }
/** * 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()); }
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(); } }
private long action(@NotNull final ExcerptTailer tailer1, @NotNull final RollCycle rollCycle) { // tailer1.direction(direction); long readvalue = 0; long seqNumRead = 0; try (final DocumentContext dc = tailer1.readingDocument()) { readvalue = dc.wire().read("value").int64(); seqNumRead = dc.index(); } final long nextSeq = rollCycle.toSequenceNumber(tailer1.index()); /*System.out.println("Return-value=" + readvalue + ", seq=" + rollCycle.toSequenceNumber(seqNumRead) + ", next-seq=" + nextSeq + "(" + Long.toHexString(nextSeq) + "x0)" + ",direction=" + tailer1.direction());*/ return readvalue; }
private static long[] writeMessagesStoreIndices(final ExcerptAppender appender, final ExcerptTailer tailer) { final long[] indices = new long[RECORD_COUNT]; for (int i = 0; i < RECORD_COUNT; i++) { try (final DocumentContext ctx = appender.writingDocument()) { ctx.wire().getValueOut().int32(i); } } for (int i = 0; i < RECORD_COUNT; i++) { try (final DocumentContext ctx = tailer.readingDocument()) { assertThat("Expected record at index " + i, ctx.isPresent(), is(true)); indices[i] = tailer.index(); } } return indices; }
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); }
if (text == null) break; indexes[count] = tailer.index() - 1; assertEquals(count++, Integer.parseInt(text));
private long doRead(@NotNull ExcerptTailer tailer, int expected) { int[] i = {0}; long t_index = 0; while (true) { try (DocumentContext dc = tailer.readingDocument()) { if (!dc.isPresent()) break; t_index = tailer.index(); dc.wire().read("log").marshallable(m -> { String msg = m.read("msg").text(); assertNotNull(msg); System.out.println("msg:" + msg); i[0]++; }); } } assertEquals(expected, i[0]); return t_index; }
String msg = messages.get(i); assertEquals("[Backward] Wrong index " + i, index, tailer.index()); assertEquals("[Backward] Wrong message " + i, msg, readNextEntry(tailer));
assertEquals("[Forward 1] Wrong Tailer index after reading msg 0", msgIndexes.get(testMessage(1)).longValue(), tailer.index()); assertEquals("[Forward 1] Wrong message 1", testMessage(1), readNextEntry(tailer)); assertEquals("[Forward 1] Wrong Tailer index after reading msg 1", msgIndexes.get(testMessage(2)).longValue(), tailer.index()); assertEquals("[Backward] Wrong Tailer index after reading msg 2", msgIndexes.get(testMessage(1)).longValue(), tailer.index()); assertEquals("[Backward] Wrong message 1", testMessage(1), readNextEntry(tailer)); assertEquals("[Backward] Wrong Tailer index after reading msg 1", msgIndexes.get(testMessage(0)).longValue(), tailer.index()); assertEquals("[Backward] Wrong message 0", testMessage(0), readNextEntry(tailer)); assertEquals("[Forward 2] Wrong Tailer index after reading msg 0", msgIndexes.get(testMessage(1)).longValue(), tailer.index()); assertEquals("[Forward 2] Wrong message 1", testMessage(1), readNextEntry(tailer)); assertEquals("[Forward 2] Wrong Tailer index after reading msg 1", msgIndexes.get(testMessage(2)).longValue(), tailer.index());
@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); } }
private static long doReadBad(@NotNull ExcerptTailer tailer, int expected, boolean additionalClose) { int[] i = {0}; long t_index = 0; while (true) { try (DocumentContext dc = tailer.readingDocument()) { if (!dc.isPresent()) break; t_index = tailer.index(); dc.wire().read("log").marshallable(m -> { String msg = m.read("msg").text(); assertNotNull(msg); i[0]++; }); if (additionalClose) { dc.close(); } } } assertEquals(expected, i[0]); return t_index; }
assertEquals(10, queue.rollCycle().toSequenceNumber(atEnd.index())); checkOneFile(baseDir); fillResults(atEnd, results);
@Test public void shouldMoveToPreviousIndexAfterDocumentIsConsumed() throws Exception { File queuePath = tmpFolder.newFolder("cq"); try (ChronicleQueue queue = ChronicleQueue.singleBuilder(queuePath).build()) { ExcerptAppender appender = queue.acquireAppender(); for (int i = 1; i < 10; ++i) { appender.writeText("id" + i); } ExcerptTailer tailer = queue.createTailer(); assertNext(tailer, "id1"); long index = tailer.index(); assertNext(tailer, "id2"); tailer.moveToIndex(index); assertNext(tailer, "id2"); tailer.moveToIndex(index); assertNext(tailer, "id2"); } }
@Test public void testAppendAndRead() { try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType) .build()) { final ExcerptAppender appender = queue.acquireAppender(); final int cycle = appender.cycle(); for (int i = 0; i < 10; i++) { final int n = i; appender.writeDocument(w -> w.write(TestKey.test).int32(n)); assertEquals(n, queue.rollCycle().toSequenceNumber(appender.lastIndexAppended())); } final ExcerptTailer tailer = queue.createTailer(); // Sequential read for (int i = 0; i < 10; i++) { final int n = i; assertTrue(tailer.readDocument(r -> assertEquals(n, r.read(TestKey.test).int32()))); assertEquals(n + 1, queue.rollCycle().toSequenceNumber(tailer.index())); } // Random read for (int i = 0; i < 10; i++) { final int n = i; assertTrue("n: " + n, tailer.moveToIndex(queue.rollCycle().toIndex(cycle, n))); assertTrue("n: " + n, tailer.readDocument(r -> assertEquals(n, r.read(TestKey.test).int32()))); assertEquals(n + 1, queue.rollCycle().toSequenceNumber(tailer.index())); } } }
@Test public void testWrittenAndReadIndexesAreTheSameOfTheFirstExcerpt() { File tmp = getTmpDir(); long expected; try (ChronicleQueue queue = single(tmp) .testBlockSize() .build()) { ExcerptAppender appender = queue.acquireAppender(); try (DocumentContext dc = appender.writingDocument()) { dc.wire().write().text("some-data"); expected = dc.index(); Assert.assertTrue(expected > 0); } appender.lastIndexAppended(); ExcerptTailer tailer = queue.createTailer(); try (DocumentContext dc = tailer.readingDocument()) { String text = dc.wire().read().text(); { long actualIndex = dc.index(); Assert.assertTrue(actualIndex > 0); Assert.assertEquals(expected, actualIndex); } { long actualIndex = tailer.index(); Assert.assertTrue(actualIndex > 0); Assert.assertEquals(expected, actualIndex); } } } }
@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()); } } }
@Test public void testAppendAndReadAtIndex() { try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType) .rollCycle(TEST2_DAILY) .build()) { final ExcerptAppender appender = queue.acquireAppender(); appender.cycle(); for (int i = 0; i < 5; i++) { final int n = i; appender.writeDocument(w -> w.write(TestKey.test).int32(n)); assertEquals(i, queue.rollCycle().toSequenceNumber(appender.lastIndexAppended())); } final ExcerptTailer tailer = queue.createTailer(); for (int i = 0; i < 5; i++) { final long index = queue.rollCycle().toIndex(appender.cycle(), i); assertTrue(tailer.moveToIndex(index)); final int n = i; assertTrue(tailer.readDocument(r -> assertEquals(n, queue.rollCycle().toSequenceNumber(r.read(TestKey.test) .int32())))); long index2 = tailer.index(); long sequenceNumber = queue.rollCycle().toSequenceNumber(index2); assertEquals(n + 1, sequenceNumber); } } }