object repair extends Helpful
- Annotations
- @Summary(s = "Commands to repair the local participant contract state", flag = FeatureFlag.Repair) @Group(name = "Repair")
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- repair
- Helpful
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
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(domain: DomainAlias, contractsToAdd: Seq[SerializableContractWithWitnesses], ignoreAlreadyAdded: Boolean = true): Unit
- Annotations
- @Summary(s = "Add specified contracts to specific domain on local participant.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This is a last resort command to recover from data corruption, e.g. in scenarios in which participant
|contracts have somehow gotten out of sync and need to be manually created. The participant needs to be
|disconnected from the specified "domain" at the time of the call, and as of now the domain cannot have had
|any inflight requests.
|For each "contractsToAdd", specify "witnesses", local parties, in case no local party is a stakeholder.
|The "ignoreAlreadyAdded" flag makes it possible to invoke the command multiple times with the same
|parameters in case an earlier command invocation has failed.
|As repair commands are powerful tools to recover from unforeseen data corruption, but dangerous under normal
|operation, use of this command requires (temporarily) enabling the "features.enable-repair-commands"
|configuration. In addition repair commands can run for an unbounded time depending on the number of
|contracts passed in. Be sure to not connect the participant to the domain until the call returns.""")
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def change_domain(contractIds: Seq[LfContractId], sourceDomain: DomainAlias, targetDomain: DomainAlias, skipInactive: Boolean = true, batchSize: Int = 100): Unit
- Annotations
- @Summary(s = "Move contracts with specified Contract IDs from one domain to another.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This is a last resort command to recover from data corruption in scenarios in which a domain is
|irreparably broken and formerly connected participants need to move contracts to another, healthy domain.
|The participant needs to be disconnected from both the "sourceDomain" and the "targetDomain". Also as of now
|the target domain cannot have had any inflight requests.
|Contracts already present in the target domain will be skipped, and this makes it possible to invoke this
|command in an "idempotent" fashion in case an earlier attempt had resulted in an error.
|The "skipInactive" flag makes it possible to only move active contracts in the "sourceDomain".
|As repair commands are powerful tools to recover from unforeseen data corruption, but dangerous under normal
|operation, use of this command requires (temporarily) enabling the "features.enable-repair-commands"
|configuration. In addition repair commands can run for an unbounded time depending on the number of
|contract ids passed in. Be sure to not connect the participant to either domain until the call returns.
Arguments:
- contractIds - set of contract ids that should be moved to the new domain
- sourceDomain - alias of the source domain
- targetDomain - alias of the target domain
- skipInactive - (default true) whether to skip inactive contracts mentioned in the contractIds list
- batchSize - (default 100) how many contracts to write at once to the database""")
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- 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 ignore_events(domainId: DomainId, from: SequencerCounter, to: SequencerCounter, force: Boolean = false): Unit
- Annotations
- @Summary(s = "Mark sequenced events as ignored.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This is the last resort to ignore events that the participant is unable to process.
|Ignoring events may lead to subsequent failures, e.g., if the event creating a contract is ignored and
|that contract is subsequently used. It may also lead to ledger forks if other participants still process
|the ignored events.
|It is possible to mark events as ignored that the participant has not yet received.
|
|The command will fail, if marking events between `from` and `to` as ignored would result in a gap in sequencer counters,
|namely if `from <= to` and `from` is greater than `maxSequencerCounter + 1`,
|where `maxSequencerCounter` is the greatest sequencer counter of a sequenced event stored by the underlying participant.
|
|The command will also fail, if `force == false` and `from` is smaller than the sequencer counter of the last event
|that has been marked as clean.
|(Ignoring such events would normally have no effect, as they have already been processed.)""")
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def migrate_domain(source: DomainAlias, target: DomainConnectionConfig): Unit
- Annotations
- @Summary(s = "Migrate domain to a new version.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This method can be used to migrate all the contracts associated with a domain to a new domain connection.
This method will register the new domain, connect to it and then re-associate all contracts on the source
domain to the target domain. Please note that this migration needs to be done by all participants
at the same time. The domain should only be used once all participants have finished their migration.
The arguments are:
source: the domain alias of the source domain
target: the configuration for the target domain
""")
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def purge(domain: DomainAlias, contractIds: Seq[LfContractId], ignoreAlreadyPurged: Boolean = true): Unit
- Annotations
- @Summary(s = "Purge contracts with specified Contract IDs from local participant.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This is a last resort command to recover from data corruption, e.g. in scenarios in which participant
|contracts have somehow gotten out of sync and need to be manually purged, or in situations in which
|stakeholders are no longer available to agree to their archival. The participant needs to be disconnected from
|the domain on which the contracts with "contractIds" reside at the time of the call, and as of now the domain
|cannot have had any inflight requests.
|The "ignoreAlreadyPurged" flag makes it possible to invoke the command multiple times with the same
|parameters in case an earlier command invocation has failed.
|As repair commands are powerful tools to recover from unforeseen data corruption, but dangerous under normal
|operation, use of this command requires (temporarily) enabling the "features.enable-repair-commands"
|configuration. In addition repair commands can run for an unbounded time depending on the number of
|contract ids passed in. Be sure to not connect the participant to the domain until the call returns.""")
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unignore_events(domainId: DomainId, from: SequencerCounter, to: SequencerCounter, force: Boolean = false): Unit
- Annotations
- @Summary(s = "Remove the ignored status from sequenced events.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command has no effect on ordinary (i.e., not ignored) events and on events that do not exist.
|
|The command will fail, if marking events between `from` and `to` as unignored would result in a gap in sequencer counters,
|namely if there is one empty ignored event with sequencer counter between `from` and `to` and
|another empty ignored event with sequencer counter greater than `to`.
|An empty ignored event is an event that has been marked as ignored and not yet received by the participant.
|
|The command will also fail, if `force == false` and `from` is smaller than the sequencer counter of the last event
|that has been marked as clean.
|(Unignoring such events would normally have no effect, as they have already been processed.)""")
- 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])