use std::path::PathBuf;
use anyhow::{anyhow, Context};
use clap::{Args, Subcommand};
use parachuter::config::SenderState;
use parachuter::control::{ControlClient, LinkOverride, Request, Response};
#[derive(Debug, Args)]
pub struct CtlArgs {
#[arg(short, long)]
socket: PathBuf,
#[command(subcommand)]
cmd: CtlCmd,
}
#[derive(Debug, Subcommand)]
enum CtlCmd {
Ping,
Status,
SetLink {
#[arg(long)]
link: Option<String>,
#[arg(long)]
chunk_size: Option<usize>,
#[arg(long)]
kbps: Option<u64>,
#[arg(long)]
ip: Option<String>,
#[arg(long)]
port: Option<u16>,
},
SetState { state: String },
Submit {
#[arg(long)]
path: PathBuf,
#[arg(long, default_value_t = false)]
interrupt: bool,
},
Enqueue {
#[arg(long)]
file_id: i64,
#[arg(long, default_value_t = -1)]
start: i32,
#[arg(long, default_value_t = 0)]
count: u32,
#[arg(long, default_value_t = false)]
interrupt: bool,
},
ResendName {
#[arg(long)]
file_id: i64,
},
Flush,
CleanerRun,
ReconcileRun,
}
pub async fn run(args: CtlArgs) -> anyhow::Result<()> {
let client = ControlClient::new(&args.socket);
let req = match args.cmd {
CtlCmd::Ping => Request::Ping,
CtlCmd::Status => {
let resp = try_each_status(&client).await?;
println!("{}", serde_json::to_string_pretty(&resp)?);
return Ok(());
}
CtlCmd::SetLink {
link,
chunk_size,
kbps,
ip,
port,
} => Request::SenderConfigure(LinkOverride {
active_link: link,
chunk_size,
max_kbps: kbps,
link_ip: ip,
link_port: port,
}),
CtlCmd::SetState { state } => {
let s = match state.as_str() {
"auto" => SenderState::Auto,
"manual" => SenderState::Manual,
"paused" => SenderState::Paused,
"debug" => SenderState::Debug,
other => return Err(anyhow!("unknown state `{other}`")),
};
Request::SenderSetState(s)
}
CtlCmd::Submit { path, interrupt } => {
let abs = if path.is_absolute() {
path
} else {
std::env::current_dir()?.join(path)
};
Request::SenderSubmit {
path: abs.to_string_lossy().into_owned(),
interrupt,
}
}
CtlCmd::Enqueue {
file_id,
start,
count,
interrupt,
} => Request::SenderEnqueue {
file_id,
start,
count,
interrupt,
},
CtlCmd::ResendName { file_id } => Request::SenderResendName { file_id },
CtlCmd::Flush => Request::SenderFlush,
CtlCmd::CleanerRun => Request::CleanerRunNow,
CtlCmd::ReconcileRun => Request::CleanerReconcileNow,
};
let resp = client.call(req).await.context("control call failed")?;
println!("{}", serde_json::to_string_pretty(&resp)?);
Ok(())
}
async fn try_each_status(client: &ControlClient) -> anyhow::Result<Response> {
let pong = client
.call(Request::Ping)
.await
.context("daemon did not answer ping")?;
let daemon = match &pong {
Response::Pong { daemon, .. } => daemon.clone(),
_ => return Ok(pong),
};
let status_req = match daemon.as_str() {
"sender" => Request::SenderStatus,
"receiver" => Request::ReceiverStatus,
"cleaner" => Request::CleanerStatus,
_ => return Ok(pong),
};
Ok(client.call(status_req).await?)
}