142 lines
4.3 KiB
Rust
142 lines
4.3 KiB
Rust
use crate::*;
|
|
use dap::transport::TcpTransport;
|
|
use gpui::AsyncApp;
|
|
use std::{ffi::OsStr, net::Ipv4Addr, path::PathBuf};
|
|
|
|
pub(crate) struct PythonDebugAdapter {
|
|
port: u16,
|
|
host: Ipv4Addr,
|
|
timeout: Option<u64>,
|
|
}
|
|
|
|
impl PythonDebugAdapter {
|
|
const ADAPTER_NAME: &'static str = "debugpy";
|
|
const ADAPTER_PATH: &'static str = "src/debugpy/adapter";
|
|
const LANGUAGE_NAME: &'static str = "Python";
|
|
|
|
pub(crate) async fn new(host: &TCPHost) -> Result<Self> {
|
|
Ok(PythonDebugAdapter {
|
|
port: TcpTransport::port(host).await?,
|
|
host: host.host(),
|
|
timeout: host.timeout,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[async_trait(?Send)]
|
|
impl DebugAdapter for PythonDebugAdapter {
|
|
fn name(&self) -> DebugAdapterName {
|
|
DebugAdapterName(Self::ADAPTER_NAME.into())
|
|
}
|
|
|
|
async fn fetch_latest_adapter_version(
|
|
&self,
|
|
delegate: &dyn DapDelegate,
|
|
) -> Result<AdapterVersion> {
|
|
let github_repo = GithubRepo {
|
|
repo_name: Self::ADAPTER_NAME.into(),
|
|
repo_owner: "microsoft".into(),
|
|
};
|
|
|
|
adapters::fetch_latest_adapter_version_from_github(github_repo, delegate).await
|
|
}
|
|
|
|
async fn install_binary(
|
|
&self,
|
|
version: AdapterVersion,
|
|
delegate: &dyn DapDelegate,
|
|
) -> Result<()> {
|
|
let version_path = adapters::download_adapter_from_github(
|
|
self.name(),
|
|
version,
|
|
adapters::DownloadedFileType::Zip,
|
|
delegate,
|
|
)
|
|
.await?;
|
|
|
|
// only needed when you install the latest version for the first time
|
|
if let Some(debugpy_dir) =
|
|
util::fs::find_file_name_in_dir(version_path.as_path(), |file_name| {
|
|
file_name.starts_with("microsoft-debugpy-")
|
|
})
|
|
.await
|
|
{
|
|
// TODO Debugger: Rename folder instead of moving all files to another folder
|
|
// We're doing uncessary IO work right now
|
|
util::fs::move_folder_files_to_folder(debugpy_dir.as_path(), version_path.as_path())
|
|
.await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_installed_binary(
|
|
&self,
|
|
delegate: &dyn DapDelegate,
|
|
config: &DebugAdapterConfig,
|
|
user_installed_path: Option<PathBuf>,
|
|
cx: &mut AsyncApp,
|
|
) -> Result<DebugAdapterBinary> {
|
|
const BINARY_NAMES: [&str; 3] = ["python3", "python", "py"];
|
|
|
|
let debugpy_dir = if let Some(user_installed_path) = user_installed_path {
|
|
user_installed_path
|
|
} else {
|
|
let adapter_path = paths::debug_adapters_dir().join(self.name());
|
|
let file_name_prefix = format!("{}_", self.name());
|
|
|
|
util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
|
|
file_name.starts_with(&file_name_prefix)
|
|
})
|
|
.await
|
|
.ok_or_else(|| anyhow!("Debugpy directory not found"))?
|
|
};
|
|
|
|
let toolchain = delegate
|
|
.toolchain_store()
|
|
.active_toolchain(
|
|
delegate.worktree_id(),
|
|
language::LanguageName::new(Self::LANGUAGE_NAME),
|
|
cx,
|
|
)
|
|
.await;
|
|
|
|
let python_path = if let Some(toolchain) = toolchain {
|
|
Some(toolchain.path.to_string())
|
|
} else {
|
|
BINARY_NAMES
|
|
.iter()
|
|
.filter_map(|cmd| {
|
|
delegate
|
|
.which(OsStr::new(cmd))
|
|
.map(|path| path.to_string_lossy().to_string())
|
|
})
|
|
.find(|_| true)
|
|
};
|
|
|
|
Ok(DebugAdapterBinary {
|
|
command: python_path.ok_or(anyhow!("failed to find binary path for python"))?,
|
|
arguments: Some(vec![
|
|
debugpy_dir.join(Self::ADAPTER_PATH).into(),
|
|
format!("--port={}", self.port).into(),
|
|
format!("--host={}", self.host).into(),
|
|
]),
|
|
connection: Some(adapters::TcpArguments {
|
|
host: self.host,
|
|
port: self.port,
|
|
timeout: self.timeout,
|
|
}),
|
|
cwd: config.cwd.clone(),
|
|
envs: None,
|
|
})
|
|
}
|
|
|
|
fn request_args(&self, config: &DebugAdapterConfig) -> Value {
|
|
json!({
|
|
"program": config.program,
|
|
"subProcess": true,
|
|
"cwd": config.cwd,
|
|
})
|
|
}
|
|
}
|