- By Inheritance
- Hide All
- Show All
- abstract class CheckedSubscriptionErrorRetryPolicy[SE <: SubscriptionError] extends SubscriptionErrorRetryPolicy
Allows implementors to only specify policy for an error hierarchy they've defined.
- trait DelaySequencedEvent extends AnyRef
- final case class DelayedSequencerClient(domain: DomainId, member: String) extends DelaySequencedEvent with Product with Serializable
- final case class Fatal(msg: String) extends SequencerSubscriptionCreationError with Product with Serializable
When a fatal error occurs on the creation of a sequencer subscription, the com.digitalasset.canton.sequencing.client.ResilientSequencerSubscription will not retry the subscription creation.
- sealed trait GrpcSequencerAuthenticationSupport extends AnyRef
- class PeriodicAcknowledgements extends NamedLogging with FlagCloseable with HasFlushFuture
Periodically pull the latest clean timestamp and if it has changed acknowledge it with the sequencer.
- final case class RecordingConfig(directory: Path, filename: Option[String] = None) extends Product with Serializable
Configuration for where to record sequencer sends and events to.
Root directory for holding all recording files
Filename that is initially empty and updated to a name based on the member-id at runtime. Use setFilename to ensure this can only be set once.
- sealed trait ReplayAction extends AnyRef
- final case class ReplayConfig(recordingConfig: RecordingConfig, action: ReplayAction) extends Product with Serializable
Configuration for setting up a sequencer client to replay requests or received events.
The path to where all recorded content is stored
What type of replay we'll be performing
- trait RequestSigner extends AnyRef
- class ResilientSequencerSubscription[HandlerError] extends SequencerSubscription[HandlerError] with NamedLogging with FlagCloseableAsync with HealthComponent
Attempts to create a resilient SequencerSubscription for the SequencerClient by creating underlying subscriptions using the com.digitalasset.canton.sequencing.client.transports.SequencerClientTransport and then recreating them if they fail with a reason that is deemed retryable.
- sealed trait SendAsyncClientError extends Product with Serializable with PrettyPrinting
Errors returned from the AsyncSend where we are sure the request has not potentially been accepted by the server so may be retried using a new message id (as a tracked message id for the failed request may remain in the pending send set).
- type SendCallback = (UnlessShutdown[SendResult]) => Unit
Signature for callbacks provided to the send operation to take advantage of the SendTracker to provide tracking of the eventual send result.
- See also
- sealed trait SendResult extends Product with Serializable
Possible outcomes for a send operation can be observed by a SequencerClient
- class SendTracker extends NamedLogging with FlagCloseableAsync with AutoCloseable
When a we make a send request to the sequencer it will not be sequenced until some point in the future and may not be sequenced at all.
- sealed trait SendType extends AnyRef
What type of message is being sent.
- sealed trait SequencedEventValidationError extends Product with Serializable with PrettyPrinting
- trait SequencedEventValidator extends FlagCloseable
Validate whether a received event is valid for processing.
- trait SequencedEventValidatorFactory extends AnyRef
- class SequencedEventValidatorImpl extends SequencedEventValidator with HasCloseContext with NamedLogging
Validate whether a received event is valid for processing.
- trait SequencerClient extends SequencerClientSend with FlagCloseable
- final case class SequencerClientConfig(eventInboxSize: PositiveInt = PositiveInt.tryCreate(100), startupConnectionRetryDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(1), initialConnectionRetryDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofMillis(10), warnDisconnectDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(5), maxConnectionRetryDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(30), handshakeRetryAttempts: NonNegativeInt = NonNegativeInt.tryCreate(50), handshakeRetryDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(5), defaultMaxSequencingTimeOffset: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofMinutes(5), acknowledgementInterval: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofMinutes(1), keepAliveClient: Option[KeepAliveClientConfig] = Some(KeepAliveClientConfig()), authToken: AuthenticationTokenManagerConfig = AuthenticationTokenManagerConfig(), optimisticSequencedEventValidation: Boolean = true, skipSequencedEventValidation: Boolean = false, overrideMaxRequestSize: Option[NonNegativeInt] = None, maximumInFlightEventBatches: PositiveInt = PositiveInt.tryCreate(20)) extends Product with Serializable
Client configured options for how to connect to a sequencer
The size of the inbox queue used to store received events. Must be at least one. Events in the inbox are processed in parallel. A larger inbox may result in higher throughput at the price of higher memory consumption, larger database queries, and longer crash recovery.
Initial delay before we attempt to establish an initial connection
Initial delay before a reconnect attempt
Consider sequencer to be degraded after delay
Maximum delay before a reconnect attempt
How many attempts should we make to get a handshake response
How long to delay between attempts to fetch a handshake response
if no max-sequencing-time is supplied to send, our current time will be offset by this amount
Controls how frequently the client acknowledges how far it has successfully processed to the sequencer which allows the sequencer to remove this data when pruning.
configuration settings for the authentication token manager
if true, sequenced event signatures will be validated first optimistically and only strict if the optimistic evaluation failed. this means that for a split second, we might still accept an event signed with a key that has just been revoked.
if true, sequenced event validation will be skipped. the default setting is false. this option should only be enabled if a defective validation is blocking processing. therefore, unless you know what you are doing, you shouldn't touch this setting.
overrides the maxRequestSize configured in the dynamic domain parameters. If overrideMaxRequestSize, is set, modifying the maxRequestSize won't have any effect.
The maximum number of event batches that the system will process concurrently. Setting the
maximumInFlightEventBatchesparameter limits the number of event batches that the system will process simultaneously, preventing overload and ensuring that the system can handle the workload effectively. A higher value of
maximumInFlightEventBatchescan lead to increased throughput, but at the cost of higher memory consumption and longer processing times for each batch. A lower value of
maximumInFlightEventBatchesmay limit throughput, but can result in more stable and predictable system behavior.
- trait SequencerClientFactory extends AnyRef
- class SequencerClientImpl extends SequencerClient with FlagCloseableAsync with NamedLogging with HasFlushFuture with Spanning with HasCloseContext
The sequencer client facilitates access to the individual domain sequencer.
- trait SequencerClientSend extends AnyRef
- sealed trait SequencerClientSubscriptionError extends Product with Serializable
- final case class SequencerClientSubscriptionException(error: SequencerClientSubscriptionError) extends RuntimeException with Product with Serializable
- trait SequencerClientTransportFactory extends AnyRef
- trait SequencerSubscription[HandlerError] extends FlagCloseableAsync with NamedLogging
A running subscription to a sequencer.
- sealed trait SequencerSubscriptionCreationError extends SubscriptionError
Errors that may occur on the creation of a sequencer subscription
- trait SequencerSubscriptionFactory[HandlerError] extends AnyRef
- final case class SequencerTransportState(transport: SequencerTransportContainer, subscription: Option[Subscription] = None) extends Product with Serializable
- class SequencersTransportState extends NamedLogging with FlagCloseable
- sealed trait SubscriptionCloseReason[+E] extends AnyRef
Why did the sequencer subscription terminate
- trait SubscriptionErrorRetryPolicy extends AnyRef
Policy for what errors are considered retryable.
- trait SubscriptionRetryDelayRule extends AnyRef
Calculator for how to select the next retry duration and specifies what duration is enough to log a warning.
- object DelayedSequencerClient extends Serializable
- object GrpcSequencerAuthenticationSupport
- case object NoDelay extends DelaySequencedEvent with Product with Serializable
- object PeriodicAcknowledgements
- object ReplayAction
- object ReplayConfig extends Serializable
- object RequestSigner
- object ResilientSequencerSubscription extends SequencerSubscriptionErrorGroup
- object SendAsyncClientError extends Serializable
- object SendCallback
Utilities for a SendCallback passed to the send method of the SequencerClient
- object SendResult extends Serializable
- object SendType
- object SequencedEventValidationError extends Serializable
- object SequencedEventValidator extends HasLoggerName
- object SequencedEventValidatorFactory
- object SequencedEventValidatorImpl
- object SequencerClient
- object SequencerClientFactory
- object SequencerClientSubscriptionError extends Serializable
- object SequencerClientTransportFactory
- object SequencerTransportState extends Serializable
- object SubscriptionCloseReason
- object SubscriptionErrorRetryPolicy
- object SubscriptionRetryDelayRule