irosh 0.1.0

SSH sessions over Iroh peer-to-peer transport
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

use tokio::process::Command;

use crate::error::{Result, ServerError, TransportError};
use crate::transport::stream::IrohDuplex;
use crate::transport::transfer::{
    CwdResponse, ExistsRequest, ExistsResponse, TransferFailure, TransferFailureCode,
    write_cwd_response, write_exists_response, write_transfer_error,
};

use super::{LiveShellContext, resolve_remote_path};

pub(super) async fn handle_exists_request(
    stream: &mut IrohDuplex,
    request: ExistsRequest,
    shell_pid: Option<u32>,
) -> Result<()> {
    let resolved = resolve_remote_path(&request.path)?;
    let helper_path = resolved.display().to_string();

    let mut exists_cmd = Command::new("test");
    if let Some(shell) = LiveShellContext::from_pid(shell_pid) {
        let exists = shell.path_exists(&helper_path).await?;
        write_exists_response(stream, &ExistsResponse { exists })
            .await
            .map_err(TransportError::from)?;
        return Ok(());
    }
    exists_cmd.arg("-e").arg(&helper_path);
    let status = exists_cmd
        .status()
        .await
        .map_err(|e| ServerError::ShellError {
            details: format!("probing remote existence without live shell failed: {e}"),
        })?;
    write_exists_response(
        stream,
        &ExistsResponse {
            exists: status.success(),
        },
    )
    .await
    .map_err(TransportError::from)?;
    Ok(())
}

pub(super) async fn handle_cwd_request(
    stream: &mut IrohDuplex,
    shell_pid: Option<u32>,
) -> Result<()> {
    let Some(shell) = LiveShellContext::from_pid(shell_pid) else {
        write_transfer_error(
            stream,
            &TransferFailure::new(
                TransferFailureCode::RemoteShellUnavailable,
                "no live shell process",
            ),
        )
        .await
        .map_err(TransportError::from)?;
        return Ok(());
    };

    let cwd = shell.cwd().await?;
    write_cwd_response(
        stream,
        &CwdResponse {
            path: cwd.display().to_string(),
        },
    )
    .await
    .map_err(TransportError::from)?;
    Ok(())
}