feat: add headless agent management to CLI and both desktop clients
This commit is contained in:
1 parent
e91fa0235c
commit
6916dd54fb
50 files changed
+4837
-148
No files matched your search
@@ -10,3 +10,12 @@ anyhow.workspace = true
|
||||
clap.workspace = true
|
||||
tokio.workspace = true
|
||||
tracing.workspace = true
|
||||
ads-management = { path = "../crates/ads-management" }
|
||||
serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
tracing-subscriber.workspace = true
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Security", "Win32_System_JobObjects", "Win32_System_Threading"] }
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
libc = "0.2"
|
||||
@@ -0,0 +1,126 @@
|
||||
use ads_core::{adb_tcp_connect, dial, next_control, relay, tcp_connect, NetworkArgs};
|
||||
use anyhow::{bail, Context, Result};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
use tokio::{net::TcpStream, task::JoinSet, time::sleep};
|
||||
use tracing::{info, warn};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Gateway {
|
||||
pub network: NetworkArgs,
|
||||
pub token: String,
|
||||
pub device: String,
|
||||
pub target: Option<String>,
|
||||
pub adb_serial: Option<String>,
|
||||
pub adb_server: String,
|
||||
pub device_port: u16,
|
||||
}
|
||||
#[derive(Default, Clone)]
|
||||
pub struct Health {
|
||||
pub connected: bool,
|
||||
pub last_error: Option<String>,
|
||||
}
|
||||
pub type WorkerHealth = Arc<std::sync::Mutex<Health>>;
|
||||
async fn upstream(args: &Gateway) -> Result<TcpStream> {
|
||||
match &args.target {
|
||||
Some(address) => tcp_connect(address).await,
|
||||
None => {
|
||||
adb_tcp_connect(
|
||||
&args.adb_server,
|
||||
args.adb_serial.as_deref().context("missing serial")?,
|
||||
args.device_port,
|
||||
)
|
||||
.await
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn serve_session(
|
||||
args: Arc<Gateway>,
|
||||
session: String,
|
||||
signal_key: Option<String>,
|
||||
) -> Result<()> {
|
||||
let tcp = upstream(&args).await.context("cannot reach phone adbd")?;
|
||||
if let Some(key) = signal_key {
|
||||
let signal = dial(
|
||||
args.network
|
||||
.url("/v2/signal", &[("session", &session), ("key", &key)])?,
|
||||
&args.token,
|
||||
args.network.connect_address.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
return ads_core::transport::agent_session(tcp, signal, &args.network).await;
|
||||
}
|
||||
let ws = dial(
|
||||
args.network.url(
|
||||
"/v1/data",
|
||||
&[("device", &args.device), ("session", &session)],
|
||||
)?,
|
||||
&args.token,
|
||||
args.network.connect_address.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
relay(tcp, ws).await
|
||||
}
|
||||
|
||||
async fn online(args: Arc<Gateway>, health: &Option<WorkerHealth>) -> Result<()> {
|
||||
let mut ws = dial(
|
||||
args.network
|
||||
.url("/v1/agent", &[("device", &args.device), ("v", "2")])?,
|
||||
&args.token,
|
||||
args.network.connect_address.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
let hello = next_control(&mut ws).await?;
|
||||
if hello.kind != "registered" {
|
||||
bail!("expected registered response");
|
||||
}
|
||||
if let Some(health) = health {
|
||||
let mut state = health.lock().unwrap_or_else(|e| e.into_inner());
|
||||
state.connected = true;
|
||||
state.last_error = None;
|
||||
}
|
||||
info!(device = %args.device, "gateway registered");
|
||||
let mut tasks = JoinSet::new();
|
||||
loop {
|
||||
tokio::select! {
|
||||
message = next_control(&mut ws) => {
|
||||
let message = message?;
|
||||
if message.kind != "open" && message.kind != "open_v2" { bail!("unexpected gateway control message"); }
|
||||
let signal_key = if message.kind == "open_v2" { Some(message.signal_key.context("missing signal key")?) } else { None };
|
||||
let session = message.session.context("missing session ticket")?;
|
||||
if tasks.len() >= 32 { warn!("gateway stream limit reached"); continue; }
|
||||
let args = args.clone();
|
||||
let health = health.clone();
|
||||
tasks.spawn(async move {
|
||||
let device=args.device.clone();
|
||||
if let Err(error) = serve_session(args, session, signal_key).await {
|
||||
if let Some(health)=health {health.lock().unwrap_or_else(|e|e.into_inner()).last_error=Some(error.to_string());}
|
||||
warn!(%device,%error, "device stream ended");
|
||||
}
|
||||
});
|
||||
},
|
||||
_ = tasks.join_next(), if !tasks.is_empty() => {},
|
||||
}
|
||||
}
|
||||
// JoinSet drop aborts all streams when the control connection is lost.
|
||||
}
|
||||
|
||||
pub async fn run(args: Arc<Gateway>, health: Option<WorkerHealth>) {
|
||||
let mut delay = 1;
|
||||
loop {
|
||||
let started = std::time::Instant::now();
|
||||
if let Err(error) = online(args.clone(), &health).await {
|
||||
if let Some(health) = &health {
|
||||
let mut state = health.lock().unwrap_or_else(|e| e.into_inner());
|
||||
state.connected = false;
|
||||
state.last_error = Some(error.to_string());
|
||||
}
|
||||
warn!(device=%args.device,%error, "gateway offline; reconnecting");
|
||||
}
|
||||
if started.elapsed() > Duration::from_secs(30) {
|
||||
delay = 1;
|
||||
}
|
||||
sleep(Duration::from_secs(delay)).await;
|
||||
delay = (delay * 2).min(30);
|
||||
}
|
||||
}
|
||||
+57
-113
@@ -1,34 +1,34 @@
|
||||
use ads_core::{
|
||||
adb_tcp_connect, dial, init_logging, next_control, relay, tcp_connect, valid_device_id,
|
||||
validate_token, NetworkArgs,
|
||||
};
|
||||
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::{sync::Arc, time::Duration};
|
||||
use tokio::{net::TcpStream, task::JoinSet, time::sleep};
|
||||
use tracing::{info, warn};
|
||||
use std::{path::PathBuf, sync::Arc};
|
||||
|
||||
#[derive(Parser)]
|
||||
#[command(
|
||||
version,
|
||||
about = "Remote device gateway: outbound-only connection to the ADS relay"
|
||||
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: String,
|
||||
/// Stable public device alias, e.g. home-phone
|
||||
token: Option<String>,
|
||||
#[arg(long)]
|
||||
device: String,
|
||||
/// Direct phone adbd address reachable from this gateway, e.g. 192.168.100.141:5555
|
||||
#[arg(
|
||||
long,
|
||||
required_unless_present = "adb_serial",
|
||||
conflicts_with = "adb_serial"
|
||||
)]
|
||||
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>,
|
||||
/// Alternative: choose a transport from an existing ADB server (phone must have TCP adbd enabled)
|
||||
#[arg(long)]
|
||||
adb_serial: Option<String>,
|
||||
#[arg(long, default_value = "127.0.0.1:5037")]
|
||||
@@ -36,105 +36,49 @@ struct Args {
|
||||
#[arg(long, default_value_t = 5555)]
|
||||
device_port: u16,
|
||||
}
|
||||
|
||||
async fn upstream(args: &Args) -> Result<TcpStream> {
|
||||
match &args.target {
|
||||
Some(address) => tcp_connect(address).await,
|
||||
None => {
|
||||
adb_tcp_connect(
|
||||
&args.adb_server,
|
||||
args.adb_serial.as_deref().context("missing serial")?,
|
||||
args.device_port,
|
||||
)
|
||||
.await
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn serve_session(args: Arc<Args>, session: String, signal_key: Option<String>) -> Result<()> {
|
||||
let tcp = upstream(&args).await.context("cannot reach phone adbd")?;
|
||||
if let Some(key) = signal_key {
|
||||
let signal = dial(
|
||||
args.network
|
||||
.url("/v2/signal", &[("session", &session), ("key", &key)])?,
|
||||
&args.token,
|
||||
args.network.connect_address.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
return ads_core::transport::agent_session(tcp, signal, &args.network).await;
|
||||
}
|
||||
let ws = dial(
|
||||
args.network.url(
|
||||
"/v1/data",
|
||||
&[("device", &args.device), ("session", &session)],
|
||||
)?,
|
||||
&args.token,
|
||||
args.network.connect_address.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
relay(tcp, ws).await
|
||||
}
|
||||
|
||||
async fn online(args: Arc<Args>) -> Result<()> {
|
||||
let mut ws = dial(
|
||||
args.network
|
||||
.url("/v1/agent", &[("device", &args.device), ("v", "2")])?,
|
||||
&args.token,
|
||||
args.network.connect_address.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
let hello = next_control(&mut ws).await?;
|
||||
if hello.kind != "registered" {
|
||||
bail!("expected registered response");
|
||||
}
|
||||
info!(device = %args.device, "gateway registered");
|
||||
let mut tasks = JoinSet::new();
|
||||
loop {
|
||||
tokio::select! {
|
||||
message = next_control(&mut ws) => {
|
||||
let message = message?;
|
||||
if message.kind != "open" && message.kind != "open_v2" { bail!("unexpected gateway control message"); }
|
||||
let signal_key = if message.kind == "open_v2" { Some(message.signal_key.context("missing signal key")?) } else { None };
|
||||
let session = message.session.context("missing session ticket")?;
|
||||
if tasks.len() >= 32 { warn!("gateway stream limit reached"); continue; }
|
||||
let args = args.clone();
|
||||
tasks.spawn(async move {
|
||||
if let Err(error) = serve_session(args, session, signal_key).await { warn!(%error, "device stream ended"); }
|
||||
});
|
||||
},
|
||||
_ = tasks.join_next(), if !tasks.is_empty() => {},
|
||||
}
|
||||
}
|
||||
// JoinSet drop aborts all streams when the control connection is lost.
|
||||
}
|
||||
|
||||
async fn run(args: Arc<Args>) {
|
||||
let mut delay = 1;
|
||||
loop {
|
||||
let started = std::time::Instant::now();
|
||||
if let Err(error) = online(args.clone()).await {
|
||||
warn!(%error, "gateway offline; reconnecting");
|
||||
}
|
||||
if started.elapsed() > Duration::from_secs(30) {
|
||||
delay = 1;
|
||||
}
|
||||
sleep(Duration::from_secs(delay)).await;
|
||||
delay = (delay * 2).min(30);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<()> {
|
||||
init_logging();
|
||||
let args = Args::parse();
|
||||
validate_token(&args.token)?;
|
||||
if !valid_device_id(&args.device) {
|
||||
bail!("invalid device ID (use letters, digits, -, _, .; max 128 bytes)");
|
||||
if args.quiet {
|
||||
std::env::set_var("ADS_LOG_STDOUT", "0");
|
||||
}
|
||||
args.network.url("/v1/agent", &[])?;
|
||||
tokio::select! {
|
||||
_ = run(Arc::new(args)) => {},
|
||||
result = tokio::signal::ctrl_c() => { result?; info!("gateway stopping"); },
|
||||
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 worker = gateway::Gateway {
|
||||
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(())
|
||||
}
|
||||
@@ -0,0 +1,374 @@
|
||||
use crate::gateway::{self, Gateway, Health, WorkerHealth};
|
||||
use ads_management::{
|
||||
now, read_ws, write_ws, AgentConfig, AgentStatus, DeviceStatus, LogEntry, LogPage, Request,
|
||||
Response,
|
||||
};
|
||||
use anyhow::{bail, Context, Result};
|
||||
use serde::Deserialize;
|
||||
use std::{
|
||||
collections::{BTreeMap, VecDeque},
|
||||
path::PathBuf,
|
||||
sync::{Arc, Mutex},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
use tokio::{
|
||||
sync::{watch, Mutex as AsyncMutex},
|
||||
task::JoinHandle,
|
||||
time::{interval, sleep},
|
||||
};
|
||||
use tracing_subscriber::{
|
||||
layer::{Context as LayerContext, SubscriberExt},
|
||||
util::SubscriberInitExt,
|
||||
Layer,
|
||||
};
|
||||
struct Logs {
|
||||
entries: VecDeque<LogEntry>,
|
||||
next: u64,
|
||||
secret: String,
|
||||
instance: String,
|
||||
}
|
||||
#[derive(Clone)]
|
||||
struct LogLayer(Arc<Mutex<Logs>>);
|
||||
struct Visitor(String);
|
||||
impl tracing::field::Visit for Visitor {
|
||||
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
|
||||
if !self.0.is_empty() {
|
||||
self.0.push(' ')
|
||||
};
|
||||
self.0.push_str(field.name());
|
||||
self.0.push('=');
|
||||
self.0.push_str(&format!("{value:?}"));
|
||||
}
|
||||
}
|
||||
impl<S: tracing::Subscriber> Layer<S> for LogLayer {
|
||||
fn on_event(&self, event: &tracing::Event<'_>, _: LayerContext<'_, S>) {
|
||||
let mut visitor = Visitor(String::new());
|
||||
event.record(&mut visitor);
|
||||
let mut logs = self.0.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let message = visitor
|
||||
.0
|
||||
.replace(&logs.secret, "[REDACTED]")
|
||||
.chars()
|
||||
.take(1024)
|
||||
.collect();
|
||||
let entry = LogEntry {
|
||||
seq: logs.next,
|
||||
time: now(),
|
||||
level: event.metadata().level().to_string(),
|
||||
message,
|
||||
};
|
||||
logs.next += 1;
|
||||
logs.entries.push_back(entry);
|
||||
while logs.entries.len() > 500 {
|
||||
logs.entries.pop_front();
|
||||
}
|
||||
}
|
||||
}
|
||||
struct Worker {
|
||||
config: ads_management::DeviceConfig,
|
||||
health: WorkerHealth,
|
||||
task: JoinHandle<()>,
|
||||
}
|
||||
impl Drop for Worker {
|
||||
fn drop(&mut self) {
|
||||
self.task.abort();
|
||||
}
|
||||
}
|
||||
struct State {
|
||||
config: AgentConfig,
|
||||
workers: BTreeMap<String, Worker>,
|
||||
revision: u64,
|
||||
}
|
||||
struct Runtime {
|
||||
path: PathBuf,
|
||||
state: AsyncMutex<State>,
|
||||
token: String,
|
||||
logs: Arc<Mutex<Logs>>,
|
||||
started: Instant,
|
||||
restart: watch::Sender<bool>,
|
||||
supervised: bool,
|
||||
instance: String,
|
||||
}
|
||||
impl Runtime {
|
||||
fn reconcile(&self, state: &mut State) {
|
||||
let network = state.config.network();
|
||||
let adb_server = state.config.adb_server.clone();
|
||||
state.workers.retain(|id, worker| {
|
||||
state
|
||||
.config
|
||||
.devices
|
||||
.iter()
|
||||
.any(|d| d.enabled && d.id == *id && *d == worker.config)
|
||||
});
|
||||
for device in &state.config.devices {
|
||||
if !device.enabled || state.workers.contains_key(&device.id) {
|
||||
continue;
|
||||
}
|
||||
let health = Arc::new(Mutex::new(Health::default()));
|
||||
let gateway = Gateway {
|
||||
network: network.clone(),
|
||||
token: self.token.clone(),
|
||||
device: device.id.clone(),
|
||||
target: device.target.clone(),
|
||||
adb_serial: device.adb_serial.clone(),
|
||||
adb_server: device
|
||||
.adb_server
|
||||
.clone()
|
||||
.unwrap_or_else(|| adb_server.clone()),
|
||||
device_port: device.device_port,
|
||||
};
|
||||
let task = tokio::spawn(gateway::run(Arc::new(gateway), Some(health.clone())));
|
||||
state.workers.insert(
|
||||
device.id.clone(),
|
||||
Worker {
|
||||
config: device.clone(),
|
||||
health,
|
||||
task,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
async fn status(&self) -> AgentStatus {
|
||||
let state = self.state.lock().await;
|
||||
let devices = state
|
||||
.config
|
||||
.devices
|
||||
.iter()
|
||||
.map(|config| {
|
||||
let health = state
|
||||
.workers
|
||||
.get(&config.id)
|
||||
.map(|w| w.health.lock().unwrap_or_else(|e| e.into_inner()).clone())
|
||||
.unwrap_or_default();
|
||||
DeviceStatus {
|
||||
config: config.clone(),
|
||||
connected: health.connected,
|
||||
last_error: health
|
||||
.last_error
|
||||
.map(|e| e.replace(&self.token, "[REDACTED]")),
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
AgentStatus {
|
||||
id: state.config.id.clone(),
|
||||
name: state.config.name.clone(),
|
||||
hostname: std::env::var("COMPUTERNAME")
|
||||
.or_else(|_| std::env::var("HOSTNAME"))
|
||||
.unwrap_or_else(|_| "unknown".into()),
|
||||
os: std::env::consts::OS.into(),
|
||||
arch: std::env::consts::ARCH.into(),
|
||||
version: env!("CARGO_PKG_VERSION").into(),
|
||||
pid: std::process::id(),
|
||||
uptime_seconds: self.started.elapsed().as_secs(),
|
||||
supervised: self.supervised,
|
||||
revision: state.revision,
|
||||
instance: self.instance.clone(),
|
||||
devices,
|
||||
}
|
||||
}
|
||||
async fn execute(&self, request: Request) -> Result<Response> {
|
||||
match request {
|
||||
Request::Status => Ok(Response::success(self.status().await)),
|
||||
Request::DevicesList => Ok(Response::success(self.status().await.devices)),
|
||||
Request::ConfigGet => Ok(Response::success(&self.state.lock().await.config)),
|
||||
Request::Logs { after, limit } => {
|
||||
let logs = self.logs.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let after = if after >= logs.next { 0 } else { after };
|
||||
let entries: Vec<_> = logs
|
||||
.entries
|
||||
.iter()
|
||||
.filter(|e| e.seq > after)
|
||||
.take(if limit == 0 { 50 } else { limit.min(50) } as usize)
|
||||
.cloned()
|
||||
.collect();
|
||||
Ok(Response::success(LogPage {
|
||||
instance: logs.instance.clone(),
|
||||
next: entries.last().map(|e| e.seq).unwrap_or(after),
|
||||
entries,
|
||||
}))
|
||||
}
|
||||
Request::Restart => {
|
||||
if !self.supervised {
|
||||
bail!("restart requires --supervise or an installed managed service")
|
||||
};
|
||||
let sender = self.restart.clone();
|
||||
tokio::spawn(async move {
|
||||
sleep(Duration::from_millis(500)).await;
|
||||
let _ = sender.send(true);
|
||||
});
|
||||
Ok(Response::success(serde_json::json!({"restarting":true})))
|
||||
}
|
||||
mutation => {
|
||||
let mut state = self.state.lock().await;
|
||||
let mut config = state.config.clone();
|
||||
match mutation {
|
||||
Request::DeviceAdd { device } => {
|
||||
if config.devices.iter().any(|d| d.id == device.id) {
|
||||
bail!("device ID already exists")
|
||||
};
|
||||
config.devices.push(device);
|
||||
}
|
||||
Request::DeviceRemove { id } => {
|
||||
let count = config.devices.len();
|
||||
config.devices.retain(|d| d.id != id);
|
||||
if count == config.devices.len() {
|
||||
bail!("device not found")
|
||||
}
|
||||
}
|
||||
Request::DeviceEnable { id, enabled } => {
|
||||
config
|
||||
.devices
|
||||
.iter_mut()
|
||||
.find(|d| d.id == id)
|
||||
.context("device not found")?
|
||||
.enabled = enabled;
|
||||
}
|
||||
Request::ConfigSet { config: new } => {
|
||||
if new.id != config.id {
|
||||
bail!("agent ID is immutable; initialize a separate agent to change identity")
|
||||
};
|
||||
config = new;
|
||||
}
|
||||
_ => bail!("unsupported operation"),
|
||||
}
|
||||
config.validate()?;
|
||||
let changed_network = config.server != state.config.server
|
||||
|| config.connect_address != state.config.connect_address
|
||||
|| config.allow_insecure != state.config.allow_insecure
|
||||
|| config.adb_server != state.config.adb_server;
|
||||
ads_management::save_private(&self.path, &serde_json::to_vec_pretty(&config)?)?;
|
||||
if changed_network {
|
||||
state.workers.clear();
|
||||
}
|
||||
state.config = config;
|
||||
state.revision += 1;
|
||||
self.reconcile(&mut state);
|
||||
tracing::info!(revision = state.revision, "agent configuration applied");
|
||||
Ok(Response::success(
|
||||
serde_json::json!({"revision":state.revision}),
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
async fn handle(&self, request: Request) -> Response {
|
||||
match self.execute(request).await {
|
||||
Ok(value) => value,
|
||||
Err(error) => Response::failure(error.to_string().replace(&self.token, "[REDACTED]")),
|
||||
}
|
||||
}
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct Incoming {
|
||||
#[serde(rename = "type")]
|
||||
kind: String,
|
||||
#[serde(default)]
|
||||
request_id: String,
|
||||
request: Option<Request>,
|
||||
}
|
||||
async fn online(runtime: Arc<Runtime>) -> Result<()> {
|
||||
let config = runtime.state.lock().await.config.clone();
|
||||
let network = config.network();
|
||||
let mut ws = ads_core::dial(
|
||||
network.url("/v3/agents/register", &[("agent", &config.id)])?,
|
||||
&runtime.token,
|
||||
network.connect_address.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
let hello: serde_json::Value = read_ws(&mut ws).await?;
|
||||
if hello["type"] != "registered" {
|
||||
bail!("invalid management registration")
|
||||
}
|
||||
tracing::info!(agent=%config.id,"agent management connected");
|
||||
let mut heartbeat = interval(Duration::from_secs(5));
|
||||
loop {
|
||||
tokio::select! {
|
||||
message=read_ws::<Incoming>(&mut ws)=>{
|
||||
let message=message?;if message.kind!="request"||message.request_id.is_empty(){bail!("unexpected management message")}
|
||||
let response=runtime.handle(message.request.context("missing request")?).await;
|
||||
write_ws(&mut ws,&serde_json::json!({"type":"result","request_id":message.request_id,"response":response})).await?;
|
||||
},
|
||||
_=heartbeat.tick()=>{
|
||||
let latest=runtime.state.lock().await.config.clone();
|
||||
if latest.server!=config.server||latest.connect_address!=config.connect_address||latest.allow_insecure!=config.allow_insecure{bail!("management address changed")}
|
||||
write_ws(&mut ws,&serde_json::json!({"type":"status","status":runtime.status().await})).await?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
pub async fn run(path: PathBuf, config: AgentConfig, token: String) -> Result<bool> {
|
||||
let instance = format!(
|
||||
"{}-{}-{}",
|
||||
now(),
|
||||
std::process::id(),
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)?
|
||||
.subsec_nanos()
|
||||
);
|
||||
let logs = Arc::new(Mutex::new(Logs {
|
||||
entries: VecDeque::new(),
|
||||
next: 1,
|
||||
secret: token.clone(),
|
||||
instance: instance.clone(),
|
||||
}));
|
||||
tracing_subscriber::registry()
|
||||
.with(
|
||||
tracing_subscriber::EnvFilter::try_from_default_env()
|
||||
.unwrap_or_else(|_| "ads_agent=info,ads_core=info,warn".into()),
|
||||
)
|
||||
.with(
|
||||
tracing_subscriber::fmt::layer()
|
||||
.with_ansi(false)
|
||||
.with_filter(tracing_subscriber::filter::filter_fn(|_| {
|
||||
std::env::var("ADS_LOG_STDOUT").as_deref() != Ok("0")
|
||||
})),
|
||||
)
|
||||
.with(LogLayer(logs.clone()))
|
||||
.init();
|
||||
let (restart, mut restarting) = watch::channel(false);
|
||||
let runtime = Arc::new(Runtime {
|
||||
path: path.clone(),
|
||||
state: AsyncMutex::new(State {
|
||||
config,
|
||||
workers: BTreeMap::new(),
|
||||
revision: 1,
|
||||
}),
|
||||
token,
|
||||
logs,
|
||||
started: Instant::now(),
|
||||
restart,
|
||||
supervised: std::env::var("ADS_SUPERVISED").as_deref() == Ok("1"),
|
||||
instance,
|
||||
});
|
||||
let handler: ads_management::ipc::Handler = {
|
||||
let runtime = runtime.clone();
|
||||
Arc::new(move |request| {
|
||||
let runtime = runtime.clone();
|
||||
Box::pin(async move { runtime.handle(request).await })
|
||||
})
|
||||
};
|
||||
// Bind IPC before starting phone workers, so a duplicate process cannot steal devices.
|
||||
let (ready_tx, ready_rx) = tokio::sync::oneshot::channel();
|
||||
let ipc = ads_management::ipc::serve(&path, handler, ready_tx);
|
||||
tokio::pin!(ipc);
|
||||
let networking = async {
|
||||
if ready_rx.await.is_err() {
|
||||
std::future::pending::<()>().await;
|
||||
}
|
||||
{
|
||||
let mut state = runtime.state.lock().await;
|
||||
runtime.reconcile(&mut state);
|
||||
}
|
||||
let mut delay = 1;
|
||||
loop {
|
||||
if let Err(error) = online(runtime.clone()).await {
|
||||
tracing::warn!(%error,"management offline; reconnecting")
|
||||
};
|
||||
sleep(Duration::from_secs(delay)).await;
|
||||
delay = (delay * 2).min(30);
|
||||
}
|
||||
};
|
||||
tokio::pin!(networking);
|
||||
let restart = tokio::select! {result=&mut ipc=>{result?;false},_=&mut networking=>false,result=restarting.changed()=>{result?;sleep(Duration::from_millis(400)).await;true},result=crate::supervisor::shutdown()=>{result?;false}};
|
||||
runtime.state.lock().await.workers.clear();
|
||||
Ok(restart)
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
use ads_management::AgentConfig;
|
||||
#[cfg(windows)]
|
||||
use anyhow::Context;
|
||||
use anyhow::Result;
|
||||
use std::{path::PathBuf, time::Duration};
|
||||
pub async fn shutdown() -> Result<()> {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
let mut term = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())?;
|
||||
tokio::select! {value=tokio::signal::ctrl_c()=>{value?;},_=term.recv()=>{}}
|
||||
}
|
||||
#[cfg(windows)]
|
||||
tokio::signal::ctrl_c().await?;
|
||||
Ok(())
|
||||
}
|
||||
pub async fn run(path: PathBuf) -> Result<()> {
|
||||
AgentConfig::load(&path)?;
|
||||
let executable = std::env::current_exe()?;
|
||||
let mut delay = 1;
|
||||
#[cfg(windows)]
|
||||
let job = Job::new()?;
|
||||
loop {
|
||||
let mut command = tokio::process::Command::new(&executable);
|
||||
command
|
||||
.arg("--config")
|
||||
.arg(&path)
|
||||
.env("ADS_SUPERVISED", "1")
|
||||
.env("ADS_SUPERVISOR_PID", std::process::id().to_string())
|
||||
.kill_on_drop(true);
|
||||
#[cfg(windows)]
|
||||
command.creation_flags(0x08000000);
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
let parent = std::process::id() as libc::pid_t;
|
||||
unsafe {
|
||||
command.pre_exec(move || {
|
||||
if libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM) != 0 {
|
||||
return Err(std::io::Error::last_os_error());
|
||||
}
|
||||
if libc::getppid() != parent {
|
||||
return Err(std::io::Error::other(
|
||||
"supervisor exited before child startup",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
});
|
||||
}
|
||||
}
|
||||
let mut child = command.spawn()?;
|
||||
#[cfg(windows)]
|
||||
if let Err(error) = job.assign(
|
||||
child
|
||||
.raw_handle()
|
||||
.context("child process handle unavailable")?,
|
||||
) {
|
||||
let _ = child.kill().await;
|
||||
return Err(error);
|
||||
}
|
||||
let result = tokio::select! {
|
||||
result=child.wait()=>result?,
|
||||
result=shutdown()=>{
|
||||
result?;
|
||||
#[cfg(unix)]if let Some(pid)=child.id(){unsafe{libc::kill(pid as libc::pid_t,libc::SIGTERM);}}
|
||||
#[cfg(unix)]if tokio::time::timeout(Duration::from_secs(3),child.wait()).await.is_ok(){return Ok(())}
|
||||
let _=child.kill().await;return Ok(())
|
||||
}
|
||||
};
|
||||
if result.success() {
|
||||
return Ok(());
|
||||
}
|
||||
if result.code() == Some(75) {
|
||||
delay = 1;
|
||||
continue;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_secs(delay)).await;
|
||||
delay = (delay * 2).min(30);
|
||||
}
|
||||
}
|
||||
#[cfg(windows)]
|
||||
struct Job(windows_sys::Win32::Foundation::HANDLE);
|
||||
#[cfg(windows)]
|
||||
impl Job {
|
||||
fn new() -> Result<Self> {
|
||||
use windows_sys::Win32::System::JobObjects::*;
|
||||
let handle = unsafe { CreateJobObjectW(std::ptr::null(), std::ptr::null()) };
|
||||
if handle.is_null() {
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
}
|
||||
let job = Self(handle);
|
||||
let mut info: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = unsafe { std::mem::zeroed() };
|
||||
info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
|
||||
if unsafe {
|
||||
SetInformationJobObject(
|
||||
handle,
|
||||
JobObjectExtendedLimitInformation,
|
||||
&info as *const _ as _,
|
||||
std::mem::size_of_val(&info) as u32,
|
||||
)
|
||||
} == 0
|
||||
{
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
};
|
||||
Ok(job)
|
||||
}
|
||||
fn assign(&self, child: std::os::windows::io::RawHandle) -> Result<()> {
|
||||
if unsafe {
|
||||
windows_sys::Win32::System::JobObjects::AssignProcessToJobObject(self.0, child as _)
|
||||
} == 0
|
||||
{
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
};
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
#[cfg(windows)]
|
||||
impl Drop for Job {
|
||||
fn drop(&mut self) {
|
||||
unsafe { windows_sys::Win32::Foundation::CloseHandle(self.0) };
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user