/** * Publish an event to the ring buffer. * * @param eventTranslator the translator that will load data into the event. */ public void publishEvent(final EventTranslator<T> eventTranslator) { ringBuffer.publishEvent(eventTranslator); }
/** * Publish an event to the ring buffer. * * @param <A> Class of the user supplied argument. * @param eventTranslator the translator that will load data into the event. * @param arg A single argument to load into the event */ public <A> void publishEvent(final EventTranslatorOneArg<T, A> eventTranslator, final A arg) { ringBuffer.publishEvent(eventTranslator, arg); }
/** * Publish an event to the ring buffer. * * @param <A> Class of the user supplied argument. * @param <B> Class of the user supplied argument. * @param eventTranslator the translator that will load data into the event. * @param arg0 The first argument to load into the event * @param arg1 The second argument to load into the event */ public <A, B> void publishEvent(final EventTranslatorTwoArg<T, A, B> eventTranslator, final A arg0, final B arg1) { ringBuffer.publishEvent(eventTranslator, arg0, arg1); }
/** * Publish an event to the ring buffer. * * @param eventTranslator the translator that will load data into the event. * @param <A> Class of the user supplied argument. * @param <B> Class of the user supplied argument. * @param <C> Class of the user supplied argument. * @param arg0 The first argument to load into the event * @param arg1 The second argument to load into the event * @param arg2 The third argument to load into the event */ public <A, B, C> void publishEvent(final EventTranslatorThreeArg<T, A, B, C> eventTranslator, final A arg0, final B arg1, final C arg2) { ringBuffer.publishEvent(eventTranslator, arg0, arg1, arg2); }
@Override public void insert(RawMessage message) { ringBuffer.publishEvent(RawMessageEvent.TRANSLATOR, message); incomingMessages.mark(); }
/** * publish disruptor event. * * @param hmilyTransaction {@linkplain HmilyTransaction } * @param type {@linkplain EventTypeEnum} */ public void publishEvent(final HmilyTransaction hmilyTransaction, final int type) { final RingBuffer<HmilyTransactionEvent> ringBuffer = disruptor.getRingBuffer(); ringBuffer.publishEvent(new HmilyTransactionEventTranslator(type), hmilyTransaction); }
/** * publish disruptor event. * * @param mythTransaction {@linkplain MythTransaction } * @param type {@linkplain EventTypeEnum} */ public void publishEvent(final MythTransaction mythTransaction, final int type) { final RingBuffer<MythTransactionEvent> ringBuffer = disruptor.getRingBuffer(); ringBuffer.publishEvent(new MythTransactionEventTranslator(type), mythTransaction); }
@Test public void shouldPreventWrapping() throws Exception { Sequence sequence = new Sequence(Sequencer.INITIAL_CURSOR_VALUE); final RingBuffer<StubEvent> ringBuffer = createMultiProducer(StubEvent.EVENT_FACTORY, 4); ringBuffer.addGatingSequences(sequence); ringBuffer.publishEvent(StubEvent.TRANSLATOR, 0, "0"); ringBuffer.publishEvent(StubEvent.TRANSLATOR, 1, "1"); ringBuffer.publishEvent(StubEvent.TRANSLATOR, 2, "2"); ringBuffer.publishEvent(StubEvent.TRANSLATOR, 3, "3"); assertFalse(ringBuffer.tryPublishEvent(StubEvent.TRANSLATOR, 3, "3")); }
/** * publish disruptor event. * * @param transactionRecover {@linkplain TransactionRecover } * @param type {@linkplain CompensationActionEnum} */ public void publishEvent(final TransactionRecover transactionRecover, final int type) { if (txConfig.getCompensation()) { final RingBuffer<TxTransactionEvent> ringBuffer = disruptor.getRingBuffer(); ringBuffer.publishEvent(new TxTransactionEventTranslator(type), transactionRecover); } }
@Test public void shouldPublishEvent() { ringBuffer.addGatingSequences(new NoOpEventProcessor(ringBuffer).getSequence()); ringBuffer.publishEvent(this); ringBuffer.publishEvent(this); assertThat(Long.valueOf(ringBuffer.get(0).get()), is(Long.valueOf(0 + 29L))); assertThat(Long.valueOf(ringBuffer.get(1).get()), is(Long.valueOf(1 + 29L))); }
@Test public void shouldClaimAndGetInSeparateThread() throws Exception { Future<List<StubEvent>> messages = getMessages(0, 0); StubEvent expectedEvent = new StubEvent(2701); ringBuffer.publishEvent(StubEvent.TRANSLATOR, expectedEvent.getValue(), expectedEvent.getTestString()); assertEquals(expectedEvent, messages.get().get(0)); }
public static void main(String[] args) throws InterruptedException { Disruptor<ObjectBox> disruptor = new Disruptor<ObjectBox>( ObjectBox.FACTORY, RING_SIZE, DaemonThreadFactory.INSTANCE, ProducerType.MULTI, new BlockingWaitStrategy()); disruptor.handleEventsWith(new Consumer()).then(new Consumer()); final RingBuffer<ObjectBox> ringBuffer = disruptor.getRingBuffer(); Publisher p = new Publisher(); IMessage message = new IMessage(); ITransportable transportable = new ITransportable(); String streamName = "com.lmax.wibble"; System.out.println("publishing " + RING_SIZE + " messages"); for (int i = 0; i < RING_SIZE; i++) { ringBuffer.publishEvent(p, message, transportable, streamName); Thread.sleep(10); } System.out.println("start disruptor"); disruptor.start(); System.out.println("continue publishing"); while (true) { ringBuffer.publishEvent(p, message, transportable, streamName); Thread.sleep(10); } } }
@Test public void shouldPublishEventOneArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); ringBuffer.publishEvent(translator, "Foo"); ringBuffer.tryPublishEvent(translator, "Foo"); assertThat(ringBuffer, ringBufferWithEvents("Foo-0", "Foo-1")); }
@Test public void shouldPublishEventTwoArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorTwoArg<Object[], String, String> translator = new TwoArgEventTranslator(); ringBuffer.publishEvent(translator, "Foo", "Bar"); ringBuffer.tryPublishEvent(translator, "Foo", "Bar"); assertThat(ringBuffer, ringBufferWithEvents("FooBar-0", "FooBar-1")); }
@Test public void shouldPublishEvent() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); final EventTranslator<Object[]> translator = new NoArgEventTranslator(); ringBuffer.publishEvent(translator); ringBuffer.tryPublishEvent(translator); assertThat(ringBuffer, ringBufferWithEvents(0L, 1L)); }
@Test public void shouldPublishEventThreeArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorThreeArg<Object[], String, String, String> translator = new ThreeArgEventTranslator(); ringBuffer.publishEvent(translator, "Foo", "Bar", "Baz"); ringBuffer.tryPublishEvent(translator, "Foo", "Bar", "Baz"); assertThat(ringBuffer, ringBufferWithEvents("FooBarBaz-0", "FooBarBaz-1")); }
@Test public void shouldPublishEventVarArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorVararg<Object[]> translator = new VarArgEventTranslator(); ringBuffer.publishEvent(translator, "Foo", "Bar", "Baz", "Bam"); ringBuffer.tryPublishEvent(translator, "Foo", "Bar", "Baz", "Bam"); assertThat(ringBuffer, ringBufferWithEvents("FooBarBazBam-0", "FooBarBazBam-1")); }
@Test public void shouldClaimAndGetMultipleMessages() throws Exception { int numMessages = ringBuffer.getBufferSize(); for (int i = 0; i < numMessages; i++) { ringBuffer.publishEvent(StubEvent.TRANSLATOR, i, ""); } long expectedSequence = numMessages - 1; long available = sequenceBarrier.waitFor(expectedSequence); assertEquals(expectedSequence, available); for (int i = 0; i < numMessages; i++) { assertEquals(i, ringBuffer.get(i).getValue()); } }
@Test public void shouldWrap() throws Exception { int numMessages = ringBuffer.getBufferSize(); int offset = 1000; for (int i = 0; i < numMessages + offset; i++) { ringBuffer.publishEvent(StubEvent.TRANSLATOR, i, ""); } long expectedSequence = numMessages + offset - 1; long available = sequenceBarrier.waitFor(expectedSequence); assertEquals(expectedSequence, available); for (int i = offset; i < numMessages + offset; i++) { assertEquals(i, ringBuffer.get(i).getValue()); } }
@Test public void shouldClaimAndGet() throws Exception { assertEquals(SingleProducerSequencer.INITIAL_CURSOR_VALUE, ringBuffer.getCursor()); StubEvent expectedEvent = new StubEvent(2701); ringBuffer.publishEvent(StubEvent.TRANSLATOR, expectedEvent.getValue(), expectedEvent.getTestString()); long sequence = sequenceBarrier.waitFor(0); assertEquals(0, sequence); StubEvent event = ringBuffer.get(sequence); assertEquals(expectedEvent, event); assertEquals(0L, ringBuffer.getCursor()); }