fix(host): spurrious higher ranked lifetime error

A seemingly spurrious higher-ranked lifetime error is being generated
on Rust 1.75.0 in wasmbus while launching the provider task.

As this code compiled just fine prior to Rust 1.75.0 (released
2023/12/21), this seems to be a spurrious error, for which there is
some tracking upstream:

rust-lang/rust#110338

Assuming this error *is* spurrious, we can shuffle the work via
`tokio::task::spawn_blocking` to avoid the error, causing the work
that was going to be done in a distinct thread.

This commit fixes a higher-ranked lifetime error by using tokio to
force execution on a separate thread which seemingly recalculates
lifetimes due to the the synchronous move closure.

Signed-off-by: Victor Adossi <[email protected]>

Author: vados-cosmonic

crates/host/src/wasmbus/mod.rs

@@ -3372,29 +3372,39 @@ impl Host {
         info!(provider_ref, link_name, "handling launch provider"); // Log at info since launching providers can take a while
 
         let host_id = host_id.to_string();
-        spawn(async move {
-            if let Err(err) = self
-                .handle_launch_provider_task(
-                    configuration,
-                    &link_name,
-                    &provider_ref,
-                    annotations.unwrap_or_default(),
-                    &host_id,
-                )
-                .await
-            {
-                error!(provider_ref, link_name, ?err, "failed to launch provider");
+
+        // Rust 1.75.0 seems to trigger a bogus higher-ranked lifetime error
+        // when using tokio::task::spawn here -- using `spawn_blocking` avoids this particular issue.
+        //
+        // To avoid the higher ranked lifetime error we use spawn_blocking
+        // which will move the closure to another blocking-allowed thread,
+        // then execute.
+        tokio::task::spawn_blocking(move || {
+            tokio::runtime::Handle::current().block_on(async move {
                 if let Err(err) = self
-                    .publish_event(
-                        "provider_start_failed",
-                        event::provider_start_failed(provider_ref, link_name, &err),
+                    .handle_launch_provider_task(
+                        configuration,
+                        &link_name,
+                        &provider_ref,
+                        annotations.unwrap_or_default(),
+                        &host_id,
                     )
                     .await
                 {
-                    error!(?err, "failed to publish provider_start_failed event");
+                    error!(provider_ref, link_name, ?err, "failed to launch provider");
+                    if let Err(err) = self
+                        .publish_event(
+                            "provider_start_failed",
+                            event::provider_start_failed(provider_ref, link_name, &err),
+                        )
+                        .await
+                    {
+                        error!(?err, "failed to publish provider_start_failed event");
+                    }
                 }
-            }
+            })
         });
+
         Ok(ACCEPTED.into())
     }