Can't get CDC service to start

An Eventuate project

This project is part of Eventuate, which is a microservices collaboration platform.

Eventuate Tram (Transactional Messaging) platform

Spring/Micronaut
Quarkus

Eventuate Tram is a platform that solves the distributed data management problems inherent in a microservice architecture.

It is described in more detail in my book Microservice Patterns and the getting started guide.

Key benefits of Eventuate Tram

Maintain data consistency using sagas

Implement commands that update data in multiple microservices by using Sagas, which are sequences of local transactions coordinated using messages

Implement queries using CQRS

Implement queries that retrieve data from multiple services by using CQRS views, which are easily queryable replicas maintained using events

Communicate using transactional messaging

Reliably send and receive messages and events as part of a database transaction by using the Transactional Outbox pattern

How it works

Eventuate Tram provides several messaging abstractions:

messaging - send and receive messages over named channels
events - publish domain events and subscribe to domain events
commands - asynchronously send a command to a service and receive a reply

Eventuate Tram messaging implements the Transactional Outbox pattern. An message producer inserts events into an OUTBOX table as part of the ACID transaction that updates data, such as JPA entities. A separate message relay (a.k.a. Eventuate CDC service) publishes messages to the message broker.

The Eventuate CDC service works in one of two ways:

Transaction log tailing - currently implemented for MySQL and Postgres WAL
Polling - for other databases

Supported technologies

Languages:

Spring Boot
Micronaut
Quarkus - see https://github.com/eventuate-tram/eventuate-tram-core-quarkus
.NET - see this project

Databases:

MySQL - transaction log tailing using the MySQL binlog
Postgres - transaction log tailing using the Postgres WAL
Other databases including Microsoft SQL server - polling

Message brokers:

Apache Kafka
ActiveMQ
RabbitMQ
Redis Streams

Getting started

Please see the getting started guide.

Example applications

There are numerous example applications:

Basic examples
Customers and Orders - illustrates choreography-based sagas and CQRS
Customers and Orders - illustrates orchestration-based sagas using the Eventuate Tram Sagas framework
FTGO Example application for Microservice Patterns book

Got questions?

Don’t hesitate to create an issue or see

Need support?

Take a look at the available paid support options.

Transactional messaging

Send a message using MessageProducer:

public interface MessageProducer {
  void send(String destination, Message message);
}

Receive messages using:

public interface MessageConsumer {
  void subscribe(String subscriberId, Set<String> channels, MessageHandler handler);
}

See this example of transactional messaging.

Transactional domain events

The domain event package builds on the core APIs.

Publish domain events using the DomainEventPublisher interface:

public interface DomainEventPublisher {

  void publish(String aggregateType, Object aggregateId, List<DomainEvent> domainEvents);
  ...

Subscribe to domain events using a DomainEventDispatcher:

public class DomainEventDispatcher {
    public DomainEventDispatcher(String eventDispatcherId,
                DomainEventHandlers eventHandlers,
                ...) {
...
}

Handle the events using DomainEventHandlers:

public class RestaurantOrderEventConsumer {

  public DomainEventHandlers domainEventHandlers() {
    return DomainEventHandlersBuilder
            .forAggregateType("net.chrisrichardson.ftgo.restaurantservice.Restaurant")
            .onEvent(RestaurantMenuRevised.class, this::reviseMenu)
            .build();
  }

  public void reviseMenu(DomainEventEnvelope<RestaurantMenuRevised> de) {

See this example of transaction events.

Transactional commands

Transaction commands are implemented using transactional messaging.

Send a command using a CommandProducer:

public interface CommandProducer {
  String send(String channel, Command command, String replyTo, Map<String, String> headers);
  ...
}

Subscribe to commands using a CommandDispatcher:

public class CommandDispatcher {

  public CommandDispatcher(String commandDispatcherId,
           CommandHandlers commandHandlers) {
  ...
}

Handle commands and send a reply using CommandHandlers:

public class OrderCommandHandlers {


  public CommandHandlers commandHandlers() {
    return CommandHandlersBuilder
          .fromChannel("orderService")
          .onMessage(ApproveOrderCommand.class, this::approveOrder)
          ...
          .build();
  }

  public Message approveOrder(CommandMessage<ApproveOrderCommand> cm) {
    ApproveOrderCommand command = cm.getCommand();
    ...
  }

See this example of transactional commands.

Maven/Gradle artifacts

The artifacts are in JCenter. The latest version is:

RC
Release

There are the following API artifacts:

io.eventuate.tram.core:eventuate-tram-messaging:$eventuateTramVersion - core messaging APIs
io.eventuate.tram.core:eventuate-tram-events:$eventuateTramVersion - domain event API
io.eventuate.tram.core:eventuate-tram-commands:$eventuateTramVersion - commands/reply API

There are the following 'implementation' artifacts:

io.eventuate.tram.core:eventuate-tram-jdbc-kafka:$eventuateTramVersion - JDBC database and Apache Kafka message broker
io.eventuate.tram.core:eventuate-tram-jdbc-activemq:$eventuateTramVersion - JDBC database and Apache ActiveMQ message broker
io.eventuate.tram.core:eventuate-tram-jdbc-rabbitmq:$eventuateTramVersion - JDBC database and RabbitMQ message broker
io.eventuate.tram.core:eventuate-tram-jdbc-redis:$eventuateTramVersion - JDBC database and Redis Streams
io.eventuate.tram.core:eventuate-tram-in-memory:$eventuateTramVersion - In-memory JDBC database and in-memory messaging for testing

Running the CDC service

In addition to a database and message broker, you will need to run the Eventuate Tram CDC service. It reads events inserted into the database and publishes them to the message broker. It is written using Spring Boot. The easiest way to run this service during development is to use Docker Compose. The Eventuate Tram Code Basic examples project has an example docker-compose.yml file.

Contributing

Contributions are welcome.

Please sign a contributor license agreement.

	@RestController
	public class SwaggerController {
	@GetMapping("/swagger-ui.html")
	public Resource getFile() {
	return new ClassPathResource("META-INF/swagger-ui/index.html");
	}
	}

	export EVENTUATELOCAL_CDC_POLLING_INTERVAL_IN_MILLISECONDS=500
	export EVENTUATELOCAL_CDC_MAX_EVENTS_PER_POLLING=1000
	export EVENTUATELOCAL_CDC_MAX_ATTEMPTS_FOR_POLLING=100
	export EVENTUATELOCAL_CDC_POLLING_RETRY_INTERVAL_IN_MILLISECONDS=500
	export SPRING_PROFILES_ACTIVE=EventuatePolling

	EVENTUATELOCAL_CDC_POLLING_INTERVAL_IN_MILLISECONDS: 500
	EVENTUATELOCAL_CDC_MAX_EVENTS_PER_POLLING: 1000
	EVENTUATELOCAL_CDC_MAX_ATTEMPTS_FOR_POLLING: 100
	EVENTUATELOCAL_CDC_POLLING_RETRY_INTERVAL_IN_MILLISECONDS: 500

eventuate-tram / eventuate-tram-sagas-examples-customers-and-orders Goto Github PK

eventuate-tram-sagas-examples-customers-and-orders's Introduction

An Eventuate project

Eventuate Tram (Transactional Messaging) platform

Key benefits of Eventuate Tram

Maintain data consistency using sagas

Implement queries using CQRS

Communicate using transactional messaging

How it works

Supported technologies

Getting started

Example applications

Got questions?

Need support?

Transactional messaging

Transactional domain events

Transactional commands

Maven/Gradle artifacts

Running the CDC service

Contributing

eventuate-tram-sagas-examples-customers-and-orders's People

Contributors

Stargazers

Watchers

Forkers

eventuate-tram-sagas-examples-customers-and-orders's Issues

Test:

API Gateway

composeUp

Recommend Projects

Recommend Topics

Recommend Org

Jobs