The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
//! Remote files over SFTP. Remote paths are POSIX strings.
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
use russh_sftp::client::SftpSession;
use russh_sftp::client::error::Error as SftpError;
use russh_sftp::protocol::{FileAttributes, OpenFlags, StatusCode};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
/// A remote directory entry.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteEntry {
pub name: String,
/// Absolute remote path.
pub path: String,
pub is_dir: bool,
pub is_symlink: bool,
pub size: u64,
/// Seconds since the Unix epoch.
pub mtime: Option<u32>,
/// `rwxr-xr-x`.
pub permissions: String,
}
/// `dir/name` without doubling the separator.
pub fn join(dir: &str, name: &str) -> String {
if name.starts_with('/') {
return name.to_owned();
}
let dir = dir.trim_end_matches('/');
if dir.is_empty() && !name.is_empty() { format!("/{name}") } else { format!("{dir}/{name}") }
}
/// The parent of a remote path (`/` for top-level entries).
pub fn parent(path: &str) -> Option<&str> {
let trimmed = path.trim_end_matches('/');
let i = trimmed.rfind('/')?;
Some(if i == 0 { "/" } else { &trimmed[..i] })
}
pub(crate) fn mode_string(mode: u32) -> String {
let bits = [
(0o400, 'r'),
(0o200, 'w'),
(0o100, 'x'),
(0o40, 'r'),
(0o20, 'w'),
(0o10, 'x'),
(0o4, 'r'),
(0o2, 'w'),
(0o1, 'x'),
];
bits.iter().map(|&(b, c)| if mode & b != 0 { c } else { '-' }).collect()
}
fn entry(path: String, name: String, attrs: &FileAttributes, target_is_dir: bool) -> RemoteEntry {
RemoteEntry {
name,
path,
is_dir: attrs.is_dir() || target_is_dir,
is_symlink: attrs.is_symlink(),
size: attrs.size.unwrap_or(0),
mtime: attrs.mtime,
permissions: attrs.permissions.map(mode_string).unwrap_or_default(),
}
}
fn err(path: &str, e: SftpError) -> IdeError {
let kind = match &e {
SftpError::Status(s) if s.status_code == StatusCode::NoSuchFile => ErrorKind::NotFound,
SftpError::Status(s) if s.status_code == StatusCode::PermissionDenied => ErrorKind::PermissionDenied,
_ => ErrorKind::Io,
};
IdeError::new(kind, format!("{path}: {e}"))
}
/// Higher-level operations on an [`SftpSession`].
pub struct SftpFs {
sftp: SftpSession,
}
impl SftpFs {
pub fn new(sftp: SftpSession) -> Self {
Self { sftp }
}
/// The login directory.
pub async fn home(&self) -> IdeResult<String> {
self.sftp.canonicalize(".").await.map_err(|e| err(".", e))
}
/// Absolute form of `path`; `~` and `~/…` are relative to the login directory.
pub async fn resolve(&self, path: &str) -> IdeResult<String> {
let path = path.trim();
if path.is_empty() || path == "~" {
return self.home().await;
}
if let Some(rest) = path.strip_prefix("~/") {
return Ok(join(&self.home().await?, rest));
}
if path.starts_with('/') {
return Ok(path.to_owned());
}
Ok(join(&self.home().await?, path))
}
pub async fn stat(&self, path: &str) -> IdeResult<Option<RemoteEntry>> {
match self.sftp.metadata(path).await {
Ok(a) => {
let name = path.rsplit('/').next().unwrap_or(path).to_owned();
Ok(Some(entry(path.to_owned(), name, &a, false)))
}
Err(e) if err(path, e.clone()).kind == ErrorKind::NotFound => Ok(None),
Err(e) => Err(err(path, e)),
}
}
/// Entries of `dir`, folders first, then by name; symlinks to folders count as folders.
pub async fn list(&self, dir: &str) -> IdeResult<Vec<RemoteEntry>> {
let read = self.sftp.read_dir(dir).await.map_err(|e| err(dir, e))?;
let mut out = Vec::new();
for e in read {
let name = e.file_name();
// A name with `/` (from a hostile server) would point elsewhere once joined.
if name == "." || name == ".." || name.contains('/') {
continue;
}
let path = join(dir, &name);
let attrs = e.metadata();
let target_is_dir =
attrs.is_symlink() && self.sftp.metadata(path.as_str()).await.map(|m| m.is_dir()).unwrap_or(false);
out.push(entry(path, name, &attrs, target_is_dir));
}
out.sort_by(|a, b| b.is_dir.cmp(&a.is_dir).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())));
Ok(out)
}
pub async fn read(&self, path: &str) -> IdeResult<Vec<u8>> {
let mut file = self.sftp.open(path).await.map_err(|e| err(path, e))?;
let mut buf = Vec::new();
file.read_to_end(&mut buf).await?;
Ok(buf)
}
/// Writes `data`, creating missing parent folders.
pub async fn write(&self, path: &str, data: &[u8], mtime: Option<u32>) -> IdeResult<()> {
if let Some(dir) = parent(path) {
self.mkdir_all(dir).await?;
}
let mut file = self.sftp.create(path).await.map_err(|e| err(path, e))?;
file.write_all(data).await?;
file.shutdown().await?;
if let Some(t) = mtime {
let attrs = FileAttributes { atime: Some(t), mtime: Some(t), ..FileAttributes::empty() };
if let Err(e) = self.sftp.set_metadata(path, attrs).await {
tracing::debug!("SFTP: cannot set the time of {path}: {e}");
}
}
Ok(())
}
pub async fn upload(&self, local: &Path, remote: &str, preserve_time: bool) -> IdeResult<()> {
let data = tokio::fs::read(local).await?;
let mtime = if preserve_time { mtime_of(local) } else { None };
self.write(remote, &data, mtime).await
}
/// Imports a local file without replacing an existing remote entry.
pub async fn upload_new(&self, local: &Path, remote: &str, cancel: &CancellationToken) -> IdeResult<()> {
let mut input = tokio::fs::File::open(local).await?;
let mut output = self
.sftp
.open_with_flags(remote, OpenFlags::WRITE | OpenFlags::CREATE | OpenFlags::EXCLUDE)
.await
.map_err(|e| err(remote, e))?;
let result = crate::filesystem::copy_stream(&mut input, &mut output, cancel).await;
let closed = output.shutdown().await.map_err(IdeError::from);
drop(output);
let result = async {
result.and(closed)?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = input.metadata().await?.permissions().mode() & 0o7777;
self.sftp
.set_metadata(remote, FileAttributes { permissions: Some(mode), ..FileAttributes::empty() })
.await
.map_err(|e| err(remote, e))?;
}
Ok(())
}
.await;
if result.is_err() {
let _ = self.sftp.remove_file(remote).await;
}
result
}
pub async fn symlink(&self, target: &str, link: &str) -> IdeResult<()> {
self.sftp.symlink(target, link).await.map_err(|e| err(link, e))
}
pub async fn create_dir(&self, path: &str) -> IdeResult<()> {
self.sftp.create_dir(path).await.map_err(|e| err(path, e))
}
pub async fn download(&self, remote: &str, local: &Path) -> IdeResult<()> {
let data = self.read(remote).await?;
if let Some(dir) = local.parent() {
tokio::fs::create_dir_all(dir).await?;
}
tokio::fs::write(local, data).await?;
Ok(())
}
/// `mkdir -p`.
pub async fn mkdir_all(&self, dir: &str) -> IdeResult<()> {
if dir.is_empty() || dir == "/" {
return Ok(());
}
match self.sftp.metadata(dir).await {
Ok(a) if a.is_dir() => return Ok(()),
Ok(_) => return Err(IdeError::new(ErrorKind::AlreadyExists, format!("{dir} is not a folder"))),
Err(_) => {}
}
if let Some(p) = parent(dir) {
Box::pin(self.mkdir_all(p)).await?;
}
match self.sftp.create_dir(dir).await {
Ok(()) => Ok(()),
// Created meanwhile by a concurrent upload.
Err(_) if self.sftp.metadata(dir).await.is_ok_and(|a| a.is_dir()) => Ok(()),
Err(e) => Err(err(dir, e)),
}
}
/// Deletes a file, or a folder with its contents.
pub async fn remove(&self, path: &str) -> IdeResult<()> {
let attrs = self.sftp.symlink_metadata(path).await.map_err(|e| err(path, e))?;
if attrs.is_dir() {
for e in self.list(path).await? {
if e.is_dir && !e.is_symlink {
Box::pin(self.remove(&e.path)).await?;
} else {
self.sftp.remove_file(e.path.as_str()).await.map_err(|x| err(&e.path, x))?;
}
}
self.sftp.remove_dir(path).await.map_err(|e| err(path, e))
} else {
self.sftp.remove_file(path).await.map_err(|e| err(path, e))
}
}
pub async fn rename(&self, from: &str, to: &str) -> IdeResult<()> {
self.sftp.rename(from, to).await.map_err(|e| err(from, e))
}
pub async fn close(&self) {
let _ = self.sftp.close().await;
}
}
/// Seconds since the epoch of a local file's modification.
pub fn mtime_of(path: &Path) -> Option<u32> {
let t = std::fs::metadata(path).ok()?.modified().ok()?;
u32::try_from(t.duration_since(std::time::UNIX_EPOCH).ok()?.as_secs()).ok()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn joins_and_splits_paths() {
assert_eq!(join("/srv/app/", "a.txt"), "/srv/app/a.txt");
assert_eq!(join("/", "etc"), "/etc");
assert_eq!(join("/x", "/abs"), "/abs");
assert_eq!(parent("/srv/app/a.txt"), Some("/srv/app"));
assert_eq!(parent("/etc"), Some("/"));
assert_eq!(parent("rel"), None);
assert_eq!(mode_string(0o755), "rwxr-xr-x");
}
}