futu_backend/auth/commconfig/

fetch.rs

//! auth/commconfig/fetch — fetch_all 主入口 + SharedCommConfig + empty_snapshot + spawn_refresher
//! (v1.4.110 CC Batch M: 拆自 commconfig.rs L666-869 + 1050-1121)

use std::collections::HashMap;
use std::sync::Arc;

use super::parsers::{
    fetch_page, parse_auth_guaranteed_domain_list, parse_forced_ip, parse_guaranteed_ip,
    parse_web_tcp_config_identity, value_kind,
};
use super::types::{
    AuthGuaranteedDomainMap, CommonConfigSnapshot, ForcedIpMap, GuaranteedBrokerIpMap,
    GuaranteedIpMap, GuaranteedWebIpMap,
};
use arc_swap::ArcSwap;

pub async fn fetch_all(
    http: &reqwest::Client,
    client_type: u8,
    device_id: &str,
    user_id: u64,
    svr_time_offset: i64,
) -> CommonConfigSnapshot {
    let mut guaranteed_ip: GuaranteedIpMap = HashMap::new();
    let mut guaranteed_ip_broker: GuaranteedBrokerIpMap = HashMap::new();
    let mut guaranteed_ip_web: GuaranteedWebIpMap = HashMap::new();
    let mut web_conn_identity: Option<u32> = None;
    let mut auth_guaranteed_domains: AuthGuaranteedDomainMap = HashMap::new();
    let mut auth_guaranteed_domains_configured = false;
    let mut forced_ip: ForcedIpMap = HashMap::new();
    let mut next_refresh_ts: i64 = 0;
    let mut begin_id: i32 = -1; // C++ 首次 `OMLParam param(-1)`
    let max_pages = 20;

    for page in 0..max_pages {
        let json = match fetch_page(
            http,
            client_type,
            device_id,
            user_id,
            begin_id,
            svr_time_offset,
        )
        .await
        {
            Ok(j) => j,
            Err(e) => {
                tracing::warn!(error = %e, page, "commconfig: fetch page failed, giving up");
                break;
            }
        };

        // C++ NNBiz_CommonConfig.cpp:105 无 ret_code 直接丢
        let ret_code = json.get("ret_code").and_then(|v| v.as_i64());
        if ret_code != Some(0) {
            tracing::warn!(
                ret_code = ?ret_code,
                msg = ?json.get("ret_msg").and_then(|v| v.as_str()),
                "commconfig: non-zero ret_code, abort"
            );
            break;
        }

        let data = match json.get("data").and_then(|v| v.as_object()) {
            Some(d) => d,
            None => {
                tracing::warn!("commconfig: response missing `data` object");
                break;
            }
        };

        // conf_info.<name> → value（形态可能是 string / array / null，
        // parse_guaranteed_ip 三态都能处理）
        if let Some(conf_info) = data.get("conf_info").and_then(|v| v.as_object()) {
            if let Some(val) = conf_info.get("guaranteed_ip_for_conn") {
                tracing::debug!(
                    kind = value_kind(val),
                    "commconfig: guaranteed_ip_for_conn received"
                );
                let (platform_map, broker_map, web_map) = parse_guaranteed_ip(val);
                // Platform 跨页去重合并
                for (attr, pool) in platform_map {
                    let slot = guaranteed_ip.entry(attr).or_default();
                    for ip in pool {
                        if !slot.contains(&ip) {
                            slot.push(ip);
                        }
                    }
                }
                // Broker 跨页去重合并
                for (broker_id, pool) in broker_map {
                    let slot = guaranteed_ip_broker.entry(broker_id).or_default();
                    for ip in pool {
                        if !slot.contains(&ip) {
                            slot.push(ip);
                        }
                    }
                }
                // WebTCP-short 跨页去重合并
                for (identity, pool) in web_map {
                    let slot = guaranteed_ip_web.entry(identity).or_default();
                    for ip in pool {
                        if !slot.contains(&ip) {
                            slot.push(ip);
                        }
                    }
                }
            }

            if let Some(val) = conf_info.get("web_tcp_config") {
                tracing::debug!(
                    kind = value_kind(val),
                    "commconfig: web_tcp_config received"
                );
                if let Some(identity) = parse_web_tcp_config_identity(val) {
                    web_conn_identity = Some(identity);
                    tracing::info!(
                        identity,
                        "commconfig: web_tcp_config.web_conn_identity loaded"
                    );
                }
            }

            if let Some(val) = conf_info.get("auth_guaranteed_domain_list") {
                tracing::debug!(
                    kind = value_kind(val),
                    "commconfig: auth_guaranteed_domain_list received"
                );
                let (domains, configured) = parse_auth_guaranteed_domain_list(val);
                auth_guaranteed_domains_configured |= configured;
                for (domain, retry_domain) in domains {
                    auth_guaranteed_domains.insert(domain, retry_domain);
                }
            }

            // v1.4.22：forced_ip_for_conn —— 最高优先级 IP，带过期时间
            // 对齐 C++ `address.cpp:360-400` ParseForcedIpConfig
            if let Some(val) = conf_info.get("forced_ip_for_conn") {
                tracing::debug!(
                    kind = value_kind(val),
                    "commconfig: forced_ip_for_conn received"
                );
                let page_map = parse_forced_ip(val);
                for (attr, entry) in page_map {
                    // 跨页取 expire 更晚的那条（更新鲜）
                    let existing = forced_ip.get(&attr);
                    if existing.is_none_or(|e| e.expire_ts < entry.expire_ts) {
                        forced_ip.insert(attr, entry);
                    }
                }
            }
        }

        let control = data.get("config_control").and_then(|v| v.as_object());
        if let Some(c) = control
            && let Some(limit) = c.get("limit_time").and_then(|v| v.as_i64())
        {
            let now = chrono::Utc::now().timestamp();
            next_refresh_ts = now + limit;
        }

        // 分页判断——和 C++ `NNBiz_CommonConfig.cpp:153-160` 对齐
        let has_more = control
            .and_then(|c| c.get("has_more"))
            .and_then(|v| v.as_bool())
            .unwrap_or(false);
        if !has_more {
            break;
        }
        let next_id = control
            .and_then(|c| c.get("next_id"))
            .and_then(|v| v.as_i64())
            .unwrap_or(0);
        begin_id = next_id as i32;
    }

    tracing::info!(
        platform_pools = guaranteed_ip.len(),
        broker_pools = guaranteed_ip_broker.len(),
        web_pools = guaranteed_ip_web.len(),
        web_conn_identity,
        auth_retry_domains = auth_guaranteed_domains.len(),
        auth_retry_domain_configured = auth_guaranteed_domains_configured,
        forced_count = forced_ip.len(),
        "commconfig: fetched"
    );
    CommonConfigSnapshot {
        guaranteed_ip,
        guaranteed_ip_broker,
        guaranteed_ip_web,
        web_conn_identity,
        auth_guaranteed_domains,
        auth_guaranteed_domains_configured,
        forced_ip,
        next_refresh_ts,
    }
}

/// 一个 `ArcSwap` 缓存槽——Bridge 持有，重连/后台刷新器共享。
/// `load()` 无锁读，`store(Arc::new(new))` 原子替换。
pub type SharedCommConfig = Arc<ArcSwap<CommonConfigSnapshot>>;

/// 生成一个空 snapshot —— 用于 `SharedCommConfig` 初始化 / fallback。
pub fn empty_snapshot() -> CommonConfigSnapshot {
    CommonConfigSnapshot {
        guaranteed_ip: HashMap::new(),
        guaranteed_ip_broker: HashMap::new(),
        guaranteed_ip_web: HashMap::new(),
        web_conn_identity: None,
        auth_guaranteed_domains: HashMap::new(),
        auth_guaranteed_domains_configured: false,
        forced_ip: HashMap::new(),
        next_refresh_ts: 0,
    }
}