feat(host): gate builtins with feature flags

Signed-off-by: Brooks Townsend <brooksmtownsend@gmail.com>

Author: brooksmtownsend

crates/host/src/wasmbus/experimental.rs

@@ -0,0 +1,66 @@
+use tracing::warn;
+
+/// Feature flags to enable experimental functionality in the host. Flags are disabled
+/// by default and must be explicitly enabled.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Features {
+    /// Enable the built-in HTTP server capability provider
+    /// that can be started with the reference wasmcloud+builtin://http-server
+    pub(crate) builtin_http: bool,
+    /// Enable the built-in NATS Messaging capability provider
+    /// that can be started with the reference wasmcloud+builtin://messaging-nats
+    pub(crate) builtin_messaging: bool,
+}
+
+impl Features {
+    /// Enable the built-in HTTP server capability provider
+    pub fn with_builtin_http() -> Self {
+        Self {
+            builtin_http: true,
+            ..Default::default()
+        }
+    }
+
+    /// Enable the built-in NATS messaging capability provider
+    pub fn with_builtin_messaging() -> Self {
+        Self {
+            builtin_messaging: true,
+            ..Default::default()
+        }
+    }
+}
+
+/// This enables unioning feature flags together
+impl std::ops::Add for Features {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            builtin_http: self.builtin_http || rhs.builtin_http,
+            builtin_messaging: self.builtin_messaging || rhs.builtin_messaging,
+        }
+    }
+}
+
+/// Allow for summing over a collection of feature flags
+impl std::iter::Sum for Features {
+    fn sum<I: Iterator<Item = Self>>(mut iter: I) -> Self {
+        // Grab the first set of flags, fall back on defaults (all disabled)
+        let first = iter.next().unwrap_or_default();
+        iter.fold(first, |a, b| a + b)
+    }
+}
+
+/// Parse a feature flag from a string, enabling the feature if the string matches
+impl From<&str> for Features {
+    fn from(s: &str) -> Self {
+        match &*s.to_ascii_lowercase() {
+            "builtin-http" | "builtin_http" => Self::with_builtin_http(),
+            "builtin-messaging" | "builtin_messaging" => Self::with_builtin_messaging(),
+            _ => {
+                warn!(%s, "unknown feature flag");
+                Features::default()
+            }
+        }
+    }
+}

crates/host/src/wasmbus/host_config.rs

@@ -9,6 +9,8 @@ use url::Url;
 use wasmcloud_core::{logging::Level as LogLevel, OtelConfig};
 use wasmcloud_runtime::{MAX_COMPONENTS, MAX_COMPONENT_SIZE, MAX_LINEAR_MEMORY};
 
+use crate::wasmbus::experimental::Features;
+
 /// wasmCloud Host configuration
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Clone, Debug)]
@@ -72,6 +74,8 @@ pub struct Host {
     pub max_components: u32,
     /// The interval at which the Host will send heartbeats
     pub heartbeat_interval: Option<Duration>,
+    /// Experimental features that can be enabled in the host
+    pub experimental_features: Features,
 }
 
 /// Configuration for wasmCloud policy service
@@ -121,6 +125,7 @@ impl Default for Host {
             max_component_size: MAX_COMPONENT_SIZE,
             max_components: MAX_COMPONENTS,
             heartbeat_interval: None,
+            experimental_features: Features::default(),
         }
     }
 }

crates/host/src/wasmbus/mod.rs

@@ -63,6 +63,7 @@ use crate::{
 };
 
 mod event;
+mod experimental;
 mod handler;
 mod providers;
 
@@ -73,6 +74,7 @@ pub mod host_config;
 pub use self::host_config::Host as HostConfig;
 
 use self::config::{BundleGenerator, ConfigBundle};
+pub use self::experimental::Features;
 use self::handler::Handler;
 
 const MAX_INVOCATION_CHANNEL_SIZE: usize = 5000;
@@ -389,6 +391,8 @@ pub struct Host {
     max_execution_time: Duration,
     messaging_links:
         Arc<RwLock<HashMap<Arc<str>, Arc<RwLock<HashMap<Box<str>, async_nats::Client>>>>>>,
+    /// Experimental features to enable in the host that gate functionality
+    experimental_features: Features,
 }
 
 #[derive(Debug, Serialize, Deserialize, Default)]
@@ -884,6 +888,8 @@ impl Host {
 
         let max_execution_time_ms = config.max_execution_time;
 
+        debug!("Feature flags: {:?}", config.experimental_features);
+
         let host = Host {
             components: Arc::default(),
             event_builder,
@@ -896,6 +902,7 @@ impl Host {
             labels: RwLock::new(labels),
             ctl_nats,
             rpc_nats: Arc::new(rpc_nats),
+            experimental_features: config.experimental_features,
             host_config: config,
             data: data.clone(),
             data_watch: data_watch_abort.clone(),
@@ -2547,7 +2554,7 @@ impl Host {
                     .await?
                 }
                 (None, ResourceRef::Builtin(name)) => match *name {
-                    "http-server" => {
+                    "http-server" if self.experimental_features.builtin_http => {
                         self.start_http_server_provider(
                             &mut tasks,
                             link_definitions,
@@ -2558,7 +2565,8 @@ impl Host {
                         )
                         .await?
                     }
-                    "messaging-nats" => {
+                    "http-server" => bail!("feature `builtin-http` is not enabled, denying start"),
+                    "messaging-nats" if self.experimental_features.builtin_messaging => {
                         self.start_messaging_nats_provider(
                             &mut tasks,
                             link_definitions,
@@ -2569,6 +2577,9 @@ impl Host {
                         )
                         .await?
                     }
+                    "messaging-nats" => {
+                        bail!("feature `messaging-nats` is not enabled, denying start")
+                    }
                     _ => bail!("unknown builtin name: {name}"),
                 },
                 _ => bail!("invalid provider reference"),

src/main.rs

@@ -17,6 +17,7 @@ use wasmcloud_core::{OtelConfig, OtelProtocol};
 use wasmcloud_host::oci::Config as OciConfig;
 use wasmcloud_host::url::Url;
 use wasmcloud_host::wasmbus::host_config::PolicyService as PolicyServiceConfig;
+use wasmcloud_host::wasmbus::Features;
 use wasmcloud_host::WasmbusHostConfig;
 use wasmcloud_tracing::configure_observability;
 
@@ -327,6 +328,15 @@ struct Args {
     #[arg(long = "heartbeat-interval-seconds", env = "WASMCLOUD_HEARTBEAT_INTERVAL", value_parser = parse_duration_secs, hide = true)]
     heartbeat_interval: Option<Duration>,
 
+    /// Experimental features to enable in the host. This is a repeatable option.
+    #[arg(
+        long = "feature",
+        env = "WASMCLOUD_EXPERIMENTAL_FEATURES",
+        value_delimiter = ',',
+        hide = true
+    )]
+    experimental_features: Vec<Features>,
+
     #[clap(
         long = "help-markdown",
         action=ArgAction::SetTrue,
@@ -498,6 +508,8 @@ async fn main() -> anyhow::Result<()> {
         max_component_size: args.max_component_size,
         max_components: args.max_components,
         heartbeat_interval: args.heartbeat_interval,
+        // NOTE(brooks): Summing the feature flags "OR"s the multiple flags together.
+        experimental_features: args.experimental_features.into_iter().sum(),
     }))
     .await
     .context("failed to initialize host")?;