@Override public void writeMarshallable(@NotNull WireOut wire) { wire.write("age").int32(age); // interrupt half way through writing if (INTERRUPT.equals(name)) { Thread.currentThread().interrupt(); } else if (THROW.equals(name)) { throw new NullPointerException(); } else { wire.write("name").text(name); } }
private Future<RecordInfo> attemptToWriteDocument(final ChronicleQueue queue) throws InterruptedException { final CountDownLatch startedLatch = new CountDownLatch(1); final Future<RecordInfo> future = executorService.submit(() -> { final int counterValue; startedLatch.countDown(); try (final DocumentContext documentContext = queue.acquireAppender().writingDocument()) { counterValue = counter.getAndIncrement(); documentContext.wire().getValueOut().int32(counterValue); } return new RecordInfo(counterValue); }); assertTrue("Task did not start", startedLatch.await(1, TimeUnit.MINUTES)); return future; }
@Override public void writeMarshallable(@NotNull WireOut wire) { wire.write(RollFields.length).int32(length) .write(RollFields.format).text(format) .write(RollFields.epoch).int64(epoch); if (rollTime != null) wire.write(RollFields.rollTime).time(rollTime); if (rollTimeZone != null) wire.write(RollFields.rollTimeZone).text(rollTimeZone.getId()); }
private int write(ExcerptAppender appender) { int value; try (DocumentContext writingDocument = appender.writingDocument()) { final long documentAcquireTimestamp = System.nanoTime(); value = wrote.getAndIncrement(); ValueOut valueOut = writingDocument.wire().getValueOut(); // make the message longer valueOut.int64(documentAcquireTimestamp); for (int i = 0; i < NUMBER_OF_INTS; i++) { valueOut.int32(value); } writingDocument.wire().padToCacheAlign(); } return value; } }
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; }
@Test public void uninitialisedTailerCreatedBeforeFirstAppendWithDirectionNoneShouldNotFindDocument() { final AtomicLong clock = new AtomicLong(System.currentTimeMillis()); String path = OS.TARGET + "/" + getClass().getSimpleName() + "-" + System.nanoTime(); final ChronicleQueue queue = SingleChronicleQueueBuilder.single(path).timeProvider(clock::get).testBlockSize() .rollCycle(RollCycles.TEST_SECONDLY).build(); final ExcerptTailer tailer = queue.createTailer(); tailer.direction(TailerDirection.NONE); final ExcerptAppender excerptAppender = queue.acquireAppender(); for (int i = 0; i < 10; i++) { excerptAppender.writeDocument(i, (out, value) -> { out.int32(value); }); } DocumentContext document = tailer.readingDocument(); assertFalse(document.isPresent()); }
@Test public void shouldHandleCycleRoll() { File dir = tempDir("shouldHandleCycleRoll"); try (final SingleChronicleQueue queue = createQueue(dir, clock::get)) { final Pretoucher pretoucher = new Pretoucher(createQueue(dir, clock::get), chunkListener, capturedCycles::add); range(0, 10).forEach(i -> { try (final DocumentContext ctx = queue.acquireAppender().writingDocument()) { assertThat(capturedCycles.size(), is(i)); ctx.wire().write().int32(i); ctx.wire().write().bytes(new byte[1024]); } try { pretoucher.execute(); } catch (InvalidEventHandlerException e) { e.printStackTrace(); } assertThat(capturedCycles.size(), is(i + 1)); try { pretoucher.execute(); } catch (InvalidEventHandlerException e) { e.printStackTrace(); } assertThat(capturedCycles.size(), is(i + 1)); clock.addAndGet(TimeUnit.SECONDS.toMillis(5L)); }); assertThat(capturedCycles.size(), is(10)); //assertThat(chunkListener.chunkMap.isEmpty(), is(false)); } }
@Test public void tailerToEndIncreasesRefCount() throws Exception { String path = OS.TARGET + "/toEndIncRefCount-" + System.nanoTime(); IOTools.shallowDeleteDirWithFiles(path); SetTimeProvider time = new SetTimeProvider(); long now = System.currentTimeMillis(); time.currentTimeMillis(now); ChronicleQueue queue = SingleChronicleQueueBuilder.binary(path) .testBlockSize() .rollCycle(RollCycles.TEST_SECONDLY) .timeProvider(time) .build(); final SingleChronicleQueueExcerpts.StoreAppender appender = (SingleChronicleQueueExcerpts.StoreAppender) queue.acquireAppender(); Field storeF1 = SingleChronicleQueueExcerpts.StoreAppender.class.getDeclaredField("store"); Jvm.setAccessible(storeF1); SingleChronicleQueueStore store1 = (SingleChronicleQueueStore) storeF1.get(appender); System.out.println(store1); appender.writeDocument(wire -> wire.write(() -> "msg").int32(1)); final SingleChronicleQueueExcerpts.StoreTailer tailer = (SingleChronicleQueueExcerpts.StoreTailer) queue.createTailer(); System.out.println(tailer); tailer.toEnd(); System.out.println(tailer); Field storeF2 = SingleChronicleQueueExcerpts.StoreTailer.class.getDeclaredField("store"); Jvm.setAccessible(storeF2); SingleChronicleQueueStore store2 = (SingleChronicleQueueStore) storeF2.get(tailer); // the reference count here is 1, the queue itself assertEquals(1, store2.refCount()); }
@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 } } }
@Test public void shouldAppendToExistingQueueFile() throws Exception { try (final SingleChronicleQueue queue = createQueue()) { final ExcerptAppender appender = queue.acquireAppender(); appender.writeDocument(1, (w, i) -> { w.int32(i); }); final ExcerptTailer tailer = queue.createTailer(); try (final DocumentContext context = tailer.readingDocument()) { assertTrue(context.isPresent()); } assertQueueFileCount(queue.path.toPath(), 1); assertFalse(tailer.readingDocument().isPresent()); appender.writeDocument(2, (w, i) -> { w.int32(i); }); assertQueueFileCount(queue.path.toPath(), 1); try (final DocumentContext context = tailer.readingDocument()) { assertTrue(context.isPresent()); } } }
@Test public void shouldIndicateNoProcessIdWhenDocumentIsComplete() throws IOException { try (final RollingChronicleQueue queue = ChronicleQueue.singleBuilder(getTmpDir()). testBlockSize(). build()) { final QueueInspector inspector = new QueueInspector(queue); final ExcerptAppender appender = queue.acquireAppender(); appender.writeDocument(37L, ValueOut::int64); try (final DocumentContext ctx = appender.writingDocument()) { ctx.wire().write("foo").int32(17L); } final int writingThreadId = inspector.getWritingThreadId(); assertThat(writingThreadId, is(not(OS.getProcessId()))); assertThat(QueueInspector.isValidThreadId(writingThreadId), is(false)); } }
@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)); } }
appender.writeDocument(wire -> wire.write(() -> "msg").int32(j));
@Test public void shouldDetermineWritingProcessIdWhenDocumentIsNotComplete() throws IOException { try (final RollingChronicleQueue queue = ChronicleQueue.singleBuilder(getTmpDir()). testBlockSize(). build()) { final QueueInspector inspector = new QueueInspector(queue); final ExcerptAppender appender = queue.acquireAppender(); appender.writeDocument(37L, ValueOut::int64); try (final DocumentContext ctx = appender.writingDocument()) { ctx.wire().write("foo").int32(17L); final int writingThreadId = inspector.getWritingThreadId(); // commentedVanillaMsgSequenceHandler out as fails on Mac OS // assertThat(writingThreadId, is(Affinity.getThreadId())); // we no longer write header before the document is closed // assertThat(QueueInspector.isValidThreadId(writingThreadId), is(true)); } } }
@Test public void test() throws IOException { try (final RollingChronicleQueue queue = SingleChronicleQueueBuilder .binary(getTmpDir()) .testBlockSize() .wireType(this.wireType) .build()) { final ExcerptAppender appender = queue.acquireAppender(); for (int i = 0; i < 5; i++) { final int n = i; appender.writeDocument( w -> w.write(TestKey.test).int32(n)); final int cycle = queue.lastCycle(); long index0 = queue.rollCycle().toIndex(cycle, n); long indexA = appender.lastIndexAppended(); accessHexEquals(index0, indexA); } } }
@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())); } }
@Test public void testLongLivingTailerAppenderReAcquiredEachSecond() { SetTimeProvider timeProvider = new SetTimeProvider(); final File dir = DirectoryUtils.tempDir(testName.getMethodName()); final RollCycles rollCycle = RollCycles.TEST_SECONDLY; try (ChronicleQueue queuet = binary(dir) .rollCycle(rollCycle) .timeProvider(timeProvider) .build()) { final ExcerptTailer tailer = queuet.createTailer(); // write first message try (ChronicleQueue queue = binary(dir) .rollCycle(rollCycle) .timeProvider(timeProvider) .build()) { for (int i = 0; i < 5; i++) { final ExcerptAppender appender = queue.acquireAppender(); timeProvider.advanceMillis(1100); try (final DocumentContext dc = appender.writingDocument()) { dc.wire().write("some").int32(i); } try (final DocumentContext dc = tailer.readingDocument()) { Assert.assertEquals(i, dc.wire().read("some").int32()); } } } } }
@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())); } } }