class ParticipantPartiesAdministrationGroup extends PartiesAdministrationGroup with FeatureFlagFilter
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- ParticipantPartiesAdministrationGroup
- FeatureFlagFilter
- NamedLogging
- PartiesAdministrationGroup
- Helpful
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Instance Constructors
- new ParticipantPartiesAdministrationGroup(participantId: => ParticipantId, reference: ParticipantReference, consoleEnvironment: ConsoleEnvironment, loggerFactory: NamedLoggerFactory)
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 add_party_async(party: PartyId, synchronizerId: SynchronizerId, sourceParticipant: ParticipantId, serial: PositiveInt, participantPermission: ParticipantPermission): String
- Annotations
- @Summary(s = "Add a previously existing party to the local participant", flag = FeatureFlag.Preview) @Description(s = """Initiate adding a previously existing party to this participant on the specified synchronizer.
|Performs some checks synchronously and then initiates party replication asynchronously. The returned `addPartyRequestId`
|parameter allows identifying asynchronous progress and errors.""")
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def cantonConfig: CantonConfig
- Attributes
- protected
- Definition Classes
- FeatureFlagFilter
- def check[T](flag: FeatureFlag)(command: => T): T
- Attributes
- protected
- Definition Classes
- FeatureFlagFilter
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()
- val consoleEnvironment: ConsoleEnvironment
- Attributes
- protected
- Definition Classes
- ParticipantPartiesAdministrationGroup → FeatureFlagFilter
- def defaultLimit: PositiveInt
- Attributes
- protected
- Definition Classes
- PartiesAdministrationGroup
- def disable(party: PartyId, forceFlags: ForceFlags = ForceFlags.none, synchronizer: Option[SynchronizerAlias] = None): Unit
- Annotations
- @Summary(s = "Disable party on participant", flag = console.this.Help.Summary.<init>$default$2)
- def enable(name: String, namespace: Namespace = participantId.namespace, synchronizer: Option[SynchronizerAlias] = None, synchronizeParticipants: Seq[ParticipantReference] = consoleEnvironment.participants.all, synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.unbounded
)): PartyId
- Annotations
- @Summary(s = "Enable/add party to participant", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This function registers a new party on a synchronizer with the current participant within the
|participants namespace. The function fails if the participant does not have appropriate signing keys
|to issue the corresponding PartyToParticipant topology transaction, or if the participant is not connected to any
|synchronizers.
|The synchronizer parameter does not have to be specified if the participant is connected only to one synchronizer.
|If the participant is connected to multiple synchronizers, the party needs to be enabled on each synchronizer explicitly.
|Additionally, a sequence of additional participants can be added to be synchronized to
|ensure that the party is known to these participants as well before the function terminates.
|""")
- 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 export_acs(parties: Set[PartyId], ledgerOffset: NonNegativeLong, synchronizerId: Option[SynchronizerId] = None, exportFilePath: String = "canton-acs-export.gz", contractSynchronizerRenames: Map[SynchronizerId, SynchronizerId] = Map.empty, timeout: NonNegativeDuration = timeouts.unbounded): Unit
- Annotations
- @Summary(s = "Export active contracts for the given set of parties to a file.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command exports the current Active Contract Set (ACS) of a given set of parties to a
|GZIP compressed ACS snapshot file. Afterwards, the `import_acs` repair command imports it
|into a participant's ACS again.
|
|The arguments are:
|- parties: Identifying contracts having at least one stakeholder from the given set.
|- synchronizerId: When defined, restricts the export to the given synchronizer.
|- exportFilePath: The path denoting the file where the ACS snapshot will be stored.
|- ledgerOffset: The offset at which the ACS snapshot is exported.
|- contractSynchronizerRenames: Changes the associated synchronizer id of contracts from
| one synchronizer to another based on the mapping.
|- timeout: A timeout for this operation to complete.
""")
- def export_acs_at_timestamp(parties: Set[PartyId], synchronizerId: SynchronizerId, topologyTransactionEffectiveTime: Instant, exportFilePath: String = "canton-acs-export.gz", timeout: NonNegativeDuration = timeouts.unbounded): Unit
- Annotations
- @Summary(s = "Export active contracts for the given set of parties to a file.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command exports the current Active Contract Set (ACS) of a given set of parties to a
|GZIP compressed ACS snapshot file. Afterwards, the `import_acs` repair command imports it
|into a participant's ACS again.
|
|This command attempts to resolve the given instant (`topologyTransactionEffectiveTime`)
|to a ledger offset internally. Such offset exists only after the corresponding topology
|transaction has been recorded on the ledger.
|This command returns an error when no offset has been found. Possible causes:
|1. No topology transaction. Solution: Issue a topology transaction.
|2. Topology transaction exists. Solution: Retry the command.
|
|The arguments are:
|- parties: Identifying contracts having at least one stakeholder from the given set.
|- synchronizerId: Restricts the export to the given synchronizer.
|- topologyTransactionEffectiveTime: The effective time of a topology transaction at which
| the ACS snapshot is exported.
|- exportFilePath: The path denoting the file where the ACS snapshot will be stored.
|- timeout: A timeout for this operation to complete.
""")
- def find(filterParty: String): PartyId
- Annotations
- @Summary(s = "Find a party from a filter string", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Will search for all parties that match this filter string. If it finds exactly one party, it
|will return that one. Otherwise, the function will throw.""")
- def find_highest_offset_by_timestamp(synchronizerId: SynchronizerId, timestamp: Instant, force: Boolean = false): NonNegativeLong
- Annotations
- @Summary(s = "Find highest ledger offset by timestamp.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command attempts to find the highest ledger offset among all events belonging
|to a synchronizer that have a record time before or at the given timestamp.
|
|Returns the highest ledger offset, or an error.
|
|Possible failure causes:
|- The requested timestamp is too far in the past for which no events exist anymore.
|- There are no events for the given synchronizer.
|- Not all events have been processed fully and/or published to the Ledger API DB
| until the requested timestamp.
|
|Depending on the failure cause, this command can be tried to get a ledger offset.
|For example, if not all events have been processed fully and/or published to the
|Ledger API DB, a retry makes sense.
|
|The arguments are:
|- synchronizerId: Restricts the query to a particular synchronizer.
|- timestamp: A point in time.
|- force: Defaults to false. If true, returns the highest currently known ledger offset
| with a record time before or at the given timestamp.
|""")
- def find_party_max_activation_offset(partyId: PartyId, participantId: ParticipantId, synchronizerId: SynchronizerId, validFrom: Option[Instant] = None, beginOffsetExclusive: Long = 0L, endOffsetInclusive: Option[Long] = None, completeAfter: PositiveInt = PositiveInt.MaxValue, timeout: NonNegativeDuration = timeouts.bounded): NonNegativeLong
- Annotations
- @Summary(s = "Finds a party's highest activation offset.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command locates the highest ledger offset where a party's activation matches
|specified criteria.
|
|It searches the ledger for topology transactions, sequenced by the given synchronizer
|(`synchronizerId`), that result in the party (`partyId`) being newly hosted on the
|participant (`participantId`). An optional `validFrom` timestamp filters the topology
|transactions for their effective time.
|
|The ledger search occurs within the specified offset range, targeting a specific number
|of topology transactions (`completeAfter`).
|
|The search begins at the ledger start if `beginOffsetExclusive` is default. If the
|participant was pruned and `beginOffsetExclusive` is below the pruning offset, a
|`NOT_FOUND` error occurs. Use an `beginOffsetExclusive` near, but before, the desired
|topology transactions.
|
|If `endOffsetInclusive` is not set (`None`), the search continues until `completeAfter`
|number of transactions are found or the `timeout` expires. Otherwise, the ledger search
|ends at the specified offset.
|
|This command is useful for creating ACS snapshots with `export_acs`, which requires the
|party activation ledger offset.
|
|
|The arguments are:
|- partyId: The party to find activations for.
|- participantId: The participant hosting the new party.
|- synchronizerId: The synchronizer sequencing the activations.
|- validFrom: The activation's effective time (default: None).
|- beginOffsetExclusive: Starting ledger offset (default: 0).
|- endOffsetInclusive: Ending ledger offset (default: None = trailing search).
|- completeAfter: Number of transactions to find (default: Maximum = no limit).
|- timeout: Search timeout (default: 1 minute).
|""")
- def find_party_max_deactivation_offset(partyId: PartyId, participantId: ParticipantId, synchronizerId: SynchronizerId, validFrom: Option[Instant] = None, beginOffsetExclusive: Long = 0L, endOffsetInclusive: Option[Long] = None, completeAfter: PositiveInt = PositiveInt.MaxValue, timeout: NonNegativeDuration = timeouts.bounded): NonNegativeLong
- Annotations
- @Summary(s = "Finds a party's highest deactivation offset.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command locates the highest ledger offset where a party's deactivation matches
|specified criteria.
|
|It searches the ledger for topology transactions, sequenced by the given synchronizer
|(`synchronizerId`), that result in the party (`partyId`) being revoked on the participant
|(`participantId`). An optional `validFrom` timestamp filters the topology transactions
|for their effective time.
|
|The ledger search occurs within the specified offset range, targeting a specific number
|of topology transactions (`completeAfter`).
|
|The search begins at the ledger start if `beginOffsetExclusive` is default. If the
|participant was pruned and `beginOffsetExclusive` is below the pruning offset, a
|`NOT_FOUND` error occurs. Use an `beginOffsetExclusive` near, but before, the desired
|topology transactions.
|
|If `endOffsetInclusive` is not set (`None`), the search continues until `completeAfter`
|number of transactions are found or the `timeout` expires. Otherwise, the ledger search
|ends at the specified offset.
|
|This command is useful for finding active contracts at the ledger offset where a party
|has been off-boarded from a participant.
|
|
|The arguments are:
|- partyId: The party to find deactivations for.
|- participantId: The participant hosting the new party.
|- synchronizerId: The synchronizer sequencing the deactivations.
|- validFrom: The deactivation's effective time (default: None).
|- beginOffsetExclusive: Starting ledger offset (default: 0).
|- endOffsetInclusive: Ending ledger offset (default: None = trailing search).
|- completeAfter: Number of transactions to find (default: Maximum = no limit).
|- timeout: Search timeout (default: 1 minute).
|""")
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @IntrinsicCandidate() @native()
- def get_add_party_status(addPartyRequestId: String): AddPartyStatus
- Annotations
- @Summary(s = "Obtain status on a pending `add_party_async` call", flag = FeatureFlag.Preview) @Description(s = """Retrieve status information on a party previously added via the `add_party_async` endpoint
|by specifying the previously returned `addPartyRequestId` parameter.""")
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @IntrinsicCandidate() @native()
- def help(methodName: String)(implicit consoleEnvironment: ConsoleEnvironment): Unit
- Definition Classes
- Helpful
- Annotations
- @Summary(s = "Help for specific commands (use help() or help(\"method\") for more information)", flag = console.this.Help.Summary.<init>$default$2) @Topic(t = Seq("Top-level Commands"))
- def help()(implicit consoleEnvironment: ConsoleEnvironment): Unit
- Definition Classes
- Helpful
- def hosted(filterParty: String = "", synchronizerIds: Set[SynchronizerId] = Set.empty, asOf: Option[Instant] = None, limit: PositiveInt = defaultLimit): Seq[ListPartiesResult]
- Annotations
- @Summary(s = "List parties hosted by this participant", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Inspect the parties hosted by this participant as used for synchronisation.
|The response is built from the timestamped topology transactions of each synchronizer, excluding the
|authorized store of the given node. The search will include all hosted parties and is equivalent
|to running the `list` method using the participant id of the invoking participant.
|
filterParty: Filter by parties starting with the given string.
filterSynchronizerId: Filter by synchronizers whose id starts with the given string.
asOf: Optional timestamp to inspect the topology state at a given point in time.
limit: How many items to return (defaults to canton.parameters.console.default-limit)
Example: participant1.parties.hosted(filterParty="alice")""")
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def list(filterParty: String = "", filterParticipant: String = "", synchronizerIds: Set[SynchronizerId] = Set.empty, asOf: Option[Instant] = None, limit: PositiveInt = defaultLimit): Seq[ListPartiesResult]
- Definition Classes
- PartiesAdministrationGroup
- Annotations
- @Summary(s = "List active parties, their active participants, and the participants' permissions on synchronizers.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Inspect the parties known by this participant as used for synchronisation.
|The response is built from the timestamped topology transactions of each synchronizer, excluding the
|authorized store of the given node. For each known party, the list of active
|participants and their permission on the synchronizer for that party is given.
|
filterParty: Filter by parties starting with the given string.
filterParticipant: Filter for parties that are hosted by a participant with an id starting with the given string
filterSynchronizerId: Filter by synchronizers whose id starts with the given string.
asOf: Optional timestamp to inspect the topology state at a given point in time.
limit: Limit on the number of parties fetched (defaults to canton.parameters.console.default-limit).
Example: participant1.parties.list(filterParty="alice")
""")
- def logger: TracedLogger
- Attributes
- protected
- Definition Classes
- NamedLogging
- val loggerFactory: NamedLoggerFactory
- Attributes
- protected
- Definition Classes
- ParticipantPartiesAdministrationGroup → NamedLogging
- 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()
- 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])
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])