Creating Abstract and Concrete Flow in Corda - corda

Question

I am writing a Corda flow in Java using abstract class as an initiating flow but having a concrete implementation of it. I get a log that tells me that the abstract flow is registered to initiate a responder flow and I don’t see any error in the logs. However, when I do a flow list, I don’t see that flow in the listing and neither when I try to do a rpcOps.registeredFlows list. What could be the reason for that discrepancy?
#InitiatingFlow
#StartableByRPC
public abstract class AbstractExampleFlow extends
FlowLogic<SignedTransaction> {
private final int iouValue;
private final Party otherParty;
public AbstractExampleFlow(int iouValue, Party otherParty) {
this.iouValue = iouValue;
this.otherParty = otherParty;
}
protected SignedTransaction verifyAndSignQuoteRequest (TransactionBuilder txBuilder) throws FlowException {
txBuilder.verify(getServiceHub());
// Sign the transaction.
final SignedTransaction partSignedTx = getServiceHub().signInitialTransaction(txBuilder);
return partSignedTx;
}
#Suspendable
protected SignedTransaction collectQuotePartySignatures
(SignedTransaction partSignedTx) throws FlowException {
FlowSession otherPartySession = initiateFlow(otherParty);
final SignedTransaction fullySignedTx = subFlow(
new CollectSignaturesFlow(partSignedTx,
ImmutableSet.of(otherPartySession), CollectSignaturesFlow.Companion.tracker()));
return fullySignedTx;
};
protected Party obtainNotary () {
return getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
}
protected abstract SignedTransaction performAction () throws FlowException;
protected TransactionBuilder buildQuoteRequestTransaction() {
Party me = getServiceHub().getMyInfo().getLegalIdentities().get(0);
IOUState iouState = new IOUState(iouValue, me, otherParty, new UniqueIdentifier());
final Command<IOUContract.Commands.Create> txCommand = new Command<>(
new IOUContract.Commands.Create(),
ImmutableList.of(iouState.getLender().getOwningKey(), iouState.getBorrower().getOwningKey()));
final TransactionBuilder txBuilder = new TransactionBuilder(obtainNotary())
.addOutputState(iouState, IOU_CONTRACT_ID)
.addCommand(txCommand);
return txBuilder;
} ;
/**
* The flow logic is encapsulated within the call() method.
*/
#Suspendable
#Override
public SignedTransaction call() throws FlowException {
return performAction();
} .
The concrete (default implementation) looks like this.
public class ConcreteDefaultExampleFlow extends AbstractExampleFlow {
public ConcreteDefaultExampleFlow(int iouValue, Party otherParty) {
super (iouValue, otherParty);
}
/**
* The flow logic is encapsulated within the performAction() method.
*/
#Suspendable
#Override
public SignedTransaction performAction () throws FlowException {
System.out.println ("In the concrete default flow");
return collectQuotePartySignatures(verifyAndSignQuoteRequest(buildQuoteRequestTransaction()));
}
} .

Answer 1

You need to add the #StartableByRPC annotation to the concrete implementation, and not to the abstract superclass. For example:
#InitiatingFlow
abstract class AbstractInitiator : FlowLogic<Unit>()
#StartableByRPC
class Initiator(val party: Party) : AbstractInitiator() {
override val progressTracker = ProgressTracker()
#Suspendable
override fun call() {
val session = initiateFlow(party)
val string = session.receive<String>().unwrap { it -> it }
logger.info(string)
}
}
#InitiatedBy(AbstractInitiator::class)
class Responder(val counterpartySession: FlowSession) : FlowLogic<Unit>() {
#Suspendable
override fun call() {
counterpartySession.send("Joel1234")
}
}