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
74
75
76
77
78
79

use crate::client::Session;
use crate::error::{ClientError, Result, TransportError};
use crate::transport::stream::IrohDuplex;
use crate::transport::transfer::{
    CwdRequest, ExistsRequest, TransferFrame, read_next_frame, write_cwd_request,
    write_exists_request,
};

impl Session {
    /// Queries the current working directory of the live remote shell process for this session.
    pub async fn remote_cwd(&self) -> Result<std::path::PathBuf> {
        let mut stream = self.open_transfer_stream("remote cwd unavailable").await?;

        write_cwd_request(&mut stream, &CwdRequest)
            .await
            .map_err(TransportError::from)?;
        let res = read_next_frame(&mut stream)
            .await
            .map_err(TransportError::from)?;
        match res {
            TransferFrame::CwdResponse(res) => Ok(std::path::PathBuf::from(res.path)),
            TransferFrame::Error(details) => Err(ClientError::TransferRejected {
                details: details.to_string(),
            }
            .into()),
            other => Err(ClientError::TransferFailed {
                details: format!("remote cwd failed with unexpected frame: {other:?}"),
            }
            .into()),
        }
    }

    /// Checks if a file or directory exists on the remote system.
    pub async fn remote_exists(&self, path: &std::path::Path) -> Result<bool> {
        let mut stream = self
            .open_transfer_stream("remote exists unavailable")
            .await?;

        write_exists_request(
            &mut stream,
            &ExistsRequest {
                path: path.display().to_string(),
            },
        )
        .await
        .map_err(TransportError::from)?;
        let res = read_next_frame(&mut stream)
            .await
            .map_err(TransportError::from)?;
        match res {
            TransferFrame::ExistsResponse(res) => Ok(res.exists),
            TransferFrame::Error(details) => Err(ClientError::TransferRejected {
                details: details.to_string(),
            }
            .into()),
            other => Err(ClientError::TransferFailed {
                details: format!("remote exists failed with unexpected frame: {other:?}"),
            }
            .into()),
        }
    }

    pub(crate) async fn open_transfer_stream(
        &self,
        unavailable_context: &'static str,
    ) -> Result<IrohDuplex> {
        let connection =
            self.connection
                .as_ref()
                .ok_or_else(|| ClientError::TransportUnavailable {
                    details: unavailable_context,
                })?;
        let (send, recv) = connection
            .open_bi()
            .await
            .map_err(|source| ClientError::StreamOpenFailed { source })?;
        Ok(IrohDuplex::new(send, recv))
    }
}