/** * Specify the {@link ExceptionHandler} to use with the event handler. * * @param exceptionHandler the exception handler to use. */ @SuppressWarnings("unchecked") public void with(ExceptionHandler<? super T> exceptionHandler) { final EventProcessor eventProcessor = consumerRepository.getEventProcessorFor(eventHandler); if (eventProcessor instanceof BatchEventProcessor) { ((BatchEventProcessor<T>) eventProcessor).setExceptionHandler(exceptionHandler); consumerRepository.getBarrierFor(eventHandler).alert(); } else { throw new RuntimeException( "EventProcessor: " + eventProcessor + " is not a BatchEventProcessor " + "and does not support exception handlers"); } } }
@Test(expected = NullPointerException.class) public void shouldThrowExceptionOnSettingNullExceptionHandler() { final BatchEventProcessor<StubEvent> batchEventProcessor = new BatchEventProcessor<StubEvent>( ringBuffer, sequenceBarrier, new ExceptionEventHandler()); batchEventProcessor.setExceptionHandler(null); }
EventHandlerGroup<T> createEventProcessors( final Sequence[] barrierSequences, final EventHandler<? super T>[] eventHandlers) { checkNotStarted(); final Sequence[] processorSequences = new Sequence[eventHandlers.length]; final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences); for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++) { final EventHandler<? super T> eventHandler = eventHandlers[i]; final BatchEventProcessor<T> batchEventProcessor = new BatchEventProcessor<>(ringBuffer, barrier, eventHandler); if (exceptionHandler != null) { batchEventProcessor.setExceptionHandler(exceptionHandler); } consumerRepository.add(batchEventProcessor, eventHandler, barrier); processorSequences[i] = batchEventProcessor.getSequence(); } updateGatingSequencesForNextInChain(barrierSequences, processorSequences); return new EventHandlerGroup<>(this, consumerRepository, processorSequences); }
@Test public void shouldCallExceptionHandlerOnUncaughtException() throws Exception { CountDownLatch exceptionLatch = new CountDownLatch(1); LatchExceptionHandler latchExceptionHandler = new LatchExceptionHandler(exceptionLatch); final BatchEventProcessor<StubEvent> batchEventProcessor = new BatchEventProcessor<StubEvent>( ringBuffer, sequenceBarrier, new ExceptionEventHandler()); ringBuffer.addGatingSequences(batchEventProcessor.getSequence()); batchEventProcessor.setExceptionHandler(latchExceptionHandler); Thread thread = new Thread(batchEventProcessor); thread.start(); ringBuffer.publish(ringBuffer.next()); assertTrue(exceptionLatch.await(2, TimeUnit.SECONDS)); batchEventProcessor.halt(); thread.join(); }
sequenceBarrier, new SimpleParserStage(logContext)); simpleParserStage.setExceptionHandler(exceptionHandler); disruptorMsgBuffer.addGatingSequences(simpleParserStage.getSequence()); sinkSequenceBarrier, new SinkStoreStage()); sinkStoreStage.setExceptionHandler(exceptionHandler); disruptorMsgBuffer.addGatingSequences(sinkStoreStage.getSequence());
/** * Specify the {@link ExceptionHandler} to use with the event handler. * * @param exceptionHandler the exception handler to use. */ @SuppressWarnings("unchecked") public void with(ExceptionHandler<? super T> exceptionHandler) { final EventProcessor eventProcessor = consumerRepository.getEventProcessorFor(eventHandler); if (eventProcessor instanceof BatchEventProcessor) { ((BatchEventProcessor<T>) eventProcessor).setExceptionHandler(exceptionHandler); consumerRepository.getBarrierFor(eventHandler).alert(); } else { throw new RuntimeException( "EventProcessor: " + eventProcessor + " is not a BatchEventProcessor " + "and does not support exception handlers"); } } }
EventHandlerGroup<T> createEventProcessors( final Sequence[] barrierSequences, final EventHandler<? super T>[] eventHandlers) { checkNotStarted(); final Sequence[] processorSequences = new Sequence[eventHandlers.length]; final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences); for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++) { final EventHandler<? super T> eventHandler = eventHandlers[i]; final BatchEventProcessor<T> batchEventProcessor = new BatchEventProcessor<>(ringBuffer, barrier, eventHandler); if (exceptionHandler != null) { batchEventProcessor.setExceptionHandler(exceptionHandler); } consumerRepository.add(batchEventProcessor, eventHandler, barrier); processorSequences[i] = batchEventProcessor.getSequence(); } updateGatingSequencesForNextInChain(barrierSequences, processorSequences); return new EventHandlerGroup<>(this, consumerRepository, processorSequences); }
/** * Specify the {@link ExceptionHandler} to use with the event handler. * * @param exceptionHandler the exception handler to use. */ public void with(ExceptionHandler exceptionHandler) { ((BatchEventProcessor<?>) consumerRepository.getEventProcessorFor(eventHandler)).setExceptionHandler(exceptionHandler); consumerRepository.getBarrierFor(eventHandler).alert(); } }
@Inject ReplyProcessorImpl(MetricsRegistry metrics, Panicker panicker) { replyRing = RingBuffer.<ReplyEvent>createMultiProducer(ReplyEvent.EVENT_FACTORY, 1<<12, new BusySpinWaitStrategy()); SequenceBarrier replySequenceBarrier = replyRing.newBarrier(); BatchEventProcessor<ReplyEvent> replyProcessor = new BatchEventProcessor<ReplyEvent>( replyRing, replySequenceBarrier, this); replyProcessor.setExceptionHandler(new FatalExceptionHandler(panicker)); replyRing.addGatingSequences(replyProcessor.getSequence()); ExecutorService replyExec = Executors.newSingleThreadExecutor( new ThreadFactoryBuilder().setNameFormat("reply-%d").build()); replyExec.submit(replyProcessor); abortMeter = metrics.meter(name("tso", "aborts")); commitMeter = metrics.meter(name("tso", "commits")); timestampMeter = metrics.meter(name("tso", "timestampAllocation")); }
@Inject ReplyProcessorImpl(MetricsRegistry metrics, Panicker panicker, ObjectPool<Batch> batchPool) { this.batchPool = batchPool; this.nextIDToHandle.set(0); this.replyRing = RingBuffer.createMultiProducer(ReplyBatchEvent.EVENT_FACTORY, 1 << 12, new BusySpinWaitStrategy()); SequenceBarrier replySequenceBarrier = replyRing.newBarrier(); BatchEventProcessor<ReplyBatchEvent> replyProcessor = new BatchEventProcessor<>(replyRing, replySequenceBarrier, this); replyProcessor.setExceptionHandler(new FatalExceptionHandler(panicker)); replyRing.addGatingSequences(replyProcessor.getSequence()); ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("reply-%d").build(); ExecutorService replyExec = Executors.newSingleThreadExecutor(threadFactory); replyExec.submit(replyProcessor); this.futureEvents = new PriorityQueue<>(10, new Comparator<ReplyBatchEvent>() { public int compare(ReplyBatchEvent replyBatchEvent1, ReplyBatchEvent replyBatchEvent2) { return Long.compare(replyBatchEvent1.getBatchSequence(), replyBatchEvent2.getBatchSequence()); } }); this.abortMeter = metrics.meter(name("tso", "aborts")); this.commitMeter = metrics.meter(name("tso", "commits")); this.timestampMeter = metrics.meter(name("tso", "timestampAllocation")); }
/** * Specify the {@link ExceptionHandler} to use with the event handler. * * @param exceptionHandler the exception handler to use. */ public void with(ExceptionHandler<? super T> exceptionHandler) { ((BatchEventProcessor<T>) consumerRepository.getEventProcessorFor(eventHandler)) .setExceptionHandler(exceptionHandler); consumerRepository.getBarrierFor(eventHandler).alert(); } }
/** * Specify the {@link ExceptionHandler} to use with the event handler. * * @param exceptionHandler the exception handler to use. */ @SuppressWarnings("unchecked") public void with(ExceptionHandler<? super T> exceptionHandler) { final EventProcessor eventProcessor = consumerRepository.getEventProcessorFor(eventHandler); if (eventProcessor instanceof BatchEventProcessor) { ((BatchEventProcessor<T>) eventProcessor).setExceptionHandler(exceptionHandler); consumerRepository.getBarrierFor(eventHandler).alert(); } else { throw new RuntimeException( "EventProcessor: " + eventProcessor + " is not a BatchEventProcessor " + "and does not support exception handlers"); } } }
@Inject RetryProcessorImpl(MetricsRegistry metrics, CommitTable commitTable, ReplyProcessor replyProc, Panicker panicker) throws InterruptedException, ExecutionException { this.commitTableClient = commitTable.getClient().get(); this.writer = commitTable.getWriter().get(); this.replyProc = replyProc; WaitStrategy strategy = new YieldingWaitStrategy(); retryRing = RingBuffer.<RetryEvent>createSingleProducer( RetryEvent.EVENT_FACTORY, 1<<12, strategy); SequenceBarrier retrySequenceBarrier = retryRing.newBarrier(); BatchEventProcessor<RetryEvent> retryProcessor = new BatchEventProcessor<RetryEvent>( retryRing, retrySequenceBarrier, this); retryProcessor.setExceptionHandler(new FatalExceptionHandler(panicker)); retryRing.addGatingSequences(retryProcessor.getSequence()); ExecutorService retryExec = Executors.newSingleThreadExecutor( new ThreadFactoryBuilder().setNameFormat("retry-%d").build()); retryExec.submit(retryProcessor); // Metrics retriesMeter = metrics.meter(name("tso", "retries")); }
@Inject RetryProcessorImpl(MetricsRegistry metrics, CommitTable commitTable, ReplyProcessor replyProc, Panicker panicker, ObjectPool<Batch> batchPool) throws InterruptedException, ExecutionException, IOException { this.commitTableClient = commitTable.getClient(); this.replyProc = replyProc; this.batchPool = batchPool; retryRing = RingBuffer.createSingleProducer(RetryEvent.EVENT_FACTORY, 1 << 12, new YieldingWaitStrategy()); SequenceBarrier retrySequenceBarrier = retryRing.newBarrier(); BatchEventProcessor<RetryEvent> retryProcessor = new BatchEventProcessor<>(retryRing, retrySequenceBarrier, this); retryProcessor.setExceptionHandler(new FatalExceptionHandler(panicker)); retryRing.addGatingSequences(retryProcessor.getSequence()); ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("retry-%d").build(); ExecutorService retryExec = Executors.newSingleThreadExecutor(threadFactory); retryExec.submit(retryProcessor); // Metrics configuration retriesMeter = metrics.meter(name("tso", "retries")); }
@Inject RequestProcessorImpl(MetricsRegistry metrics, TimestampOracle timestampOracle, PersistenceProcessor persistProc, Panicker panicker, TSOServerConfig config) throws IOException { this.metrics = metrics; this.persistProc = persistProc; this.timestampOracle = timestampOracle; this.hashmap = new CommitHashMap(config.getMaxItems()); final TimeoutBlockingWaitStrategy timeoutStrategy = new TimeoutBlockingWaitStrategy(config.getBatchPersistTimeoutInMs(), TimeUnit.MILLISECONDS); // Set up the disruptor thread requestRing = RingBuffer.createMultiProducer(RequestEvent.EVENT_FACTORY, 1 << 12, timeoutStrategy); SequenceBarrier requestSequenceBarrier = requestRing.newBarrier(); BatchEventProcessor<RequestEvent> requestProcessor = new BatchEventProcessor<>(requestRing, requestSequenceBarrier, this); requestRing.addGatingSequences(requestProcessor.getSequence()); requestProcessor.setExceptionHandler(new FatalExceptionHandler(panicker)); ExecutorService requestExec = Executors.newSingleThreadExecutor( new ThreadFactoryBuilder().setNameFormat("request-%d").build()); // Each processor runs on a separate thread requestExec.submit(requestProcessor); }
@Inject RequestProcessorImpl(MetricsRegistry metrics, TimestampOracle timestampOracle, PersistenceProcessor persistProc, Panicker panicker, TSOServerConfig config) { this.persistProc = persistProc; this.timestampOracle = timestampOracle; this.lowWatermark = timestampOracle.getLast(); persistProc.persistLowWatermark(lowWatermark); this.hashmap = new CommitHashMap(config.getMaxItems(), lowWatermark); // Set up the disruptor thread requestRing = RingBuffer.<RequestEvent>createMultiProducer(RequestEvent.EVENT_FACTORY, 1<<12, new BusySpinWaitStrategy()); SequenceBarrier requestSequenceBarrier = requestRing.newBarrier(); BatchEventProcessor<RequestEvent> requestProcessor = new BatchEventProcessor<RequestEvent>(requestRing, requestSequenceBarrier, this); requestRing.addGatingSequences(requestProcessor.getSequence()); requestProcessor.setExceptionHandler(new FatalExceptionHandler(panicker)); ExecutorService requestExec = Executors.newSingleThreadExecutor( new ThreadFactoryBuilder().setNameFormat("request-%d").build()); // Each processor runs on a separate thread requestExec.submit(requestProcessor); }
this); persistRing.addGatingSequences(persistProcessor.getSequence()); persistProcessor.setExceptionHandler(new FatalExceptionHandler(panicker));
EventHandlerGroup<T> createEventProcessors( final Sequence[] barrierSequences, final EventHandler<? super T>[] eventHandlers) { checkNotStarted(); final Sequence[] processorSequences = new Sequence[eventHandlers.length]; final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences); for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++) { final EventHandler<? super T> eventHandler = eventHandlers[i]; final BatchEventProcessor<T> batchEventProcessor = new BatchEventProcessor<>(ringBuffer, barrier, eventHandler); if (exceptionHandler != null) { batchEventProcessor.setExceptionHandler(exceptionHandler); } consumerRepository.add(batchEventProcessor, eventHandler, barrier); processorSequences[i] = batchEventProcessor.getSequence(); } updateGatingSequencesForNextInChain(barrierSequences, processorSequences); return new EventHandlerGroup<>(this, consumerRepository, processorSequences); }
EventHandlerGroup<T> createEventProcessors(final Sequence[] barrierSequences, final EventHandler<? super T>[] eventHandlers) { checkNotStarted(); final Sequence[] processorSequences = new Sequence[eventHandlers.length]; final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences); for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++) { final EventHandler<? super T> eventHandler = eventHandlers[i]; final BatchEventProcessor<T> batchEventProcessor = new BatchEventProcessor<T>(ringBuffer, barrier, eventHandler); if (exceptionHandler != null) { batchEventProcessor.setExceptionHandler(exceptionHandler); } consumerRepository.add(batchEventProcessor, eventHandler, barrier); processorSequences[i] = batchEventProcessor.getSequence(); } if (processorSequences.length > 0) { consumerRepository.unMarkEventProcessorsAsEndOfChain(barrierSequences); } return new EventHandlerGroup<T>(this, consumerRepository, processorSequences); }
EventHandlerGroup<T> createEventProcessors( final Sequence[] barrierSequences, final EventHandler<? super T>[] eventHandlers) { checkNotStarted(); final Sequence[] processorSequences = new Sequence[eventHandlers.length]; final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences); for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++) { final EventHandler<? super T> eventHandler = eventHandlers[i]; final BatchEventProcessor<T> batchEventProcessor = new BatchEventProcessor<T>(ringBuffer, barrier, eventHandler); if (exceptionHandler != null) { batchEventProcessor.setExceptionHandler(exceptionHandler); } consumerRepository.add(batchEventProcessor, eventHandler, barrier); processorSequences[i] = batchEventProcessor.getSequence(); } if (processorSequences.length > 0) { consumerRepository.unMarkEventProcessorsAsEndOfChain(barrierSequences); } return new EventHandlerGroup<T>(this, consumerRepository, processorSequences); }