Ecotone
SponsorBlogGithubSupport and ContactCommunity Channel
  • About
  • Installation
  • How to use
    • CQRS PHP
    • Event Handling PHP
    • Aggregates & Sagas
    • Scheduling in PHP
    • Asynchronous PHP
    • Event Sourcing PHP
    • Microservices PHP
    • Resiliency and Error Handling
    • Laravel Demos
    • Symfony Demos
      • Doctrine ORM
  • Tutorial
    • Before we start tutorial
    • Lesson 1: Messaging Concepts
    • Lesson 2: Tactical DDD
    • Lesson 3: Converters
    • Lesson 4: Metadata and Method Invocation
    • Lesson 5: Interceptors
    • Lesson 6: Asynchronous Handling
  • Enterprise
  • Modelling
    • Introduction
    • Message Bus and CQRS
      • CQRS Introduction - Commands
        • Query Handling
        • Event Handling
      • Aggregate Introduction
        • Aggregate Command Handlers
        • Aggregate Query Handlers
        • Aggregate Event Handlers
        • Advanced Aggregate creation
      • Repositories Introduction
      • Business Interface
        • Introduction
        • Business Repository
        • Database Business Interface
          • Converting Parameters
          • Converting Results
      • Saga Introduction
      • Identifier Mapping
    • Extending Messaging (Middlewares)
      • Message Headers
      • Interceptors (Middlewares)
        • Additional Scenarios
      • Intercepting Asynchronous Endpoints
      • Extending Message Buses (Gateways)
    • Event Sourcing
      • Installation
      • Event Sourcing Introduction
        • Working with Event Streams
        • Event Sourcing Aggregates
          • Working with Aggregates
          • Applying Events
          • Different ways to Record Events
        • Working with Metadata
        • Event versioning
        • Event Stream Persistence
          • Event Sourcing Repository
          • Making Stream immune to changes
          • Snapshoting
          • Persistence Strategies
          • Event Serialization and PII Data (GDPR)
      • Projection Introduction
        • Configuration
        • Choosing Event Streams for Projection
        • Executing and Managing
          • Running Projections
          • Projection CLI Actions
          • Access Event Store
        • Projections with State
        • Emitting events
    • Recovering, Tracing and Monitoring
      • Resiliency
        • Retries
        • Error Channel and Dead Letter
          • Dbal Dead Letter
        • Idempotent Consumer (Deduplication)
        • Resilient Sending
        • Outbox Pattern
        • Concurrency Handling
      • Message Handling Isolation
      • Ecotone Pulse (Service Dashboard)
    • Asynchronous Handling and Scheduling
      • Asynchronous Message Handlers
      • Asynchronous Message Bus (Gateways)
      • Delaying Messages
      • Time to Live
      • Message Priority
      • Scheduling
      • Dynamic Message Channels
    • Distributed Bus and Microservices
      • Distributed Bus
        • Distributed Bus with Service Map
          • Configuration
          • Custom Features
          • Non-Ecotone Application integration
          • Testing
        • AMQP Distributed Bus (RabbitMQ)
          • Configuration
        • Distributed Bus Interface
      • Message Consumer
      • Message Publisher
    • Business Workflows
      • The Basics - Stateless Workflows
      • Stateful Workflows - Saga
      • Handling Failures
    • Testing Support
      • Testing Messaging
      • Testing Aggregates and Sagas with Message Flows
      • Testing Event Sourcing Applications
      • Testing Asynchronous Messaging
  • Messaging and Ecotone In Depth
    • Overview
    • Multi-Tenancy Support
      • Getting Started
        • Any Framework Configuration
        • Symfony and Doctrine ORM
        • Laravel
      • Different Scenarios
        • Hooking into Tenant Switch
        • Shared and Multi Database Tenants
        • Accessing Current Tenant in Message Handler
        • Events and Tenant Propagation
        • Multi-Tenant aware Dead Letter
      • Advanced Queuing Strategies
    • Document Store
    • Console Commands
    • Messaging concepts
      • Message
      • Message Channel
      • Message Endpoints/Handlers
        • Internal Message Handler
        • Message Router
        • Splitter
      • Consumer
      • Messaging Gateway
      • Inbound/Outbound Channel Adapter
    • Method Invocation And Conversion
      • Method Invocation
      • Conversion
        • Payload Conversion
        • Headers Conversion
    • Service (Application) Configuration
    • Contributing to Ecotone
      • How Ecotone works under the hood
      • Ecotone Phases
      • Registering new Module Package
      • Demo Integration with SQS
        • Preparation
        • Inbound and Outbound Adapters and Message Channel
        • Message Consumer and Publisher
  • Modules
    • Overview
    • Symfony
      • Symfony Configuration
      • Symfony Database Connection (DBAL Module)
      • Doctrine ORM
      • Symfony Messenger Transport
    • Laravel
      • Laravel Configuration
      • Database Connection (DBAL Module)
      • Eloquent
      • Laravel Queues
      • Laravel Octane
    • Ecotone Lite
      • Logging
      • Database Connection (DBAL Module)
    • JMS Converter
    • OpenTelemetry (Tracing and Metrics)
      • Configuration
    • RabbitMQ Support
    • Kafka Support
      • Configuration
      • Message partitioning
      • Usage
    • DBAL Support
    • Amazon SQS Support
    • Redis Support
  • Other
    • Contact, Workshops and Support
Powered by GitBook
On this page
  • Ecotone's Heart (Configuration)
  • Ecotone's Heart is beating (Configured Messaging System)
  • What the Heart is actually built from?
  • Ecotone's Veins

Was this helpful?

Export as PDF
  1. Messaging and Ecotone In Depth
  2. Contributing to Ecotone

How Ecotone works under the hood

PreviousContributing to EcotoneNextEcotone Phases

Last updated 2 years ago

Was this helpful?

Ecotone's Heart (Configuration)

The heart of Ecotone is :

Ecotone\Messaging\Config\Configuration::class

This is a place, where all messaging concepts are registered. Messaging System Configuration is responsible for exposing an API for registering lower level messaging concepts, like or . This is the only place, where all configuration is gathered together in order to prepare . After setting up configuration, this config can then be cached and reused between requests. This is one of the powers of Ecotone, as once the configuration is set up, then all we do is to execute it.

Ecotone's Heart is beating (Configured Messaging System)

When configuration is prepared, we can then build Configured Messaging System from it:

Ecotone\Messaging\Config\Configuration::buildMessagingSystemFromConfiguration()

The result of the built is

Ecotone\Messaging\Config\ConfiguredMessagingSystem::class

This is actually an API that you work with on daily basics when using Ecotone. We can get Command/Query/Event buses (which are actually ) from here, execute consumer or fetch message channel.

What the Heart is actually built from?

So we know that the heart of Ecotone is Messaging Configuration, what is this built from actually? Who registers Gateways, Message Handlers, Channels? And the answer are Modules. Modules are layer which transforms User land code to Ecotone's configuration.

Modules are grouped under package. This way you can steer turning off and on set of related modules. You may take a look on Ecotone\Messaging\Config\ModulePackageList to check all available module packages. And Ecotone\Messaging\Config\ModuleClassList for all modules in given package.

In most of the cases they look for code that is annotated with given Attribute, to register . This way Ecotone joins messaging world with user land world and provides easy to work with API on the high level, using powerful messaging concepts under the hood.

Ecotone's Veins

So what happens when we execute gateway like Command Bus? It goes through Message Channels (Ecotone\Messaging\MessageChannel), where at the end of each channel there is specific Message Handler (Ecotone\Messaging\MessageHandler) implementation. You can imagine channels as veins, that pass messages to your organs (Message Handlers).

Message Handlers can have input and output message channels, however they unaware of specific Channel implementation. This allow you to switch different implementations like RabbitMQ,Dbal,In Memoryand your Handlers will stay the same.

So each of the Handlers after receiving message performs an action and may provide reply message. If given Handler has output channel defined, it will go to the next channel. This happens till the moment there is no output channel defined and then flows stop.

Actually, if there is no output channel defined for Message Handler, Message Headers are checked for replyChannel header inside the Message. If it exists, it will be used as output channel. This is case for receiving reply message when using Query Bus. This logic exists in same place for all Handlers, which is Ecotone\Messaging\Handler\RequestReplyProducer.

There are multiple implementations of Message Handlers, including , Message Splitter, , you will find them in Ecotone\Messaging\Handler namespace.

What about Command/Event/Query Handlers? This is just another level of abstraction built on top of messaging concepts. In reality Command Handler is just an Service Activator. The same about Command/Event/Query buses, on the fundamental level they are combined with.

Service Activator
Router
Gateways
Routers
Messaging Configuration
Message Channels
Message Handlers
messaging gateways
Messaging Concepts
Configured Messaging System