kfk 0.1.2

A pure Rust Kafka CLI tool for cluster management, topic operations, and message produce/consume
use crate::cli::args::{ConsumeArgs, OffsetValue, OutputFormat};
use crate::cli::output;
use crate::client::{AdminClient, CliResult, create_consumer};
use std::time::Duration;
use uuid::Uuid;

pub async fn handle_consume(args: ConsumeArgs, admin: AdminClient) {
    let result = consume_impl(args, admin).await;
    if let Err(e) = result {
        output::print_err(e);
    }
}

async fn consume_impl(args: ConsumeArgs, admin: AdminClient) -> CliResult<()> {
    let offset = match args.offset {
        OffsetValue::Earliest => kafka_client::AutoOffsetReset::Earliest,
        OffsetValue::Latest => kafka_client::AutoOffsetReset::Latest,
    };

    // 自动生成随机消费组,避免 rebalance 等待
    let group = if args.group.eq_ignore_ascii_case("random") {
        let g = format!("kfk-{}", Uuid::new_v4());
        output::print_note(format!("Using random group: {g}"));
        g
    } else {
        args.group.clone()
    };

    let client = admin.client();
    let mut consumer = create_consumer(client, &group, offset).await?;

    consumer
        .subscribe(vec![args.topic.clone()])
        .await
        .map_err(|e| format!("Failed to subscribe: {e}"))?;

    output::print_ok(format!(
        "Consuming from '{}' (group: {}, offset: {})",
        args.topic, group, args.offset
    ));

    let pretty_output = args.output == OutputFormat::Pretty;
    let tail = args.tail;
    let mut consumed = 0;
    let mut empty_polls = 0u32;

    loop {
        match consumer.poll_timeout(Duration::from_millis(1000)).await {
            Ok(records) => {
                if records.is_empty() {
                    if tail.is_some() {
                        // --tail 模式:消费完后若持续 15 秒无数据则退出
                        if consumed > 0 {
                            empty_polls += 1;
                            if empty_polls >= 15 {
                                break;
                            }
                        }
                        continue;
                    }
                    // 无限模式:持续轮询,永不因无数据退出
                    continue;
                }

                for r in records {
                    if let Some(n) = tail {
                        if consumed >= n {
                            admin.close().await?;
                            return Ok(());
                        }
                    }

                    if pretty_output {
                        let record_json = serde_json::json!({
                            "topic": r.topic,
                            "partition": r.partition,
                            "offset": r.offset,
                            "timestamp": r.timestamp,
                            "key": r.key.as_ref().map(|k| String::from_utf8_lossy(k).to_string()),
                            "payload": String::from_utf8_lossy(&r.value),
                            "headers": r.headers.iter().map(|h| {
                                serde_json::json!({
                                    "key": h.key,
                                    "value": String::from_utf8_lossy(&h.value)
                                })
                            }).collect::<Vec<_>>(),
                        });
                        let json_str = serde_json::to_string_pretty(&record_json)
                            .unwrap_or_else(|_| record_json.to_string());
                        match colored_json::to_colored_json(
                            &record_json,
                            colored_json::ColorMode::On,
                        ) {
                            Ok(colored) => println!("{colored}"),
                            Err(_) => println!("{json_str}"),
                        }
                    } else {
                        println!("{}", String::from_utf8_lossy(&r.value));
                    }
                    consumed += 1;
                }
            }
            Err(e) => {
                eprintln!("Poll error: {e}");
                break;
            }
        }
    }

    admin.close().await?;
    Ok(())
}