Method FetchAndParseClusterSlots

src/brpc/redis_cluster.cpp:774–843

}

bool RedisClusterChannel::FetchAndParseClusterSlots(
    Channel* channel,
    const std::string& endpoint,
    std::vector<std::string>* slot_to_endpoint,
    std::vector<std::string>* discovered_endpoints) {
    RedisRequest request;
    if (!request.AddCommand("cluster slots")) {
        return false;
    }

    RedisResponse response;
    Controller cntl;
    cntl.set_timeout_ms(_options.topology_refresh_timeout_ms);
    channel->CallMethod(NULL, &cntl, &request, &response, NULL);
    if (cntl.Failed()) {
        return false;
    }

    if (response.reply_size() != 1 || !response.reply(0).is_array()) {
        return false;
    }

    const RedisReply& root = response.reply(0);
    const std::string fallback_host = EndpointHost(endpoint);
    bool has_slot = false;
    for (size_t i = 0; i < root.size(); ++i) {
        const RedisReply& item = root[i];
        if (!item.is_array() || item.size() < 3) {
            continue;
        }
        if (!item[0].is_integer() || !item[1].is_integer()) {
            continue;
        }

        int64_t start = item[0].integer();
        int64_t end = item[1].integer();
        if (start < 0 || end < start) {
            continue;
        }

        if (!item[2].is_array() || item[2].size() < 2 || !item[2][1].is_integer()) {
            continue;
        }
        std::string host;
        if (item[2][0].is_string()) {
            host = item[2][0].data().as_string();
        }
        if (host.empty()) {
            host = fallback_host;
        }

        const int64_t port = item[2][1].integer();
        if (port <= 0 || port > 65535) {
            continue;
        }

        std::ostringstream oss;
        oss << host << ":" << port;