- 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
- case class DelayedSequencerClient(domain: DomainId, member: String) extends DelaySequencedEvent with Product with Serializable
- case class EventValidatorFactoryArgs(initialLastEventProcessedMetadataO: Option[SequencedEventMetadata], unauthenticated: Boolean) extends Product with Serializable
settings to control the behaviour of the sequenced event validation factory
- 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.
- 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
- 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
- class ResilientSequencerSubscription[HandlerError] extends SequencerSubscription[HandlerError] with NamedLogging with FlagCloseableAsync with HasDegradationState[Warn]
- 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 = (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
- class SendCallbackWithFuture extends SendCallback
- sealed trait SendResult extends Product with Serializable
Possible outcomes for a send operation can be observed by a SequencerClient
- type SendTimeoutHandler = (MessageId) => EitherT[Future, TimeoutHandlerError, Unit]
Signature for handlers that are notified that the sequencer clock has progressed beyond the max sequencing time of a send previously done by the client and receipt has not been witnessed.
- class SendTracker extends NamedLogging 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.
- case class SequencedEventMetadata(counter: SequencerCounter, timestamp: CantonTimestamp, hash: Option[Hash]) extends Product with Serializable
Metadata of a protocol.SequencedEvent.
The counter value assigned to the event
The timestamp assigned to the event
The hash of the event contents that is also used for signing the event None for ignored sequenced events.
- sealed trait SequencedEventValidationError extends AnyRef
- class SequencedEventValidator extends ValidateSequencedEvent with NamedLogging
Validate whether a received event is valid for processing.
- class SequencerClient extends FlagCloseableAsync with NamedLogging with HasFlushFuture with Spanning
The sequencer client facilitates access to the individual domain sequencer.
- case class SequencerClientConfig(eventInboxSize: NonNegativeInt = NonNegativeInt.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) 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 optimistical 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.
- trait SequencerClientFactory extends AnyRef
- sealed trait SequencerClientSubscriptionError extends Product with Serializable
- case class SequencerClientSubscriptionException(error: SequencerClientSubscriptionError) extends RuntimeException with Product with Serializable
- 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
- 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.
- trait ValidateSequencedEvent extends AnyRef
Validate whether a received event is valid for processing.
- object DelayedSequencerClient extends Serializable
- object GrpcSequencerAuthenticationSupport
- case object NoDelay extends DelaySequencedEvent with Product with Serializable
- object PeriodicAcknowledgements
- object ReplayAction
- object ReplayConfig extends Serializable
- 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 SendTrackerUpdateError
- object SendType
- object SequencedEventMetadata extends Serializable
- object SequencedEventValidationError
- object SequencerClient
- object SequencerClientSubscriptionError extends Serializable
- object SubscriptionCloseReason
- object SubscriptionErrorRetryPolicy
- object SubscriptionRetryDelayRule