Function topology

cake-core/src/cake/sharding/api/ui.rs:85–203

Return cluster topology as JSON.

(
    state: web::Data<Arc<RwLock<Master<M>>>>,
    req: HttpRequest,
)

/// Return cluster topology as JSON.
pub async fn topology<M: Model>(
    state: web::Data<Arc<RwLock<Master<M>>>>,
    req: HttpRequest,
) -> HttpResponse {
    if !check_ui_auth(&state, &req).await {
        return HttpResponse::Unauthorized()
            .insert_header(("WWW-Authenticate", "Basic realm=\"cake\""))
            .body("Unauthorized");
    }

    let master = state.read().await;
    let ctx = &master.ctx;

    let num_layers = ctx
        .config
        .as_ref()
        .map(|c| c.num_hidden_layers)
        .unwrap_or(0);

    // Estimate per-layer size from safetensors index
    let layer_size_bytes = estimate_layer_size(&ctx.data_path, num_layers);

    // Collect worker layers from topology
    let mut worker_layer_set = HashSet::new();
    let mut workers = Vec::new();

    for (name, node) in ctx.topology.iter() {
        for layer in &node.layers {
            worker_layer_set.insert(layer.clone());
        }
        workers.push(WorkerTopologyInfo {
            name: name.clone(),
            host: node.host.clone(),
            description: node.description.clone(),
            layers: node.layers.clone(),
            vram_bytes: node.vram_bytes,
            tflops: node.tflops,
            backend: node.backend.clone(),
            hostname: node.hostname.clone(),
            os: node.os.clone(),
        });
    }

    // Derive layer prefix from config
    let layer_prefix = ctx
        .config
        .as_ref()
        .map(|c| format!("{}.layers", c.model_prefix))
        .unwrap_or_else(|| "model.layers".to_string());

    // Master layers = all layers not assigned to workers
    let master_layers: Vec<String> = (0..num_layers)
        .map(|i| format!("{layer_prefix}.{i}"))
        .filter(|l| !worker_layer_set.contains(l))
        .collect();

    let device = if ctx.device.is_cuda() {
        "cuda"