/** * Convert a plain {@link EventMessage} to a {@link DomainEventMessage}. If the message already is a {@link * DomainEventMessage} it will be returned as is. Otherwise a new {@link GenericDomainEventMessage} is made with * {@code null} type, aggegrateIdentifier equal to messageIdentifier and sequence number of 0L. * * @param eventMessage the input event message * @param <T> The type of payload in the message * @return the message converted to a domain event message */ public static <T> DomainEventMessage<T> asDomainEventMessage(EventMessage<T> eventMessage) { if (eventMessage instanceof DomainEventMessage<?>) { return (DomainEventMessage<T>) eventMessage; } return new GenericDomainEventMessage<>(null, eventMessage.getIdentifier(), 0L, eventMessage, eventMessage::getTimestamp); }
@Override public void onError(Exception exception, EventMessage<?> event, EventMessageHandler eventHandler) { logger.error("EventListener [{}] failed to handle event [{}] ({}). " + "Continuing processing with next listener", eventHandler.getTargetType().getSimpleName(), event.getIdentifier(), event.getPayloadType().getName(), exception); } }
@Override public <T> Message<T> convertToOutboundMessage(EventMessage<T> event) { Map<String, Object> headers = new HashMap<>(); event.getMetaData().forEach(headers::put); headers.put(MESSAGE_ID, event.getIdentifier()); if (event instanceof DomainEventMessage) { headers.put(AGGREGATE_ID, ((DomainEventMessage) event).getAggregateIdentifier()); headers.put(AGGREGATE_SEQ, ((DomainEventMessage) event).getSequenceNumber()); headers.put(AGGREGATE_TYPE, ((DomainEventMessage) event).getType()); } return new GenericMessage<>(event.getPayload(), new SettableTimestampMessageHeaders(headers, event.getTimestamp().toEpochMilli())); }
@Override public JobDataMap toJobData(Object event) { JobDataMap jobData = new JobDataMap(); EventMessage eventMessage = (EventMessage) event; jobData.put(MESSAGE_ID, eventMessage.getIdentifier()); jobData.put(MESSAGE_TIMESTAMP, eventMessage.getTimestamp().toEpochMilli()); SerializedObject<byte[]> serializedPayload = serializer.serialize(eventMessage.getPayload(), byte[].class); jobData.put(SERIALIZED_MESSAGE_PAYLOAD, serializedPayload.getData()); jobData.put(MESSAGE_TYPE, serializedPayload.getType().getName()); jobData.put(MESSAGE_REVISION, serializedPayload.getType().getRevision()); SerializedObject<byte[]> serializedMetaData = serializer.serialize(eventMessage.getMetaData(), byte[].class); jobData.put(MESSAGE_METADATA, serializedMetaData.getData()); return jobData; }
/** * Invoke when an Exception is raised while persisting an Event or Snapshot. * * @param exception The exception raised while persisting an Event * @param failedEvent The EventMessage that could not be persisted */ protected void handlePersistenceException(Exception exception, EventMessage<?> failedEvent) { String eventDescription; if (failedEvent instanceof DomainEventMessage<?>) { DomainEventMessage<?> failedDomainEvent = (DomainEventMessage<?>) failedEvent; eventDescription = format("An event for aggregate [%s] at sequence [%d]", failedDomainEvent.getAggregateIdentifier(), failedDomainEvent.getSequenceNumber()); } else { eventDescription = format("An event with identifier [%s]", failedEvent.getIdentifier()); } if (persistenceExceptionResolver != null && persistenceExceptionResolver.isDuplicateKeyViolation(exception)) { throw new ConcurrencyException(eventDescription + " was already inserted", exception); } else { throw new EventStoreException(eventDescription + " could not be persisted", exception); } }
/** * Generate defaults headers to recognise an event message. * * @param message event message. * @param serializedObject payload. * @return headers */ public static Map<String, Object> defaultHeaders(EventMessage<?> message, SerializedObject<?> serializedObject) { Assert.notNull(message, () -> "Event message cannot be null"); Assert.notNull(serializedObject, () -> "Serialized Object cannot be null"); Assert.notNull(serializedObject.getType(), () -> "SerializedObject Type cannot be null"); HashMap<String, Object> headers = new HashMap<>(); headers.put(MESSAGE_ID, message.getIdentifier()); headers.put(MESSAGE_TYPE, serializedObject.getType().getName()); headers.put(MESSAGE_REVISION, serializedObject.getType().getRevision()); headers.put(MESSAGE_TIMESTAMP, message.getTimestamp()); if (message instanceof DomainEventMessage) { headers.put(AGGREGATE_ID, ((DomainEventMessage<?>) message).getAggregateIdentifier()); headers.put(AGGREGATE_SEQ, ((DomainEventMessage<?>) message).getSequenceNumber()); headers.put(AGGREGATE_TYPE, ((DomainEventMessage<?>) message).getType()); } return Collections.unmodifiableMap(headers); }
private EventMessage<Object> timeCorrectedEventMessage(Object event) { EventMessage<?> msg = GenericEventMessage.asEventMessage(event); return new GenericEventMessage<>(msg.getIdentifier(), msg.getPayload(), msg.getMetaData(), currentTime()); }
@Override public ScheduleToken schedule(Instant triggerDateTime, Object event) { Assert.state(initialized, () -> "Scheduler is not yet initialized"); EventMessage eventMessage = GenericEventMessage.asEventMessage(event); String jobIdentifier = JOB_NAME_PREFIX + eventMessage.getIdentifier(); QuartzScheduleToken tr = new QuartzScheduleToken(jobIdentifier, groupIdentifier); try { JobDetail jobDetail = buildJobDetail(eventMessage, new JobKey(jobIdentifier, groupIdentifier)); scheduler.scheduleJob(jobDetail, buildTrigger(triggerDateTime, jobDetail.getKey())); } catch (SchedulerException e) { throw new SchedulingException("An error occurred while setting a timer for a saga", e); } return tr; }
@Test public void testResetBeforeStartingPerformsANormalRun() throws Exception { when(mockHandler.supportsReset()).thenReturn(true); final List<String> handled = new CopyOnWriteArrayList<>(); final List<String> handledInRedelivery = new CopyOnWriteArrayList<>(); //noinspection Duplicates doAnswer(i -> { EventMessage message = i.getArgument(0); handled.add(message.getIdentifier()); if (ReplayToken.isReplay(message)) { handledInRedelivery.add(message.getIdentifier()); } return null; }).when(mockHandler).handle(any()); testSubject.start(); testSubject.shutDown(); testSubject.resetTokens(); testSubject.start(); eventBus.publish(createEvents(4)); assertWithin(1, TimeUnit.SECONDS, () -> assertEquals(4, handled.size())); assertEquals(0, handledInRedelivery.size()); assertFalse(testSubject.processingStatus().get(0).isReplaying()); }
@Test public void testResetToPositionCausesCertainEventsToBeReplayed() throws Exception { when(mockHandler.supportsReset()).thenReturn(true); final List<String> handled = new CopyOnWriteArrayList<>(); final List<String> handledInRedelivery = new CopyOnWriteArrayList<>(); //noinspection Duplicates doAnswer(i -> { EventMessage message = i.getArgument(0); handled.add(message.getIdentifier()); if (ReplayToken.isReplay(message)) { handledInRedelivery.add(message.getIdentifier()); } return null; }).when(mockHandler).handle(any()); eventBus.publish(createEvents(4)); testSubject.start(); assertWithin(1, TimeUnit.SECONDS, () -> assertEquals(4, handled.size())); testSubject.shutDown(); testSubject.resetTokens(source -> new GlobalSequenceTrackingToken(1L)); testSubject.start(); assertWithin(1, TimeUnit.SECONDS, () -> assertEquals(6, handled.size())); assertFalse(handledInRedelivery.contains(handled.get(0))); assertFalse(handledInRedelivery.contains(handled.get(1))); assertEquals(handled.subList(2, 4), handled.subList(4, 6)); assertEquals(handled.subList(4, 6), handledInRedelivery); assertTrue(testSubject.processingStatus().get(0).isReplaying()); eventBus.publish(createEvents(1)); assertWithin(1, TimeUnit.SECONDS, () -> assertFalse(testSubject.processingStatus().get(0).isReplaying())); }
@Test public void testResetCausesEventsToBeReplayed() throws Exception { when(mockHandler.supportsReset()).thenReturn(true); final List<String> handled = new CopyOnWriteArrayList<>(); final List<String> handledInRedelivery = new CopyOnWriteArrayList<>(); //noinspection Duplicates doAnswer(i -> { EventMessage message = i.getArgument(0); handled.add(message.getIdentifier()); if (ReplayToken.isReplay(message)) { handledInRedelivery.add(message.getIdentifier()); } return null; }).when(mockHandler).handle(any()); eventBus.publish(createEvents(4)); testSubject.start(); assertWithin(1, TimeUnit.SECONDS, () -> assertEquals(4, handled.size())); testSubject.shutDown(); testSubject.resetTokens(); // Resetting twice caused problems (see issue #559) testSubject.resetTokens(); testSubject.start(); assertWithin(1, TimeUnit.SECONDS, () -> assertEquals(8, handled.size())); assertEquals(handled.subList(0, 4), handled.subList(4, 8)); assertEquals(handled.subList(4, 8), handledInRedelivery); assertTrue(testSubject.processingStatus().get(0).isReplaying()); eventBus.publish(createEvents(1)); assertWithin(1, TimeUnit.SECONDS, () -> assertFalse(testSubject.processingStatus().get(0).isReplaying())); }
@Before public void setUp() { tokenStore = spy(new InMemoryTokenStore()); mockHandler = mock(EventMessageHandler.class); when(mockHandler.canHandle(any())).thenReturn(true); eventHandlerInvoker = SimpleEventHandlerInvoker.builder() .eventHandlers(singletonList(mockHandler)) .sequencingPolicy(event -> { if (event instanceof DomainEventMessage) { return ((DomainEventMessage) event) .getSequenceNumber(); } return event.getIdentifier(); }) .build(); eventBus = EmbeddedEventStore.builder().storageEngine(new InMemoryEventStorageEngine()).build(); // A processor config, with a policy which guarantees segmenting by using the sequence number. configureProcessor(TrackingEventProcessorConfiguration.forParallelProcessing(2)); }
/** * Construct a new event entry from a published event message to enable storing the event or sending it to a remote * location. * <p> * The given {@code serializer} will be used to serialize the payload and metadata in the given {@code eventMessage}. * The type of the serialized data will be the same as the given {@code contentType}. * * @param eventMessage The event message to convert to a serialized event entry * @param serializer The serializer to convert the event * @param contentType The data type of the payload and metadata after serialization */ public AbstractEventEntry(EventMessage<?> eventMessage, Serializer serializer, Class<T> contentType) { SerializedObject<T> payload = eventMessage.serializePayload(serializer, contentType); SerializedObject<T> metaData = eventMessage.serializeMetaData(serializer, contentType); this.eventIdentifier = eventMessage.getIdentifier(); this.payloadType = payload.getType().getName(); this.payloadRevision = payload.getType().getRevision(); this.payload = payload.getData(); this.metaData = metaData.getData(); this.timeStamp = formatInstant(eventMessage.getTimestamp()); }
handled.add(message.getIdentifier()); if (ReplayToken.isReplay(message)) { handledInRedelivery.add(message.getIdentifier());
.eventHandlers( (EventMessageHandler) eventHandler -> { if (readEvents.add(eventHandler.getIdentifier())) { remainingEvents.countDown(); } else {
public Event map(EventMessage<?> eventMessage, Serializer serializer) { Event.Builder builder = Event.newBuilder(); if (eventMessage instanceof GenericDomainEventMessage) { builder.setAggregateIdentifier(((GenericDomainEventMessage) eventMessage).getAggregateIdentifier()) .setAggregateSequenceNumber(((GenericDomainEventMessage) eventMessage).getSequenceNumber()) .setAggregateType(((GenericDomainEventMessage) eventMessage).getType()); } SerializedObject<byte[]> serializedPayload = eventMessage.serializePayload(serializer, byte[].class); builder.setMessageIdentifier(eventMessage.getIdentifier()).setPayload( io.axoniq.axonserver.grpc.SerializedObject.newBuilder() .setType(serializedPayload.getType().getName()) .setRevision(getOrDefault( serializedPayload.getType().getRevision(), "" )) .setData(ByteString.copyFrom(serializedPayload.getData())) ).setTimestamp(eventMessage.getTimestamp().toEpochMilli()); eventMessage.getMetaData().forEach((k, v) -> builder.putMetaData(k, converter.convertToMetaDataValue(v))); return builder.build(); }
@Override public void onError(Exception exception, EventMessage<?> event, EventListener eventListener) { Class<?> eventListenerType = getEventListenerType(eventListener); logger.error("EventListener [{}] failed to handle event [{}] ({}). " + "Continuing processing with next listener", eventListenerType.getSimpleName(), event.getIdentifier(), event.getPayloadType().getName(), exception); }
@Override public void onError(Exception exception, EventMessage<?> event, EventMessageHandler eventHandler) { logger.error("EventListener [{}] failed to handle event [{}] ({}). " + "Continuing processing with next listener", eventHandler.getTargetType().getSimpleName(), event.getIdentifier(), event.getPayloadType().getName(), exception); } }
@Override public ScheduleToken schedule(Instant triggerDateTime, Object event) { Assert.state(initialized, () -> "Scheduler is not yet initialized"); EventMessage eventMessage = GenericEventMessage.asEventMessage(event); String jobIdentifier = JOB_NAME_PREFIX + eventMessage.getIdentifier(); QuartzScheduleToken tr = new QuartzScheduleToken(jobIdentifier, groupIdentifier); try { JobDetail jobDetail = buildJobDetail(eventMessage, new JobKey(jobIdentifier, groupIdentifier)); scheduler.scheduleJob(jobDetail, buildTrigger(triggerDateTime, jobDetail.getKey())); } catch (SchedulerException e) { throw new SchedulingException("An error occurred while setting a timer for a saga", e); } return tr; }
@Override public ScheduleToken schedule(Instant triggerDateTime, Object event) { Assert.state(initialized, () -> "Scheduler is not yet initialized"); EventMessage eventMessage = GenericEventMessage.asEventMessage(event); String jobIdentifier = JOB_NAME_PREFIX + eventMessage.getIdentifier(); QuartzScheduleToken tr = new QuartzScheduleToken(jobIdentifier, groupIdentifier); try { JobDetail jobDetail = buildJobDetail(eventMessage, new JobKey(jobIdentifier, groupIdentifier)); scheduler.scheduleJob(jobDetail, buildTrigger(triggerDateTime, jobDetail.getKey())); } catch (SchedulerException e) { throw new SchedulingException("An error occurred while setting a timer for a saga", e); } return tr; }