Update usercall-extension example to tokio 0.2

Author: Jethro Beekman

examples/usercall-extension/app/Cargo.toml

@@ -2,5 +2,6 @@
 name = "app"
 version = "0.1.0"
 authors = ["Vardhan Thigle <[email protected]>"]
+edition = "2018"
 
 [dependencies]

examples/usercall-extension/runner/Cargo.toml

@@ -3,9 +3,12 @@ name = "runner"
 version = "0.1.0"
 authors = ["Fortanix, Inc."]
 license = "MPL-2.0"
+edition = "2018"
 
 [dependencies]
-aesm-client = { version = "0.2.0", features = ["sgxs"], path="../../../aesm-client"}
-enclave-runner = { version = "0.2.0", path="../../../enclave-runner"}
-sgxs-loaders = { version = "0.3.0",   path="../../../sgxs-loaders"}
-tokio = "0.1.22"         # MIT
+aesm-client = { version = "0.5.0", features = ["sgxs"], path="../../../intel-sgx/aesm-client"}
+enclave-runner = { version = "0.5.0", path="../../../intel-sgx/enclave-runner"}
+sgxs-loaders = { version = "0.3.0",   path="../../../intel-sgx/sgxs-loaders"}
+futures = "0.3"
+tokio = { version = "0.2", features = ["process"] }
+pin-utils = "0.1"

examples/usercall-extension/runner/src/main.rs

@@ -4,93 +4,96 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-extern crate aesm_client;
-extern crate enclave_runner;
-extern crate sgxs_loaders;
-extern crate tokio;
+use std::future::Future;
+use std::io::Result as IoResult;
+use std::pin::Pin;
+use std::process::Stdio;
+use std::task::{Context, Poll};
+
+use futures::FutureExt;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::process::{ChildStdin, ChildStdout, Command};
 
 use aesm_client::AesmClient;
 use enclave_runner::usercalls::{AsyncStream, UsercallExtension};
 use enclave_runner::EnclaveBuilder;
 use sgxs_loaders::isgx::Device as IsgxDevice;
-use tokio::io::{AsyncRead, AsyncWrite};
-use std::io::{Read, Result as IoResult, Write};
-use std::process::{Child, Command, Stdio};
-use tokio::sync::lock::Lock;
-use tokio::prelude::Async;
 
 /// This example demonstrates use of usercall extensions.
 /// User call extension allow the enclave code to "connect" to an external service via a customized enclave runner.
 /// Here we customize the runner to intercept calls to connect to an address "cat" which actually connects the enclave application to
 /// stdin and stdout of `cat` process.
 struct CatService {
-    c: Lock<Child>,
+    stdin: ChildStdin,
+    stdout: ChildStdout,
 }
 
 impl CatService {
+    // SAFETY: `Self` doesn't implement `Drop` or `Unpin`, and isn't `repr(packed)`
+    pin_utils::unsafe_pinned!(stdin: ChildStdin);
+    pin_utils::unsafe_pinned!(stdout: ChildStdout);
+
     fn new() -> Result<CatService, std::io::Error> {
         Command::new("/bin/cat")
             .stdout(Stdio::piped())
             .stdin(Stdio::piped())
             .spawn()
-            .map(|c| Lock::new(c))
-            .map(|c| CatService { c })
-    }
-}
-
-macro_rules! poll_lock_wouldblock {
-    ($lock:expr) => {
-        match $lock.clone().poll_lock() {
-            Async::NotReady => Err(std::io::ErrorKind::WouldBlock.into()),
-            Async::Ready(ret) => IoResult::Ok(ret),
-        }
+            .map(|mut c| CatService {
+                stdin: c.stdin.take().unwrap(),
+                stdout: c.stdout.take().unwrap(),
+            })
     }
 }
 
-impl Read for CatService {
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
-        poll_lock_wouldblock!(self.c)?.stdout.as_mut().unwrap().read(buf)
+impl AsyncRead for CatService {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut [u8]
+    ) -> Poll<IoResult<usize>> {
+        self.stdout().poll_read(cx, buf)
     }
 }
 
-impl Write for CatService {
-    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
-        poll_lock_wouldblock!(self.c)?.stdin.as_mut().unwrap().write(buf)
+impl AsyncWrite for CatService {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &[u8]
+    ) -> Poll<IoResult<usize>> {
+        self.stdin().poll_write(cx, buf)
     }
 
-    fn flush(&mut self) -> IoResult<()> {
-        poll_lock_wouldblock!(self.c)?.stdin.as_mut().unwrap().flush()
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoResult<()>> {
+        self.stdin().poll_flush(cx)
     }
-}
-
-impl AsyncRead for CatService {
-}
 
-impl AsyncWrite for CatService {
-    fn shutdown(&mut self) -> tokio::prelude::Poll<(), std::io::Error> {
-        Ok(().into())
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoResult<()>> {
+        self.stdin().poll_shutdown(cx)
     }
 }
 
 #[derive(Debug)]
 struct ExternalService;
 // Ignoring local_addr and peer_addr, as they are not relavent in the current context.
 impl UsercallExtension for ExternalService {
-    fn connect_stream(
-        &self,
-        addr: &str,
-        _local_addr: Option<&mut String>,
-        _peer_addr: Option<&mut String>,
-    ) -> IoResult<Option<Box<dyn AsyncStream>>> {
-        // If the passed address is not "cat", we return none, whereby the passed address gets treated as
-        // an IP address which is the default behavior.
-        match &*addr {
-            "cat" => {
-                let stream = CatService::new()?;
-                Ok(Some(Box::new(stream)))
+    fn connect_stream<'future>(
+        &'future self,
+        addr: &'future str,
+        _local_addr: Option<&'future mut String>,
+        _peer_addr: Option<&'future mut String>,
+    ) -> std::pin::Pin<Box<dyn Future<Output = IoResult<Option<Box<dyn AsyncStream>>>> +'future>> {
+        async move {
+            // If the passed address is not "cat", we return none, whereby the passed address gets treated as
+            // an IP address which is the default behavior.
+            match &*addr {
+                "cat" => {
+                    let stream = CatService::new()?;
+                    Ok(Some(Box::new(stream) as _))
+                }
+                _ => Ok(None),
             }
-            _ => Ok(None),
-        }
+        }.boxed_local()
     }
 }