91 lines
3.1 KiB
Rust
91 lines
3.1 KiB
Rust
mod adb_monitor;
|
|
mod gateway;
|
|
mod managed;
|
|
mod supervisor;
|
|
use ads_core::{valid_device_id, validate_token, NetworkArgs};
|
|
use ads_management::{credential, AgentConfig};
|
|
use anyhow::{bail, Context, Result};
|
|
use clap::Parser;
|
|
use std::{path::PathBuf, sync::Arc};
|
|
|
|
#[derive(Parser)]
|
|
#[command(
|
|
version,
|
|
about = "ADS agent: managed multi-device gateway or legacy single-device worker"
|
|
)]
|
|
struct Args {
|
|
#[command(flatten)]
|
|
network: NetworkArgs,
|
|
#[arg(long, env = "ADS_AGENT_TOKEN", hide_env_values = true)]
|
|
token: Option<String>,
|
|
#[arg(long)]
|
|
config: Option<PathBuf>,
|
|
/// Supervise the headless child; required for management restart
|
|
#[arg(long, requires = "config")]
|
|
supervise: bool,
|
|
/// Retain managed logs in memory without console output
|
|
#[arg(long)]
|
|
quiet: bool,
|
|
#[arg(long)]
|
|
device: Option<String>,
|
|
#[arg(long, conflicts_with = "adb_serial")]
|
|
target: Option<String>,
|
|
#[arg(long)]
|
|
adb_serial: Option<String>,
|
|
#[arg(long, default_value = "127.0.0.1:5037")]
|
|
adb_server: String,
|
|
#[arg(long, default_value_t = 5555)]
|
|
device_port: u16,
|
|
}
|
|
#[tokio::main]
|
|
async fn main() -> Result<()> {
|
|
let args = Args::parse();
|
|
if args.quiet {
|
|
std::env::set_var("ADS_LOG_STDOUT", "0");
|
|
}
|
|
if let Some(path) = args.config {
|
|
if args.device.is_some() || args.target.is_some() || args.adb_serial.is_some() {
|
|
bail!("managed config cannot be combined with single-device arguments")
|
|
}
|
|
let path = std::fs::canonicalize(path).context("agent config not found")?;
|
|
if args.supervise {
|
|
return supervisor::run(path).await;
|
|
}
|
|
let config = AgentConfig::load(&path)?;
|
|
let token = match args.token {
|
|
Some(value) => value,
|
|
None => credential(&path.with_file_name("agent.env"), "ADS_AGENT_TOKEN")?,
|
|
};
|
|
validate_token(&token)?;
|
|
let restart = managed::run(path, config, token).await?;
|
|
if restart {
|
|
std::process::exit(75)
|
|
}
|
|
} else {
|
|
ads_core::init_logging();
|
|
let token = args.token.context("provide ADS_AGENT_TOKEN")?;
|
|
validate_token(&token)?;
|
|
let device = args.device.context("provide --device or --config")?;
|
|
if !valid_device_id(&device) || args.target.is_none() == args.adb_serial.is_none() {
|
|
bail!("valid device and exactly one of --target / --adb-serial are required")
|
|
}
|
|
args.network.url("/v1/agent", &[])?;
|
|
let monitor = args
|
|
.adb_serial
|
|
.as_ref()
|
|
.map(|_| adb_monitor::Monitor::start(args.adb_server.clone()));
|
|
let worker = gateway::Gateway {
|
|
adb_presence: monitor.as_ref().map(|m| m.receiver.clone()),
|
|
network: args.network,
|
|
token,
|
|
device,
|
|
target: args.target,
|
|
adb_serial: args.adb_serial,
|
|
adb_server: args.adb_server,
|
|
device_port: args.device_port,
|
|
};
|
|
tokio::select! {_=gateway::run(Arc::new(worker),None)=>{},result=tokio::signal::ctrl_c()=>{result?;}}
|
|
}
|
|
Ok(())
|
|
}
|