1509 lines
48 KiB
Rust
1509 lines
48 KiB
Rust
use crate::{
|
|
RemoteClientDelegate, RemotePlatform,
|
|
remote_client::{CommandTemplate, RemoteConnection, RemoteConnectionOptions},
|
|
};
|
|
use anyhow::{Context as _, Result, anyhow};
|
|
use async_trait::async_trait;
|
|
use collections::HashMap;
|
|
use futures::{
|
|
AsyncReadExt as _, FutureExt as _,
|
|
channel::mpsc::{Sender, UnboundedReceiver, UnboundedSender},
|
|
select_biased,
|
|
};
|
|
use gpui::{App, AppContext as _, AsyncApp, SemanticVersion, Task};
|
|
use parking_lot::Mutex;
|
|
use paths::remote_server_dir_relative;
|
|
use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
|
|
use rpc::proto::Envelope;
|
|
pub use settings::SshPortForwardOption;
|
|
use smol::{
|
|
fs,
|
|
process::{self, Child, Stdio},
|
|
};
|
|
use std::{
|
|
path::{Path, PathBuf},
|
|
sync::Arc,
|
|
time::Instant,
|
|
};
|
|
use tempfile::TempDir;
|
|
use util::{
|
|
paths::{PathStyle, RemotePathBuf},
|
|
rel_path::RelPath,
|
|
shell::ShellKind,
|
|
};
|
|
|
|
pub(crate) struct SshRemoteConnection {
|
|
socket: SshSocket,
|
|
master_process: Mutex<Option<MasterProcess>>,
|
|
remote_binary_path: Option<Arc<RelPath>>,
|
|
ssh_platform: RemotePlatform,
|
|
ssh_path_style: PathStyle,
|
|
ssh_shell: String,
|
|
ssh_shell_kind: ShellKind,
|
|
ssh_default_system_shell: String,
|
|
_temp_dir: TempDir,
|
|
}
|
|
|
|
#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
|
|
pub struct SshConnectionOptions {
|
|
pub host: String,
|
|
pub username: Option<String>,
|
|
pub port: Option<u16>,
|
|
pub password: Option<String>,
|
|
pub args: Option<Vec<String>>,
|
|
pub port_forwards: Option<Vec<SshPortForwardOption>>,
|
|
|
|
pub nickname: Option<String>,
|
|
pub upload_binary_over_ssh: bool,
|
|
}
|
|
|
|
impl From<settings::SshConnection> for SshConnectionOptions {
|
|
fn from(val: settings::SshConnection) -> Self {
|
|
SshConnectionOptions {
|
|
host: val.host.into(),
|
|
username: val.username,
|
|
port: val.port,
|
|
password: None,
|
|
args: Some(val.args),
|
|
nickname: val.nickname,
|
|
upload_binary_over_ssh: val.upload_binary_over_ssh.unwrap_or_default(),
|
|
port_forwards: val.port_forwards,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct SshSocket {
|
|
connection_options: SshConnectionOptions,
|
|
#[cfg(not(target_os = "windows"))]
|
|
socket_path: std::path::PathBuf,
|
|
envs: HashMap<String, String>,
|
|
#[cfg(target_os = "windows")]
|
|
_proxy: askpass::PasswordProxy,
|
|
}
|
|
|
|
struct MasterProcess {
|
|
process: Child,
|
|
}
|
|
|
|
#[cfg(not(target_os = "windows"))]
|
|
impl MasterProcess {
|
|
pub fn new(
|
|
askpass_script_path: &std::ffi::OsStr,
|
|
additional_args: Vec<String>,
|
|
socket_path: &std::path::Path,
|
|
url: &str,
|
|
) -> Result<Self> {
|
|
let args = [
|
|
"-N",
|
|
"-o",
|
|
"ControlPersist=no",
|
|
"-o",
|
|
"ControlMaster=yes",
|
|
"-o",
|
|
];
|
|
|
|
let mut master_process = util::command::new_smol_command("ssh");
|
|
master_process
|
|
.kill_on_drop(true)
|
|
.stdin(Stdio::null())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.env("SSH_ASKPASS_REQUIRE", "force")
|
|
.env("SSH_ASKPASS", askpass_script_path)
|
|
.args(additional_args)
|
|
.args(args);
|
|
|
|
master_process.arg(format!("ControlPath='{}'", socket_path.display()));
|
|
|
|
let process = master_process.arg(&url).spawn()?;
|
|
|
|
Ok(MasterProcess { process })
|
|
}
|
|
|
|
pub async fn wait_connected(&mut self) -> Result<()> {
|
|
let Some(mut stdout) = self.process.stdout.take() else {
|
|
anyhow::bail!("ssh process stdout capture failed");
|
|
};
|
|
|
|
let mut output = Vec::new();
|
|
stdout.read_to_end(&mut output).await?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
impl MasterProcess {
|
|
const CONNECTION_ESTABLISHED_MAGIC: &str = "ZED_SSH_CONNECTION_ESTABLISHED";
|
|
|
|
pub fn new(
|
|
askpass_script_path: &std::ffi::OsStr,
|
|
additional_args: Vec<String>,
|
|
url: &str,
|
|
) -> Result<Self> {
|
|
// On Windows, `ControlMaster` and `ControlPath` are not supported:
|
|
// https://github.com/PowerShell/Win32-OpenSSH/issues/405
|
|
// https://github.com/PowerShell/Win32-OpenSSH/wiki/Project-Scope
|
|
//
|
|
// Using an ugly workaround to detect connection establishment
|
|
// -N doesn't work with JumpHosts as windows openssh never closes stdin in that case
|
|
let args = [
|
|
"-t",
|
|
&format!("echo '{}'; exec $0", Self::CONNECTION_ESTABLISHED_MAGIC),
|
|
];
|
|
|
|
let mut master_process = util::command::new_smol_command("ssh");
|
|
master_process
|
|
.kill_on_drop(true)
|
|
.stdin(Stdio::null())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.env("SSH_ASKPASS_REQUIRE", "force")
|
|
.env("SSH_ASKPASS", askpass_script_path)
|
|
.args(additional_args)
|
|
.arg(url)
|
|
.args(args);
|
|
|
|
let process = master_process.spawn()?;
|
|
|
|
Ok(MasterProcess { process })
|
|
}
|
|
|
|
pub async fn wait_connected(&mut self) -> Result<()> {
|
|
use smol::io::AsyncBufReadExt;
|
|
|
|
let Some(stdout) = self.process.stdout.take() else {
|
|
anyhow::bail!("ssh process stdout capture failed");
|
|
};
|
|
|
|
let mut reader = smol::io::BufReader::new(stdout);
|
|
|
|
let mut line = String::new();
|
|
|
|
loop {
|
|
let n = reader.read_line(&mut line).await?;
|
|
if n == 0 {
|
|
anyhow::bail!("ssh process exited before connection established");
|
|
}
|
|
|
|
if line.contains(Self::CONNECTION_ESTABLISHED_MAGIC) {
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AsRef<Child> for MasterProcess {
|
|
fn as_ref(&self) -> &Child {
|
|
&self.process
|
|
}
|
|
}
|
|
|
|
impl AsMut<Child> for MasterProcess {
|
|
fn as_mut(&mut self) -> &mut Child {
|
|
&mut self.process
|
|
}
|
|
}
|
|
|
|
#[async_trait(?Send)]
|
|
impl RemoteConnection for SshRemoteConnection {
|
|
async fn kill(&self) -> Result<()> {
|
|
let Some(mut process) = self.master_process.lock().take() else {
|
|
return Ok(());
|
|
};
|
|
process.as_mut().kill().ok();
|
|
process.as_mut().status().await?;
|
|
Ok(())
|
|
}
|
|
|
|
fn has_been_killed(&self) -> bool {
|
|
self.master_process.lock().is_none()
|
|
}
|
|
|
|
fn connection_options(&self) -> RemoteConnectionOptions {
|
|
RemoteConnectionOptions::Ssh(self.socket.connection_options.clone())
|
|
}
|
|
|
|
fn shell(&self) -> String {
|
|
self.ssh_shell.clone()
|
|
}
|
|
|
|
fn default_system_shell(&self) -> String {
|
|
self.ssh_default_system_shell.clone()
|
|
}
|
|
|
|
fn build_command(
|
|
&self,
|
|
input_program: Option<String>,
|
|
input_args: &[String],
|
|
input_env: &HashMap<String, String>,
|
|
working_dir: Option<String>,
|
|
port_forward: Option<(u16, String, u16)>,
|
|
) -> Result<CommandTemplate> {
|
|
let Self {
|
|
ssh_path_style,
|
|
socket,
|
|
ssh_shell_kind,
|
|
ssh_shell,
|
|
..
|
|
} = self;
|
|
let env = socket.envs.clone();
|
|
build_command(
|
|
input_program,
|
|
input_args,
|
|
input_env,
|
|
working_dir,
|
|
port_forward,
|
|
env,
|
|
*ssh_path_style,
|
|
ssh_shell,
|
|
*ssh_shell_kind,
|
|
socket.ssh_args(),
|
|
)
|
|
}
|
|
|
|
fn build_forward_ports_command(
|
|
&self,
|
|
forwards: Vec<(u16, String, u16)>,
|
|
) -> Result<CommandTemplate> {
|
|
let Self { socket, .. } = self;
|
|
let mut args = socket.ssh_args();
|
|
args.push("-N".into());
|
|
for (local_port, host, remote_port) in forwards {
|
|
args.push("-L".into());
|
|
args.push(format!("{local_port}:{host}:{remote_port}"));
|
|
}
|
|
Ok(CommandTemplate {
|
|
program: "ssh".into(),
|
|
args,
|
|
env: Default::default(),
|
|
})
|
|
}
|
|
|
|
fn upload_directory(
|
|
&self,
|
|
src_path: PathBuf,
|
|
dest_path: RemotePathBuf,
|
|
cx: &App,
|
|
) -> Task<Result<()>> {
|
|
let dest_path_str = dest_path.to_string();
|
|
let src_path_display = src_path.display().to_string();
|
|
|
|
let mut sftp_command = self.build_sftp_command();
|
|
let mut scp_command =
|
|
self.build_scp_command(&src_path, &dest_path_str, Some(&["-C", "-r"]));
|
|
|
|
cx.background_spawn(async move {
|
|
// We will try SFTP first, and if that fails, we will fall back to SCP.
|
|
// If SCP fails also, we give up and return an error.
|
|
// The reason we allow a fallback from SFTP to SCP is that if the user has to specify a password,
|
|
// depending on the implementation of SSH stack, SFTP may disable interactive password prompts in batch mode.
|
|
// This is for example the case on Windows as evidenced by this implementation snippet:
|
|
// https://github.com/PowerShell/openssh-portable/blob/b8c08ef9da9450a94a9c5ef717d96a7bd83f3332/sshconnect2.c#L417
|
|
if Self::is_sftp_available().await {
|
|
log::debug!("using SFTP for directory upload");
|
|
let mut child = sftp_command.spawn()?;
|
|
if let Some(mut stdin) = child.stdin.take() {
|
|
use futures::AsyncWriteExt;
|
|
let sftp_batch = format!("put -r \"{src_path_display}\" \"{dest_path_str}\"\n");
|
|
stdin.write_all(sftp_batch.as_bytes()).await?;
|
|
stdin.flush().await?;
|
|
}
|
|
|
|
let output = child.output().await?;
|
|
if output.status.success() {
|
|
return Ok(());
|
|
}
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
log::debug!("failed to upload directory via SFTP {src_path_display} -> {dest_path_str}: {stderr}");
|
|
}
|
|
|
|
log::debug!("using SCP for directory upload");
|
|
let output = scp_command.output().await?;
|
|
|
|
if output.status.success() {
|
|
return Ok(());
|
|
}
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
log::debug!("failed to upload directory via SCP {src_path_display} -> {dest_path_str}: {stderr}");
|
|
|
|
anyhow::bail!(
|
|
"failed to upload directory via SFTP/SCP {} -> {}: {}",
|
|
src_path_display,
|
|
dest_path_str,
|
|
stderr,
|
|
);
|
|
})
|
|
}
|
|
|
|
fn start_proxy(
|
|
&self,
|
|
unique_identifier: String,
|
|
reconnect: bool,
|
|
incoming_tx: UnboundedSender<Envelope>,
|
|
outgoing_rx: UnboundedReceiver<Envelope>,
|
|
connection_activity_tx: Sender<()>,
|
|
delegate: Arc<dyn RemoteClientDelegate>,
|
|
cx: &mut AsyncApp,
|
|
) -> Task<Result<i32>> {
|
|
delegate.set_status(Some("Starting proxy"), cx);
|
|
|
|
let Some(remote_binary_path) = self.remote_binary_path.clone() else {
|
|
return Task::ready(Err(anyhow!("Remote binary path not set")));
|
|
};
|
|
|
|
let mut proxy_args = vec![];
|
|
for env_var in ["RUST_LOG", "RUST_BACKTRACE", "ZED_GENERATE_MINIDUMPS"] {
|
|
if let Some(value) = std::env::var(env_var).ok() {
|
|
proxy_args.push(format!("{}='{}'", env_var, value));
|
|
}
|
|
}
|
|
proxy_args.push(remote_binary_path.display(self.path_style()).into_owned());
|
|
proxy_args.push("proxy".to_owned());
|
|
proxy_args.push("--identifier".to_owned());
|
|
proxy_args.push(unique_identifier);
|
|
|
|
if reconnect {
|
|
proxy_args.push("--reconnect".to_owned());
|
|
}
|
|
|
|
let ssh_proxy_process = match self
|
|
.socket
|
|
.ssh_command(self.ssh_shell_kind, "env", &proxy_args, false)
|
|
// IMPORTANT: we kill this process when we drop the task that uses it.
|
|
.kill_on_drop(true)
|
|
.spawn()
|
|
{
|
|
Ok(process) => process,
|
|
Err(error) => {
|
|
return Task::ready(Err(anyhow!("failed to spawn remote server: {}", error)));
|
|
}
|
|
};
|
|
|
|
super::handle_rpc_messages_over_child_process_stdio(
|
|
ssh_proxy_process,
|
|
incoming_tx,
|
|
outgoing_rx,
|
|
connection_activity_tx,
|
|
cx,
|
|
)
|
|
}
|
|
|
|
fn path_style(&self) -> PathStyle {
|
|
self.ssh_path_style
|
|
}
|
|
}
|
|
|
|
impl SshRemoteConnection {
|
|
pub(crate) async fn new(
|
|
connection_options: SshConnectionOptions,
|
|
delegate: Arc<dyn RemoteClientDelegate>,
|
|
cx: &mut AsyncApp,
|
|
) -> Result<Self> {
|
|
use askpass::AskPassResult;
|
|
|
|
let url = connection_options.ssh_url();
|
|
|
|
let temp_dir = tempfile::Builder::new()
|
|
.prefix("zed-ssh-session")
|
|
.tempdir()?;
|
|
let askpass_delegate = askpass::AskPassDelegate::new(cx, {
|
|
let delegate = delegate.clone();
|
|
move |prompt, tx, cx| delegate.ask_password(prompt, tx, cx)
|
|
});
|
|
|
|
let mut askpass =
|
|
askpass::AskPassSession::new(cx.background_executor(), askpass_delegate).await?;
|
|
|
|
delegate.set_status(Some("Connecting"), cx);
|
|
|
|
// Start the master SSH process, which does not do anything except for establish
|
|
// the connection and keep it open, allowing other ssh commands to reuse it
|
|
// via a control socket.
|
|
#[cfg(not(target_os = "windows"))]
|
|
let socket_path = temp_dir.path().join("ssh.sock");
|
|
|
|
#[cfg(target_os = "windows")]
|
|
let mut master_process = MasterProcess::new(
|
|
askpass.script_path().as_ref(),
|
|
connection_options.additional_args(),
|
|
&url,
|
|
)?;
|
|
#[cfg(not(target_os = "windows"))]
|
|
let mut master_process = MasterProcess::new(
|
|
askpass.script_path().as_ref(),
|
|
connection_options.additional_args(),
|
|
&socket_path,
|
|
&url,
|
|
)?;
|
|
|
|
let result = select_biased! {
|
|
result = askpass.run().fuse() => {
|
|
match result {
|
|
AskPassResult::CancelledByUser => {
|
|
master_process.as_mut().kill().ok();
|
|
anyhow::bail!("SSH connection canceled")
|
|
}
|
|
AskPassResult::Timedout => {
|
|
anyhow::bail!("connecting to host timed out")
|
|
}
|
|
}
|
|
}
|
|
_ = master_process.wait_connected().fuse() => {
|
|
anyhow::Ok(())
|
|
}
|
|
};
|
|
|
|
if let Err(e) = result {
|
|
return Err(e.context("Failed to connect to host"));
|
|
}
|
|
|
|
if master_process.as_mut().try_status()?.is_some() {
|
|
let mut output = Vec::new();
|
|
output.clear();
|
|
let mut stderr = master_process.as_mut().stderr.take().unwrap();
|
|
stderr.read_to_end(&mut output).await?;
|
|
|
|
let error_message = format!(
|
|
"failed to connect: {}",
|
|
String::from_utf8_lossy(&output).trim()
|
|
);
|
|
anyhow::bail!(error_message);
|
|
}
|
|
|
|
#[cfg(not(target_os = "windows"))]
|
|
let socket = SshSocket::new(connection_options, socket_path).await?;
|
|
#[cfg(target_os = "windows")]
|
|
let socket = SshSocket::new(
|
|
connection_options,
|
|
askpass
|
|
.get_password()
|
|
.or_else(|| askpass::EncryptedPassword::try_from("").ok())
|
|
.context("Failed to fetch askpass password")?,
|
|
cx.background_executor().clone(),
|
|
)
|
|
.await?;
|
|
drop(askpass);
|
|
|
|
let ssh_shell = socket.shell().await;
|
|
log::info!("Remote shell discovered: {}", ssh_shell);
|
|
let ssh_platform = socket.platform(ShellKind::new(&ssh_shell, false)).await?;
|
|
log::info!("Remote platform discovered: {:?}", ssh_platform);
|
|
let ssh_path_style = match ssh_platform.os {
|
|
"windows" => PathStyle::Windows,
|
|
_ => PathStyle::Posix,
|
|
};
|
|
let ssh_default_system_shell = String::from("/bin/sh");
|
|
let ssh_shell_kind = ShellKind::new(
|
|
&ssh_shell,
|
|
match ssh_platform.os {
|
|
"windows" => true,
|
|
_ => false,
|
|
},
|
|
);
|
|
|
|
let mut this = Self {
|
|
socket,
|
|
master_process: Mutex::new(Some(master_process)),
|
|
_temp_dir: temp_dir,
|
|
remote_binary_path: None,
|
|
ssh_path_style,
|
|
ssh_platform,
|
|
ssh_shell,
|
|
ssh_shell_kind,
|
|
ssh_default_system_shell,
|
|
};
|
|
|
|
let (release_channel, version, commit) = cx.update(|cx| {
|
|
(
|
|
ReleaseChannel::global(cx),
|
|
AppVersion::global(cx),
|
|
AppCommitSha::try_global(cx),
|
|
)
|
|
})?;
|
|
this.remote_binary_path = Some(
|
|
this.ensure_server_binary(&delegate, release_channel, version, commit, cx)
|
|
.await?,
|
|
);
|
|
|
|
Ok(this)
|
|
}
|
|
|
|
async fn ensure_server_binary(
|
|
&self,
|
|
delegate: &Arc<dyn RemoteClientDelegate>,
|
|
release_channel: ReleaseChannel,
|
|
version: SemanticVersion,
|
|
commit: Option<AppCommitSha>,
|
|
cx: &mut AsyncApp,
|
|
) -> Result<Arc<RelPath>> {
|
|
let version_str = match release_channel {
|
|
ReleaseChannel::Nightly => {
|
|
let commit = commit.map(|s| s.full()).unwrap_or_default();
|
|
format!("{}-{}", version, commit)
|
|
}
|
|
ReleaseChannel::Dev => "build".to_string(),
|
|
_ => version.to_string(),
|
|
};
|
|
let binary_name = format!(
|
|
"zed-remote-server-{}-{}",
|
|
release_channel.dev_name(),
|
|
version_str
|
|
);
|
|
let dst_path =
|
|
paths::remote_server_dir_relative().join(RelPath::unix(&binary_name).unwrap());
|
|
|
|
#[cfg(debug_assertions)]
|
|
if let Some(remote_server_path) =
|
|
super::build_remote_server_from_source(&self.ssh_platform, delegate.as_ref(), cx)
|
|
.await?
|
|
{
|
|
let tmp_path = paths::remote_server_dir_relative().join(
|
|
RelPath::unix(&format!(
|
|
"download-{}-{}",
|
|
std::process::id(),
|
|
remote_server_path.file_name().unwrap().to_string_lossy()
|
|
))
|
|
.unwrap(),
|
|
);
|
|
self.upload_local_server_binary(&remote_server_path, &tmp_path, delegate, cx)
|
|
.await?;
|
|
self.extract_server_binary(&dst_path, &tmp_path, delegate, cx)
|
|
.await?;
|
|
return Ok(dst_path);
|
|
}
|
|
|
|
if self
|
|
.socket
|
|
.run_command(
|
|
self.ssh_shell_kind,
|
|
&dst_path.display(self.path_style()),
|
|
&["version"],
|
|
true,
|
|
)
|
|
.await
|
|
.is_ok()
|
|
{
|
|
return Ok(dst_path);
|
|
}
|
|
|
|
let wanted_version = cx.update(|cx| match release_channel {
|
|
ReleaseChannel::Nightly => Ok(None),
|
|
ReleaseChannel::Dev => {
|
|
anyhow::bail!(
|
|
"ZED_BUILD_REMOTE_SERVER is not set and no remote server exists at ({:?})",
|
|
dst_path
|
|
)
|
|
}
|
|
_ => Ok(Some(AppVersion::global(cx))),
|
|
})??;
|
|
|
|
let tmp_path_gz = remote_server_dir_relative().join(
|
|
RelPath::unix(&format!(
|
|
"{}-download-{}.gz",
|
|
binary_name,
|
|
std::process::id()
|
|
))
|
|
.unwrap(),
|
|
);
|
|
if !self.socket.connection_options.upload_binary_over_ssh
|
|
&& let Some(url) = delegate
|
|
.get_download_url(self.ssh_platform, release_channel, wanted_version, cx)
|
|
.await?
|
|
{
|
|
match self
|
|
.download_binary_on_server(&url, &tmp_path_gz, delegate, cx)
|
|
.await
|
|
{
|
|
Ok(_) => {
|
|
self.extract_server_binary(&dst_path, &tmp_path_gz, delegate, cx)
|
|
.await
|
|
.context("extracting server binary")?;
|
|
return Ok(dst_path);
|
|
}
|
|
Err(e) => {
|
|
log::error!(
|
|
"Failed to download binary on server, attempting to download locally and then upload it the server: {e:#}",
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
let src_path = delegate
|
|
.download_server_binary_locally(self.ssh_platform, release_channel, wanted_version, cx)
|
|
.await
|
|
.context("downloading server binary locally")?;
|
|
self.upload_local_server_binary(&src_path, &tmp_path_gz, delegate, cx)
|
|
.await
|
|
.context("uploading server binary")?;
|
|
self.extract_server_binary(&dst_path, &tmp_path_gz, delegate, cx)
|
|
.await
|
|
.context("extracting server binary")?;
|
|
Ok(dst_path)
|
|
}
|
|
|
|
async fn download_binary_on_server(
|
|
&self,
|
|
url: &str,
|
|
tmp_path_gz: &RelPath,
|
|
delegate: &Arc<dyn RemoteClientDelegate>,
|
|
cx: &mut AsyncApp,
|
|
) -> Result<()> {
|
|
if let Some(parent) = tmp_path_gz.parent() {
|
|
self.socket
|
|
.run_command(
|
|
self.ssh_shell_kind,
|
|
"mkdir",
|
|
&["-p", parent.display(self.path_style()).as_ref()],
|
|
true,
|
|
)
|
|
.await?;
|
|
}
|
|
|
|
delegate.set_status(Some("Downloading remote development server on host"), cx);
|
|
|
|
match self
|
|
.socket
|
|
.run_command(
|
|
self.ssh_shell_kind,
|
|
"curl",
|
|
&[
|
|
"-f",
|
|
"-L",
|
|
url,
|
|
"-o",
|
|
&tmp_path_gz.display(self.path_style()),
|
|
],
|
|
true,
|
|
)
|
|
.await
|
|
{
|
|
Ok(_) => {}
|
|
Err(e) => {
|
|
if self
|
|
.socket
|
|
.run_command(self.ssh_shell_kind, "which", &["curl"], true)
|
|
.await
|
|
.is_ok()
|
|
{
|
|
return Err(e);
|
|
}
|
|
|
|
log::info!("curl is not available, trying wget");
|
|
match self
|
|
.socket
|
|
.run_command(
|
|
self.ssh_shell_kind,
|
|
"wget",
|
|
&[url, "-O", &tmp_path_gz.display(self.path_style())],
|
|
true,
|
|
)
|
|
.await
|
|
{
|
|
Ok(_) => {}
|
|
Err(e) => {
|
|
if self
|
|
.socket
|
|
.run_command(self.ssh_shell_kind, "which", &["wget"], true)
|
|
.await
|
|
.is_ok()
|
|
{
|
|
return Err(e);
|
|
} else {
|
|
anyhow::bail!("Neither curl nor wget is available");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn upload_local_server_binary(
|
|
&self,
|
|
src_path: &Path,
|
|
tmp_path_gz: &RelPath,
|
|
delegate: &Arc<dyn RemoteClientDelegate>,
|
|
cx: &mut AsyncApp,
|
|
) -> Result<()> {
|
|
if let Some(parent) = tmp_path_gz.parent() {
|
|
self.socket
|
|
.run_command(
|
|
self.ssh_shell_kind,
|
|
"mkdir",
|
|
&["-p", parent.display(self.path_style()).as_ref()],
|
|
true,
|
|
)
|
|
.await?;
|
|
}
|
|
|
|
let src_stat = fs::metadata(&src_path).await?;
|
|
let size = src_stat.len();
|
|
|
|
let t0 = Instant::now();
|
|
delegate.set_status(Some("Uploading remote development server"), cx);
|
|
log::info!(
|
|
"uploading remote development server to {:?} ({}kb)",
|
|
tmp_path_gz,
|
|
size / 1024
|
|
);
|
|
self.upload_file(src_path, tmp_path_gz)
|
|
.await
|
|
.context("failed to upload server binary")?;
|
|
log::info!("uploaded remote development server in {:?}", t0.elapsed());
|
|
Ok(())
|
|
}
|
|
|
|
async fn extract_server_binary(
|
|
&self,
|
|
dst_path: &RelPath,
|
|
tmp_path: &RelPath,
|
|
delegate: &Arc<dyn RemoteClientDelegate>,
|
|
cx: &mut AsyncApp,
|
|
) -> Result<()> {
|
|
delegate.set_status(Some("Extracting remote development server"), cx);
|
|
let server_mode = 0o755;
|
|
|
|
let shell_kind = ShellKind::Posix;
|
|
let orig_tmp_path = tmp_path.display(self.path_style());
|
|
let server_mode = format!("{:o}", server_mode);
|
|
let server_mode = shell_kind
|
|
.try_quote(&server_mode)
|
|
.context("shell quoting")?;
|
|
let dst_path = dst_path.display(self.path_style());
|
|
let dst_path = shell_kind.try_quote(&dst_path).context("shell quoting")?;
|
|
let script = if let Some(tmp_path) = orig_tmp_path.strip_suffix(".gz") {
|
|
let orig_tmp_path = shell_kind
|
|
.try_quote(&orig_tmp_path)
|
|
.context("shell quoting")?;
|
|
let tmp_path = shell_kind.try_quote(&tmp_path).context("shell quoting")?;
|
|
format!(
|
|
"gunzip -f {orig_tmp_path} && chmod {server_mode} {tmp_path} && mv {tmp_path} {dst_path}",
|
|
)
|
|
} else {
|
|
let orig_tmp_path = shell_kind
|
|
.try_quote(&orig_tmp_path)
|
|
.context("shell quoting")?;
|
|
format!("chmod {server_mode} {orig_tmp_path} && mv {orig_tmp_path} {dst_path}",)
|
|
};
|
|
let args = shell_kind.args_for_shell(false, script.to_string());
|
|
self.socket
|
|
.run_command(shell_kind, "sh", &args, true)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
fn build_scp_command(
|
|
&self,
|
|
src_path: &Path,
|
|
dest_path_str: &str,
|
|
args: Option<&[&str]>,
|
|
) -> process::Command {
|
|
let mut command = util::command::new_smol_command("scp");
|
|
self.socket.ssh_options(&mut command, false).args(
|
|
self.socket
|
|
.connection_options
|
|
.port
|
|
.map(|port| vec!["-P".to_string(), port.to_string()])
|
|
.unwrap_or_default(),
|
|
);
|
|
if let Some(args) = args {
|
|
command.args(args);
|
|
}
|
|
command.arg(src_path).arg(format!(
|
|
"{}:{}",
|
|
self.socket.connection_options.scp_url(),
|
|
dest_path_str
|
|
));
|
|
command
|
|
}
|
|
|
|
fn build_sftp_command(&self) -> process::Command {
|
|
let mut command = util::command::new_smol_command("sftp");
|
|
self.socket.ssh_options(&mut command, false).args(
|
|
self.socket
|
|
.connection_options
|
|
.port
|
|
.map(|port| vec!["-P".to_string(), port.to_string()])
|
|
.unwrap_or_default(),
|
|
);
|
|
command.arg("-b").arg("-");
|
|
command.arg(self.socket.connection_options.scp_url());
|
|
command.stdin(Stdio::piped());
|
|
command
|
|
}
|
|
|
|
async fn upload_file(&self, src_path: &Path, dest_path: &RelPath) -> Result<()> {
|
|
log::debug!("uploading file {:?} to {:?}", src_path, dest_path);
|
|
|
|
let src_path_display = src_path.display().to_string();
|
|
let dest_path_str = dest_path.display(self.path_style());
|
|
|
|
// We will try SFTP first, and if that fails, we will fall back to SCP.
|
|
// If SCP fails also, we give up and return an error.
|
|
// The reason we allow a fallback from SFTP to SCP is that if the user has to specify a password,
|
|
// depending on the implementation of SSH stack, SFTP may disable interactive password prompts in batch mode.
|
|
// This is for example the case on Windows as evidenced by this implementation snippet:
|
|
// https://github.com/PowerShell/openssh-portable/blob/b8c08ef9da9450a94a9c5ef717d96a7bd83f3332/sshconnect2.c#L417
|
|
if Self::is_sftp_available().await {
|
|
log::debug!("using SFTP for file upload");
|
|
let mut command = self.build_sftp_command();
|
|
let sftp_batch = format!("put {src_path_display} {dest_path_str}\n");
|
|
|
|
let mut child = command.spawn()?;
|
|
if let Some(mut stdin) = child.stdin.take() {
|
|
use futures::AsyncWriteExt;
|
|
stdin.write_all(sftp_batch.as_bytes()).await?;
|
|
stdin.flush().await?;
|
|
}
|
|
|
|
let output = child.output().await?;
|
|
if output.status.success() {
|
|
return Ok(());
|
|
}
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
log::debug!(
|
|
"failed to upload file via SFTP {src_path_display} -> {dest_path_str}: {stderr}"
|
|
);
|
|
}
|
|
|
|
log::debug!("using SCP for file upload");
|
|
let mut command = self.build_scp_command(src_path, &dest_path_str, None);
|
|
let output = command.output().await?;
|
|
|
|
if output.status.success() {
|
|
return Ok(());
|
|
}
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
log::debug!(
|
|
"failed to upload file via SCP {src_path_display} -> {dest_path_str}: {stderr}",
|
|
);
|
|
anyhow::bail!(
|
|
"failed to upload file via STFP/SCP {} -> {}: {}",
|
|
src_path_display,
|
|
dest_path_str,
|
|
stderr,
|
|
);
|
|
}
|
|
|
|
async fn is_sftp_available() -> bool {
|
|
which::which("sftp").is_ok()
|
|
}
|
|
}
|
|
|
|
impl SshSocket {
|
|
#[cfg(not(target_os = "windows"))]
|
|
async fn new(options: SshConnectionOptions, socket_path: PathBuf) -> Result<Self> {
|
|
Ok(Self {
|
|
connection_options: options,
|
|
envs: HashMap::default(),
|
|
socket_path,
|
|
})
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
async fn new(
|
|
options: SshConnectionOptions,
|
|
password: askpass::EncryptedPassword,
|
|
executor: gpui::BackgroundExecutor,
|
|
) -> Result<Self> {
|
|
let mut envs = HashMap::default();
|
|
let get_password =
|
|
move |_| Task::ready(std::ops::ControlFlow::Continue(Ok(password.clone())));
|
|
|
|
let _proxy = askpass::PasswordProxy::new(get_password, executor).await?;
|
|
envs.insert("SSH_ASKPASS_REQUIRE".into(), "force".into());
|
|
envs.insert(
|
|
"SSH_ASKPASS".into(),
|
|
_proxy.script_path().as_ref().display().to_string(),
|
|
);
|
|
|
|
Ok(Self {
|
|
connection_options: options,
|
|
envs,
|
|
_proxy,
|
|
})
|
|
}
|
|
|
|
// :WARNING: ssh unquotes arguments when executing on the remote :WARNING:
|
|
// e.g. $ ssh host sh -c 'ls -l' is equivalent to $ ssh host sh -c ls -l
|
|
// and passes -l as an argument to sh, not to ls.
|
|
// Furthermore, some setups (e.g. Coder) will change directory when SSH'ing
|
|
// into a machine. You must use `cd` to get back to $HOME.
|
|
// You need to do it like this: $ ssh host "cd; sh -c 'ls -l /tmp'"
|
|
fn ssh_command(
|
|
&self,
|
|
shell_kind: ShellKind,
|
|
program: &str,
|
|
args: &[impl AsRef<str>],
|
|
allow_pseudo_tty: bool,
|
|
) -> process::Command {
|
|
let mut command = util::command::new_smol_command("ssh");
|
|
let program = shell_kind.prepend_command_prefix(program);
|
|
let mut to_run = shell_kind
|
|
.try_quote_prefix_aware(&program)
|
|
.expect("shell quoting")
|
|
.into_owned();
|
|
for arg in args {
|
|
// We're trying to work with: sh, bash, zsh, fish, tcsh, ...?
|
|
debug_assert!(
|
|
!arg.as_ref().contains('\n'),
|
|
"multiline arguments do not work in all shells"
|
|
);
|
|
to_run.push(' ');
|
|
to_run.push_str(&shell_kind.try_quote(arg.as_ref()).expect("shell quoting"));
|
|
}
|
|
let separator = shell_kind.sequential_commands_separator();
|
|
let to_run = format!("cd{separator} {to_run}");
|
|
self.ssh_options(&mut command, true)
|
|
.arg(self.connection_options.ssh_url());
|
|
if !allow_pseudo_tty {
|
|
command.arg("-T");
|
|
}
|
|
command.arg(to_run);
|
|
log::debug!("ssh {:?}", command);
|
|
command
|
|
}
|
|
|
|
async fn run_command(
|
|
&self,
|
|
shell_kind: ShellKind,
|
|
program: &str,
|
|
args: &[impl AsRef<str>],
|
|
allow_pseudo_tty: bool,
|
|
) -> Result<String> {
|
|
let mut command = self.ssh_command(shell_kind, program, args, allow_pseudo_tty);
|
|
let output = command.output().await?;
|
|
anyhow::ensure!(
|
|
output.status.success(),
|
|
"failed to run command {command:?}: {}",
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
Ok(String::from_utf8_lossy(&output.stdout).to_string())
|
|
}
|
|
|
|
#[cfg(not(target_os = "windows"))]
|
|
fn ssh_options<'a>(
|
|
&self,
|
|
command: &'a mut process::Command,
|
|
include_port_forwards: bool,
|
|
) -> &'a mut process::Command {
|
|
let args = if include_port_forwards {
|
|
self.connection_options.additional_args()
|
|
} else {
|
|
self.connection_options.additional_args_for_scp()
|
|
};
|
|
|
|
command
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.args(args)
|
|
.args(["-o", "ControlMaster=no", "-o"])
|
|
.arg(format!("ControlPath={}", self.socket_path.display()))
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn ssh_options<'a>(
|
|
&self,
|
|
command: &'a mut process::Command,
|
|
include_port_forwards: bool,
|
|
) -> &'a mut process::Command {
|
|
let args = if include_port_forwards {
|
|
self.connection_options.additional_args()
|
|
} else {
|
|
self.connection_options.additional_args_for_scp()
|
|
};
|
|
|
|
command
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.args(args)
|
|
.envs(self.envs.clone())
|
|
}
|
|
|
|
// On Windows, we need to use `SSH_ASKPASS` to provide the password to ssh.
|
|
// On Linux, we use the `ControlPath` option to create a socket file that ssh can use to
|
|
#[cfg(not(target_os = "windows"))]
|
|
fn ssh_args(&self) -> Vec<String> {
|
|
let mut arguments = self.connection_options.additional_args();
|
|
arguments.extend(vec![
|
|
"-o".to_string(),
|
|
"ControlMaster=no".to_string(),
|
|
"-o".to_string(),
|
|
format!("ControlPath={}", self.socket_path.display()),
|
|
self.connection_options.ssh_url(),
|
|
]);
|
|
arguments
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn ssh_args(&self) -> Vec<String> {
|
|
let mut arguments = self.connection_options.additional_args();
|
|
arguments.push(self.connection_options.ssh_url());
|
|
arguments
|
|
}
|
|
|
|
async fn platform(&self, shell: ShellKind) -> Result<RemotePlatform> {
|
|
let uname = self.run_command(shell, "uname", &["-sm"], false).await?;
|
|
let Some((os, arch)) = uname.split_once(" ") else {
|
|
anyhow::bail!("unknown uname: {uname:?}")
|
|
};
|
|
|
|
let os = match os.trim() {
|
|
"Darwin" => "macos",
|
|
"Linux" => "linux",
|
|
_ => anyhow::bail!(
|
|
"Prebuilt remote servers are not yet available for {os:?}. See https://zed.dev/docs/remote-development"
|
|
),
|
|
};
|
|
// exclude armv5,6,7 as they are 32-bit.
|
|
let arch = if arch.starts_with("armv8")
|
|
|| arch.starts_with("armv9")
|
|
|| arch.starts_with("arm64")
|
|
|| arch.starts_with("aarch64")
|
|
{
|
|
"aarch64"
|
|
} else if arch.starts_with("x86") {
|
|
"x86_64"
|
|
} else {
|
|
anyhow::bail!(
|
|
"Prebuilt remote servers are not yet available for {arch:?}. See https://zed.dev/docs/remote-development"
|
|
)
|
|
};
|
|
|
|
Ok(RemotePlatform { os, arch })
|
|
}
|
|
|
|
async fn shell(&self) -> String {
|
|
let default_shell = "sh";
|
|
match self
|
|
.run_command(ShellKind::Posix, "sh", &["-c", "echo $SHELL"], false)
|
|
.await
|
|
{
|
|
Ok(shell) => match shell.trim() {
|
|
"" => {
|
|
log::error!("$SHELL is not set, falling back to {default_shell}");
|
|
default_shell.to_owned()
|
|
}
|
|
shell => shell.to_owned(),
|
|
},
|
|
Err(e) => {
|
|
log::error!("Failed to get shell: {e}");
|
|
default_shell.to_owned()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_port_number(port_str: &str) -> Result<u16> {
|
|
port_str
|
|
.parse()
|
|
.with_context(|| format!("parsing port number: {port_str}"))
|
|
}
|
|
|
|
fn parse_port_forward_spec(spec: &str) -> Result<SshPortForwardOption> {
|
|
let parts: Vec<&str> = spec.split(':').collect();
|
|
|
|
match parts.len() {
|
|
4 => {
|
|
let local_port = parse_port_number(parts[1])?;
|
|
let remote_port = parse_port_number(parts[3])?;
|
|
|
|
Ok(SshPortForwardOption {
|
|
local_host: Some(parts[0].to_string()),
|
|
local_port,
|
|
remote_host: Some(parts[2].to_string()),
|
|
remote_port,
|
|
})
|
|
}
|
|
3 => {
|
|
let local_port = parse_port_number(parts[0])?;
|
|
let remote_port = parse_port_number(parts[2])?;
|
|
|
|
Ok(SshPortForwardOption {
|
|
local_host: None,
|
|
local_port,
|
|
remote_host: Some(parts[1].to_string()),
|
|
remote_port,
|
|
})
|
|
}
|
|
_ => anyhow::bail!("Invalid port forward format"),
|
|
}
|
|
}
|
|
|
|
impl SshConnectionOptions {
|
|
pub fn parse_command_line(input: &str) -> Result<Self> {
|
|
let input = input.trim_start_matches("ssh ");
|
|
let mut hostname: Option<String> = None;
|
|
let mut username: Option<String> = None;
|
|
let mut port: Option<u16> = None;
|
|
let mut args = Vec::new();
|
|
let mut port_forwards: Vec<SshPortForwardOption> = Vec::new();
|
|
|
|
// disallowed: -E, -e, -F, -f, -G, -g, -M, -N, -n, -O, -q, -S, -s, -T, -t, -V, -v, -W
|
|
const ALLOWED_OPTS: &[&str] = &[
|
|
"-4", "-6", "-A", "-a", "-C", "-K", "-k", "-X", "-x", "-Y", "-y",
|
|
];
|
|
const ALLOWED_ARGS: &[&str] = &[
|
|
"-B", "-b", "-c", "-D", "-F", "-I", "-i", "-J", "-l", "-m", "-o", "-P", "-p", "-R",
|
|
"-w",
|
|
];
|
|
|
|
let mut tokens = ShellKind::Posix
|
|
.split(input)
|
|
.context("invalid input")?
|
|
.into_iter();
|
|
|
|
'outer: while let Some(arg) = tokens.next() {
|
|
if ALLOWED_OPTS.contains(&(&arg as &str)) {
|
|
args.push(arg.to_string());
|
|
continue;
|
|
}
|
|
if arg == "-p" {
|
|
port = tokens.next().and_then(|arg| arg.parse().ok());
|
|
continue;
|
|
} else if let Some(p) = arg.strip_prefix("-p") {
|
|
port = p.parse().ok();
|
|
continue;
|
|
}
|
|
if arg == "-l" {
|
|
username = tokens.next();
|
|
continue;
|
|
} else if let Some(l) = arg.strip_prefix("-l") {
|
|
username = Some(l.to_string());
|
|
continue;
|
|
}
|
|
if arg == "-L" || arg.starts_with("-L") {
|
|
let forward_spec = if arg == "-L" {
|
|
tokens.next()
|
|
} else {
|
|
Some(arg.strip_prefix("-L").unwrap().to_string())
|
|
};
|
|
|
|
if let Some(spec) = forward_spec {
|
|
port_forwards.push(parse_port_forward_spec(&spec)?);
|
|
} else {
|
|
anyhow::bail!("Missing port forward format");
|
|
}
|
|
}
|
|
|
|
for a in ALLOWED_ARGS {
|
|
if arg == *a {
|
|
args.push(arg);
|
|
if let Some(next) = tokens.next() {
|
|
args.push(next);
|
|
}
|
|
continue 'outer;
|
|
} else if arg.starts_with(a) {
|
|
args.push(arg);
|
|
continue 'outer;
|
|
}
|
|
}
|
|
if arg.starts_with("-") || hostname.is_some() {
|
|
anyhow::bail!("unsupported argument: {:?}", arg);
|
|
}
|
|
let mut input = &arg as &str;
|
|
// Destination might be: username1@username2@ip2@ip1
|
|
if let Some((u, rest)) = input.rsplit_once('@') {
|
|
input = rest;
|
|
username = Some(u.to_string());
|
|
}
|
|
if let Some((rest, p)) = input.split_once(':') {
|
|
input = rest;
|
|
port = p.parse().ok()
|
|
}
|
|
hostname = Some(input.to_string())
|
|
}
|
|
|
|
let Some(hostname) = hostname else {
|
|
anyhow::bail!("missing hostname");
|
|
};
|
|
|
|
let port_forwards = match port_forwards.len() {
|
|
0 => None,
|
|
_ => Some(port_forwards),
|
|
};
|
|
|
|
Ok(Self {
|
|
host: hostname,
|
|
username,
|
|
port,
|
|
port_forwards,
|
|
args: Some(args),
|
|
password: None,
|
|
nickname: None,
|
|
upload_binary_over_ssh: false,
|
|
})
|
|
}
|
|
|
|
pub fn ssh_url(&self) -> String {
|
|
let mut result = String::from("ssh://");
|
|
if let Some(username) = &self.username {
|
|
// Username might be: username1@username2@ip2
|
|
let username = urlencoding::encode(username);
|
|
result.push_str(&username);
|
|
result.push('@');
|
|
}
|
|
result.push_str(&self.host);
|
|
if let Some(port) = self.port {
|
|
result.push(':');
|
|
result.push_str(&port.to_string());
|
|
}
|
|
result
|
|
}
|
|
|
|
pub fn additional_args_for_scp(&self) -> Vec<String> {
|
|
self.args.iter().flatten().cloned().collect::<Vec<String>>()
|
|
}
|
|
|
|
pub fn additional_args(&self) -> Vec<String> {
|
|
let mut args = self.additional_args_for_scp();
|
|
|
|
if let Some(forwards) = &self.port_forwards {
|
|
args.extend(forwards.iter().map(|pf| {
|
|
let local_host = match &pf.local_host {
|
|
Some(host) => host,
|
|
None => "localhost",
|
|
};
|
|
let remote_host = match &pf.remote_host {
|
|
Some(host) => host,
|
|
None => "localhost",
|
|
};
|
|
|
|
format!(
|
|
"-L{}:{}:{}:{}",
|
|
local_host, pf.local_port, remote_host, pf.remote_port
|
|
)
|
|
}));
|
|
}
|
|
|
|
args
|
|
}
|
|
|
|
fn scp_url(&self) -> String {
|
|
if let Some(username) = &self.username {
|
|
format!("{}@{}", username, self.host)
|
|
} else {
|
|
self.host.clone()
|
|
}
|
|
}
|
|
|
|
pub fn connection_string(&self) -> String {
|
|
let host = if let Some(username) = &self.username {
|
|
format!("{}@{}", username, self.host)
|
|
} else {
|
|
self.host.clone()
|
|
};
|
|
if let Some(port) = &self.port {
|
|
format!("{}:{}", host, port)
|
|
} else {
|
|
host
|
|
}
|
|
}
|
|
}
|
|
|
|
fn build_command(
|
|
input_program: Option<String>,
|
|
input_args: &[String],
|
|
input_env: &HashMap<String, String>,
|
|
working_dir: Option<String>,
|
|
port_forward: Option<(u16, String, u16)>,
|
|
ssh_env: HashMap<String, String>,
|
|
ssh_path_style: PathStyle,
|
|
ssh_shell: &str,
|
|
ssh_shell_kind: ShellKind,
|
|
ssh_args: Vec<String>,
|
|
) -> Result<CommandTemplate> {
|
|
use std::fmt::Write as _;
|
|
|
|
let mut exec = String::new();
|
|
if let Some(working_dir) = working_dir {
|
|
let working_dir = RemotePathBuf::new(working_dir, ssh_path_style).to_string();
|
|
|
|
// shlex will wrap the command in single quotes (''), disabling ~ expansion,
|
|
// replace with with something that works
|
|
const TILDE_PREFIX: &'static str = "~/";
|
|
if working_dir.starts_with(TILDE_PREFIX) {
|
|
let working_dir = working_dir.trim_start_matches("~").trim_start_matches("/");
|
|
write!(
|
|
exec,
|
|
"cd \"$HOME/{working_dir}\" {} ",
|
|
ssh_shell_kind.sequential_and_commands_separator()
|
|
)?;
|
|
} else {
|
|
write!(
|
|
exec,
|
|
"cd \"{working_dir}\" {} ",
|
|
ssh_shell_kind.sequential_and_commands_separator()
|
|
)?;
|
|
}
|
|
} else {
|
|
write!(
|
|
exec,
|
|
"cd {} ",
|
|
ssh_shell_kind.sequential_and_commands_separator()
|
|
)?;
|
|
};
|
|
write!(exec, "exec env ")?;
|
|
|
|
for (k, v) in input_env.iter() {
|
|
write!(
|
|
exec,
|
|
"{}={} ",
|
|
k,
|
|
ssh_shell_kind.try_quote(v).context("shell quoting")?
|
|
)?;
|
|
}
|
|
|
|
if let Some(input_program) = input_program {
|
|
write!(
|
|
exec,
|
|
"{}",
|
|
ssh_shell_kind
|
|
.try_quote_prefix_aware(&input_program)
|
|
.context("shell quoting")?
|
|
)?;
|
|
for arg in input_args {
|
|
let arg = ssh_shell_kind.try_quote(&arg).context("shell quoting")?;
|
|
write!(exec, " {}", &arg)?;
|
|
}
|
|
} else {
|
|
write!(exec, "{ssh_shell} -l")?;
|
|
};
|
|
|
|
let mut args = Vec::new();
|
|
args.extend(ssh_args);
|
|
|
|
if let Some((local_port, host, remote_port)) = port_forward {
|
|
args.push("-L".into());
|
|
args.push(format!("{local_port}:{host}:{remote_port}"));
|
|
}
|
|
|
|
args.push("-t".into());
|
|
args.push(exec);
|
|
Ok(CommandTemplate {
|
|
program: "ssh".into(),
|
|
args,
|
|
env: ssh_env,
|
|
})
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_build_command() -> Result<()> {
|
|
let mut input_env = HashMap::default();
|
|
input_env.insert("INPUT_VA".to_string(), "val".to_string());
|
|
let mut env = HashMap::default();
|
|
env.insert("SSH_VAR".to_string(), "ssh-val".to_string());
|
|
|
|
let command = build_command(
|
|
Some("remote_program".to_string()),
|
|
&["arg1".to_string(), "arg2".to_string()],
|
|
&input_env,
|
|
Some("~/work".to_string()),
|
|
None,
|
|
env.clone(),
|
|
PathStyle::Posix,
|
|
"/bin/fish",
|
|
ShellKind::Fish,
|
|
vec!["-p".to_string(), "2222".to_string()],
|
|
)?;
|
|
|
|
assert_eq!(command.program, "ssh");
|
|
assert_eq!(
|
|
command.args.iter().map(String::as_str).collect::<Vec<_>>(),
|
|
[
|
|
"-p",
|
|
"2222",
|
|
"-t",
|
|
"cd \"$HOME/work\" && exec env INPUT_VA=val remote_program arg1 arg2"
|
|
]
|
|
);
|
|
assert_eq!(command.env, env);
|
|
|
|
let mut input_env = HashMap::default();
|
|
input_env.insert("INPUT_VA".to_string(), "val".to_string());
|
|
let mut env = HashMap::default();
|
|
env.insert("SSH_VAR".to_string(), "ssh-val".to_string());
|
|
|
|
let command = build_command(
|
|
None,
|
|
&["arg1".to_string(), "arg2".to_string()],
|
|
&input_env,
|
|
None,
|
|
Some((1, "foo".to_owned(), 2)),
|
|
env.clone(),
|
|
PathStyle::Posix,
|
|
"/bin/fish",
|
|
ShellKind::Fish,
|
|
vec!["-p".to_string(), "2222".to_string()],
|
|
)?;
|
|
|
|
assert_eq!(command.program, "ssh");
|
|
assert_eq!(
|
|
command.args.iter().map(String::as_str).collect::<Vec<_>>(),
|
|
[
|
|
"-p",
|
|
"2222",
|
|
"-L",
|
|
"1:foo:2",
|
|
"-t",
|
|
"cd && exec env INPUT_VA=val /bin/fish -l"
|
|
]
|
|
);
|
|
assert_eq!(command.env, env);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn scp_args_exclude_port_forward_flags() {
|
|
let options = SshConnectionOptions {
|
|
host: "example.com".into(),
|
|
args: Some(vec![
|
|
"-p".to_string(),
|
|
"2222".to_string(),
|
|
"-o".to_string(),
|
|
"StrictHostKeyChecking=no".to_string(),
|
|
]),
|
|
port_forwards: Some(vec![SshPortForwardOption {
|
|
local_host: Some("127.0.0.1".to_string()),
|
|
local_port: 8080,
|
|
remote_host: Some("127.0.0.1".to_string()),
|
|
remote_port: 80,
|
|
}]),
|
|
..Default::default()
|
|
};
|
|
|
|
let ssh_args = options.additional_args();
|
|
assert!(
|
|
ssh_args.iter().any(|arg| arg.starts_with("-L")),
|
|
"expected ssh args to include port-forward: {ssh_args:?}"
|
|
);
|
|
|
|
let scp_args = options.additional_args_for_scp();
|
|
assert_eq!(
|
|
scp_args,
|
|
vec![
|
|
"-p".to_string(),
|
|
"2222".to_string(),
|
|
"-o".to_string(),
|
|
"StrictHostKeyChecking=no".to_string()
|
|
]
|
|
);
|
|
assert!(
|
|
scp_args.iter().all(|arg| !arg.starts_with("-L")),
|
|
"scp args should not contain port forward flags: {scp_args:?}"
|
|
);
|
|
}
|
|
}
|