@NotNull public JDBCStatement createWriter() { return in.acquireAppender() .methodWriterBuilder(JDBCStatement.class) .recordHistory(true) .get(); }
@NotNull default <T> VanillaMethodWriterBuilder<T> methodWriterBuilder(@NotNull Class<T> tClass) { return new VanillaMethodWriterBuilder<>(tClass, new BinaryMethodWriterInvocationHandler(false, this::acquireAppender)); }
@Test @Ignore("TODO FIX") public void readOnlyQueueTailerInFollowModeShouldObserveChangesAfterInitiallyObservedReadLimit() throws Exception { DirectoryUtils.deleteDir(dataDir.toFile()); dataDir.toFile().mkdirs(); try (final ChronicleQueue queue = SingleChronicleQueueBuilder.binary(dataDir).testBlockSize().build()) { final StringEvents events = queue.acquireAppender().methodWriterBuilder(StringEvents.class).build(); events.say("hello"); final long readerCapacity = getCurrentQueueFileLength(dataDir); final AtomicReference<String> messageReceiver = new AtomicReference<>(); final ChronicleReader chronicleReader = basicReader().tail(). withMessageSink(messageReceiver::set); final ExecutorService executorService = Executors.newSingleThreadExecutor(); Future<?> submit = executorService.submit(chronicleReader::execute); final long expectedReadingDocumentCount = (readerCapacity / ONE_KILOBYTE.length) + 1; int i; for (i = 0; i < expectedReadingDocumentCount; i++) { events.say(new String(ONE_KILOBYTE)); } events.say(LAST_MESSAGE); while (!(messageReceiver.get() != null && messageReceiver.get().contains(LAST_MESSAGE))) { LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(1000L)); } executorService.shutdownNow(); executorService.awaitTermination(5L, TimeUnit.SECONDS); submit.get(); } }
private void generateTestData(final ChronicleQueue inputQueue, final ChronicleQueue outputQueue) { final First first = inputQueue.acquireAppender(). methodWriterBuilder(First.class).recordHistory(true).build(); first.say("one"); first.say("two"); first.say("three"); final LoggingFirst loggingFirst = new LoggingFirst(outputQueue.acquireAppender(). methodWriterBuilder(Second.class).build()); final MethodReader reader = inputQueue.createTailer(). methodReaderBuilder().build(loggingFirst); assertThat(reader.readOne(), is(true)); assertThat(reader.readOne(), is(true)); // roll queue file clock.addAndGet(TimeUnit.DAYS.toMillis(2)); assertThat(reader.readOne(), is(true)); assertThat(reader.readOne(), is(false)); }
methodWriterBuilder(StringEvents.class).get(); final HelloWorld secondWriter = secondInputQueue.acquireAppender(). methodWriterBuilder(HelloWorld.class).get(); methodWriterBuilder(StringEvents.class).recordHistory(true).get();
OrderIdeaListener orderManager = out.acquireAppender() .methodWriterBuilder(OrderIdeaListener.class) .addInterface(MarketDataListener.class) .recordHistory(true) .get(); .recordHistory(true) .get();
private void doWrite(ChronicleQueue queue, BiConsumer<PersonListener, ChronicleQueue> action) { ExcerptAppender appender = queue.acquireAppender(); PersonListener proxy = appender.methodWriterBuilder(PersonListener.class).get(); action.accept(proxy, queue); }
public static void main(String[] args) { SingleChronicleQueue outQueue = SingleChronicleQueueBuilder.binary("target/" + "monitor") .rollCycle(RollCycles.TEST_SECONDLY).build(); ExcerptAppender outQueueAppender = outQueue.acquireAppender(); HeartbeatListener heartbeatWriter = outQueueAppender.methodWriterBuilder(HeartbeatListener.class).methodWriterListener((m, a) -> validateAll(a)).recordHistory(true).build(); Monitor.addPeriodicUpdateSource(10, () -> currentTimeMillis -> { outQueueAppender.pretouch(); }); long lastHB = 0; while (true) { if (System.currentTimeMillis() - lastHB > 1) { // write a hb to the queue MessageHistory.get().reset(); Heartbeat heartBeat = new Heartbeat(UUID.randomUUID().toString()); heartbeatWriter.heartbeat(heartBeat); lastHB = System.currentTimeMillis(); } } }
@NotNull public <T> T inputWriter(Class<T> tClass) { ChronicleQueue queue = inputQueue(); return queue.acquireAppender() .methodWriterBuilder(tClass) .recordHistory(true) .onClose(queue) .get(); } }
@Test(timeout = 5000) public void readOnlyQueueTailerShouldObserveChangesAfterInitiallyObservedReadLimit() throws Exception { DirectoryUtils.deleteDir(dataDir.toFile()); dataDir.toFile().mkdirs(); try (final ChronicleQueue queue = SingleChronicleQueueBuilder.binary(dataDir).testBlockSize().build()) { final StringEvents events = queue.acquireAppender().methodWriterBuilder(StringEvents.class).build(); events.say("hello"); final long readerCapacity = getCurrentQueueFileLength(dataDir); final RecordCounter recordCounter = new RecordCounter(); final ChronicleReader chronicleReader = basicReader().withMessageSink(recordCounter); final ExecutorService executorService = Executors.newSingleThreadExecutor(); Future<?> submit = executorService.submit(chronicleReader::execute); final long expectedReadingDocumentCount = (readerCapacity / ONE_KILOBYTE.length) + 1; int i; for (i = 0; i < expectedReadingDocumentCount; i++) { events.say(new String(ONE_KILOBYTE)); } recordCounter.latch.countDown(); executorService.shutdown(); executorService.awaitTermination(Jvm.isDebug() ? 50 : 5, TimeUnit.SECONDS); submit.get(1, TimeUnit.SECONDS); // #460 read only not supported on windows. if (!OS.isWindows()) assertEquals(expectedReadingDocumentCount, recordCounter.recordCount.get() - 1); } }
@NotNull default <T> VanillaMethodWriterBuilder<T> methodWriterBuilder(@NotNull Class<T> tClass) { return new VanillaMethodWriterBuilder<>(tClass, new BinaryMethodWriterInvocationHandler(false, this::acquireAppender)); }
public EventLoopServiceWrapper(@NotNull ServiceWrapperBuilder<O> builder) { this.priority = builder.priority(); outputQueue = ChronicleQueue.singleBuilder(builder.outputPath()) .sourceId(builder.outputSourceId()) .checkInterrupts(false) .build(); serviceOut = outputQueue.acquireAppender() .methodWriterBuilder(builder.outClass()) .recordHistory(builder.outputSourceId() != 0) .get(); serviceImpl = builder.getServiceFunctions().stream() .map(f -> f.apply(serviceOut)) .toArray(); List<String> paths = builder.inputPath(); serviceIn = new MethodReader[paths.size()]; inputQueues = new ChronicleQueue[paths.size()]; for (int i = 0; i < paths.size(); i++) { inputQueues[i] = ChronicleQueue.singleBuilder(paths.get(i)) .sourceId(builder.inputSourceId()) .build(); serviceIn[i] = inputQueues[i].createTailer() .afterLastWritten(outputQueue) .methodReader(serviceImpl); } eventLoop = builder.eventLoop(); eventLoop.addHandler(this); createdEventLoop = builder.createdEventLoop(); if (createdEventLoop) eventLoop.start(); }
try (SingleChronicleQueue queue = SingleChronicleQueueBuilder.binary(tempDir).build()) { TestMessageListener writer = queue.acquireAppender().methodWriterBuilder(TestMessageListener.class).build(); Message message = new ProxyTest.Message();
void runLoop() { try { JDBCResult result = out.acquireAppender() .methodWriterBuilder(JDBCResult.class) .recordHistory(true) .get(); JDBCComponent js = new JDBCComponent(connectionSupplier, result); MethodReader reader = in.createTailer().afterLastWritten(out).methodReader(js); Pauser pauser = Pauser.millis(1, 10); while (!closed) { if (reader.readOne()) pauser.reset(); else pauser.pause(); } } catch (Throwable t) { LOGGER.warn("Run loop exited", t); } }
@Test public void shouldHandleCycleRollWhenInReadOnlyMode() { final MutableTimeProvider timeProvider = new MutableTimeProvider(); final ChronicleQueue queue = build(createQueue(dataDirectory, RollCycles.MINUTELY, 0, "cycleRoll", false). timeProvider(timeProvider)); final StringEvents events = queue.acquireAppender().methodWriterBuilder(StringEvents.class).build(); timeProvider.setTime(System.currentTimeMillis()); events.onEvent("firstEvent"); timeProvider.addTime(2, TimeUnit.MINUTES); events.onEvent("secondEvent"); final ChronicleQueue readerQueue = build(createQueue(dataDirectory, RollCycles.MINUTELY, 0, "cycleRoll", true). timeProvider(timeProvider)); final ExcerptTailer tailer = readerQueue.createTailer(); tailer.toStart(); try (final DocumentContext context = tailer.readingDocument()) { assertThat(context.isPresent(), is(true)); } tailer.toEnd(); try (final DocumentContext context = tailer.readingDocument()) { assertThat(context.isPresent(), is(false)); } }
final Msg msg = inQueue.acquireAppender().methodWriterBuilder(Msg.class).recordHistory(true).build(); Msg out = outQueue.acquireAppender().methodWriterBuilder(Msg.class).recordHistory(true).build(); MethodReader methodReader = inQueue.createTailer().methodReader((Msg) out::msg);
DummyListener writer = out.acquireAppender() .methodWriterBuilder(DummyListener.class) .recordHistory(recordHistoryFirst) .get(); writer.say("hello"); DummyListener writer = out.acquireAppender() .methodWriterBuilder(DummyListener.class) .recordHistory(true) .get(); DummyListener dummy = msg -> { DummyListener writer = out.acquireAppender() .methodWriterBuilder(DummyListener.class) .recordHistory(true) .get(); DummyListener dummy = msg -> {
.recordHistory(true) .build(); .recordHistory(true) .build(); MethodReader methodReader = inQueue.createTailer()
.recordHistory(true) .build(); .recordHistory(true) .build(); MethodReader methodReader = inQueue.createTailer().methodReader((Msg) out::msg);
SidedMarketDataListener combiner = out.acquireAppender() .methodWriterBuilder(SidedMarketDataListener.class) .recordHistory(true) .get(); MarketDataListener mdListener = excerptAppender .methodWriterBuilder(MarketDataListener.class) .recordHistory(true) .get(); SidedMarketDataCombiner combiner = new SidedMarketDataCombiner(mdListener);