chore: type safe api.

Author: l-monninger

util/movement-aptos/movement-aptos-core/src/movement_aptos.rs

@@ -95,10 +95,14 @@ where
 		let rest_api_state = self.rest_api.clone();
 		let rest_api_polling = kestrel::task(async move {
 			loop {
+				tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+				println!("POLLING REST API: {:?}", rest_api);
 				// wait for the rest api to be ready
 				let response = reqwest::get(rest_api.rest_api_url.clone())
 					.await
 					.map_err(|e| MovementAptosError::Internal(e.into()))?;
+
+				println!("REST API RESPONSE: {:?}", response);
 				if response.status().is_success() {
 					rest_api_state.write().set(rest_api).await;
 					break;
@@ -151,9 +155,16 @@ mod tests {
 
 		let movement_aptos = MovementAptos::<runtime::TokioTest>::try_new(node_config, None)?;
 		let rest_api_state = movement_aptos.rest_api().read().clone();
-		movement_aptos.run().await?;
+
+		let movement_aptos_task = kestrel::task(async move {
+			movement_aptos.run().await?;
+			Ok::<_, MovementAptosError>(())
+		});
+
 		rest_api_state.wait_for(tokio::time::Duration::from_secs(30)).await?;
 
+		kestrel::end!(movement_aptos_task)?;
+
 		Ok(())
 	}
 }

util/movement-aptos/movement-aptos-core/src/movement_aptos/runtime.rs

@@ -1,3 +1,11 @@
+pub mod delegated;
+pub mod native;
+pub mod tokio_test;
+
+pub use delegated::*;
+pub use native::*;
+pub use tokio_test::*;
+
 use std::fmt::Debug;
 
 /// Errors thrown when attempting to use a runtime.
@@ -9,14 +17,6 @@ pub enum RuntimeError {
 	Unavailable(#[source] Box<dyn std::error::Error + Send + Sync>),
 }
 
-/// Returns true if the current runtime is multithreaded.
-fn is_multithreaded_runtime() -> bool {
-	std::panic::catch_unwind(|| {
-		tokio::task::block_in_place(|| {});
-	})
-	.is_ok()
-}
-
 /// Trait for a runtime that can be used to run [MovementAptos].
 ///
 /// A runtime knows statically whether it is multithreaded or not.
@@ -28,63 +28,15 @@ pub trait Runtime: Sized + Clone + Debug + Send + Sync + 'static {
 	fn create_global_rayon_pool() -> bool;
 }
 
-/// Tokio test runtime.
-#[derive(Debug, Clone)]
-pub struct TokioTest;
-
-impl Runtime for TokioTest {
-	/// Try to create a new runtime.
-	fn try_new() -> Result<Self, RuntimeError> {
-		if !is_multithreaded_runtime() {
-			return Err(RuntimeError::Unavailable(Box::new(std::io::Error::new(
-				std::io::ErrorKind::Other,
-				"Tokio test runtime is not multithreaded use #[tokio::test(flavor = \"multi_thread\")] instead",
-			))));
-		}
-
-		Ok(Self)
-	}
-
-	/// Whether to create a global rayon pool.
-	fn create_global_rayon_pool() -> bool {
-		false
-	}
-}
-
-/// Native runtime refers to a runtime where the global rayon pool is created within the runner.
-#[derive(Debug, Clone)]
-pub struct Native;
-
-impl Runtime for Native {
-	/// Try to create a new runtime.
-	///
-	/// There are no restrictions on the surrounding environment here.
-	fn try_new() -> Result<Self, RuntimeError> {
-		Ok(Self)
-	}
-
-	/// Whether to create a global rayon pool.
-	fn create_global_rayon_pool() -> bool {
-		true
-	}
+/// Returns true if the current runtime is multithreaded.
+fn is_multithreaded_runtime() -> bool {
+	std::panic::catch_unwind(|| {
+		tokio::task::block_in_place(|| {});
+	})
+	.is_ok()
 }
 
-/// Delegated runtime refers to a runtime where the global rayon pool is created outside of the runner.
-///
-/// This is useful when we may be calling from other tasks, i.e., not at the main thread.
-#[derive(Debug, Clone)]
-pub struct Delegated;
-
-impl Runtime for Delegated {
-	/// Try to create a new runtime.
-	///
-	/// There are no restrictions on the surrounding environment here.
-	fn try_new() -> Result<Self, RuntimeError> {
-		Ok(Self)
-	}
-
-	/// Whether to create a global rayon pool.
-	fn create_global_rayon_pool() -> bool {
-		false
-	}
+/// Returns true if the current runtime is a tokio runtime.
+fn is_in_tokio_runtime() -> bool {
+	tokio::runtime::Handle::try_current().is_ok()
 }

util/movement-aptos/movement-aptos-core/src/movement_aptos/runtime/delegated.rs

@@ -0,0 +1,21 @@
+use super::{Runtime, RuntimeError};
+
+/// Delegated runtime refers to a runtime where the global rayon pool is created outside of the runner.
+///
+/// This is useful when we may be calling from other tasks, i.e., not at the main thread.
+#[derive(Debug, Clone)]
+pub struct Delegated;
+
+impl Runtime for Delegated {
+	/// Try to create a new runtime.
+	///
+	/// There are no restrictions on the surrounding environment here.
+	fn try_new() -> Result<Self, RuntimeError> {
+		Ok(Self)
+	}
+
+	/// Whether to create a global rayon pool.
+	fn create_global_rayon_pool() -> bool {
+		false
+	}
+}

util/movement-aptos/movement-aptos-core/src/movement_aptos/runtime/native.rs

@@ -0,0 +1,43 @@
+use super::{is_in_tokio_runtime, Runtime, RuntimeError};
+
+/// Native runtime refers to a runtime where the global rayon pool is created within the runner.
+#[derive(Debug, Clone)]
+pub struct Native;
+
+impl Runtime for Native {
+	/// Try to create a new runtime.
+	///
+	/// There are no restrictions on the surrounding environment here.
+	fn try_new() -> Result<Self, RuntimeError> {
+		if is_in_tokio_runtime() {
+			return Err(RuntimeError::Unavailable(Box::new(std::io::Error::new(
+				std::io::ErrorKind::Other,
+				"Native runtime is not available in a tokio runtime",
+			))));
+		}
+
+		Ok(Self)
+	}
+
+	/// Whether to create a global rayon pool.
+	fn create_global_rayon_pool() -> bool {
+		true
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[tokio::test]
+	async fn test_native_runtime_should_fail_in_tokio_runtime() -> Result<(), anyhow::Error> {
+		assert!(Native::try_new().is_err());
+		Ok(())
+	}
+
+	#[test]
+	fn test_native_runtime_should_succeed_outside_of_tokio_runtime() -> Result<(), anyhow::Error> {
+		assert!(Native::try_new().is_ok());
+		Ok(())
+	}
+}

util/movement-aptos/movement-aptos-core/src/movement_aptos/runtime/tokio_test.rs

@@ -0,0 +1,47 @@
+use super::{is_in_tokio_runtime, is_multithreaded_runtime, Runtime, RuntimeError};
+
+/// Tokio test runtime.
+#[derive(Debug, Clone)]
+pub struct TokioTest;
+
+impl Runtime for TokioTest {
+	/// Try to create a new runtime.
+	fn try_new() -> Result<Self, RuntimeError> {
+		if !is_in_tokio_runtime() || !is_multithreaded_runtime() {
+			return Err(RuntimeError::Unavailable(Box::new(std::io::Error::new(
+				std::io::ErrorKind::Other,
+				"Tokio test runtime is not multithreaded use #[tokio::test(flavor = \"multi_thread\")] instead",
+			))));
+		}
+
+		Ok(Self)
+	}
+
+	/// Whether to create a global rayon pool.
+	fn create_global_rayon_pool() -> bool {
+		false
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[tokio::test(flavor = "multi_thread")]
+	async fn test_tokio_test_should_succeed_in_multi_thread() -> Result<(), anyhow::Error> {
+		TokioTest::try_new()?;
+		Ok(())
+	}
+
+	#[tokio::test]
+	async fn test_tokio_test_should_fail_in_single_thread() -> Result<(), anyhow::Error> {
+		assert!(TokioTest::try_new().is_err());
+		Ok(())
+	}
+
+	#[test]
+	fn test_tokio_test_should_fail_outside_of_tokio_test() -> Result<(), anyhow::Error> {
+		assert!(TokioTest::try_new().is_err());
+		Ok(())
+	}
+}