Packages

class AcsCommitmentProcessor extends AcsChangeListener with FlagCloseableAsync with NamedLogging

Computes, sends, receives and compares ACS commitments

In more detail:

  • The class computes the participant's ACS commitments (for each of the participant's "counter-participants", i.e., participants who host a stakeholder of some contract in participant's ACS). The commitments are computed at specified (sequencer) times that are configured by the domain and are uniform for all participants connected to the domain. We refer to them as "commitment ticks". The commitments must be computed "online", i.e., after the the state of the ACS at a commitment tick becomes known.
  • After the commitments for a tick are computed, they should be distributed to the counter-participants; but this is best-effort.
  • The class processes the ACS commitments from counter-participants (method processBatch):
  • it checks that the commitments are properly signed
  • it checks that they match the locally computed ACS commitments
  • The class must define crash recovery points, such that the class itself combined with startup procedures of the node jointly ensure that the participant doesn't neglect to send its ACS commitments or process the remote ones. We allow the participant to send the same commitments multiple times in case of a crash, and we do allow the participant to not send some commitments in some edge cases due to crashes.
  • Finally, the class supports pruning: it computes the safe timestamps for participant pruning, such that, after pruning, non-repudiation still holds for any contract in the ACS

The first four pieces of class functionality must be appropriately synchronized:

  • ACS commitments for a tick cannot be completely processed before the local commitment for that tick is computed. Note that the class cannot make many assumptions on the received commitments: the counter-participants can send them in any order, and they can either precede or lag behind the local commitment computations.
  • The recovery points must be chosen such that the participant computes its local commitments correctly, and never misses to compute a local commitment for every tick. Otherwise, the participant will start raising false alarms when remote commitments are received (either because it computes the wrong thing, or because it doesn't compute anything at all and thus doesn't expect to receive anything).

Additionally, the startup procedure must ensure that:

Finally, the class requires the reconciliation interval to be a multiple of 1 second.

The commitmentPeriodObserver is guaranteed to be called whenever a commitment is computed for a period. If publish is called multiple times for the same timestamp (once before a crash and once after the recovery), the observer may also be called twice for the same period.

Annotations
@SuppressWarnings()
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. AcsCommitmentProcessor
  2. NamedLogging
  3. FlagCloseableAsync
  4. FlagCloseable
  5. AutoCloseable
  6. AcsChangeListener
  7. AnyRef
  8. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new AcsCommitmentProcessor(domainId: DomainId, participantId: ParticipantId, sequencerClient: SequencerClient, domainCrypto: SyncCryptoClient, reconciliationInterval: PositiveSeconds, store: AcsCommitmentStore, commitmentPeriodObserver: (ExecutionContext, TraceContext) => Future[Unit], killSwitch: => Unit, metrics: PruningMetrics, timeouts: ProcessingTimeout, loggerFactory: NamedLoggerFactory)(implicit ec: ExecutionContext)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  6. 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 → AutoCloseable
    Annotations
    @SuppressWarnings()
  7. 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
    AcsCommitmentProcessorFlagCloseableAsync
  8. def closingTimeout: FiniteDuration
    Attributes
    protected
    Definition Classes
    AcsCommitmentProcessorFlagCloseable
  9. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  10. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  11. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  12. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  13. def initializeTicksOnStartup(timestamps: List[CantonTimestamp])(implicit traceContext: TraceContext): Unit
  14. def internalPerformUnlessClosingF[A](f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): UnlessShutdown[Future[A]]
    Attributes
    protected
    Definition Classes
    FlagCloseable
  15. def isClosing: Boolean

    Check whether we're closing.

    Check whether we're closing. Susceptible to race conditions; unless you're using using this as a flag to the retry lib or you really know what you're doing, prefer performUnlessClosing and friends.

    Definition Classes
    FlagCloseable
  16. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  17. 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
    FlagCloseable
  18. def logger: TracedLogger
    Attributes
    protected
    Definition Classes
    NamedLogging
  19. val loggerFactory: NamedLoggerFactory
    Attributes
    protected
    Definition Classes
    AcsCommitmentProcessorNamedLogging
  20. implicit def loggingContext(implicit traceContext: TraceContext): ErrorLoggingContext
    Attributes
    protected
    Definition Classes
    NamedLogging
  21. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  22. def noTracingLogger: Logger
    Attributes
    protected
    Definition Classes
    NamedLogging
  23. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  24. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  25. final def onClosed(): Unit
    Definition Classes
    FlagCloseableAsyncFlagCloseable
  26. def performUnlessClosing[A](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 after f completes, but other tasks may execute concurrently with f, 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.

    f

    The task to perform

    returns

    scala.None$ if a shutdown has been initiated. Otherwise the result of the task.

    Definition Classes
    FlagCloseable
  27. def performUnlessClosingEitherT[E, R](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. Both etf 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 after etf completes, but other tasks may execute concurrently with etf, 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.

    etf

    The task to perform

    Definition Classes
    FlagCloseable
  28. def performUnlessClosingEitherTF[E, R](onClosing: => E)(etf: => EitherT[Future, E, Future[R]])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[Future, E, Future[R]]
    Definition Classes
    FlagCloseable
  29. def performUnlessClosingF[A](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 after f completes, but other tasks may execute concurrently with f, 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.

    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
    FlagCloseable
  30. def processBatch(timestamp: CantonTimestamp, batch: Traced[List[OpenEnvelope[SignedProtocolMessage[AcsCommitment]]]]): FutureUnlessShutdown[Unit]
  31. def processBatchInternal(timestamp: CantonTimestamp, batch: List[OpenEnvelope[SignedProtocolMessage[AcsCommitment]]])(implicit traceContext: TraceContext): FutureUnlessShutdown[Unit]

    Process incoming commitments.

    Process incoming commitments.

    The caller(s) must jointly ensure that all incoming commitments are passed to this method, in their order of arrival. Upon startup, the method must be called on all incoming commitments whose processing hasn't finished yet, including those whose processing has been aborted due to shutdown.

  32. def publish(initialToc: RecordTime, acsChange: AcsChange)(implicit traceContext: TraceContext): Unit

    ACS change notification.

    ACS change notification. Any response logic needs to happen in the background. The ACS change set may be empty, (e.g., in case of time proofs).

    acsChange

    active contract set change descriptor

    Definition Classes
    AcsCommitmentProcessorAcsChangeListener
  33. def runOnShutdown[T](task: RunOnShutdown)(implicit traceContext: TraceContext): Unit

    Register a task that will run onClose after all "performUnlessShutdown" tasks have finished

    Register a task that will run onClose after all "performUnlessShutdown" tasks have finished

    Definition Classes
    FlagCloseable
  34. def runStateChanged(waitingState: Boolean = false): Unit
    Attributes
    protected
    Definition Classes
    FlagCloseable
    Annotations
    @VisibleForTesting()
  35. val runningCommitments: Future[RunningCommitments]
  36. def scheduleTopologyTick(effectiveTime: CantonTimestamp): Unit
  37. val sequencerClient: SequencerClient
  38. def sleepMillis: Long
    Attributes
    protected
    Definition Classes
    FlagCloseable
  39. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  40. val timeouts: ProcessingTimeout
    Attributes
    protected
    Definition Classes
    AcsCommitmentProcessorFlagCloseable
  41. def toString(): String
    Definition Classes
    AnyRef → Any
  42. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  43. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  44. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from NamedLogging

Inherited from FlagCloseableAsync

Inherited from FlagCloseable

Inherited from AutoCloseable

Inherited from AcsChangeListener

Inherited from AnyRef

Inherited from Any

Ungrouped