feat: Add support for Spin plugins

Cargo.toml

@@ -35,6 +35,7 @@ spin-engine = { path = "crates/engine" }
 spin-http-engine = { path = "crates/http" }
 spin-loader = { path = "crates/loader" }
 spin-manifest = { path = "crates/manifest" }
+spin-plugins = { path = "crates/plugins" }
 spin-publish = { path = "crates/publish" }
 spin-redis-engine = { path = "crates/redis" }
 spin-templates = { path = "crates/templates" }
@@ -78,6 +79,7 @@ members = [
     "crates/manifest",
     "crates/outbound-http",
     "crates/outbound-redis",
+    "crates/plugins",
     "crates/redis",
     "crates/templates",
     "crates/testing",

crates/plugins/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "spin-plugins"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0"
+bytes = "1.1"
+dirs = "4.0"
+flate2 = "1.0"
+log = { version = "0.4", default-features = false }
+reqwest = { version = "0.11", features = ["json"] }
+semver = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+sha2 = "0.10.2"
+tar = "0.4.38"
+tempfile = "3.3.0"
+thiserror = "1"
+tokio = { version = "1.10", features = [ "fs", "process", "rt", "macros" ] }
+url = "2.2.2"

crates/plugins/src/error.rs

@@ -0,0 +1,89 @@
+pub type PluginLookupResult<T> = std::result::Result<T, Error>;
+
+/// Error message during plugin lookup or deserializing
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("{0}")]
+    NotFound(NotFoundError),
+
+    #[error("{0}")]
+    ConnectionFailed(ConnectionFailedError),
+
+    #[error("{0}")]
+    InvalidManifest(InvalidManifestError),
+
+    #[error("URL parse error {0}")]
+    UrlParseError(#[from] url::ParseError),
+}
+
+/// Contains error details for when a plugin resource cannot be found at expected location
+#[derive(Debug)]
+pub struct NotFoundError {
+    name: Option<String>,
+    addr: String,
+    err: String,
+}
+
+impl NotFoundError {
+    pub fn new(name: Option<String>, addr: String, err: String) -> Self {
+        Self { name, addr, err }
+    }
+}
+
+impl std::fmt::Display for NotFoundError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!(
+            "plugin '{}' not found at expected location {}: {}",
+            self.name.as_deref().unwrap_or_default(),
+            self.addr,
+            self.err
+        ))
+    }
+}
+
+/// Contains error details for when a plugin manifest cannot be properly serialized
+#[derive(Debug)]
+pub struct InvalidManifestError {
+    name: Option<String>,
+    addr: String,
+    err: String,
+}
+
+impl InvalidManifestError {
+    pub fn new(name: Option<String>, addr: String, err: String) -> Self {
+        Self { name, addr, err }
+    }
+}
+
+impl std::fmt::Display for InvalidManifestError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!(
+            "invalid manifest for plugin '{}' at {}: {}",
+            self.name.clone().unwrap_or_default(),
+            self.addr,
+            self.err
+        ))
+    }
+}
+
+/// Contains error details for when there is an error getting a plugin resource from an address.
+#[derive(Debug)]
+pub struct ConnectionFailedError {
+    addr: String,
+    err: String,
+}
+
+impl ConnectionFailedError {
+    pub fn new(addr: String, err: String) -> Self {
+        Self { addr, err }
+    }
+}
+
+impl std::fmt::Display for ConnectionFailedError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!(
+            "failed to connect to endpoint {}: {}",
+            self.addr, self.err
+        ))
+    }
+}

crates/plugins/src/git.rs

@@ -0,0 +1,65 @@
+use anyhow::Result;
+use std::path::{Path, PathBuf};
+use tokio::process::Command;
+use url::Url;
+
+const DEFAULT_BRANCH: &str = "main";
+
+/// Enables cloning and fetching the latest of a git repository to a local
+/// directory.
+pub struct GitSource {
+    /// Address to remote git repository.
+    source_url: Url,
+    /// Branch to clone/fetch.
+    branch: String,
+    /// Destination to clone repository into.
+    git_root: PathBuf,
+}
+
+impl GitSource {
+    /// Creates a new git source
+    pub fn new(source_url: &Url, branch: Option<String>, git_root: impl AsRef<Path>) -> GitSource {
+        Self {
+            source_url: source_url.clone(),
+            branch: branch.unwrap_or_else(|| DEFAULT_BRANCH.to_owned()),
+            git_root: git_root.as_ref().to_owned(),
+        }
+    }
+
+    /// Clones a contents of a git repository to a local directory
+    pub async fn clone_repo(&self) -> Result<()> {
+        let mut git = Command::new("git");
+        git.args([
+            "clone",
+            self.source_url.as_ref(),
+            "--branch",
+            &self.branch,
+            "--single-branch",
+        ])
+        .arg(&self.git_root);
+        let clone_result = git.output().await?;
+        if !clone_result.status.success() {
+            anyhow::bail!(
+                "Error cloning Git repo {}: {}",
+                self.source_url,
+                String::from_utf8_lossy(&clone_result.stderr)
+            )
+        }
+        Ok(())
+    }
+
+    /// Fetches the latest changes from the source repository
+    pub async fn pull(&self) -> Result<()> {
+        let mut git = Command::new("git");
+        git.arg("-C").arg(&self.git_root).arg("pull");
+        let pull_result = git.output().await?;
+        if !pull_result.status.success() {
+            anyhow::bail!(
+                "Error updating Git repo at {}: {}",
+                self.git_root.display(),
+                String::from_utf8_lossy(&pull_result.stderr)
+            )
+        }
+        Ok(())
+    }
+}

crates/plugins/src/lib.rs

@@ -0,0 +1,22 @@
+pub mod error;
+mod git;
+pub mod lookup;
+pub mod manager;
+pub mod manifest;
+mod prompt;
+mod store;
+pub use prompt::prompt_confirm_install;
+pub use store::PluginStore;
+
+/// List of Spin internal subcommands
+pub(crate) const SPIN_INTERNAL_COMMANDS: [&str; 9] = [
+    "templates",
+    "up",
+    "new",
+    "bindle",
+    "deploy",
+    "build",
+    "plugin",
+    "trigger",
+    "external",
+];

crates/plugins/src/lookup.rs

@@ -0,0 +1,107 @@
+use crate::{error::*, git::GitSource, manifest::PluginManifest, store::manifest_file_name};
+use semver::Version;
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+};
+use url::Url;
+
+// Name of directory that contains the cloned centralized Spin plugins
+// repository
+const PLUGINS_REPO_LOCAL_DIRECTORY: &str = ".spin-plugins";
+
+// Name of directory containing the installed manifests
+const PLUGINS_REPO_MANIFESTS_DIRECTORY: &str = "manifests";
+
+const SPIN_PLUGINS_REPO: &str = "https://github.com/fermyon/spin-plugins/";
+
+/// Looks up plugin manifests in centralized spin plugin repository.
+pub struct PluginLookup {
+    pub name: String,
+    pub version: Option<Version>,
+}
+
+impl PluginLookup {
+    pub fn new(name: &str, version: Option<Version>) -> Self {
+        Self {
+            name: name.to_lowercase(),
+            version,
+        }
+    }
+
+    pub async fn get_manifest_from_repository(
+        &self,
+        plugins_dir: &Path,
+    ) -> PluginLookupResult<PluginManifest> {
+        let url = plugins_repo_url()?;
+        log::info!("Pulling manifest for plugin {} from {url}", self.name);
+        fetch_plugins_repo(&url, plugins_dir, false)
+            .await
+            .map_err(|e| {
+                Error::ConnectionFailed(ConnectionFailedError::new(url.to_string(), e.to_string()))
+            })?;
+        let expected_path = spin_plugins_repo_manifest_path(&self.name, &self.version, plugins_dir);
+        let file = File::open(&expected_path).map_err(|e| {
+            Error::NotFound(NotFoundError::new(
+                Some(self.name.clone()),
+                expected_path.display().to_string(),
+                e.to_string(),
+            ))
+        })?;
+        let manifest: PluginManifest = serde_json::from_reader(file).map_err(|e| {
+            Error::InvalidManifest(InvalidManifestError::new(
+                Some(self.name.clone()),
+                expected_path.display().to_string(),
+                e.to_string(),
+            ))
+        })?;
+        Ok(manifest)
+    }
+}
+
+pub fn plugins_repo_url() -> Result<Url, url::ParseError> {
+    Url::parse(SPIN_PLUGINS_REPO)
+}
+
+pub async fn fetch_plugins_repo(
+    repo_url: &Url,
+    plugins_dir: &Path,
+    update: bool,
+) -> anyhow::Result<()> {
+    let git_root = plugin_manifests_repo_path(plugins_dir);
+    let git_source = GitSource::new(repo_url, None, &git_root);
+    if git_root.join(".git").exists() {
+        if update {
+            git_source.pull().await?;
+        }
+    } else {
+        git_source.clone_repo().await?;
+    }
+    Ok(())
+}
+
+fn plugin_manifests_repo_path(plugins_dir: &Path) -> PathBuf {
+    plugins_dir.join(PLUGINS_REPO_LOCAL_DIRECTORY)
+}
+
+// Given a name and option version, outputs expected file name for the plugin.
+fn manifest_file_name_version(plugin_name: &str, version: &Option<semver::Version>) -> String {
+    match version {
+        Some(v) => format!("{}@{}.json", plugin_name, v),
+        None => manifest_file_name(plugin_name),
+    }
+}
+
+/// Get expected path to the manifest of a plugin with a given name
+/// and version within the spin-plugins repository
+fn spin_plugins_repo_manifest_path(
+    plugin_name: &str,
+    plugin_version: &Option<Version>,
+    plugins_dir: &Path,
+) -> PathBuf {
+    plugins_dir
+        .join(PLUGINS_REPO_LOCAL_DIRECTORY)
+        .join(PLUGINS_REPO_MANIFESTS_DIRECTORY)
+        .join(plugin_name)
+        .join(manifest_file_name_version(plugin_name, plugin_version))
+}