Struct Session

pub struct Session<S: AsyncRead + AsyncWrite>(/* private fields */);

An established and authenticated SSH session.

You can use this session to execute commands on the remote host using Session::open_exec. This will give you back a [Channel], which can be used to read from the resulting process’ STDOUT, or to write the the process’ STDIN.

Implementations

impl<S: AsyncRead + AsyncWrite + Tcp + 'static> Session<S>

pub fn new( stream: S, handle: &Handle, ) -> Result<NewSession<S>, HandlerError<()>>

Establish a new SSH session on top of the given stream.

The resulting SSH session is initially unauthenticated (see NewSession), and must be authenticated before it becomes useful.

Note that the reactor behind the given handle must continue to be driven for any channels created from this Session to work.

Examples found in repository

examples/ls.rs (line 24)

fn main() {
    // async:

    let mut core = tokio_core::reactor::Core::new().unwrap();
    let handle = core.handle();

    let cmd = ::std::env::args().skip(1).next().unwrap();
    let key = thrussh_keys::load_secret_key("/home/jon/aws-test.pem", None).unwrap();

    let ls_out = TcpStream::connect(&"52.23.157.12:22".parse().unwrap(), &handle)
        .map_err(thrussh::Error::IO)
        .map_err(thrussh::HandlerError::Error)
        .and_then(|c| Session::new(c, &handle))
        .and_then(|session| session.authenticate_key("ec2-user", key))
        .and_then(|mut session| session.open_exec(&cmd));

    let channel = core.run(ls_out).unwrap();
    let (channel, data) = core.run(tokio_io::io::read_to_end(channel, Vec::new()))
        .unwrap();
    println!("{}", ::std::str::from_utf8(&data[..]).unwrap());
    let status = core.run(channel.exit_status()).unwrap();
    println!("{}", status);

    /*

    // sync:

    // Connect to the local SSH server
    let tcp = TcpStream::connect("127.0.0.1:22").unwrap();
    let mut sess = Session::new().unwrap();
    sess.handshake(&tcp).unwrap();
    sess.userauth_agent("username").unwrap();

    let mut channel = sess.channel_session().unwrap();
    channel.exec("ls").unwrap();
    let mut s = String::new();
    channel.read_to_string(&mut s).unwrap();
    println!("{}", s);
    channel.wait_close();
    println!("{}", channel.exit_status().unwrap());
    */
}

pub fn last_error(&mut self) -> Option<HandlerError<()>>

Retrieve the last error encountered during this session.

Note that it is unlikely you will be able to use any items associated with this session once it has returned an error.

Calling this method clears the error.

pub fn open_exec<'a>(&mut self, cmd: &'a str) -> ChannelOpenFuture<'a, S>

Establish a new channel over this session to execute the given command.

Note that any errors encountered while operating on the channel after it has been opened will manifest only as reads or writes no longer succeeding. To get the underlying error, call Session::last_error.

Examples found in repository

examples/ls.rs (line 26)

fn main() {
    // async:

    let mut core = tokio_core::reactor::Core::new().unwrap();
    let handle = core.handle();

    let cmd = ::std::env::args().skip(1).next().unwrap();
    let key = thrussh_keys::load_secret_key("/home/jon/aws-test.pem", None).unwrap();

    let ls_out = TcpStream::connect(&"52.23.157.12:22".parse().unwrap(), &handle)
        .map_err(thrussh::Error::IO)
        .map_err(thrussh::HandlerError::Error)
        .and_then(|c| Session::new(c, &handle))
        .and_then(|session| session.authenticate_key("ec2-user", key))
        .and_then(|mut session| session.open_exec(&cmd));

    let channel = core.run(ls_out).unwrap();
    let (channel, data) = core.run(tokio_io::io::read_to_end(channel, Vec::new()))
        .unwrap();
    println!("{}", ::std::str::from_utf8(&data[..]).unwrap());
    let status = core.run(channel.exit_status()).unwrap();
    println!("{}", status);

    /*

    // sync:

    // Connect to the local SSH server
    let tcp = TcpStream::connect("127.0.0.1:22").unwrap();
    let mut sess = Session::new().unwrap();
    sess.handshake(&tcp).unwrap();
    sess.userauth_agent("username").unwrap();

    let mut channel = sess.channel_session().unwrap();
    channel.exec("ls").unwrap();
    let mut s = String::new();
    channel.read_to_string(&mut s).unwrap();
    println!("{}", s);
    channel.wait_close();
    println!("{}", channel.exit_status().unwrap());
    */
}