Monitor ADB device presence and withdraw stale registrations in 0.2.6

This commit is contained in:
tongtong committed 2026-11-13 21:55:45 +08:00
1 parent 03e729a60b
commit dc29a20a41
17 files changed
+488 -23

No files matched your search

+86
View File
@@ -0,0 +1,86 @@
//! One bounded ADB snapshot query per server, shared by all configured phones.
use std::{collections::BTreeMap, time::Duration};
use tokio::{sync::watch, task::JoinHandle};
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Snapshot {
Pending,
Unavailable(String),
Devices(BTreeMap<String, String>),
}
impl Snapshot {
pub fn error_for(&self, serial: &str) -> Option<String> {
match self {
Self::Pending => Some("正在确认 ADB 设备状态".into()),
Self::Unavailable(error) => Some(format!("ADB 服务不可达:{error}")),
Self::Devices(devices) => match devices.get(serial).map(String::as_str) {
Some("device") => None,
Some("unauthorized") => Some("ADB 设备未授权,请在手机上允许 USB 调试".into()),
Some(state) => Some(format!("ADB 设备不可用:{state}")),
None => Some("ADB 未发现该设备:USB 已拔出或 ADB 连接已断开".into()),
},
}
}
pub fn parse(text: &str) -> Self {
Self::Devices(
text.lines()
.filter_map(|line| {
let mut fields = line.split_whitespace();
Some((fields.next()?.to_owned(), fields.next()?.to_owned()))
})
.collect(),
)
}
}
pub struct Monitor {
pub receiver: watch::Receiver<Snapshot>,
task: JoinHandle<()>,
}
impl Monitor {
pub fn start(server: String) -> Self {
let (sender, receiver) = watch::channel(Snapshot::Pending);
let task = tokio::spawn(async move {
loop {
// ads_core bounds connection and response reads to five seconds.
let next = match ads_core::adb_devices(&server).await {
Ok(text) => Snapshot::parse(&text),
Err(error) => Snapshot::Unavailable(format!("{error:#}")),
};
sender.send_if_modified(|current| {
if *current == next {
false
} else {
*current = next;
true
}
});
tokio::time::sleep(Duration::from_secs(2)).await;
}
});
Self { receiver, task }
}
}
impl Drop for Monitor {
fn drop(&mut self) {
self.task.abort();
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_authorized_online_serials_are_available() {
let snapshot =
Snapshot::parse("ready\tdevice product:pixel\nlocked\tunauthorized\nlost\toffline\n");
assert!(snapshot.error_for("ready").is_none());
assert!(snapshot.error_for("locked").unwrap().contains("未授权"));
assert!(snapshot.error_for("lost").unwrap().contains("offline"));
assert!(snapshot.error_for("missing").unwrap().contains("未发现"));
assert!(Snapshot::Pending.error_for("ready").is_some());
assert!(Snapshot::Unavailable("stopped".into())
.error_for("ready")
.is_some());
}
}
+68 -8
View File
@@ -6,6 +6,7 @@ use tracing::{info, warn};
#[derive(Clone)]
pub struct Gateway {
pub adb_presence: Option<tokio::sync::watch::Receiver<crate::adb_monitor::Snapshot>>,
pub network: NetworkArgs,
pub token: String,
pub device: String,
@@ -62,7 +63,17 @@ async fn serve_session(
relay(tcp, ws).await
}
async fn probe_target(args: &Gateway) -> Result<()> {
if let Some(target) = &args.target {
let stream = tokio::time::timeout(Duration::from_secs(3), tcp_connect(target))
.await
.context("设备 TCP 连接检查超时")??;
drop(stream);
}
Ok(())
}
async fn online(args: Arc<Gateway>, health: &Option<WorkerHealth>) -> Result<()> {
probe_target(&args).await?;
let mut ws = dial(
args.network
.url("/v1/agent", &[("device", &args.device), ("v", "2")])?,
@@ -81,6 +92,9 @@ async fn online(args: Arc<Gateway>, health: &Option<WorkerHealth>) -> Result<()>
}
info!(device = %args.device, "gateway registered");
let mut tasks = JoinSet::new();
let mut target_check = tokio::time::interval(Duration::from_secs(5));
target_check.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
target_check.tick().await;
loop {
tokio::select! {
message = next_control(&mut ws) => {
@@ -100,27 +114,73 @@ async fn online(args: Arc<Gateway>, health: &Option<WorkerHealth>) -> Result<()>
});
},
_ = tasks.join_next(), if !tasks.is_empty() => {},
_ = target_check.tick(), if args.target.is_some() => {probe_target(&args).await?;},
}
}
// JoinSet drop aborts all streams when the control connection is lost.
}
fn offline(health: &Option<WorkerHealth>, error: String) {
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);
}
}
async fn wait_until_unavailable(
receiver: &mut tokio::sync::watch::Receiver<crate::adb_monitor::Snapshot>,
serial: &str,
) -> String {
loop {
let error = receiver.borrow_and_update().error_for(serial);
if let Some(error) = error {
return error;
}
if receiver.changed().await.is_err() {
return "ADB 监听已停止".into();
}
}
}
pub async fn run(args: Arc<Gateway>, health: Option<WorkerHealth>) {
let mut presence = args.adb_presence.clone();
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(format!("{error:#}"));
if let Some(receiver) = &mut presence {
loop {
let error = receiver
.borrow_and_update()
.error_for(args.adb_serial.as_deref().unwrap_or_default());
let Some(error) = error else { break };
offline(&health, error);
if receiver.changed().await.is_err() {
return;
}
}
warn!(device=%args.device,%error, "gateway offline; reconnecting");
}
let started = std::time::Instant::now();
let result = if let Some(receiver) = &mut presence {
tokio::select! {
result=online(args.clone(),&health)=>result,
error=wait_until_unavailable(receiver,args.adb_serial.as_deref().unwrap_or_default())=>Err(anyhow::anyhow!(error)),
}
} else {
online(args.clone(), &health).await
};
if let Err(error) = result {
offline(&health, format!("{error:#}"));
warn!(device=%args.device,%error,"gateway offline; reconnecting");
}
if started.elapsed() > Duration::from_secs(30) {
delay = 1;
}
sleep(Duration::from_secs(delay)).await;
if let Some(receiver) = &mut presence {
tokio::select! {
_=sleep(Duration::from_secs(delay))=>{},
result=receiver.changed()=>{if result.is_err(){return;}delay=1;},
}
} else {
sleep(Duration::from_secs(delay)).await;
}
delay = (delay * 2).min(30);
}
}
+6
View File
@@ -1,3 +1,4 @@
mod adb_monitor;
mod gateway;
mod managed;
mod supervisor;
@@ -69,7 +70,12 @@ async fn main() -> Result<()> {
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,
+29 -1
View File
@@ -78,6 +78,7 @@ struct State {
config: AgentConfig,
workers: BTreeMap<String, Worker>,
revision: u64,
monitors: BTreeMap<String, crate::adb_monitor::Monitor>,
}
struct Runtime {
path: PathBuf,
@@ -93,6 +94,25 @@ impl Runtime {
fn reconcile(&self, state: &mut State) {
let network = state.config.network();
let adb_server = state.config.adb_server.clone();
let servers: std::collections::BTreeSet<_> = state
.config
.devices
.iter()
.filter(|device| device.enabled && device.adb_serial.is_some())
.map(|device| {
device
.adb_server
.clone()
.unwrap_or_else(|| adb_server.clone())
})
.collect();
state.monitors.retain(|server, _| servers.contains(server));
for server in servers {
state
.monitors
.entry(server.clone())
.or_insert_with(|| crate::adb_monitor::Monitor::start(server));
}
state.workers.retain(|id, worker| {
state
.config
@@ -106,6 +126,11 @@ impl Runtime {
}
let health = Arc::new(Mutex::new(Health::default()));
let gateway = Gateway {
adb_presence: device.adb_serial.as_ref().map(|_| {
state.monitors[device.adb_server.as_ref().unwrap_or(&adb_server)]
.receiver
.clone()
}),
network: network.clone(),
token: self.token.clone(),
device: device.id.clone(),
@@ -341,6 +366,7 @@ pub async fn run(path: PathBuf, config: AgentConfig, token: String) -> Result<bo
state: AsyncMutex::new(State {
config,
workers: BTreeMap::new(),
monitors: BTreeMap::new(),
revision: 1,
}),
token,
@@ -380,6 +406,8 @@ pub async fn run(path: PathBuf, config: AgentConfig, token: String) -> Result<bo
};
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();
let mut state = runtime.state.lock().await;
state.workers.clear();
state.monitors.clear();
Ok(restart)
}