trait SequencerClient extends SequencerClientSend with FlagCloseable
- Alphabetic
- By Inheritance
- SequencerClient
- FlagCloseable
- PerformUnlessClosing
- OnShutdownRunner
- AutoCloseable
- SequencerClientSend
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def acknowledgeSigned(timestamp: CantonTimestamp)(implicit traceContext: TraceContext): EitherT[Future, String, Unit]
- abstract def changeTransport(sequencerTransports: SequencerTransports)(implicit traceContext: TraceContext): Future[Unit]
- abstract 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.
- abstract 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.
- Annotations
- @VisibleForTesting()
- abstract 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
- SequencerClientSend
- abstract def healthComponent: CloseableHealthComponent
- abstract def initialCounterLowerBound: SequencerCounter
The sequencer counter at which the first subscription starts
The sequencer counter at which the first subscription starts
- Attributes
- protected
- abstract def logger: TracedLogger
- Attributes
- protected
- Definition Classes
- OnShutdownRunner
- abstract 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
- 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
- abstract 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
- abstract 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. - abstract 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 initialCounterLowerBound.
- 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.
- abstract 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
- abstract 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).- See also
subscribe for the description of the
eventHandler
and thetimeTracker
- abstract def timeouts: ProcessingTimeout
- Attributes
- protected
- Definition Classes
- FlagCloseable
Concrete 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
- 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 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 closingTimeout: FiniteDuration
- Attributes
- protected
- Definition Classes
- FlagCloseable → PerformUnlessClosing
- def containsShutdownTask(token: Long): Boolean
- Definition Classes
- OnShutdownRunner
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- 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
- SequencerClientSend
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- 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 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
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- 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
- def onClosed(): Unit
- Attributes
- protected
- Definition Classes
- 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
- 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()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- 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])