private static void simplePublish(Disruptor<Event> disruptor, AtomicBoolean running) { while (running.get()) { disruptor.publishEvent(new EventTranslator<Event>() { @Override public void translateTo(Event event, long sequence) { event.value = sequence; } }); } }
@Test(timeout = 1000) public void shouldShutdownGracefulEvenWithFatalExceptionHandler() { disruptor.start(); byte[] bytes; for (int i = 1; i < 10; i++) { bytes = new byte[32]; random.nextBytes(bytes); disruptor.publishEvent(new ByteArrayTranslator(bytes)); } }
private TestEvent publishEvent() throws InterruptedException, BrokenBarrierException { if (ringBuffer == null) { ringBuffer = disruptor.start(); for (DelayedEventHandler eventHandler : delayedEventHandlers) { eventHandler.awaitStart(); } } disruptor.publishEvent( new EventTranslator<TestEvent>() { @Override public void translateTo(final TestEvent event, final long sequence) { lastPublishedEvent = event; } }); return lastPublishedEvent; }
disruptor.publishEvent( new EventTranslator<TestEvent>() disruptor.publishEvent( new EventTranslator<TestEvent>()
disruptor.publishEvent(t);
@Override public void run() { disruptor.publishEvent(new EventTranslatorOneArg<ReportingEvent, MetricRegistry>() { @Override public void translateTo(ReportingEvent event, long sequence, MetricRegistry metricRegistry) { event.reportMetrics(metricRegistry); } }, metricRegistry); } }, intervalMs, intervalMs, TimeUnit.MILLISECONDS);
@Override public <R> CompletableFuture<R> process(BiConsumer<T, CompletableFuture<R>> consumer) { if (!isStarted) throw new RuntimeException("Pipe Processor must be started!"); final CompletableFuture<R> f = new CompletableFuture<R>(); disruptor.publishEvent((e,s) -> consumer.accept(e, f)); return f; }
@Override public void onApplicationEvent(DisruptorApplicationEvent appEvent) { DisruptorEvent event = (DisruptorEvent) appEvent.getSource(); disruptor.publishEvent(oneArgEventTranslator, event); }
@Override public boolean apply(BucketCommand<?> input) { if(closed.get()) { return false; } disruptor.publishEvent(new BucketCommandEventTranslator(input)); return true; }
@Override public void onApplicationEvent(DisruptorApplicationEvent appEvent) { DisruptorEvent event = (DisruptorEvent) appEvent.getSource(); disruptor.publishEvent(oneArgEventTranslator, event); }
@Override public void close() { disruptor.publishEvent(SHUTDOWN_EVENT_TRANSLATOR); try { disruptor.shutdown(5, TimeUnit.SECONDS); } catch (com.lmax.disruptor.TimeoutException e) { logger.warn("Timeout while shutting down disruptor"); } reportingEventHandler.close(); if (metricsReportingScheduler != null) { metricsReportingScheduler.shutdown(); } }
public void flush(long internalMessageId) { Message message = pendingMessages.remove(internalMessageId); if (message != null) { if (message.hasAttachedQueues()) { disruptor.publishEvent(INSERT_MESSAGE, message); } else { message.release(); } } }
void enqueueLogMessageInfo(final RingBufferLogEventTranslator translator) { // LOG4J2-639: catch NPE if disruptor field was set to null in stop() try { // Note: we deliberately access the volatile disruptor field afresh here. // Avoiding this and using an older reference could result in adding a log event to the disruptor after it // was shut down, which could cause the publishEvent method to hang and never return. disruptor.publishEvent(translator); } catch (final NullPointerException npe) { LOGGER.warn("[{}] Ignoring log event after log4j was shut down: {} [{}] {}", contextName, translator.level, translator.loggerName, translator.message.getFormattedMessage() + (translator.thrown == null ? "" : Throwables.toStringList(translator.thrown))); } }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public void execute(ExecutionContext context) { this.disruptor.publishEvent((event, sequence) -> { event.clear(); event.setContext(context); }); }
private void produceEvent(Message message, Deferred<Message, Exception> deferred) { if (!this.isStarted()) { return; } this.sendWorker.publishEvent((ProducerEvent event, long sequence) -> { event.clear(); event.setDeferred(deferred); event.setMessage(message); }); }
public void publishEvent(String event, String tag, Object body) { DisruptorBindEvent bindEvent = new DisruptorBindEvent(); bindEvent.setEvent(event); bindEvent.setTag(tag); bindEvent.setBody(body); disruptor.publishEvent(oneArgEventTranslator, bindEvent); }
public void publishEvent(String event, String tag, Object body) { DisruptorBindEvent bindEvent = new DisruptorBindEvent(); bindEvent.setEvent(event); bindEvent.setTag(tag); bindEvent.setBody(body); disruptor.publishEvent(oneArgEventTranslator, bindEvent); }
public void publishEvent(String event, String tag, String key, Object body) { DisruptorBindEvent bindEvent = new DisruptorBindEvent(); bindEvent.setEvent(event); bindEvent.setTag(tag); bindEvent.setKey(key); bindEvent.setBody(body); disruptor.publishEvent(oneArgEventTranslator, bindEvent); }
public void detach(String queueName, Message message) { message.removeAttachedQueue(queueName); if (!message.hasAttachedQueues()) { delete(message.getInternalId()); } else { disruptor.publishEvent(DETACH_FROM_QUEUE, queueName, message.getInternalId()); } }
public void publishEvent(String event, String tag, String key, Object body) { DisruptorBindEvent bindEvent = new DisruptorBindEvent(); bindEvent.setEvent(event); bindEvent.setTag(tag); bindEvent.setKey(key); bindEvent.setBody(body); disruptor.publishEvent(oneArgEventTranslator, bindEvent); }