feat(host): introduce modular outbound transport architecture with initial gRPC client support

- Add `OutgoingHandler` trait to enable pluggable transport protocols
- Implement `CompositeOutgoingHandler` for automatic protocol routing
- Add gRPC client handler with HTTP/2, TLS, and h2c support
- Move transport configuration ownership to `HttpServer`
- Ensure full backward compatibility for existing HTTP-only hosts

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

Author: Aditya1404Sal

crates/wash-runtime/build.rs

@@ -25,6 +25,8 @@ fn main() {
         env::var("OUT_DIR").expect("failed to look up `OUT_DIR` from environment variables"),
     );
     let workspace_dir = workspace_dir().expect("failed to get workspace dir");
+    println!("cargo:rerun-if-changed=tests/proto");
+    println!("cargo:rerun-if-changed=proto");
     let top_proto_dir = workspace_dir.join("proto");
     let proto_dir = top_proto_dir.join("wasmcloud/runtime/v2");
 
@@ -58,15 +60,15 @@ fn main() {
     }
 
     // Compile test proto files if they exist
-    let test_proto_file = workspace_dir.join("tests/proto/helloworld.proto");
-    if test_proto_file.exists() {
-        println!("cargo:rerun-if-changed={}", test_proto_file.display());
+    let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    let test_proto_file = crate_dir.join("tests/proto/helloworld.proto");
 
-        tonic_prost_build::configure()
-            .build_client(false)
-            .build_server(true)
-            .build_transport(true)
-            .compile_protos(&[&test_proto_file], &[&workspace_dir.join("tests/proto")])
-            .expect("failed to compile test protos");
-    }
+    println!("cargo:rerun-if-changed={}", test_proto_file.display());
+
+    tonic_prost_build::configure()
+        .build_client(false)
+        .build_server(true)
+        .build_transport(true)
+        .compile_protos(&[&test_proto_file], &[&crate_dir.join("tests/proto")])
+        .expect("failed to compile test protos");
 }

crates/wash-runtime/src/host/http.rs

@@ -22,6 +22,7 @@ use std::{collections::HashMap, net::SocketAddr, path::Path, sync::Arc};
 
 use crate::engine::ctx::Ctx;
 use crate::engine::workload::ResolvedWorkload;
+use crate::host::transport::CompositeOutgoingHandler;
 use crate::wit::WitInterface;
 use anyhow::{Context, ensure};
 use hyper::server::conn::http1;
@@ -276,6 +277,7 @@ pub struct HttpServer<T: Router> {
     workload_handles: WorkloadHandles,
     shutdown_tx: Arc<RwLock<Option<mpsc::Sender<()>>>>,
     tls_acceptor: Option<TlsAcceptor>,
+    outgoing: CompositeOutgoingHandler,
 }
 
 impl<T: Router> std::fmt::Debug for HttpServer<T> {
@@ -296,12 +298,22 @@ impl<T: Router> HttpServer<T> {
     /// # Returns
     /// A new `HttpServer` instance configured for HTTP connections.
     pub fn new(router: T, addr: SocketAddr) -> Self {
+        Self::with_outgoing_handler(router, addr, CompositeOutgoingHandler::default())
+    }
+
+    /// Creates a new HTTP server with custom outgoing handlers
+    pub fn with_outgoing_handler(
+        router: T,
+        addr: SocketAddr,
+        outgoing: CompositeOutgoingHandler,
+    ) -> Self {
         Self {
             router: Arc::new(router),
             addr,
             workload_handles: Arc::default(),
             shutdown_tx: Arc::new(RwLock::new(None)),
             tls_acceptor: None,
+            outgoing,
         }
     }
 
@@ -325,6 +337,7 @@ impl<T: Router> HttpServer<T> {
         cert_path: &Path,
         key_path: &Path,
         ca_path: Option<&Path>,
+        outgoing: Option<CompositeOutgoingHandler>,
     ) -> anyhow::Result<Self> {
         let tls_config = load_tls_config(cert_path, key_path, ca_path).await?;
         let tls_acceptor = TlsAcceptor::from(Arc::new(tls_config));
@@ -335,6 +348,7 @@ impl<T: Router> HttpServer<T> {
             workload_handles: Arc::default(),
             shutdown_tx: Arc::new(RwLock::new(None)),
             tls_acceptor: Some(tls_acceptor),
+            outgoing: outgoing.unwrap_or_default(),
         })
     }
 }
@@ -430,32 +444,8 @@ impl<T: Router> HostHandler for HttpServer<T> {
                 wasmtime_wasi_http::HttpError::trap(anyhow::anyhow!("request not allowed: {}", e))
             })?;
 
-        // NOTE(lxf): Bring wasi-http code if needed
-        // Separate HTTP / GRPC handling
-        let is_grpc = request
-            .headers()
-            .get(hyper::header::CONTENT_TYPE)
-            .and_then(|v| v.to_str().ok())
-            .map(|v| v.starts_with("application/grpc"))
-            .unwrap_or(false);
-
-        // Route to appropriate client plugin
-        if is_grpc {
-            #[cfg(feature = "grpc")]
-            {
-                return crate::grpc::send_request(request, config);
-            }
-            #[cfg(not(feature = "grpc"))]
-            {
-                return Err(wasmtime_wasi_http::HttpError::trap(anyhow::anyhow!(
-                    "gRPC requests are not supported. Please enable the 'grpc' feature."
-                )));
-            }
-        }
-
-        Ok(wasmtime_wasi_http::types::default_send_request(
-            request, config,
-        ))
+        // Route through composite handler
+        self.outgoing.send_request(request, config)
     }
 }
 

crates/wash-runtime/src/host/mod.rs

@@ -59,6 +59,7 @@ mod sysinfo;
 use sysinfo::SystemMonitor;
 
 pub mod http;
+pub mod transport;
 
 /// The API for interacting with a wasmcloud host.
 ///
@@ -603,8 +604,8 @@ pub struct HostConfig {
 }
 
 /// Builder for the [`Host`]
-#[derive(Default)]
 pub struct HostBuilder {
+    id: String,
     engine: Option<Engine>,
     plugins: HashMap<&'static str, Arc<dyn HostPlugin>>,
     hostname: Option<String>,
@@ -634,6 +635,10 @@ impl HostBuilder {
         Self::default()
     }
 
+    pub fn id(&self) -> &str {
+        &self.id
+    }
+
     pub fn with_engine(mut self, engine: Engine) -> Self {
         self.engine = Some(engine);
         self
@@ -645,12 +650,6 @@ impl HostBuilder {
         self
     }
 
-    #[cfg(feature = "grpc")]
-    pub fn with_grpc(mut self, config: HashMap<String, String>) -> Self {
-        self.grpc_config = Some(config);
-        self
-    }
-
     pub fn with_plugin<T: HostPlugin>(mut self, plugin: Arc<T>) -> anyhow::Result<Self> {
         let plugin_id = plugin.id();
 
@@ -662,6 +661,7 @@ impl HostBuilder {
         self.plugins.insert(plugin_id, plugin);
         Ok(self)
     }
+
     /// Sets the hostname for this host.
     ///
     /// # Arguments
@@ -721,11 +721,6 @@ impl HostBuilder {
     /// # Errors
     /// Returns an error if the default engine cannot be created (when no engine is provided).
     pub fn build(self) -> anyhow::Result<Host> {
-        #[cfg(feature = "grpc")]
-        if let Some(config) = self.grpc_config {
-            crate::grpc::init_grpc(&config)?;
-        }
-
         let engine = if let Some(engine) = self.engine {
             engine
         } else {
@@ -758,7 +753,7 @@ impl HostBuilder {
             engine,
             workloads: Arc::default(),
             plugins: self.plugins,
-            id: uuid::Uuid::new_v4().to_string(),
+            id: self.id,
             hostname,
             friendly_name,
             version: env!("CARGO_PKG_VERSION").to_string(),

crates/wash-runtime/src/host/transport.rs

@@ -0,0 +1,127 @@
+//! Modular outgoing request handling for HTTP server
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use wasmtime_wasi_http::{
+    HttpResult,
+    body::HyperOutgoingBody,
+    types::{HostFutureIncomingResponse, OutgoingRequestConfig},
+};
+
+/// Trait for handling outgoing requests with specific transport protocols
+pub trait OutgoingHandler: Send + Sync + 'static {
+    /// Check if this handler can handle the given request
+    fn can_handle(&self, request: &hyper::Request<HyperOutgoingBody>) -> bool;
+
+    /// Send the request using this handler's transport
+    fn send_request(
+        &self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> HttpResult<HostFutureIncomingResponse>;
+}
+
+/// Default HTTP/1.1 and HTTP/2 handler
+#[derive(Clone, Default)]
+pub struct DefaultHttpHandler;
+
+impl OutgoingHandler for DefaultHttpHandler {
+    fn can_handle(&self, _request: &hyper::Request<HyperOutgoingBody>) -> bool {
+        true // Accepts everything
+    }
+
+    fn send_request(
+        &self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> HttpResult<HostFutureIncomingResponse> {
+        Ok(wasmtime_wasi_http::types::default_send_request(
+            request, config,
+        ))
+    }
+}
+
+/// gRPC handler
+#[cfg(feature = "grpc")]
+pub struct GrpcHandler {
+    _config: HashMap<String, String>,
+}
+
+#[cfg(feature = "grpc")]
+impl GrpcHandler {
+    pub fn new(config: HashMap<String, String>) -> anyhow::Result<Self> {
+        crate::grpc::init_grpc(&config)?;
+        Ok(Self { _config: config })
+    }
+}
+
+#[cfg(feature = "grpc")]
+impl OutgoingHandler for GrpcHandler {
+    fn can_handle(&self, request: &hyper::Request<HyperOutgoingBody>) -> bool {
+        request
+            .headers()
+            .get(hyper::header::CONTENT_TYPE)
+            .and_then(|v| v.to_str().ok())
+            .map(|v| v.starts_with("application/grpc"))
+            .unwrap_or(false)
+    }
+
+    fn send_request(
+        &self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> HttpResult<HostFutureIncomingResponse> {
+        crate::grpc::send_request(request, config)
+    }
+}
+
+/// Chains multiple outgoing handlers together
+pub struct CompositeOutgoingHandler {
+    handlers: Vec<Arc<dyn OutgoingHandler>>,
+    default: Arc<dyn OutgoingHandler>,
+}
+
+impl CompositeOutgoingHandler {
+    pub fn new() -> Self {
+        Self {
+            handlers: Vec::new(),
+            default: Arc::new(DefaultHttpHandler),
+        }
+    }
+
+    pub fn with_handler(mut self, handler: Arc<dyn OutgoingHandler>) -> Self {
+        self.handlers.push(handler);
+        self
+    }
+
+    #[cfg(feature = "grpc")]
+    pub fn with_grpc(self, config: HashMap<String, String>) -> anyhow::Result<Self> {
+        let grpc = GrpcHandler::new(config)?;
+        Ok(self.with_handler(Arc::new(grpc)))
+    }
+
+    pub fn send_request(
+        &self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> HttpResult<HostFutureIncomingResponse> {
+        for handler in &self.handlers {
+            if handler.can_handle(&request) {
+                tracing::debug!(
+                    uri = %request.uri(),
+                    "routing outgoing request to custom handler"
+                );
+                return handler.send_request(request, config);
+            }
+        }
+
+        tracing::debug!(uri = %request.uri(), "routing to default HTTP handler");
+        self.default.send_request(request, config)
+    }
+}
+
+impl Default for CompositeOutgoingHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/wash-runtime/src/washlet/mod.rs

@@ -1,5 +1,3 @@
-#[cfg(feature = "grpc")]
-use std::collections::HashMap;
 use std::env;
 use std::sync::Arc;
 use std::time::Duration;
@@ -37,8 +35,6 @@ pub struct ClusterHostBuilder {
     host_group: Option<String>,
     host_name: Option<String>,
     heartbeat_interval: Option<Duration>,
-    #[cfg(feature = "grpc")]
-    grpc_config: Option<HashMap<String, String>>,
 }
 
 impl ClusterHostBuilder {
@@ -62,12 +58,6 @@ impl ClusterHostBuilder {
         self
     }
 
-    #[cfg(feature = "grpc")]
-    pub fn with_grpc(mut self, config: HashMap<String, String>) -> Self {
-        self.grpc_config = Some(config);
-        self
-    }
-
     pub fn with_plugin<T: HostPlugin>(mut self, plugin: Arc<T>) -> anyhow::Result<Self> {
         self.host_builder = self.host_builder.with_plugin(plugin)?;
         Ok(self)