All Classes and Interfaces
Class
Description
Signals a failure that retrying cannot fix, such as a message that will never be
valid for this handler.
The message header names that make up the AceMQ cross-language contract.
The entry point: one connection to one broker, and the publishers and consumers built on it.
Serves AceMQ's metrics, health and version over HTTP.
Base type for every exception this library raises.
Signals a failure worth retrying: the message is sound but the attempt did not
succeed, typically because a dependency was briefly unavailable.
What should happen to a delivery once a handler has looked at it.
Handles one message and states the outcome explicitly.
Settles one delivery.
How an
AceMqActuator is exposed.Collects the settings.
How much a topology apply is allowed to do.
Reads and writes Avro.
The two formats that need no library, announced to the registry.
Announces
BytesCodec as bytes.Announces
StringCodec as text.Passes bytes through untouched.
A feature a broker either supports or does not.
Writes throwaway TLS certificates for local development.
Keeps large payloads off the broker.
Where a payload too large for a broker actually goes.
Turns payloads into bytes and back.
Announces a codec to the engine, so that a format can be chosen by name.
Finds the codecs on the classpath and names the ones used by default.
Writes in one format and reads several.
The broker's answer to one publish.
The broker has stopped accepting publishes, and waiting for it to resume ran out of time.
Everything a transport needs in order to open a connection.
Builds
ConnectionConfig instances.Hands back the JDBC connection the calling code is already using for its own work.
A message about to be handled, as an interceptor sees it.
Runs around every handler on a connection.
Several consumers on one queue, resized while the application runs.
Says how many consumers to run and how much each may hold, and then starts them.
How a consumer should behave.
A username and a secret.
Supplies the credentials to connect with, every time a connection is made.
Publishes to one destination, waiting for the broker to confirm every message.
Receives deliveries from a subscription.
Generates a throwaway certificate authority and the certificates a local broker and client
need, so that running with TLS on a developer's machine is one command rather than an
afternoon with
openssl.Encrypts whatever another codec produced, so the broker holds ciphertext.
A key and the name messages will refer to it by.
The AceMQ metadata that travels with every message, independent of payload and broker.
Builds
Envelope instances.A claim-check store on a filesystem.
Remembers which messages have already been handled, so handling one twice does not happen
twice.
What
IdempotencyStore.tryClaim(java.lang.String) found.A message handed up from the broker, still encoded.
A claim-check store in a map, for tests.
An idempotency store held in this process's memory, bounded by size and age.
A registry held in this process's memory.
A transport that runs entirely in the process, for tests that should not need Docker.
An itinerary a message carries with it, naming every stop rather than every step.
One stop on an itinerary.
An idempotency store in a database table, shared by every consumer that points at it.
An outbox kept in a relational table, in the same database as the work it accompanies.
A schema registry in a database table.
Reads and writes JSON, using Jackson.
Announces
JsonCodec to the engine as json.The keys a service can write with and the keys it can read with.
Collects keys for a
Keyring that does not change while the process runs.A keyring over a fixed map.
Getting an AES key from the shapes one usually arrives in.
A message as a handler sees it: the decoded payload plus everything known about how it
arrived.
A running consumer.
Handles one message.
The metric and span names AceMQ emits.
Creates the Micrometer sink, in a class of its own.
Creates the OpenTelemetry sink, in a class of its own.
Messages that share a key are handled in the order they were sent.
What happens when a handler fails.
Says how a stream of messages is partitioned, and then declares it.
A message on its way to the broker, already encoded.
Builds
OutboundMessage instances.One message waiting in the outbox: where it is going, what it says, and how it has fared.
Moves messages out of the outbox and into the broker.
Holds messages that must be published if, and only if, the work that produced them was
committed.
Decides which partition an ordering key belongs to.
A chain of steps, each its own queue.
Declares the steps of a pipeline, in order, threading the types along the chain.
Reads and writes Protocol Buffers.
A message about to be published, as an interceptor sees it.
Sends messages of one type to one destination.
Raised when a publish did not result in a message the broker took responsibility for and
could route.
Publishing was paused on this connection, so the message was not sent.
Runs around every publish on a connection.
How a message should be published.
The outcome of one publish, after the broker has confirmed it.
One message taken off a queue by
TransportConnection.receive(java.lang.String, java.time.Duration), and the means to settle
it.What a broker says about a queue somebody is about to declare.
Which of the four answers this is.
The kind of queue to declare.
AMQP 0-9-1 transport backed by the RabbitMQ Java client.
Moves messages out of a dead-letter queue or parking lot and back to the queue they failed in.
Asks a question and waits for the answer.
No reply arrived in time.
The other end of
Requester: reads a request, computes an answer, sends it back.The responder answered, and the answer was a failure.
When, and how often, a failed message should be tried again, and where the waiting happens.
How long before the next attempt, and where the message spends it.
Where a message is going, carried by the message.
A sequence of steps where each one knows how to undo itself.
Collects the steps of a
Saga.What a saga did.
Delivering a message later.
A schema as a registry sees it: some text, and enough about it to know what the text is.
Turns a schema into a small integer and back.
How a connection is protected.
What a connection does about transport security.
Something about the security configuration is wrong.
One stage of a pipeline: a message in, the next payload out.
A running read of a stream.
Where in a stream a consumer starts reading.
How a stream should be read.
What to do when a handler throws.
Says where to start reading a stream, and then starts.
Reads and writes UTF-8 text.
A live consumer registration.
Builds the telemetry sink for a connection.
Where AceMQ reports what it is doing.
An operation in progress.
Reads and writes TOML.
Announces
TomlCodec to the engine as toml.A topology as data: what exchanges, queues and bindings should exist.
A binding that should exist.
Builds a
Topology.An exchange that should exist.
A queue that should exist.
What applying a
Topology would do, worked out before anything is done.One item of a plan.
What a plan proposes to do about one item.
Works out what a
Topology would change before changing it.A binding to one messaging protocol.
An open connection to one broker.
Raised when a broker interaction fails in a way the caller cannot correct.
Reads and writes XML.
Announces
XmlCodec to the engine as xml.Reads and writes YAML.
Announces
YamlCodec to the engine as yaml.