qos_core: fix new nits

Author: Turnalek

src/integration/examples/boot_enclave.rs

@@ -1,3 +1,6 @@
+//! Example showing how enclaves can be booted locally end-to-end.
+//! Useful to make debugging easier when iterating on the core of QOS.
+
 use std::{
 	fs,
 	io::{BufRead, BufReader, Write},

src/integration/src/bin/pivot_proof.rs

@@ -10,7 +10,6 @@ use qos_core::{
 };
 use tokio::sync::RwLock;
 
-#[derive(Clone)]
 struct Processor {
 	ephemeral_key_handle: EphemeralKeyHandle,
 }

src/integration/src/bin/pivot_async_remote_tls.rs renamed to src/integration/src/bin/pivot_remote_tls.rs

@@ -34,9 +34,6 @@ pub const PIVOT_PANIC_PATH: &str = "../target/debug/pivot_panic";
 /// Path to an enclave app that has routes to test remote connection features.
 pub const PIVOT_REMOTE_TLS_PATH: &str = "../target/debug/pivot_remote_tls";
 /// Path to an enclave app that has routes to test remote connection features.
-pub const PIVOT_ASYNC_REMOTE_TLS_PATH: &str =
-	"../target/debug/pivot_async_remote_tls";
-/// Path to an enclave app that has routes to test remote connection features.
 pub const QOS_NET_PATH: &str = "../target/debug/qos_net";
 /// Path to an enclave app that has routes to stress our socket.
 pub const PIVOT_SOCKET_STRESS_PATH: &str =

src/integration/src/lib.rs

@@ -24,7 +24,7 @@ async fn fetch_and_verify_app_proof() {
 	wait_for_usock(PROOF_TEST_ENCLAVE_SOCKET).await;
 
 	let enclave_pool =
-		StreamPool::new(SocketAddress::new_unix(PROOF_TEST_ENCLAVE_SOCKET), 1)
+		StreamPool::single(SocketAddress::new_unix(PROOF_TEST_ENCLAVE_SOCKET))
 			.unwrap();
 
 	let enclave_client = SocketClient::new(

src/integration/tests/proofs.rs

@@ -61,4 +61,8 @@ async fn connects_and_gets_info() {
 
 	let r = ureq::get("http://127.0.0.1:3323/qos/enclave-info").call();
 	assert!(r.is_ok()); // expect 200 here
+	assert_eq!(
+		r.unwrap().into_string().unwrap(),
+		"{\"phase\":\"WaitingForBootInstruction\",\"manifestEnvelope\":null}"
+	);
 }

src/integration/tests/qos_host.rs

@@ -2,8 +2,7 @@ use std::process::Command;
 
 use borsh::BorshDeserialize;
 use integration::{
-	wait_for_usock, PivotRemoteTlsMsg, PIVOT_ASYNC_REMOTE_TLS_PATH,
-	QOS_NET_PATH,
+	wait_for_usock, PivotRemoteTlsMsg, PIVOT_REMOTE_TLS_PATH, QOS_NET_PATH,
 };
 use qos_core::{
 	client::SocketClient,
@@ -13,10 +12,9 @@ use qos_core::{
 
 use qos_test_primitives::ChildWrapper;
 
-const REMOTE_TLS_TEST_NET_PROXY_SOCKET: &str =
-	"/tmp/async_remote_tls_test.net.sock";
+const REMOTE_TLS_TEST_NET_PROXY_SOCKET: &str = "/tmp/remote_tls_test.net.sock";
 const REMOTE_TLS_TEST_ENCLAVE_SOCKET: &str =
-	"/tmp/async_remote_tls_test.enclave.sock";
+	"/tmp/remote_tls_test.enclave.sock";
 const POOL_SIZE: &str = "1";
 
 #[tokio::test]
@@ -30,7 +28,7 @@ async fn fetch_async_remote_tls_content() {
 		.unwrap()
 		.into();
 
-	let _enclave_app: ChildWrapper = Command::new(PIVOT_ASYNC_REMOTE_TLS_PATH)
+	let _enclave_app: ChildWrapper = Command::new(PIVOT_REMOTE_TLS_PATH)
 		.arg(REMOTE_TLS_TEST_ENCLAVE_SOCKET)
 		.arg(REMOTE_TLS_TEST_NET_PROXY_SOCKET)
 		.spawn()

src/integration/tests/remote_tls.rs

@@ -48,6 +48,16 @@ impl EnclaveOpts {
 		Self { parsed }
 	}
 
+	/// Create a new `StreamPool` for connecting to the enclave.
+	fn enclave_pool(&self) -> Result<StreamPool, IOError> {
+		self.async_pool(false)
+	}
+
+	/// Create a new `StreamPool` for connecting to the app.
+	fn app_pool(&self) -> Result<StreamPool, IOError> {
+		self.async_pool(true)
+	}
+
 	/// Create a new `StreamPool` using the list of `SocketAddress` for the qos host.
 	/// The `app` parameter specifies if this is a pool meant for the enclave itself, or the enclave app.
 	fn async_pool(&self, app: bool) -> Result<StreamPool, IOError> {
@@ -64,13 +74,14 @@ impl EnclaveOpts {
 					c.parse().map_err(|_| IOError::ConnectAddressInvalid)?;
 				let p =
 					p.parse().map_err(|_| IOError::ConnectAddressInvalid)?;
-				StreamPool::new(
-					SocketAddress::new_vsock(c, p, crate::io::VMADDR_NO_FLAGS),
-					1,
-				)
+				StreamPool::single(SocketAddress::new_vsock(
+					c,
+					p,
+					crate::io::VMADDR_NO_FLAGS,
+				))
 			}
 			(None, None, Some(u)) => {
-				StreamPool::new(SocketAddress::new_unix(u), 1)
+				StreamPool::single(SocketAddress::new_unix(u))
 			}
 			_ => panic!("Invalid socket opts"),
 		}
@@ -150,10 +161,9 @@ impl CLI {
 						opts.pivot_file(),
 					),
 					opts.nsm(),
-					opts.async_pool(false)
+					opts.enclave_pool()
 						.expect("Unable to create enclave socket pool"),
-					opts.async_pool(true)
-						.expect("Unable to create enclave app pool"),
+					opts.app_pool().expect("Unable to create enclave app pool"),
 					None,
 				);
 			});

src/qos_core/src/cli.rs

@@ -55,9 +55,6 @@ impl SocketClient {
 
 	/// Send raw bytes and wait for a response until the clients configured
 	/// timeout.
-	///
-	/// # Panics
-	/// Does not. See comment bellow.
 	pub async fn call(&self, request: &[u8]) -> Result<Vec<u8>, ClientError> {
 		let pool = self.pool.read().await;
 
@@ -95,8 +92,13 @@ impl SocketClient {
 	}
 }
 
+// Convers TimeVal to Duration
+// # Panics
+//
+// Panics if timeval values are negative
 fn timeval_to_duration(timeval: TimeVal) -> Duration {
-	#[allow(clippy::cast_possible_truncation)]
-	#[allow(clippy::cast_sign_loss)]
-	Duration::new(timeval.tv_sec() as u64, timeval.tv_usec() as u32 * 1000)
+	let secs: u64 = timeval.tv_sec().try_into().expect("invalid TimeVal value");
+	let usecs: u32 =
+		timeval.tv_usec().try_into().expect("invalid TimeVal value");
+	Duration::new(secs, usecs * 1000)
 }

src/qos_core/src/client.rs

@@ -44,7 +44,7 @@ pub enum IOError {
 	RecvNixError(nix::Error),
 	/// Reading the response size resulted in a size which exceeds the max payload size.
 	OversizedPayload(usize),
-	/// A async socket pool error during pool operations.
+	/// An async socket pool error during pool operations.
 	PoolError(PoolError),
 }