private static long findCycleLinearSearch(@NotNull NavigableSet<Long> cycles, Wire key, @NotNull Comparator<Wire> c, @NotNull ExcerptTailer tailer, @NotNull final ChronicleQueue queue) { final Iterator<Long> iterator = cycles.iterator(); if (!iterator.hasNext()) return -1; final RollCycle rollCycle = queue.rollCycle(); long prevIndex = iterator.next(); while (iterator.hasNext()) { final Long current = iterator.next(); final boolean b = tailer.moveToIndex(rollCycle.toIndex((int) (long) current, 0)); if (!b) return prevIndex; try (final DocumentContext dc = tailer.readingDocument()) { final int compare = c.compare(dc.wire(), key); if (compare == 0) return current; else if (compare > 0) return prevIndex; prevIndex = current; } } return prevIndex; }
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(); } }
writer.append("# firstIndex: ").append(Long.toHexString(firstIndex)).append("\n"); ExcerptTailer tailer = createTailer(); if (!tailer.moveToIndex(fromIndex)) { if (firstIndex > fromIndex) { tailer.toStart();
final boolean b = tailer.moveToIndex(midIndex); assert b; try (DocumentContext dc = tailer.readingDocument()) {
@Override public Long call() throws Exception { ExcerptTailer tailer = queue.createTailer(); tailer.moveToIndex(startIndex); Long fromWriter = sync.take(); long index = doReadBad(tailer, messages + 50, false); if (index != fromWriter) { System.out.println("Reader:1 Not the same:" + index + " vs. " + fromWriter); } sync.put(index); fromWriter = sync.take(); index = doReadBad(tailer, 50, false); if (index != fromWriter) { System.out.println("Reader:2 Not the same:" + index + " vs. " + fromWriter); } return index; } }
tailer.moveToIndex(highestReachedIndex);
tailer.moveToIndex(lastIndex);
@Test public void testRandomMove() throws Exception { final Map<Long, String> messageByIndex = new HashMap<>(); try (ChronicleQueue queue = SingleChronicleQueueBuilder. binary(tmpFolder.newFolder()).build()) { // create a queue and add some excerpts final ExcerptAppender appender = queue.acquireAppender(); for (int i = 0; i < 10; i++) { final String message = "msg" + i; appender.writeDocument(w -> w.write("message").object(message)); final long appendIndex = appender.lastIndexAppended(); messageByIndex.put(appendIndex, message); } final Random random = new Random(1510298038000L); final List<Long> indices = new ArrayList<>(messageByIndex.keySet()); final ExcerptTailer tailer = queue.createTailer(); final AtomicReference<String> capturedMessage = new AtomicReference<>(); for (int i = 0; i < 100; i++) { final long randomIndex = indices.get(random.nextInt(messageByIndex.keySet().size())); tailer.moveToIndex(randomIndex); tailer.readDocument(w -> capturedMessage.set((String) w.read("message").object())); assertEquals(messageByIndex.get(randomIndex), capturedMessage.get()); tailer.readDocument(w -> w.read("message").object()); } } }
assertTrue(tailer.moveToIndex(indexes[i])); String text = tailer.readText(); assertEquals(i, Integer.parseInt(text));
@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"); } }
@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) + "%"); } } } }
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 testHeaderIndexReadAtIndex() { try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType) .build()) { final ExcerptAppender appender = queue.acquireAppender(); final int cycle = appender.cycle(); // create 100 documents for (int i = 0; i < 100; i++) { final int j = i; appender.writeDocument(wire -> wire.write(() -> "key").text("value=" + j)); } final ExcerptTailer tailer = queue.createTailer(); assertTrue(tailer.moveToIndex(queue.rollCycle().toIndex(cycle, 0))); StringBuilder sb = new StringBuilder(); tailer.readDocument(wire -> wire.read(() -> "key").text(sb)); Assert.assertEquals("value=0", sb.toString()); } }
@Test public void testIndex() { try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType) .rollCycle(RollCycles.HOURLY) .build()) { final ExcerptAppender appender = queue.acquireAppender(); int cycle = appender.cycle(); // create 100 documents for (int i = 0; i < 5; i++) { final int j = i; appender.writeDocument(wire -> wire.write(() -> "key").text("value=" + j)); if (i == 2) { final long cycle1 = queue.rollCycle().toCycle(appender.lastIndexAppended()); Assert.assertEquals(cycle1, cycle); } } final ExcerptTailer tailer = queue.createTailer(); assertTrue(tailer.moveToIndex(queue.rollCycle().toIndex(cycle, 2))); StringBuilder sb = new StringBuilder(); tailer.readDocument(wire -> wire.read(() -> "key").text(sb)); Assert.assertEquals("value=2", sb.toString()); tailer.readDocument(wire -> wire.read(() -> "key").text(sb)); Assert.assertEquals("value=3", sb.toString()); tailer.readDocument(wire -> wire.read(() -> "key").text(sb)); Assert.assertEquals("value=4", sb.toString()); } }
final long index = queue.rollCycle().toIndex(cycle, i); assertTrue("i: " + i, tailer.moveToIndex( index)); final DocumentContext context = tailer.readingDocument();
assertTrue(tailer.moveToIndex(queue.rollCycle().toIndex(cycle, 2)));
assertTrue(tailer.moveToIndex(queue.rollCycle().toIndex(cycle, 2)));
@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); } } }
@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())); } } }
Assert.assertTrue(tailer.moveToIndex(startIndex));