127 lines
4.4 KiB
Rust
127 lines
4.4 KiB
Rust
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(format!("{error:#}"));}
|
|
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(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;
|
|
delay = (delay * 2).min(30);
|
|
}
|
|
}
|