class CantonSyncService extends WriteService with WriteParticipantPruningService with ReadService with FlagCloseable with Spanning with NamedLogging
The Canton-based synchronization service.
A single Canton sync service can connect to multiple domains.
- Alphabetic
- By Inheritance
- CantonSyncService
- NamedLogging
- Spanning
- FlagCloseable
- AutoCloseable
- ReadService
- WriteService
- ReportsHealth
- WriteParticipantPruningService
- WriteConfigService
- WritePartyService
- WritePackagesService
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new CantonSyncService(participantId: ParticipantId, domainRegistry: DomainRegistry, domainConnectionConfigStore: DomainConnectionConfigStore, aliasManager: DomainAliasManager, participantNodePersistentState: Eval[ParticipantNodePersistentState], participantNodeEphemeralState: ParticipantNodeEphemeralState, syncDomainPersistentStateManager: SyncDomainPersistentStateManager, packageService: PackageService, topologyManagerOps: ParticipantTopologyManagerOps, identityPusher: ParticipantTopologyDispatcherCommon, partyNotifier: LedgerServerPartyNotifier, syncCrypto: SyncCryptoApiProvider, pruningProcessor: PruningProcessor, ledgerId: LedgerId, engine: Engine, syncDomainStateFactory: SyncDomainEphemeralStateFactory, clock: Clock, resourceManagementService: ResourceManagementService, parameters: ParticipantNodeParameters, syncDomainFactory: Factory[SyncDomain], indexedStringStore: IndexedStringStore, storage: Storage, metrics: ParticipantMetrics, sequencerInfoLoader: SequencerInfoLoader, isActive: () => Boolean, futureSupervisor: FutureSupervisor, loggerFactory: NamedLoggerFactory, skipRecipientsCheck: Boolean, multiDomainLedgerAPIEnabled: Boolean)(implicit ec: ExecutionContext, mat: Materializer, tracer: Tracer)
- participantId
The participant node id hosting this sync service.
- domainRegistry
Domain registry for connecting to domains.
- domainConnectionConfigStore
Storage for domain connection configs
- packageService
Underlying package management service.
- syncCrypto
Synchronisation crypto utility combining IPS and Crypto operations.
- isActive
Returns true of the node is the active replica
Type Members
- case class ReaderState(count: Int, readers: MultiSet[String]) extends Product with Serializable
- Definition Classes
- FlagCloseable
- type ConnectionListener = (DomainAlias) => Unit
Value Members
- object ReaderState extends Serializable
- Definition Classes
- FlagCloseable
- 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 addDomain(config: DomainConnectionConfig)(implicit traceContext: TraceContext): EitherT[Future, SyncServiceError, Unit]
Adds a new domain to the sync service's configuration.
Adds a new domain to the sync service's configuration.
NOTE: Does not automatically connect the sync service to the new domain.
- config
The domain configuration.
- returns
Error or unit.
- def allocateParty(hint: Option[LfPartyId], displayName: Option[String], rawSubmissionId: LedgerSubmissionId)(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]
Adds a new party to the set managed by the ledger.
Adds a new party to the set managed by the ledger.
Caller specifies a party identifier suggestion, the actual identifier allocated might be different and is implementation specific.
In particular, a ledger may: - Disregard the given hint and choose a completely new party identifier - Construct a new unique identifier from the given hint, e.g., by appending a UUID - Use the given hint as is, and reject the call if such a party already exists
Successful party allocations will result in a com.digitalasset.canton.ledger.participant.state.v2.Update.PartyAddedToParticipant message. See the comments on com.digitalasset.canton.ledger.participant.state.v2.ReadService.stateUpdates and com.digitalasset.canton.ledger.participant.state.v2.Update for further details.
- hint
A party identifier suggestion
- displayName
A human readable name of the new party
- returns
an async result of a SubmissionResult
- Definition Classes
- CantonSyncService → WritePartyService
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- val cantonAuthorityResolver: AuthorityResolver
- def checkOverloaded(traceContext: TraceContext): Option[SubmissionResult]
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- 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()
- def closingTimeout: FiniteDuration
- Attributes
- protected
- Definition Classes
- FlagCloseable
- def computeTotalLoad: Int
- def configuredDomains: Seq[StoredDomainConnectionConfig]
Returns the domains this sync service is configured with.
- def connectDomain(domainAlias: DomainAlias, keepRetrying: Boolean)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Boolean]
Connect the sync service to the given domain.
Connect the sync service to the given domain. This method makes sure there can only be one connection in progress at a time.
- def currentHealth(): HealthStatus
Reports the current health of the object.
Reports the current health of the object. This should always return immediately.
- Definition Classes
- CantonSyncService → ReportsHealth
- def currentWriteHealth(): HealthStatus
- def disconnectDomain(domain: DomainAlias)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Unit]
Disconnect the given domain from the sync service.
- def disconnectDomains()(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Unit]
Disconnect from all connected domains.
- def domainConnectionConfigByAlias(domainAlias: DomainAlias): EitherT[Future, MissingConfigForAlias, StoredDomainConnectionConfig]
- val ephemeralHealth: MutableHealthComponent
- 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
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def getConnectedDomains(request: ConnectedDomainRequest)(implicit traceContext: TraceContext): Future[ConnectedDomainResponse]
- Definition Classes
- CantonSyncService → ReadService
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def incompleteReassignmentOffsets(validAt: LedgerSyncOffset, stakeholders: Set[LfPartyId])(implicit traceContext: TraceContext): Future[Vector[LedgerSyncOffset]]
Get the offsets of the incomplete assigned/unassigned events for a set of stakeholders.
Get the offsets of the incomplete assigned/unassigned events for a set of stakeholders.
- validAt
The offset of validity in participant offset terms.
- stakeholders
Only offsets are returned which have at least one stakeholder from this set.
- returns
All the offset of assigned/unassigned events which do not have their conterparts visible at the validAt offset, and only for the reassignments for which this participant is reassigning.
- Definition Classes
- CantonSyncService → ReadService
- def incompleteTransferData(validAt: GlobalOffset, stakeholders: Set[LfPartyId])(implicit traceContext: TraceContext): Future[List[IncompleteTransferData]]
- def initializeState()(implicit traceContext: TraceContext): Unit
- def internalPerformUnlessClosingF[A](name: String)(f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): UnlessShutdown[Future[A]]
- Attributes
- protected
- Definition Classes
- FlagCloseable
- val isActive: () => Boolean
- 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
- 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
- FlagCloseable
- def ledgerInitialConditions(): Source[LedgerInitialConditions, NotUsed]
Retrieve the static initial conditions of the ledger, containing the ledger identifier, the ledger config and the initial ledger record time.
Retrieve the static initial conditions of the ledger, containing the ledger identifier, the ledger config and the initial ledger record time.
Returns a single element Source since the implementation may need to first establish connectivity to the underlying ledger. The implementer may assume that this method is called only once, or very rarely. Source is being used instead of Future as this is in line with stateUpdates, and is easy to implement from both Java and Scala.
- Definition Classes
- CantonSyncService → ReadService
- def logger: TracedLogger
- Attributes
- protected
- Definition Classes
- NamedLogging
- val loggerFactory: NamedLoggerFactory
- Attributes
- protected
- Definition Classes
- CantonSyncService → NamedLogging
- def lookupDomainTimeTracker(domainId: DomainId): Option[DomainTimeTracker]
Lookup a time tracker for the given
domainId.Lookup a time tracker for the given
domainId. A time tracker will only be returned if the domain is registered and connected. - val maxDeduplicationDuration: NonNegativeFiniteDuration
- def maxSleepMillis: Long
- Attributes
- protected
- Definition Classes
- FlagCloseable
- def migrateDomain(source: DomainAlias, target: DomainConnectionConfig)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Unit]
- def modifyDomain(config: DomainConnectionConfig)(implicit traceContext: TraceContext): EitherT[Future, SyncServiceError, Unit]
Modifies the settings of the sync-service's configuration
Modifies the settings of the sync-service's configuration
NOTE: This does not automatically reconnect the sync service.
- 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() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def onCloseFailure(e: Throwable): Unit
- Attributes
- protected
- Definition Classes
- FlagCloseable
- def onClosed(): Unit
- Definition Classes
- CantonSyncService → FlagCloseable
- val participantId: ParticipantId
- def partyHasActiveContracts(partyId: PartyId)(implicit traceContext: TraceContext): Future[Boolean]
Checks if a given party has any active contracts.
- def performUnlessClosing[A](name: String)(f: => A)(implicit traceContext: TraceContext): UnlessShutdown[A]
Performs the task given by
funless a shutdown has been initiated.Performs the task given by
funless a shutdown has been initiated. The shutdown will only begin afterfcompletes, 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.closeas 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
- FlagCloseable
- 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
- FlagCloseable
- 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
etfunless a shutdown has been initiated, in which case the provided error is returned instead.Performs the EitherT[Future] given by
etfunless a shutdown has been initiated, in which case the provided error is returned instead. Bothetfand the error are lazy;etfis only evaluated if there is no shutdown, the error only if we're shutting down. The shutdown will only begin afteretfcompletes, 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.closeas part ofetf, because it will result in a deadlock.- etf
The task to perform
- Definition Classes
- FlagCloseable
- 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
- FlagCloseable
- def performUnlessClosingEitherU[E, R](name: String)(etf: => EitherT[Future, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[FutureUnlessShutdown, E, R]
- Definition Classes
- FlagCloseable
- def performUnlessClosingEitherUSF[E, R](name: String)(etf: => EitherT[FutureUnlessShutdown, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[FutureUnlessShutdown, E, R]
- Definition Classes
- FlagCloseable
- def performUnlessClosingF[A](name: String)(f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): FutureUnlessShutdown[A]
Performs the Future given by
funless a shutdown has been initiated.Performs the Future given by
funless a shutdown has been initiated. The future is lazy and not evaluated during shutdown. The shutdown will only begin afterfcompletes, 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.closeas 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
- FlagCloseable
- def performUnlessClosingUSF[A](name: String)(f: => FutureUnlessShutdown[A])(implicit ec: ExecutionContext, traceContext: TraceContext): FutureUnlessShutdown[A]
- Definition Classes
- FlagCloseable
- val protocolVersionGetter: (Traced[DomainId]) => Future[Option[ProtocolVersion]]
- def prune(pruneUpToInclusive: LedgerSyncOffset, submissionId: LedgerSubmissionId, _pruneAllDivulgedContracts: Boolean): CompletionStage[PruningResult]
Prune the participant ledger specifying the offset up to which participant ledger events can be removed.
Prune the participant ledger specifying the offset up to which participant ledger events can be removed.
As this interface applies only to the local participant unlike other administrator services, returns a (completion stage of a) PruningResult rather than a SubmissionResult.
Ledgers that do not elect to support participant pruning, return NotPruned(Status.UNIMPLEMENTED). Returning an error also keeps the ledger api server from pruning its index.
Ledgers whose participants hold no participant-local state, but want the ledger api server to prune, return ParticipantPruned.
For pruning implementations to be fault tolerant, the following aspects are important: - Consider failing a prune request before embarking on destructive operations for example if certain safety conditions are not met (such as being low on resources). This helps minimize the chances of partially performed prune operations. If the system cannot prune up to the specified offset, the call should not alter the system and return NotPruned rather than prune partially. - Implement pruning either atomically (performing all operations or none), or break down pruning steps into idempotent pieces that pick up after retries or system recovery in case of a mid-pruning crash. - To the last point, be aware that pruning of the ledger api server index happens in such an idempotent follow-up step upon successful completion of each prune call. To reach eventual consistency upon failures, be sure to return ParticipantPruned even if the specified offset has already been pruned to allow ledger api server index pruning to proceed in case of an earlier failure.
- pruneUpToInclusive
The offset up to which contracts should be pruned.
- submissionId
The submission id.
- returns
The pruning result.
- Definition Classes
- CantonSyncService → WriteParticipantPruningService
- def pruneInternally(pruneUpToInclusive: LedgerSyncOffset)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, CantonError, Unit]
- def pureCryptoApi: CryptoPureApi
Returns the pure crypto operations used for the sync protocol
- def purgeDomain(domain: DomainAlias): Either[SyncServiceError, Unit]
Removes a configured and disconnected domain.
Removes a configured and disconnected domain.
This is an unsafe operation as it changes the ledger offsets.
- def readyDomains: Map[DomainAlias, (DomainId, Boolean)]
Returns the ready domains this sync service is connected to.
- def reconnectDomains(ignoreFailures: Boolean)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Seq[DomainAlias]]
Reconnect to all configured domains that have autoStart = true
- def refreshCaches()(implicit traceContext: TraceContext): FutureUnlessShutdown[Unit]
- val repairService: RepairService
- 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
- FlagCloseable
- def runStateChanged(waitingState: Boolean = false): Unit
- Attributes
- protected
- Definition Classes
- FlagCloseable
- Annotations
- @VisibleForTesting()
- val sequencerClientHealth: MutableHealthComponent
- lazy val stateInspection: SyncStateInspection
- def stateUpdates(beginAfterOffset: Option[LedgerSyncOffset])(implicit traceContext: TraceContext): Source[(LedgerSyncOffset, Traced[Update]), NotUsed]
Build source for subscription (for ledger api server indexer).
Build source for subscription (for ledger api server indexer).
- beginAfterOffset
offset after which to emit events
- Definition Classes
- CantonSyncService → ReadService
- def submitConfiguration(_maxRecordTimeToBeRemovedUpstream: LedgerSyncRecordTime, submissionId: LedgerSubmissionId, config: Configuration)(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]
Submit a new configuration to the ledger.
Submit a new configuration to the ledger. If the configuration is accepted a com.digitalasset.canton.ledger.participant.state.v2.Update.ConfigurationChanged event will be emitted to all participants. In case of rejection a com.digitalasset.canton.ledger.participant.state.v2.Update.ConfigurationChangeRejected will be emitted.
The com.digitalasset.canton.ledger.configuration.Configuration contains the identity of the participant that is allowed to further change the configuration. The initial configuration can be submitted by any participant.
If configuration changes are not supported by the implementation then the com.digitalasset.canton.ledger.participant.state.v2.SubmissionResult.SynchronousError should be returned. *
- returns
an async result of a SubmissionResult
- Definition Classes
- CantonSyncService → WriteConfigService
- def submitReassignment(submitter: Party, applicationId: daml.lf.data.Ref.ApplicationId, commandId: daml.lf.data.Ref.CommandId, submissionId: Option[SubmissionId], workflowId: Option[daml.lf.data.Ref.WorkflowId], reassignmentCommand: ReassignmentCommand)(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]
Submit a reassignment command for acceptance to the ledger.
Submit a reassignment command for acceptance to the ledger.
To complete a reassignment, first a submission of an unassign command followed by an assign command is required. The com.digitalasset.canton.ledger.participant.state.v2.ReassignmentCommand.Assign command must include the unassign ID which can be observed in the accepted event marking the corresponding successful unassign command.
- submitter
The submitter of the reassignment.
- applicationId
An identifier for the Daml application that submitted the command. This is used for monitoring, command deduplication, and to allow Daml applications subscribe to their own submissions only.
- commandId
A submitter-provided identifier to identify an intended ledger change within all the submissions by the same parties and application.
- submissionId
An identifier for the submission that allows an application to correlate completions to its submissions.
- workflowId
A submitter-provided identifier used for monitoring and to traffic-shape the work handled by Daml applications communicating over the ledger.
- reassignmentCommand
The command specifying this reassignment further.
- Definition Classes
- CantonSyncService → WriteService
- def submitTransaction(submitterInfo: SubmitterInfo, transactionMeta: TransactionMeta, transaction: LfSubmittedTransaction, _estimatedInterpretationCost: Long, keyResolver: LfKeyResolver, disclosedContracts: ImmArray[ProcessedDisclosedContract])(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]
Submit a transaction for acceptance to the ledger.
Submit a transaction for acceptance to the ledger.
This method must be thread-safe.
The result of the transaction submission is communicated asynchronously via a com.digitalasset.canton.ledger.participant.state.v2.ReadService implementation backed by the same participant state as this com.digitalasset.canton.ledger.participant.state.v2.WriteService. Successful transaction acceptance is communicated using a com.digitalasset.canton.ledger.participant.state.v2.Update.TransactionAccepted message. Failed transaction acceptance is communicated when possible via a com.digitalasset.canton.ledger.participant.state.v2.Update.CommandRejected message referencing the same
submitterInfoas provided in the submission. There can be failure modes where a transaction submission is lost in transit, and no com.digitalasset.canton.ledger.participant.state.v2.Update.CommandRejected is generated. See the comments on com.digitalasset.canton.ledger.participant.state.v2.ReadService.stateUpdates for further details.A note on ledger time and record time: transactions are submitted together with a
ledgerTimeprovided as part of thetransactionMetainformation. The ledger time is used by the Daml Engine to resolve calls to thegetTime :: Update Timefunction. Letting the submitter freely choose the ledger time is though a problem for the other stakeholders in the contracts affected by the submitted transaction. The submitter can in principle choose to submit transactions that are effective far in the past or future relative to the wall-clock time of the other participants. This gives the submitter an unfair advantage and make the semantics ofgetTimequite surprising. We've chosen the following solution to provide useful guarantees for contracts relying ongetTime.The ledger is charged with (1) associating record-time stamps to accepted transactions and (2) to provide a guarantee on the maximal skew between the ledger effective time and the record time stamp associated to an accepted transaction. The ledger is also expected to provide guarantees on the distribution of the maximal skew between record time stamps on accepted transactions and the wall-clock time at delivery of accepted transactions to a ledger participant. Thereby providing ledger participants with a guarantee on the maximal skew between the ledger effective time of an accepted transaction and the wall-clock time at delivery to these participants.
Concretely, we typically expect the allowed skew between record time and ledger time to be in the minute range. Thereby leaving ample time for submitting and validating large transactions before they are timestamped with their record time.
The com.digitalasset.canton.ledger.participant.state.v2.WriteService is responsible for deduplicating commands with the same com.digitalasset.canton.ledger.participant.state.v2.SubmitterInfo.changeId within the com.digitalasset.canton.ledger.participant.state.v2.SubmitterInfo.deduplicationPeriod.
- submitterInfo
the information provided by the submitter for correlating this submission with its acceptance or rejection on the associated com.digitalasset.canton.ledger.participant.state.v2.ReadService.
- transactionMeta
the meta-data accessible to all consumers of the transaction. See com.digitalasset.canton.ledger.participant.state.v2.TransactionMeta for more information.
- transaction
the submitted transaction. This transaction can contain local contract-ids that need suffixing. The participant state may have to suffix those contract-ids in order to guaranteed their global uniqueness. See the Contract Id specification for more detail daml-lf/spec/contract-id.rst.
- Definition Classes
- CantonSyncService → WriteService
- def subscribeToConnections(subscriber: ConnectionListener): Unit
- val syncCrypto: SyncCryptoApiProvider
- val syncDomainHealth: MutableHealthComponent
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def timeouts: ProcessingTimeout
- Attributes
- protected
- Definition Classes
- CantonSyncService → FlagCloseable
- def toString(): String
- Definition Classes
- CantonSyncService → AnyRef → Any
- implicit val tracer: Tracer
- val transferService: TransferService
- def uploadPackages(submissionId: LedgerSubmissionId, archives: List[Archive], sourceDescription: Option[String])(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]
Upload a collection of Daml-LF packages to the ledger.
Upload a collection of Daml-LF packages to the ledger.
This method must be thread-safe, not throw, and not block on IO. It is though allowed to perform significant computation.
Successful archives upload will result in a com.digitalasset.canton.ledger.participant.state.v2.Update.PublicPackageUpload message. See the comments on com.digitalasset.canton.ledger.participant.state.v2.ReadService.stateUpdates and com.digitalasset.canton.ledger.participant.state.v2.Update for further details.
Note: we accept com.daml.daml_lf_dev.DamlLf.Archives rather than parsed packages, because we want to be able to get the byte size of each individual ArchivePayload, which is information that the read / index service need to provide. Moreover this information should be consistent with the payload that the com.daml.ledger.api.v1.package_service.GetPackageResponse contains. If we were to consume packages we'd have to re-encode them to provide the size, and the size might potentially be different from the original size, which would be quite confusing.
- submissionId
Submitter chosen submission identifier.
- archives
Daml-LF archives to be uploaded to the ledger. All archives must be valid, i.e., they must successfully decode and pass Daml engine validation.
- sourceDescription
Description provided by the backing participant describing where it got the package from, e.g., when, where, or by whom the packages were uploaded.
- returns
an async result of a com.digitalasset.canton.ledger.participant.state.v2.SubmissionResult
- Definition Classes
- CantonSyncService → WritePackagesService
- 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 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