Update ValidatorFn to use string slices

Signed-off-by: Kate Goldenring <[email protected]>

Author: kate-goldenring

crates/app/src/lib.rs

@@ -31,7 +31,7 @@ pub const OCI_IMAGE_DIGEST_KEY: MetadataKey = MetadataKey::new("oci_image_digest
 
 /// Validation function type for ensuring that applications meet requirements
 /// even with components filtered out.
-pub type ValidatorFn = dyn Fn(&App, &[String]) -> anyhow::Result<()>;
+pub type ValidatorFn = dyn Fn(&App, &[&str]) -> anyhow::Result<()>;
 
 /// An `App` holds loaded configuration for a Spin application.
 #[derive(Debug, Clone)]
@@ -171,7 +171,7 @@ impl App {
     /// Introspects the LockedApp to find and selectively retain the triggers that correspond to those components
     fn retain_components(
         mut self,
-        retained_components: &[String],
+        retained_components: &[&str],
         validators: &[&ValidatorFn],
     ) -> Result<LockedApp> {
         self.validate_retained_components_exist(retained_components)?;
@@ -181,7 +181,7 @@ impl App {
         let (component_ids, trigger_ids): (HashSet<String>, HashSet<String>) = self
             .triggers()
             .filter_map(|t| match t.component() {
-                Ok(comp) if retained_components.contains(&comp.id().to_string()) => {
+                Ok(comp) if retained_components.contains(&comp.id()) => {
                     Some((comp.id().to_owned(), t.id().to_owned()))
                 }
                 _ => None,
@@ -195,13 +195,13 @@ impl App {
     }
 
     /// Validates that all components specified to be retained actually exist in the app
-    fn validate_retained_components_exist(&self, retained_components: &[String]) -> Result<()> {
+    fn validate_retained_components_exist(&self, retained_components: &[&str]) -> Result<()> {
         let app_components = self
             .components()
             .map(|c| c.id().to_string())
             .collect::<HashSet<_>>();
         for c in retained_components {
-            if !app_components.contains(c) {
+            if !app_components.contains(*c) {
                 return Err(Error::ValidationError(anyhow::anyhow!(
                     "Specified component \"{c}\" not found in application"
                 )));
@@ -320,7 +320,7 @@ struct CommonTriggerConfig {
 /// Introspects the LockedApp to find and selectively retain the triggers that correspond to those components
 pub fn retain_components(
     locked: LockedApp,
-    components: &[String],
+    components: &[&str],
     validators: &[&ValidatorFn],
 ) -> Result<LockedApp> {
     App::new("unused", locked).retain_components(components, validators)
@@ -332,7 +332,7 @@ mod test {
 
     use super::*;
 
-    fn does_nothing_validator(_: &App, _: &[String]) -> anyhow::Result<()> {
+    fn does_nothing_validator(_: &App, _: &[&str]) -> anyhow::Result<()> {
         Ok(())
     }
 
@@ -351,12 +351,7 @@ mod test {
             source = "does-not-exist.wasm"
         };
         let mut locked_app = build_locked_app(&manifest).await.unwrap();
-        locked_app = retain_components(
-            locked_app,
-            &["empty".to_string()],
-            &[&does_nothing_validator],
-        )
-        .unwrap();
+        locked_app = retain_components(locked_app, &["empty"], &[&does_nothing_validator]).unwrap();
         let components = locked_app
             .components
             .iter()

crates/factor-outbound-networking/src/config.rs

@@ -44,18 +44,18 @@ pub fn allowed_outbound_hosts(component: &AppComponent) -> anyhow::Result<Vec<St
 /// are ignored.
 pub fn validate_service_chaining_for_components(
     app: &App,
-    retained_components: &[String],
+    retained_components: &[&str],
 ) -> anyhow::Result<()> {
     app
         .triggers().try_for_each(|t| {
             let Ok(component) = t.component() else  { return Ok(()) };
-            if retained_components.contains(&component.id().to_string()) {
+            if retained_components.contains(&component.id()) {
             let allowed_hosts = allowed_outbound_hosts(&component).context("failed to get allowed hosts")?;
             for host in allowed_hosts {
                 // Templated URLs are not yet resolved at this point, so ignore unresolvable URIs
                 if let Ok(uri) = host.parse::<http::Uri>() {
                     if let Some(chaining_target) = parse_service_chaining_target(&uri) {
-                        if !retained_components.contains(&chaining_target) {
+                        if !retained_components.contains(&chaining_target.as_ref()) {
                             if chaining_target == "*" {
                                 return  Err(anyhow::anyhow!("Selected component '{}' cannot use wildcard service chaining: allowed_outbound_hosts = [\"http://*.spin.internal\"]", component.id()));
                             }
@@ -891,24 +891,21 @@ mod test {
             .await
             .expect("could not build locked app");
         let app = App::new("unused", locked_app);
-        let Err(e) = validate_service_chaining_for_components(&app, &["empty".to_string()]) else {
+        let Err(e) = validate_service_chaining_for_components(&app, &["empty"]) else {
             panic!("Expected service chaining to non-retained component error");
         };
         assert_eq!(
             e.to_string(),
             "Selected component 'empty' cannot use service chaining to unselected component: allowed_outbound_hosts = [\"http://another.spin.internal\"]"
         );
-        let Err(e) = validate_service_chaining_for_components(
-            &app,
-            &["third".to_string(), "another".to_string()],
-        ) else {
+        let Err(e) = validate_service_chaining_for_components(&app, &["third", "another"]) else {
             panic!("Expected wildcard service chaining error");
         };
         assert_eq!(
             e.to_string(),
             "Selected component 'third' cannot use wildcard service chaining: allowed_outbound_hosts = [\"http://*.spin.internal\"]"
         );
-        assert!(validate_service_chaining_for_components(&app, &["another".to_string()]).is_ok());
+        assert!(validate_service_chaining_for_components(&app, &["another"]).is_ok());
     }
 
     #[tokio::test]
@@ -945,10 +942,6 @@ mod test {
             .await
             .expect("could not build locked app");
         let app = App::new("unused", locked_app);
-        assert!(validate_service_chaining_for_components(
-            &app,
-            &["empty".to_string(), "third".to_string()]
-        )
-        .is_ok());
+        assert!(validate_service_chaining_for_components(&app, &["empty", "third"]).is_ok());
     }
 }

src/commands/up.rs

@@ -201,7 +201,11 @@ impl UpCommand {
         if !self.components.is_empty() {
             locked_app = spin_app::retain_components(
                 locked_app,
-                &self.components,
+                &self
+                    .components
+                    .iter()
+                    .map(|s| s.as_str())
+                    .collect::<Vec<&str>>(),
                 &[&validate_service_chaining_for_components],
             )
             .context(