rs_transfer 8.0.0

A simple crate to handle downloads and uploads on multiple providers
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

use crate::{error::Error, secret::SftpSecret};
use ssh_transfer::{AuthenticationType, Configuration, Connection, KnownHost};
use std::{
  convert::TryFrom,
  sync::{Arc, Mutex},
};

#[derive(Clone)]
pub struct SftpEndpoint {
  connection: Arc<Mutex<Connection>>,
  root_directory: String,
}

unsafe impl Sync for SftpEndpoint {}

impl TryFrom<&SftpSecret> for SftpEndpoint {
  type Error = Error;

  fn try_from(secret: &SftpSecret) -> Result<Self, Self::Error> {
    let connection = Self::connect(secret)?;
    let connection = Arc::new(Mutex::new(connection));
    Ok(Self {
      connection,
      root_directory: secret
        .root_directory
        .clone()
        .unwrap_or_else(|| "/".to_string()),
    })
  }
}

impl SftpEndpoint {
  fn connect(secret: &SftpSecret) -> Result<Connection, Error> {
    log::debug!(
      "Attempting to connect to {}:{}.",
      secret.hostname(),
      secret.port()
    );

    let authentication_type = if let Some(password) = secret.password() {
      AuthenticationType::Password(password)
    } else if let Some(private_key) = secret.private_key() {
      AuthenticationType::KeyMemory(private_key)
    } else if let Some(private_key_file_path) = &secret.private_key_file_path() {
      AuthenticationType::KeyFile(private_key_file_path.into())
    } else {
      AuthenticationType::Agent
    };

    let configuration = Configuration::new(secret.hostname())
      .with_port(secret.port())
      .with_username(secret.username())
      .with_authentication(authentication_type);

    let mut connection = Connection::new(&configuration)?;

    if let Some(known_host) = &secret.known_host() {
      let known_host = KnownHost::try_from(known_host.as_str())?;
      connection.add_known_host(&known_host)?;
    }

    connection.start()?;

    Ok(connection)
  }

  pub fn connection(&self) -> Arc<Mutex<Connection>> {
    self.connection.clone()
  }

  pub fn absolute_path(&self, path: &str) -> String {
    format!(
      "{}/{}",
      self.root_directory.trim_end_matches('/'),
      path.trim_start_matches('/')
    )
  }
}