@Override public long toSequenceNumber(long index) { return delegate.toSequenceNumber(index); }
void writeIndexForPosition(long index, long position) throws UnrecoverableTimeoutException, StreamCorruptedException { long sequenceNumber = queue.rollCycle().toSequenceNumber(index); store.setPositionForSequenceNumber(this, sequenceNumber, position); }
boolean checkIndex(long index, long position) { try { final long seq1 = queue.rollCycle().toSequenceNumber(index + 1) - 1; final long seq2 = store.sequenceForPosition(this, position, true); if (seq1 != seq2) { final long seq3 = ((SingleChronicleQueueStore) store).indexing .linearScanByPosition(wireForIndex(), position, 0, 0, true); System.out.println("Thread=" + Thread.currentThread().getName() + " pos: " + position + " seq1: " + Long.toHexString(seq1) + " seq2: " + Long.toHexString(seq2) + " seq3: " + Long.toHexString(seq3)); System.out.println(store.dump()); assert seq1 == seq3 : "seq1=" + seq1 + ", seq3=" + seq3; assert seq1 == seq2 : "seq1=" + seq1 + ", seq2=" + seq2; } } catch (@NotNull EOFException | UnrecoverableTimeoutException | StreamCorruptedException e) { throw new AssertionError(e); } return true; }
@NotNull @Override public String toString() { long index = index(); return "StoreTailer{" + "index sequence=" + queue.rollCycle().toSequenceNumber(index) + ", index cycle=" + queue.rollCycle().toCycle(index) + ", store=" + store + ", queue=" + queue + '}'; }
private boolean inACycleCheckRep() { long lastSequenceAck = queue.lastAcknowledgedIndexReplicated(); long seq = queue.rollCycle().toSequenceNumber(index()); return seq > lastSequenceAck; }
private long toSeq(final ChronicleQueue q, final long index) { return q.rollCycle().toSequenceNumber(index); }
boolean checkWritePositionHeaderNumber() { if (wire == null || wire.headerNumber() == Long.MIN_VALUE) return true; try { long pos = position; long seq1 = queue.rollCycle().toSequenceNumber(wire.headerNumber() + 1) - 1; long seq2 = store.sequenceForPosition(this, pos, true); if (seq1 != seq2) { // System.out.println(queue.dump()); String message = "~~~~~~~~~~~~~~ " + "thread: " + Thread.currentThread().getName() + " pos: " + pos + " header: " + wire.headerNumber() + " seq1: " + seq1 + " seq2: " + seq2; //System.err.println(message); new AssertionError(message).printStackTrace(); throw new AssertionError(message); } } catch (Exception e) { Jvm.fatal().on(getClass(), e); throw Jvm.rethrow(e); } return true; }
@NotNull private String toTextIndex(ChronicleQueue q, long index) { return Long.toHexString(q.rollCycle().toCycle(index)) + "_" + Long.toHexString(q.rollCycle().toSequenceNumber(index)); }
@PackageLocal void incrementIndex() { RollCycle rollCycle = queue.rollCycle(); long index = this.index(); long seq = rollCycle.toSequenceNumber(index); int cycle = rollCycle.toCycle(index); seq += direction.add(); switch (direction) { case NONE: break; case FORWARD: // if it runs out of seq number it will flow over to tomorrows cycle file if (rollCycle.toSequenceNumber(seq) < seq) { cycle(cycle + 1); LOG.warn("we have run out of sequence numbers, so will start to write to " + "the next .cq4 file, the new cycle=" + cycle); seq = 0; } break; case BACKWARD: if (seq < 0) { windBackCycle(cycle); return; } break; } index0(rollCycle.toIndex(cycle, seq)); }
ScanResult moveToIndexResult(long index) { final int cycle = queue.rollCycle().toCycle(index); final long sequenceNumber = queue.rollCycle().toSequenceNumber(index); if (LOG.isTraceEnabled()) { Jvm.debug().on(getClass(), "moveToIndex: " + Long.toHexString(cycle) + " " + Long.toHexString(sequenceNumber)); } if (cycle != this.cycle || state != FOUND_CYCLE) { // moves to the expected cycle if (!cycle(cycle)) return ScanResult.NOT_REACHED; } index(index); ScanResult scanResult = this.store().moveToIndexForRead(this, sequenceNumber); Bytes<?> bytes = wire().bytes(); if (scanResult == FOUND) { state = FOUND_CYCLE; moveToState.onSuccessfulLookup(index, direction, bytes.readPosition()); return scanResult; } else if (scanResult == END_OF_FILE) { state = END_OF_CYCLE; return scanResult; } else if (scanResult == NOT_FOUND && this.cycle < this.queue.lastCycle) { state = END_OF_CYCLE; return END_OF_FILE; } return scanResult; }
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; }
@Test public void testAppend() { try (final ChronicleQueue queue = builder(getTmpDir(), wireType) .build()) { final ExcerptAppender appender = queue.acquireAppender(); 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())); } assertThat(countEntries(queue), is(10L)); } }
Assert.assertEquals(0, chronicle.rollCycle().toSequenceNumber(index)); dc.wire().write(() -> "FirstName").text("Quartilla"); Assert.assertEquals(1, chronicle.rollCycle().toSequenceNumber(dc.index())); dc.wire().write(() -> "FirstName").text("Rob"); Assert.assertEquals(2, chronicle.rollCycle().toSequenceNumber(dc.index())); dc.wire().write(() -> "FirstName").text("Rob"); Assert.assertEquals(0, chronicle.rollCycle().toSequenceNumber(index)); Assert.assertEquals(1, chronicle.rollCycle().toSequenceNumber(dc.index())); Assert.assertEquals(2, chronicle.rollCycle().toSequenceNumber(dc.index()));
@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())); } }
private boolean inACycleNotForward() { Jvm.optionalSafepoint(); if (!moveToIndexInternal(index())) { try { Jvm.optionalSafepoint(); // after toEnd() call, index is past the end of the queue // so try to go back one (to the last record in the queue) if ((int) queue.rollCycle().toSequenceNumber(index()) < 0) { long lastSeqNum = store.lastSequenceNumber(this); if (lastSeqNum == -1) { windBackCycle(cycle); return moveToIndexInternal(index()); } return moveToIndexInternal(queue.rollCycle().toIndex(cycle, lastSeqNum)); } if (!moveToIndexInternal(index() - 1)) { Jvm.optionalSafepoint(); return false; } } catch (Exception e) { // can happen if index goes negative Jvm.optionalSafepoint(); return false; } } Jvm.optionalSafepoint(); return true; }
@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); } } }
/** * if one appender if much further ahead than the other, then the new append should jump * straight to the end rather than attempting to write a positions that are already occupied */ @Test public void testAppendedSkipToEnd() { try (ChronicleQueue q = builder(getTmpDir(), this.wireType) .build()) { ExcerptAppender appender = q.acquireAppender(); ExcerptAppender appender2 = q.acquireAppender(); int indexCount = 100; for (int i = 0; i < indexCount; i++) { try (DocumentContext dc = appender.writingDocument()) { dc.wire().write("key").text("some more " + 1); Assert.assertEquals(i, q.rollCycle().toSequenceNumber(dc.index())); } } try (DocumentContext dc = appender2.writingDocument()) { dc.wire().write("key").text("some data " + indexCount); Assert.assertEquals(indexCount, q.rollCycle().toSequenceNumber(dc.index())); } } }
@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.assertEquals(queue.rollCycle().toSequenceNumber(indexs[6]), 0); Assert.assertEquals(5, queue.countExcerpts(indexs[0], indexs[6] - 1));
@Test public void testSomeMessages() { 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 (long i = 0; i < entries; i++) { long finalI = i; appender.writeDocument(w -> w.writeEventName("hello").int64(finalI)); long seq = chronicle.rollCycle().toSequenceNumber(appender.lastIndexAppended()); assertEquals(i, seq); // System.out.println(chronicle.dump()); tailer.readDocument(w -> w.read().int64(finalI, (a, b) -> Assert.assertEquals((long) a, b))); } } }