trait SequencerStore extends NamedLogging with AutoCloseable

Persistence for the Sequencer. Writers are expected to create a SequencerWriterStore which may delegate to this underlying store through an appropriately managed storage instance.

Linear Supertypes
AutoCloseable, NamedLogging, AnyRef, Any
Known Subclasses
DbSequencerStore, InMemorySequencerStore
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SequencerStore
  2. AutoCloseable
  3. NamedLogging
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Abstract Value Members

  1. abstract def acknowledge(member: SequencerMemberId, timestamp: CantonTimestamp)(implicit traceContext: TraceContext): Future[Unit]

    Write an acknowledgement that member has processed earlier timestamps.

    Write an acknowledgement that member has processed earlier timestamps. Only the latest timestamp needs to be stored. Earlier timestamps can be overwritten. Acknowledgements of earlier timestamps should be ignored.

  2. abstract def adjustPruningTimestampForCounterCheckpoints(timestamp: CantonTimestamp, disabledMembers: Seq[SequencerMemberId])(implicit traceContext: TraceContext): Future[Option[CantonTimestamp]]

    This takes the timestamp that is considered safe to prune from and walks it back to ensure that we have retained enough events to be able to start subscriptions from the counter checkpoint immediately preceding the timestamp.

    This takes the timestamp that is considered safe to prune from and walks it back to ensure that we have retained enough events to be able to start subscriptions from the counter checkpoint immediately preceding the timestamp.

    Attributes
    protected[store]
  3. abstract def close(): Unit
    Definition Classes
    AutoCloseable
    Annotations
    @throws(classOf[java.lang.Exception])
  4. abstract def countRecords(implicit traceContext: TraceContext): Future[SequencerStoreRecordCounts]

    Count records currently stored by the sequencer.

    Count records currently stored by the sequencer. Used for pruning tests.

    Attributes
    protected[store]
    Annotations
    @VisibleForTesting()
  5. abstract def deleteEventsPastWatermark(instanceIndex: Int)(implicit traceContext: TraceContext): Future[Unit]

    Delete all events that are ahead of the watermark of this sequencer.

    Delete all events that are ahead of the watermark of this sequencer. These events will not have been read and should be removed before returning the sequencer online. Should not be called alongside updating the watermark for this sequencer and only while the sequencer is offline.

  6. abstract def disableMember(member: SequencerMemberId)(implicit traceContext: TraceContext): Future[Unit]

    Prevents member from sending and reading from the sequencer, and allows unread data for this member to be pruned.

    Prevents member from sending and reading from the sequencer, and allows unread data for this member to be pruned. It however won't stop any sends addressed to this member.

  7. implicit abstract val executionContext: ExecutionContext
    Attributes
    protected
  8. abstract def fetchClosestCheckpointBefore(memberId: SequencerMemberId, counter: SequencerCounter)(implicit traceContext: TraceContext): Future[Option[CounterCheckpoint]]

    Fetch a checkpoint with a counter value less than the provided counter.

  9. abstract def fetchLowerBound()(implicit traceContext: TraceContext): Future[Option[CantonTimestamp]]

    Fetch the lower bound of events that can be read.

    Fetch the lower bound of events that can be read. Returns None if all events can be read.

  10. abstract def fetchOnlineInstances(implicit traceContext: TraceContext): Future[SortedSet[Int]]

    Fetch the indexes of all sequencers that are currently online

  11. abstract def fetchWatermark(instanceIndex: Int)(implicit traceContext: TraceContext): Future[Option[Watermark]]

    Read the watermark for this sequencer and its online/offline status.

    Read the watermark for this sequencer and its online/offline status. Currently only used for testing.

  12. abstract def goOffline(instanceIndex: Int)(implicit traceContext: TraceContext): Future[Unit]

    Flag that we're going offline (likely due to a shutdown)

  13. abstract def goOnline(instanceIndex: Int, now: CantonTimestamp)(implicit traceContext: TraceContext): Future[CantonTimestamp]

    Mark the sequencer as online and return a timestamp for when this sequencer can start safely producing events.

    Mark the sequencer as online and return a timestamp for when this sequencer can start safely producing events.

    now

    Now according to this sequencer's clock which will be used if it is ahead of the lowest available timestamp from other sequencers.

  14. abstract def isEnabled(member: SequencerMemberId)(implicit traceContext: TraceContext): EitherT[Future, MemberDisabledError.type, Unit]

    Check whether the member is enabled.

    Check whether the member is enabled. Currently used when receiving a request for reading.

  15. abstract def latestAcknowledgements()(implicit traceContext: TraceContext): Future[Map[SequencerMemberId, CantonTimestamp]]

    Return the latest acknowledgements for all members

    Return the latest acknowledgements for all members

    Attributes
    protected[store]
    Annotations
    @VisibleForTesting()
  16. abstract def loggerFactory: NamedLoggerFactory
    Attributes
    protected
    Definition Classes
    NamedLogging
  17. abstract def lookupMemberInternal(member: Member)(implicit traceContext: TraceContext): Future[Option[RegisteredMember]]

    Lookup member directly without caching.

    Lookup member directly without caching.

    Attributes
    protected
  18. abstract def markLaggingSequencersOffline(cutoffTime: CantonTimestamp)(implicit traceContext: TraceContext): Future[Unit]

    Flag any sequencers that have a last updated watermark on or before the given cutoffTime as offline.

  19. abstract def pruneCheckpoints(timestamp: CantonTimestamp)(implicit traceContext: TraceContext): Future[Int]

    Prune counter checkpoints for the given member before the given timestamp.

    Prune counter checkpoints for the given member before the given timestamp.

    returns

    A lower bound on the number of checkpoints removed.

    Attributes
    protected[store]
  20. abstract def pruneEvents(timestamp: CantonTimestamp)(implicit traceContext: TraceContext): Future[Int]

    Prune events before the given timestamp

    Prune events before the given timestamp

    returns

    a best efforts count of how many events were removed. this value can be less than the number of events actually removed if technical issues prevent a full count from being returned (e.g. with a database we may retry a delete after a connectivity issue and find that all events were successfully removed and have 0 rows removed returned).

    Attributes
    protected[store]
  21. abstract def prunePayloads(timestamp: CantonTimestamp)(implicit traceContext: TraceContext): Future[Int]

    Prune payloads before the given timestamp

    Prune payloads before the given timestamp

    returns

    a best efforts count of how many events were removed. this value can be less than the number of payloads actually removed if technical issues prevent a full count from being returned.

    Attributes
    protected[store]
  22. abstract def readEvents(memberId: SequencerMemberId, fromTimestampO: Option[CantonTimestamp], limit: Int)(implicit traceContext: TraceContext): Future[Seq[Sequenced[Payload]]]

    Read all events of which a member is a recipient from the provided timestamp but no greater than the earliest watermark.

  23. abstract def registerMember(member: Member, timestamp: CantonTimestamp)(implicit traceContext: TraceContext): Future[SequencerMemberId]

    Register the provided member.

    Register the provided member. Should be idempotent if member is already registered and return the existing id.

  24. abstract def saveCounterCheckpoint(memberId: SequencerMemberId, counter: SequencerCounter, ts: CantonTimestamp)(implicit traceContext: TraceContext): EitherT[Future, SaveCounterCheckpointError, Unit]

    Save a checkpoint that as of a certain timestamp the member has this counter value.

    Save a checkpoint that as of a certain timestamp the member has this counter value. Any future subscriptions can then use this as a starting point for serving their event stream rather than starting from 0.

  25. abstract def saveEvents(instanceIndex: Int, events: NonEmpty[Seq[Sequenced[PayloadId]]])(implicit traceContext: TraceContext): Future[Unit]

    Save a series of events to the store.

    Save a series of events to the store. Callers should determine batch size. No batching is done within the store. Callers MUST ensure that event-ids are unique as no errors will be returned if a duplicate is present (for the sequencer writer see sequencer.PartitionedTimestampGenerator for use with their instance index).

  26. abstract def saveLowerBound(ts: CantonTimestamp)(implicit traceContext: TraceContext): EitherT[Future, SaveLowerBoundError, Unit]

    Save an updated lower bound of events that can be read.

    Save an updated lower bound of events that can be read. Must be equal or greater than any prior set lower bound.

    Exceptions thrown

    java.lang.IllegalArgumentException if timestamp is lower than existing lower bound

  27. abstract def savePayloads(payloads: NonEmpty[Seq[Payload]], instanceDiscriminator: UUID)(implicit traceContext: TraceContext): EitherT[Future, SavePayloadsError, Unit]

    Save a series of payloads to the store.

    Save a series of payloads to the store. Is up to the caller to determine a reasonable batch size and no batching is done within the store.

    payloads

    the payloads to save

    instanceDiscriminator

    a unique ephemeral value to ensure that no other sequencer instances are writing conflicting payloads without having to check the payload body

  28. abstract def saveWatermark(instanceIndex: Int, ts: CantonTimestamp)(implicit traceContext: TraceContext): EitherT[Future, SaveWatermarkError, Unit]

    Write the watermark that we promise not to write anything earlier than.

    Write the watermark that we promise not to write anything earlier than. Does not indicate that there is an event written by this sequencer for this timestamp as there may be no activity at the sequencer, but updating the timestamp allows the sequencer to indicate that it's still alive. Return an error if we find our sequencer is offline.

  29. abstract def status(now: CantonTimestamp)(implicit traceContext: TraceContext): Future[SequencerPruningStatus]

    Build a status object representing the current state of the sequencer.

  30. abstract def validateCommitMode(configuredCommitMode: CommitMode)(implicit traceContext: TraceContext): EitherT[Future, String, Unit]

    Validate that the commit mode of a session is inline with the configured expected commit mode.

    Validate that the commit mode of a session is inline with the configured expected commit mode. Return a human readable message about the mismatch in commit modes if not.

Concrete 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 eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  8. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  9. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  10. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  11. def logger: TracedLogger
    Attributes
    protected
    Definition Classes
    NamedLogging
  12. implicit def loggingContext(implicit traceContext: TraceContext): ErrorLoggingContext
    Attributes
    protected
    Definition Classes
    NamedLogging
  13. final def lookupMember(member: Member)(implicit traceContext: TraceContext): Future[Option[RegisteredMember]]

    Lookup an existing member id for the given member.

    Lookup an existing member id for the given member. Will return a cached value if available. Return scala.None if no id exists.

  14. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  15. def noTracingLogger: Logger
    Attributes
    protected
    Definition Classes
    NamedLogging
  16. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  17. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  18. def prune(requestedTimestamp: CantonTimestamp, status: SequencerPruningStatus, payloadToEventMargin: NonNegativeFiniteDuration)(implicit traceContext: TraceContext): EitherT[Future, PruningError, String]

    Prune as much data as safely possible from before the given timestamp.

    Prune as much data as safely possible from before the given timestamp. Return a human readable report on what has been removed.

    requestedTimestamp

    the timestamp that we would like to prune from (see docs on using the pruning status and disabling members for picking this value)

    status

    the pruning status that should be used for determining a safe to prune time for validation

    payloadToEventMargin

    the maximum time margin between payloads and events. once we have a safe to prune timestamp we simply prune all payloads at safeTimestamp - margin to ensure no payloads are removed where events will remain. typically sourced from SequencerWriterConfig.payloadToEventMargin.

  19. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  20. def toString(): String
    Definition Classes
    AnyRef → Any
  21. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  22. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  23. 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 AutoCloseable

Inherited from NamedLogging

Inherited from AnyRef

Inherited from Any

Ungrouped