class SequencerClientImpl extends SequencerClient with FlagCloseableAsync with NamedLogging with HasFlushFuture with Spanning with HasCloseContext
The sequencer client facilitates access to the individual domain sequencer. A client centralizes the message signing operations, as well as the handling and storage of message receipts and delivery proofs, such that this functionality does not have to be duplicated throughout the participant node.
- Alphabetic
- By Inheritance
- SequencerClientImpl
- HasCloseContext
- PromiseUnlessShutdownFactory
- Spanning
- HasFlushFuture
- NamedLogging
- FlagCloseableAsync
- SequencerClient
- FlagCloseable
- PerformUnlessClosing
- OnShutdownRunner
- AutoCloseable
- SequencerClientSend
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new SequencerClientImpl(domainId: DomainId, member: Member, sequencerTransports: SequencerTransports, config: SequencerClientConfig, testingConfig: TestingConfigInternal, protocolVersion: ProtocolVersion, domainParametersLookup: DomainParametersLookup[SequencerDomainParameters], timeouts: ProcessingTimeout, eventValidatorFactory: SequencedEventValidatorFactory, clock: Clock, requestSigner: RequestSigner, sequencedEventStore: SequencedEventStore, sendTracker: SendTracker, metrics: SequencerClientMetrics, recorderO: Option[SequencerClientRecorder], replayEnabled: Boolean, cryptoPureApi: CryptoPureApi, loggingConfig: LoggingConfig, loggerFactory: NamedLoggerFactory, futureSupervisor: FutureSupervisor, initialCounterLowerBound: SequencerCounter)(implicit executionContext: ExecutionContext, tracer: Tracer)
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def acknowledgeSigned(timestamp: CantonTimestamp)(implicit traceContext: TraceContext): EitherT[Future, String, Unit]
- Definition Classes
- SequencerClientImpl → SequencerClient
- def addToFlushAndLogError(name: String)(future: Future[_])(implicit loggingContext: ErrorLoggingContext): Unit
Adds the task
future
to the flush future so that doFlush completes only afterfuture
has completed.Adds the task
future
to the flush future so that doFlush completes only afterfuture
has completed. Logs an error if thefuture
fails with an exception.- Attributes
- protected
- Definition Classes
- HasFlushFuture
- def addToFlushWithoutLogging(name: String)(future: Future[_]): Unit
Adds the task
future
to the flush future so that doFlush completes only afterfuture
has completed.Adds the task
future
to the flush future so that doFlush completes only afterfuture
has completed. The caller is responsible for logging any exceptions thrown inside the future.- Attributes
- protected
- Definition Classes
- HasFlushFuture
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def cancelShutdownTask(token: Long): Unit
Removes a shutdown task from the list using a token returned by runOnShutdown
Removes a shutdown task from the list using a token returned by runOnShutdown
- Definition Classes
- OnShutdownRunner
- def changeTransport(sequencerTransports: SequencerTransports)(implicit traceContext: TraceContext): Future[Unit]
- Definition Classes
- SequencerClientImpl → SequencerClient
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
- final def close(): Unit
Blocks until all earlier tasks have completed and then prevents further tasks from being run.
Blocks until all earlier tasks have completed and then prevents further tasks from being run.
- Definition Classes
- FlagCloseable → OnShutdownRunner → AutoCloseable
- def closeAsync(): Seq[AsyncOrSyncCloseable]
closeAsync asynchronously releases resources held by a future
closeAsync asynchronously releases resources held by a future
- returns
an ordered sequence of async and sync closeables with async closeables made up of future and timeout
- Attributes
- protected
- Definition Classes
- SequencerClientImpl → FlagCloseableAsync
- implicit val closeContext: CloseContext
- Definition Classes
- HasCloseContext
- def closingTimeout: FiniteDuration
- Attributes
- protected
- Definition Classes
- FlagCloseable → PerformUnlessClosing
- def completion: Future[CloseReason]
Future which is completed when the client is not functional any more and is ready to be closed.
Future which is completed when the client is not functional any more and is ready to be closed. The value with which the future is completed will indicate the reason for completion.
- Definition Classes
- SequencerClientImpl → SequencerClient
- val config: SequencerClientConfig
- def containsShutdownTask(token: Long): Boolean
- Definition Classes
- OnShutdownRunner
- def doFlush(): Future[Unit]
Returns a future that completes after all added futures have completed.
Returns a future that completes after all added futures have completed. The returned future never fails.
- Attributes
- protected
- Definition Classes
- HasFlushFuture
- val domainId: DomainId
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- implicit def errorLoggingContext(implicit traceContext: TraceContext): ErrorLoggingContext
- Attributes
- protected
- Definition Classes
- NamedLogging
- def flush(): Future[Unit]
Returns a future that completes after asynchronous processing has completed for all events whose synchronous processing has been completed prior to this call.
Returns a future that completes after asynchronous processing has completed for all events whose synchronous processing has been completed prior to this call. May complete earlier if event processing has failed.
- Definition Classes
- SequencerClientImpl → SequencerClient
- Annotations
- @VisibleForTesting()
- def flushCloseable(name: String, timeout: NonNegativeDuration): SyncCloseable
- Attributes
- protected
- Definition Classes
- HasFlushFuture
- def generateMaxSequencingTime: CantonTimestamp
Provides a value for max-sequencing-time to use for
sendAsync
if no better application provided timeout is available.Provides a value for max-sequencing-time to use for
sendAsync
if no better application provided timeout is available. Is currently a configurable offset from our clock.- Definition Classes
- SequencerClientImpl → SequencerClientSend
- def generateMessageId: MessageId
Generates a message id.
Generates a message id. The message id is only for correlation within this client and does not need to be globally unique.
- Definition Classes
- SequencerClientImpl → SequencerClientSend
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- val healthComponent: CloseableHealthComponent
- Definition Classes
- SequencerClientImpl → SequencerClient
- val initialCounterLowerBound: SequencerCounter
The sequencer counter at which the first subscription starts
The sequencer counter at which the first subscription starts
- Attributes
- protected
- Definition Classes
- SequencerClientImpl → SequencerClient
- def internalPerformUnlessClosingF[A](name: String)(f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): UnlessShutdown[Future[A]]
- Attributes
- protected
- Definition Classes
- PerformUnlessClosing
- def isClosing: Boolean
Check whether we're closing.
Check whether we're closing. Susceptible to race conditions; unless you're using this as a flag to the retry lib or you really know what you're doing, prefer
performUnlessClosing
and friends.- Definition Classes
- OnShutdownRunner
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def keepTrackOfOpenFutures: Boolean
track running futures on shutdown
track running futures on shutdown
set to true to get detailed information about all futures that did not complete during shutdown. if set to false, we don't do anything.
- Attributes
- protected
- Definition Classes
- PerformUnlessClosing
- def logger: TracedLogger
- Attributes
- protected
- Definition Classes
- NamedLogging
- val loggerFactory: NamedLoggerFactory
- Definition Classes
- SequencerClientImpl → NamedLogging
- def maxSleepMillis: Long
How often to poll to check that all tasks have completed.
How often to poll to check that all tasks have completed.
- Attributes
- protected
- Definition Classes
- PerformUnlessClosing
- val member: Member
- def mkPromise[A](description: String, futureSupervisor: FutureSupervisor, logAfter: Duration = 10.seconds, logLevel: Level = Level.DEBUG)(implicit elc: ErrorLoggingContext, ec: ExecutionContext): PromiseUnlessShutdown[A]
Use this method to create a PromiseUnlessShutdown that will automatically be cancelled when the close context is closed.
Use this method to create a PromiseUnlessShutdown that will automatically be cancelled when the close context is closed. This allows proper clean up of stray promises when the node is transitioning to a passive state.
Note: you should *not* invoke
success
on the returned promise but rather usetrySuccess
. The reason is that the call tosuccess
may fail in case of shutdown.- Definition Classes
- PromiseUnlessShutdownFactory
- implicit def namedLoggingContext(implicit traceContext: TraceContext): NamedLoggingContext
- Attributes
- protected
- Definition Classes
- NamedLogging
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def noTracingLogger: Logger
- Attributes
- protected
- Definition Classes
- NamedLogging
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
- def onCloseFailure(e: Throwable): Unit
- Attributes
- protected
- Definition Classes
- PerformUnlessClosing
- final def onClosed(): Unit
- Definition Classes
- FlagCloseableAsync → PerformUnlessClosing
- final def onFirstClose(): Unit
Blocks until all earlier tasks have completed and then prevents further tasks from being run.
Blocks until all earlier tasks have completed and then prevents further tasks from being run.
- Definition Classes
- PerformUnlessClosing → OnShutdownRunner
- Annotations
- @SuppressWarnings()
- def performUnlessClosing[A](name: String)(f: => A)(implicit traceContext: TraceContext): UnlessShutdown[A]
Performs the task given by
f
unless a shutdown has been initiated.Performs the task given by
f
unless a shutdown has been initiated. The shutdown will only begin afterf
completes, but other tasks may execute concurrently withf
, if started using this function, or one of the other variants (performUnlessClosingF and performUnlessClosingEitherT). The tasks are assumed to take less than closingTimeout to complete.DO NOT CALL
this.close
as part off
, because it will result in a deadlock.- f
The task to perform
- returns
scala.None$ if a shutdown has been initiated. Otherwise the result of the task.
- Definition Classes
- PerformUnlessClosing
- def performUnlessClosingCheckedT[A, N, R](name: String, onClosing: => Checked[A, N, R])(etf: => CheckedT[Future, A, N, R])(implicit ec: ExecutionContext, traceContext: TraceContext): CheckedT[Future, A, N, R]
- Definition Classes
- PerformUnlessClosing
- def performUnlessClosingEitherT[E, R](name: String, onClosing: => E)(etf: => EitherT[Future, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[Future, E, R]
Performs the EitherT[Future] given by
etf
unless a shutdown has been initiated, in which case the provided error is returned instead.Performs the EitherT[Future] given by
etf
unless a shutdown has been initiated, in which case the provided error is returned instead. Bothetf
and the error are lazy;etf
is only evaluated if there is no shutdown, the error only if we're shutting down. The shutdown will only begin afteretf
completes, but other tasks may execute concurrently withetf
, if started using this function, or one of the other variants (performUnlessClosing and performUnlessClosingF). The tasks are assumed to take less than closingTimeout to complete.DO NOT CALL
this.close
as part ofetf
, because it will result in a deadlock.- etf
The task to perform
- Definition Classes
- PerformUnlessClosing
- def performUnlessClosingEitherTF[E, R](name: String, onClosing: => E)(etf: => EitherT[Future, E, Future[R]])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[Future, E, Future[R]]
- Definition Classes
- PerformUnlessClosing
- def performUnlessClosingEitherU[E, R](name: String)(etf: => EitherT[Future, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[FutureUnlessShutdown, E, R]
- Definition Classes
- PerformUnlessClosing
- def performUnlessClosingEitherUSF[E, R](name: String)(etf: => EitherT[FutureUnlessShutdown, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[FutureUnlessShutdown, E, R]
- Definition Classes
- PerformUnlessClosing
- def performUnlessClosingF[A](name: String)(f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): FutureUnlessShutdown[A]
Performs the Future given by
f
unless a shutdown has been initiated.Performs the Future given by
f
unless a shutdown has been initiated. The future is lazy and not evaluated during shutdown. The shutdown will only begin afterf
completes, but other tasks may execute concurrently withf
, if started using this function, or one of the other variants (performUnlessClosing and performUnlessClosingEitherT). The tasks are assumed to take less than closingTimeout to complete.DO NOT CALL
this.close
as part off
, because it will result in a deadlock.- f
The task to perform
- returns
The future completes with com.digitalasset.canton.lifecycle.UnlessShutdown.AbortedDueToShutdown if a shutdown has been initiated. Otherwise the result of the task wrapped in com.digitalasset.canton.lifecycle.UnlessShutdown.Outcome.
- Definition Classes
- PerformUnlessClosing
- def performUnlessClosingUSF[A](name: String)(f: => FutureUnlessShutdown[A])(implicit ec: ExecutionContext, traceContext: TraceContext): FutureUnlessShutdown[A]
- Definition Classes
- PerformUnlessClosing
- val protocolVersion: ProtocolVersion
- val requestSigner: RequestSigner
- def runOnShutdown[T](task: RunOnShutdown)(implicit traceContext: TraceContext): Long
Same as runOnShutdown_ but returns a token that allows you to remove the task explicitly from being run using cancelShutdownTask
Same as runOnShutdown_ but returns a token that allows you to remove the task explicitly from being run using cancelShutdownTask
- Definition Classes
- OnShutdownRunner
- def runOnShutdown_[T](task: RunOnShutdown)(implicit traceContext: TraceContext): Unit
Register a task to run when shutdown is initiated.
Register a task to run when shutdown is initiated.
You can use this for example to register tasks that cancel long-running computations, whose termination you can then wait for in "closeAsync".
- Definition Classes
- OnShutdownRunner
- def runStateChanged(waitingState: Boolean = false): Unit
- Attributes
- protected
- Definition Classes
- OnShutdownRunner
- Annotations
- @VisibleForTesting()
- def sendAsync(batch: Batch[DefaultOpenEnvelope], sendType: SendType = SendType.Other, timestampOfSigningKey: Option[CantonTimestamp] = None, maxSequencingTime: CantonTimestamp = generateMaxSequencingTime, messageId: MessageId = generateMessageId, callback: SendCallback = SendCallback.empty)(implicit traceContext: TraceContext): EitherT[Future, SendAsyncClientError, Unit]
Sends a request to sequence a deliver event to the sequencer.
Sends a request to sequence a deliver event to the sequencer. If we fail to make the request to the sequencer and are certain that it was not received by the sequencer an error is returned. In this circumstance it is safe for the caller to retry the request without causing a duplicate request. A successful response however does not mean that the request will be successfully sequenced. Instead the caller must subscribe to the sequencer and can observe one of the following outcomes:
- A deliver event is sequenced with a messageId matching this send.
2. A deliver error is sequenced with a messageId matching this send.
3. The sequencing time progresses beyond the provided max-sequencing-time. The caller can assume that the send
will now never be sequenced.
Callers should be aware that a message-id can be reused once one of these outcomes is observed so cannot assume
that an event with a matching message-id at any point in the future matches their send. Use the
sendTracker
to aid tracking timeouts for events (if useful this could be enriched in the future to provide send completion callbacks alongside the existing timeout notifications). For convenience callers can provide a callback that the SendTracker will invoke when the outcome of the send is known. However this convenience comes with significant limitations that a caller must understand:
- the callback has no ability to be persisted so will be lost after a restart or recreation of the SequencerClient
- the callback is called by the send tracker while handling an event from a SequencerSubscription. If the callback returns an error this will be returned to the underlying subscription handler and shutdown the sequencer client. If handlers do not want to halt the sequencer subscription errors should be appropriately handled (particularly logged) and a successful value returned from the callback.
- If witnessing an event causes many prior sends to timeout there is no guaranteed order in which the callbacks of these sends will be notified.
- If replay is enabled, the callback will be called immediately with a fake
SendResult
. For more robust send result tracking callers should persist metadata about the send they will make and monitor the sequenced events when read, so actions can be taken even if in-memory state is lost.
- Definition Classes
- SequencerClientImpl → SequencerClientSend
- A deliver event is sequenced with a messageId matching this send.
2. A deliver error is sequenced with a messageId matching this send.
3. The sequencing time progresses beyond the provided max-sequencing-time. The caller can assume that the send
will now never be sequenced.
Callers should be aware that a message-id can be reused once one of these outcomes is observed so cannot assume
that an event with a matching message-id at any point in the future matches their send. Use the
- def sendAsyncUnauthenticated(batch: Batch[DefaultOpenEnvelope], sendType: SendType = SendType.Other, maxSequencingTime: CantonTimestamp = generateMaxSequencingTime, messageId: MessageId = generateMessageId, callback: SendCallback = SendCallback.empty)(implicit traceContext: TraceContext): EitherT[Future, SendAsyncClientError, Unit]
Does the same as sendAsync, except that this method is supposed to be used only by unauthenticated members for very specific operations that do not require authentication such as requesting that a participant's topology data gets accepted by the topology manager
Does the same as sendAsync, except that this method is supposed to be used only by unauthenticated members for very specific operations that do not require authentication such as requesting that a participant's topology data gets accepted by the topology manager
- Definition Classes
- SequencerClientImpl → SequencerClient
- def sendAsyncUnauthenticatedOrNot(batch: Batch[DefaultOpenEnvelope], sendType: SendType = SendType.Other, timestampOfSigningKey: Option[CantonTimestamp] = None, maxSequencingTime: CantonTimestamp = generateMaxSequencingTime, messageId: MessageId = generateMessageId, callback: SendCallback = SendCallback.empty)(implicit traceContext: TraceContext): EitherT[Future, SendAsyncClientError, Unit]
Sends a request to sequence a deliver event to the sequencer.
Sends a request to sequence a deliver event to the sequencer. This method merely dispatches to one of the other methods (
sendAsync
orsendAsyncUnauthenticated
) depending if member is Authenticated or Unauthenticated.- Definition Classes
- SequencerClientImpl → SequencerClient
- def snapshotIncomplete: Seq[String]
Returns the list of currently incomplete tasks.
Returns the list of currently incomplete tasks. Use only for inspection and debugging.
- Definition Classes
- HasFlushFuture
- def subscribeAfter(priorTimestamp: CantonTimestamp, cleanPreheadTsO: Option[CantonTimestamp], eventHandler: PossiblyIgnoredApplicationHandler[ClosedEnvelope], timeTracker: DomainTimeTracker, fetchCleanTimestamp: FetchCleanTimestamp)(implicit traceContext: TraceContext): Future[Unit]
Create a subscription for sequenced events for this member, starting after the last event in the com.digitalasset.canton.store.SequencedEventStore up to
priorTimestamp
.Create a subscription for sequenced events for this member, starting after the last event in the com.digitalasset.canton.store.SequencedEventStore up to
priorTimestamp
. A sequencer client can only have a single subscription - additional subscription attempts will throw an exception. When an event is received, we will check the pending sends and invoke the provided call-backs with the send result (which can be deliver or timeout) before invoking theeventHandler
.If the com.digitalasset.canton.store.SequencedEventStore contains events after
priorTimestamp
, the handler is first fed with these events before the subscription is established, starting at the last event found in the com.digitalasset.canton.store.SequencedEventStore.- priorTimestamp
The timestamp of the event prior to where the event processing starts. If scala.None$, the subscription starts at the com.digitalasset.canton.data.CounterCompanion.Genesis.
- cleanPreheadTsO
The timestamp of the clean prehead sequencer counter, if known.
- eventHandler
A function handling the events.
- timeTracker
Tracker for operations requiring the current domain time. Only updated with received events and not previously stored events.
- fetchCleanTimestamp
A function for retrieving the latest clean timestamp to use for periodic acknowledgements
- returns
The future completes after the subscription has been established or when an error occurs before that. In particular, synchronous processing of events from the com.digitalasset.canton.store.SequencedEventStore runs before the future completes.
- Definition Classes
- SequencerClientImpl → SequencerClient
- def subscribeAfterUnauthenticated(priorTimestamp: CantonTimestamp, eventHandler: PossiblyIgnoredApplicationHandler[ClosedEnvelope], timeTracker: DomainTimeTracker)(implicit traceContext: TraceContext): Future[Unit]
Does the same as subscribeAfter, except that this method is supposed to be used only by unauthenticated members
Does the same as subscribeAfter, except that this method is supposed to be used only by unauthenticated members
The method does not verify the signature of the server.
- Definition Classes
- SequencerClientImpl → SequencerClient
- def subscribeTracking(sequencerCounterTrackerStore: SequencerCounterTrackerStore, eventHandler: PossiblyIgnoredApplicationHandler[ClosedEnvelope], timeTracker: DomainTimeTracker, onCleanHandler: (Traced[SequencerCounterCursorPrehead]) => Unit = _ => ())(implicit traceContext: TraceContext): Future[Unit]
Create a subscription for sequenced events for this member, starting after the prehead in the
sequencerCounterTrackerStore
.Create a subscription for sequenced events for this member, starting after the prehead in the
sequencerCounterTrackerStore
.The
eventHandler
is monitored by com.digitalasset.canton.sequencing.handlers.CleanSequencerCounterTracker so that thesequencerCounterTrackerStore
advances the prehead when (a batch of) events has been successfully processed by theeventHandler
(synchronously and asynchronously).- Definition Classes
- SequencerClientImpl → SequencerClient
- See also
subscribe for the description of the
eventHandler
and thetimeTracker
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- val timeouts: ProcessingTimeout
- Definition Classes
- SequencerClientImpl → FlagCloseable
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- def waitForHandlerToComplete(): Unit
- def withNewTrace[A](description: String)(f: (TraceContext) => (SpanWrapper) => A)(implicit tracer: Tracer): A
- Attributes
- protected
- Definition Classes
- Spanning
- def withSpan[A](description: String)(f: (TraceContext) => (SpanWrapper) => A)(implicit traceContext: TraceContext, tracer: Tracer): A
- Attributes
- protected
- Definition Classes
- Spanning
- def withSpanFromGrpcContext[A](description: String)(f: (TraceContext) => (SpanWrapper) => A)(implicit tracer: Tracer): A
- Attributes
- protected
- Definition Classes
- Spanning