qcp 0.8.3

Secure remote file copy utility which uses the QUIC protocol over UDP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Subprocess management (client side)
// (c) 2024-2025 Ross Younger

use std::process::Stdio;

use tokio::process::{ChildStderr, ChildStdin, ChildStdout, Command};

use anyhow::{Result, anyhow};
use tracing::warn;

use crate::protocol::common::SendReceivePair;
use crate::protocol::common::{ReceivingStream, SendingStream};

/// A child process (usually ssh) that implements the connection to the remote
#[derive(Debug, derive_more::Constructor)]
pub(crate) struct ProcessWrapper {
    process: tokio::process::Child,
}

impl Drop for ProcessWrapper {
    fn drop(&mut self) {
        // Tidy up as best we can.
        if let Ok(Some(_)) = self.process.try_wait() {
            return;
        }
        let _ = self
            .process
            .start_kill()
            .map_err(|e| warn!("killing connection process: {e}"));
        let _ = self
            .process
            .try_wait()
            .map_err(|e| warn!("reaping connection process: {e}"));
    }
}

impl SendingStream for ChildStdin {}
impl ReceivingStream for ChildStdout {}

impl ProcessWrapper {
    /// Wraps a [`tokio::process::Command`] with our stream wrapper.
    pub(crate) fn spawn(mut cmd: Command) -> Result<Self> {
        let process = cmd
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .spawn()
            .map_err(|e| anyhow!("could not spawn child process: {e}"))?;
        Ok(Self { process })
    }

    /// Accessor for the child process stderr.
    /// Note that this only works once; future calls return None.
    pub(crate) fn stderr(&mut self) -> Option<ChildStderr> {
        self.process.stderr.take()
    }

    /// A reasonably controlled shutdown.
    /// (If you don't mind being rough, simply drop the [`ProcessWrapper`].)
    pub(crate) async fn close(&mut self) -> Result<()> {
        // wait() closes the child process stdin
        let _ = self.process.wait().await?;
        Ok(())
    }

    /// Accessor for the communication channels.
    /// Note that this can only be called once; future calls error.
    pub(crate) fn stream_pair(&mut self) -> Result<SendReceivePair<ChildStdin, ChildStdout>> {
        let sp = SendReceivePair::from((
            self.process
                .stdin
                .take()
                .ok_or_else(|| anyhow!("could not access process stdin"))?,
            self.process
                .stdout
                .take()
                .ok_or_else(|| anyhow!("could not access process stdout"))?,
        ));
        Ok(sp)
    }
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod test {
    #[cfg(unix)]
    #[tokio::test]
    async fn drop_coverage() {
        let process = tokio::process::Command::new("sleep")
            .arg("100")
            .spawn()
            .expect("could not spawn sleep command");
        let wrapper = super::ProcessWrapper { process };
        drop(wrapper);
    }
}