Merge pull request #889 from itowlson/templates-new-component

`spin new`: add component to existing application

Author: itowlson

crates/plugins/src/lib.rs

@@ -7,10 +7,11 @@ mod store;
 pub use store::PluginStore;
 
 /// List of Spin internal subcommands
-pub(crate) const SPIN_INTERNAL_COMMANDS: [&str; 9] = [
+pub(crate) const SPIN_INTERNAL_COMMANDS: [&str; 10] = [
     "templates",
     "up",
     "new",
+    "add",
     "bindle",
     "deploy",
     "build",

crates/templates/src/app_info.rs

@@ -0,0 +1,64 @@
+// Information about the application manifest that is of
+// interest to the template system.  spin_loader does too
+// much processing to fit our needs here.
+
+use std::path::{Path, PathBuf};
+
+use anyhow::Context;
+
+use crate::store::TemplateLayout;
+
+#[derive(Debug, serde::Deserialize)]
+#[serde(tag = "spin_version")]
+pub(crate) enum AppInfo {
+    /// A manifest with API version 1.
+    #[serde(rename = "1")]
+    V1(AppInfoV1),
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub(crate) struct AppInfoV1 {
+    trigger: TriggerInfo,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub(crate) struct TriggerInfo {
+    #[serde(rename = "type")]
+    trigger_type: String,
+}
+
+impl AppInfo {
+    pub(crate) fn from_layout(layout: &TemplateLayout) -> Option<anyhow::Result<AppInfo>> {
+        Self::layout_manifest_path(layout)
+            .map(|manifest_path| Self::from_existent_file(&manifest_path))
+    }
+
+    pub(crate) fn from_file(manifest_path: &Path) -> Option<anyhow::Result<AppInfo>> {
+        if manifest_path.exists() {
+            Some(Self::from_existent_file(manifest_path))
+        } else {
+            None
+        }
+    }
+
+    fn layout_manifest_path(layout: &TemplateLayout) -> Option<PathBuf> {
+        let manifest_path = layout.content_dir().join("spin.toml");
+        if manifest_path.exists() {
+            Some(manifest_path)
+        } else {
+            None
+        }
+    }
+
+    fn from_existent_file(manifest_path: &Path) -> anyhow::Result<AppInfo> {
+        let manifest_text =
+            std::fs::read_to_string(manifest_path).context("Can't read manifest file")?;
+        toml::from_str(&manifest_text).context("Can't parse manifest file")
+    }
+
+    pub(crate) fn trigger_type(&self) -> &str {
+        match self {
+            Self::V1(info) => &info.trigger.trigger_type,
+        }
+    }
+}

crates/templates/src/lib.rs

@@ -2,6 +2,7 @@
 
 #![deny(missing_docs)]
 
+mod app_info;
 mod constraints;
 mod custom_filters;
 mod directory;
@@ -18,4 +19,4 @@ mod template;
 pub use manager::*;
 pub use run::{Run, RunOptions, TemplatePreparationResult};
 pub use source::TemplateSource;
-pub use template::Template;
+pub use template::{Template, TemplateVariantKind};

crates/templates/src/manager.rs

@@ -414,7 +414,7 @@ mod tests {
         PathBuf::from(crate_dir).join("tests")
     }
 
-    const TPLS_IN_THIS: usize = 8;
+    const TPLS_IN_THIS: usize = 9;
 
     #[tokio::test]
     async fn can_install_into_new_directory() {
@@ -631,10 +631,12 @@ mod tests {
         .into_iter()
         .collect();
         let options = RunOptions {
+            variant: crate::template::TemplateVariantKind::NewApplication,
             output_path: output_dir.clone(),
             name: "my project".to_owned(),
             values,
             accept_defaults: false,
+            existing_manifest: None,
         };
 
         template
@@ -669,10 +671,12 @@ mod tests {
         let output_dir = dest_temp_dir.path().join("myproj");
         let values = HashMap::new();
         let options = RunOptions {
+            variant: crate::template::TemplateVariantKind::NewApplication,
             output_path: output_dir.clone(),
             name: "my project".to_owned(),
             values,
             accept_defaults: true,
+            existing_manifest: None,
         };
 
         template
@@ -716,10 +720,12 @@ mod tests {
         .into_iter()
         .collect();
         let options = RunOptions {
+            variant: crate::template::TemplateVariantKind::NewApplication,
             output_path: output_dir.clone(),
             name: "custom-filter-test".to_owned(),
             values,
             accept_defaults: false,
+            existing_manifest: None,
         };
 
         template
@@ -737,4 +743,206 @@ mod tests {
         assert!(message.contains("p2/studly = nOmNoMnOm"));
         assert!(message.contains("p1/clappy = b👏i👏s👏c👏u👏i👏t👏s"));
     }
+
+    #[tokio::test]
+    async fn can_add_component_from_template() {
+        let temp_dir = tempdir().unwrap();
+        let store = TemplateStore::new(temp_dir.path());
+        let manager = TemplateManager { store };
+        let source = TemplateSource::File(project_root());
+
+        manager
+            .install(&source, &InstallOptions::default(), &DiscardingReporter)
+            .await
+            .unwrap();
+
+        let dest_temp_dir = tempdir().unwrap();
+        let application_dir = dest_temp_dir.path().join("multi");
+
+        // Set up the containing app
+        {
+            let template = manager.get("http-empty").unwrap().unwrap();
+
+            let values = [
+                ("project-description".to_owned(), "my desc".to_owned()),
+                ("http-base".to_owned(), "/".to_owned()),
+            ]
+            .into_iter()
+            .collect();
+            let options = RunOptions {
+                variant: crate::template::TemplateVariantKind::NewApplication,
+                output_path: application_dir.clone(),
+                name: "my multi project".to_owned(),
+                values,
+                accept_defaults: false,
+                existing_manifest: None,
+            };
+
+            template
+                .run(options)
+                .silent()
+                .await
+                .execute()
+                .await
+                .unwrap();
+        }
+
+        let spin_toml_path = application_dir.join("spin.toml");
+        assert!(spin_toml_path.exists(), "expected spin.toml to be created");
+
+        // Now add a component
+        {
+            let template = manager.get("http-rust").unwrap().unwrap();
+
+            let output_dir = "hello";
+            let values = [
+                ("project-description".to_owned(), "hello".to_owned()),
+                ("http-path".to_owned(), "/hello".to_owned()),
+            ]
+            .into_iter()
+            .collect();
+            let options = RunOptions {
+                variant: crate::template::TemplateVariantKind::AddComponent,
+                output_path: PathBuf::from(output_dir),
+                name: "hello".to_owned(),
+                values,
+                accept_defaults: false,
+                existing_manifest: Some(spin_toml_path.clone()),
+            };
+
+            template
+                .run(options)
+                .silent()
+                .await
+                .execute()
+                .await
+                .unwrap();
+        }
+
+        // And another
+        {
+            let template = manager.get("http-rust").unwrap().unwrap();
+
+            let output_dir = "encore";
+            let values = [
+                ("project-description".to_owned(), "hello 2".to_owned()),
+                ("http-path".to_owned(), "/hello-2".to_owned()),
+            ]
+            .into_iter()
+            .collect();
+            let options = RunOptions {
+                variant: crate::template::TemplateVariantKind::AddComponent,
+                output_path: PathBuf::from(output_dir),
+                name: "hello 2".to_owned(),
+                values,
+                accept_defaults: false,
+                existing_manifest: Some(spin_toml_path.clone()),
+            };
+
+            template
+                .run(options)
+                .silent()
+                .await
+                .execute()
+                .await
+                .unwrap();
+        }
+
+        let cargo1 = tokio::fs::read_to_string(application_dir.join("hello/Cargo.toml"))
+            .await
+            .unwrap();
+        assert!(cargo1.contains("name = \"hello\""));
+
+        let cargo2 = tokio::fs::read_to_string(application_dir.join("encore/Cargo.toml"))
+            .await
+            .unwrap();
+        assert!(cargo2.contains("name = \"hello-2\""));
+
+        let spin_toml = tokio::fs::read_to_string(&spin_toml_path).await.unwrap();
+        assert!(spin_toml.contains("source = \"hello/target/wasm32-wasi/release/hello.wasm\""));
+        assert!(spin_toml.contains("source = \"encore/target/wasm32-wasi/release/hello_2.wasm\""));
+    }
+
+    #[tokio::test]
+    async fn cannot_add_component_that_does_not_match_trigger() {
+        let temp_dir = tempdir().unwrap();
+        let store = TemplateStore::new(temp_dir.path());
+        let manager = TemplateManager { store };
+        let source = TemplateSource::File(project_root());
+
+        manager
+            .install(&source, &InstallOptions::default(), &DiscardingReporter)
+            .await
+            .unwrap();
+
+        let dest_temp_dir = tempdir().unwrap();
+        let application_dir = dest_temp_dir.path().join("multi");
+
+        // Set up the containing app
+        {
+            let template = manager.get("redis-rust").unwrap().unwrap();
+
+            let values = [
+                ("project-description".to_owned(), "my desc".to_owned()),
+                (
+                    "redis-address".to_owned(),
+                    "redis://localhost:6379".to_owned(),
+                ),
+                (
+                    "redis-channel".to_owned(),
+                    "the-horrible-knuckles".to_owned(),
+                ),
+            ]
+            .into_iter()
+            .collect();
+            let options = RunOptions {
+                variant: crate::template::TemplateVariantKind::NewApplication,
+                output_path: application_dir.clone(),
+                name: "my multi project".to_owned(),
+                values,
+                accept_defaults: false,
+                existing_manifest: None,
+            };
+
+            template
+                .run(options)
+                .silent()
+                .await
+                .execute()
+                .await
+                .unwrap();
+        }
+
+        let spin_toml_path = application_dir.join("spin.toml");
+        assert!(spin_toml_path.exists(), "expected spin.toml to be created");
+
+        // Now add a component
+        {
+            let template = manager.get("http-rust").unwrap().unwrap();
+
+            let output_dir = "hello";
+            let values = [
+                ("project-description".to_owned(), "hello".to_owned()),
+                ("http-path".to_owned(), "/hello".to_owned()),
+            ]
+            .into_iter()
+            .collect();
+            let options = RunOptions {
+                variant: crate::template::TemplateVariantKind::AddComponent,
+                output_path: PathBuf::from(output_dir),
+                name: "hello".to_owned(),
+                values,
+                accept_defaults: false,
+                existing_manifest: Some(spin_toml_path.clone()),
+            };
+
+            template
+                .run(options)
+                .silent()
+                .await
+                .execute()
+                .await
+                .expect_err("Expected to fail to add component, but it succeeded");
+        }
+    }
 }

crates/templates/src/reader.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use anyhow::Context;
 use indexmap::IndexMap;
 use serde::Deserialize;
@@ -15,10 +17,20 @@ pub(crate) enum RawTemplateManifest {
 pub(crate) struct RawTemplateManifestV1 {
     pub id: String,
     pub description: Option<String>,
+    pub trigger_type: Option<String>,
+    pub add_component: Option<RawTemplateVariant>,
     pub parameters: Option<IndexMap<String, RawParameter>>,
     pub custom_filters: Option<Vec<RawCustomFilter>>,
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "snake_case")]
+pub(crate) struct RawTemplateVariant {
+    pub skip_files: Option<Vec<String>>,
+    pub skip_parameters: Option<Vec<String>>,
+    pub snippets: Option<HashMap<String, String>>,
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields, rename_all = "snake_case")]
 pub(crate) struct RawParameter {