├── .circleci └── config.yml ├── .gitignore ├── LICENSE.md ├── README.adoc ├── ReliablePublication.png ├── _build-and-test-all.sh ├── activemq ├── Dockerfile └── activemq.xml ├── build-and-test-all-mssql-polling-activemq.sh ├── build-and-test-all-mysql-binlog-kafka.sh ├── build-and-test-all-mysql-binlog-redis.sh ├── build-and-test-all-mysql-kafka-spring-boot-3.sh ├── build-and-test-all-postgres-wal-rabbitmq.sh ├── build-and-test-everything.sh ├── build.gradle ├── deploy-artifacts.sh ├── docker-compose-mssql-polling-activemq.yml ├── docker-compose-mysql-binlog-kafka.yml ├── docker-compose-mysql-binlog-redis.yml ├── docker-compose-postgres-wal-rabbitmq.yml ├── docker-compose-zipkin.yml ├── eventuate-tram-aggregate-domain-events ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── events │ └── aggregates │ ├── AbstractAggregateDomainEventPublisher.java │ └── ResultWithDomainEvents.java ├── eventuate-tram-commands-db-broker-integration-test ├── build.gradle └── src │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── commands │ │ └── db │ │ └── broker │ │ └── integrationtests │ │ ├── AbstractTramCommandsDBBrokerIntegrationTest.java │ │ ├── MyReplyConsumer.java │ │ ├── MyTestCommand.java │ │ ├── MyTestCommandHandler.java │ │ ├── MyTestCommandJSonTest.java │ │ ├── TramCommandsDBBrokerIntegrationCustomDBTest.java │ │ ├── TramCommandsDBBrokerIntegrationData.java │ │ ├── TramCommandsDBBrokerIntegrationTest.java │ │ └── TramCommandsDBBrokerIntegrationTestConfiguration.java │ └── resources │ ├── application-mssql.properties │ ├── application-postgres.properties │ ├── application.properties │ ├── custom-db-mysql-schema.sql │ └── customdb.properties ├── eventuate-tram-commands ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── commands │ │ ├── CommandDestination.java │ │ ├── common │ │ ├── Command.java │ │ ├── CommandMessageHeaders.java │ │ ├── CommandNameMapping.java │ │ ├── CommandReplyOutcome.java │ │ ├── DefaultCommandNameMapping.java │ │ ├── Failure.java │ │ ├── Outcome.java │ │ ├── ReplyMessageHeaders.java │ │ ├── Success.java │ │ └── paths │ │ │ ├── PlaceholderValueMapProvider.java │ │ │ ├── PlaceholderValueProvider.java │ │ │ ├── ResourcePath.java │ │ │ ├── ResourcePathPattern.java │ │ │ └── SingleValuePlaceholderValueProvider.java │ │ ├── consumer │ │ ├── AbstractCommandHandler.java │ │ ├── CommandDispatcher.java │ │ ├── CommandDispatcherFactory.java │ │ ├── CommandExceptionHandler.java │ │ ├── CommandHandler.java │ │ ├── CommandHandlerArgs.java │ │ ├── CommandHandlerParams.java │ │ ├── CommandHandlerReplyBuilder.java │ │ ├── CommandHandlers.java │ │ ├── CommandHandlersBuilder.java │ │ ├── CommandMessage.java │ │ ├── CommandReplyProducer.java │ │ ├── CommandReplyToken.java │ │ ├── CommandWithDestination.java │ │ ├── CommandWithDestinationBuilder.java │ │ ├── DestinationForExceptionRootObject.java │ │ ├── DestinationRootObject.java │ │ ├── DestinationRootObjectForException.java │ │ ├── PathVariable.java │ │ ├── PathVariables.java │ │ ├── ReplyDestination.java │ │ └── annotations │ │ │ ├── EventuateCommandHandler.java │ │ │ ├── FailureReply.java │ │ │ └── SuccessReply.java │ │ └── producer │ │ ├── CommandMessageFactory.java │ │ ├── CommandProducer.java │ │ └── CommandProducerImpl.java │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── commands │ │ ├── AbstractCommandDispatchingTests.java │ │ ├── CommandDispatchingTests.java │ │ ├── InMemoryCommands.java │ │ ├── NotificationTests.java │ │ ├── common │ │ └── paths │ │ │ └── ResourcePathPatternTest.java │ │ └── consumer │ │ ├── CommandDispatcherTest.java │ │ └── CommandReplyTokenSerdeTest.java │ └── resources │ └── application.properties ├── eventuate-tram-common-spring-in-memory ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── common │ └── spring │ └── inmemory │ └── EventuateSpringTransactionSynchronizationManager.java ├── eventuate-tram-common ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── common │ │ └── TypeParameterExtractor.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── common │ └── test │ └── TypeParameterExtractorTest.java ├── eventuate-tram-consumer-activemq ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── consumer │ └── activemq │ ├── EventuateTramActiveMQMessageConsumer.java │ └── EventuateTramActiveMQMessageConsumerConfiguration.java ├── eventuate-tram-consumer-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── consumer │ └── common │ ├── DecoratedMessageHandlerFactory.java │ ├── DuplicateDetectingMessageHandlerDecorator.java │ ├── DuplicateMessageDetector.java │ ├── MessageConsumerImpl.java │ ├── MessageConsumerImplementation.java │ ├── MessageHandlerDecorator.java │ ├── MessageHandlerDecoratorChain.java │ ├── MessageHandlerDecoratorChainBuilder.java │ ├── NoopDuplicateMessageDetector.java │ ├── PrePostHandlerMessageHandlerDecorator.java │ └── PrePostReceiveMessageHandlerDecorator.java ├── eventuate-tram-consumer-jdbc ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── consumer │ └── jdbc │ ├── SqlTableBasedDuplicateMessageDetector.java │ └── TransactionalNoopDuplicateMessageDetector.java ├── eventuate-tram-consumer-kafka ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── consumer │ └── kafka │ └── EventuateTramKafkaMessageConsumer.java ├── eventuate-tram-consumer-rabbitmq ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── consumer │ └── rabbitmq │ ├── EventuateTramRabbitMQMessageConsumer.java │ └── EventuateTramRabbitMQMessageConsumerConfiguration.java ├── eventuate-tram-consumer-redis ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── consumer │ └── redis │ ├── EventuateTramRedisMessageConsumer.java │ └── EventuateTramRedisMessageConsumerConfiguration.java ├── eventuate-tram-db-broker-integration-test ├── build.gradle └── src │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── broker │ │ └── db │ │ └── integrationtests │ │ ├── AbstractTramIntegrationTest.java │ │ ├── MultipleOutboxTramIntegrationTest.java │ │ ├── TramChannelMappingIntegrationTest.java │ │ ├── TramIntegrationCustomDBTest.java │ │ ├── TramIntegrationTest.java │ │ ├── TramIntegrationTestConfiguration.java │ │ └── TramMessageHandlerExceptionHandlingIntegrationTest.java │ └── resources │ ├── application-mssql.properties │ ├── application-postgres.properties │ ├── application.properties │ ├── custom-db-mysql-schema.sql │ └── customdb.properties ├── eventuate-tram-events ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── events │ │ ├── common │ │ ├── DefaultDomainEventNameMapping.java │ │ ├── DomainEvent.java │ │ ├── DomainEventNameMapping.java │ │ ├── EventMessageHeaders.java │ │ └── EventUtil.java │ │ ├── publisher │ │ ├── AbstractDomainEventPublisherForAggregateImpl.java │ │ ├── DomainEventPublisher.java │ │ ├── DomainEventPublisherForAggregate.java │ │ ├── DomainEventPublisherImpl.java │ │ ├── ResultWithEvents.java │ │ └── ResultWithTypedEvents.java │ │ └── subscriber │ │ ├── DomainEventDispatcher.java │ │ ├── DomainEventDispatcherFactory.java │ │ ├── DomainEventEnvelope.java │ │ ├── DomainEventEnvelopeImpl.java │ │ ├── DomainEventHandler.java │ │ ├── DomainEventHandlers.java │ │ ├── DomainEventHandlersBuilder.java │ │ └── annotations │ │ └── EventuateDomainEventHandler.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── events │ ├── ExampleDomainEvent.java │ ├── ExampleDomainEventConsumer.java │ ├── MyEventHandler.java │ └── subscriber │ └── DomainEventDispatcherTest.java ├── eventuate-tram-in-memory-test ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── inmemory │ └── test │ └── AbstractInMemoryMessageProducerTest.java ├── eventuate-tram-in-memory ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── inmemory │ │ ├── EventuateTransactionSynchronizationManager.java │ │ ├── InMemoryMessageConsumer.java │ │ ├── InMemoryMessageProducer.java │ │ ├── InMemoryMessaging.java │ │ └── MessageHandlerWithSubscriberId.java │ └── resources │ └── eventuate-tram-embedded-schema.sql ├── eventuate-tram-integration-test-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── integrationtest │ └── common │ ├── MySqlBinlogKafkaCondition.java │ ├── MySqlBinlogRedisCondition.java │ ├── PollingActiveMQCondition.java │ ├── PostgresWalRabbitMQCondition.java │ ├── TramIntegrationTestMySqlBinlogKafkaConfiguration.java │ ├── TramIntegrationTestMySqlBinlogRedisConfiguration.java │ ├── TramIntegrationTestPollingActiveMQConfiguration.java │ └── TramIntegrationTestPostgresWalRabbitMQConfiguration.java ├── eventuate-tram-jdbc-activemq ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── jdbcactivemq │ └── TramJdbcActiveMQConfiguration.java ├── eventuate-tram-jdbc-rabbitmq ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── jdbcrabbitmq │ └── TramJdbcRabbitMQConfiguration.java ├── eventuate-tram-jdbc-redis ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── jdbcredis │ └── TramJdbcRedisConfiguration.java ├── eventuate-tram-messaging-producer-common ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── messaging │ │ └── producer │ │ └── common │ │ ├── MessageProducerImpl.java │ │ └── MessageProducerImplementation.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── messaging │ └── producer │ └── common │ ├── HttpDateHeaderFormatUtilTest.java │ └── MessageProducerImplTest.java ├── eventuate-tram-messaging ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── messaging │ ├── common │ ├── ChannelMapping.java │ ├── DefaultChannelMapping.java │ ├── Message.java │ ├── MessageImpl.java │ ├── MessageInterceptor.java │ └── SubscriberIdAndMessage.java │ ├── consumer │ ├── BuiltInMessageHandlerDecoratorOrder.java │ ├── DefaultSubscriberMapping.java │ ├── MessageConsumer.java │ ├── MessageHandler.java │ ├── MessageSubscription.java │ └── SubscriberMapping.java │ └── producer │ ├── HttpDateHeaderFormatUtil.java │ ├── MessageBuilder.java │ └── MessageProducer.java ├── eventuate-tram-micronaut-commands ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── micronaut │ │ └── commands │ │ ├── CommandDispatcherInitializer.java │ │ ├── common │ │ └── TramCommandCommonFactory.java │ │ ├── consumer │ │ └── TramCommandConsumerFactory.java │ │ └── producer │ │ └── TramCommandProducerFactory.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── micronaut │ └── commands │ └── common │ └── TramCommandCommonFactoryTest.java ├── eventuate-tram-micronaut-consumer-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── micronaut │ └── consumer │ └── common │ ├── TramConsumerBaseCommonFactory.java │ ├── TramConsumerCommonFactory.java │ └── TramNoopDuplicateMessageDetectorFactory.java ├── eventuate-tram-micronaut-consumer-jdbc ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── micronaut │ │ └── consumer │ │ └── jdbc │ │ ├── TramConsumerJdbcFactory.java │ │ └── TransactionalNoopDuplicateMessageDetectorFactory.java │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── micronaut │ │ └── consumer │ │ └── jdbc │ │ └── EventuateMicronautSqlTableBasedDuplicateMessageDetectorTest.java │ └── resources │ ├── application-mssql.yml │ ├── application-postgres.yml │ └── application.yml ├── eventuate-tram-micronaut-consumer-kafka ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── micronaut │ └── consumer │ └── kafka │ └── EventuateTramKafkaMessageConsumerFactory.java ├── eventuate-tram-micronaut-data-jdbc-optimistic-locking ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── micronaut │ │ └── data │ │ └── jdbc │ │ └── optimistic │ │ └── locking │ │ └── OptimisticLockingDecorator.java │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── micronaut │ │ └── data │ │ └── jdbc │ │ └── optimistic │ │ └── locking │ │ ├── AbstractEventuateMicronautOptimisticLockingTest.java │ │ ├── EventuateMicronautOptimisticLockingWithAnnotationTransactionTest.java │ │ ├── EventuateMicronautOptimisticLockingWithTransactionTemplateTransactionTest.java │ │ ├── TestEntityRepositoryImpl.java │ │ ├── TestEntityServiceTransactionAnnotation.java │ │ └── TestEntityServiceTransactionTemplate.java │ └── resources │ ├── application-mssql.yml │ ├── application-postgres.yml │ └── application.yml ├── eventuate-tram-micronaut-events ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── micronaut │ └── events │ ├── common │ └── TramEventsCommonFactory.java │ ├── publisher │ └── TramEventsPublisherFactory.java │ └── subscriber │ ├── DomainEventDispatcherInitializer.java │ └── TramEventSubscriberFactory.java ├── eventuate-tram-micronaut-in-memory ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── micronaut │ │ └── inmemory │ │ ├── EventuateMicronautTransactionSynchronizationManager.java │ │ └── TramInMemoryFactory.java │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── micronaut │ │ └── inmemory │ │ └── InMemoryMessageProducerTest.java │ └── resources │ └── application.yml ├── eventuate-tram-micronaut-jdbc-kafka └── build.gradle ├── eventuate-tram-micronaut-messaging-producer-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── micronaut │ └── messaging │ └── producer │ └── common │ └── TramMessagingCommonProducerFactory.java ├── eventuate-tram-micronaut-messaging ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── micronaut │ └── messaging │ └── common │ └── TramMessagingCommonFactory.java ├── eventuate-tram-micronaut-producer-jdbc ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── micronaut │ └── messaging │ └── producer │ └── jdbc │ └── TramMessageProducerJdbcFactory.java ├── eventuate-tram-optimistic-locking-common-test ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── jdbc │ └── optimistic │ └── locking │ └── common │ └── test │ ├── AbstractEventuateOptimisticLockingTest.java │ ├── AbstractTestEntityService.java │ ├── AbstractTestEntityServiceTransactionTemplate.java │ ├── TestEntity.java │ └── TestEntityRepository.java ├── eventuate-tram-producer-jdbc ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── messaging │ └── producer │ └── jdbc │ └── MessageProducerJdbcImpl.java ├── eventuate-tram-reactive-commands ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── reactive │ │ └── commands │ │ ├── consumer │ │ ├── ReactiveCommandDispatcher.java │ │ ├── ReactiveCommandDispatcherFactory.java │ │ ├── ReactiveCommandExceptionHandler.java │ │ ├── ReactiveCommandHandler.java │ │ ├── ReactiveCommandHandlerReplyBuilder.java │ │ ├── ReactiveCommandHandlers.java │ │ ├── ReactiveCommandHandlersBuilder.java │ │ └── ReactiveCommandReplyProducer.java │ │ └── producer │ │ ├── ReactiveCommandProducer.java │ │ └── ReactiveCommandProducerImpl.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── reactive │ └── commands │ ├── ReactiveAbstractCommandDispatchingTests.java │ ├── ReactiveCommandDispatchingTests.java │ ├── ReactiveNotificationTests.java │ ├── ReactiveTestMessageConsumer.java │ └── consumer │ └── ReactiveCommandDispatcherTest.java ├── eventuate-tram-reactive-consumer-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── consumer │ └── common │ └── reactive │ ├── DecoratedReactiveMessageHandlerFactory.java │ ├── ReactiveDuplicateDetectingMessageHandlerDecorator.java │ ├── ReactiveDuplicateMessageDetector.java │ ├── ReactiveMessageConsumer.java │ ├── ReactiveMessageConsumerImpl.java │ ├── ReactiveMessageConsumerImplementation.java │ ├── ReactiveMessageHandler.java │ ├── ReactiveMessageHandlerDecorator.java │ ├── ReactiveMessageHandlerDecoratorChain.java │ └── ReactiveNoopDuplicateMessageDetector.java ├── eventuate-tram-reactive-consumer-jdbc ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── reactive │ └── consumer │ └── jdbc │ ├── ReactiveSqlTableBasedDuplicateMessageDetector.java │ └── ReactiveTransactionalNoopDuplicateMessageDetector.java ├── eventuate-tram-reactive-consumer-kafka ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── reactive │ └── consumer │ └── kafka │ └── EventuateTramReactiveKafkaMessageConsumer.java ├── eventuate-tram-reactive-events ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── reactive │ └── events │ └── subscriber │ ├── ReactiveDomainEventDispatcher.java │ ├── ReactiveDomainEventDispatcherFactory.java │ ├── ReactiveDomainEventHandler.java │ ├── ReactiveDomainEventHandlers.java │ └── ReactiveDomainEventHandlersBuilder.java ├── eventuate-tram-reactive-in-memory ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── reactive │ │ └── inmemory │ │ ├── ReactiveInMemoryMessageConsumer.java │ │ └── ReactiveInMemoryMessageProducer.java │ └── resources │ └── eventuate-tram-embedded-schema.sql ├── eventuate-tram-reactive-messaging-producer-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── reactive │ └── messaging │ └── producer │ └── common │ ├── ReactiveMessageProducer.java │ └── ReactiveMessageProducerImplementation.java ├── eventuate-tram-reactive-producer-jdbc ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── reactive │ └── messaging │ └── producer │ └── jdbc │ └── ReactiveMessageProducerJdbcImpl.java ├── eventuate-tram-spring-commands-common ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── commands │ │ └── common │ │ └── TramCommandsCommonAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-commands-starter ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── commands │ │ └── autoconfigure │ │ └── EventuateTramCommandsAutoConfigure.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-commands ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── commands │ │ ├── consumer │ │ ├── AnnotationBasedCommandHandlerConfiguration.java │ │ ├── CommandHandlerInfo.java │ │ ├── EventuateCommandDispatcher.java │ │ ├── EventuateCommandHandlerBeanPostProcessor.java │ │ ├── TramCommandConsumerConfiguration.java │ │ └── TramCommandReplyProducerConfiguration.java │ │ └── producer │ │ └── TramCommandProducerConfiguration.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── commands │ └── consumer │ ├── CommandHandlingTest.java │ └── customersandorders │ ├── CustomerCommandHandler.java │ ├── CustomerCreditLimitExceededException.java │ ├── CustomerNotFoundException.java │ ├── CustomerService.java │ ├── CustomersAndOrdersConfiguration.java │ ├── commands │ └── ReserveCreditCommand.java │ └── replies │ ├── CustomerCreditLimitExceeded.java │ ├── CustomerCreditReserved.java │ ├── CustomerNotFound.java │ └── ReserveCreditReply.java ├── eventuate-tram-spring-consumer-activemq └── build.gradle ├── eventuate-tram-spring-consumer-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── consumer │ └── common │ ├── TramConsumerBaseCommonConfiguration.java │ ├── TramConsumerCommonConfiguration.java │ └── TramNoopDuplicateMessageDetectorConfiguration.java ├── eventuate-tram-spring-consumer-jdbc ├── build.gradle └── src │ ├── main │ ├── java │ │ └── io │ │ │ └── eventuate │ │ │ └── tram │ │ │ └── spring │ │ │ └── consumer │ │ │ └── jdbc │ │ │ ├── TramConsumerJdbcAutoConfiguration.java │ │ │ └── TransactionalNoopDuplicateMessageDetectorConfiguration.java │ └── resources │ │ └── META-INF │ │ ├── spring.factories │ │ └── spring │ │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── consumer │ │ └── jdbc │ │ └── EventuateSpringSqlTableBasedDuplicateMessageDetectorTest.java │ └── resources │ ├── application-mssql.properties │ ├── application-postgres.properties │ └── application.properties ├── eventuate-tram-spring-consumer-kafka ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── consumer │ └── kafka │ └── EventuateTramKafkaMessageConsumerConfiguration.java ├── eventuate-tram-spring-consumer-rabbitmq └── build.gradle ├── eventuate-tram-spring-consumer-redis └── build.gradle ├── eventuate-tram-spring-events-common ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── events │ │ └── common │ │ └── TramEventsCommonAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-events-publisher-starter ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── events │ │ └── autoconfigure │ │ └── TramEventsPublisherAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-events-publisher ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── events │ └── publisher │ └── TramEventsPublisherConfiguration.java ├── eventuate-tram-spring-events-starter └── build.gradle ├── eventuate-tram-spring-events-subscriber-starter ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── events │ │ └── autoconfigure │ │ └── TramEventsSubscriberAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-events-subscriber ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── events │ │ └── subscriber │ │ ├── AnnotationBasedEventsSubscriberConfiguration.java │ │ ├── EventuateDomainEventDispatcher.java │ │ ├── EventuateDomainEventHandlerBeanPostProcessor.java │ │ ├── EventuateDomainEventHandlerInfo.java │ │ ├── EventuateDomainEventHandlerMethodValidator.java │ │ ├── EventuateDomainEventHandlerValidationException.java │ │ └── TramEventSubscriberConfiguration.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── events │ └── subscriber │ ├── EventuateDomainEventDispatcherTest.java │ ├── EventuateDomainEventHandlerIntegrationTest.java │ └── EventuateDomainEventHandlerMethodValidatorTest.java ├── eventuate-tram-spring-events └── build.gradle ├── eventuate-tram-spring-flyway ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── flyway │ │ ├── EventuateTramFlywayMigrationConfiguration.java │ │ └── V1005__MyMigration.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── flyway │ └── EventuateTramFlywayMigrationTest.java ├── eventuate-tram-spring-in-memory ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── inmemory │ │ ├── TramInMemoryCommonConfiguration.java │ │ └── TramInMemoryConfiguration.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── inmemory │ └── InMemoryMessageProducerTest.java ├── eventuate-tram-spring-jdbc-activemq └── build.gradle ├── eventuate-tram-spring-jdbc-kafka ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── jdbckafka │ └── TramJdbcKafkaConfiguration.java ├── eventuate-tram-spring-jdbc-rabbitmq └── build.gradle ├── eventuate-tram-spring-jdbc-redis └── build.gradle ├── eventuate-tram-spring-logging ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── logging │ │ ├── LoggingMessageInterceptor.java │ │ └── LoggingMessageInterceptorAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-messaging-producer-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── messaging │ └── producer │ └── common │ └── TramMessagingCommonProducerConfiguration.java ├── eventuate-tram-spring-messaging-starter ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── messaging │ │ └── autoconfigure │ │ ├── EventuateTramActiveMQMessageConsumerAutoConfiguration.java │ │ ├── EventuateTramKafkaMessageConsumerAutoConfiguration.java │ │ ├── EventuateTramRabbitMQMessageConsumerAutoConfiguration.java │ │ ├── EventuateTramRedisMessageConsumerAutoConfiguration.java │ │ └── TramMessageProducerJdbcAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-messaging ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── messaging │ │ └── common │ │ └── TramMessagingCommonAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-optimistic-locking ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── optimisticlocking │ │ ├── OptimisticLockingDecorator.java │ │ └── OptimisticLockingDecoratorConfiguration.java │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── optimisticlocking │ │ ├── AbstractEventuateSpringOptimisticLockingTest.java │ │ ├── EventuateSpringOptimisticLockingWithAnnotationTransactionTest.java │ │ ├── EventuateSpringOptimisticLockingWithTransactionTemplateTransactionTest.java │ │ ├── TestEntityRepositoryConfiguration.java │ │ ├── TestEntityRepositoryImpl.java │ │ ├── TestEntityServiceTransactionAnnotation.java │ │ ├── TestEntityServiceTransactionTemplate.java │ │ └── TestEntitySpringRepository.java │ └── resources │ ├── application-mssql.properties │ ├── application-postgres.properties │ └── application.properties ├── eventuate-tram-spring-producer-jdbc ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── messaging │ └── producer │ └── jdbc │ └── TramMessageProducerJdbcConfiguration.java ├── eventuate-tram-spring-reactive-commands-starter ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── reactive │ │ └── commands │ │ └── autoconfigure │ │ └── EventuateReactiveTramCommandsAutoConfigure.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-reactive-commands ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── reactive │ └── commands │ ├── consumer │ └── ReactiveTramCommandConsumerConfiguration.java │ └── producer │ └── ReactiveTramCommandProducerConfiguration.java ├── eventuate-tram-spring-reactive-consumer-common ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── reactive │ └── consumer │ └── common │ ├── ReactiveTramConsumerBaseCommonConfiguration.java │ ├── ReactiveTramConsumerCommonConfiguration.java │ └── ReactiveTramNoopDuplicateMessageDetectorConfiguration.java ├── eventuate-tram-spring-reactive-consumer-jdbc ├── build.gradle └── src │ ├── main │ ├── java │ │ └── io │ │ │ └── eventuate │ │ │ └── tram │ │ │ └── spring │ │ │ └── reactive │ │ │ └── consumer │ │ │ └── jdbc │ │ │ ├── ReactiveTramConsumerJdbcAutoConfiguration.java │ │ │ └── ReactiveTransactionalNoopDuplicateMessageDetectorConfiguration.java │ └── resources │ │ └── META-INF │ │ ├── spring.factories │ │ └── spring │ │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── reactive │ │ └── consumer │ │ └── jdbc │ │ └── EventuateSpringReactiveSqlTableBasedDuplicateMessageDetectorTest.java │ └── resources │ └── application.properties ├── eventuate-tram-spring-reactive-consumer-kafka ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── reactive │ └── consumer │ └── kafka │ └── EventuateTramReactiveKafkaMessageConsumerConfiguration.java ├── eventuate-tram-spring-reactive-events-publisher-starter ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── reactive │ │ └── events │ │ └── autoconfigure │ │ └── ReactiveTramEventsPublisherAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-reactive-events-publisher ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── events │ └── publisher │ ├── DomainEventPublishingBuilder.java │ ├── ReactiveDomainEventPublisher.java │ └── ReactiveTramEventsPublisherConfiguration.java ├── eventuate-tram-spring-reactive-events-starter └── build.gradle ├── eventuate-tram-spring-reactive-events-subscriber-starter ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── reactive │ │ └── events │ │ └── autoconfigure │ │ └── ReactiveTramEventsSubscriberAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-reactive-events-subscriber ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── reactive │ └── events │ └── subscriber │ ├── ReactiveTramEventSubscriberConfiguration.java │ └── SpringReactiveDomainEventDispatcherFactory.java ├── eventuate-tram-spring-reactive-events └── build.gradle ├── eventuate-tram-spring-reactive-integration-tests ├── build.gradle └── src │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── reactive │ │ └── integrationtests │ │ ├── IdSupplier.java │ │ ├── commands │ │ ├── ReactiveTramCommandIntegrationTest.java │ │ ├── ReactiveTramTestCommandHandler.java │ │ ├── TestCommand.java │ │ └── TestCommandForMultipleReplies.java │ │ ├── events │ │ ├── AdditionalTestEvent.java │ │ ├── ReactiveTramAdditionalTestEventConsumer.java │ │ ├── ReactiveTramEventIntegrationTest.java │ │ ├── ReactiveTramEventIntegrationTestConfiguration.java │ │ ├── ReactiveTramEventTransactionIntegrationTest.java │ │ ├── ReactiveTramTestEventConsumer.java │ │ ├── TestEvent.java │ │ └── TestEventThatInitiatesException.java │ │ └── messaging │ │ ├── ReactiveTramMessagingDuplicateDetectionTest.java │ │ └── ReactiveTramMessagingIntegrationTest.java │ └── resources │ └── application.properties ├── eventuate-tram-spring-reactive-jdbc-kafka ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── reactive │ └── jdbckafka │ └── ReactiveTramJdbcKafkaConfiguration.java ├── eventuate-tram-spring-reactive-messaging-starter ├── build.gradle └── src │ └── main │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── reactive │ │ └── messaging │ │ └── autoconfigure │ │ ├── EventuateTramReactiveKafkaMessageConsumerAutoConfiguration.java │ │ └── ReactiveTramMessageProducerJdbcAutoConfiguration.java │ └── resources │ └── META-INF │ ├── spring.factories │ └── spring │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports ├── eventuate-tram-spring-reactive-optimistic-locking ├── build.gradle └── src │ ├── main │ ├── java │ │ └── io │ │ │ └── eventuate │ │ │ └── tram │ │ │ └── spring │ │ │ └── reactive │ │ │ └── optimisticlocking │ │ │ ├── OptimisticLockingDecorator.java │ │ │ ├── OptimisticLockingDecoratorAutoConfiguration.java │ │ │ └── OptimisticLockingDecoratorConfiguration.java │ └── resources │ │ └── META-INF │ │ ├── spring.factories │ │ └── spring │ │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── reactive │ └── optimisticlocking │ ├── OptimisticLockingDecoratorAutoConfigurationTest.java │ └── OptimisticLockingDecoratorTest.java ├── eventuate-tram-spring-reactive-producer-jdbc ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── messaging │ │ └── producer │ │ └── jdbc │ │ └── reactive │ │ └── ReactiveTramMessageProducerJdbcConfiguration.java │ └── test │ ├── java │ └── io │ │ └── eventuate │ │ └── tram │ │ └── spring │ │ └── messaging │ │ └── producer │ │ └── jdbc │ │ └── reactive │ │ └── ReactiveTramIntegrationTest.java │ └── resources │ └── application.properties ├── eventuate-tram-spring-testing-support-cloud-contract ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── cloudcontractsupport │ ├── ContractVerifierEventuateMessaging.java │ ├── EventuateContractVerifierConfiguration.java │ ├── EventuateTramMessageVerifier.java │ └── EventuateTramRoutesConfigurer.java ├── eventuate-tram-spring-testing-support-kafka-producer ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── testing │ └── kafka │ └── producer │ └── EventuateKafkaTestCommandProducerConfiguration.java ├── eventuate-tram-spring-testing-support-messaging ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── testing │ ├── events │ └── publisher │ │ ├── EventOutboxTestSupport.java │ │ └── EventOutboxTestSupportConfiguration.java │ └── messaging │ ├── UniqueChannelMapping.java │ ├── UniqueChannelMappingConfiguration.java │ └── consumer │ ├── AssertableMessage.java │ ├── AssertableMessageConsumer.java │ ├── AssertableMessageConsumerConfiguration.java │ ├── UniqueSubscriberIdMapping.java │ └── UniqueSubscriberIdMappingConfiguration.java ├── eventuate-tram-spring-testing-support-outbox-commands ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── spring │ └── testing │ └── outbox │ └── commands │ ├── CommandOutboxTestSupport.java │ └── CommandOutboxTestSupportConfiguration.java ├── eventuate-tram-test-util ├── build.gradle └── src │ └── main │ └── java │ └── io │ └── eventuate │ └── tram │ └── testutil │ ├── TestMessageConsumer.java │ └── TestMessageConsumerFactory.java ├── eventuate-tram-testing-support ├── build.gradle └── src │ ├── main │ └── java │ │ └── io │ │ └── eventuate │ │ └── tram │ │ └── testing │ │ ├── DomainEventHandlerUnitTestSupport.java │ │ ├── MessageTracker.java │ │ └── commands │ │ ├── CommandHandlerReply.java │ │ └── CommandMessageHandlerUnitTestSupport.java │ └── test │ └── java │ └── io │ └── eventuate │ └── tram │ └── testing │ ├── DomainEventHandlerUnitTestSupportTest.java │ ├── MessageTrackerTest.java │ └── commands │ └── CommandMessageHandlerUnitTestSupportTest.java ├── gradle.properties ├── gradle ├── gradlew ├── gradlew.bat └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── mssql-cli.sh ├── mysql-cli.sh ├── postgres-cli.sh ├── redis-cli.sh ├── settings.gradle ├── wait-for-mssql.sh ├── wait-for-mysql.sh ├── wait-for-postgres.sh └── wait-for-services.sh /.gitignore: -------------------------------------------------------------------------------- 1 | .gradle 2 | build/ 3 | *.idea/ 4 | *.iml 5 | *.log 6 | out 7 | .classpath 8 | .project 9 | .settings 10 | bin 11 | .DS_Store 12 | .java-version 13 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | Copyright (c) 2020 Eventuate, Inc. All rights reserved. 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /ReliablePublication.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eventuate-tram/eventuate-tram-core/b30a9d273471a26935c51e23919d4252eeb4e3b5/ReliablePublication.png -------------------------------------------------------------------------------- /activemq/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM openjdk:8-jre-alpine 2 | 3 | RUN wget -O activemq.tar.gz http://archive.apache.org/dist/activemq/5.15.6/apache-activemq-5.15.6-bin.tar.gz 4 | 5 | RUN tar -xzf activemq.tar.gz 6 | 7 | RUN rm apache-activemq-5.15.6/conf/activemq.xml 8 | COPY activemq.xml apache-activemq-5.15.6/conf 9 | 10 | CMD ["apache-activemq-5.15.6/bin/activemq", "console"] -------------------------------------------------------------------------------- /build-and-test-all-mssql-polling-activemq.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | set -e 4 | 5 | export DATABASE=mssql 6 | export MODE=polling 7 | export BROKER=activemq 8 | export COORDINATOR=zookeeper 9 | export MICRONAUT_ENVIRONMENTS=mssql 10 | export SPRING_PROFILES_ACTIVE=EventuatePolling,ActiveMQ,mssql 11 | 12 | ./_build-and-test-all.sh 13 | -------------------------------------------------------------------------------- /build-and-test-all-mysql-binlog-kafka.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | set -e 4 | 5 | export DATABASE=mysql 6 | export MODE=binlog 7 | export BROKER=kafka 8 | export COORDINATOR=zookeeper 9 | 10 | ./_build-and-test-all.sh 11 | -------------------------------------------------------------------------------- /build-and-test-all-mysql-binlog-redis.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | set -e 4 | 5 | export DATABASE=mysql 6 | export MODE=binlog 7 | export BROKER=redis 8 | export SPRING_PROFILES_ACTIVE=Redis 9 | 10 | ./_build-and-test-all.sh 11 | -------------------------------------------------------------------------------- /build-and-test-all-mysql-kafka-spring-boot-3.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | set -e 4 | 5 | export DATABASE=mysql 6 | export MODE=binlog 7 | export BROKER=kafka 8 | export COORDINATOR=zookeeper 9 | 10 | ./_build-and-test-all.sh -P springBootVersion=3.0.1 11 | -------------------------------------------------------------------------------- /build-and-test-all-postgres-wal-rabbitmq.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | set -e 4 | 5 | export DATABASE=postgres 6 | export MODE=wal 7 | export BROKER=rabbitmq 8 | export COORDINATOR=zookeeper 9 | export MICRONAUT_ENVIRONMENTS=postgres 10 | export SPRING_PROFILES_ACTIVE=PostgresWal,RabbitMQ,postgres 11 | 12 | ./_build-and-test-all.sh 13 | -------------------------------------------------------------------------------- /build-and-test-everything.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash -e 2 | 3 | set -o pipefail 4 | 5 | SCRIPTS=" 6 | ./build-and-test-all-mysql-binlog-kafka.sh 7 | ./build-and-test-all-mssql-polling-activemq.sh 8 | ./build-and-test-all-postgres-wal-rabbitmq.sh 9 | ./build-and-test-all-mysql-binlog-redis.sh 10 | " 11 | 12 | 13 | date > build-and-test-everything.log 14 | 15 | for script in $SCRIPTS ; do 16 | echo '****************************************** Running' $script 17 | date >> build-and-test-everything.log 18 | echo '****************************************** Running' $script >> build-and-test-everything.log 19 | $script | tee -a build-and-test-everything.log 20 | done 21 | 22 | echo 'Finished successfully!!!' 23 | -------------------------------------------------------------------------------- /deploy-artifacts.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash -e 2 | 3 | ./gradlew --parallel publishEventuateArtifacts 4 | -------------------------------------------------------------------------------- /docker-compose-zipkin.yml: -------------------------------------------------------------------------------- 1 | zipkin: 2 | image: openzipkin/zipkin:2.5.0 3 | ports: 4 | - "9411:9411" 5 | environment: 6 | JAVA_OPTS: -Xmx128m 7 | -------------------------------------------------------------------------------- /eventuate-tram-aggregate-domain-events/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-events") 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-aggregate-domain-events/src/main/java/io/eventuate/tram/events/aggregates/ResultWithDomainEvents.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.aggregates; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | 5 | import java.util.Arrays; 6 | import java.util.List; 7 | 8 | public class ResultWithDomainEvents { 9 | 10 | public final A result; 11 | public final List events; 12 | 13 | public ResultWithDomainEvents(A result, List events) { 14 | this.result = result; 15 | this.events = events; 16 | } 17 | 18 | public ResultWithDomainEvents(A result, E... events) { 19 | this.result = result; 20 | this.events = Arrays.asList(events); 21 | } 22 | } -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-producer-jdbc") 4 | api project(":eventuate-tram-spring-consumer-jdbc") 5 | api project(":eventuate-tram-integration-test-common") 6 | api project(":eventuate-tram-spring-commands") 7 | 8 | testImplementation "io.eventuate.cdc:eventuate-local-java-test-util:$eventuateCdcVersion" 9 | 10 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 11 | 12 | testImplementation "io.netty:netty-resolver-dns:4.1.79.Final" 13 | 14 | } 15 | 16 | test { 17 | def testCustomDBVariable = System.env['TEST_CUSTOM_DB'] 18 | if (testCustomDBVariable != 'true') { 19 | exclude '**/TramCommandsDBBrokerIntegrationCustomDBTest**' 20 | } 21 | forkEvery 1 22 | } 23 | -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/java/io/eventuate/tram/commands/db/broker/integrationtests/MyTestCommand.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.db.broker.integrationtests; 2 | 3 | import io.eventuate.tram.commands.CommandDestination; 4 | import io.eventuate.tram.commands.common.Command; 5 | 6 | @CommandDestination("destination") 7 | public class MyTestCommand implements Command { 8 | 9 | private String name; 10 | 11 | public MyTestCommand() { 12 | } 13 | 14 | public String getName() { 15 | return name; 16 | } 17 | 18 | public void setName(String name) { 19 | this.name = name; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/java/io/eventuate/tram/commands/db/broker/integrationtests/MyTestCommandJSonTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.db.broker.integrationtests; 2 | 3 | import io.eventuate.common.json.mapper.JSonMapper; 4 | import org.junit.Test; 5 | 6 | public class MyTestCommandJSonTest { 7 | 8 | @Test 9 | public void shouldSerde() { 10 | MyTestCommand x = new MyTestCommand(); 11 | String s = JSonMapper.toJson(x); 12 | MyTestCommand x2 = JSonMapper.fromJson(s, MyTestCommand.class); 13 | 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/java/io/eventuate/tram/commands/db/broker/integrationtests/TramCommandsDBBrokerIntegrationCustomDBTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.db.broker.integrationtests; 2 | 3 | import io.eventuate.local.testutil.CustomDBCreator; 4 | import io.eventuate.local.testutil.CustomDBTestConfiguration; 5 | import org.junit.Before; 6 | import org.junit.runner.RunWith; 7 | import org.springframework.beans.factory.annotation.Autowired; 8 | import org.springframework.boot.test.context.SpringBootTest; 9 | import org.springframework.test.context.junit4.SpringRunner; 10 | 11 | @RunWith(SpringRunner.class) 12 | @SpringBootTest(classes = {TramCommandsDBBrokerIntegrationTestConfiguration.class, CustomDBTestConfiguration.class}) 13 | public class TramCommandsDBBrokerIntegrationCustomDBTest extends AbstractTramCommandsDBBrokerIntegrationTest { 14 | 15 | @Autowired 16 | private CustomDBCreator customDBCreator; 17 | 18 | @Before 19 | public void createCustomDB() { 20 | customDBCreator.create(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/java/io/eventuate/tram/commands/db/broker/integrationtests/TramCommandsDBBrokerIntegrationData.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.db.broker.integrationtests; 2 | 3 | public class TramCommandsDBBrokerIntegrationData { 4 | 5 | private long now = System.currentTimeMillis(); 6 | private String commandDispatcherId = "command-dispatcher-" + now; 7 | private String commandChannel = "command-channel-" + now; 8 | private String aggregateDestination = "aggregate-destination-" + now; 9 | private String eventDispatcherId = "event-dispatcher-" + now; 10 | 11 | public String getAggregateDestination() { 12 | return aggregateDestination; 13 | } 14 | 15 | 16 | public String getCommandDispatcherId() { 17 | return commandDispatcherId; 18 | } 19 | 20 | public String getCommandChannel() { 21 | return commandChannel; 22 | } 23 | 24 | public String getEventDispatcherId() { 25 | return eventDispatcherId; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/java/io/eventuate/tram/commands/db/broker/integrationtests/TramCommandsDBBrokerIntegrationTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.db.broker.integrationtests; 2 | 3 | import org.junit.runner.RunWith; 4 | import org.springframework.boot.test.context.SpringBootTest; 5 | import org.springframework.test.context.junit4.SpringRunner; 6 | 7 | @RunWith(SpringRunner.class) 8 | @SpringBootTest(classes = TramCommandsDBBrokerIntegrationTestConfiguration.class) 9 | public class TramCommandsDBBrokerIntegrationTest extends AbstractTramCommandsDBBrokerIntegrationTest { 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/resources/application-mssql.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:sqlserver://${DOCKER_HOST_IP:localhost}:1433;databaseName=eventuate 2 | spring.datasource.username=sa 3 | spring.datasource.password=Eventuate123! 4 | spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver 5 | spring.datasource.driver.class.name=com.microsoft.sqlserver.jdbc.SQLServerDriver 6 | -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/resources/application-postgres.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:postgresql://${DOCKER_HOST_IP:localhost}/eventuate 2 | spring.datasource.username=eventuate 3 | spring.datasource.password=eventuate 4 | spring.datasource.driver-class-name=org.postgresql.Driver 5 | spring.datasource.driver.class.name=org.postgresql.Driver 6 | -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/resources/application.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:mysql://${DOCKER_HOST_IP:localhost}/eventuate 2 | spring.datasource.username=mysqluser 3 | spring.datasource.password=mysqlpw 4 | spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 5 | spring.datasource.driver.class.name=com.mysql.cj.jdbc.Driver 6 | 7 | eventuatelocal.kafka.bootstrap.servers=${DOCKER_HOST_IP:localhost}:9092 8 | eventuatelocal.zookeeper.connection.string=${DOCKER_HOST_IP:localhost}:2181 9 | 10 | eventuatelocal.cdc.db.user.name=root 11 | eventuatelocal.cdc.db.password=rootpassword 12 | 13 | activemq.url=tcp://${DOCKER_HOST_IP:localhost}:61616 14 | activemq.user=eventuateuser 15 | activemq.password=eventuatepassword 16 | 17 | rabbitmq.broker.addresses=${DOCKER_HOST_IP:localhost} 18 | 19 | eventuate.redis.servers=${DOCKER_HOST_IP:localhost}:6379 20 | eventuate.redis.partitions=1 -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/resources/custom-db-mysql-schema.sql: -------------------------------------------------------------------------------- 1 | CREATE DATABASE IF NOT EXISTS custom; 2 | GRANT ALL PRIVILEGES ON custom.* TO 'mysqluser'@'%' WITH GRANT OPTION; 3 | 4 | USE custom; 5 | 6 | DROP Table IF Exists message; 7 | DROP Table IF Exists received_messages; 8 | DROP Table IF Exists offset_store; 9 | 10 | CREATE TABLE message ( 11 | id VARCHAR(255) PRIMARY KEY, 12 | destination VARCHAR(1000) NOT NULL, 13 | headers VARCHAR(1000) NOT NULL, 14 | payload VARCHAR(1000) NOT NULL, 15 | published SMALLINT DEFAULT 0, 16 | message_partition SMALLINT, 17 | creation_time BIGINT 18 | ); 19 | 20 | CREATE INDEX message_published_idx ON message(published, id); 21 | 22 | CREATE TABLE received_messages ( 23 | consumer_id VARCHAR(255), 24 | message_id VARCHAR(255), 25 | PRIMARY KEY(consumer_id, message_id), 26 | creation_time BIGINT 27 | ); 28 | 29 | CREATE TABLE offset_store( 30 | client_name VARCHAR(255) NOT NULL PRIMARY KEY, 31 | serialized_offset VARCHAR(255) 32 | ); -------------------------------------------------------------------------------- /eventuate-tram-commands-db-broker-integration-test/src/test/resources/customdb.properties: -------------------------------------------------------------------------------- 1 | eventuate.database.schema=custom 2 | data.file=file:src/test/resources/custom-db-mysql-schema.sql -------------------------------------------------------------------------------- /eventuate-tram-commands/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | 5 | api "io.eventuate.common:eventuate-common-json-mapper:$eventuateCommonVersion" 6 | 7 | api "javax.annotation:javax.annotation-api:1.3.2" 8 | 9 | testImplementation project(":eventuate-tram-in-memory") 10 | testImplementation "io.eventuate.util:eventuate-util-test:$eventuateUtilVersion" 11 | testImplementation project(":eventuate-tram-test-util") 12 | 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/CommandDestination.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface CommandDestination { 8 | String value(); 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/Command.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public interface Command { 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/CommandMessageHeaders.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public class CommandMessageHeaders { 4 | public static final String COMMAND_HEADER_PREFIX = "command_"; 5 | 6 | public static final String COMMAND_TYPE = COMMAND_HEADER_PREFIX + "type"; 7 | public static final String RESOURCE = COMMAND_HEADER_PREFIX + "resource";; 8 | public static final String DESTINATION = COMMAND_HEADER_PREFIX + "_destination"; 9 | 10 | public static final String COMMAND_REPLY_PREFIX = "commandreply_"; 11 | public static final String REPLY_TO = COMMAND_HEADER_PREFIX + "reply_to"; 12 | 13 | public static String inReply(String header) { 14 | assert header.startsWith(COMMAND_HEADER_PREFIX); 15 | return COMMAND_REPLY_PREFIX + header.substring(COMMAND_HEADER_PREFIX.length()); 16 | } 17 | 18 | 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/CommandNameMapping.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public interface CommandNameMapping { 4 | 5 | String commandToExternalCommandType(Command command); 6 | String externalCommandTypeToCommandClassName(String commandTypeHeader); 7 | 8 | } 9 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/CommandReplyOutcome.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public enum CommandReplyOutcome { SUCCESS, FAILURE } 4 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/DefaultCommandNameMapping.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public class DefaultCommandNameMapping implements CommandNameMapping { 4 | 5 | @Override 6 | public String commandToExternalCommandType(Command command) { 7 | return command.getClass().getName(); 8 | } 9 | 10 | @Override 11 | public String externalCommandTypeToCommandClassName(String commandTypeHeader) { 12 | return commandTypeHeader; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/Failure.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public class Failure implements Outcome { 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/Outcome.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public interface Outcome { 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/ReplyMessageHeaders.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public class ReplyMessageHeaders { 4 | 5 | public static final String REPLY_TYPE = "reply_type"; // Unused?? 6 | public static final String IN_REPLY_TO = "reply_to_message_id"; 7 | 8 | public static final String REPLY_OUTCOME = "reply_outcome-type"; 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/Success.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common; 2 | 3 | public class Success implements Outcome { 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/paths/PlaceholderValueMapProvider.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common.paths; 2 | 3 | import java.util.Map; 4 | import java.util.Optional; 5 | 6 | public class PlaceholderValueMapProvider implements PlaceholderValueProvider { 7 | private final Map params; 8 | 9 | public PlaceholderValueMapProvider(Map params) { 10 | if (params == null) { 11 | throw new IllegalArgumentException("params cannot be null"); 12 | } 13 | 14 | this.params = params; 15 | } 16 | 17 | @Override 18 | public Optional get(String name) { 19 | return Optional.ofNullable(params.get(name)); 20 | } 21 | 22 | @Override 23 | public Map getParams() { 24 | return params; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/paths/PlaceholderValueProvider.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common.paths; 2 | 3 | import java.util.Map; 4 | import java.util.Optional; 5 | 6 | public interface PlaceholderValueProvider { 7 | Optional get(String name); 8 | Map getParams(); 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/paths/ResourcePath.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common.paths; 2 | 3 | import java.util.Arrays; 4 | 5 | import static java.util.stream.Collectors.joining; 6 | 7 | public class ResourcePath { 8 | 9 | final String[] splits; 10 | 11 | public ResourcePath(String[] splits) { 12 | this.splits = splits; 13 | } 14 | 15 | public ResourcePath(String resource) { 16 | if (!resource.startsWith("/")) { 17 | throw new IllegalArgumentException("Should start with / " + resource ); 18 | } 19 | 20 | this.splits = splitPath(resource); 21 | } 22 | 23 | private String[] splitPath(String path) { 24 | return path.split("/"); 25 | } 26 | 27 | public static ResourcePath parse(String resource) { 28 | return new ResourcePath(resource); 29 | } 30 | 31 | public int length() { 32 | return splits.length; 33 | } 34 | 35 | public String toPath() { 36 | return Arrays.stream(splits).collect(joining("/")); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/common/paths/SingleValuePlaceholderValueProvider.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common.paths; 2 | 3 | import java.util.Collections; 4 | import java.util.Map; 5 | import java.util.Optional; 6 | 7 | public class SingleValuePlaceholderValueProvider implements PlaceholderValueProvider { 8 | private Object pathParam; 9 | private boolean used; 10 | 11 | public SingleValuePlaceholderValueProvider(Object pathParam) { 12 | this.pathParam = pathParam; 13 | } 14 | 15 | @Override 16 | public Optional get(String name) { 17 | if (!used) { 18 | used = true; 19 | return Optional.of(pathParam.toString()); 20 | } else 21 | return Optional.empty(); 22 | } 23 | 24 | @Override 25 | public Map getParams() { 26 | return Collections.singletonMap("singleValue", pathParam.toString()); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/CommandExceptionHandler.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | 4 | import io.eventuate.tram.messaging.common.Message; 5 | 6 | import java.util.List; 7 | 8 | public class CommandExceptionHandler { 9 | public List invoke(Throwable cause) { 10 | throw new UnsupportedOperationException(); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/CommandHandler.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | import io.eventuate.tram.commands.common.Command; 4 | import io.eventuate.tram.messaging.common.Message; 5 | 6 | import java.util.List; 7 | import java.util.Optional; 8 | import java.util.function.Function; 9 | 10 | 11 | public class CommandHandler extends AbstractCommandHandler>{ 12 | 13 | public CommandHandler(String channel, Optional resource, 14 | Class commandClass, 15 | Function, List> handler) { 16 | 17 | super(channel, resource, commandClass, handler); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/CommandReplyToken.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | import java.util.Map; 4 | 5 | public class CommandReplyToken { 6 | private Map replyHeaders; 7 | private String replyChannel; 8 | 9 | public CommandReplyToken(Map correlationHeaders, String replyChannel) { 10 | this.replyHeaders = correlationHeaders; 11 | this.replyChannel = replyChannel; 12 | } 13 | 14 | private CommandReplyToken() { 15 | // For ObjectMapper 16 | } 17 | 18 | public Map getReplyHeaders() { 19 | return replyHeaders; 20 | } 21 | 22 | public String getReplyChannel() { 23 | return replyChannel; 24 | } 25 | 26 | public void setReplyHeaders(Map replyHeaders) { 27 | this.replyHeaders = replyHeaders; 28 | } 29 | 30 | public void setReplyChannel(String replyChannel) { 31 | this.replyChannel = replyChannel; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/DestinationForExceptionRootObject.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | public class DestinationForExceptionRootObject { 4 | private final Object parameter; 5 | private final Throwable cause; 6 | 7 | public Object getParameter() { 8 | return parameter; 9 | } 10 | 11 | public Throwable getCause() { 12 | return cause; 13 | } 14 | 15 | public DestinationForExceptionRootObject(Object parameter, Throwable cause) { 16 | this.parameter = parameter; 17 | this.cause = cause; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/DestinationRootObject.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | import java.util.Map; 4 | 5 | public class DestinationRootObject { 6 | private final Object parameter; 7 | private final Object result; 8 | private Map path; 9 | 10 | public DestinationRootObject(Object parameter, Object result, Map path) { 11 | this.parameter = parameter; 12 | this.result = result; 13 | this.path = path; 14 | } 15 | 16 | public Object getParameter() { 17 | return parameter; 18 | } 19 | 20 | public Object getResult() { 21 | return result; 22 | } 23 | 24 | public Map getPath() { 25 | return path; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/DestinationRootObjectForException.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | import java.util.Map; 4 | 5 | public class DestinationRootObjectForException extends DestinationRootObject { 6 | private final Throwable throwable; 7 | 8 | public Throwable getThrowable() { 9 | return throwable; 10 | } 11 | 12 | public DestinationRootObjectForException(Object parameter, Object result, Map pathVars, Throwable throwable) { 13 | super(parameter, result, pathVars); 14 | this.throwable = throwable; 15 | 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/PathVariable.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface PathVariable { 8 | String value(); 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/PathVariables.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | import java.util.Map; 4 | 5 | public class PathVariables { 6 | 7 | private Map pathVars; 8 | 9 | public PathVariables(Map pathVars) { 10 | 11 | this.pathVars = pathVars; 12 | } 13 | 14 | public String getString(String name) { 15 | return pathVars.get(name); 16 | } 17 | 18 | public long getLong(String name) { 19 | return Long.parseLong(getString(name)); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/ReplyDestination.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | import org.apache.commons.lang.builder.ToStringBuilder; 4 | 5 | public class ReplyDestination { 6 | 7 | public final String destination; 8 | public final String partitionKey; 9 | 10 | public ReplyDestination(String destination, String partitionKey) { 11 | this.partitionKey = partitionKey; 12 | this.destination = destination; 13 | } 14 | 15 | @Override 16 | public String toString() { 17 | return ToStringBuilder.reflectionToString(this); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/annotations/EventuateCommandHandler.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer.annotations; 2 | 3 | import java.lang.annotation.ElementType; 4 | import java.lang.annotation.Retention; 5 | import java.lang.annotation.RetentionPolicy; 6 | import java.lang.annotation.Target; 7 | 8 | @Retention(RetentionPolicy.RUNTIME) 9 | @Target(ElementType.METHOD) 10 | public @interface EventuateCommandHandler { 11 | String subscriberId(); 12 | 13 | String channel(); 14 | 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/annotations/FailureReply.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer.annotations; 2 | 3 | import java.lang.annotation.ElementType; 4 | import java.lang.annotation.Retention; 5 | import java.lang.annotation.RetentionPolicy; 6 | import java.lang.annotation.Target; 7 | 8 | @Retention(RetentionPolicy.RUNTIME) 9 | @Target(ElementType.TYPE) 10 | public @interface FailureReply { 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/main/java/io/eventuate/tram/commands/consumer/annotations/SuccessReply.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer.annotations; 2 | 3 | import java.lang.annotation.ElementType; 4 | import java.lang.annotation.Retention; 5 | import java.lang.annotation.RetentionPolicy; 6 | import java.lang.annotation.Target; 7 | 8 | @Retention(RetentionPolicy.RUNTIME) 9 | @Target(ElementType.TYPE) 10 | public @interface SuccessReply { 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/test/java/io/eventuate/tram/commands/AbstractCommandDispatchingTests.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands; 2 | 3 | import io.eventuate.tram.commands.consumer.CommandHandlers; 4 | import io.eventuate.tram.inmemory.InMemoryMessaging; 5 | import org.junit.Before; 6 | 7 | public abstract class AbstractCommandDispatchingTests { 8 | 9 | protected final InMemoryMessaging inMemoryMessaging = InMemoryMessaging.make(); 10 | protected InMemoryCommands inMemoryCommands; 11 | protected String channel = "myChannel"; 12 | 13 | 14 | @Before 15 | public void setup() { 16 | 17 | CommandHandlers commandHandlers = defineCommandHandlers(); 18 | 19 | inMemoryCommands = InMemoryCommands.make(commandHandlers, inMemoryMessaging); 20 | } 21 | 22 | public abstract CommandHandlers defineCommandHandlers(); 23 | } 24 | -------------------------------------------------------------------------------- /eventuate-tram-commands/src/test/java/io/eventuate/tram/commands/common/paths/ResourcePathPatternTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.common.paths; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.junit.Assert.assertEquals; 6 | 7 | public class ResourcePathPatternTest { 8 | 9 | @Test 10 | public void shouldReplacePlaceholders() { 11 | ResourcePathPattern rpp = new ResourcePathPattern("/foo/{bar}"); 12 | ResourcePath rp = rpp.replacePlaceholders(new SingleValuePlaceholderValueProvider("baz")); 13 | 14 | assertEquals("/foo/baz", rp.toPath()); 15 | } 16 | 17 | } -------------------------------------------------------------------------------- /eventuate-tram-commands/src/test/java/io/eventuate/tram/commands/consumer/CommandReplyTokenSerdeTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.commands.consumer; 2 | 3 | import io.eventuate.common.json.mapper.JSonMapper; 4 | import org.junit.Test; 5 | 6 | import java.util.Collections; 7 | 8 | import static org.junit.Assert.assertEquals; 9 | 10 | public class CommandReplyTokenSerdeTest { 11 | 12 | @Test 13 | public void shouldSerializeAndDeserialize() { 14 | CommandReplyToken crt = new CommandReplyToken(Collections.singletonMap("x", "y"), "Hollywood"); 15 | String s = JSonMapper.toJson(crt); 16 | CommandReplyToken newCrt = JSonMapper.fromJson(s, CommandReplyToken.class); 17 | assertEquals(crt.getReplyChannel(), newCrt.getReplyChannel()); 18 | assertEquals(crt.getReplyHeaders(), newCrt.getReplyHeaders()); 19 | } 20 | } -------------------------------------------------------------------------------- /eventuate-tram-commands/src/test/resources/application.properties: -------------------------------------------------------------------------------- 1 | logging.level.io.eventuate.tram=DEBUG 2 | logging.level.io.eventuate.local=DEBUG -------------------------------------------------------------------------------- /eventuate-tram-common-spring-in-memory/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-in-memory") 4 | api "org.springframework.boot:spring-boot-starter-jdbc:$springBootCdcVersion" 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-common-spring-in-memory/src/main/java/io/eventuate/tram/common/spring/inmemory/EventuateSpringTransactionSynchronizationManager.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.common.spring.inmemory; 2 | 3 | import io.eventuate.tram.inmemory.EventuateTransactionSynchronizationManager; 4 | import org.springframework.transaction.support.TransactionSynchronizationAdapter; 5 | import org.springframework.transaction.support.TransactionSynchronizationManager; 6 | 7 | public class EventuateSpringTransactionSynchronizationManager 8 | implements EventuateTransactionSynchronizationManager { 9 | 10 | @Override 11 | public boolean isTransactionActive() { 12 | return TransactionSynchronizationManager.isActualTransactionActive(); 13 | } 14 | 15 | @Override 16 | public void executeAfterTransaction(Runnable callback) { 17 | TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() { 18 | @Override 19 | public void afterCommit() { 20 | callback.run(); 21 | } 22 | }); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /eventuate-tram-common/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | testImplementation "junit:junit:4.12" 3 | testImplementation "org.mockito:mockito-core:2.23.4" 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-activemq/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | api project(":eventuate-tram-spring-consumer-common") 5 | 6 | api "io.eventuate.messaging.activemq:eventuate-messaging-activemq-spring-consumer:$eventuateMessagingActiveMQVersion" 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | 5 | api "io.eventuate.common:eventuate-common-coordination-leadership:$eventuateCommonVersion" 6 | api "io.eventuate.common:eventuate-common-json-mapper:$eventuateCommonVersion" 7 | 8 | testImplementation 'com.google.guava:guava:19.0' 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-common/src/main/java/io/eventuate/tram/consumer/common/DuplicateMessageDetector.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common; 2 | 3 | import io.eventuate.tram.messaging.common.SubscriberIdAndMessage; 4 | 5 | public interface DuplicateMessageDetector { 6 | boolean isDuplicate(String consumerId, String messageId); 7 | void doWithMessage(SubscriberIdAndMessage subscriberIdAndMessage, Runnable callback); 8 | } 9 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-common/src/main/java/io/eventuate/tram/consumer/common/MessageConsumerImplementation.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common; 2 | 3 | import io.eventuate.tram.messaging.consumer.MessageHandler; 4 | import io.eventuate.tram.messaging.consumer.MessageSubscription; 5 | 6 | import java.util.Set; 7 | 8 | public interface MessageConsumerImplementation { 9 | MessageSubscription subscribe(String subscriberId, Set channels, MessageHandler handler); 10 | String getId(); 11 | void close(); 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-common/src/main/java/io/eventuate/tram/consumer/common/MessageHandlerDecorator.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common; 2 | 3 | import io.eventuate.tram.messaging.common.SubscriberIdAndMessage; 4 | 5 | import java.util.function.BiConsumer; 6 | 7 | public interface MessageHandlerDecorator extends BiConsumer { 8 | int getOrder(); 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-common/src/main/java/io/eventuate/tram/consumer/common/MessageHandlerDecoratorChain.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common; 2 | 3 | import io.eventuate.tram.messaging.common.SubscriberIdAndMessage; 4 | 5 | public interface MessageHandlerDecoratorChain { 6 | void invokeNext(SubscriberIdAndMessage subscriberIdAndMessage); 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-common/src/main/java/io/eventuate/tram/consumer/common/NoopDuplicateMessageDetector.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common; 2 | 3 | import io.eventuate.tram.messaging.common.SubscriberIdAndMessage; 4 | 5 | public class NoopDuplicateMessageDetector implements DuplicateMessageDetector { 6 | 7 | @Override 8 | public boolean isDuplicate(String consumerId, String messageId) { 9 | return false; 10 | } 11 | 12 | @Override 13 | public void doWithMessage(SubscriberIdAndMessage subscriberIdAndMessage, Runnable callback) { 14 | callback.run(); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "io.eventuate.common:eventuate-common-jdbc:$eventuateCommonVersion" 4 | api 'org.springframework:spring-jdbc:5.1.8.RELEASE' 5 | api project(":eventuate-tram-consumer-common") 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-kafka/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | api project(":eventuate-tram-consumer-common") 5 | 6 | api "io.eventuate.messaging.kafka:eventuate-messaging-kafka-consumer:$eventuateMessagingKafkaVersion" 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-rabbitmq/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | api project(":eventuate-tram-spring-consumer-common") 5 | 6 | api "io.eventuate.messaging.rabbitmq:eventuate-messaging-rabbitmq-spring-consumer:$eventuateMessagingRabbitMQVersion" 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-redis/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | api project(":eventuate-tram-spring-consumer-common") 5 | 6 | api "io.eventuate.messaging.redis:eventuate-messaging-redis-spring-consumer:$eventuateMessagingRedisVersion" 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /eventuate-tram-consumer-redis/src/main/java/io/eventuate/tram/consumer/redis/EventuateTramRedisMessageConsumerConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.redis; 2 | 3 | import io.eventuate.messaging.redis.spring.consumer.MessageConsumerRedisConfiguration; 4 | import io.eventuate.messaging.redis.spring.consumer.MessageConsumerRedisImpl; 5 | import io.eventuate.tram.consumer.common.MessageConsumerImplementation; 6 | import io.eventuate.tram.spring.consumer.common.TramConsumerCommonConfiguration; 7 | import org.springframework.context.annotation.Bean; 8 | import org.springframework.context.annotation.Configuration; 9 | import org.springframework.context.annotation.Import; 10 | 11 | @Configuration 12 | @Import({MessageConsumerRedisConfiguration.class, TramConsumerCommonConfiguration.class,}) 13 | public class EventuateTramRedisMessageConsumerConfiguration { 14 | @Bean 15 | public MessageConsumerImplementation messageConsumerImplementation(MessageConsumerRedisImpl messageConsumerRedis) { 16 | return new EventuateTramRedisMessageConsumer(messageConsumerRedis); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /eventuate-tram-db-broker-integration-test/src/test/java/io/eventuate/tram/broker/db/integrationtests/TramIntegrationCustomDBTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.broker.db.integrationtests; 2 | 3 | import io.eventuate.local.testutil.CustomDBCreator; 4 | import io.eventuate.local.testutil.CustomDBTestConfiguration; 5 | import org.junit.Before; 6 | import org.junit.runner.RunWith; 7 | import org.springframework.beans.factory.annotation.Autowired; 8 | import org.springframework.boot.test.context.SpringBootTest; 9 | import org.springframework.test.context.junit4.SpringRunner; 10 | 11 | @RunWith(SpringRunner.class) 12 | @SpringBootTest(classes = {CustomDBTestConfiguration.class, TramIntegrationTestConfiguration.class}) 13 | public class TramIntegrationCustomDBTest extends AbstractTramIntegrationTest { 14 | 15 | @Autowired 16 | private CustomDBCreator customDBCreator; 17 | 18 | @Before 19 | public void createCustomDB() { 20 | customDBCreator.create(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /eventuate-tram-db-broker-integration-test/src/test/java/io/eventuate/tram/broker/db/integrationtests/TramIntegrationTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.broker.db.integrationtests; 2 | 3 | import org.junit.runner.RunWith; 4 | import org.springframework.boot.test.context.SpringBootTest; 5 | import org.springframework.test.context.junit4.SpringRunner; 6 | 7 | @RunWith(SpringRunner.class) 8 | @SpringBootTest(classes = TramIntegrationTestConfiguration.class) 9 | public class TramIntegrationTest extends AbstractTramIntegrationTest { 10 | 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-db-broker-integration-test/src/test/resources/application-mssql.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:sqlserver://${DOCKER_HOST_IP:localhost}:1433;databaseName=eventuate 2 | spring.datasource.username=sa 3 | spring.datasource.password=Eventuate123! 4 | spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver 5 | spring.datasource.driver.class.name=com.microsoft.sqlserver.jdbc.SQLServerDriver 6 | -------------------------------------------------------------------------------- /eventuate-tram-db-broker-integration-test/src/test/resources/application-postgres.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:postgresql://${DOCKER_HOST_IP:localhost}/eventuate 2 | spring.datasource.username=eventuate 3 | spring.datasource.password=eventuate 4 | spring.datasource.driver-class-name=org.postgresql.Driver 5 | spring.datasource.driver.class.name=org.postgresql.Driver 6 | -------------------------------------------------------------------------------- /eventuate-tram-db-broker-integration-test/src/test/resources/application.properties: -------------------------------------------------------------------------------- 1 | logging.level.io.eventuate.messaging=DEBUG 2 | 3 | spring.datasource.url=jdbc:mysql://${DOCKER_HOST_IP:localhost}/eventuate?useSSL=false 4 | spring.datasource.username=mysqluser 5 | spring.datasource.password=mysqlpw 6 | spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 7 | spring.datasource.driver.class.name=com.mysql.cj.jdbc.Driver 8 | 9 | eventuatelocal.kafka.bootstrap.servers=${DOCKER_HOST_IP:localhost}:9092 10 | eventuatelocal.cdc.db.user.name=root 11 | eventuatelocal.cdc.db.password=rootpassword 12 | eventuatelocal.zookeeper.connection.string=${DOCKER_HOST_IP:localhost}:2181 13 | 14 | 15 | eventuate.local.kafka.consumer.properties.session.timeout.ms=15000 16 | 17 | activemq.url=tcp://${DOCKER_HOST_IP:localhost}:61616 18 | activemq.user=eventuateuser 19 | activemq.password=eventuatepassword 20 | 21 | rabbitmq.broker.addresses=${DOCKER_HOST_IP:localhost} 22 | 23 | eventuate.redis.servers=${DOCKER_HOST_IP:localhost}:6379 24 | eventuate.redis.partitions=1 -------------------------------------------------------------------------------- /eventuate-tram-db-broker-integration-test/src/test/resources/custom-db-mysql-schema.sql: -------------------------------------------------------------------------------- 1 | CREATE DATABASE IF NOT EXISTS custom; 2 | GRANT ALL PRIVILEGES ON custom.* TO 'mysqluser'@'%' WITH GRANT OPTION; 3 | 4 | USE custom; 5 | 6 | DROP Table IF Exists message; 7 | DROP Table IF Exists received_messages; 8 | DROP Table IF Exists offset_store; 9 | 10 | CREATE TABLE message ( 11 | id VARCHAR(255) PRIMARY KEY, 12 | destination VARCHAR(1000) NOT NULL, 13 | headers VARCHAR(1000) NOT NULL, 14 | payload VARCHAR(1000) NOT NULL, 15 | published SMALLINT DEFAULT 0, 16 | message_partition SMALLINT, 17 | creation_time BIGINT 18 | ); 19 | 20 | CREATE INDEX message_published_idx ON message(published, id); 21 | 22 | CREATE TABLE received_messages ( 23 | consumer_id VARCHAR(255), 24 | message_id VARCHAR(255), 25 | PRIMARY KEY(consumer_id, message_id), 26 | creation_time BIGINT 27 | ); 28 | 29 | CREATE TABLE offset_store( 30 | client_name VARCHAR(255) NOT NULL PRIMARY KEY, 31 | serialized_offset VARCHAR(255) 32 | ); -------------------------------------------------------------------------------- /eventuate-tram-db-broker-integration-test/src/test/resources/customdb.properties: -------------------------------------------------------------------------------- 1 | eventuate.database.schema=custom 2 | data.file=file:src/test/resources/custom-db-mysql-schema.sql -------------------------------------------------------------------------------- /eventuate-tram-events/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | 5 | api "io.eventuate.common:eventuate-common-json-mapper:$eventuateCommonVersion" 6 | 7 | api "javax.annotation:javax.annotation-api:1.3.2" 8 | 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/common/DefaultDomainEventNameMapping.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.common; 2 | 3 | public class DefaultDomainEventNameMapping implements DomainEventNameMapping { 4 | 5 | @Override 6 | public String eventToExternalEventType(String aggregateType, DomainEvent event) { 7 | return event.getClass().getName(); 8 | } 9 | 10 | @Override 11 | public String externalEventTypeToEventClassName(String aggregateType, String eventTypeHeader) { 12 | return eventTypeHeader; 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/common/DomainEvent.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.common; 2 | 3 | public interface DomainEvent { 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/common/DomainEventNameMapping.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.common; 2 | 3 | /** 4 | * Maps between event class names and external event types 5 | */ 6 | public interface DomainEventNameMapping { 7 | 8 | String eventToExternalEventType(String aggregateType, DomainEvent event); 9 | String externalEventTypeToEventClassName(String aggregateType, String eventTypeHeader); 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/common/EventMessageHeaders.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.common; 2 | 3 | public class EventMessageHeaders { 4 | public static final String EVENT_TYPE = "event-type"; 5 | public static final String AGGREGATE_TYPE = "event-aggregate-type"; 6 | public static final String AGGREGATE_ID = "event-aggregate-id"; 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/publisher/DomainEventPublisher.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.publisher; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | 5 | import java.util.List; 6 | import java.util.Map; 7 | 8 | public interface DomainEventPublisher { 9 | 10 | void publish(String aggregateType, Object aggregateId, List domainEvents); 11 | 12 | void publish(String aggregateType, Object aggregateId, Map headers, List domainEvents); 13 | 14 | default void publish(Class aggregateType, Object aggregateId, List domainEvents) { 15 | publish(aggregateType.getName(), aggregateId, domainEvents); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/publisher/DomainEventPublisherForAggregate.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.publisher; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | 5 | import java.util.List; 6 | 7 | public interface DomainEventPublisherForAggregate { 8 | void publishById(I aggregateId, E event); 9 | void publish(A aggregate, E event); 10 | void publish(A aggregate, List events); 11 | 12 | Class getAggregateClass(); 13 | 14 | Class getEventBaseClass(); 15 | } -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/publisher/ResultWithEvents.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.publisher; 2 | 3 | 4 | import io.eventuate.tram.events.common.DomainEvent; 5 | 6 | import java.util.Arrays; 7 | import java.util.List; 8 | 9 | public class ResultWithEvents { 10 | 11 | public final T result; 12 | public final List events; 13 | 14 | public ResultWithEvents(T result, List events) { 15 | this.result = result; 16 | this.events = events; 17 | } 18 | 19 | public ResultWithEvents(T result, DomainEvent... events) { 20 | this.result = result; 21 | this.events = Arrays.asList(events); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/publisher/ResultWithTypedEvents.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.publisher; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | 5 | import java.util.Collections; 6 | import java.util.List; 7 | 8 | public class ResultWithTypedEvents { 9 | private final Result result; 10 | private final List events; 11 | 12 | public ResultWithTypedEvents(Result result, List events) { 13 | this.result = result; 14 | this.events = events; 15 | } 16 | 17 | public ResultWithTypedEvents(Result result, Event event) { 18 | this(result, Collections.singletonList(event)); 19 | } 20 | 21 | public Result getResult() { 22 | return result; 23 | } 24 | 25 | public List getEvents() { 26 | return events; 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/subscriber/DomainEventDispatcherFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.subscriber; 2 | 3 | import io.eventuate.tram.events.common.DomainEventNameMapping; 4 | import io.eventuate.tram.messaging.consumer.MessageConsumer; 5 | 6 | public class DomainEventDispatcherFactory { 7 | 8 | protected MessageConsumer messageConsumer; 9 | protected DomainEventNameMapping domainEventNameMapping; 10 | 11 | public DomainEventDispatcherFactory(MessageConsumer messageConsumer, DomainEventNameMapping domainEventNameMapping) { 12 | this.messageConsumer = messageConsumer; 13 | this.domainEventNameMapping = domainEventNameMapping; 14 | } 15 | 16 | public DomainEventDispatcher make(String eventDispatcherId, DomainEventHandlers domainEventHandlers) { 17 | DomainEventDispatcher domainEventDispatcher = new DomainEventDispatcher(eventDispatcherId, domainEventHandlers, messageConsumer, domainEventNameMapping); 18 | domainEventDispatcher.initialize(); 19 | return domainEventDispatcher; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/subscriber/DomainEventEnvelope.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.subscriber; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | import io.eventuate.tram.messaging.common.Message; 5 | 6 | public interface DomainEventEnvelope { 7 | String getAggregateId(); 8 | Message getMessage(); 9 | String getAggregateType(); 10 | String getEventId(); 11 | 12 | T getEvent(); 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/main/java/io/eventuate/tram/events/subscriber/DomainEventHandlers.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events.subscriber; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | 5 | import java.util.List; 6 | import java.util.Optional; 7 | import java.util.Set; 8 | 9 | import static java.util.stream.Collectors.toSet; 10 | 11 | public class DomainEventHandlers { 12 | private List handlers; 13 | 14 | public DomainEventHandlers(List handlers) { 15 | this.handlers = handlers; 16 | } 17 | 18 | public Set getAggregateTypesAndEvents() { 19 | return handlers.stream().map(DomainEventHandler::getAggregateType).collect(toSet()); 20 | } 21 | 22 | public List getHandlers() { 23 | return handlers; 24 | } 25 | 26 | public Optional findTargetMethod(Message message) { 27 | return handlers.stream().filter(h -> h.handles(message)).findFirst(); 28 | } 29 | 30 | 31 | } 32 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/test/java/io/eventuate/tram/events/ExampleDomainEvent.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | 5 | public class ExampleDomainEvent implements DomainEvent { 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/test/java/io/eventuate/tram/events/ExampleDomainEventConsumer.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events; 2 | 3 | import io.eventuate.tram.events.subscriber.DomainEventEnvelope; 4 | 5 | public class ExampleDomainEventConsumer { 6 | 7 | public void handleEvent(DomainEventEnvelope event) { 8 | System.out.println("I got an event: " + event); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-events/src/test/java/io/eventuate/tram/events/MyEventHandler.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.events; 2 | 3 | import io.eventuate.tram.events.subscriber.DomainEventEnvelope; 4 | 5 | import java.util.concurrent.BlockingQueue; 6 | import java.util.concurrent.LinkedBlockingQueue; 7 | 8 | public class MyEventHandler { 9 | 10 | private BlockingQueue> receivedEvents = new LinkedBlockingQueue<>(); 11 | 12 | public BlockingQueue> getReceivedEvents() { 13 | return receivedEvents; 14 | } 15 | 16 | public void handleEvent(DomainEventEnvelope de) { 17 | System.out.println(de); 18 | receivedEvents.add(de); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-in-memory-test/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-in-memory") 4 | 5 | api "junit:junit:4.12" 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-in-memory/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | api project(":eventuate-tram-consumer-common") 5 | api project(":eventuate-tram-messaging-producer-common") 6 | 7 | api project(":eventuate-tram-consumer-jdbc") 8 | 9 | api "io.eventuate.common:eventuate-common-id:$eventuateCommonVersion" 10 | api "com.h2database:h2:1.3.166" 11 | api "io.eventuate.common:eventuate-common-in-memory-database:$eventuateCommonVersion" 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-in-memory/src/main/java/io/eventuate/tram/inmemory/EventuateTransactionSynchronizationManager.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.inmemory; 2 | 3 | public interface EventuateTransactionSynchronizationManager { 4 | boolean isTransactionActive(); 5 | void executeAfterTransaction(Runnable runnable); 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-in-memory/src/main/java/io/eventuate/tram/inmemory/MessageHandlerWithSubscriberId.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.inmemory; 2 | 3 | import io.eventuate.tram.messaging.common.SubscriberIdAndMessage; 4 | 5 | import java.util.function.Consumer; 6 | 7 | public class MessageHandlerWithSubscriberId { 8 | 9 | private String subscriber; 10 | private Consumer messageHandler; 11 | 12 | public MessageHandlerWithSubscriberId(String subscriber, Consumer messageHandler) { 13 | this.subscriber = subscriber; 14 | this.messageHandler = messageHandler; 15 | } 16 | 17 | public String getSubscriber() { 18 | return subscriber; 19 | } 20 | 21 | public Consumer getMessageHandler() { 22 | return messageHandler; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /eventuate-tram-in-memory/src/main/resources/eventuate-tram-embedded-schema.sql: -------------------------------------------------------------------------------- 1 | CREATE SCHEMA IF NOT EXISTS eventuate AUTHORIZATION SA; 2 | 3 | drop table if exists eventuate.message; 4 | 5 | CREATE TABLE eventuate.message ( 6 | ID VARCHAR(1000) PRIMARY KEY, 7 | DESTINATION VARCHAR(1000) NOT NULL, 8 | HEADERS VARCHAR(1000) NOT NULL, 9 | PAYLOAD VARCHAR(1000) NOT NULL, 10 | MESSAGE_PARTITION SMALLINT, 11 | CREATION_TIME BIGINT 12 | ); 13 | 14 | drop table if exists eventuate.received_messages; 15 | 16 | CREATE TABLE eventuate.received_messages ( 17 | CONSUMER_ID VARCHAR(1000), 18 | MESSAGE_ID VARCHAR(1000), 19 | CREATION_TIME BIGINT, 20 | PRIMARY KEY(CONSUMER_ID, MESSAGE_ID) 21 | ); 22 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-jdbc-kafka") 4 | api project(":eventuate-tram-jdbc-rabbitmq") 5 | api project(":eventuate-tram-jdbc-activemq") 6 | api project(":eventuate-tram-jdbc-redis") 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/src/main/java/io/eventuate/tram/integrationtest/common/MySqlBinlogKafkaCondition.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.integrationtest.common; 2 | 3 | import org.springframework.context.annotation.Condition; 4 | import org.springframework.context.annotation.ConditionContext; 5 | import org.springframework.core.type.AnnotatedTypeMetadata; 6 | 7 | public class MySqlBinlogKafkaCondition implements Condition { 8 | @Override 9 | public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 10 | return !context.getEnvironment().acceptsProfiles("EventuatePolling") && 11 | !context.getEnvironment().acceptsProfiles("PostgresWal") && 12 | !context.getEnvironment().acceptsProfiles("ActiveMQ") && 13 | !context.getEnvironment().acceptsProfiles("RabbitMQ") && 14 | !context.getEnvironment().acceptsProfiles("Redis"); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/src/main/java/io/eventuate/tram/integrationtest/common/MySqlBinlogRedisCondition.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.integrationtest.common; 2 | 3 | import org.springframework.context.annotation.Condition; 4 | import org.springframework.context.annotation.ConditionContext; 5 | import org.springframework.core.type.AnnotatedTypeMetadata; 6 | 7 | public class MySqlBinlogRedisCondition implements Condition { 8 | @Override 9 | public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 10 | return !context.getEnvironment().acceptsProfiles("EventuatePolling") && 11 | !context.getEnvironment().acceptsProfiles("PostgresWal") && 12 | context.getEnvironment().acceptsProfiles("Redis"); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/src/main/java/io/eventuate/tram/integrationtest/common/PollingActiveMQCondition.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.integrationtest.common; 2 | 3 | import org.springframework.context.annotation.Condition; 4 | import org.springframework.context.annotation.ConditionContext; 5 | import org.springframework.core.type.AnnotatedTypeMetadata; 6 | 7 | public class PollingActiveMQCondition implements Condition { 8 | @Override 9 | public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 10 | return context.getEnvironment().acceptsProfiles("EventuatePolling") && 11 | context.getEnvironment().acceptsProfiles("ActiveMQ"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/src/main/java/io/eventuate/tram/integrationtest/common/PostgresWalRabbitMQCondition.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.integrationtest.common; 2 | 3 | import org.springframework.context.annotation.Condition; 4 | import org.springframework.context.annotation.ConditionContext; 5 | import org.springframework.core.type.AnnotatedTypeMetadata; 6 | 7 | public class PostgresWalRabbitMQCondition implements Condition { 8 | @Override 9 | public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 10 | return context.getEnvironment().acceptsProfiles("PostgresWal") && 11 | context.getEnvironment().acceptsProfiles("RabbitMQ"); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/src/main/java/io/eventuate/tram/integrationtest/common/TramIntegrationTestMySqlBinlogKafkaConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.integrationtest.common; 2 | 3 | import io.eventuate.tram.spring.jdbckafka.TramJdbcKafkaConfiguration; 4 | import org.springframework.context.annotation.Conditional; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import(TramJdbcKafkaConfiguration.class) 10 | @Conditional(MySqlBinlogKafkaCondition.class) 11 | public class TramIntegrationTestMySqlBinlogKafkaConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/src/main/java/io/eventuate/tram/integrationtest/common/TramIntegrationTestMySqlBinlogRedisConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.integrationtest.common; 2 | 3 | import io.eventuate.tram.jdbcredis.TramJdbcRedisConfiguration; 4 | import org.springframework.context.annotation.Conditional; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import(TramJdbcRedisConfiguration.class) 10 | @Conditional(MySqlBinlogRedisCondition.class) 11 | public class TramIntegrationTestMySqlBinlogRedisConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/src/main/java/io/eventuate/tram/integrationtest/common/TramIntegrationTestPollingActiveMQConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.integrationtest.common; 2 | 3 | import io.eventuate.tram.jdbcactivemq.TramJdbcActiveMQConfiguration; 4 | import org.springframework.context.annotation.Conditional; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import(TramJdbcActiveMQConfiguration.class) 10 | @Conditional(PollingActiveMQCondition.class) 11 | public class TramIntegrationTestPollingActiveMQConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-integration-test-common/src/main/java/io/eventuate/tram/integrationtest/common/TramIntegrationTestPostgresWalRabbitMQConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.integrationtest.common; 2 | 3 | import io.eventuate.tram.jdbcrabbitmq.TramJdbcRabbitMQConfiguration; 4 | import org.springframework.context.annotation.Conditional; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import(TramJdbcRabbitMQConfiguration.class) 10 | @Conditional(PostgresWalRabbitMQCondition.class) 11 | public class TramIntegrationTestPostgresWalRabbitMQConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-jdbc-activemq/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | 4 | api project(":eventuate-tram-spring-consumer-common") 5 | api project(":eventuate-tram-spring-producer-jdbc") 6 | api project(":eventuate-tram-spring-consumer-jdbc") 7 | api project(":eventuate-tram-consumer-activemq") 8 | 9 | api "io.eventuate.messaging.activemq:eventuate-messaging-activemq-spring-consumer:$eventuateMessagingActiveMQVersion" 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-jdbc-activemq/src/main/java/io/eventuate/tram/jdbcactivemq/TramJdbcActiveMQConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.jdbcactivemq; 2 | 3 | import io.eventuate.tram.consumer.activemq.EventuateTramActiveMQMessageConsumerConfiguration; 4 | import io.eventuate.tram.spring.messaging.producer.jdbc.TramMessageProducerJdbcConfiguration; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import({TramMessageProducerJdbcConfiguration.class, EventuateTramActiveMQMessageConsumerConfiguration.class}) 10 | public class TramJdbcActiveMQConfiguration { 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-jdbc-rabbitmq/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "io.eventuate.messaging.rabbitmq:eventuate-messaging-rabbitmq-spring-consumer:$eventuateMessagingRabbitMQVersion" 4 | 5 | api project(":eventuate-tram-spring-consumer-common") 6 | api project(":eventuate-tram-spring-producer-jdbc") 7 | api project(":eventuate-tram-spring-consumer-jdbc") 8 | api project(":eventuate-tram-consumer-rabbitmq") 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-jdbc-rabbitmq/src/main/java/io/eventuate/tram/jdbcrabbitmq/TramJdbcRabbitMQConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.jdbcrabbitmq; 2 | 3 | import io.eventuate.tram.consumer.rabbitmq.EventuateTramRabbitMQMessageConsumerConfiguration; 4 | import io.eventuate.tram.spring.messaging.producer.jdbc.TramMessageProducerJdbcConfiguration; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import({TramMessageProducerJdbcConfiguration.class, 10 | EventuateTramRabbitMQMessageConsumerConfiguration.class}) 11 | public class TramJdbcRabbitMQConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-jdbc-redis/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "io.eventuate.messaging.redis:eventuate-messaging-redis-spring-consumer:$eventuateMessagingRedisVersion" 4 | 5 | api project(":eventuate-tram-spring-consumer-common") 6 | api project(":eventuate-tram-spring-producer-jdbc") 7 | api project(":eventuate-tram-spring-consumer-jdbc") 8 | api project(":eventuate-tram-consumer-redis") 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-jdbc-redis/src/main/java/io/eventuate/tram/jdbcredis/TramJdbcRedisConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.jdbcredis; 2 | 3 | import io.eventuate.tram.consumer.redis.EventuateTramRedisMessageConsumerConfiguration; 4 | import io.eventuate.tram.spring.messaging.producer.jdbc.TramMessageProducerJdbcConfiguration; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import({TramMessageProducerJdbcConfiguration.class, EventuateTramRedisMessageConsumerConfiguration.class}) 10 | public class TramJdbcRedisConfiguration { 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-messaging-producer-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | 5 | api "org.slf4j:slf4j-api:1.7.18" 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-messaging-producer-common/src/main/java/io/eventuate/tram/messaging/producer/common/MessageProducerImplementation.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.producer.common; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | 5 | public interface MessageProducerImplementation { 6 | 7 | void send(Message message); 8 | 9 | default void setMessageIdIfNecessary(Message message) { 10 | //do nothing by default 11 | } 12 | 13 | default void withContext(Runnable runnable) { 14 | runnable.run(); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /eventuate-tram-messaging-producer-common/src/test/java/io/eventuate/tram/messaging/producer/common/HttpDateHeaderFormatUtilTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.producer.common; 2 | 3 | import io.eventuate.tram.messaging.producer.HttpDateHeaderFormatUtil; 4 | import org.junit.Assert; 5 | import org.junit.Test; 6 | 7 | import java.time.ZonedDateTime; 8 | import java.time.format.DateTimeFormatter; 9 | 10 | import static junit.framework.TestCase.assertEquals; 11 | 12 | public class HttpDateHeaderFormatUtilTest { 13 | 14 | @Test 15 | public void shouldFormatDateNow() { 16 | Assert.assertNotNull((HttpDateHeaderFormatUtil.nowAsHttpDateString())); 17 | } 18 | 19 | @Test 20 | public void shouldFormatDate() { 21 | String expected = "Tue, 15 Nov 1994 08:12:31 GMT"; 22 | ZonedDateTime time = ZonedDateTime.parse(expected, DateTimeFormatter.RFC_1123_DATE_TIME); 23 | assertEquals(expected, HttpDateHeaderFormatUtil.timeAsHttpDateString(time)); 24 | } 25 | 26 | } -------------------------------------------------------------------------------- /eventuate-tram-messaging/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "commons-lang:commons-lang:2.6" 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/common/ChannelMapping.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.common; 2 | 3 | public interface ChannelMapping { 4 | 5 | String transform(String channel); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/common/Message.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.common; 2 | 3 | import java.util.Map; 4 | import java.util.Optional; 5 | 6 | /** 7 | * A message 8 | * @see io.eventuate.tram.messaging.producer.MessageBuilder 9 | */ 10 | public interface Message { 11 | 12 | String getId(); 13 | Map getHeaders(); 14 | String getPayload(); 15 | 16 | String ID = "ID"; 17 | String PARTITION_ID = "PARTITION_ID"; 18 | String DESTINATION = "DESTINATION"; 19 | String DATE = "DATE"; 20 | 21 | Optional getHeader(String name); 22 | String getRequiredHeader(String name); 23 | 24 | boolean hasHeader(String name); 25 | 26 | void setPayload(String payload); 27 | void setHeaders(Map headers); 28 | void setHeader(String name, String value); 29 | void removeHeader(String key); 30 | } 31 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/common/MessageInterceptor.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.common; 2 | 3 | public interface MessageInterceptor { 4 | 5 | default void preSend(Message message) {} 6 | default void postSend(Message message, Exception e) {} 7 | 8 | default void preReceive(Message message) {} 9 | default void preHandle(String subscriberId, Message message) {} 10 | default void postHandle(String subscriberId, Message message, Throwable throwable) {} 11 | default void postReceive(Message message) {} 12 | 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/common/SubscriberIdAndMessage.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.common; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | 5 | public class SubscriberIdAndMessage { 6 | 7 | private String subscriberId; 8 | private Message message; 9 | 10 | public SubscriberIdAndMessage(String subscriberId, Message message) { 11 | this.subscriberId = subscriberId; 12 | this.message = message; 13 | } 14 | 15 | public String getSubscriberId() { 16 | return subscriberId; 17 | } 18 | 19 | public Message getMessage() { 20 | return message; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/consumer/BuiltInMessageHandlerDecoratorOrder.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.consumer; 2 | 3 | public class BuiltInMessageHandlerDecoratorOrder { 4 | public static int PRE_POST_RECEIVE_MESSAGE_HANDLER_DECORATOR = 100; 5 | public static int DUPLICATE_DETECTING_MESSAGE_HANDLER_DECORATOR = 200; 6 | public static int PRE_POST_HANDLER_MESSAGE_HANDLER_DECORATOR = 300; 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/consumer/DefaultSubscriberMapping.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.consumer; 2 | 3 | public class DefaultSubscriberMapping implements SubscriberMapping { 4 | 5 | @Override 6 | public String toExternal(String subscriberId) { 7 | return subscriberId; 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/consumer/MessageConsumer.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.consumer; 2 | 3 | import java.util.Set; 4 | 5 | public interface MessageConsumer { 6 | MessageSubscription subscribe(String subscriberId, Set channels, MessageHandler handler); 7 | String getId(); 8 | void close(); 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/consumer/MessageHandler.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.consumer; 2 | 3 | 4 | import io.eventuate.tram.messaging.common.Message; 5 | 6 | import java.util.function.Consumer; 7 | 8 | public interface MessageHandler extends Consumer { 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/consumer/MessageSubscription.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.consumer; 2 | 3 | public interface MessageSubscription { 4 | 5 | void unsubscribe(); 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/consumer/SubscriberMapping.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.consumer; 2 | 3 | public interface SubscriberMapping { 4 | 5 | String toExternal(String subscriberId); 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/producer/HttpDateHeaderFormatUtil.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.producer; 2 | 3 | import java.time.ZoneId; 4 | import java.time.ZonedDateTime; 5 | import java.time.format.DateTimeFormatter; 6 | 7 | public class HttpDateHeaderFormatUtil { 8 | public static String nowAsHttpDateString() { 9 | return timeAsHttpDateString(ZonedDateTime.now(ZoneId.of("GMT"))); 10 | } 11 | 12 | public static String timeAsHttpDateString(ZonedDateTime gmtTime) { 13 | return gmtTime.format(DateTimeFormatter.RFC_1123_DATE_TIME); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-messaging/src/main/java/io/eventuate/tram/messaging/producer/MessageProducer.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.messaging.producer; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | 5 | public interface MessageProducer { 6 | 7 | /** 8 | * Send a message 9 | * @param destination the destination channel 10 | * @param message the message to doSend 11 | * @see Message 12 | */ 13 | void send(String destination, Message message); 14 | 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-commands/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id "io.spring.dependency-management" version "1.0.6.RELEASE" 3 | } 4 | 5 | 6 | 7 | 8 | dependencyManagement { 9 | imports { 10 | mavenBom "io.micronaut:micronaut-bom:$micronautVersion" 11 | } 12 | } 13 | 14 | dependencies { 15 | api project(":eventuate-tram-commands") 16 | 17 | annotationProcessor "io.micronaut:micronaut-inject-java" 18 | annotationProcessor "io.micronaut:micronaut-validation" 19 | annotationProcessor "io.micronaut.configuration:micronaut-openapi" 20 | api "io.micronaut:micronaut-inject" 21 | api "io.micronaut:micronaut-validation" 22 | api "io.micronaut:micronaut-runtime" 23 | 24 | testAnnotationProcessor "io.micronaut:micronaut-inject-java" 25 | testImplementation "org.junit.jupiter:junit-jupiter-api" 26 | testImplementation "io.micronaut.test:micronaut-test-junit5" 27 | testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine" 28 | } 29 | 30 | // use JUnit 5 platform 31 | test { 32 | useJUnitPlatform() 33 | } 34 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-commands/src/main/java/io/eventuate/tram/micronaut/commands/CommandDispatcherInitializer.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.commands; 2 | 3 | import io.eventuate.tram.commands.consumer.CommandDispatcher; 4 | import io.micronaut.context.annotation.Context; 5 | import org.slf4j.Logger; 6 | import org.slf4j.LoggerFactory; 7 | 8 | import javax.annotation.PostConstruct; 9 | import javax.inject.Inject; 10 | import java.util.Arrays; 11 | 12 | @Context 13 | public class CommandDispatcherInitializer { 14 | private Logger logger = LoggerFactory.getLogger(getClass()); 15 | 16 | @Inject 17 | private CommandDispatcher[] commandDispatchers; 18 | 19 | @PostConstruct 20 | public void init() { 21 | logger.info("initializing command dispatchers"); 22 | Arrays.stream(commandDispatchers).forEach(CommandDispatcher::initialize); 23 | logger.info("initialized command dispatchers"); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-commands/src/main/java/io/eventuate/tram/micronaut/commands/common/TramCommandCommonFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.commands.common; 2 | 3 | import io.eventuate.tram.commands.common.CommandNameMapping; 4 | import io.eventuate.tram.commands.common.DefaultCommandNameMapping; 5 | import io.micronaut.context.annotation.Factory; 6 | import io.micronaut.context.annotation.Requires; 7 | 8 | import javax.inject.Singleton; 9 | 10 | @Factory 11 | public class TramCommandCommonFactory { 12 | 13 | @Singleton 14 | @Requires(missingBeans = CommandNameMapping.class) 15 | public CommandNameMapping domainEventNameMapping() { 16 | return new DefaultCommandNameMapping(); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-commands/src/main/java/io/eventuate/tram/micronaut/commands/producer/TramCommandProducerFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.commands.producer; 2 | 3 | import io.eventuate.tram.commands.common.CommandNameMapping; 4 | import io.eventuate.tram.commands.producer.CommandProducer; 5 | import io.eventuate.tram.commands.producer.CommandProducerImpl; 6 | import io.eventuate.tram.messaging.common.ChannelMapping; 7 | import io.eventuate.tram.messaging.producer.MessageProducer; 8 | import io.micronaut.context.annotation.Factory; 9 | 10 | import javax.inject.Singleton; 11 | 12 | @Factory 13 | public class TramCommandProducerFactory { 14 | @Singleton 15 | public CommandProducer commandProducer(MessageProducer messageProducer, ChannelMapping channelMapping, CommandNameMapping commandNameMapping) { 16 | return new CommandProducerImpl(messageProducer, commandNameMapping); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-commands/src/test/java/io/eventuate/tram/micronaut/commands/common/TramCommandCommonFactoryTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.commands.common; 2 | 3 | import io.eventuate.tram.commands.common.CommandNameMapping; 4 | import io.micronaut.test.annotation.MicronautTest; 5 | import org.junit.jupiter.api.Assertions; 6 | import org.junit.jupiter.api.Test; 7 | 8 | import javax.inject.Inject; 9 | 10 | @MicronautTest 11 | public class TramCommandCommonFactoryTest { 12 | 13 | @Inject 14 | CommandNameMapping commandNameMapping; 15 | 16 | @Test 17 | public void shouldLoadCommandNamingBean() { 18 | Assertions.assertNotNull(commandNameMapping); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-common/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id "io.spring.dependency-management" version "1.0.6.RELEASE" 3 | } 4 | 5 | 6 | 7 | 8 | 9 | dependencyManagement { 10 | imports { 11 | mavenBom "io.micronaut:micronaut-bom:$micronautVersion" 12 | } 13 | } 14 | 15 | dependencies { 16 | api project(":eventuate-tram-consumer-common") 17 | 18 | annotationProcessor "io.micronaut:micronaut-inject-java" 19 | annotationProcessor "io.micronaut:micronaut-validation" 20 | annotationProcessor "io.micronaut.configuration:micronaut-openapi" 21 | api "io.micronaut:micronaut-inject" 22 | api "io.micronaut:micronaut-validation" 23 | api "io.micronaut:micronaut-runtime" 24 | } 25 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-common/src/main/java/io/eventuate/tram/micronaut/consumer/common/TramNoopDuplicateMessageDetectorFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.consumer.common; 2 | 3 | import io.eventuate.tram.consumer.common.DuplicateMessageDetector; 4 | import io.eventuate.tram.consumer.common.NoopDuplicateMessageDetector; 5 | import io.micronaut.context.annotation.Factory; 6 | import io.micronaut.context.annotation.Requires; 7 | 8 | import javax.inject.Singleton; 9 | 10 | @Factory 11 | public class TramNoopDuplicateMessageDetectorFactory { 12 | 13 | @Singleton 14 | @Requires(missingBeans = DuplicateMessageDetector.class) 15 | public DuplicateMessageDetector duplicateMessageDetector() { 16 | return new NoopDuplicateMessageDetector(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-jdbc/src/main/java/io/eventuate/tram/micronaut/consumer/jdbc/TransactionalNoopDuplicateMessageDetectorFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.consumer.jdbc; 2 | 3 | import io.eventuate.common.jdbc.EventuateTransactionTemplate; 4 | import io.eventuate.tram.consumer.common.DuplicateMessageDetector; 5 | import io.eventuate.tram.consumer.jdbc.TransactionalNoopDuplicateMessageDetector; 6 | import io.micronaut.context.annotation.Factory; 7 | import io.micronaut.context.annotation.Requires; 8 | import org.springframework.transaction.support.TransactionTemplate; 9 | 10 | import javax.inject.Singleton; 11 | 12 | @Factory 13 | public class TransactionalNoopDuplicateMessageDetectorFactory { 14 | 15 | @Singleton 16 | @Requires(property = "transactional.noop.duplicate.message.detector.factory.enabled") 17 | public DuplicateMessageDetector duplicateMessageDetector(EventuateTransactionTemplate eventuateTransactionTemplate) { 18 | return new TransactionalNoopDuplicateMessageDetector(eventuateTransactionTemplate); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-jdbc/src/test/java/io/eventuate/tram/micronaut/consumer/jdbc/EventuateMicronautSqlTableBasedDuplicateMessageDetectorTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.consumer.jdbc; 2 | 3 | import io.eventuate.tram.consumer.common.DuplicateMessageDetector; 4 | import io.micronaut.test.annotation.MicronautTest; 5 | import org.junit.jupiter.api.Test; 6 | 7 | import javax.inject.Inject; 8 | 9 | import static org.junit.Assert.assertFalse; 10 | import static org.junit.Assert.assertTrue; 11 | 12 | @MicronautTest 13 | public class EventuateMicronautSqlTableBasedDuplicateMessageDetectorTest { 14 | 15 | @Inject 16 | private DuplicateMessageDetector duplicateMessageDetector; 17 | 18 | @Test 19 | public void shouldDetectDuplicate() { 20 | String consumerId = getClass().getName(); 21 | String messageId = Long.toString(System.currentTimeMillis()); 22 | 23 | assertFalse(duplicateMessageDetector.isDuplicate(consumerId, messageId)); 24 | assertTrue(duplicateMessageDetector.isDuplicate(consumerId, messageId)); 25 | } 26 | 27 | } -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-jdbc/src/test/resources/application-mssql.yml: -------------------------------------------------------------------------------- 1 | datasources: 2 | default: 3 | url: jdbc:sqlserver://${$DOCKER_HOST_IP:localhost}:1433;databaseName=eventuate 4 | username: sa 5 | password: Eventuate123! 6 | driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-jdbc/src/test/resources/application-postgres.yml: -------------------------------------------------------------------------------- 1 | datasources: 2 | default: 3 | url: jdbc:postgresql://${$DOCKER_HOST_IP:localhost}/eventuate 4 | username: eventuate 5 | password: eventuate 6 | driverClassName: org.postgresql.Driver -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-jdbc/src/test/resources/application.yml: -------------------------------------------------------------------------------- 1 | datasources: 2 | default: 3 | url: jdbc:mysql://${$DOCKER_HOST_IP:localhost}/eventuate 4 | username: mysqluser 5 | password: mysqlpw 6 | driverClassName: com.mysql.cj.jdbc.Driver -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-kafka/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id "io.spring.dependency-management" version "1.0.6.RELEASE" 3 | } 4 | 5 | 6 | 7 | 8 | 9 | dependencyManagement { 10 | imports { 11 | mavenBom "io.micronaut:micronaut-bom:$micronautVersion" 12 | } 13 | } 14 | 15 | dependencies { 16 | api project (":eventuate-tram-micronaut-consumer-common") 17 | api project(":eventuate-tram-micronaut-messaging") 18 | api project(":eventuate-tram-consumer-kafka") 19 | api "io.eventuate.messaging.kafka:eventuate-messaging-kafka-micronaut-consumer:$eventuateMessagingKafkaVersion" 20 | 21 | annotationProcessor "io.micronaut:micronaut-inject-java" 22 | annotationProcessor "io.micronaut:micronaut-validation" 23 | annotationProcessor "io.micronaut.configuration:micronaut-openapi" 24 | api "io.micronaut:micronaut-inject" 25 | api "io.micronaut:micronaut-validation" 26 | api "io.micronaut:micronaut-runtime" 27 | } 28 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-consumer-kafka/src/main/java/io/eventuate/tram/micronaut/consumer/kafka/EventuateTramKafkaMessageConsumerFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.consumer.kafka; 2 | 3 | import io.eventuate.messaging.kafka.consumer.MessageConsumerKafkaImpl; 4 | import io.eventuate.tram.consumer.common.MessageConsumerImplementation; 5 | import io.eventuate.tram.consumer.kafka.EventuateTramKafkaMessageConsumer; 6 | import io.micronaut.context.annotation.Factory; 7 | 8 | import javax.inject.Singleton; 9 | 10 | @Factory 11 | public class EventuateTramKafkaMessageConsumerFactory { 12 | @Singleton 13 | public MessageConsumerImplementation messageConsumerImplementation(MessageConsumerKafkaImpl messageConsumerKafka) { 14 | return new EventuateTramKafkaMessageConsumer(messageConsumerKafka); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-data-jdbc-optimistic-locking/src/test/java/io/eventuate/tram/micronaut/data/jdbc/optimistic/locking/AbstractEventuateMicronautOptimisticLockingTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.data.jdbc.optimistic.locking; 2 | 3 | import io.eventuate.tram.consumer.common.MessageHandlerDecorator; 4 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.AbstractEventuateOptimisticLockingTest; 5 | 6 | import javax.inject.Inject; 7 | 8 | abstract public class AbstractEventuateMicronautOptimisticLockingTest extends AbstractEventuateOptimisticLockingTest { 9 | 10 | @Inject 11 | private OptimisticLockingDecorator optimisticLockingDecorator; 12 | 13 | @Override 14 | public MessageHandlerDecorator getOptimisticLockingDecorator() { 15 | return optimisticLockingDecorator; 16 | } 17 | } -------------------------------------------------------------------------------- /eventuate-tram-micronaut-data-jdbc-optimistic-locking/src/test/java/io/eventuate/tram/micronaut/data/jdbc/optimistic/locking/EventuateMicronautOptimisticLockingWithAnnotationTransactionTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.data.jdbc.optimistic.locking; 2 | 3 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.AbstractTestEntityService; 4 | import io.micronaut.test.annotation.MicronautTest; 5 | import org.junit.jupiter.api.Test; 6 | 7 | import javax.inject.Inject; 8 | 9 | @MicronautTest(transactional = false) 10 | public class EventuateMicronautOptimisticLockingWithAnnotationTransactionTest extends AbstractEventuateMicronautOptimisticLockingTest { 11 | 12 | @Inject 13 | private TestEntityServiceTransactionAnnotation testEntityService; 14 | 15 | @Override 16 | protected AbstractTestEntityService testEntityService() { 17 | return testEntityService; 18 | } 19 | 20 | @Override 21 | @Test 22 | public void shouldRetryOnLockException() throws InterruptedException { 23 | super.shouldRetryOnLockException(); 24 | } 25 | } -------------------------------------------------------------------------------- /eventuate-tram-micronaut-data-jdbc-optimistic-locking/src/test/java/io/eventuate/tram/micronaut/data/jdbc/optimistic/locking/EventuateMicronautOptimisticLockingWithTransactionTemplateTransactionTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.data.jdbc.optimistic.locking; 2 | 3 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.AbstractTestEntityService; 4 | import io.micronaut.test.annotation.MicronautTest; 5 | import org.junit.jupiter.api.Test; 6 | 7 | import javax.inject.Inject; 8 | 9 | @MicronautTest(transactional = false) 10 | public class EventuateMicronautOptimisticLockingWithTransactionTemplateTransactionTest extends AbstractEventuateMicronautOptimisticLockingTest { 11 | 12 | @Inject 13 | private TestEntityServiceTransactionTemplate testEntityService; 14 | 15 | @Override 16 | protected AbstractTestEntityService testEntityService() { 17 | return testEntityService; 18 | } 19 | 20 | @Override 21 | @Test 22 | public void shouldRetryOnLockException() throws InterruptedException { 23 | super.shouldRetryOnLockException(); 24 | } 25 | } -------------------------------------------------------------------------------- /eventuate-tram-micronaut-data-jdbc-optimistic-locking/src/test/java/io/eventuate/tram/micronaut/data/jdbc/optimistic/locking/TestEntityRepositoryImpl.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.data.jdbc.optimistic.locking; 2 | 3 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.TestEntity; 4 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.TestEntityRepository; 5 | 6 | import javax.inject.Singleton; 7 | import javax.persistence.EntityManager; 8 | import javax.persistence.PersistenceContext; 9 | 10 | @Singleton 11 | public class TestEntityRepositoryImpl implements TestEntityRepository { 12 | @PersistenceContext 13 | private EntityManager entityManager; 14 | 15 | @Override 16 | public TestEntity find(Long entityId) { 17 | return entityManager.find(TestEntity.class, entityId); 18 | } 19 | 20 | @Override 21 | public void persist(TestEntity testEntity) { 22 | entityManager.persist(testEntity); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-data-jdbc-optimistic-locking/src/test/resources/application-mssql.yml: -------------------------------------------------------------------------------- 1 | datasources: 2 | default: 3 | url: jdbc:sqlserver://${$DOCKER_HOST_IP:localhost}:1433;databaseName=eventuate 4 | username: sa 5 | password: Eventuate123! 6 | driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver -------------------------------------------------------------------------------- /eventuate-tram-micronaut-data-jdbc-optimistic-locking/src/test/resources/application-postgres.yml: -------------------------------------------------------------------------------- 1 | datasources: 2 | default: 3 | url: jdbc:postgresql://${$DOCKER_HOST_IP:localhost}/eventuate 4 | username: eventuate 5 | password: eventuate 6 | driverClassName: org.postgresql.Driver -------------------------------------------------------------------------------- /eventuate-tram-micronaut-data-jdbc-optimistic-locking/src/test/resources/application.yml: -------------------------------------------------------------------------------- 1 | datasources: 2 | default: 3 | url: jdbc:mysql://${$DOCKER_HOST_IP:localhost}/eventuate 4 | username: mysqluser 5 | password: mysqlpw 6 | driverClassName: com.mysql.cj.jdbc.Driver 7 | jpa: 8 | default: 9 | packages-to-scan: 10 | - 'io.eventuate.tram.jdbc.optimistic.locking.common.test' 11 | properties: 12 | hibernate: 13 | hbm2ddl: 14 | auto: update 15 | show_sql: true 16 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-events/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id "io.spring.dependency-management" version "1.0.6.RELEASE" 3 | } 4 | 5 | 6 | 7 | 8 | 9 | dependencyManagement { 10 | imports { 11 | mavenBom "io.micronaut:micronaut-bom:$micronautVersion" 12 | } 13 | } 14 | 15 | dependencies { 16 | api project(":eventuate-tram-events") 17 | 18 | annotationProcessor "io.micronaut:micronaut-inject-java" 19 | annotationProcessor "io.micronaut:micronaut-validation" 20 | annotationProcessor "io.micronaut.configuration:micronaut-openapi" 21 | api "io.micronaut:micronaut-inject" 22 | api "io.micronaut:micronaut-validation" 23 | api "io.micronaut:micronaut-runtime" 24 | } 25 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-events/src/main/java/io/eventuate/tram/micronaut/events/common/TramEventsCommonFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.events.common; 2 | 3 | import io.eventuate.tram.events.common.DefaultDomainEventNameMapping; 4 | import io.eventuate.tram.events.common.DomainEventNameMapping; 5 | import io.micronaut.context.annotation.Factory; 6 | import io.micronaut.context.annotation.Requires; 7 | 8 | import javax.inject.Singleton; 9 | 10 | @Factory 11 | public class TramEventsCommonFactory { 12 | 13 | @Singleton 14 | @Requires(missingBeans = DomainEventNameMapping.class) 15 | public DomainEventNameMapping domainEventNameMapping() { 16 | return new DefaultDomainEventNameMapping(); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-events/src/main/java/io/eventuate/tram/micronaut/events/publisher/TramEventsPublisherFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.events.publisher; 2 | 3 | import io.eventuate.tram.events.common.DomainEventNameMapping; 4 | import io.eventuate.tram.events.publisher.DomainEventPublisher; 5 | import io.eventuate.tram.events.publisher.DomainEventPublisherImpl; 6 | import io.eventuate.tram.messaging.producer.MessageProducer; 7 | import io.micronaut.context.annotation.Factory; 8 | 9 | import javax.inject.Singleton; 10 | 11 | @Factory 12 | public class TramEventsPublisherFactory { 13 | 14 | @Singleton 15 | public DomainEventPublisher domainEventPublisher(MessageProducer messageProducer, DomainEventNameMapping domainEventNameMapping) { 16 | return new DomainEventPublisherImpl(messageProducer, domainEventNameMapping); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-events/src/main/java/io/eventuate/tram/micronaut/events/subscriber/TramEventSubscriberFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.events.subscriber; 2 | 3 | import io.eventuate.tram.events.common.DomainEventNameMapping; 4 | import io.eventuate.tram.events.subscriber.DomainEventDispatcherFactory; 5 | import io.eventuate.tram.messaging.consumer.MessageConsumer; 6 | import io.micronaut.context.annotation.Factory; 7 | 8 | import javax.inject.Singleton; 9 | 10 | @Factory 11 | public class TramEventSubscriberFactory { 12 | 13 | @Singleton 14 | public DomainEventDispatcherFactory domainEventDispatcherFactory(MessageConsumer messageConsumer, DomainEventNameMapping domainEventNameMapping) { 15 | return new DomainEventDispatcherFactory(messageConsumer, domainEventNameMapping); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-in-memory/src/main/java/io/eventuate/tram/micronaut/inmemory/EventuateMicronautTransactionSynchronizationManager.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.inmemory; 2 | 3 | import io.eventuate.tram.inmemory.EventuateTransactionSynchronizationManager; 4 | import io.micronaut.transaction.support.TransactionSynchronizationAdapter; 5 | import io.micronaut.transaction.support.TransactionSynchronizationManager; 6 | 7 | public class EventuateMicronautTransactionSynchronizationManager 8 | implements EventuateTransactionSynchronizationManager { 9 | 10 | @Override 11 | public boolean isTransactionActive() { 12 | return TransactionSynchronizationManager.isActualTransactionActive(); 13 | } 14 | 15 | @Override 16 | public void executeAfterTransaction(Runnable callback) { 17 | TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() { 18 | @Override 19 | public void afterCommit() { 20 | callback.run(); 21 | } 22 | }); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-in-memory/src/test/resources/application.yml: -------------------------------------------------------------------------------- 1 | datasources: 2 | default: 3 | url: jdbc:h2:mem:testdb 4 | username: sa 5 | password: test 6 | driverClassName: org.h2.Driver -------------------------------------------------------------------------------- /eventuate-tram-micronaut-jdbc-kafka/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "io.eventuate.messaging.kafka:eventuate-messaging-kafka-micronaut-consumer:$eventuateMessagingKafkaVersion" 4 | 5 | api project(":eventuate-tram-micronaut-producer-jdbc") 6 | api project(":eventuate-tram-micronaut-consumer-common") 7 | api project(":eventuate-tram-micronaut-consumer-jdbc") 8 | api project(":eventuate-tram-micronaut-consumer-kafka") 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-messaging-producer-common/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id "io.spring.dependency-management" version "1.0.6.RELEASE" 3 | } 4 | 5 | 6 | 7 | 8 | 9 | dependencyManagement { 10 | imports { 11 | mavenBom "io.micronaut:micronaut-bom:$micronautVersion" 12 | } 13 | } 14 | 15 | dependencies { 16 | api project(":eventuate-tram-messaging-producer-common") 17 | 18 | annotationProcessor "io.micronaut:micronaut-inject-java" 19 | annotationProcessor "io.micronaut:micronaut-validation" 20 | annotationProcessor "io.micronaut.configuration:micronaut-openapi" 21 | api "io.micronaut:micronaut-inject" 22 | api "io.micronaut:micronaut-validation" 23 | api "io.micronaut:micronaut-runtime" 24 | } 25 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-messaging/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id "io.spring.dependency-management" version "1.0.6.RELEASE" 3 | } 4 | 5 | 6 | 7 | 8 | 9 | dependencyManagement { 10 | imports { 11 | mavenBom "io.micronaut:micronaut-bom:$micronautVersion" 12 | } 13 | } 14 | 15 | dependencies { 16 | api project (":eventuate-tram-messaging") 17 | 18 | annotationProcessor "io.micronaut:micronaut-inject-java" 19 | annotationProcessor "io.micronaut:micronaut-validation" 20 | annotationProcessor "io.micronaut.configuration:micronaut-openapi" 21 | api "io.micronaut:micronaut-inject" 22 | api "io.micronaut:micronaut-validation" 23 | api "io.micronaut:micronaut-runtime" 24 | } 25 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-messaging/src/main/java/io/eventuate/tram/micronaut/messaging/common/TramMessagingCommonFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.micronaut.messaging.common; 2 | 3 | import io.eventuate.tram.messaging.common.ChannelMapping; 4 | import io.eventuate.tram.messaging.common.DefaultChannelMapping; 5 | import io.eventuate.tram.messaging.consumer.DefaultSubscriberMapping; 6 | import io.eventuate.tram.messaging.consumer.SubscriberMapping; 7 | import io.micronaut.context.annotation.Factory; 8 | import io.micronaut.context.annotation.Requires; 9 | 10 | import javax.inject.Singleton; 11 | 12 | @Factory 13 | public class TramMessagingCommonFactory { 14 | 15 | @Singleton 16 | @Requires(missingBeans = ChannelMapping.class) 17 | public ChannelMapping channelMapping() { 18 | return new DefaultChannelMapping.DefaultChannelMappingBuilder().build(); 19 | } 20 | 21 | @Singleton 22 | @Requires(missingBeans = SubscriberMapping.class) 23 | public SubscriberMapping subscriberMapping() { 24 | return new DefaultSubscriberMapping(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /eventuate-tram-micronaut-producer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id "io.spring.dependency-management" version "1.0.6.RELEASE" 3 | } 4 | 5 | 6 | 7 | 8 | 9 | dependencyManagement { 10 | imports { 11 | mavenBom "io.micronaut:micronaut-bom:$micronautVersion" 12 | } 13 | } 14 | 15 | dependencies { 16 | api project(":eventuate-tram-micronaut-messaging") 17 | api project(":eventuate-tram-producer-jdbc") 18 | api project(":eventuate-tram-micronaut-messaging-producer-common") 19 | 20 | api "io.eventuate.common:eventuate-common-micronaut-id:$eventuateCommonVersion" 21 | api "io.eventuate.common:eventuate-common-micronaut-jdbc:$eventuateCommonVersion" 22 | 23 | annotationProcessor "io.micronaut:micronaut-inject-java" 24 | annotationProcessor "io.micronaut:micronaut-validation" 25 | annotationProcessor "io.micronaut.configuration:micronaut-openapi" 26 | api "io.micronaut:micronaut-inject" 27 | api "io.micronaut:micronaut-validation" 28 | api "io.micronaut:micronaut-runtime" 29 | } 30 | 31 | -------------------------------------------------------------------------------- /eventuate-tram-optimistic-locking-common-test/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | api project(":eventuate-tram-consumer-common") 3 | api project(":eventuate-tram-consumer-common") 4 | api "io.eventuate.common:eventuate-common-jdbc:$eventuateCommonVersion" 5 | api 'javax.persistence:javax.persistence-api:2.2' 6 | 7 | api "junit:junit:4.12" 8 | } 9 | -------------------------------------------------------------------------------- /eventuate-tram-optimistic-locking-common-test/src/main/java/io/eventuate/tram/jdbc/optimistic/locking/common/test/TestEntity.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.jdbc.optimistic.locking.common.test; 2 | 3 | import javax.persistence.Access; 4 | import javax.persistence.AccessType; 5 | import javax.persistence.Entity; 6 | import javax.persistence.GeneratedValue; 7 | import javax.persistence.GenerationType; 8 | import javax.persistence.Id; 9 | import javax.persistence.Table; 10 | import javax.persistence.Version; 11 | 12 | @Entity 13 | @Table(name="Customer") 14 | @Access(AccessType.FIELD) 15 | public class TestEntity { 16 | @Id 17 | @GeneratedValue(strategy = GenerationType.IDENTITY) 18 | private Long id; 19 | 20 | @Version 21 | private Long version; 22 | 23 | private long data; 24 | 25 | public Long getId() { 26 | return id; 27 | } 28 | 29 | public long getData() { 30 | return data; 31 | } 32 | 33 | public void setData(long data) { 34 | this.data = data; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /eventuate-tram-optimistic-locking-common-test/src/main/java/io/eventuate/tram/jdbc/optimistic/locking/common/test/TestEntityRepository.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.jdbc.optimistic.locking.common.test; 2 | 3 | public interface TestEntityRepository { 4 | TestEntity find(Long entityId); 5 | 6 | void persist(TestEntity testEntity); 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-producer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging-producer-common") 4 | 5 | api "io.eventuate.common:eventuate-common-jdbc:$eventuateCommonVersion" 6 | api "io.eventuate.common:eventuate-common-json-mapper:$eventuateCommonVersion" 7 | api "io.eventuate.common:eventuate-common-id:$eventuateCommonVersion" 8 | 9 | 10 | api "io.eventuate.common:eventuate-common-jdbc:$eventuateCommonVersion" 11 | } 12 | 13 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-commands/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-commands") 4 | api project(":eventuate-tram-reactive-messaging-producer-common") 5 | api project(":eventuate-tram-reactive-consumer-common") 6 | 7 | api "io.projectreactor:reactor-core:$reactorVersion" 8 | 9 | testImplementation project(":eventuate-tram-reactive-in-memory") 10 | testImplementation "io.eventuate.util:eventuate-util-test:$eventuateUtilVersion" 11 | testImplementation "io.projectreactor:reactor-tools:$reactorVersion" 12 | 13 | 14 | } 15 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-commands/src/main/java/io/eventuate/tram/reactive/commands/consumer/ReactiveCommandExceptionHandler.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.commands.consumer; 2 | 3 | 4 | import io.eventuate.tram.messaging.common.Message; 5 | import org.reactivestreams.Publisher; 6 | 7 | public class ReactiveCommandExceptionHandler { 8 | public Publisher invoke(Throwable cause) { 9 | throw new UnsupportedOperationException(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-commands/src/main/java/io/eventuate/tram/reactive/commands/consumer/ReactiveCommandHandler.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.commands.consumer; 2 | 3 | import io.eventuate.tram.commands.common.Command; 4 | import io.eventuate.tram.commands.consumer.AbstractCommandHandler; 5 | import io.eventuate.tram.commands.consumer.CommandHandlerArgs; 6 | import io.eventuate.tram.messaging.common.Message; 7 | import org.reactivestreams.Publisher; 8 | 9 | import java.util.Optional; 10 | import java.util.function.Function; 11 | 12 | 13 | public class ReactiveCommandHandler extends AbstractCommandHandler> { 14 | 15 | public ReactiveCommandHandler(String channel, Optional resource, 16 | Class commandClass, 17 | Function, Publisher> handler) { 18 | super(channel, resource, commandClass, handler); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-commands/src/main/java/io/eventuate/tram/reactive/commands/producer/ReactiveCommandProducer.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.commands.producer; 2 | 3 | import io.eventuate.tram.commands.common.Command; 4 | import reactor.core.publisher.Mono; 5 | 6 | import java.util.Map; 7 | 8 | public interface ReactiveCommandProducer { 9 | Mono send(String channel, Command command, String replyTo, Map headers); 10 | 11 | Mono sendNotification(String channel, Command command, Map headers); 12 | 13 | Mono send(String channel, String resource, Command command, String replyTo, Map headers); 14 | } 15 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | 5 | api "io.projectreactor:reactor-core:$reactorVersion" 6 | 7 | api "io.eventuate.common:eventuate-common-json-mapper:$eventuateCommonVersion" 8 | } 9 | 10 | 11 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-common/src/main/java/io/eventuate/tram/consumer/common/reactive/ReactiveDuplicateMessageDetector.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common.reactive; 2 | 3 | import io.eventuate.tram.messaging.common.SubscriberIdAndMessage; 4 | import org.reactivestreams.Publisher; 5 | import reactor.core.publisher.Mono; 6 | 7 | public interface ReactiveDuplicateMessageDetector { 8 | Mono isDuplicate(SubscriberIdAndMessage subscriberIdAndMessage); 9 | Publisher doWithMessage(SubscriberIdAndMessage subscriberIdAndMessage, Publisher processingFlow); 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-common/src/main/java/io/eventuate/tram/consumer/common/reactive/ReactiveMessageConsumer.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common.reactive; 2 | 3 | import io.eventuate.tram.messaging.consumer.MessageSubscription; 4 | 5 | import java.util.Set; 6 | 7 | public interface ReactiveMessageConsumer { 8 | MessageSubscription subscribe(String subscriberId, Set channels, ReactiveMessageHandler handler); 9 | String getId(); 10 | void close(); 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-common/src/main/java/io/eventuate/tram/consumer/common/reactive/ReactiveMessageConsumerImplementation.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common.reactive; 2 | 3 | import io.eventuate.tram.messaging.consumer.MessageSubscription; 4 | 5 | import java.util.Set; 6 | 7 | public interface ReactiveMessageConsumerImplementation { 8 | MessageSubscription subscribe(String subscriberId, Set channels, ReactiveMessageHandler handler); 9 | String getId(); 10 | void close(); 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-common/src/main/java/io/eventuate/tram/consumer/common/reactive/ReactiveMessageHandler.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common.reactive; 2 | 3 | 4 | import io.eventuate.tram.messaging.common.Message; 5 | import org.reactivestreams.Publisher; 6 | 7 | import java.util.function.Function; 8 | 9 | public interface ReactiveMessageHandler extends Function> { 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-common/src/main/java/io/eventuate/tram/consumer/common/reactive/ReactiveMessageHandlerDecorator.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common.reactive; 2 | 3 | import io.eventuate.tram.messaging.common.SubscriberIdAndMessage; 4 | import org.reactivestreams.Publisher; 5 | 6 | public interface ReactiveMessageHandlerDecorator { 7 | Publisher accept(SubscriberIdAndMessage subscriberIdAndMessage, ReactiveMessageHandlerDecoratorChain decoratorChain); 8 | 9 | int getOrder(); 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-common/src/main/java/io/eventuate/tram/consumer/common/reactive/ReactiveNoopDuplicateMessageDetector.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.consumer.common.reactive; 2 | 3 | import io.eventuate.tram.messaging.common.SubscriberIdAndMessage; 4 | import org.reactivestreams.Publisher; 5 | import reactor.core.publisher.Mono; 6 | 7 | public class ReactiveNoopDuplicateMessageDetector implements ReactiveDuplicateMessageDetector { 8 | @Override 9 | public Mono isDuplicate(SubscriberIdAndMessage subscriberIdAndMessage) { 10 | return Mono.just(false); 11 | } 12 | 13 | @Override 14 | public Publisher doWithMessage(SubscriberIdAndMessage subscriberIdAndMessage, Publisher processingFlow) { 15 | return processingFlow; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "io.eventuate.common:eventuate-common-spring-reactive-jdbc:$eventuateCommonVersion" 4 | api project(":eventuate-tram-reactive-consumer-common") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-consumer-kafka/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-reactive-consumer-common") 4 | 5 | api "io.eventuate.messaging.kafka:eventuate-messaging-kafka-consumer:$eventuateMessagingKafkaVersion" 6 | } 7 | 8 | 9 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-events/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | api project(":eventuate-tram-events") 5 | api project(":eventuate-tram-reactive-consumer-common") 6 | 7 | api "io.projectreactor:reactor-core:$reactorVersion" 8 | 9 | api "io.eventuate.common:eventuate-common-json-mapper:$eventuateCommonVersion" 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-events/src/main/java/io/eventuate/tram/reactive/events/subscriber/ReactiveDomainEventHandlers.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.events.subscriber; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | 5 | import java.util.List; 6 | import java.util.Optional; 7 | import java.util.Set; 8 | 9 | import static java.util.stream.Collectors.toSet; 10 | 11 | public class ReactiveDomainEventHandlers { 12 | private List handlers; 13 | 14 | public ReactiveDomainEventHandlers(List handlers) { 15 | this.handlers = handlers; 16 | } 17 | 18 | public Set getAggregateTypesAndEvents() { 19 | return handlers.stream().map(ReactiveDomainEventHandler::getAggregateType).collect(toSet()); 20 | } 21 | 22 | public List getHandlers() { 23 | return handlers; 24 | } 25 | 26 | public Optional findTargetMethod(Message message) { 27 | return handlers.stream().filter(h -> h.handles(message)).findFirst(); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-in-memory/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | api project(":eventuate-tram-reactive-consumer-common") 5 | api project(":eventuate-tram-reactive-messaging-producer-common") 6 | 7 | api project(":eventuate-tram-consumer-jdbc") 8 | 9 | api "io.eventuate.common:eventuate-common-id:$eventuateCommonVersion" 10 | api "com.h2database:h2:1.3.166" 11 | api "io.eventuate.common:eventuate-common-in-memory-database:$eventuateCommonVersion" 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-in-memory/src/main/resources/eventuate-tram-embedded-schema.sql: -------------------------------------------------------------------------------- 1 | CREATE SCHEMA IF NOT EXISTS eventuate AUTHORIZATION SA; 2 | 3 | drop table if exists eventuate.message; 4 | 5 | CREATE TABLE eventuate.message ( 6 | ID VARCHAR(1000) PRIMARY KEY, 7 | DESTINATION VARCHAR(1000) NOT NULL, 8 | HEADERS VARCHAR(1000) NOT NULL, 9 | PAYLOAD VARCHAR(1000) NOT NULL, 10 | MESSAGE_PARTITION SMALLINT, 11 | CREATION_TIME BIGINT 12 | ); 13 | 14 | drop table if exists eventuate.received_messages; 15 | 16 | CREATE TABLE eventuate.received_messages ( 17 | CONSUMER_ID VARCHAR(1000), 18 | MESSAGE_ID VARCHAR(1000), 19 | CREATION_TIME BIGINT, 20 | PRIMARY KEY(CONSUMER_ID, MESSAGE_ID) 21 | ); 22 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-messaging-producer-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | 5 | api "io.projectreactor:reactor-core:$reactorVersion" 6 | 7 | api "org.slf4j:slf4j-api:1.7.18" 8 | } 9 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-messaging-producer-common/src/main/java/io/eventuate/tram/reactive/messaging/producer/common/ReactiveMessageProducerImplementation.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.messaging.producer.common; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | import reactor.core.publisher.Mono; 5 | 6 | public interface ReactiveMessageProducerImplementation { 7 | 8 | Mono send(Message message); 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-reactive-producer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-reactive-messaging-producer-common") 4 | api "io.eventuate.common:eventuate-common-reactive-jdbc:$eventuateCommonVersion" 5 | } 6 | 7 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-commands") 4 | api project(":eventuate-tram-spring-messaging") 5 | 6 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands-common/src/main/java/io/eventuate/tram/spring/commands/common/TramCommandsCommonAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.common; 2 | 3 | import io.eventuate.tram.commands.common.CommandNameMapping; 4 | import io.eventuate.tram.commands.common.DefaultCommandNameMapping; 5 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 6 | import org.springframework.context.annotation.Bean; 7 | import org.springframework.boot.autoconfigure.AutoConfiguration; 8 | 9 | @AutoConfiguration 10 | @ConditionalOnMissingBean(CommandNameMapping.class) 11 | public class TramCommandsCommonAutoConfiguration { 12 | 13 | @Bean 14 | public CommandNameMapping commandNameMapping() { 15 | return new DefaultCommandNameMapping(); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands-common/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.commands.common.TramCommandsCommonAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands-common/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.commands.common.TramCommandsCommonAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-messaging-starter") 4 | api project(":eventuate-tram-spring-commands") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands-starter/src/main/java/io/eventuate/tram/spring/commands/autoconfigure/EventuateTramCommandsAutoConfigure.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.autoconfigure; 2 | 3 | import io.eventuate.tram.spring.commands.consumer.TramCommandConsumerConfiguration; 4 | import io.eventuate.tram.spring.commands.producer.TramCommandProducerConfiguration; 5 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 6 | import org.springframework.boot.autoconfigure.AutoConfiguration; 7 | import org.springframework.context.annotation.Import; 8 | 9 | @AutoConfiguration 10 | @ConditionalOnClass(TramCommandConsumerConfiguration.class) 11 | @Import({TramCommandConsumerConfiguration.class, TramCommandProducerConfiguration.class}) 12 | public class EventuateTramCommandsAutoConfigure { 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands-starter/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.commands.autoconfigure.EventuateTramCommandsAutoConfigure -------------------------------------------------------------------------------- /eventuate-tram-spring-commands-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.commands.autoconfigure.EventuateTramCommandsAutoConfigure 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | implementation project(":eventuate-tram-common") 4 | 5 | api project(":eventuate-tram-commands") 6 | api project(":eventuate-tram-spring-messaging") 7 | api project(":eventuate-tram-spring-commands-common") 8 | implementation project(":eventuate-tram-common") 9 | 10 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 11 | testImplementation project(":eventuate-tram-spring-commands-starter") 12 | testImplementation project(":eventuate-tram-test-util") 13 | testImplementation project(":eventuate-tram-spring-in-memory") 14 | 15 | testImplementation "io.eventuate.util:eventuate-util-test:$eventuateUtilVersion" 16 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 17 | testImplementation "io.eventuate.examples.common:eventuate-examples-common-money:$eventuateCommonExamplesVersion" 18 | 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/main/java/io/eventuate/tram/spring/commands/consumer/AnnotationBasedCommandHandlerConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer; 2 | 3 | import io.eventuate.tram.commands.consumer.CommandDispatcherFactory; 4 | import org.springframework.context.annotation.Bean; 5 | import org.springframework.context.annotation.Configuration; 6 | 7 | @Configuration 8 | public class AnnotationBasedCommandHandlerConfiguration { 9 | 10 | 11 | @Bean 12 | public EventuateCommandHandlerBeanPostProcessor eventuateCommandHandlerBeanPostProcessor(EventuateCommandDispatcher eventuateCommandDispatcher) { 13 | return new EventuateCommandHandlerBeanPostProcessor(eventuateCommandDispatcher); 14 | } 15 | 16 | @Bean 17 | public EventuateCommandDispatcher eventuateCommandDispatcher(CommandDispatcherFactory commandDispatcherFactory) { 18 | return new EventuateCommandDispatcher(commandDispatcherFactory); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/main/java/io/eventuate/tram/spring/commands/consumer/TramCommandReplyProducerConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer; 2 | 3 | import io.eventuate.tram.commands.consumer.CommandReplyProducer; 4 | import io.eventuate.tram.messaging.producer.MessageProducer; 5 | import org.springframework.context.annotation.Bean; 6 | import org.springframework.context.annotation.Configuration; 7 | 8 | @Configuration 9 | public class TramCommandReplyProducerConfiguration { 10 | @Bean 11 | public CommandReplyProducer commandReplyProducer(MessageProducer messageProducer) { 12 | return new CommandReplyProducer(messageProducer); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/test/java/io/eventuate/tram/spring/commands/consumer/customersandorders/CustomerCreditLimitExceededException.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer.customersandorders; 2 | 3 | public class CustomerCreditLimitExceededException extends RuntimeException { 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/test/java/io/eventuate/tram/spring/commands/consumer/customersandorders/CustomerNotFoundException.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer.customersandorders; 2 | 3 | public class CustomerNotFoundException extends RuntimeException{ 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/test/java/io/eventuate/tram/spring/commands/consumer/customersandorders/CustomerService.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer.customersandorders; 2 | 3 | import io.eventuate.examples.common.money.Money; 4 | 5 | public class CustomerService { 6 | public void reserveCredit(Long customerId, Long orderId, Money orderTotal) {} 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/test/java/io/eventuate/tram/spring/commands/consumer/customersandorders/CustomersAndOrdersConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer.customersandorders; 2 | 3 | import org.springframework.context.annotation.Bean; 4 | import org.springframework.context.annotation.Configuration; 5 | 6 | @Configuration 7 | public class CustomersAndOrdersConfiguration { 8 | @Bean 9 | CustomerCommandHandler customerCommandHandler(CustomerService customerService) { 10 | return new CustomerCommandHandler(customerService); 11 | } 12 | 13 | @Bean 14 | CustomerService customerService() { 15 | return new CustomerService(); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/test/java/io/eventuate/tram/spring/commands/consumer/customersandorders/replies/CustomerCreditLimitExceeded.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer.customersandorders.replies; 2 | 3 | import io.eventuate.tram.commands.consumer.annotations.FailureReply; 4 | 5 | @FailureReply 6 | public class CustomerCreditLimitExceeded implements ReserveCreditReply { 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/test/java/io/eventuate/tram/spring/commands/consumer/customersandorders/replies/CustomerCreditReserved.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer.customersandorders.replies; 2 | 3 | import io.eventuate.tram.commands.consumer.annotations.SuccessReply; 4 | 5 | @SuccessReply 6 | public class CustomerCreditReserved implements ReserveCreditReply { 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/test/java/io/eventuate/tram/spring/commands/consumer/customersandorders/replies/CustomerNotFound.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer.customersandorders.replies; 2 | 3 | import io.eventuate.tram.commands.consumer.annotations.FailureReply; 4 | 5 | @FailureReply 6 | public class CustomerNotFound implements ReserveCreditReply { 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-commands/src/test/java/io/eventuate/tram/spring/commands/consumer/customersandorders/replies/ReserveCreditReply.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.commands.consumer.customersandorders.replies; 2 | 3 | public interface ReserveCreditReply { 4 | } 5 | -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-activemq/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation project(":eventuate-tram-consumer-activemq") 3 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-consumer-common") 4 | api project(":eventuate-tram-spring-messaging") 5 | 6 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-common/src/main/java/io/eventuate/tram/spring/consumer/common/TramNoopDuplicateMessageDetectorConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.consumer.common; 2 | 3 | import io.eventuate.tram.consumer.common.DuplicateMessageDetector; 4 | import io.eventuate.tram.consumer.common.NoopDuplicateMessageDetector; 5 | import org.springframework.context.annotation.Bean; 6 | import org.springframework.context.annotation.Configuration; 7 | 8 | @Configuration 9 | public class TramNoopDuplicateMessageDetectorConfiguration { 10 | 11 | @Bean 12 | public DuplicateMessageDetector duplicateMessageDetector() { 13 | return new NoopDuplicateMessageDetector(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 4 | 5 | api project(":eventuate-tram-consumer-jdbc") 6 | 7 | api "io.eventuate.common:eventuate-common-spring-jdbc:$eventuateCommonVersion" 8 | 9 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-jdbc/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.consumer.jdbc.TramConsumerJdbcAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-jdbc/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.consumer.jdbc.TramConsumerJdbcAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-jdbc/src/test/resources/application-mssql.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:sqlserver://${DOCKER_HOST_IP:localhost}:1433;databaseName=eventuate 2 | spring.datasource.username=sa 3 | spring.datasource.password=Eventuate123! 4 | spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-jdbc/src/test/resources/application-postgres.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:postgresql://${DOCKER_HOST_IP:localhost}/eventuate 2 | spring.datasource.username=eventuate 3 | spring.datasource.password=eventuate 4 | spring.datasource.driver-class-name=org.postgresql.Driver -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-jdbc/src/test/resources/application.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:mysql://${DOCKER_HOST_IP:localhost}/eventuate 2 | spring.datasource.username=mysqluser 3 | spring.datasource.password=mysqlpw 4 | spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 5 | -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-kafka/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-consumer-common") 4 | api project(":eventuate-tram-spring-messaging") 5 | api project(":eventuate-tram-consumer-kafka") 6 | 7 | api "io.eventuate.messaging.kafka:eventuate-messaging-kafka-spring-consumer:$eventuateMessagingKafkaVersion" 8 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-rabbitmq/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation project(":eventuate-tram-consumer-rabbitmq") 3 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-consumer-redis/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation project(":eventuate-tram-consumer-redis") 3 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-events-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-events") 4 | api project(":eventuate-tram-spring-messaging") 5 | 6 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-common/src/main/java/io/eventuate/tram/spring/events/common/TramEventsCommonAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.events.common; 2 | 3 | import io.eventuate.tram.events.common.DefaultDomainEventNameMapping; 4 | import io.eventuate.tram.events.common.DomainEventNameMapping; 5 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 6 | import org.springframework.context.annotation.Bean; 7 | import org.springframework.boot.autoconfigure.AutoConfiguration; 8 | 9 | @AutoConfiguration 10 | @ConditionalOnMissingBean(DomainEventNameMapping.class) 11 | public class TramEventsCommonAutoConfiguration { 12 | 13 | @Bean 14 | public DomainEventNameMapping domainEventNameMapping() { 15 | return new DefaultDomainEventNameMapping(); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-common/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.events.common.TramEventsCommonAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-common/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.events.common.TramEventsCommonAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-publisher-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-messaging-starter") 4 | api project(":eventuate-tram-spring-events") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-publisher-starter/src/main/java/io/eventuate/tram/spring/events/autoconfigure/TramEventsPublisherAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.events.autoconfigure; 2 | 3 | import io.eventuate.tram.spring.events.publisher.TramEventsPublisherConfiguration; 4 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 5 | import org.springframework.boot.autoconfigure.AutoConfiguration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @AutoConfiguration 9 | @ConditionalOnClass(TramEventsPublisherConfiguration.class) 10 | @Import(TramEventsPublisherConfiguration.class) 11 | public class TramEventsPublisherAutoConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-publisher-starter/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.events.autoconfigure.TramEventsPublisherAutoConfiguration -------------------------------------------------------------------------------- /eventuate-tram-spring-events-publisher-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.events.autoconfigure.TramEventsPublisherAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-publisher/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-events") 4 | api project(":eventuate-tram-spring-messaging") 5 | api project(":eventuate-tram-spring-events-common") 6 | 7 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 8 | } 9 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-publisher/src/main/java/io/eventuate/tram/spring/events/publisher/TramEventsPublisherConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.events.publisher; 2 | 3 | import io.eventuate.tram.events.common.DomainEventNameMapping; 4 | import io.eventuate.tram.events.publisher.DomainEventPublisher; 5 | import io.eventuate.tram.events.publisher.DomainEventPublisherImpl; 6 | import io.eventuate.tram.messaging.producer.MessageProducer; 7 | import org.springframework.context.annotation.Bean; 8 | import org.springframework.context.annotation.Configuration; 9 | 10 | @Configuration 11 | public class TramEventsPublisherConfiguration { 12 | 13 | @Bean 14 | public DomainEventPublisher domainEventPublisher(MessageProducer messageProducer, DomainEventNameMapping domainEventNameMapping) { 15 | return new DomainEventPublisherImpl(messageProducer, domainEventNameMapping); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-events-publisher-starter") 4 | api project(":eventuate-tram-spring-events-subscriber-starter") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-subscriber-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-messaging-starter") 4 | api project(":eventuate-tram-spring-events") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-subscriber-starter/src/main/java/io/eventuate/tram/spring/events/autoconfigure/TramEventsSubscriberAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.events.autoconfigure; 2 | 3 | import io.eventuate.tram.spring.events.subscriber.TramEventSubscriberConfiguration; 4 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 5 | import org.springframework.boot.autoconfigure.AutoConfiguration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @AutoConfiguration 9 | @ConditionalOnClass(TramEventSubscriberConfiguration.class) 10 | @Import(TramEventSubscriberConfiguration.class) 11 | public class TramEventsSubscriberAutoConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-subscriber-starter/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.events.autoconfigure.TramEventsSubscriberAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-subscriber-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.events.autoconfigure.TramEventsSubscriberAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-subscriber/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-events") 4 | api project(":eventuate-tram-spring-messaging") 5 | api project(":eventuate-tram-spring-events-common") 6 | api project(":eventuate-tram-common") 7 | 8 | implementation "org.springframework.boot:spring-boot-starter:$springBootVersion" 9 | 10 | testImplementation project(":eventuate-tram-test-util") 11 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootVersion" 12 | testImplementation project(":eventuate-tram-spring-events-publisher") 13 | testImplementation project(":eventuate-tram-in-memory") 14 | testImplementation project(":eventuate-tram-spring-in-memory") 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-subscriber/src/main/java/io/eventuate/tram/spring/events/subscriber/AnnotationBasedEventsSubscriberConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.events.subscriber; 2 | 3 | import io.eventuate.tram.events.subscriber.DomainEventDispatcherFactory; 4 | import org.springframework.context.annotation.Bean; 5 | import org.springframework.context.annotation.Configuration; 6 | 7 | @Configuration 8 | public class AnnotationBasedEventsSubscriberConfiguration { 9 | 10 | 11 | @Bean 12 | public EventuateDomainEventDispatcher eventuateDomainEventDispatcher(DomainEventDispatcherFactory domainEventDispatcherFactory) { 13 | return new EventuateDomainEventDispatcher(domainEventDispatcherFactory); 14 | } 15 | 16 | @Bean 17 | public EventuateDomainEventHandlerBeanPostProcessor eventuateDomainEventHandlerBeanPostProcessor(EventuateDomainEventDispatcher eventuateDomainEventDispatcher) { 18 | return new EventuateDomainEventHandlerBeanPostProcessor(eventuateDomainEventDispatcher); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events-subscriber/src/main/java/io/eventuate/tram/spring/events/subscriber/EventuateDomainEventHandlerValidationException.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.events.subscriber; 2 | 3 | /** 4 | * Exception thrown when a method annotated with @EventuateDomainEventHandler 5 | * does not meet the required conventions. 6 | */ 7 | public class EventuateDomainEventHandlerValidationException extends RuntimeException { 8 | public EventuateDomainEventHandlerValidationException(String message) { 9 | super(message); 10 | } 11 | 12 | public EventuateDomainEventHandlerValidationException(String message, Throwable cause) { 13 | super(message, cause); 14 | } 15 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-events-subscriber/src/main/java/io/eventuate/tram/spring/events/subscriber/TramEventSubscriberConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.events.subscriber; 2 | 3 | import io.eventuate.tram.events.common.DomainEventNameMapping; 4 | import io.eventuate.tram.events.subscriber.DomainEventDispatcherFactory; 5 | import io.eventuate.tram.messaging.consumer.MessageConsumer; 6 | import org.springframework.context.annotation.Bean; 7 | import org.springframework.context.annotation.Configuration; 8 | import org.springframework.context.annotation.Import; 9 | 10 | @Configuration 11 | @Import(AnnotationBasedEventsSubscriberConfiguration.class) 12 | public class TramEventSubscriberConfiguration { 13 | 14 | @Bean 15 | public DomainEventDispatcherFactory domainEventDispatcherFactory(MessageConsumer messageConsumer, DomainEventNameMapping domainEventNameMapping) { 16 | return new DomainEventDispatcherFactory(messageConsumer, domainEventNameMapping); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /eventuate-tram-spring-events/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-events-publisher") 4 | api project(":eventuate-tram-spring-events-subscriber") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-flyway/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation "org.flywaydb:flyway-core:$flywayVersion" 3 | implementation "org.flywaydb:flyway-mysql:$flywayVersion" 4 | 5 | implementation "org.springframework.boot:spring-boot-starter:$springBootVersion" 6 | implementation "io.eventuate.common:eventuate-common-jdbc:$eventuateCommonVersion" 7 | implementation "io.eventuate.common:eventuate-common-flyway:$eventuateCommonVersion" 8 | 9 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 10 | testImplementation "io.eventuate.common:eventuate-common-testcontainers:$eventuateCommonVersion" 11 | testImplementation "org.testcontainers:testcontainers:$testContainersVersion" 12 | testImplementation "org.springframework.boot:spring-boot-starter-jdbc:$springBootVersion" 13 | testRuntimeOnly "org.flywaydb:flyway-sqlserver:$flywayVersion" 14 | 15 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-flyway/src/main/java/io/eventuate/tram/spring/flyway/EventuateTramFlywayMigrationConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.flyway; 2 | 3 | import io.eventuate.common.flyway.TemplatedMessageTableCreator; 4 | import io.eventuate.common.jdbc.OutboxPartitioningSpec; 5 | import org.springframework.context.annotation.Bean; 6 | import org.springframework.context.annotation.Configuration; 7 | 8 | @Configuration 9 | public class EventuateTramFlywayMigrationConfiguration { 10 | 11 | @Bean 12 | public V1005__MyMigration v1005__myMigration(TemplatedMessageTableCreator templatedMessageTableCreator, OutboxPartitioningSpec outboxPartitioningSpec) { 13 | return new V1005__MyMigration(templatedMessageTableCreator, outboxPartitioningSpec); 14 | } 15 | 16 | @Bean 17 | public TemplatedMessageTableCreator templatedMessageTableCreator() { 18 | return new TemplatedMessageTableCreator(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-spring-in-memory/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-in-memory") 4 | api project(":eventuate-tram-common-spring-in-memory") 5 | 6 | api project(":eventuate-tram-spring-messaging") 7 | api project(":eventuate-tram-spring-consumer-common") 8 | api project(":eventuate-tram-spring-messaging-producer-common") 9 | api project(":eventuate-tram-spring-consumer-jdbc") 10 | 11 | api "io.eventuate.common:eventuate-common-spring-id:$eventuateCommonVersion" 12 | api "io.eventuate.common:eventuate-common-spring-in-memory-database:$eventuateCommonVersion" 13 | 14 | 15 | testImplementation project(":eventuate-tram-in-memory-test") 16 | 17 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 18 | 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-spring-in-memory/src/main/java/io/eventuate/tram/spring/inmemory/TramInMemoryConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.inmemory; 2 | 3 | import io.eventuate.tram.spring.consumer.jdbc.TransactionalNoopDuplicateMessageDetectorConfiguration; 4 | import org.springframework.context.annotation.Configuration; 5 | import org.springframework.context.annotation.Import; 6 | 7 | @Configuration 8 | @Import({TramInMemoryCommonConfiguration.class, TransactionalNoopDuplicateMessageDetectorConfiguration.class}) 9 | public class TramInMemoryConfiguration { 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-spring-jdbc-activemq/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation project(":eventuate-tram-jdbc-activemq") 3 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-jdbc-kafka/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "io.eventuate.messaging.kafka:eventuate-messaging-kafka-spring-consumer:$eventuateMessagingKafkaVersion" 4 | 5 | api project(":eventuate-tram-spring-producer-jdbc") 6 | api project(":eventuate-tram-spring-consumer-common") 7 | api project(":eventuate-tram-spring-consumer-jdbc") 8 | api project(":eventuate-tram-spring-consumer-kafka") 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-spring-jdbc-kafka/src/main/java/io/eventuate/tram/spring/jdbckafka/TramJdbcKafkaConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.jdbckafka; 2 | 3 | import io.eventuate.tram.spring.consumer.kafka.EventuateTramKafkaMessageConsumerConfiguration; 4 | import io.eventuate.tram.spring.messaging.producer.jdbc.TramMessageProducerJdbcConfiguration; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import({TramMessageProducerJdbcConfiguration.class, 10 | EventuateTramKafkaMessageConsumerConfiguration.class}) 11 | public class TramJdbcKafkaConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-spring-jdbc-rabbitmq/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation project(":eventuate-tram-jdbc-rabbitmq") 3 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-jdbc-redis/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation project(":eventuate-tram-jdbc-redis") 3 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-logging/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation project(":eventuate-tram-messaging") 3 | implementation "org.springframework.boot:spring-boot-starter:$springBootVersion" 4 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-logging/src/main/java/io/eventuate/tram/spring/logging/LoggingMessageInterceptor.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.logging; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | import io.eventuate.tram.messaging.common.MessageInterceptor; 5 | import org.slf4j.Logger; 6 | import org.slf4j.LoggerFactory; 7 | 8 | public class LoggingMessageInterceptor implements MessageInterceptor { 9 | 10 | private static final Logger logger = LoggerFactory.getLogger("io.eventuate.activity"); 11 | 12 | @Override 13 | public void postSend(Message message, Exception e) { 14 | logger.info("Message Sent: {}", message); 15 | } 16 | 17 | @Override 18 | public void preHandle(String subscriberId, Message message) { 19 | logger.info("message received: {} {}", subscriberId, message); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /eventuate-tram-spring-logging/src/main/java/io/eventuate/tram/spring/logging/LoggingMessageInterceptorAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.logging; 2 | 3 | import io.eventuate.tram.messaging.common.MessageInterceptor; 4 | import org.springframework.context.annotation.Bean; 5 | import org.springframework.boot.autoconfigure.AutoConfiguration; 6 | 7 | @AutoConfiguration 8 | public class LoggingMessageInterceptorAutoConfiguration { 9 | @Bean 10 | public MessageInterceptor messageLoggingInterceptor() { 11 | return new LoggingMessageInterceptor(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-spring-logging/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.logging.LoggingMessageInterceptorAutoConfiguration -------------------------------------------------------------------------------- /eventuate-tram-spring-logging/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.logging.LoggingMessageInterceptorAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-producer-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging-producer-common") 4 | api project(":eventuate-tram-spring-messaging") 5 | 6 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | 4 | api project(":eventuate-tram-messaging") 5 | 6 | compileOnly project(":eventuate-tram-spring-producer-jdbc") 7 | compileOnly project(":eventuate-tram-spring-consumer-kafka") 8 | compileOnly project(":eventuate-tram-consumer-activemq") 9 | compileOnly project(":eventuate-tram-consumer-rabbitmq") 10 | compileOnly project(":eventuate-tram-consumer-redis") 11 | 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-starter/src/main/java/io/eventuate/tram/spring/messaging/autoconfigure/EventuateTramActiveMQMessageConsumerAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.messaging.autoconfigure; 2 | 3 | import io.eventuate.tram.consumer.activemq.EventuateTramActiveMQMessageConsumerConfiguration; 4 | import io.eventuate.tram.consumer.common.MessageConsumerImplementation; 5 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 6 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 7 | import org.springframework.boot.autoconfigure.AutoConfiguration; 8 | import org.springframework.context.annotation.Import; 9 | 10 | @AutoConfiguration 11 | @ConditionalOnClass(EventuateTramActiveMQMessageConsumerConfiguration.class) 12 | @ConditionalOnMissingBean(MessageConsumerImplementation.class) 13 | @Import(EventuateTramActiveMQMessageConsumerConfiguration.class) 14 | public class EventuateTramActiveMQMessageConsumerAutoConfiguration { 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-starter/src/main/java/io/eventuate/tram/spring/messaging/autoconfigure/EventuateTramKafkaMessageConsumerAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.messaging.autoconfigure; 2 | 3 | import io.eventuate.tram.consumer.common.MessageConsumerImplementation; 4 | import io.eventuate.tram.spring.consumer.kafka.EventuateTramKafkaMessageConsumerConfiguration; 5 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 6 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 7 | import org.springframework.boot.autoconfigure.AutoConfiguration; 8 | import org.springframework.context.annotation.Import; 9 | 10 | @AutoConfiguration 11 | @ConditionalOnClass(EventuateTramKafkaMessageConsumerConfiguration.class) 12 | @ConditionalOnMissingBean(MessageConsumerImplementation.class) 13 | @Import(EventuateTramKafkaMessageConsumerConfiguration.class) 14 | public class EventuateTramKafkaMessageConsumerAutoConfiguration { 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-starter/src/main/java/io/eventuate/tram/spring/messaging/autoconfigure/EventuateTramRabbitMQMessageConsumerAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.messaging.autoconfigure; 2 | 3 | import io.eventuate.tram.consumer.common.MessageConsumerImplementation; 4 | import io.eventuate.tram.consumer.rabbitmq.EventuateTramRabbitMQMessageConsumerConfiguration; 5 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 6 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 7 | import org.springframework.boot.autoconfigure.AutoConfiguration; 8 | import org.springframework.context.annotation.Import; 9 | 10 | @AutoConfiguration 11 | @ConditionalOnClass(EventuateTramRabbitMQMessageConsumerConfiguration.class) 12 | @ConditionalOnMissingBean(MessageConsumerImplementation.class) 13 | @Import(EventuateTramRabbitMQMessageConsumerConfiguration.class) 14 | public class EventuateTramRabbitMQMessageConsumerAutoConfiguration { 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-starter/src/main/java/io/eventuate/tram/spring/messaging/autoconfigure/EventuateTramRedisMessageConsumerAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.messaging.autoconfigure; 2 | 3 | import io.eventuate.tram.consumer.common.MessageConsumerImplementation; 4 | import io.eventuate.tram.consumer.redis.EventuateTramRedisMessageConsumerConfiguration; 5 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 6 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 7 | import org.springframework.boot.autoconfigure.AutoConfiguration; 8 | import org.springframework.context.annotation.Import; 9 | 10 | @AutoConfiguration 11 | @ConditionalOnClass(EventuateTramRedisMessageConsumerConfiguration.class) 12 | @ConditionalOnMissingBean(MessageConsumerImplementation.class) 13 | @Import(EventuateTramRedisMessageConsumerConfiguration.class) 14 | public class EventuateTramRedisMessageConsumerAutoConfiguration { 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-starter/src/main/java/io/eventuate/tram/spring/messaging/autoconfigure/TramMessageProducerJdbcAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.messaging.autoconfigure; 2 | 3 | import io.eventuate.tram.spring.messaging.producer.jdbc.TramMessageProducerJdbcConfiguration; 4 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 5 | import org.springframework.boot.autoconfigure.AutoConfiguration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @AutoConfiguration 9 | @ConditionalOnClass(TramMessageProducerJdbcConfiguration.class) 10 | @Import(TramMessageProducerJdbcConfiguration.class) 11 | public class TramMessageProducerJdbcAutoConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-starter/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.messaging.autoconfigure.EventuateTramActiveMQMessageConsumerAutoConfiguration, \ 3 | io.eventuate.tram.spring.messaging.autoconfigure.EventuateTramKafkaMessageConsumerAutoConfiguration, \ 4 | io.eventuate.tram.spring.messaging.autoconfigure.EventuateTramRabbitMQMessageConsumerAutoConfiguration, \ 5 | io.eventuate.tram.spring.messaging.autoconfigure.EventuateTramRedisMessageConsumerAutoConfiguration, \ 6 | io.eventuate.tram.spring.messaging.autoconfigure.TramMessageProducerJdbcAutoConfiguration 7 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.messaging.autoconfigure.EventuateTramActiveMQMessageConsumerAutoConfiguration 2 | io.eventuate.tram.spring.messaging.autoconfigure.EventuateTramKafkaMessageConsumerAutoConfiguration 3 | io.eventuate.tram.spring.messaging.autoconfigure.EventuateTramRabbitMQMessageConsumerAutoConfiguration 4 | io.eventuate.tram.spring.messaging.autoconfigure.EventuateTramRedisMessageConsumerAutoConfiguration 5 | io.eventuate.tram.spring.messaging.autoconfigure.TramMessageProducerJdbcAutoConfiguration 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project (":eventuate-tram-messaging") 4 | 5 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.messaging.common.TramMessagingCommonAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-messaging/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.messaging.common.TramMessagingCommonAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project (":eventuate-tram-consumer-common") 4 | api project(":eventuate-tram-optimistic-locking-common-test") 5 | api "org.springframework.boot:spring-boot-starter-jdbc:$springBootVersion" 6 | api 'org.springframework.retry:spring-retry:1.2.4.RELEASE' 7 | api "io.eventuate.common:eventuate-common-spring-jdbc:$eventuateCommonVersion" 8 | api "org.springframework.boot:spring-boot-starter-data-jpa:$springBootCdcVersion" 9 | 10 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/src/main/java/io/eventuate/tram/spring/optimisticlocking/OptimisticLockingDecoratorConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.optimisticlocking; 2 | 3 | import org.springframework.context.annotation.Bean; 4 | import org.springframework.context.annotation.Configuration; 5 | import org.springframework.retry.annotation.EnableRetry; 6 | 7 | @Configuration 8 | @EnableRetry 9 | public class OptimisticLockingDecoratorConfiguration { 10 | @Bean 11 | public OptimisticLockingDecorator optimisticLockingDecorator() { 12 | return new OptimisticLockingDecorator(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/src/test/java/io/eventuate/tram/spring/optimisticlocking/AbstractEventuateSpringOptimisticLockingTest.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.optimisticlocking; 2 | 3 | import io.eventuate.tram.consumer.common.MessageHandlerDecorator; 4 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.AbstractEventuateOptimisticLockingTest; 5 | import org.springframework.beans.factory.annotation.Autowired; 6 | 7 | abstract public class AbstractEventuateSpringOptimisticLockingTest extends AbstractEventuateOptimisticLockingTest { 8 | 9 | @Autowired 10 | private OptimisticLockingDecorator optimisticLockingDecorator; 11 | 12 | @Override 13 | public MessageHandlerDecorator getOptimisticLockingDecorator() { 14 | return optimisticLockingDecorator; 15 | } 16 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/src/test/java/io/eventuate/tram/spring/optimisticlocking/TestEntityRepositoryConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.optimisticlocking; 2 | 3 | import io.eventuate.common.spring.jdbc.EventuateTransactionTemplateConfiguration; 4 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.TestEntityRepository; 5 | import org.springframework.boot.autoconfigure.EnableAutoConfiguration; 6 | import org.springframework.boot.autoconfigure.domain.EntityScan; 7 | import org.springframework.context.annotation.Bean; 8 | import org.springframework.context.annotation.Configuration; 9 | import org.springframework.context.annotation.Import; 10 | 11 | @Configuration 12 | @EnableAutoConfiguration 13 | @EntityScan(basePackages = "io.eventuate.tram.jdbc.optimistic.locking.common.test") 14 | @Import(EventuateTransactionTemplateConfiguration.class) 15 | public class TestEntityRepositoryConfiguration { 16 | @Bean 17 | public TestEntityRepository testEntityRepository() { 18 | return new TestEntityRepositoryImpl(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/src/test/java/io/eventuate/tram/spring/optimisticlocking/TestEntityRepositoryImpl.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.optimisticlocking; 2 | 3 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.TestEntity; 4 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.TestEntityRepository; 5 | import org.springframework.beans.factory.annotation.Autowired; 6 | 7 | public class TestEntityRepositoryImpl implements TestEntityRepository { 8 | 9 | @Autowired 10 | private TestEntitySpringRepository testEntitySpringRepository; 11 | 12 | @Override 13 | public TestEntity find(Long entityId) { 14 | return testEntitySpringRepository.findById(entityId).orElse(null); 15 | } 16 | 17 | @Override 18 | public void persist(TestEntity testEntity) { 19 | testEntitySpringRepository.save(testEntity); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/src/test/java/io/eventuate/tram/spring/optimisticlocking/TestEntitySpringRepository.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.optimisticlocking; 2 | 3 | import io.eventuate.tram.jdbc.optimistic.locking.common.test.TestEntity; 4 | import org.springframework.data.repository.PagingAndSortingRepository; 5 | 6 | public interface TestEntitySpringRepository extends PagingAndSortingRepository { 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/src/test/resources/application-mssql.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:sqlserver://${DOCKER_HOST_IP:localhost}:1433;databaseName=eventuate 2 | spring.datasource.username=sa 3 | spring.datasource.password=Eventuate123! 4 | spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/src/test/resources/application-postgres.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:postgresql://${DOCKER_HOST_IP:localhost}/eventuate 2 | spring.datasource.username=eventuate 3 | spring.datasource.password=eventuate 4 | spring.datasource.driver-class-name=org.postgresql.Driver 5 | spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect -------------------------------------------------------------------------------- /eventuate-tram-spring-optimistic-locking/src/test/resources/application.properties: -------------------------------------------------------------------------------- 1 | spring.datasource.url=jdbc:mysql://${DOCKER_HOST_IP:localhost}/eventuate 2 | spring.datasource.username=mysqluser 3 | spring.datasource.password=mysqlpw 4 | spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 5 | spring.jpa.generate-ddl=true 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-producer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-producer-jdbc") 4 | api project(":eventuate-tram-spring-messaging-producer-common") 5 | 6 | api "io.eventuate.common:eventuate-common-spring-id:$eventuateCommonVersion" 7 | api "io.eventuate.common:eventuate-common-spring-jdbc:$eventuateCommonVersion" 8 | } 9 | 10 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-commands-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-reactive-messaging-starter") 4 | api project(":eventuate-tram-spring-reactive-commands") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-commands-starter/src/main/java/io/eventuate/tram/spring/reactive/commands/autoconfigure/EventuateReactiveTramCommandsAutoConfigure.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.commands.autoconfigure; 2 | 3 | import io.eventuate.tram.spring.reactive.commands.consumer.ReactiveTramCommandConsumerConfiguration; 4 | import io.eventuate.tram.spring.reactive.commands.producer.ReactiveTramCommandProducerConfiguration; 5 | import org.springframework.boot.autoconfigure.AutoConfiguration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @AutoConfiguration 9 | @Import({ReactiveTramCommandConsumerConfiguration.class, ReactiveTramCommandProducerConfiguration.class}) 10 | public class EventuateReactiveTramCommandsAutoConfigure { 11 | } 12 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-commands-starter/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.reactive.commands.autoconfigure.EventuateReactiveTramCommandsAutoConfigure -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-commands-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.reactive.commands.autoconfigure.EventuateReactiveTramCommandsAutoConfigure 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-commands/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-reactive-commands") 4 | api project(":eventuate-tram-spring-commands-common") 5 | 6 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 7 | } 8 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-commands/src/main/java/io/eventuate/tram/spring/reactive/commands/producer/ReactiveTramCommandProducerConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.commands.producer; 2 | 3 | import io.eventuate.tram.commands.common.CommandNameMapping; 4 | import io.eventuate.tram.messaging.common.ChannelMapping; 5 | import io.eventuate.tram.reactive.commands.producer.ReactiveCommandProducer; 6 | import io.eventuate.tram.reactive.commands.producer.ReactiveCommandProducerImpl; 7 | import io.eventuate.tram.reactive.messaging.producer.common.ReactiveMessageProducer; 8 | import org.springframework.context.annotation.Bean; 9 | import org.springframework.context.annotation.Configuration; 10 | 11 | @Configuration 12 | public class ReactiveTramCommandProducerConfiguration { 13 | 14 | @Bean 15 | public ReactiveCommandProducer commandProducer(ReactiveMessageProducer messageProducer, CommandNameMapping commandNameMapping) { 16 | return new ReactiveCommandProducerImpl(messageProducer, commandNameMapping); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-consumer-common/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-reactive-consumer-common") 4 | api project(":eventuate-tram-spring-messaging") 5 | 6 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-consumer-common/src/main/java/io/eventuate/tram/spring/reactive/consumer/common/ReactiveTramNoopDuplicateMessageDetectorConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.consumer.common; 2 | 3 | import io.eventuate.tram.consumer.common.reactive.ReactiveDuplicateMessageDetector; 4 | import io.eventuate.tram.consumer.common.reactive.ReactiveNoopDuplicateMessageDetector; 5 | import org.springframework.context.annotation.Bean; 6 | import org.springframework.context.annotation.Configuration; 7 | 8 | @Configuration 9 | public class ReactiveTramNoopDuplicateMessageDetectorConfiguration { 10 | 11 | @Bean 12 | public ReactiveDuplicateMessageDetector duplicateMessageDetector() { 13 | return new ReactiveNoopDuplicateMessageDetector(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-consumer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "io.eventuate.common:eventuate-common-spring-reactive-jdbc:$eventuateCommonVersion" 4 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 5 | api project(":eventuate-tram-reactive-consumer-jdbc") 6 | api project(":eventuate-tram-reactive-consumer-common") 7 | 8 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 9 | } 10 | 11 | test { 12 | def profile = System.env['SPRING_PROFILES_ACTIVE'] 13 | if (profile != null && profile != "" && !profile.toLowerCase().contains("mysql")) { 14 | exclude '**/EventuateSpringReactiveSqlTableBasedDuplicateMessageDetectorTest**' 15 | } 16 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-consumer-jdbc/src/main/java/io/eventuate/tram/spring/reactive/consumer/jdbc/ReactiveTransactionalNoopDuplicateMessageDetectorConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.consumer.jdbc; 2 | 3 | import io.eventuate.tram.consumer.common.reactive.ReactiveDuplicateMessageDetector; 4 | import io.eventuate.tram.reactive.consumer.jdbc.ReactiveTransactionalNoopDuplicateMessageDetector; 5 | import org.springframework.context.annotation.Bean; 6 | import org.springframework.context.annotation.Configuration; 7 | import org.springframework.transaction.reactive.TransactionalOperator; 8 | 9 | @Configuration 10 | public class ReactiveTransactionalNoopDuplicateMessageDetectorConfiguration { 11 | 12 | @Bean 13 | public ReactiveDuplicateMessageDetector duplicateMessageDetector(TransactionalOperator transactionalOperator) { 14 | return new ReactiveTransactionalNoopDuplicateMessageDetector(transactionalOperator); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-consumer-jdbc/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.reactive.consumer.jdbc.ReactiveTramConsumerJdbcAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-consumer-jdbc/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.reactive.consumer.jdbc.ReactiveTramConsumerJdbcAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-consumer-jdbc/src/test/resources/application.properties: -------------------------------------------------------------------------------- 1 | eventuate.reactive.db.driver=mysql 2 | eventuate.reactive.db.host=${DOCKER_HOST_IP:localhost} 3 | eventuate.reactive.db.port=3306 4 | eventuate.reactive.db.username=mysqluser 5 | eventuate.reactive.db.password=mysqlpw 6 | eventuate.reactive.db.database=eventuate 7 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-consumer-kafka/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-consumer-common") 4 | api project(":eventuate-tram-spring-messaging") 5 | api project(":eventuate-tram-reactive-consumer-kafka") 6 | api project(":eventuate-tram-spring-reactive-consumer-common") 7 | 8 | api "io.eventuate.messaging.kafka:eventuate-messaging-kafka-spring-consumer:$eventuateMessagingKafkaVersion" 9 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 10 | } 11 | 12 | 13 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-publisher-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-reactive-messaging-starter") 4 | api project(":eventuate-tram-spring-reactive-events") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-publisher-starter/src/main/java/io/eventuate/tram/spring/reactive/events/autoconfigure/ReactiveTramEventsPublisherAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.events.autoconfigure; 2 | 3 | import io.eventuate.tram.spring.events.publisher.ReactiveTramEventsPublisherConfiguration; 4 | import org.springframework.boot.autoconfigure.AutoConfiguration; 5 | import org.springframework.context.annotation.Import; 6 | 7 | @AutoConfiguration 8 | @Import(ReactiveTramEventsPublisherConfiguration.class) 9 | public class ReactiveTramEventsPublisherAutoConfiguration { 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-publisher-starter/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.reactive.events.autoconfigure.ReactiveTramEventsPublisherAutoConfiguration -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-publisher-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.reactive.events.autoconfigure.ReactiveTramEventsPublisherAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-publisher/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-events") 4 | api project(":eventuate-tram-spring-messaging") 5 | api project(":eventuate-tram-spring-reactive-producer-jdbc") 6 | api project(":eventuate-tram-spring-events-common") 7 | 8 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-publisher/src/main/java/io/eventuate/tram/spring/events/publisher/ReactiveTramEventsPublisherConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.events.publisher; 2 | 3 | import io.eventuate.tram.events.common.DomainEventNameMapping; 4 | import io.eventuate.tram.reactive.messaging.producer.common.ReactiveMessageProducer; 5 | import org.springframework.context.annotation.Bean; 6 | import org.springframework.context.annotation.Configuration; 7 | 8 | @Configuration 9 | public class ReactiveTramEventsPublisherConfiguration { 10 | 11 | @Bean 12 | public ReactiveDomainEventPublisher reactiveDomainEventPublisher(ReactiveMessageProducer reactiveMessageProducer, 13 | DomainEventNameMapping domainEventNameMapping) { 14 | return new ReactiveDomainEventPublisher(reactiveMessageProducer, domainEventNameMapping); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-reactive-events-publisher-starter") 4 | api project(":eventuate-tram-spring-reactive-events-subscriber-starter") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-subscriber-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-reactive-messaging-starter") 4 | api project(":eventuate-tram-spring-reactive-events") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-subscriber-starter/src/main/java/io/eventuate/tram/spring/reactive/events/autoconfigure/ReactiveTramEventsSubscriberAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.events.autoconfigure; 2 | 3 | import io.eventuate.tram.spring.reactive.events.subscriber.ReactiveTramEventSubscriberConfiguration; 4 | import org.springframework.boot.autoconfigure.AutoConfiguration; 5 | import org.springframework.context.annotation.Import; 6 | 7 | @AutoConfiguration 8 | @Import(ReactiveTramEventSubscriberConfiguration.class) 9 | public class ReactiveTramEventsSubscriberAutoConfiguration { 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-subscriber-starter/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.reactive.events.autoconfigure.ReactiveTramEventsSubscriberAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-subscriber-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.reactive.events.autoconfigure.ReactiveTramEventsSubscriberAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-subscriber/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-reactive-events") 4 | api project(":eventuate-tram-spring-messaging") 5 | api project(":eventuate-tram-spring-events-common") 6 | 7 | api "org.springframework.boot:spring-boot-starter:$springBootVersion" 8 | } 9 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events-subscriber/src/main/java/io/eventuate/tram/spring/reactive/events/subscriber/ReactiveTramEventSubscriberConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.events.subscriber; 2 | 3 | import io.eventuate.tram.consumer.common.reactive.ReactiveMessageConsumer; 4 | import io.eventuate.tram.events.common.DomainEventNameMapping; 5 | import io.eventuate.tram.reactive.events.subscriber.ReactiveDomainEventDispatcherFactory; 6 | import org.springframework.context.annotation.Bean; 7 | import org.springframework.context.annotation.Configuration; 8 | 9 | @Configuration 10 | public class ReactiveTramEventSubscriberConfiguration { 11 | 12 | @Bean 13 | public ReactiveDomainEventDispatcherFactory domainEventDispatcherFactory(ReactiveMessageConsumer messageConsumer, 14 | DomainEventNameMapping domainEventNameMapping) { 15 | return new SpringReactiveDomainEventDispatcherFactory(messageConsumer, domainEventNameMapping); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-events/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-reactive-events-publisher") 4 | api project(":eventuate-tram-spring-reactive-events-subscriber") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-integration-tests/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-spring-reactive-consumer-jdbc") 4 | api project(":eventuate-tram-spring-reactive-consumer-kafka") 5 | api project(":eventuate-tram-spring-reactive-producer-jdbc") 6 | api project(":eventuate-tram-spring-reactive-events-publisher") 7 | api project(":eventuate-tram-spring-reactive-events-subscriber") 8 | api project(":eventuate-tram-spring-reactive-commands") 9 | 10 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 11 | testImplementation "io.eventuate.util:eventuate-util-test:$eventuateUtilVersion" 12 | 13 | } 14 | 15 | test { 16 | def profile = System.env['SPRING_PROFILES_ACTIVE'] 17 | if (profile != null && profile != "" && (!profile.toLowerCase().contains("mysql") || profile.toLowerCase().contains("redis"))) { 18 | exclude '**/**' 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-integration-tests/src/test/java/io/eventuate/tram/reactive/integrationtests/IdSupplier.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.integrationtests; 2 | 3 | import java.util.UUID; 4 | 5 | public class IdSupplier { 6 | public static String get() { 7 | return UUID.randomUUID().toString(); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-integration-tests/src/test/java/io/eventuate/tram/reactive/integrationtests/commands/TestCommand.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.integrationtests.commands; 2 | 3 | import io.eventuate.tram.commands.common.Command; 4 | 5 | public class TestCommand implements Command { 6 | 7 | private String payload; 8 | 9 | public TestCommand() { 10 | } 11 | 12 | public TestCommand(String payload) { 13 | this.payload = payload; 14 | } 15 | 16 | public String getPayload() { 17 | return payload; 18 | } 19 | 20 | public void setPayload(String payload) { 21 | this.payload = payload; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-integration-tests/src/test/java/io/eventuate/tram/reactive/integrationtests/commands/TestCommandForMultipleReplies.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.integrationtests.commands; 2 | 3 | import io.eventuate.tram.commands.common.Command; 4 | 5 | public class TestCommandForMultipleReplies implements Command { 6 | } 7 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-integration-tests/src/test/java/io/eventuate/tram/reactive/integrationtests/events/AdditionalTestEvent.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.integrationtests.events; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | 5 | public class AdditionalTestEvent implements DomainEvent { 6 | 7 | private String payload; 8 | 9 | public AdditionalTestEvent() { 10 | } 11 | 12 | public AdditionalTestEvent(String payload) { 13 | this.payload = payload; 14 | } 15 | 16 | public String getPayload() { 17 | return payload; 18 | } 19 | 20 | public void setPayload(String payload) { 21 | this.payload = payload; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-integration-tests/src/test/java/io/eventuate/tram/reactive/integrationtests/events/TestEvent.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.integrationtests.events; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | 5 | public class TestEvent implements DomainEvent { 6 | 7 | private String payload; 8 | 9 | public TestEvent() { 10 | } 11 | 12 | public TestEvent(String payload) { 13 | this.payload = payload; 14 | } 15 | 16 | public String getPayload() { 17 | return payload; 18 | } 19 | 20 | public void setPayload(String payload) { 21 | this.payload = payload; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-integration-tests/src/test/java/io/eventuate/tram/reactive/integrationtests/events/TestEventThatInitiatesException.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.reactive.integrationtests.events; 2 | 3 | import io.eventuate.tram.events.common.DomainEvent; 4 | 5 | public class TestEventThatInitiatesException implements DomainEvent { 6 | 7 | private String payload; 8 | 9 | public TestEventThatInitiatesException() { 10 | } 11 | 12 | public TestEventThatInitiatesException(String payload) { 13 | this.payload = payload; 14 | } 15 | 16 | public String getPayload() { 17 | return payload; 18 | } 19 | 20 | public void setPayload(String payload) { 21 | this.payload = payload; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-integration-tests/src/test/resources/application.properties: -------------------------------------------------------------------------------- 1 | eventuate.reactive.db.driver=mysql 2 | eventuate.reactive.db.host=${DOCKER_HOST_IP:localhost} 3 | eventuate.reactive.db.port=3306 4 | eventuate.reactive.db.username=mysqluser 5 | eventuate.reactive.db.password=mysqlpw 6 | eventuate.reactive.db.database=eventuate 7 | 8 | eventuatelocal.kafka.bootstrap.servers=${DOCKER_HOST_IP:localhost}:9092 -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-jdbc-kafka/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api "io.eventuate.messaging.kafka:eventuate-messaging-kafka-spring-consumer:$eventuateMessagingKafkaVersion" 4 | 5 | api project(":eventuate-tram-spring-reactive-producer-jdbc") 6 | api project(":eventuate-tram-spring-reactive-consumer-common") 7 | api project(":eventuate-tram-spring-reactive-consumer-jdbc") 8 | api project(":eventuate-tram-spring-reactive-consumer-kafka") 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-jdbc-kafka/src/main/java/io/eventuate/tram/spring/reactive/jdbckafka/ReactiveTramJdbcKafkaConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.jdbckafka; 2 | 3 | import io.eventuate.tram.spring.messaging.producer.jdbc.reactive.ReactiveTramMessageProducerJdbcConfiguration; 4 | import io.eventuate.tram.spring.reactive.consumer.kafka.EventuateTramReactiveKafkaMessageConsumerConfiguration; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.context.annotation.Import; 7 | 8 | @Configuration 9 | @Import({ReactiveTramMessageProducerJdbcConfiguration.class, 10 | EventuateTramReactiveKafkaMessageConsumerConfiguration.class}) 11 | public class ReactiveTramJdbcKafkaConfiguration { 12 | } 13 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-messaging-starter/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | compileOnly project(":eventuate-tram-spring-reactive-producer-jdbc") 4 | compileOnly project(":eventuate-tram-spring-reactive-consumer-kafka") 5 | } 6 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-messaging-starter/src/main/java/io/eventuate/tram/spring/reactive/messaging/autoconfigure/EventuateTramReactiveKafkaMessageConsumerAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.messaging.autoconfigure; 2 | 3 | import io.eventuate.tram.consumer.common.MessageConsumerImplementation; 4 | import io.eventuate.tram.spring.reactive.consumer.kafka.EventuateTramReactiveKafkaMessageConsumerConfiguration; 5 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 6 | import org.springframework.boot.autoconfigure.AutoConfiguration; 7 | import org.springframework.context.annotation.Import; 8 | 9 | @AutoConfiguration 10 | @ConditionalOnMissingBean(MessageConsumerImplementation.class) 11 | @Import(EventuateTramReactiveKafkaMessageConsumerConfiguration.class) 12 | public class EventuateTramReactiveKafkaMessageConsumerAutoConfiguration { 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-messaging-starter/src/main/java/io/eventuate/tram/spring/reactive/messaging/autoconfigure/ReactiveTramMessageProducerJdbcAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.messaging.autoconfigure; 2 | 3 | import io.eventuate.tram.spring.messaging.producer.jdbc.reactive.ReactiveTramMessageProducerJdbcConfiguration; 4 | import org.springframework.boot.autoconfigure.AutoConfiguration; 5 | import org.springframework.context.annotation.Import; 6 | 7 | @AutoConfiguration 8 | @Import(ReactiveTramMessageProducerJdbcConfiguration.class) 9 | public class ReactiveTramMessageProducerJdbcAutoConfiguration { 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-messaging-starter/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.reactive.messaging.autoconfigure.EventuateTramReactiveKafkaMessageConsumerAutoConfiguration, \ 3 | io.eventuate.tram.spring.reactive.messaging.autoconfigure.ReactiveTramMessageProducerJdbcAutoConfiguration 4 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-messaging-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.reactive.messaging.autoconfigure.EventuateTramReactiveKafkaMessageConsumerAutoConfiguration 2 | io.eventuate.tram.spring.reactive.messaging.autoconfigure.ReactiveTramMessageProducerJdbcAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-optimistic-locking/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | api project(":eventuate-tram-reactive-consumer-common") 3 | api "org.springframework.boot:spring-boot-starter-jdbc:$springBootVersion" 4 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 5 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-optimistic-locking/src/main/java/io/eventuate/tram/spring/reactive/optimisticlocking/OptimisticLockingDecoratorAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.optimisticlocking; 2 | 3 | import org.springframework.boot.autoconfigure.AutoConfiguration; 4 | import org.springframework.context.annotation.Import; 5 | 6 | @AutoConfiguration 7 | @Import(OptimisticLockingDecoratorConfiguration.class) 8 | public class OptimisticLockingDecoratorAutoConfiguration { 9 | } 10 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-optimistic-locking/src/main/java/io/eventuate/tram/spring/reactive/optimisticlocking/OptimisticLockingDecoratorConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.reactive.optimisticlocking; 2 | 3 | import org.springframework.context.annotation.Bean; 4 | import org.springframework.context.annotation.Configuration; 5 | 6 | @Configuration 7 | public class OptimisticLockingDecoratorConfiguration { 8 | 9 | @Bean 10 | public OptimisticLockingDecorator reactiveOptimisticLockingDecorator() { 11 | return new OptimisticLockingDecorator(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-optimistic-locking/src/main/resources/META-INF/spring.factories: -------------------------------------------------------------------------------- 1 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 2 | io.eventuate.tram.spring.reactive.optimisticlocking.OptimisticLockingDecoratorAutoConfiguration 3 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-optimistic-locking/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -------------------------------------------------------------------------------- 1 | io.eventuate.tram.spring.reactive.optimisticlocking.OptimisticLockingDecoratorAutoConfiguration 2 | -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-producer-jdbc/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-reactive-producer-jdbc") 4 | 5 | api "io.eventuate.common:eventuate-common-spring-reactive-jdbc:$eventuateCommonVersion" 6 | 7 | testImplementation project(":eventuate-tram-spring-consumer-kafka") 8 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 9 | } 10 | 11 | test { 12 | def profile = System.env['SPRING_PROFILES_ACTIVE'] 13 | if (profile != null && profile != '' && !profile.toLowerCase().contains("mysql")) { 14 | exclude '**/ReactiveTramIntegrationTest**' 15 | } 16 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-reactive-producer-jdbc/src/test/resources/application.properties: -------------------------------------------------------------------------------- 1 | eventuate.reactive.db.driver=mysql 2 | eventuate.reactive.db.host=${DOCKER_HOST_IP:localhost} 3 | eventuate.reactive.db.port=3306 4 | eventuate.reactive.db.username=mysqluser 5 | eventuate.reactive.db.password=mysqlpw 6 | eventuate.reactive.db.database=eventuate 7 | 8 | eventuatelocal.kafka.bootstrap.servers=${DOCKER_HOST_IP:localhost}:9092 9 | -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-cloud-contract/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | 4 | api project(":eventuate-tram-messaging") 5 | api project(":eventuate-tram-commands") 6 | api "org.springframework.cloud:spring-cloud-starter-contract-verifier:$springCloudContractDependenciesVersion" 7 | api project(":eventuate-tram-spring-in-memory") 8 | api "org.springframework.cloud:spring-cloud-starter-contract-stub-runner:$springCloudContractDependenciesVersion" 9 | 10 | } 11 | -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-cloud-contract/src/main/java/io/eventuate/tram/spring/cloudcontractsupport/ContractVerifierEventuateMessaging.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.cloudcontractsupport; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | import org.springframework.cloud.contract.verifier.messaging.MessageVerifier; 5 | import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierMessage; 6 | import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierMessaging; 7 | 8 | import java.util.HashMap; 9 | 10 | public class ContractVerifierEventuateMessaging extends ContractVerifierMessaging { 11 | public ContractVerifierEventuateMessaging(MessageVerifier exchange) { 12 | super(exchange); 13 | } 14 | 15 | @Override 16 | protected ContractVerifierMessage convert(Message receive) { 17 | if (receive == null) 18 | return null; 19 | return new ContractVerifierMessage(receive.getPayload(), new HashMap<>(receive.getHeaders())); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-cloud-contract/src/main/java/io/eventuate/tram/spring/cloudcontractsupport/EventuateContractVerifierConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.cloudcontractsupport; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | import org.springframework.cloud.contract.verifier.messaging.MessageVerifier; 5 | import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierMessaging; 6 | import org.springframework.context.annotation.Bean; 7 | import org.springframework.context.annotation.Configuration; 8 | 9 | @Configuration 10 | public class EventuateContractVerifierConfiguration { 11 | 12 | @Bean 13 | public EventuateTramMessageVerifier newEventuateTramMessageVerifier() { 14 | return new EventuateTramMessageVerifier(); 15 | } 16 | 17 | @Bean 18 | public ContractVerifierMessaging contractVerifierEventuateMessaging(MessageVerifier exchange) { 19 | return new ContractVerifierEventuateMessaging(exchange); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-kafka-producer/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | 3 | implementation project(":eventuate-tram-spring-commands") 4 | implementation "io.eventuate.messaging.kafka:eventuate-messaging-kafka-spring-producer:$eventuateMessagingKafkaVersion" 5 | 6 | 7 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-messaging/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | compileOnly project(":eventuate-tram-events") 4 | implementation project(":eventuate-tram-messaging") 5 | implementation "io.eventuate.common:eventuate-common-json-mapper:$eventuateCommonVersion" 6 | 7 | compileOnly "org.springframework.boot:spring-boot-starter:$springBootVersion" 8 | compileOnly "org.springframework.boot:spring-boot-starter-jdbc:$springBootVersion" 9 | 10 | implementation "com.jayway.jsonpath:json-path:2.6.0" 11 | 12 | implementation "org.hamcrest:hamcrest:2.2" 13 | implementation "org.junit.jupiter:junit-jupiter-api:5.5.2" 14 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-messaging/src/main/java/io/eventuate/tram/spring/testing/events/publisher/EventOutboxTestSupportConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.testing.events.publisher; 2 | 3 | import org.springframework.context.annotation.Bean; 4 | import org.springframework.context.annotation.Configuration; 5 | import org.springframework.jdbc.core.JdbcTemplate; 6 | 7 | @Configuration 8 | public class EventOutboxTestSupportConfiguration { 9 | 10 | @Bean 11 | public EventOutboxTestSupport eventOutboxTestSupport(JdbcTemplate jdbcTemplate) { 12 | return new EventOutboxTestSupport(jdbcTemplate); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-messaging/src/main/java/io/eventuate/tram/spring/testing/messaging/UniqueChannelMappingConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.testing.messaging; 2 | 3 | import org.springframework.context.annotation.Bean; 4 | import org.springframework.context.annotation.Configuration; 5 | 6 | @Configuration 7 | public class UniqueChannelMappingConfiguration { 8 | 9 | @Bean 10 | public UniqueChannelMapping uniqueChannelMapping() { 11 | return new UniqueChannelMapping(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-messaging/src/main/java/io/eventuate/tram/spring/testing/messaging/consumer/AssertableMessageConsumerConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.testing.messaging.consumer; 2 | 3 | import io.eventuate.tram.messaging.consumer.MessageConsumer; 4 | import org.springframework.context.annotation.Bean; 5 | import org.springframework.context.annotation.Configuration; 6 | 7 | @Configuration 8 | public class AssertableMessageConsumerConfiguration { 9 | 10 | @Bean 11 | public AssertableMessageConsumer testMessageConsumer(MessageConsumer messageConsumer) { 12 | return new AssertableMessageConsumer(messageConsumer); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-messaging/src/main/java/io/eventuate/tram/spring/testing/messaging/consumer/UniqueSubscriberIdMapping.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.testing.messaging.consumer; 2 | 3 | import io.eventuate.tram.messaging.consumer.SubscriberMapping; 4 | 5 | import java.util.UUID; 6 | 7 | public class UniqueSubscriberIdMapping implements SubscriberMapping { 8 | 9 | @Override 10 | public String toExternal(String s) { 11 | return "ext-" + s + "-" + UUID.randomUUID(); 12 | } 13 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-messaging/src/main/java/io/eventuate/tram/spring/testing/messaging/consumer/UniqueSubscriberIdMappingConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.testing.messaging.consumer; 2 | 3 | import io.eventuate.tram.messaging.consumer.SubscriberMapping; 4 | import org.springframework.context.annotation.Bean; 5 | import org.springframework.context.annotation.Configuration; 6 | 7 | @Configuration 8 | public class UniqueSubscriberIdMappingConfiguration { 9 | 10 | @Bean 11 | public SubscriberMapping subscriberMapping() { 12 | return new UniqueSubscriberIdMapping(); 13 | } 14 | 15 | } 16 | 17 | -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-outbox-commands/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | implementation project(":eventuate-tram-spring-producer-jdbc") 3 | implementation project(":eventuate-tram-commands") 4 | implementation "org.assertj:assertj-core:$assertjVersion" 5 | } -------------------------------------------------------------------------------- /eventuate-tram-spring-testing-support-outbox-commands/src/main/java/io/eventuate/tram/spring/testing/outbox/commands/CommandOutboxTestSupportConfiguration.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.spring.testing.outbox.commands; 2 | 3 | 4 | import org.springframework.context.annotation.Bean; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.jdbc.core.JdbcTemplate; 7 | 8 | @Configuration 9 | public class CommandOutboxTestSupportConfiguration { 10 | @Bean 11 | public CommandOutboxTestSupport commandOutboxTestSupport(JdbcTemplate jdbcTemplate) { 12 | return new CommandOutboxTestSupport(jdbcTemplate); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /eventuate-tram-test-util/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-events") 4 | api project(":eventuate-tram-spring-commands") 5 | 6 | api "io.eventuate.util:eventuate-util-test:$eventuateUtilVersion" 7 | api "junit:junit:4.12" 8 | } 9 | -------------------------------------------------------------------------------- /eventuate-tram-test-util/src/main/java/io/eventuate/tram/testutil/TestMessageConsumerFactory.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.testutil; 2 | 3 | import io.eventuate.tram.messaging.consumer.MessageConsumer; 4 | import org.slf4j.Logger; 5 | import org.slf4j.LoggerFactory; 6 | import org.springframework.beans.factory.annotation.Autowired; 7 | 8 | import java.util.Collections; 9 | 10 | public class TestMessageConsumerFactory { 11 | 12 | private Logger logger = LoggerFactory.getLogger(getClass()); 13 | 14 | @Autowired 15 | private MessageConsumer messageConsumer; 16 | 17 | 18 | public TestMessageConsumer make() { 19 | String replyChannel = "reply-channel-" + System.currentTimeMillis(); 20 | String subscriberId = "subscriberId-" + System.currentTimeMillis(); 21 | 22 | TestMessageConsumer consumer = new TestMessageConsumer(replyChannel); 23 | 24 | messageConsumer.subscribe(subscriberId, Collections.singleton(replyChannel), consumer); 25 | 26 | return consumer; 27 | 28 | } 29 | } 30 | 31 | -------------------------------------------------------------------------------- /eventuate-tram-testing-support/build.gradle: -------------------------------------------------------------------------------- 1 | 2 | dependencies { 3 | api project(":eventuate-tram-messaging") 4 | api project(":eventuate-tram-spring-commands") 5 | api project(":eventuate-tram-spring-events") 6 | 7 | api "io.eventuate.util:eventuate-util-test:$eventuateUtilVersion" 8 | api "junit:junit:4.12" 9 | compileOnly "org.mockito:mockito-core:2.23.4" 10 | 11 | testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootCdcVersion" 12 | testImplementation project(":eventuate-tram-spring-in-memory") 13 | } 14 | -------------------------------------------------------------------------------- /eventuate-tram-testing-support/src/main/java/io/eventuate/tram/testing/commands/CommandHandlerReply.java: -------------------------------------------------------------------------------- 1 | package io.eventuate.tram.testing.commands; 2 | 3 | import io.eventuate.tram.messaging.common.Message; 4 | 5 | public class CommandHandlerReply { 6 | private final T reply; 7 | private final Message replyMessage; 8 | 9 | public CommandHandlerReply(T reply, Message replyMessage) { 10 | this.reply = reply; 11 | this.replyMessage = replyMessage; 12 | } 13 | 14 | public T getReply() { 15 | return reply; 16 | } 17 | 18 | public Message getReplyMessage() { 19 | return replyMessage; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eventuate-tram/eventuate-tram-core/b30a9d273471a26935c51e23919d4252eeb4e3b5/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Wed Jan 07 09:04:59 PST 2015 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.4-all.zip 7 | -------------------------------------------------------------------------------- /mssql-cli.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash -e 2 | 3 | docker run $* \ 4 | --name mssqlterm --rm \ 5 | -e MSSQL_HOST=$DOCKER_HOST_IP \ 6 | mcr.microsoft.com/mssql/server:2017-latest \ 7 | sh -c 'exec /opt/mssql-tools/bin/sqlcmd -S "$MSSQL_HOST" -U SA -P "Eventuate123!"' 8 | -------------------------------------------------------------------------------- /mysql-cli.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash -e 2 | 3 | docker run ${1:--it} \ 4 | --name mysqlterm --network=${PWD##*/}_default --rm \ 5 | mysql/mysql-server:8.0.27-1.2.6-server \ 6 | sh -c 'exec mysql -hmysql -uroot -prootpassword -o eventuate' 7 | -------------------------------------------------------------------------------- /postgres-cli.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash -e 2 | 3 | if [ -z "$POSTGRES_PORT" ]; then 4 | export POSTGRES_PORT=5432 5 | fi 6 | 7 | docker run $* \ 8 | --name postgresterm --rm \ 9 | -e POSTGRES_ENV_POSTGRES_USER=eventuate -e POSTGRES_PORT=$POSTGRES_PORT -e POSTGRES_ENV_POSTGRES_PASSWORD=eventuate -e POSTGRES_HOST=$DOCKER_HOST_IP \ 10 | postgres:9.6.5 \ 11 | sh -c 'export PGPASSWORD="$POSTGRES_ENV_POSTGRES_PASSWORD"; exec psql -p $POSTGRES_PORT -h $POSTGRES_HOST -U "$POSTGRES_ENV_POSTGRES_USER" ' 12 | -------------------------------------------------------------------------------- /redis-cli.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash -e 2 | 3 | docker run -it --name rediscli --rm -e DOCKER_HOST_IP=${DOCKER_HOST_IP?} redis:5.0.3 bash -c 'redis-cli -h $DOCKER_HOST_IP' 4 | -------------------------------------------------------------------------------- /wait-for-mssql.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | until (echo select 1 from dual | ./mssql-cli.sh -i > /dev/null) 4 | do 5 | echo sleeping for mssql 6 | sleep 5 7 | done 8 | -------------------------------------------------------------------------------- /wait-for-mysql.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | until (echo select 1 from dual | ./mysql-cli.sh -i > /dev/null) 4 | do 5 | echo sleeping for mysql 6 | sleep 5 7 | done 8 | -------------------------------------------------------------------------------- /wait-for-postgres.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | until (echo select 1 | ./postgres-cli.sh -i > /dev/null) 4 | do 5 | echo sleeping for postgres 6 | sleep 5 7 | done 8 | -------------------------------------------------------------------------------- /wait-for-services.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | done=false 4 | 5 | host=$1 6 | shift 7 | health_url=$1 8 | shift 9 | ports=$* 10 | 11 | while [[ "$done" = false ]]; do 12 | for port in $ports; do 13 | curl --fail http://${host}:${port}/${health_url} >& /dev/null 14 | if [[ "$?" -eq "0" ]]; then 15 | done=true 16 | else 17 | done=false 18 | break 19 | fi 20 | done 21 | if [[ "$done" = true ]]; then 22 | echo connected 23 | break; 24 | fi 25 | echo -n . 26 | sleep 1 27 | done 28 | --------------------------------------------------------------------------------