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,
};
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() {
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(())
}