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): 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.""")
- 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
- 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])