Method call

fendermint/abci/src/application.rs:165–219

(&mut self, req: Request)

    }

    fn call(&mut self, req: Request) -> Self::Future {
        // Must make sure this is a cheap clone, required so the app can be moved into the async boxed future.
        // See https://tokio.rs/blog/2021-05-14-inventing-the-service-trait
        // The alternative is to perform the operation synchronously right here,
        // but if we use the `tower_abci::buffer4::Worker` that means nothing else
        // get processed during that time.
        let app = self.0.clone();

        // Another trick to avoid any subtle bugs is the mem::replace.
        // See https://github.com/tower-rs/tower/issues/547
        let app: A = std::mem::replace(&mut self.0, app);

        // Because this is async, make sure the `Consensus` service is wrapped in a concurrency limiting Tower layer.
        let res = async move {
            let res = match req {
                Request::Echo(r) => Response::Echo(log_error(app.echo(r).await)?),
                Request::Info(r) => Response::Info(log_error(app.info(r).await)?),
                Request::InitChain(r) => Response::InitChain(log_error(app.init_chain(r).await)?),
                Request::Query(r) => Response::Query(log_error(app.query(r).await)?),
                Request::CheckTx(r) => Response::CheckTx(log_error(app.check_tx(r).await)?),
                Request::PrepareProposal(r) => {
                    Response::PrepareProposal(log_error(app.prepare_proposal(r).await)?)
                }
                Request::ProcessProposal(r) => {
                    Response::ProcessProposal(log_error(app.process_proposal(r).await)?)
                }
                Request::ExtendVote(r) => {
                    Response::ExtendVote(log_error(app.extend_vote(r).await)?)
                }
                Request::VerifyVoteExtension(r) => {
                    Response::VerifyVoteExtension(log_error(app.verify_vote_extension(r).await)?)
                }
                Request::FinalizeBlock(r) => {
                    Response::FinalizeBlock(log_error(app.finalize_block(r).await)?)
                }
                Request::Commit => Response::Commit(log_error(app.commit().await)?),
                Request::ListSnapshots => {
                    Response::ListSnapshots(log_error(app.list_snapshots().await)?)
                }
                Request::OfferSnapshot(r) => {
                    Response::OfferSnapshot(log_error(app.offer_snapshot(r).await)?)
                }
                Request::LoadSnapshotChunk(r) => {
                    Response::LoadSnapshotChunk(log_error(app.load_snapshot_chunk(r).await)?)
                }
                Request::ApplySnapshotChunk(r) => {
                    Response::ApplySnapshotChunk(log_error(app.apply_snapshot_chunk(r).await)?)
                }
                // Some clients still send explicit Flush requests; never panic on protocol input.
                Request::Flush => Response::Flush,
            };
            Ok(res)
        };
        res.boxed()
    }
}

fn log_error<T>(res: AbciResult<T>) -> AbciResult<T> {