Package-level declarations
Types
How a subscription answers backpressure: a failure classified me.ahoo.wow.spi.subscription.FailureClass.BACKPRESSURE, a downstream that is up but asked to be called later. The entry is retried at most maxAttempts times, then its aggregate parks as after any spent budget; it never pauses the partition. The wait before the next attempt starts at initialBackoff, doubles to at most maxBackoff, is shortened by up to jitter (a share, 0 to 1) at random so the lanes do not retry in step, and is at least the downstream's Retry-After. Meanwhile the partition is throttled: each backpressure halves the handlings it runs at once, down to minConcurrency, and each success raises it by half again, back to the in-flight bound (at once when no handling waits under the limit).
Turns a committed stream into the entry a handler receives. It runs inside the handler's retries, so a stream that cannot be decoded is retried and then parks its aggregate like a failing handler.
Hears what happens to a subscription's parked entries that an operator should know of (9.x's WeCom webhook): an aggregate parked, and an entry whose automatic retries are spent. It is told on the node that parked or retried the entry, once per change of the ledger, best effort: a notifier that fails is logged, and the subscription goes on. A notifier should return quickly; it runs beside the subscription, not in its way.
How a SubscriptionRuntime retries its parked entries over the long horizon (9.x CompensationScheduler): every scanInterval it reads its subscriptions' ledger entries and, in each partition it runs, retries those whose next retry is due (me.ahoo.wow.spi.ledger.ParkedAggregate.nextRetryAt) and runs the requests an operator left on them.
A subscription's partition paused on a systemic failure: since since (epoch milliseconds), for reason, subscription of the subscription group handles nothing in partition but one probe at a time, until a handling succeeds. reason says it in full, the failure's message and aggregate included, for the log; failure is the class name of the failure that paused it, all the health details show, since a message may carry data.
How a failing call is retried: at most maxAttempts calls in all, waiting initialBackoff after the first failure and multiplier times longer after each next one, never longer than maxBackoff. A handler's attempt that runs longer than timeout is cancelled and counts as failed; infinite by default.
What a handler receives: one committed stream (its ref, version, scope and events), at its log position, with its events as the subscription's EntryDecoder read them and the transport metadata appended with it.
The streams a subscription handles: those of one bounded context, of the aggregates named (every aggregate of the context when empty), of the aggregates whose id is in ids (any id when empty: a job's subscription reads its job's instances alone), holding at least one event whose stored name is in events (any event when empty). Event names are the names the log stores (context.aggregate.Event). Without models a renamed event must be listed under its former names too; resolve adds them from the models. An entry outside the filter still moves the checkpoint, its state never read.
The tuning of a SubscriptionRuntime.
The partitions a node's subscriptions have paused on a systemic failure, as the health model reads them: a paused partition is not a failed node, but one its operator wants to see, and that stays paused as long as what it depends on is down.
Where subscription stands in partition of its source: every entry up to the sequence watermark is complete.
Runs the subscriptions of one subscription group over the partitions this node owns (–§3).
Where a subscription that has no checkpoint yet in a partition starts: the host's override of its handler's StartFrom (wow.subscriptions."<name>".start, SubscriptionOptions.starts). A subscription that has a checkpoint goes on from it whatever this says.
When a subscription pauses a partition on a systemic failure: at once on a failure classified me.ahoo.wow.spi.subscription.FailureClass.SYSTEMIC; and when failingAggregates different aggregates failed with a recoverable one within window, with no handling succeeding since (0 turns that off). While paused, one attempt at a time probes whether what failed is back, the first initialBackoff after the pause, each next one twice as long after the previous one failed, at most maxBackoff.
A subscription's partition throttled by backpressure: since since (epoch milliseconds), subscription of the subscription group runs at most limit handlings at once in partition.