Monitor ADB device presence and withdraw stale registrations in 0.2.6
This commit is contained in:
1 parent
03e729a60b
commit
dc29a20a41
17 files changed
+488
-23
No files matched your search
@@ -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
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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)
|
||||
}
|
||||
Reference in new issue
Block a user