Package-level declarations
Types
The admission plug-ins of a node's me.ahoo.wow.runtime.admission.CommandGateway, and the tenants of its aggregate types. ids are the node's id generators: admission's command and aggregate ids, the wait ids, and the ids its decide functions and sagas take. authorizer is null when the application gives none (me.ahoo.wow.runtime.admission.CommandGateway.authorizes). policies are the access policies the node's kernel holds each command to, before and after deciding.
Opens the ContextBackends of each bounded context the node hosts; the host closes what it opened.
The stores of one bounded context on a node (a log, its partitions and leases are per context). The log's partition count is the context's. Without snapshots the context has no snapshot subscription, and its default wait is COMMITTED; without reservations its commands cannot reserve keys; without timers its commands and sagas cannot schedule commands: a schedule is committed but never sent.
The parts of one bounded context on a node: the log it appends through (log, the partition append queue over the backend's log), its kernel and executor, the built-in snapshots and reservations subscriptions when the context has their stores, the subscriptions runtime of its lease group, this node's ownership of the group's partitions, its wait coordinator, and the endpoint that executes the commands other nodes forward to it.
The scheduled commands of one log group of a context on a node: the built-in timers subscription writes the timers its aggregates schedule, and the runner sends them, through the node's TimerLoop, from the partitions the node owns.
One log group of a context other than its default one: the aggregate types whose log is log, on the store instance store; the checkpoints, parked entries and timers of the subscriptions reading it are in checkpoints, ledger and timers, on the same store, and so are its types' reservations (an aggregate type's reservations follow its log; a group without its own uses the context's).
One log group of a context on a node: the aggregate types whose log is log, on the store named store; the runtime of the context's subscriptions over that log, its checkpoints and parked entries in the group's store; and the group's timers, when its store has a timer store. Every group runs the same subscriptions, in the partitions the node owns.
One sampler of what a node reports that is read rather than heard, every interval: the head of each partition of each log group the node has positions in, and how many entries each subscription has parked, by its group and name (ParkedSubscription: each context has its own snapshot), counted up to maxParked. Both its health and its gauges read the one sample (latest), so the ledgers are read once per interval, whoever reports them.
Where a listing of parked entries stands: an entry of subscription parking ref.
What an operator does with the parked entries of a node's subscriptions: list and read them, retry or skip one, mark one recoverable or not (9.x MarkRecoverable), apply a retry spec to one (9.x ApplyRetrySpec). The host serves it over HTTP; any node of the service answers for every entry.
One page of ParkedOps.list: its entries, and the key the next page starts after (null at the end).
Where a subscription stands in partition: every entry up to position is complete. In a partition this node runs, position is its live watermark, head the head the last sample read (null when it read none), and the partition may be paused on a systemic failure or throttled by backpressure; in another, position is its saved checkpoint, which the node that runs it moves.
The store instances a context's ports were opened on: those its writePath needs (each store holding one of its logs, each type's primary snapshot store), whose outage makes the node not ready, and the others (additional snapshot stores, query and search stores), whose outage the node's health shows without taking it out of service.
One node of a service, assembled without a host: what a host (Spring Boot, a test, a sample) wires to its ports.
The tuning of a ServiceNode (names the host's keys for them).
The one-round-trip reads of a context's snapshots with their tails (Store.snapshotTails): the default one, of the aggregate types the layout places nowhere in particular, when their log store holds their primary snapshots, and the one of each type placed elsewhere, null when its log and primary snapshots are on different stores.
A subscription that reads the published streams of types, aggregates of another context: its filter is of that context, and it handles the records read from each type's topic.
The topics of a node's broker, each named after prefix, the prefix every service on the broker writes under:
The application's subscriptions of one bounded context (projections, reactors, sagas), beside the built-in wow.snapshot and wow.reservation ones. Called once per context while the node is assembled, with the context's parts, so a saga can forward through its coordinator; the subscriptions are registered when the node starts. The annotated processors' come from me.ahoo.wow.runtime.binding.SubscriptionBindings.
The node's subscriptions, ordered by group and then by subscription, and the orphans of its groups, ordered the same way (ServiceNode.subscriptionsView).
The subscription id, run in group over its source, with parked entries (counted up to the sampler's limit; null when not counted) and where it stands in its partitions.
A topic one of a node's contexts owns: its name, the partitions it is created with, whether a topic of another count is refused (exact, a command topic), and what it is for, as a failed check says. An exact topic has as many partitions as a log, so its count must be a valid one (Partitioner.requirePartitions).
Properties
The partitions the node's subscriptions have paused on a systemic failure, the built-in ones, the intakes' and those of other contexts' topics included: what the health model reads.
The partitions the node's subscriptions throttle on backpressure now, the built-in ones, the intakes' and those of other contexts' topics included.
Functions
What an operator reads of the node's subscriptions, the built-in ones included, each by the group it runs in, and of the checkpoints its groups hold under names they no longer have: