Add initial support for defining language server adapters in WebAssembly-based extensions (#8645)
This PR adds **internal** ability to run arbitrary language servers via WebAssembly extensions. The functionality isn't exposed yet - we're just landing this in this early state because there have been a lot of changes to the `LspAdapter` trait, and other language server logic. ## Next steps * Currently, wasm extensions can only define how to *install* and run a language server, they can't yet implement the other LSP adapter methods, such as formatting completion labels and workspace symbols. * We don't have an automatic way to install or develop these types of extensions * We don't have a way to package these types of extensions in our extensions repo, to make them available via our extensions API. * The Rust extension API crate, `zed-extension-api` has not yet been published to crates.io, because we still consider the API a work in progress. Release Notes: - N/A --------- Co-authored-by: Marshall <marshall@zed.dev> Co-authored-by: Nathan <nathan@zed.dev> Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
This commit is contained in:
Max Brunsfeld
GitHub
parent
f3f2225a8e
commit
268fa1cbaf
84 changed files with 3714 additions and 1973 deletions
|
|
@ -16,13 +16,16 @@ path = "src/extension_json_schemas.rs"
|
|||
anyhow.workspace = true
|
||||
async-compression.workspace = true
|
||||
async-tar.workspace = true
|
||||
async-trait.workspace = true
|
||||
collections.workspace = true
|
||||
fs.workspace = true
|
||||
futures.workspace = true
|
||||
gpui.workspace = true
|
||||
language.workspace = true
|
||||
log.workspace = true
|
||||
parking_lot.workspace = true
|
||||
lsp.workspace = true
|
||||
node_runtime.workspace = true
|
||||
project.workspace = true
|
||||
schemars.workspace = true
|
||||
serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
|
|
@ -30,8 +33,12 @@ settings.workspace = true
|
|||
theme.workspace = true
|
||||
toml.workspace = true
|
||||
util.workspace = true
|
||||
wasmtime = { workspace = true, features = ["async"] }
|
||||
wasmtime-wasi.workspace = true
|
||||
wasmparser.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
fs = { workspace = true, features = ["test-support"] }
|
||||
gpui = { workspace = true, features = ["test-support"] }
|
||||
language = { workspace = true, features = ["test-support"] }
|
||||
project = { workspace = true, features = ["test-support"] }
|
||||
|
|
|
|||
90
crates/extension/src/extension_lsp_adapter.rs
Normal file
90
crates/extension/src/extension_lsp_adapter.rs
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
use crate::wasm_host::{wit::LanguageServerConfig, WasmExtension};
|
||||
use anyhow::{anyhow, Result};
|
||||
use async_trait::async_trait;
|
||||
use futures::{Future, FutureExt};
|
||||
use gpui::AsyncAppContext;
|
||||
use language::{Language, LanguageServerName, LspAdapter, LspAdapterDelegate};
|
||||
use lsp::LanguageServerBinary;
|
||||
use std::{
|
||||
any::Any,
|
||||
path::{Path, PathBuf},
|
||||
pin::Pin,
|
||||
sync::Arc,
|
||||
};
|
||||
use wasmtime_wasi::preview2::WasiView as _;
|
||||
|
||||
pub struct ExtensionLspAdapter {
|
||||
pub(crate) extension: WasmExtension,
|
||||
pub(crate) config: LanguageServerConfig,
|
||||
pub(crate) work_dir: PathBuf,
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl LspAdapter for ExtensionLspAdapter {
|
||||
fn name(&self) -> LanguageServerName {
|
||||
LanguageServerName(self.config.name.clone().into())
|
||||
}
|
||||
|
||||
fn get_language_server_command<'a>(
|
||||
self: Arc<Self>,
|
||||
_: Arc<Language>,
|
||||
_: Arc<Path>,
|
||||
delegate: Arc<dyn LspAdapterDelegate>,
|
||||
_: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
|
||||
_: &'a mut AsyncAppContext,
|
||||
) -> Pin<Box<dyn 'a + Future<Output = Result<LanguageServerBinary>>>> {
|
||||
async move {
|
||||
let command = self
|
||||
.extension
|
||||
.call({
|
||||
let this = self.clone();
|
||||
|extension, store| {
|
||||
async move {
|
||||
let resource = store.data_mut().table().push(delegate)?;
|
||||
extension
|
||||
.call_language_server_command(store, &this.config, resource)
|
||||
.await
|
||||
}
|
||||
.boxed()
|
||||
}
|
||||
})
|
||||
.await?
|
||||
.map_err(|e| anyhow!("{}", e))?;
|
||||
|
||||
Ok(LanguageServerBinary {
|
||||
path: self.work_dir.join(&command.command).into(),
|
||||
arguments: command.args.into_iter().map(|arg| arg.into()).collect(),
|
||||
env: Some(command.env.into_iter().collect()),
|
||||
})
|
||||
}
|
||||
.boxed_local()
|
||||
}
|
||||
|
||||
async fn fetch_latest_server_version(
|
||||
&self,
|
||||
_: &dyn LspAdapterDelegate,
|
||||
) -> Result<Box<dyn 'static + Send + Any>> {
|
||||
unreachable!("get_language_server_command is overridden")
|
||||
}
|
||||
|
||||
async fn fetch_server_binary(
|
||||
&self,
|
||||
_: Box<dyn 'static + Send + Any>,
|
||||
_: PathBuf,
|
||||
_: &dyn LspAdapterDelegate,
|
||||
) -> Result<LanguageServerBinary> {
|
||||
unreachable!("get_language_server_command is overridden")
|
||||
}
|
||||
|
||||
async fn cached_server_binary(
|
||||
&self,
|
||||
_: PathBuf,
|
||||
_: &dyn LspAdapterDelegate,
|
||||
) -> Option<LanguageServerBinary> {
|
||||
unreachable!("get_language_server_command is overridden")
|
||||
}
|
||||
|
||||
async fn installation_test_binary(&self, _: PathBuf) -> Option<LanguageServerBinary> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
|
@ -1,48 +1,118 @@
|
|||
mod extension_lsp_adapter;
|
||||
mod wasm_host;
|
||||
|
||||
#[cfg(test)]
|
||||
mod extension_store_test;
|
||||
|
||||
use anyhow::{anyhow, bail, Context as _, Result};
|
||||
use async_compression::futures::bufread::GzipDecoder;
|
||||
use async_tar::Archive;
|
||||
use collections::{BTreeMap, HashSet};
|
||||
use fs::{Fs, RemoveOptions};
|
||||
use futures::channel::mpsc::unbounded;
|
||||
use futures::StreamExt as _;
|
||||
use futures::{io::BufReader, AsyncReadExt as _};
|
||||
use futures::{channel::mpsc::unbounded, io::BufReader, AsyncReadExt as _, StreamExt as _};
|
||||
use gpui::{actions, AppContext, Context, Global, Model, ModelContext, Task};
|
||||
use language::{
|
||||
LanguageConfig, LanguageMatcher, LanguageQueries, LanguageRegistry, QUERY_FILENAME_PREFIXES,
|
||||
LanguageConfig, LanguageMatcher, LanguageQueries, LanguageRegistry, LanguageServerName,
|
||||
QUERY_FILENAME_PREFIXES,
|
||||
};
|
||||
use parking_lot::RwLock;
|
||||
use node_runtime::NodeRuntime;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::cmp::Ordering;
|
||||
use std::{
|
||||
cmp::Ordering,
|
||||
ffi::OsStr,
|
||||
path::{Path, PathBuf},
|
||||
path::{self, Path, PathBuf},
|
||||
sync::Arc,
|
||||
time::Duration,
|
||||
};
|
||||
use theme::{ThemeRegistry, ThemeSettings};
|
||||
use util::http::{AsyncBody, HttpClientWithUrl};
|
||||
use util::TryFutureExt;
|
||||
use util::{http::HttpClient, paths::EXTENSIONS_DIR, ResultExt};
|
||||
use util::{
|
||||
http::{AsyncBody, HttpClient, HttpClientWithUrl},
|
||||
paths::EXTENSIONS_DIR,
|
||||
ResultExt, TryFutureExt,
|
||||
};
|
||||
use wasm_host::{WasmExtension, WasmHost};
|
||||
|
||||
#[cfg(test)]
|
||||
mod extension_store_test;
|
||||
use crate::{extension_lsp_adapter::ExtensionLspAdapter, wasm_host::wit};
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct ExtensionsApiResponse {
|
||||
pub data: Vec<Extension>,
|
||||
pub data: Vec<ExtensionApiResponse>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize)]
|
||||
pub struct Extension {
|
||||
pub struct ExtensionApiResponse {
|
||||
pub id: Arc<str>,
|
||||
pub version: Arc<str>,
|
||||
pub name: String,
|
||||
pub version: Arc<str>,
|
||||
pub description: Option<String>,
|
||||
pub authors: Vec<String>,
|
||||
pub repository: String,
|
||||
pub download_count: usize,
|
||||
}
|
||||
|
||||
/// This is the old version of the extension manifest, from when it was `extension.json`.
|
||||
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
|
||||
pub struct OldExtensionManifest {
|
||||
pub name: String,
|
||||
pub version: Arc<str>,
|
||||
|
||||
#[serde(default)]
|
||||
pub description: Option<String>,
|
||||
#[serde(default)]
|
||||
pub repository: Option<String>,
|
||||
#[serde(default)]
|
||||
pub authors: Vec<String>,
|
||||
|
||||
#[serde(default)]
|
||||
pub themes: BTreeMap<Arc<str>, PathBuf>,
|
||||
#[serde(default)]
|
||||
pub languages: BTreeMap<Arc<str>, PathBuf>,
|
||||
#[serde(default)]
|
||||
pub grammars: BTreeMap<Arc<str>, PathBuf>,
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
|
||||
pub struct ExtensionManifest {
|
||||
pub id: Arc<str>,
|
||||
pub name: String,
|
||||
pub version: Arc<str>,
|
||||
|
||||
#[serde(default)]
|
||||
pub description: Option<String>,
|
||||
#[serde(default)]
|
||||
pub repository: Option<String>,
|
||||
#[serde(default)]
|
||||
pub authors: Vec<String>,
|
||||
#[serde(default)]
|
||||
pub lib: LibManifestEntry,
|
||||
|
||||
#[serde(default)]
|
||||
pub themes: Vec<PathBuf>,
|
||||
#[serde(default)]
|
||||
pub languages: Vec<PathBuf>,
|
||||
#[serde(default)]
|
||||
pub grammars: BTreeMap<Arc<str>, GrammarManifestEntry>,
|
||||
#[serde(default)]
|
||||
pub language_servers: BTreeMap<LanguageServerName, LanguageServerManifestEntry>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
|
||||
pub struct LibManifestEntry {
|
||||
path: Option<PathBuf>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
|
||||
pub struct GrammarManifestEntry {
|
||||
repository: String,
|
||||
#[serde(alias = "commit")]
|
||||
rev: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
|
||||
pub struct LanguageServerManifestEntry {
|
||||
language: Arc<str>,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub enum ExtensionStatus {
|
||||
NotInstalled,
|
||||
|
|
@ -67,7 +137,7 @@ impl ExtensionStatus {
|
|||
}
|
||||
|
||||
pub struct ExtensionStore {
|
||||
manifest: Arc<RwLock<Manifest>>,
|
||||
extension_index: ExtensionIndex,
|
||||
fs: Arc<dyn Fs>,
|
||||
http_client: Arc<HttpClientWithUrl>,
|
||||
extensions_dir: PathBuf,
|
||||
|
|
@ -76,7 +146,9 @@ pub struct ExtensionStore {
|
|||
manifest_path: PathBuf,
|
||||
language_registry: Arc<LanguageRegistry>,
|
||||
theme_registry: Arc<ThemeRegistry>,
|
||||
extension_changes: ExtensionChanges,
|
||||
modified_extensions: HashSet<Arc<str>>,
|
||||
wasm_host: Arc<WasmHost>,
|
||||
wasm_extensions: Vec<(Arc<ExtensionManifest>, WasmExtension)>,
|
||||
reload_task: Option<Task<Option<()>>>,
|
||||
needs_reload: bool,
|
||||
_watch_extensions_dir: [Task<()>; 2],
|
||||
|
|
@ -86,56 +158,44 @@ struct GlobalExtensionStore(Model<ExtensionStore>);
|
|||
|
||||
impl Global for GlobalExtensionStore {}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize, Default)]
|
||||
pub struct Manifest {
|
||||
pub extensions: BTreeMap<Arc<str>, Arc<str>>,
|
||||
pub grammars: BTreeMap<Arc<str>, GrammarManifestEntry>,
|
||||
pub languages: BTreeMap<Arc<str>, LanguageManifestEntry>,
|
||||
pub themes: BTreeMap<Arc<str>, ThemeManifestEntry>,
|
||||
#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq)]
|
||||
pub struct ExtensionIndex {
|
||||
pub extensions: BTreeMap<Arc<str>, Arc<ExtensionManifest>>,
|
||||
pub themes: BTreeMap<Arc<str>, ExtensionIndexEntry>,
|
||||
pub languages: BTreeMap<Arc<str>, ExtensionIndexLanguageEntry>,
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq, Debug, PartialOrd, Ord, Deserialize, Serialize)]
|
||||
pub struct GrammarManifestEntry {
|
||||
extension: String,
|
||||
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
|
||||
pub struct ExtensionIndexEntry {
|
||||
extension: Arc<str>,
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
|
||||
pub struct LanguageManifestEntry {
|
||||
extension: String,
|
||||
pub struct ExtensionIndexLanguageEntry {
|
||||
extension: Arc<str>,
|
||||
path: PathBuf,
|
||||
matcher: LanguageMatcher,
|
||||
grammar: Option<Arc<str>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
|
||||
pub struct ThemeManifestEntry {
|
||||
extension: String,
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct ExtensionChanges {
|
||||
languages: HashSet<Arc<str>>,
|
||||
grammars: HashSet<Arc<str>>,
|
||||
themes: HashSet<Arc<str>>,
|
||||
}
|
||||
|
||||
actions!(zed, [ReloadExtensions]);
|
||||
|
||||
pub fn init(
|
||||
fs: Arc<fs::RealFs>,
|
||||
http_client: Arc<HttpClientWithUrl>,
|
||||
node_runtime: Arc<dyn NodeRuntime>,
|
||||
language_registry: Arc<LanguageRegistry>,
|
||||
theme_registry: Arc<ThemeRegistry>,
|
||||
cx: &mut AppContext,
|
||||
) {
|
||||
let store = cx.new_model(|cx| {
|
||||
let store = cx.new_model(move |cx| {
|
||||
ExtensionStore::new(
|
||||
EXTENSIONS_DIR.clone(),
|
||||
fs.clone(),
|
||||
http_client.clone(),
|
||||
language_registry.clone(),
|
||||
fs,
|
||||
http_client,
|
||||
node_runtime,
|
||||
language_registry,
|
||||
theme_registry,
|
||||
cx,
|
||||
)
|
||||
|
|
@ -158,19 +218,28 @@ impl ExtensionStore {
|
|||
extensions_dir: PathBuf,
|
||||
fs: Arc<dyn Fs>,
|
||||
http_client: Arc<HttpClientWithUrl>,
|
||||
node_runtime: Arc<dyn NodeRuntime>,
|
||||
language_registry: Arc<LanguageRegistry>,
|
||||
theme_registry: Arc<ThemeRegistry>,
|
||||
cx: &mut ModelContext<Self>,
|
||||
) -> Self {
|
||||
let mut this = Self {
|
||||
manifest: Default::default(),
|
||||
extension_index: Default::default(),
|
||||
extensions_dir: extensions_dir.join("installed"),
|
||||
manifest_path: extensions_dir.join("manifest.json"),
|
||||
extensions_being_installed: Default::default(),
|
||||
extensions_being_uninstalled: Default::default(),
|
||||
reload_task: None,
|
||||
wasm_host: WasmHost::new(
|
||||
fs.clone(),
|
||||
http_client.clone(),
|
||||
node_runtime,
|
||||
language_registry.clone(),
|
||||
extensions_dir.join("work"),
|
||||
),
|
||||
wasm_extensions: Vec::new(),
|
||||
needs_reload: false,
|
||||
extension_changes: ExtensionChanges::default(),
|
||||
modified_extensions: Default::default(),
|
||||
fs,
|
||||
http_client,
|
||||
language_registry,
|
||||
|
|
@ -194,7 +263,8 @@ impl ExtensionStore {
|
|||
|
||||
if let Some(manifest_content) = manifest_content.log_err() {
|
||||
if let Some(manifest) = serde_json::from_str(&manifest_content).log_err() {
|
||||
self.manifest_updated(manifest, cx);
|
||||
// TODO: don't detach
|
||||
self.extensions_updated(manifest, cx).detach();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -221,11 +291,15 @@ impl ExtensionStore {
|
|||
return ExtensionStatus::Removing;
|
||||
}
|
||||
|
||||
let installed_version = self.manifest.read().extensions.get(extension_id).cloned();
|
||||
let installed_version = self
|
||||
.extension_index
|
||||
.extensions
|
||||
.get(extension_id)
|
||||
.map(|manifest| manifest.version.clone());
|
||||
let is_installing = self.extensions_being_installed.contains(extension_id);
|
||||
match (installed_version, is_installing) {
|
||||
(Some(_), true) => ExtensionStatus::Upgrading,
|
||||
(Some(version), false) => ExtensionStatus::Installed(version.clone()),
|
||||
(Some(version), false) => ExtensionStatus::Installed(version),
|
||||
(None, true) => ExtensionStatus::Installing,
|
||||
(None, false) => ExtensionStatus::NotInstalled,
|
||||
}
|
||||
|
|
@ -235,7 +309,7 @@ impl ExtensionStore {
|
|||
&self,
|
||||
search: Option<&str>,
|
||||
cx: &mut ModelContext<Self>,
|
||||
) -> Task<Result<Vec<Extension>>> {
|
||||
) -> Task<Result<Vec<ExtensionApiResponse>>> {
|
||||
let url = self.http_client.build_zed_api_url(&format!(
|
||||
"/extensions{query}",
|
||||
query = search
|
||||
|
|
@ -335,7 +409,11 @@ impl ExtensionStore {
|
|||
/// no longer in the manifest, or whose files have changed on disk.
|
||||
/// Then it loads any themes, languages, or grammars that are newly
|
||||
/// added to the manifest, or whose files have changed on disk.
|
||||
fn manifest_updated(&mut self, manifest: Manifest, cx: &mut ModelContext<Self>) {
|
||||
fn extensions_updated(
|
||||
&mut self,
|
||||
new_index: ExtensionIndex,
|
||||
cx: &mut ModelContext<Self>,
|
||||
) -> Task<Result<()>> {
|
||||
fn diff<'a, T, I1, I2>(
|
||||
old_keys: I1,
|
||||
new_keys: I2,
|
||||
|
|
@ -379,54 +457,104 @@ impl ExtensionStore {
|
|||
}
|
||||
}
|
||||
|
||||
let old_manifest = self.manifest.read();
|
||||
let (languages_to_remove, languages_to_add) = diff(
|
||||
old_manifest.languages.iter(),
|
||||
manifest.languages.iter(),
|
||||
&self.extension_changes.languages,
|
||||
let old_index = &self.extension_index;
|
||||
let (extensions_to_unload, extensions_to_load) = diff(
|
||||
old_index.extensions.iter(),
|
||||
new_index.extensions.iter(),
|
||||
&self.modified_extensions,
|
||||
);
|
||||
let (grammars_to_remove, grammars_to_add) = diff(
|
||||
old_manifest.grammars.iter(),
|
||||
manifest.grammars.iter(),
|
||||
&self.extension_changes.grammars,
|
||||
);
|
||||
let (themes_to_remove, themes_to_add) = diff(
|
||||
old_manifest.themes.iter(),
|
||||
manifest.themes.iter(),
|
||||
&self.extension_changes.themes,
|
||||
);
|
||||
self.extension_changes.clear();
|
||||
drop(old_manifest);
|
||||
self.modified_extensions.clear();
|
||||
|
||||
let themes_to_remove = &themes_to_remove
|
||||
.into_iter()
|
||||
.map(|theme| theme.into())
|
||||
let themes_to_remove = old_index
|
||||
.themes
|
||||
.iter()
|
||||
.filter_map(|(name, entry)| {
|
||||
if extensions_to_unload.contains(&entry.extension) {
|
||||
Some(name.clone().into())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
let languages_to_remove = old_index
|
||||
.languages
|
||||
.iter()
|
||||
.filter_map(|(name, entry)| {
|
||||
if extensions_to_unload.contains(&entry.extension) {
|
||||
Some(name.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
let empty = Default::default();
|
||||
let grammars_to_remove = extensions_to_unload
|
||||
.iter()
|
||||
.flat_map(|extension_id| {
|
||||
old_index
|
||||
.extensions
|
||||
.get(extension_id)
|
||||
.map_or(&empty, |extension| &extension.grammars)
|
||||
.keys()
|
||||
.cloned()
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
self.wasm_extensions
|
||||
.retain(|(extension, _)| !extensions_to_unload.contains(&extension.id));
|
||||
|
||||
for extension_id in &extensions_to_unload {
|
||||
if let Some(extension) = old_index.extensions.get(extension_id) {
|
||||
for (language_server_name, config) in extension.language_servers.iter() {
|
||||
self.language_registry
|
||||
.remove_lsp_adapter(config.language.as_ref(), language_server_name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self.theme_registry.remove_user_themes(&themes_to_remove);
|
||||
self.language_registry
|
||||
.remove_languages(&languages_to_remove, &grammars_to_remove);
|
||||
|
||||
self.language_registry
|
||||
.register_wasm_grammars(grammars_to_add.iter().map(|grammar_name| {
|
||||
let grammar = manifest.grammars.get(grammar_name).unwrap();
|
||||
let languages_to_add = new_index
|
||||
.languages
|
||||
.iter()
|
||||
.filter(|(_, entry)| extensions_to_load.contains(&entry.extension))
|
||||
.collect::<Vec<_>>();
|
||||
let mut grammars_to_add = Vec::new();
|
||||
let mut themes_to_add = Vec::new();
|
||||
for extension_id in &extensions_to_load {
|
||||
let Some(extension) = new_index.extensions.get(extension_id) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
grammars_to_add.extend(extension.grammars.keys().map(|grammar_name| {
|
||||
let mut grammar_path = self.extensions_dir.clone();
|
||||
grammar_path.extend([grammar.extension.as_ref(), grammar.path.as_path()]);
|
||||
grammar_path.extend([extension_id.as_ref(), "grammars"]);
|
||||
grammar_path.push(grammar_name.as_ref());
|
||||
grammar_path.set_extension("wasm");
|
||||
(grammar_name.clone(), grammar_path)
|
||||
}));
|
||||
themes_to_add.extend(extension.themes.iter().map(|theme_path| {
|
||||
let mut path = self.extensions_dir.clone();
|
||||
path.extend([Path::new(extension_id.as_ref()), theme_path.as_path()]);
|
||||
path
|
||||
}));
|
||||
}
|
||||
|
||||
for language_name in &languages_to_add {
|
||||
if language_name.as_ref() == "Swift" {
|
||||
continue;
|
||||
}
|
||||
self.language_registry
|
||||
.register_wasm_grammars(grammars_to_add);
|
||||
|
||||
let language = manifest.languages.get(language_name.as_ref()).unwrap();
|
||||
for (language_name, language) in languages_to_add {
|
||||
let mut language_path = self.extensions_dir.clone();
|
||||
language_path.extend([language.extension.as_ref(), language.path.as_path()]);
|
||||
language_path.extend([
|
||||
Path::new(language.extension.as_ref()),
|
||||
language.path.as_path(),
|
||||
]);
|
||||
self.language_registry.register_language(
|
||||
language_name.clone(),
|
||||
language.grammar.clone(),
|
||||
language.matcher.clone(),
|
||||
vec![],
|
||||
move || {
|
||||
let config = std::fs::read_to_string(language_path.join("config.toml"))?;
|
||||
let config: LanguageConfig = ::toml::from_str(&config)?;
|
||||
|
|
@ -436,107 +564,119 @@ impl ExtensionStore {
|
|||
);
|
||||
}
|
||||
|
||||
let (reload_theme_tx, mut reload_theme_rx) = unbounded();
|
||||
let fs = self.fs.clone();
|
||||
let wasm_host = self.wasm_host.clone();
|
||||
let root_dir = self.extensions_dir.clone();
|
||||
let theme_registry = self.theme_registry.clone();
|
||||
let themes = themes_to_add
|
||||
let extension_manifests = extensions_to_load
|
||||
.iter()
|
||||
.filter_map(|name| manifest.themes.get(name).cloned())
|
||||
.filter_map(|name| new_index.extensions.get(name).cloned())
|
||||
.collect::<Vec<_>>();
|
||||
cx.background_executor()
|
||||
.spawn(async move {
|
||||
for theme in &themes {
|
||||
let mut theme_path = root_dir.clone();
|
||||
theme_path.extend([theme.extension.as_ref(), theme.path.as_path()]);
|
||||
|
||||
theme_registry
|
||||
.load_user_theme(&theme_path, fs.clone())
|
||||
.await
|
||||
.log_err();
|
||||
}
|
||||
|
||||
reload_theme_tx.unbounded_send(()).ok();
|
||||
})
|
||||
.detach();
|
||||
|
||||
cx.spawn(|_, cx| async move {
|
||||
while let Some(_) = reload_theme_rx.next().await {
|
||||
if cx
|
||||
.update(|cx| ThemeSettings::reload_current_theme(cx))
|
||||
.is_err()
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
})
|
||||
.detach();
|
||||
|
||||
*self.manifest.write() = manifest;
|
||||
self.extension_index = new_index;
|
||||
cx.notify();
|
||||
|
||||
cx.spawn(|this, mut cx| async move {
|
||||
cx.background_executor()
|
||||
.spawn({
|
||||
let fs = fs.clone();
|
||||
async move {
|
||||
for theme_path in &themes_to_add {
|
||||
theme_registry
|
||||
.load_user_theme(&theme_path, fs.clone())
|
||||
.await
|
||||
.log_err();
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
|
||||
let mut wasm_extensions = Vec::new();
|
||||
for extension_manifest in extension_manifests {
|
||||
let Some(wasm_path) = &extension_manifest.lib.path else {
|
||||
continue;
|
||||
};
|
||||
|
||||
let mut path = root_dir.clone();
|
||||
path.extend([
|
||||
Path::new(extension_manifest.id.as_ref()),
|
||||
wasm_path.as_path(),
|
||||
]);
|
||||
let mut wasm_file = fs
|
||||
.open_sync(&path)
|
||||
.await
|
||||
.context("failed to open wasm file")?;
|
||||
let mut wasm_bytes = Vec::new();
|
||||
wasm_file
|
||||
.read_to_end(&mut wasm_bytes)
|
||||
.context("failed to read wasm")?;
|
||||
let wasm_extension = wasm_host
|
||||
.load_extension(
|
||||
wasm_bytes,
|
||||
extension_manifest.clone(),
|
||||
cx.background_executor().clone(),
|
||||
)
|
||||
.await
|
||||
.context("failed to load wasm extension")?;
|
||||
wasm_extensions.push((extension_manifest.clone(), wasm_extension));
|
||||
}
|
||||
|
||||
this.update(&mut cx, |this, cx| {
|
||||
for (manifest, wasm_extension) in &wasm_extensions {
|
||||
for (language_server_name, language_server_config) in &manifest.language_servers
|
||||
{
|
||||
this.language_registry.register_lsp_adapter(
|
||||
language_server_config.language.clone(),
|
||||
Arc::new(ExtensionLspAdapter {
|
||||
extension: wasm_extension.clone(),
|
||||
work_dir: this.wasm_host.work_dir.join(manifest.id.as_ref()),
|
||||
config: wit::LanguageServerConfig {
|
||||
name: language_server_name.0.to_string(),
|
||||
language_name: language_server_config.language.to_string(),
|
||||
},
|
||||
}),
|
||||
);
|
||||
}
|
||||
}
|
||||
this.wasm_extensions.extend(wasm_extensions);
|
||||
ThemeSettings::reload_current_theme(cx)
|
||||
})
|
||||
.ok();
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
fn watch_extensions_dir(&self, cx: &mut ModelContext<Self>) -> [Task<()>; 2] {
|
||||
let manifest = self.manifest.clone();
|
||||
let fs = self.fs.clone();
|
||||
let extensions_dir = self.extensions_dir.clone();
|
||||
|
||||
let (changes_tx, mut changes_rx) = unbounded();
|
||||
let (changed_extensions_tx, mut changed_extensions_rx) = unbounded();
|
||||
|
||||
let events_task = cx.background_executor().spawn(async move {
|
||||
let mut events = fs.watch(&extensions_dir, Duration::from_millis(250)).await;
|
||||
while let Some(events) = events.next().await {
|
||||
let mut changed_grammars = HashSet::default();
|
||||
let mut changed_languages = HashSet::default();
|
||||
let mut changed_themes = HashSet::default();
|
||||
for event in events {
|
||||
let Ok(event_path) = event.path.strip_prefix(&extensions_dir) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
{
|
||||
let manifest = manifest.read();
|
||||
for event in events {
|
||||
for (grammar_name, grammar) in &manifest.grammars {
|
||||
let mut grammar_path = extensions_dir.clone();
|
||||
grammar_path
|
||||
.extend([grammar.extension.as_ref(), grammar.path.as_path()]);
|
||||
if event.path.starts_with(&grammar_path) || event.path == grammar_path {
|
||||
changed_grammars.insert(grammar_name.clone());
|
||||
}
|
||||
}
|
||||
|
||||
for (language_name, language) in &manifest.languages {
|
||||
let mut language_path = extensions_dir.clone();
|
||||
language_path
|
||||
.extend([language.extension.as_ref(), language.path.as_path()]);
|
||||
if event.path.starts_with(&language_path) || event.path == language_path
|
||||
{
|
||||
changed_languages.insert(language_name.clone());
|
||||
}
|
||||
}
|
||||
|
||||
for (theme_name, theme) in &manifest.themes {
|
||||
let mut theme_path = extensions_dir.clone();
|
||||
theme_path.extend([theme.extension.as_ref(), theme.path.as_path()]);
|
||||
if event.path.starts_with(&theme_path) || event.path == theme_path {
|
||||
changed_themes.insert(theme_name.clone());
|
||||
}
|
||||
if let Some(path::Component::Normal(extension_dir_name)) =
|
||||
event_path.components().next()
|
||||
{
|
||||
if let Some(extension_id) = extension_dir_name.to_str() {
|
||||
changed_extensions_tx
|
||||
.unbounded_send(Arc::from(extension_id))
|
||||
.ok();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
changes_tx
|
||||
.unbounded_send(ExtensionChanges {
|
||||
languages: changed_languages,
|
||||
grammars: changed_grammars,
|
||||
themes: changed_themes,
|
||||
})
|
||||
.ok();
|
||||
}
|
||||
});
|
||||
|
||||
let reload_task = cx.spawn(|this, mut cx| async move {
|
||||
while let Some(changes) = changes_rx.next().await {
|
||||
while let Some(changed_extension_id) = changed_extensions_rx.next().await {
|
||||
if this
|
||||
.update(&mut cx, |this, cx| {
|
||||
this.extension_changes.merge(changes);
|
||||
this.modified_extensions.insert(changed_extension_id);
|
||||
this.reload(cx);
|
||||
})
|
||||
.is_err()
|
||||
|
|
@ -556,16 +696,18 @@ impl ExtensionStore {
|
|||
}
|
||||
|
||||
let fs = self.fs.clone();
|
||||
let work_dir = self.wasm_host.work_dir.clone();
|
||||
let extensions_dir = self.extensions_dir.clone();
|
||||
let manifest_path = self.manifest_path.clone();
|
||||
self.needs_reload = false;
|
||||
self.reload_task = Some(cx.spawn(|this, mut cx| {
|
||||
async move {
|
||||
let manifest = cx
|
||||
let extension_index = cx
|
||||
.background_executor()
|
||||
.spawn(async move {
|
||||
let mut manifest = Manifest::default();
|
||||
let mut index = ExtensionIndex::default();
|
||||
|
||||
fs.create_dir(&work_dir).await.log_err();
|
||||
fs.create_dir(&extensions_dir).await.log_err();
|
||||
|
||||
let extension_paths = fs.read_dir(&extensions_dir).await;
|
||||
|
|
@ -574,20 +716,16 @@ impl ExtensionStore {
|
|||
let Ok(extension_dir) = extension_dir else {
|
||||
continue;
|
||||
};
|
||||
Self::add_extension_to_manifest(
|
||||
fs.clone(),
|
||||
extension_dir,
|
||||
&mut manifest,
|
||||
)
|
||||
.await
|
||||
.log_err();
|
||||
Self::add_extension_to_index(fs.clone(), extension_dir, &mut index)
|
||||
.await
|
||||
.log_err();
|
||||
}
|
||||
}
|
||||
|
||||
if let Ok(manifest_json) = serde_json::to_string_pretty(&manifest) {
|
||||
if let Ok(index_json) = serde_json::to_string_pretty(&index) {
|
||||
fs.save(
|
||||
&manifest_path,
|
||||
&manifest_json.as_str().into(),
|
||||
&index_json.as_str().into(),
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
|
|
@ -595,12 +733,17 @@ impl ExtensionStore {
|
|||
.log_err();
|
||||
}
|
||||
|
||||
manifest
|
||||
index
|
||||
})
|
||||
.await;
|
||||
|
||||
if let Ok(task) = this.update(&mut cx, |this, cx| {
|
||||
this.extensions_updated(extension_index, cx)
|
||||
}) {
|
||||
task.await.log_err();
|
||||
}
|
||||
|
||||
this.update(&mut cx, |this, cx| {
|
||||
this.manifest_updated(manifest, cx);
|
||||
this.reload_task.take();
|
||||
if this.needs_reload {
|
||||
this.reload(cx);
|
||||
|
|
@ -611,52 +754,65 @@ impl ExtensionStore {
|
|||
}));
|
||||
}
|
||||
|
||||
async fn add_extension_to_manifest(
|
||||
async fn add_extension_to_index(
|
||||
fs: Arc<dyn Fs>,
|
||||
extension_dir: PathBuf,
|
||||
manifest: &mut Manifest,
|
||||
index: &mut ExtensionIndex,
|
||||
) -> Result<()> {
|
||||
let extension_name = extension_dir
|
||||
.file_name()
|
||||
.and_then(OsStr::to_str)
|
||||
.ok_or_else(|| anyhow!("invalid extension name"))?;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct ExtensionJson {
|
||||
pub version: String,
|
||||
}
|
||||
let mut extension_manifest_path = extension_dir.join("extension.json");
|
||||
let mut extension_manifest;
|
||||
if fs.is_file(&extension_manifest_path).await {
|
||||
let manifest_content = fs
|
||||
.load(&extension_manifest_path)
|
||||
.await
|
||||
.with_context(|| format!("failed to load {extension_name} extension.json"))?;
|
||||
let manifest_json = serde_json::from_str::<OldExtensionManifest>(&manifest_content)
|
||||
.with_context(|| {
|
||||
format!("invalid extension.json for extension {extension_name}")
|
||||
})?;
|
||||
|
||||
let extension_json_path = extension_dir.join("extension.json");
|
||||
let extension_json = fs
|
||||
.load(&extension_json_path)
|
||||
.await
|
||||
.context("failed to load extension.json")?;
|
||||
let extension_json: ExtensionJson =
|
||||
serde_json::from_str(&extension_json).context("invalid extension.json")?;
|
||||
|
||||
manifest
|
||||
.extensions
|
||||
.insert(extension_name.into(), extension_json.version.into());
|
||||
|
||||
if let Ok(mut grammar_paths) = fs.read_dir(&extension_dir.join("grammars")).await {
|
||||
while let Some(grammar_path) = grammar_paths.next().await {
|
||||
let grammar_path = grammar_path?;
|
||||
let Ok(relative_path) = grammar_path.strip_prefix(&extension_dir) else {
|
||||
continue;
|
||||
};
|
||||
let Some(grammar_name) = grammar_path.file_stem().and_then(OsStr::to_str) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
manifest.grammars.insert(
|
||||
grammar_name.into(),
|
||||
GrammarManifestEntry {
|
||||
extension: extension_name.into(),
|
||||
path: relative_path.into(),
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
extension_manifest = ExtensionManifest {
|
||||
id: extension_name.into(),
|
||||
name: manifest_json.name,
|
||||
version: manifest_json.version,
|
||||
description: manifest_json.description,
|
||||
repository: manifest_json.repository,
|
||||
authors: manifest_json.authors,
|
||||
lib: Default::default(),
|
||||
themes: {
|
||||
let mut themes = manifest_json.themes.into_values().collect::<Vec<_>>();
|
||||
themes.sort();
|
||||
themes.dedup();
|
||||
themes
|
||||
},
|
||||
languages: {
|
||||
let mut languages = manifest_json.languages.into_values().collect::<Vec<_>>();
|
||||
languages.sort();
|
||||
languages.dedup();
|
||||
languages
|
||||
},
|
||||
grammars: manifest_json
|
||||
.grammars
|
||||
.into_iter()
|
||||
.map(|(grammar_name, _)| (grammar_name, Default::default()))
|
||||
.collect(),
|
||||
language_servers: Default::default(),
|
||||
};
|
||||
} else {
|
||||
extension_manifest_path.set_extension("toml");
|
||||
let manifest_content = fs
|
||||
.load(&extension_manifest_path)
|
||||
.await
|
||||
.with_context(|| format!("failed to load {extension_name} extension.toml"))?;
|
||||
extension_manifest = ::toml::from_str(&manifest_content).with_context(|| {
|
||||
format!("invalid extension.json for extension {extension_name}")
|
||||
})?;
|
||||
};
|
||||
|
||||
if let Ok(mut language_paths) = fs.read_dir(&extension_dir.join("languages")).await {
|
||||
while let Some(language_path) = language_paths.next().await {
|
||||
|
|
@ -673,11 +829,16 @@ impl ExtensionStore {
|
|||
let config = fs.load(&language_path.join("config.toml")).await?;
|
||||
let config = ::toml::from_str::<LanguageConfig>(&config)?;
|
||||
|
||||
manifest.languages.insert(
|
||||
let relative_path = relative_path.to_path_buf();
|
||||
if !extension_manifest.languages.contains(&relative_path) {
|
||||
extension_manifest.languages.push(relative_path.clone());
|
||||
}
|
||||
|
||||
index.languages.insert(
|
||||
config.name.clone(),
|
||||
LanguageManifestEntry {
|
||||
ExtensionIndexLanguageEntry {
|
||||
extension: extension_name.into(),
|
||||
path: relative_path.into(),
|
||||
path: relative_path,
|
||||
matcher: config.matcher,
|
||||
grammar: config.grammar,
|
||||
},
|
||||
|
|
@ -699,35 +860,39 @@ impl ExtensionStore {
|
|||
continue;
|
||||
};
|
||||
|
||||
for theme in theme_family.themes {
|
||||
let location = ThemeManifestEntry {
|
||||
extension: extension_name.into(),
|
||||
path: relative_path.into(),
|
||||
};
|
||||
let relative_path = relative_path.to_path_buf();
|
||||
if !extension_manifest.themes.contains(&relative_path) {
|
||||
extension_manifest.themes.push(relative_path.clone());
|
||||
}
|
||||
|
||||
manifest.themes.insert(theme.name.into(), location);
|
||||
for theme in theme_family.themes {
|
||||
index.themes.insert(
|
||||
theme.name.into(),
|
||||
ExtensionIndexEntry {
|
||||
extension: extension_name.into(),
|
||||
path: relative_path.clone(),
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let default_extension_wasm_path = extension_dir.join("extension.wasm");
|
||||
if fs.is_file(&default_extension_wasm_path).await {
|
||||
extension_manifest
|
||||
.lib
|
||||
.path
|
||||
.get_or_insert(default_extension_wasm_path);
|
||||
}
|
||||
|
||||
index
|
||||
.extensions
|
||||
.insert(extension_name.into(), Arc::new(extension_manifest));
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ExtensionChanges {
|
||||
fn clear(&mut self) {
|
||||
self.grammars.clear();
|
||||
self.languages.clear();
|
||||
self.themes.clear();
|
||||
}
|
||||
|
||||
fn merge(&mut self, other: Self) {
|
||||
self.grammars.extend(other.grammars);
|
||||
self.languages.extend(other.languages);
|
||||
self.themes.extend(other.themes);
|
||||
}
|
||||
}
|
||||
|
||||
fn load_plugin_queries(root_path: &Path) -> LanguageQueries {
|
||||
let mut result = LanguageQueries::default();
|
||||
if let Some(entries) = std::fs::read_dir(root_path).log_err() {
|
||||
|
|
|
|||
|
|
@ -1,14 +1,27 @@
|
|||
use crate::{
|
||||
ExtensionStore, GrammarManifestEntry, LanguageManifestEntry, Manifest, ThemeManifestEntry,
|
||||
ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry, ExtensionManifest,
|
||||
ExtensionStore, GrammarManifestEntry,
|
||||
};
|
||||
use fs::FakeFs;
|
||||
use async_compression::futures::bufread::GzipEncoder;
|
||||
use collections::BTreeMap;
|
||||
use fs::{FakeFs, Fs};
|
||||
use futures::{io::BufReader, AsyncReadExt, StreamExt};
|
||||
use gpui::{Context, TestAppContext};
|
||||
use language::{LanguageMatcher, LanguageRegistry};
|
||||
use language::{
|
||||
Language, LanguageConfig, LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus,
|
||||
LanguageServerName,
|
||||
};
|
||||
use node_runtime::FakeNodeRuntime;
|
||||
use project::Project;
|
||||
use serde_json::json;
|
||||
use settings::SettingsStore;
|
||||
use std::{path::PathBuf, sync::Arc};
|
||||
use std::{
|
||||
ffi::OsString,
|
||||
path::{Path, PathBuf},
|
||||
sync::Arc,
|
||||
};
|
||||
use theme::ThemeRegistry;
|
||||
use util::http::FakeHttpClient;
|
||||
use util::http::{FakeHttpClient, Response};
|
||||
|
||||
#[gpui::test]
|
||||
async fn test_extension_store(cx: &mut TestAppContext) {
|
||||
|
|
@ -29,7 +42,13 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
"extension.json": r#"{
|
||||
"id": "zed-monokai",
|
||||
"name": "Zed Monokai",
|
||||
"version": "2.0.0"
|
||||
"version": "2.0.0",
|
||||
"themes": {
|
||||
"Monokai Dark": "themes/monokai.json",
|
||||
"Monokai Light": "themes/monokai.json",
|
||||
"Monokai Pro Dark": "themes/monokai-pro.json",
|
||||
"Monokai Pro Light": "themes/monokai-pro.json"
|
||||
}
|
||||
}"#,
|
||||
"themes": {
|
||||
"monokai.json": r#"{
|
||||
|
|
@ -70,7 +89,15 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
"extension.json": r#"{
|
||||
"id": "zed-ruby",
|
||||
"name": "Zed Ruby",
|
||||
"version": "1.0.0"
|
||||
"version": "1.0.0",
|
||||
"grammars": {
|
||||
"ruby": "grammars/ruby.wasm",
|
||||
"embedded_template": "grammars/embedded_template.wasm"
|
||||
},
|
||||
"languages": {
|
||||
"ruby": "languages/ruby",
|
||||
"erb": "languages/erb"
|
||||
}
|
||||
}"#,
|
||||
"grammars": {
|
||||
"ruby.wasm": "",
|
||||
|
|
@ -100,27 +127,49 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
)
|
||||
.await;
|
||||
|
||||
let mut expected_manifest = Manifest {
|
||||
let mut expected_index = ExtensionIndex {
|
||||
extensions: [
|
||||
("zed-ruby".into(), "1.0.0".into()),
|
||||
("zed-monokai".into(), "2.0.0".into()),
|
||||
]
|
||||
.into_iter()
|
||||
.collect(),
|
||||
grammars: [
|
||||
(
|
||||
"embedded_template".into(),
|
||||
GrammarManifestEntry {
|
||||
extension: "zed-ruby".into(),
|
||||
path: "grammars/embedded_template.wasm".into(),
|
||||
},
|
||||
"zed-ruby".into(),
|
||||
ExtensionManifest {
|
||||
id: "zed-ruby".into(),
|
||||
name: "Zed Ruby".into(),
|
||||
version: "1.0.0".into(),
|
||||
description: None,
|
||||
authors: Vec::new(),
|
||||
repository: None,
|
||||
themes: Default::default(),
|
||||
lib: Default::default(),
|
||||
languages: vec!["languages/erb".into(), "languages/ruby".into()],
|
||||
grammars: [
|
||||
("embedded_template".into(), GrammarManifestEntry::default()),
|
||||
("ruby".into(), GrammarManifestEntry::default()),
|
||||
]
|
||||
.into_iter()
|
||||
.collect(),
|
||||
language_servers: BTreeMap::default(),
|
||||
}
|
||||
.into(),
|
||||
),
|
||||
(
|
||||
"ruby".into(),
|
||||
GrammarManifestEntry {
|
||||
extension: "zed-ruby".into(),
|
||||
path: "grammars/ruby.wasm".into(),
|
||||
},
|
||||
"zed-monokai".into(),
|
||||
ExtensionManifest {
|
||||
id: "zed-monokai".into(),
|
||||
name: "Zed Monokai".into(),
|
||||
version: "2.0.0".into(),
|
||||
description: None,
|
||||
authors: vec![],
|
||||
repository: None,
|
||||
themes: vec![
|
||||
"themes/monokai-pro.json".into(),
|
||||
"themes/monokai.json".into(),
|
||||
],
|
||||
lib: Default::default(),
|
||||
languages: Default::default(),
|
||||
grammars: BTreeMap::default(),
|
||||
language_servers: BTreeMap::default(),
|
||||
}
|
||||
.into(),
|
||||
),
|
||||
]
|
||||
.into_iter()
|
||||
|
|
@ -128,7 +177,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
languages: [
|
||||
(
|
||||
"ERB".into(),
|
||||
LanguageManifestEntry {
|
||||
ExtensionIndexLanguageEntry {
|
||||
extension: "zed-ruby".into(),
|
||||
path: "languages/erb".into(),
|
||||
grammar: Some("embedded_template".into()),
|
||||
|
|
@ -140,7 +189,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
),
|
||||
(
|
||||
"Ruby".into(),
|
||||
LanguageManifestEntry {
|
||||
ExtensionIndexLanguageEntry {
|
||||
extension: "zed-ruby".into(),
|
||||
path: "languages/ruby".into(),
|
||||
grammar: Some("ruby".into()),
|
||||
|
|
@ -156,28 +205,28 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
themes: [
|
||||
(
|
||||
"Monokai Dark".into(),
|
||||
ThemeManifestEntry {
|
||||
ExtensionIndexEntry {
|
||||
extension: "zed-monokai".into(),
|
||||
path: "themes/monokai.json".into(),
|
||||
},
|
||||
),
|
||||
(
|
||||
"Monokai Light".into(),
|
||||
ThemeManifestEntry {
|
||||
ExtensionIndexEntry {
|
||||
extension: "zed-monokai".into(),
|
||||
path: "themes/monokai.json".into(),
|
||||
},
|
||||
),
|
||||
(
|
||||
"Monokai Pro Dark".into(),
|
||||
ThemeManifestEntry {
|
||||
ExtensionIndexEntry {
|
||||
extension: "zed-monokai".into(),
|
||||
path: "themes/monokai-pro.json".into(),
|
||||
},
|
||||
),
|
||||
(
|
||||
"Monokai Pro Light".into(),
|
||||
ThemeManifestEntry {
|
||||
ExtensionIndexEntry {
|
||||
extension: "zed-monokai".into(),
|
||||
path: "themes/monokai-pro.json".into(),
|
||||
},
|
||||
|
|
@ -189,12 +238,14 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
|
||||
let language_registry = Arc::new(LanguageRegistry::test());
|
||||
let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
|
||||
let node_runtime = FakeNodeRuntime::new();
|
||||
|
||||
let store = cx.new_model(|cx| {
|
||||
ExtensionStore::new(
|
||||
PathBuf::from("/the-extension-dir"),
|
||||
fs.clone(),
|
||||
http_client.clone(),
|
||||
node_runtime.clone(),
|
||||
language_registry.clone(),
|
||||
theme_registry.clone(),
|
||||
cx,
|
||||
|
|
@ -203,10 +254,10 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
|
||||
cx.executor().run_until_parked();
|
||||
store.read_with(cx, |store, _| {
|
||||
let manifest = store.manifest.read();
|
||||
assert_eq!(manifest.grammars, expected_manifest.grammars);
|
||||
assert_eq!(manifest.languages, expected_manifest.languages);
|
||||
assert_eq!(manifest.themes, expected_manifest.themes);
|
||||
let index = &store.extension_index;
|
||||
assert_eq!(index.extensions, expected_index.extensions);
|
||||
assert_eq!(index.languages, expected_index.languages);
|
||||
assert_eq!(index.themes, expected_index.themes);
|
||||
|
||||
assert_eq!(
|
||||
language_registry.language_names(),
|
||||
|
|
@ -230,7 +281,10 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
"extension.json": r#"{
|
||||
"id": "zed-gruvbox",
|
||||
"name": "Zed Gruvbox",
|
||||
"version": "1.0.0"
|
||||
"version": "1.0.0",
|
||||
"themes": {
|
||||
"Gruvbox": "themes/gruvbox.json"
|
||||
}
|
||||
}"#,
|
||||
"themes": {
|
||||
"gruvbox.json": r#"{
|
||||
|
|
@ -249,9 +303,26 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
)
|
||||
.await;
|
||||
|
||||
expected_manifest.themes.insert(
|
||||
expected_index.extensions.insert(
|
||||
"zed-gruvbox".into(),
|
||||
ExtensionManifest {
|
||||
id: "zed-gruvbox".into(),
|
||||
name: "Zed Gruvbox".into(),
|
||||
version: "1.0.0".into(),
|
||||
description: None,
|
||||
authors: vec![],
|
||||
repository: None,
|
||||
themes: vec!["themes/gruvbox.json".into()],
|
||||
lib: Default::default(),
|
||||
languages: Default::default(),
|
||||
grammars: BTreeMap::default(),
|
||||
language_servers: BTreeMap::default(),
|
||||
}
|
||||
.into(),
|
||||
);
|
||||
expected_index.themes.insert(
|
||||
"Gruvbox".into(),
|
||||
ThemeManifestEntry {
|
||||
ExtensionIndexEntry {
|
||||
extension: "zed-gruvbox".into(),
|
||||
path: "themes/gruvbox.json".into(),
|
||||
},
|
||||
|
|
@ -261,10 +332,10 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
|
||||
cx.executor().run_until_parked();
|
||||
store.read_with(cx, |store, _| {
|
||||
let manifest = store.manifest.read();
|
||||
assert_eq!(manifest.grammars, expected_manifest.grammars);
|
||||
assert_eq!(manifest.languages, expected_manifest.languages);
|
||||
assert_eq!(manifest.themes, expected_manifest.themes);
|
||||
let index = &store.extension_index;
|
||||
assert_eq!(index.extensions, expected_index.extensions);
|
||||
assert_eq!(index.languages, expected_index.languages);
|
||||
assert_eq!(index.themes, expected_index.themes);
|
||||
|
||||
assert_eq!(
|
||||
theme_registry.list_names(false),
|
||||
|
|
@ -289,6 +360,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
PathBuf::from("/the-extension-dir"),
|
||||
fs.clone(),
|
||||
http_client.clone(),
|
||||
node_runtime.clone(),
|
||||
language_registry.clone(),
|
||||
theme_registry.clone(),
|
||||
cx,
|
||||
|
|
@ -297,11 +369,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
|
||||
cx.executor().run_until_parked();
|
||||
store.read_with(cx, |store, _| {
|
||||
let manifest = store.manifest.read();
|
||||
assert_eq!(manifest.grammars, expected_manifest.grammars);
|
||||
assert_eq!(manifest.languages, expected_manifest.languages);
|
||||
assert_eq!(manifest.themes, expected_manifest.themes);
|
||||
|
||||
assert_eq!(store.extension_index, expected_index);
|
||||
assert_eq!(
|
||||
language_registry.language_names(),
|
||||
["ERB", "Plain Text", "Ruby"]
|
||||
|
|
@ -333,19 +401,204 @@ async fn test_extension_store(cx: &mut TestAppContext) {
|
|||
});
|
||||
|
||||
cx.executor().run_until_parked();
|
||||
expected_manifest.extensions.remove("zed-ruby");
|
||||
expected_manifest.languages.remove("Ruby");
|
||||
expected_manifest.languages.remove("ERB");
|
||||
expected_manifest.grammars.remove("ruby");
|
||||
expected_manifest.grammars.remove("embedded_template");
|
||||
expected_index.extensions.remove("zed-ruby");
|
||||
expected_index.languages.remove("Ruby");
|
||||
expected_index.languages.remove("ERB");
|
||||
|
||||
store.read_with(cx, |store, _| {
|
||||
let manifest = store.manifest.read();
|
||||
assert_eq!(manifest.grammars, expected_manifest.grammars);
|
||||
assert_eq!(manifest.languages, expected_manifest.languages);
|
||||
assert_eq!(manifest.themes, expected_manifest.themes);
|
||||
|
||||
assert_eq!(store.extension_index, expected_index);
|
||||
assert_eq!(language_registry.language_names(), ["Plain Text"]);
|
||||
assert_eq!(language_registry.grammar_names(), []);
|
||||
});
|
||||
}
|
||||
|
||||
#[gpui::test]
|
||||
async fn test_extension_store_with_gleam_extension(cx: &mut TestAppContext) {
|
||||
init_test(cx);
|
||||
|
||||
let gleam_extension_dir = PathBuf::from_iter([
|
||||
env!("CARGO_MANIFEST_DIR"),
|
||||
"..",
|
||||
"..",
|
||||
"extensions",
|
||||
"gleam",
|
||||
])
|
||||
.canonicalize()
|
||||
.unwrap();
|
||||
|
||||
compile_extension("zed_gleam", &gleam_extension_dir);
|
||||
|
||||
let fs = FakeFs::new(cx.executor());
|
||||
fs.insert_tree("/the-extension-dir", json!({ "installed": {} }))
|
||||
.await;
|
||||
fs.insert_tree_from_real_fs("/the-extension-dir/installed/gleam", gleam_extension_dir)
|
||||
.await;
|
||||
|
||||
fs.insert_tree(
|
||||
"/the-project-dir",
|
||||
json!({
|
||||
".tool-versions": "rust 1.73.0",
|
||||
"test.gleam": ""
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
|
||||
let project = Project::test(fs.clone(), ["/the-project-dir".as_ref()], cx).await;
|
||||
|
||||
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
|
||||
let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
|
||||
let node_runtime = FakeNodeRuntime::new();
|
||||
|
||||
let mut status_updates = language_registry.language_server_binary_statuses();
|
||||
|
||||
let http_client = FakeHttpClient::create({
|
||||
move |request| async move {
|
||||
match request.uri().to_string().as_str() {
|
||||
"https://api.github.com/repos/gleam-lang/gleam/releases" => Ok(Response::new(
|
||||
json!([
|
||||
{
|
||||
"tag_name": "v1.2.3",
|
||||
"prerelease": false,
|
||||
"tarball_url": "",
|
||||
"zipball_url": "",
|
||||
"assets": [
|
||||
{
|
||||
"name": "gleam-v1.2.3-aarch64-apple-darwin.tar.gz",
|
||||
"browser_download_url": "http://example.com/the-download"
|
||||
}
|
||||
]
|
||||
}
|
||||
])
|
||||
.to_string()
|
||||
.into(),
|
||||
)),
|
||||
|
||||
"http://example.com/the-download" => {
|
||||
let mut bytes = Vec::<u8>::new();
|
||||
let mut archive = async_tar::Builder::new(&mut bytes);
|
||||
let mut header = async_tar::Header::new_gnu();
|
||||
let content = "the-gleam-binary-contents".as_bytes();
|
||||
header.set_size(content.len() as u64);
|
||||
archive
|
||||
.append_data(&mut header, "gleam", content)
|
||||
.await
|
||||
.unwrap();
|
||||
archive.into_inner().await.unwrap();
|
||||
|
||||
let mut gzipped_bytes = Vec::new();
|
||||
let mut encoder = GzipEncoder::new(BufReader::new(bytes.as_slice()));
|
||||
encoder.read_to_end(&mut gzipped_bytes).await.unwrap();
|
||||
|
||||
Ok(Response::new(gzipped_bytes.into()))
|
||||
}
|
||||
|
||||
_ => Ok(Response::builder().status(404).body("not found".into())?),
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let _store = cx.new_model(|cx| {
|
||||
ExtensionStore::new(
|
||||
PathBuf::from("/the-extension-dir"),
|
||||
fs.clone(),
|
||||
http_client.clone(),
|
||||
node_runtime,
|
||||
language_registry.clone(),
|
||||
theme_registry.clone(),
|
||||
cx,
|
||||
)
|
||||
});
|
||||
|
||||
cx.executor().run_until_parked();
|
||||
|
||||
let mut fake_servers = language_registry.fake_language_servers("Gleam");
|
||||
|
||||
let buffer = project
|
||||
.update(cx, |project, cx| {
|
||||
project.open_local_buffer("/the-project-dir/test.gleam", cx)
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
project.update(cx, |project, cx| {
|
||||
project.set_language_for_buffer(
|
||||
&buffer,
|
||||
Arc::new(Language::new(
|
||||
LanguageConfig {
|
||||
name: "Gleam".into(),
|
||||
..Default::default()
|
||||
},
|
||||
None,
|
||||
)),
|
||||
cx,
|
||||
)
|
||||
});
|
||||
|
||||
let fake_server = fake_servers.next().await.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
fs.load("/the-extension-dir/work/gleam/gleam-v1.2.3/gleam".as_ref())
|
||||
.await
|
||||
.unwrap(),
|
||||
"the-gleam-binary-contents"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
fake_server.binary.path,
|
||||
PathBuf::from("/the-extension-dir/work/gleam/gleam-v1.2.3/gleam")
|
||||
);
|
||||
assert_eq!(fake_server.binary.arguments, [OsString::from("lsp")]);
|
||||
|
||||
assert_eq!(
|
||||
[
|
||||
status_updates.next().await.unwrap(),
|
||||
status_updates.next().await.unwrap(),
|
||||
status_updates.next().await.unwrap(),
|
||||
],
|
||||
[
|
||||
(
|
||||
LanguageServerName("gleam".into()),
|
||||
LanguageServerBinaryStatus::CheckingForUpdate
|
||||
),
|
||||
(
|
||||
LanguageServerName("gleam".into()),
|
||||
LanguageServerBinaryStatus::Downloading
|
||||
),
|
||||
(
|
||||
LanguageServerName("gleam".into()),
|
||||
LanguageServerBinaryStatus::Downloaded
|
||||
)
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
fn compile_extension(name: &str, extension_dir_path: &Path) {
|
||||
let output = std::process::Command::new("cargo")
|
||||
.args(["component", "build", "--target-dir"])
|
||||
.arg(extension_dir_path.join("target"))
|
||||
.current_dir(&extension_dir_path)
|
||||
.output()
|
||||
.unwrap();
|
||||
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"failed to build component {}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
|
||||
let mut wasm_path = PathBuf::from(extension_dir_path);
|
||||
wasm_path.extend(["target", "wasm32-wasi", "debug", name]);
|
||||
wasm_path.set_extension("wasm");
|
||||
|
||||
std::fs::rename(wasm_path, extension_dir_path.join("extension.wasm")).unwrap();
|
||||
}
|
||||
|
||||
fn init_test(cx: &mut TestAppContext) {
|
||||
cx.update(|cx| {
|
||||
let store = SettingsStore::test(cx);
|
||||
cx.set_global(store);
|
||||
theme::init(theme::LoadThemes::JustBase, cx);
|
||||
Project::init_settings(cx);
|
||||
language::init(cx);
|
||||
});
|
||||
}
|
||||
|
|
|
|||
405
crates/extension/src/wasm_host.rs
Normal file
405
crates/extension/src/wasm_host.rs
Normal file
|
|
@ -0,0 +1,405 @@
|
|||
use crate::ExtensionManifest;
|
||||
use anyhow::{anyhow, bail, Context as _, Result};
|
||||
use async_compression::futures::bufread::GzipDecoder;
|
||||
use async_tar::Archive;
|
||||
use async_trait::async_trait;
|
||||
use fs::Fs;
|
||||
use futures::{
|
||||
channel::{mpsc::UnboundedSender, oneshot},
|
||||
future::BoxFuture,
|
||||
io::BufReader,
|
||||
Future, FutureExt, StreamExt as _,
|
||||
};
|
||||
use gpui::BackgroundExecutor;
|
||||
use language::{LanguageRegistry, LanguageServerBinaryStatus, LspAdapterDelegate};
|
||||
use node_runtime::NodeRuntime;
|
||||
use std::{
|
||||
path::PathBuf,
|
||||
sync::{Arc, OnceLock},
|
||||
};
|
||||
use util::{http::HttpClient, SemanticVersion};
|
||||
use wasmtime::{
|
||||
component::{Component, Linker, Resource, ResourceTable},
|
||||
Engine, Store,
|
||||
};
|
||||
use wasmtime_wasi::preview2::{command as wasi_command, WasiCtx, WasiCtxBuilder, WasiView};
|
||||
|
||||
pub mod wit {
|
||||
wasmtime::component::bindgen!({
|
||||
async: true,
|
||||
path: "../extension_api/wit",
|
||||
with: {
|
||||
"worktree": super::ExtensionWorktree,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
pub type ExtensionWorktree = Arc<dyn LspAdapterDelegate>;
|
||||
|
||||
pub(crate) struct WasmHost {
|
||||
engine: Engine,
|
||||
linker: Arc<wasmtime::component::Linker<WasmState>>,
|
||||
http_client: Arc<dyn HttpClient>,
|
||||
node_runtime: Arc<dyn NodeRuntime>,
|
||||
language_registry: Arc<LanguageRegistry>,
|
||||
fs: Arc<dyn Fs>,
|
||||
pub(crate) work_dir: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct WasmExtension {
|
||||
tx: UnboundedSender<ExtensionCall>,
|
||||
#[allow(unused)]
|
||||
zed_api_version: SemanticVersion,
|
||||
}
|
||||
|
||||
pub(crate) struct WasmState {
|
||||
manifest: Arc<ExtensionManifest>,
|
||||
table: ResourceTable,
|
||||
ctx: WasiCtx,
|
||||
host: Arc<WasmHost>,
|
||||
}
|
||||
|
||||
type ExtensionCall = Box<
|
||||
dyn Send
|
||||
+ for<'a> FnOnce(&'a mut wit::Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, ()>,
|
||||
>;
|
||||
|
||||
static WASM_ENGINE: OnceLock<wasmtime::Engine> = OnceLock::new();
|
||||
|
||||
impl WasmHost {
|
||||
pub fn new(
|
||||
fs: Arc<dyn Fs>,
|
||||
http_client: Arc<dyn HttpClient>,
|
||||
node_runtime: Arc<dyn NodeRuntime>,
|
||||
language_registry: Arc<LanguageRegistry>,
|
||||
work_dir: PathBuf,
|
||||
) -> Arc<Self> {
|
||||
let engine = WASM_ENGINE
|
||||
.get_or_init(|| {
|
||||
let mut config = wasmtime::Config::new();
|
||||
config.wasm_component_model(true);
|
||||
config.async_support(true);
|
||||
wasmtime::Engine::new(&config).unwrap()
|
||||
})
|
||||
.clone();
|
||||
let mut linker = Linker::new(&engine);
|
||||
wasi_command::add_to_linker(&mut linker).unwrap();
|
||||
wit::Extension::add_to_linker(&mut linker, |state: &mut WasmState| state).unwrap();
|
||||
Arc::new(Self {
|
||||
engine,
|
||||
linker: Arc::new(linker),
|
||||
fs,
|
||||
work_dir,
|
||||
http_client,
|
||||
node_runtime,
|
||||
language_registry,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn load_extension(
|
||||
self: &Arc<Self>,
|
||||
wasm_bytes: Vec<u8>,
|
||||
manifest: Arc<ExtensionManifest>,
|
||||
executor: BackgroundExecutor,
|
||||
) -> impl 'static + Future<Output = Result<WasmExtension>> {
|
||||
let this = self.clone();
|
||||
async move {
|
||||
let component = Component::from_binary(&this.engine, &wasm_bytes)
|
||||
.context("failed to compile wasm component")?;
|
||||
|
||||
let mut zed_api_version = None;
|
||||
for part in wasmparser::Parser::new(0).parse_all(&wasm_bytes) {
|
||||
if let wasmparser::Payload::CustomSection(s) = part? {
|
||||
if s.name() == "zed:api-version" {
|
||||
if s.data().len() != 6 {
|
||||
bail!(
|
||||
"extension {} has invalid zed:api-version section: {:?}",
|
||||
manifest.id,
|
||||
s.data()
|
||||
);
|
||||
}
|
||||
|
||||
let major = u16::from_be_bytes(s.data()[0..2].try_into().unwrap()) as _;
|
||||
let minor = u16::from_be_bytes(s.data()[2..4].try_into().unwrap()) as _;
|
||||
let patch = u16::from_be_bytes(s.data()[4..6].try_into().unwrap()) as _;
|
||||
zed_api_version = Some(SemanticVersion {
|
||||
major,
|
||||
minor,
|
||||
patch,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let Some(zed_api_version) = zed_api_version else {
|
||||
bail!("extension {} has no zed:api-version section", manifest.id);
|
||||
};
|
||||
|
||||
let mut store = wasmtime::Store::new(
|
||||
&this.engine,
|
||||
WasmState {
|
||||
manifest,
|
||||
table: ResourceTable::new(),
|
||||
ctx: WasiCtxBuilder::new()
|
||||
.inherit_stdio()
|
||||
.env("RUST_BACKTRACE", "1")
|
||||
.build(),
|
||||
host: this.clone(),
|
||||
},
|
||||
);
|
||||
let (mut extension, instance) =
|
||||
wit::Extension::instantiate_async(&mut store, &component, &this.linker)
|
||||
.await
|
||||
.context("failed to instantiate wasm component")?;
|
||||
let (tx, mut rx) = futures::channel::mpsc::unbounded::<ExtensionCall>();
|
||||
executor
|
||||
.spawn(async move {
|
||||
extension.call_init_extension(&mut store).await.unwrap();
|
||||
|
||||
let _instance = instance;
|
||||
while let Some(call) = rx.next().await {
|
||||
(call)(&mut extension, &mut store).await;
|
||||
}
|
||||
})
|
||||
.detach();
|
||||
Ok(WasmExtension {
|
||||
tx,
|
||||
zed_api_version,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl WasmExtension {
|
||||
pub async fn call<T, Fn>(&self, f: Fn) -> T
|
||||
where
|
||||
T: 'static + Send,
|
||||
Fn: 'static
|
||||
+ Send
|
||||
+ for<'a> FnOnce(&'a mut wit::Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, T>,
|
||||
{
|
||||
let (return_tx, return_rx) = oneshot::channel();
|
||||
self.tx
|
||||
.clone()
|
||||
.unbounded_send(Box::new(move |extension, store| {
|
||||
async {
|
||||
let result = f(extension, store).await;
|
||||
return_tx.send(result).ok();
|
||||
}
|
||||
.boxed()
|
||||
}))
|
||||
.expect("wasm extension channel should not be closed yet");
|
||||
return_rx.await.expect("wasm extension channel")
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl wit::HostWorktree for WasmState {
|
||||
async fn read_text_file(
|
||||
&mut self,
|
||||
delegate: Resource<Arc<dyn LspAdapterDelegate>>,
|
||||
path: String,
|
||||
) -> wasmtime::Result<Result<String, String>> {
|
||||
let delegate = self.table().get(&delegate)?;
|
||||
Ok(delegate
|
||||
.read_text_file(path.into())
|
||||
.await
|
||||
.map_err(|error| error.to_string()))
|
||||
}
|
||||
|
||||
fn drop(&mut self, _worktree: Resource<wit::Worktree>) -> Result<()> {
|
||||
// we only ever hand out borrows of worktrees
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl wit::ExtensionImports for WasmState {
|
||||
async fn npm_package_latest_version(
|
||||
&mut self,
|
||||
package_name: String,
|
||||
) -> wasmtime::Result<Result<String, String>> {
|
||||
async fn inner(this: &mut WasmState, package_name: String) -> anyhow::Result<String> {
|
||||
this.host
|
||||
.node_runtime
|
||||
.npm_package_latest_version(&package_name)
|
||||
.await
|
||||
}
|
||||
|
||||
Ok(inner(self, package_name)
|
||||
.await
|
||||
.map_err(|err| err.to_string()))
|
||||
}
|
||||
|
||||
async fn latest_github_release(
|
||||
&mut self,
|
||||
repo: String,
|
||||
options: wit::GithubReleaseOptions,
|
||||
) -> wasmtime::Result<Result<wit::GithubRelease, String>> {
|
||||
async fn inner(
|
||||
this: &mut WasmState,
|
||||
repo: String,
|
||||
options: wit::GithubReleaseOptions,
|
||||
) -> anyhow::Result<wit::GithubRelease> {
|
||||
let release = util::github::latest_github_release(
|
||||
&repo,
|
||||
options.require_assets,
|
||||
options.pre_release,
|
||||
this.host.http_client.clone(),
|
||||
)
|
||||
.await?;
|
||||
Ok(wit::GithubRelease {
|
||||
version: release.tag_name,
|
||||
assets: release
|
||||
.assets
|
||||
.into_iter()
|
||||
.map(|asset| wit::GithubReleaseAsset {
|
||||
name: asset.name,
|
||||
download_url: asset.browser_download_url,
|
||||
})
|
||||
.collect(),
|
||||
})
|
||||
}
|
||||
|
||||
Ok(inner(self, repo, options)
|
||||
.await
|
||||
.map_err(|err| err.to_string()))
|
||||
}
|
||||
|
||||
async fn current_platform(&mut self) -> Result<(wit::Os, wit::Architecture)> {
|
||||
Ok((
|
||||
match std::env::consts::OS {
|
||||
"macos" => wit::Os::Mac,
|
||||
"linux" => wit::Os::Linux,
|
||||
"windows" => wit::Os::Windows,
|
||||
_ => panic!("unsupported os"),
|
||||
},
|
||||
match std::env::consts::ARCH {
|
||||
"aarch64" => wit::Architecture::Aarch64,
|
||||
"x86" => wit::Architecture::X86,
|
||||
"x86_64" => wit::Architecture::X8664,
|
||||
_ => panic!("unsupported architecture"),
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
async fn set_language_server_installation_status(
|
||||
&mut self,
|
||||
server_name: String,
|
||||
status: wit::LanguageServerInstallationStatus,
|
||||
) -> wasmtime::Result<()> {
|
||||
let status = match status {
|
||||
wit::LanguageServerInstallationStatus::CheckingForUpdate => {
|
||||
LanguageServerBinaryStatus::CheckingForUpdate
|
||||
}
|
||||
wit::LanguageServerInstallationStatus::Downloading => {
|
||||
LanguageServerBinaryStatus::Downloading
|
||||
}
|
||||
wit::LanguageServerInstallationStatus::Downloaded => {
|
||||
LanguageServerBinaryStatus::Downloaded
|
||||
}
|
||||
wit::LanguageServerInstallationStatus::Cached => LanguageServerBinaryStatus::Cached,
|
||||
wit::LanguageServerInstallationStatus::Failed(error) => {
|
||||
LanguageServerBinaryStatus::Failed { error }
|
||||
}
|
||||
};
|
||||
|
||||
self.host
|
||||
.language_registry
|
||||
.update_lsp_status(language::LanguageServerName(server_name.into()), status);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn download_file(
|
||||
&mut self,
|
||||
url: String,
|
||||
filename: String,
|
||||
file_type: wit::DownloadedFileType,
|
||||
) -> wasmtime::Result<Result<(), String>> {
|
||||
async fn inner(
|
||||
this: &mut WasmState,
|
||||
url: String,
|
||||
filename: String,
|
||||
file_type: wit::DownloadedFileType,
|
||||
) -> anyhow::Result<()> {
|
||||
this.host.fs.create_dir(&this.host.work_dir).await?;
|
||||
let container_dir = this.host.work_dir.join(this.manifest.id.as_ref());
|
||||
let destination_path = container_dir.join(&filename);
|
||||
|
||||
let mut response = this
|
||||
.host
|
||||
.http_client
|
||||
.get(&url, Default::default(), true)
|
||||
.await
|
||||
.map_err(|err| anyhow!("error downloading release: {}", err))?;
|
||||
|
||||
if !response.status().is_success() {
|
||||
Err(anyhow!(
|
||||
"download failed with status {}",
|
||||
response.status().to_string()
|
||||
))?;
|
||||
}
|
||||
let body = BufReader::new(response.body_mut());
|
||||
|
||||
match file_type {
|
||||
wit::DownloadedFileType::Uncompressed => {
|
||||
futures::pin_mut!(body);
|
||||
this.host
|
||||
.fs
|
||||
.create_file_with(&destination_path, body)
|
||||
.await?;
|
||||
}
|
||||
wit::DownloadedFileType::Gzip => {
|
||||
let body = GzipDecoder::new(body);
|
||||
futures::pin_mut!(body);
|
||||
this.host
|
||||
.fs
|
||||
.create_file_with(&destination_path, body)
|
||||
.await?;
|
||||
}
|
||||
wit::DownloadedFileType::GzipTar => {
|
||||
let body = GzipDecoder::new(body);
|
||||
futures::pin_mut!(body);
|
||||
this.host
|
||||
.fs
|
||||
.extract_tar_file(&destination_path, Archive::new(body))
|
||||
.await?;
|
||||
}
|
||||
wit::DownloadedFileType::Zip => {
|
||||
let zip_filename = format!("{filename}.zip");
|
||||
let mut zip_path = destination_path.clone();
|
||||
zip_path.set_file_name(zip_filename);
|
||||
futures::pin_mut!(body);
|
||||
this.host.fs.create_file_with(&zip_path, body).await?;
|
||||
|
||||
let unzip_status = std::process::Command::new("unzip")
|
||||
.current_dir(&container_dir)
|
||||
.arg(&zip_path)
|
||||
.output()?
|
||||
.status;
|
||||
if !unzip_status.success() {
|
||||
Err(anyhow!("failed to unzip {filename} archive"))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
Ok(inner(self, url, filename, file_type)
|
||||
.await
|
||||
.map(|_| ())
|
||||
.map_err(|err| err.to_string()))
|
||||
}
|
||||
}
|
||||
|
||||
impl WasiView for WasmState {
|
||||
fn table(&mut self) -> &mut ResourceTable {
|
||||
&mut self.table
|
||||
}
|
||||
|
||||
fn ctx(&mut self) -> &mut WasiCtx {
|
||||
&mut self.ctx
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue