com.digitalasset.canton.participant.store.memory
InMemoryActiveContractStore
Companion object InMemoryActiveContractStore
class InMemoryActiveContractStore extends ActiveContractStore with NamedLogging with InMemoryPrunableByTime
Implements an ActiveContractStore! in memory.
- Alphabetic
- By Inheritance
- InMemoryActiveContractStore
- InMemoryPrunableByTime
- NamedLogging
- ActiveContractStore
- ConflictDetectionStore
- Purgeable
- PrunableByTime
- ActiveContractSnapshot
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new InMemoryActiveContractStore(indexedStringStore: IndexedStringStore, loggerFactory: NamedLoggerFactory)(implicit ec: ExecutionContext)
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 activenessOf(contracts: Seq[LfContractId])(implicit traceContext: TraceContext): FutureUnlessShutdown[SortedMap[LfContractId, Seq[(CantonTimestamp, ActivenessChangeDetail)]]]
Returns the states of contracts at the given timestamp.
Returns the states of contracts at the given timestamp.
- contracts
The contracts whose state we return. If empty, we return an empty map. Omits from the response contracts that do not have an activeness state.
- returns
A map from contracts to the timestamp when the state changed, and the activeness change detail. The map is sorted by cats.kernel.Order
[com.digitalasset.canton.protocol.LfContractId].
- Definition Classes
- InMemoryActiveContractStore → ActiveContractSnapshot
- def advancePruningTimestamp(phase: PruningPhase, timestamp: CantonTimestamp)(implicit traceContext: TraceContext): FutureUnlessShutdown[Unit]
- Attributes
- protected[canton]
- Definition Classes
- InMemoryPrunableByTime → PrunableByTime
- def archiveContract(cid: LfContractId, toc: TimeOfChange)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Shorthand for
archiveContracts(Seq(cid), toc)Shorthand for
archiveContracts(Seq(cid), toc)- Definition Classes
- ActiveContractStore
- def archiveContracts(contractIds: Seq[LfContractId], toc: TimeOfChange)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Marks the given contracts as archived from
toc's timestamp (inclusive) onwards.Marks the given contracts as archived from
toc's timestamp (inclusive) onwards.- contractIds
The contract IDs of the contracts to be archived Note: this method should not take as parameter the reassignment counter for the archived contract IDs, because one cannot know the correct reassignment counter for an archival at request finalization time, which is when this method is called. The com.digitalasset.canton.participant.event.RecordOrderPublisher determines the correct reassignment counter for an archival only when all requests preceding the archival (i.e., with a lower request counter than the archival transaction) were processed. Therefore, we determine the reassignment counter for archivals in the com.digitalasset.canton.participant.event.RecordOrderPublisher, when the record order publisher triggers an acs change event.
- toc
The time of change consisting of:
- The request counter of the confirmation request that archives the contracts.
- The timestamp on the confirmation request that archives the contracts.
- returns
The future completes when all contract states have been updated. The following irregularities are reported for each contract:
- ActiveContractStore.DoubleContractArchival if the contract is archived a second time.
- ActiveContractStore.SimultaneousDeactivation if the contract is unassigned at the same time or has been archived by a different request at the same time.
- ActiveContractStore.ChangeAfterArchival for every change that occurs after the archival timestamp. This is reported only if no ActiveContractStore.DoubleContractArchival is reported.
- ActiveContractStore.ChangeBeforeCreation if this archival is earlier than the latest creation of the contract.
- Definition Classes
- ActiveContractStore
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def assignContract(contractId: LfContractId, toc: TimeOfChange, sourceSynchronizer: Source[SynchronizerId], reassignmentCounter: ReassignmentCounter)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
- Definition Classes
- ActiveContractStore
- def assignContracts(assignments: Seq[(LfContractId, Source[SynchronizerId], ReassignmentCounter, TimeOfChange)])(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Marks the given contracts as assigned from
toc's timestamp (inclusive) onwards.Marks the given contracts as assigned from
toc's timestamp (inclusive) onwards.- assignments
The contract IDs to assign, each with its source synchronizer, reassignment counter and time of change.
- returns
The future completes when the contract states have been updated. The following irregularities are reported:
- ActiveContractStore.SimultaneousActivation if an assignment from another synchronizer or a creation has been added with the same timestamp.
- ActiveContractStore.ChangeAfterArchival if this timestamp is after the earliest archival of the contract.
- ActiveContractStore.ChangeBeforeCreation if this timestamp is before the latest creation of the contract.
- ActiveContractStore.ReassignmentCounterShouldIncrease if the reassignment counter does not increase monotonically.
- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore
- def batchingParameters: Option[PrunableByTimeParameters]
Parameters to control prune batching
Parameters to control prune batching
If defined, then the pruning window will be computed such that it targets the ideal target batch size in order to optimize the load on the database.
This is currently used with the journal stores. Normal pruning of other stores already does batching on its own.
- Attributes
- protected
- Definition Classes
- PrunableByTime
- def changesBetween(fromExclusive: TimeOfChange, toInclusive: TimeOfChange)(implicit traceContext: TraceContext): FutureUnlessShutdown[LazyList[(TimeOfChange, ActiveContractIdsChange)]]
Returns all changes to the active contract set between the two timestamps (exclusive lower bound timestamp, inclusive upper bound timestamp) in the order of their changes.
Returns all changes to the active contract set between the two timestamps (exclusive lower bound timestamp, inclusive upper bound timestamp) in the order of their changes. The provided lower bound must not be larger than the upper bound.
- fromExclusive
The lower bound for the changes. Must not be larger than the upper bound.
- toInclusive
The upper bound for the changes. Must not be smaller than the lower bound.
- Definition Classes
- InMemoryActiveContractStore → ActiveContractSnapshot
- Exceptions thrown
java.lang.IllegalArgumentExceptionIf the intervals are in the wrong order.
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()
- def contractCount(timestamp: CantonTimestamp)(implicit traceContext: TraceContext): FutureUnlessShutdown[Int]
Returns the total number of contracts whose states are stored at the given timestamp.
Returns the total number of contracts whose states are stored at the given timestamp.
To get a consistent snapshot, the caller must ensure that the timestamp specifies a time that is not in the future, i.e., not after the timestamp of the clean cursor in the com.digitalasset.canton.participant.protocol.RequestJournal Note that the result may change between two invocations if prune is called in the meantime.
- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore
- def contractSnapshot(contractIds: Set[LfContractId], timeOfChange: TimeOfChange)(implicit traceContext: TraceContext): FutureUnlessShutdown[Map[LfContractId, TimeOfChange]]
Returns a map to the time of change when the contract became active for the last time before or at the given time of change.
Returns a map to the time of change when the contract became active for the last time before or at the given time of change. Omits contracts that not active right after the given time of change.
- timeOfChange
The time of change at which the activeness of the contracts shall be determined. Must be before the timestamp that corresponds to the head cursor in the com.digitalasset.canton.participant.protocol.RequestJournal for the state com.digitalasset.canton.participant.protocol.RequestJournal.RequestState.Clean. If this precondition is violated, the returned snapshot may be inconsistent, i.e., it may omit some contracts that were ActiveContractStore.Active at the given time and it may include contracts that were actually ActiveContractStore.Archived or ActiveContractStore.ReassignedAway.
- Definition Classes
- InMemoryActiveContractStore → ActiveContractSnapshot
- def contractsReassignmentCounterSnapshotBefore(contractIds: Set[LfContractId], timestampExclusive: CantonTimestamp)(implicit traceContext: TraceContext): FutureUnlessShutdown[Map[LfContractId, ReassignmentCounter]]
Returns a map to the latest reassignment counter of the contracts before the given timestamp.
Returns a map to the latest reassignment counter of the contracts before the given timestamp. Fails if not all given contract ids are active in the ACS, or if the ACS has not defined their latest reassignment counter.
- Definition Classes
- InMemoryActiveContractStore → ActiveContractSnapshot
- Exceptions thrown
java.lang.IllegalArgumentExceptionif not all given contract ids are active in the ACS, if the ACS does not contain the latest reassignment counter for each given contract id.
- def deleteSince(criterion: TimeOfChange)(implicit traceContext: TraceContext): FutureUnlessShutdown[Unit]
Deletes all activeness changes from requests whose time of change is at least the given one.
Deletes all activeness changes from requests whose time of change is at least the given one. This method must not be called concurrently with creating, archiving, or reassigning contracts.
Therefore, this method need not be linearizable w.r.t. creating, archiving, or reassigning contracts. For example, if a request at
toc1creates a contractcand another request attoc2archives it while deleteSince is running for sometoc <= toc1, toc2, then there are no guarantees which of the effects of the requests remain. For example,ccould end up being nonexistent, active, or archived but never created, even if the writes for the requests are successful.- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore
- def doPrune(beforeAndIncluding: CantonTimestamp, lastPruning: Option[CantonTimestamp])(implicit traceContext: TraceContext): FutureUnlessShutdown[Int]
Deletes all entries about archived contracts whose status hasn't changed after the timestamp.
Deletes all entries about archived contracts whose status hasn't changed after the timestamp.
The caller must ensure that the given timestamp is at most the one of the clean cursor in the com.digitalasset.canton.participant.protocol.RequestJournal
- returns
the approximate number of pruned rows, used to adjust the pruning windows to reach optimal batch sizes
- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore → PrunableByTime
- implicit val ec: ExecutionContext
- Definition Classes
- InMemoryActiveContractStore → PrunableByTime
- 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 fetchStates(contractIds: Iterable[LfContractId])(implicit traceContext: TraceContext): FutureUnlessShutdown[Map[LfContractId, ContractState]]
Returns the latest com.digitalasset.canton.participant.store.ActiveContractStore.Status for the given contract IDs along with its com.digitalasset.canton.participant.util.TimeOfChange.
Returns the latest com.digitalasset.canton.participant.store.ActiveContractStore.Status for the given contract IDs along with its com.digitalasset.canton.participant.util.TimeOfChange.
This method is used by the protocol processors for conflict detection. In-flight transactions may have changesets not yet written to the ACS datastore. Since only the
ConflictDetectortracks in-flight changesets, this method cannot be used as a source of valid data to other components.If a contract is created or assigned and archived or unassigned at the same com.digitalasset.canton.participant.util.TimeOfChange, the contract is ActiveContractStore.Archived or ActiveContractStore.ReassignedAway. A contract cannot be archived and unassigned at the same timestamp.
- returns
The map from contracts in
contractIdsin the store to their latest state. Nonexistent contracts are excluded from the map.
- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore → ConflictDetectionStore
- See also
ActiveContractSnapshot!.snapshot
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @IntrinsicCandidate() @native()
- def getSynchronizerIndices(synchronizers: Seq[SynchronizerId]): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Map[SynchronizerId, IndexedSynchronizer]]
- Attributes
- protected
- Definition Classes
- ActiveContractStore
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @IntrinsicCandidate() @native()
- val indexedStringStore: IndexedStringStore
- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def kind: String
- Attributes
- protected
- Definition Classes
- ActiveContractStore → PrunableByTime
- def logger: TracedLogger
- Attributes
- protected
- Definition Classes
- NamedLogging
- val loggerFactory: NamedLoggerFactory
- Definition Classes
- InMemoryActiveContractStore → NamedLogging
- def markContractAdded(contract: (LfContractId, ReassignmentCounter, TimeOfChange))(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Shorthand for
markContractAdded(Seq(contract), toc)Shorthand for
markContractAdded(Seq(contract), toc)- Definition Classes
- ActiveContractStore
- def markContractCreated(contract: (LfContractId, ReassignmentCounter), toc: TimeOfChange)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Shorthand for
markContractsCreated(Seq(contract), toc)Shorthand for
markContractsCreated(Seq(contract), toc)- Definition Classes
- ActiveContractStore
- def markContractsAdded(contracts: Seq[(LfContractId, ReassignmentCounter, TimeOfChange)])(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Marks the given contracts as active from
timestamp(inclusive) onwards.Marks the given contracts as active from
timestamp(inclusive) onwards.Unlike creation, add can be done several times in the life of a contract. It is intended to be used for ACS import and purges (e.g. repair service and party replication).
- Definition Classes
- ActiveContractStore
- def markContractsCreated(contracts: Seq[(LfContractId, ReassignmentCounter)], toc: TimeOfChange)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Marks the given contracts as active from
timestamp(inclusive) onwards.Marks the given contracts as active from
timestamp(inclusive) onwards.- contracts
The contracts represented as a tuple of contract id and reassignment counter
- toc
The time of change consisting of:
- The request counter of the confirmation request that created the contracts
- The timestamp of the confirmation request that created the contracts.
- returns
The future completes when all contract states have been updated. The following irregularities are reported for each contract:
- ActiveContractStore.DoubleContractCreation if the contract is created a second time.
- ActiveContractStore.SimultaneousActivation if the contract is assigned at the same time or has been created by a different request at the same time.
- ActiveContractStore.ChangeBeforeCreation for every change that occurs before the creation timestamp. This is reported only if no ActiveContractStore.DoubleContractCreation is reported.
- ActiveContractStore.ChangeAfterArchival if this creation is later than the earliest archival of the contract.
- Definition Classes
- ActiveContractStore
- def markContractsCreatedOrAdded(contracts: Seq[(LfContractId, ReassignmentCounter, TimeOfChange)], isCreation: Boolean)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore
- 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
- @IntrinsicCandidate() @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @IntrinsicCandidate() @native()
- def packageUsage(pkg: PackageId, contractStore: ContractStore)(implicit traceContext: TraceContext): FutureUnlessShutdown[Option[LfContractId]]
Returns Some(contractId) if an active contract belonging to package
pkgexists, otherwise returns None.Returns Some(contractId) if an active contract belonging to package
pkgexists, otherwise returns None. The returned contractId may be any active contract from packagepkg. The most recent contract state is used.- Definition Classes
- InMemoryActiveContractStore → ActiveContractSnapshot
- final def prune(limit: CantonTimestamp)(implicit errorLoggingContext: ErrorLoggingContext, closeContext: CloseContext): FutureUnlessShutdown[Unit]
Prune all unnecessary data relating to events before the given timestamp.
Prune all unnecessary data relating to events before the given timestamp.
The meaning of "unnecessary", and whether the limit is inclusive or exclusive both depend on the particular store. The store must implement the actual pruning logic in the doPrune method.
- Definition Classes
- PrunableByTime
- def pruningStatus(implicit traceContext: TraceContext): FutureUnlessShutdown[Option[PruningStatus]]
Returns the latest timestamp at which pruning was started or completed.
Returns the latest timestamp at which pruning was started or completed. For com.digitalasset.canton.pruning.PruningPhase.Started, it is guaranteed that no pruning has been run on the store after the returned timestamp. For com.digitalasset.canton.pruning.PruningPhase.Completed, it is guaranteed that the store is pruned at least up to the returned timestamp (inclusive). That is, another pruning with the returned timestamp (or earlier) has no effect on the store. Returns scala.None$ if no pruning has ever been started on the store.
- Definition Classes
- InMemoryPrunableByTime → PrunableByTime
- val pruningStatusF: AtomicReference[Option[PruningStatus]]
- Attributes
- protected[this]
- Definition Classes
- InMemoryPrunableByTime
- def purge()(implicit traceContext: TraceContext): FutureUnlessShutdown[Unit]
Purges all data from the store.
Purges all data from the store. This MUST ONLY be invoked when none of the data is needed anymore for example on synchronizer migration once all the data has been reassigned to the new synchronizer.
- Definition Classes
- InMemoryActiveContractStore → Purgeable
- def purgeContract(cid: LfContractId, toc: TimeOfChange)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Shorthand for
purgeContracts(Seq(cid), toc)Shorthand for
purgeContracts(Seq(cid), toc)- Definition Classes
- ActiveContractStore
- def purgeContracts(contractIds: Seq[(LfContractId, TimeOfChange)])(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Marks the given contracts as inactive from
timestamp(inclusive) onwards.Marks the given contracts as inactive from
timestamp(inclusive) onwards.Unlike archival, purge can be done several times in the life of a contract. It is intended to be used by the repair service.
- Definition Classes
- ActiveContractStore
- def purgeOrArchiveContracts(contracts: Seq[(LfContractId, TimeOfChange)], isArchival: Boolean)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Depending on the
isArchival, will archive (effect of a Daml transaction) or purge (repair service)Depending on the
isArchival, will archive (effect of a Daml transaction) or purge (repair service)- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore
- def snapshot(timeOfChange: TimeOfChange)(implicit traceContext: TraceContext): FutureUnlessShutdown[SortedMap[LfContractId, (TimeOfChange, ReassignmentCounter)]]
Returns all contracts that were active right after the given time of change, and when the contract became active for the last time before or at the given time of change.
Returns all contracts that were active right after the given time of change, and when the contract became active for the last time before or at the given time of change.
- timeOfChange
The time of change at which the snapshot shall be taken. Must be before the timestamp that corresponds to the head cursor in the com.digitalasset.canton.participant.protocol.RequestJournal for the state com.digitalasset.canton.participant.protocol.RequestJournal.RequestState.Clean. If this precondition is violated, the returned snapshot may be inconsistent, i.e., it may omit some contracts that were ActiveContractStore.Active at the given time and it may include contracts that were actually ActiveContractStore.Archived or ActiveContractStore.ReassignedAway.
- returns
A map from contracts to the latest timestamp (no later than the given
timeOfChange) when they became active again. It contains exactly those contracts that were active right after the given time of change. If a contract is created or assigned and archived or unassigned at the same time of change, it does not show up in any snapshot. The map is sorted by cats.kernel.Order[com.digitalasset.canton.protocol.LfContractId].
- Definition Classes
- InMemoryActiveContractStore → ActiveContractSnapshot
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def synchronizerIdFromIdx(idx: Int)(implicit ec: ExecutionContext, loggingContext: ErrorLoggingContext): FutureUnlessShutdown[SynchronizerId]
- Attributes
- protected
- Definition Classes
- ActiveContractStore
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unassignContracts(unassignments: Seq[(LfContractId, Target[SynchronizerId], ReassignmentCounter, TimeOfChange)])(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
Marks the given contracts as ActiveContractStore.ReassignedAway from
toc's timestamp (inclusive) onwards.Marks the given contracts as ActiveContractStore.ReassignedAway from
toc's timestamp (inclusive) onwards.- unassignments
The contract IDs to unassign, each with its target synchronizer, reassignment counter and time of change.
- returns
The future completes when the contract state has been updated. The following irregularities are reported:
- ActiveContractStore.SimultaneousDeactivation if an unassignment to another synchronizer or a creation has been added with the same timestamp.
- ActiveContractStore.ChangeAfterArchival if this timestamp is after the earliest archival of the contract.
- ActiveContractStore.ChangeBeforeCreation if this timestamp is before the latest creation of the contract.
- ActiveContractStore.ReassignmentCounterShouldIncrease if the reassignment counter does not increase monotonically.
- Definition Classes
- InMemoryActiveContractStore → ActiveContractStore
- def unassignContracts(contractId: LfContractId, toc: TimeOfChange, targetSynchronizer: Target[SynchronizerId], reassignmentCounter: ReassignmentCounter)(implicit traceContext: TraceContext): CheckedT[FutureUnlessShutdown, AcsError, AcsWarning, Unit]
- Definition Classes
- ActiveContractStore
- 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])