folly官方例子

folly官方例子

Future<vector<LeafResponse>> fanout(const map<Leaf, LeafReq> &leafToReqMap,
                                    chrono::milliseconds timeout) {
  vector<Future<LeafResponse>> leafFutures;
  for (const auto &kv : leafToReqMap) {
    const auto &leaf = kv.first;
    const auto &leafReq = kv.second;
    leafFutures.push_back(
        // Get the client for this leaf and do the async RPC
        getClient(leaf)
            ->futureLeafRPC(leafReq)
            // If the request times out, use an empty response and move on.
            .onTimeout(timeout, [=] { return LeafResponse(); })
            // If there's an error (e.g. RPC exception),
            // use an empty response and move on.
            .onError([=](const exception &e) { return LeafResponse(); }));
  }
  // Collect all the individual leaf requests into one Future
  return collect(leafFutures);
}
// Some sharding function; possibly dependent on previous responses.
map<Leaf, LeafReq> buildLeafToReqMap(const Request &request,
                                     const vector<LeafResponse> &responses);
// This function assembles our final response.
Response assembleResponse(const Request &request,
                          const vector<LeafResponse> &firstFanoutResponses,
                          const vector<LeafResponse> &secondFanoutResponses);
Future<Response> twoStageFanout(shared_ptr<Request> request) {
  // Stage 1: first fanout
  return fanout(buildLeafToReqMap(*request, {}), FIRST_FANOUT_TIMEOUT_MS)
      // Stage 2: With the first fanout completed, initiate the second fanout.
      .then([=](vector<LeafResponse> &responses) {
        auto firstFanoutResponses =
            std::make_shared<vector<LeafResponse>>(std::move(responses));

        // This time, sharding is dependent on the first fanout.
        return fanout(buildLeafToReqMap(*request, *firstFanoutResponses),
                      SECOND_FANOUT_TIMEOUT_MS)

            // Stage 3: Assemble and return the final response.
            .then([=](const vector<LeafResponse> &secondFanoutResponses) {
              return assembleResponse(*request, *firstFanoutResponses,
                                      secondFanoutResponses);
            });
      });
}