Function fetchBlockServices

cpp/core/RegistryClient.cpp:129–217

}

std::pair<int, std::string> fetchBlockServices(const std::string& addr, uint16_t port, Duration timeout, ShardId shid, std::vector<FullBlockServiceInfo>& blockServices, std::vector<BlockServiceInfoShort>& currentBlockServices) {
    blockServices.clear();
    currentBlockServices.clear();

#define FAIL(err, errStr) do { blockServices.clear(); currentBlockServices.clear(); return {err, errStr}; } while (0)

    auto [sock, err] = registrySock(addr, port, timeout);
    if (sock.error()) {
        return {sock.getErrno(), err};
    }

    // all block services
    {
        RegistryReqContainer reqContainer;
        auto& req = reqContainer.setAllBlockServices();
        {
            const auto [err, errStr] = writeRegistryRequest(sock.get(), reqContainer, timeout);
            if (err) { FAIL(err, errStr); }
        }

        RegistryRespContainer respContainer;
        {
            const auto [err, errStr] = readRegistryResponse(sock.get(), respContainer, timeout);
            if (err) { FAIL(err, errStr); }
        }

        blockServices = respContainer.getAllBlockServices().blockServices.els;
    }

    // current block services
    {
        RegistryReqContainer reqContainer;
        auto& req = reqContainer.setShardBlockServices();
        req.shardId = shid;
        {
            const auto [err, errStr] = writeRegistryRequest(sock.get(), reqContainer, timeout);
            if (err) { FAIL(err, errStr); }
        }

        RegistryRespContainer respContainer;
        {
            const auto [err, errStr] = readRegistryResponse(sock.get(), respContainer, timeout);
            if (err) { FAIL(err, errStr); }
        }

        currentBlockServices = respContainer.getShardBlockServices().blockServices.els;
    }

    // check that all current block services are known -- there's a small race here
    // the caller should just retry in these cases.
    // check that all current block services are from different failure domains
    // registry should guarantee that when sending response but verify the invariant
    {
        std::unordered_set<uint64_t> knownBlockServices;
        std::unordered_map<uint64_t, const FullBlockServiceInfo* > bsIdToBlockService;
        std::unordered_set<std::string> fdSet;
        for (const auto& bs : blockServices) {
            knownBlockServices.insert(bs.id.u64);