remove executor option from trigger config

Signed-off-by: karthik2804 <[email protected]>

Author: karthik2804

src/lib.rs

@@ -18,8 +18,6 @@ pub struct CommandTrigger {
 #[serde(deny_unknown_fields)]
 pub struct Component {
     pub id: String,
-    #[serde(default)]
-    pub executor: CommandExecutorType,
 }
 
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
@@ -28,20 +26,10 @@ struct TriggerMetadata {
     pub r#type: String,
 }
 
-#[derive(Clone, Debug, Default, Deserialize, Serialize)]
-#[serde(deny_unknown_fields, rename_all = "lowercase", tag = "type")]
-pub enum CommandExecutorType {
-    #[default]
-    Preview2,
-    Preview1,
-}
-
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct CommandTriggerConfig {
     pub component: String,
-    #[serde(default)]
-    pub executor: CommandExecutorType,
 }
 
 pub enum CommandInstancePre {
@@ -67,7 +55,6 @@ impl TriggerExecutor for CommandTrigger {
             .trigger_configs()
             .map(|(_, config)| Component {
                 id: config.component.clone(),
-                executor: config.executor.clone(),
             })
             .collect();
         Ok(Self { engine, components })
@@ -85,18 +72,18 @@ impl TriggerInstancePre<RuntimeData, CommandTriggerConfig> for CommandInstancePr
     async fn instantiate_pre(
         engine: &Engine<RuntimeData>,
         component: &AppComponent,
-        config: &CommandTriggerConfig,
+        _config: &CommandTriggerConfig,
     ) -> Result<CommandInstancePre> {
-        if let CommandExecutorType::Preview1 = &config.executor {
+        // Attempt to load as a component and fallback to loading a module
+        if let Ok(comp) = component.load_component(engine).await {
+            Ok(CommandInstancePre::Component(
+                engine.instantiate_pre(&comp)?,
+            ))
+        } else {
             let module = component.load_module(engine).await?;
             Ok(CommandInstancePre::Module(
                 engine.module_instantiate_pre(&module)?,
             ))
-        } else {
-            let comp = component.load_component(engine).await?;
-            Ok(CommandInstancePre::Component(
-                engine.instantiate_pre(&comp)?,
-            ))
         }
     }
 
@@ -117,36 +104,35 @@ impl TriggerInstancePre<RuntimeData, CommandTriggerConfig> for CommandInstancePr
 impl CommandTrigger {
     pub async fn handle(&self) -> Result<()> {
         let component = &self.components[0];
-        match component.executor {
-            CommandExecutorType::Preview2 => {
-                let (instance, mut store) = self.engine.prepare_instance(&component.id).await?;
-                let CommandInstance::Component(instance) = instance else {
-                    unreachable!()
-                };
+        let (instance, mut store) = self.engine.prepare_instance(&component.id).await?;
+        match instance {
+            CommandInstance::Component(instance) => {
                 let handler =
                     wasmtime_wasi::preview2::command::Command::new(&mut store, &instance)?;
                 let _ = handler.wasi_cli_run().call_run(store).await?;
             }
-            CommandExecutorType::Preview1 => {
+            CommandInstance::Module(_) => {
+                // Toss the commandInstance we have and create a new one as the
+                // associated store will be a preview2 store
                 let store_builder = self
                     .engine
                     .store_builder(&component.id, spin_core::WasiVersion::Preview1)?;
                 let (instance, mut store) = self
                     .engine
                     .prepare_instance_with_store(&component.id, store_builder)
                     .await?;
-
-                let CommandInstance::Module(instance) = instance else {
-                    unreachable!()
-                };
-
-                let start = instance
-                    .get_func(&mut store, "_start")
-                    .context("Expected component to export _start function")?;
-
-                let _ = start.call_async(&mut store, &[], &mut []).await?;
+                if let CommandInstance::Module(instance) = instance {
+                    let start = instance
+                        .get_func(&mut store, "_start")
+                        .context("Expected component to export _start function")?;
+
+                    let _ = start.call_async(&mut store, &[], &mut []).await?;
+                } else {
+                    unreachable!();
+                }
             }
-        };
+        }
+
         Ok(())
     }
 }