@Override public void prepareReset() { try { handle(GenericEventMessage.asEventMessage(new ResetTriggeredEvent())); } catch (Exception e) { throw new ResetNotSupportedException("An Error occurred while notifying handlers of the reset", e); } }
/** * Indicates whether the given message is "redelivered", as a result of a previous reset. If {@code true}, this * means this message has been delivered to this processor before its token was reset. * * @param message The message to inspect * @return {@code true} if the message is a replay */ public static boolean isReplay(Message<?> message) { return message instanceof TrackedEventMessage && isReplay(((TrackedEventMessage) message).trackingToken()); }
@SuppressWarnings("unchecked") public <T> TrackedEventMessage<T> alterToken(TrackedEventMessage<T> message) { if (lastToken == null) { return message; } if (message instanceof DomainEventMessage) { return new GenericTrackedDomainEventMessage<>(lastToken.advancedTo(message.trackingToken()), (DomainEventMessage<T>) message); } else { return new GenericTrackedEventMessage<>(lastToken.advancedTo(message.trackingToken()), message); } } }
@EventHandler protected void handle(EventMessage event) { identifier = ((DomainEventMessage) event).getAggregateIdentifier(); }
/** * Initialize a DomainEventMessage originating from an aggregate. * * @param trackingToken Tracking token of the event * @param delegate Delegate domain event containing other event data */ public GenericTrackedDomainEventMessage(TrackingToken trackingToken, DomainEventMessage<T> delegate) { this(trackingToken, delegate.getType(), delegate.getAggregateIdentifier(), delegate.getSequenceNumber(), delegate, delegate.getTimestamp()); }
@Before public void setUp() { SimpleEventHandlerInvoker eventHandlerInvoker = SimpleEventHandlerInvoker.builder() .eventHandlers(this) .build(); eventProcessor = SubscribingEventProcessor.builder() .name("test") .eventHandlerInvoker(eventHandlerInvoker) .messageSource(eventBus) .build(); eventProcessor.start(); }
private void configureProcessor(TrackingEventProcessorConfiguration processorConfiguration) { testSubject = TrackingEventProcessor.builder() .name("test") .eventHandlerInvoker(eventHandlerInvoker) .messageSource(eventBus) .tokenStore(tokenStore) .transactionManager(NoTransactionManager.INSTANCE) .trackingEventProcessorConfiguration(processorConfiguration) .build(); }
@Override public Instant resolveParameterValue(Message message) { if (message instanceof EventMessage) { return ((EventMessage) message).getTimestamp(); } return null; }
@Override public TrackingToken resolveParameterValue(Message<?> message) { return unwrap(((TrackedEventMessage) message).trackingToken()); }
/** * Indicates whether this tracking processor supports a "reset". Generally, a reset is supported if at least one * of the event handlers assigned to this processor supports it, and no handlers explicitly prevent the resets. * * @return {@code true} if resets are supported, {@code false} otherwise */ public boolean supportsReset() { return eventHandlerInvoker().supportsReset(); }
@Override public boolean supportsReset() { for (EventMessageHandler eventHandler : wrappedEventHandlers) { if (!eventHandler.supportsReset()) { return false; } } return true; }
/** * Initializes a {@link TrackingEventProcessor} as specified through this Builder. * * @return a {@link TrackingEventProcessor} as specified through this Builder */ public TrackingEventProcessor build() { return new TrackingEventProcessor(this); }
/** * Instantiate an {@link AbstractEventBus} based on the fields contained in the {@link Builder}. * * @param builder the {@link Builder} used to instantiate an {@link AbstractEventBus} instance */ protected AbstractEventBus(Builder builder) { builder.validate(); this.messageMonitor = builder.messageMonitor; }
/** * {@inheritDoc}. Defaults to a {@link RollbackConfigurationType#ANY_THROWABLE}) */ @Override public Builder rollbackConfiguration(RollbackConfiguration rollbackConfiguration) { super.rollbackConfiguration(rollbackConfiguration); return this; }
@Override public Builder name(String name) { super.name(name); return this; }
@Override public Builder eventHandlerInvoker(EventHandlerInvoker eventHandlerInvoker) { super.eventHandlerInvoker(eventHandlerInvoker); return this; }
@Override public Builder errorHandler(ErrorHandler errorHandler) { super.errorHandler(errorHandler); return this; }
/** * Instantiate a Builder to be able to create a {@link SimpleEventBus}. * <p> * The {@link MessageMonitor} is defaulted to a {@link NoOpMessageMonitor} and the {@code queueCapacity} to * {@link Integer#MAX_VALUE}. * * @return a Builder to be able to create a {@link SimpleEventBus} */ public static Builder builder() { return new Builder(); }