diff --git a/core/src/main/kotlin/net/corda/core/flows/FinalityRecoveryFlow.kt b/core/src/main/kotlin/net/corda/core/flows/FinalityRecoveryFlow.kt new file mode 100644 index 0000000000..e31f5b4fa8 --- /dev/null +++ b/core/src/main/kotlin/net/corda/core/flows/FinalityRecoveryFlow.kt @@ -0,0 +1,97 @@ +package net.corda.core.flows + +import co.paralleluniverse.fibers.Suspendable +import net.corda.core.CordaInternal +import net.corda.core.crypto.SecureHash +import net.corda.core.flows.FinalityFlow.Companion.tracker +import net.corda.core.identity.CordaX500Name +import net.corda.core.serialization.CordaSerializable +import net.corda.core.utilities.ProgressTracker +import java.time.Instant + +/** + * TWO_PHASE_FINALITY Recovery Flow + * This flow is exposed via the Core API for use by any CorDapp but its implementation is available in Enterprise only. + */ +@StartableByRPC +@InitiatingFlow +class FinalityRecoveryFlow( + private val txIds: Collection = emptySet(), + private val flowIds: Collection = emptySet(), + private val matchingCriteria: FlowRecoveryQuery? = null, + private val forceRecover: Boolean = false, + private val recoverAll: Boolean = false, + override val progressTracker: ProgressTracker = ProgressTracker()) : FlowLogic>() { + + @CordaInternal + data class ExtraConstructorArgs(val txIds: Collection, + val flowIds: Collection, + val matchingCriteria: FlowRecoveryQuery?, + val forceRecover: Boolean, + val recoverAll: Boolean) + @CordaInternal + fun getExtraConstructorArgs() = ExtraConstructorArgs(txIds, flowIds, matchingCriteria, forceRecover, recoverAll) + + constructor(txId: SecureHash, forceRecover: Boolean = false) : this(setOf(txId), forceRecover) + constructor(txIds: Collection, forceRecover: Boolean = false, recoverAll: Boolean = false) : this(txIds, emptySet(), null, forceRecover, recoverAll, tracker()) + constructor(flowId: StateMachineRunId, forceRecover: Boolean = false) : this(emptySet(), setOf(flowId), null, forceRecover) + constructor(flowIds: Collection, forceRecover: Boolean = false) : this(emptySet(), flowIds, null, forceRecover, false, tracker()) + constructor(recoverAll: Boolean, forceRecover: Boolean = false) : this(emptySet(), emptySet(), null, forceRecover, recoverAll, tracker()) + constructor(matchingCriteria: FlowRecoveryQuery, forceRecover: Boolean = false) : this(emptySet(), emptySet(), matchingCriteria, forceRecover, false, tracker()) + + @Suspendable + @Throws(FlowRecoveryException::class) + override fun call(): Map { + throw NotImplementedError("Enterprise only feature") + } +} + +@CordaSerializable +class FlowRecoveryException(message: String, cause: Throwable? = null) : FlowException(message, cause) { + constructor(txnId: SecureHash, message: String, cause: Throwable? = null) : this("Flow recovery failed for transaction $txnId: $message", cause) +} + +@CordaSerializable +data class FlowRecoveryQuery( + val timeframe: FlowTimeWindow? = null, + val initiatedBy: CordaX500Name? = null, + val counterParties: List? = null) { + init { + require(timeframe != null || initiatedBy != null || counterParties != null) { + "Must specify at least one recovery criteria" + } + } +} + +@CordaSerializable +data class FlowTimeWindow(val fromTime: Instant? = null, val untilTime: Instant? = null) { + + init { + if (fromTime == null && untilTime == null) + throw IllegalArgumentException("Must specify one or both of fromTime or/and untilTime") + fromTime?.let { startTime -> + untilTime?.let { endTime -> + if (endTime < startTime) { + throw IllegalArgumentException(FlowTimeWindow::fromTime.name + " must be before or equal to " + FlowTimeWindow::untilTime.name) + } + } + } + } + + companion object { + @JvmStatic + fun between(fromTime: Instant, untilTime: Instant): FlowTimeWindow { + return FlowTimeWindow(fromTime, untilTime) + } + + @JvmStatic + fun fromOnly(fromTime: Instant): FlowTimeWindow { + return FlowTimeWindow(fromTime = fromTime) + } + + @JvmStatic + fun untilOnly(untilTime: Instant): FlowTimeWindow { + return FlowTimeWindow(untilTime = untilTime) + } + } +} \ No newline at end of file diff --git a/core/src/main/kotlin/net/corda/core/flows/LedgerRecoverFlow.kt b/core/src/main/kotlin/net/corda/core/flows/LedgerRecoverFlow.kt new file mode 100644 index 0000000000..f9d7353ed4 --- /dev/null +++ b/core/src/main/kotlin/net/corda/core/flows/LedgerRecoverFlow.kt @@ -0,0 +1,85 @@ +package net.corda.core.flows + +import co.paralleluniverse.fibers.Suspendable +import net.corda.core.CordaInternal +import net.corda.core.crypto.SecureHash +import net.corda.core.identity.CordaX500Name +import net.corda.core.identity.Party +import net.corda.core.serialization.CordaSerializable +import net.corda.core.utilities.ProgressTracker + +/** + * Ledger Recovery Flow (available in Enterprise only). + */ +@StartableByRPC +@InitiatingFlow +class LedgerRecoveryFlow( + private val recoveryPeers: Collection, + private val timeWindow: RecoveryTimeWindow, + private val useAllNetworkNodes: Boolean = false, + private val transactionRole: TransactionRole = TransactionRole.ALL, + private val dryRun: Boolean = false, + private val optimisticInitiatorRecovery: Boolean = false, + override val progressTracker: ProgressTracker = ProgressTracker()) : FlowLogic>() { + + @CordaInternal + data class ExtraConstructorArgs(val recoveryPeers: Collection, + val timeWindow: RecoveryTimeWindow, + val useAllNetworkNodes: Boolean, + val transactionRole: TransactionRole, + val dryRun: Boolean, + val optimisticInitiatorRecovery: Boolean) + @CordaInternal + fun getExtraConstructorArgs() = ExtraConstructorArgs(recoveryPeers, timeWindow, useAllNetworkNodes, transactionRole, dryRun, optimisticInitiatorRecovery) + + // unused constructors added to facilitate Node Shell command invocation + constructor(recoveryPeer: Party, timeWindow: RecoveryTimeWindow) : this(setOf(recoveryPeer), timeWindow, false, TransactionRole.ALL, false, false) + constructor(recoveryPeer: Party, timeWindow: RecoveryTimeWindow, dryRun: Boolean) : this(setOf(recoveryPeer), timeWindow, false, TransactionRole.ALL, dryRun, false) + + constructor(timeWindow: RecoveryTimeWindow, dryRun: Boolean) : this(emptySet(), timeWindow, false, TransactionRole.ALL, dryRun, false) + constructor(timeWindow: RecoveryTimeWindow, dryRun: Boolean, optimisticInitiatorRecovery: Boolean) : this(emptySet(), timeWindow, false, TransactionRole.ALL, dryRun, optimisticInitiatorRecovery) + constructor(recoveryPeers: Collection, timeWindow: RecoveryTimeWindow, dryRun: Boolean) : this(recoveryPeers, timeWindow, false, TransactionRole.ALL, dryRun, false) + constructor(recoveryPeers: Collection, timeWindow: RecoveryTimeWindow, dryRun: Boolean, optimisticInitiatorRecovery: Boolean) : this(recoveryPeers, timeWindow, false, TransactionRole.ALL, dryRun, optimisticInitiatorRecovery) + + @Suspendable + @Throws(LedgerRecoveryException::class) + override fun call(): Map { + throw NotImplementedError("Enterprise only feature") + } +} + +@InitiatedBy(LedgerRecoveryFlow::class) +class ReceiveLedgerRecoveryFlow constructor(private val otherSideSession: FlowSession) : FlowLogic() { + @Suspendable + override fun call() { + throw NotImplementedError("Enterprise only feature") + } +} + +@CordaSerializable +class LedgerRecoveryException(message: String) : FlowException("Ledger recovery failed: $message") + +/** + * This specifies which type of transactions to recover based on the transaction role of the recovering node + */ +@CordaSerializable +enum class TransactionRole { + ALL, + INITIATOR, // only recover transactions that I initiated + PEER, // only recover transactions where I am a participant on a transaction + OBSERVER, // only recover transactions where I am an observer (but not participant) to a transaction + PEER_AND_OBSERVER // recovery transactions where I am either participant or observer +} + +@CordaSerializable +data class RecoveryResult( + val transactionId: SecureHash, + val recoveryPeer: CordaX500Name, + val transactionRole: TransactionRole, // what role did I play in this transaction + val synchronised: Boolean, // whether the transaction was successfully synchronised (will always be false when dryRun option specified) + val synchronisedInitiated: Boolean = false, // only attempted if [optimisticInitiatorRecovery] option set to true and [TransactionRecoveryType.INITIATOR] + val failureCause: String? = null // reason why a transaction failed to synchronise +) + + +