feat: add headless agent management to CLI and both desktop clients

This commit is contained in:
tongtong committed 2026-11-12 21:17:44 +08:00
1 parent e91fa0235c
commit 6916dd54fb
50 files changed
+4837 -148

No files matched your search

+9
View File
@@ -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"
+126
View File
@@ -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
View File
@@ -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(())
}
+374
View File
@@ -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)
}
+120
View File
@@ -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) };
}
}