runtime: Use block_in_place to avoid exhausting the blocking pool

keymanager/src/client/remote.rs

@@ -405,12 +405,10 @@ impl KeyManagerClient for RemoteClient {
 
         // Fetch current epoch.
         let consensus_state = self.inner.consensus_verifier.latest_state().await?;
-        let consensus_epoch = tokio::task::spawn_blocking(move || {
+        let consensus_epoch = tokio::task::block_in_place(move || {
             let beacon_state = BeaconState::new(&consensus_state);
             beacon_state.epoch()
-        })
-        .await
-        .unwrap()?;
+        })?;
 
         // First try to fetch from cache.
         {

runtime/src/attestation.rs

@@ -106,12 +106,10 @@ impl Handler {
             let consensus_verifier = self.consensus_verifier.clone();
             let version = Some(self.version);
             let runtime_id = self.runtime_id;
-            let policy = tokio::task::spawn_blocking(move || {
+            let policy = tokio::task::block_in_place(move || {
                 // Obtain current quote policy from (verified) consensus state.
                 PolicyVerifier::new(consensus_verifier).quote_policy(&runtime_id, version)
-            })
-            .await
-            .unwrap()?;
+            })?;
 
             self.identity.set_quote_policy(policy)?;
         }

runtime/src/enclave_rpc/session.rs

@@ -314,14 +314,12 @@ impl Session {
 
         let consensus_state = consensus_verifier.latest_state().await?;
         // TODO: Make this access async.
-        let node = tokio::task::spawn_blocking(move || -> Result<_> {
+        let node = tokio::task::block_in_place(move || -> Result<_> {
             let registry_state = RegistryState::new(&consensus_state);
             Ok(registry_state
                 .node(&node)?
                 .ok_or(SessionError::NodeNotRegistered)?)
-        })
-        .await
-        .unwrap()?;
+        })?;
 
         let verified = node
             .runtimes