Some tentative support to get wasm support for Ractor

ractor/Cargo.toml

@@ -17,7 +17,6 @@ rust-version = "1.64"
 ### Other features
 cluster = []
 
-# default = ["async-std"]
 default = []
 
 [dependencies]
@@ -26,23 +25,45 @@ async-trait = "0.1"
 dashmap = "5"
 futures = "0.3"
 once_cell = "1"
-rand = "0.8"
 
 # Tracing feature requires --cfg=tokio_unstable
 tokio = { version = "1", features = ["sync", "time", "rt", "macros", "tracing"] }
 async-std = { version = "1", features = ["attributes"], optional = true}
 tracing = { version = "0.1", features = ["attributes"] }
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+# TODO #124 - this is due to the temporary disabling of the "factory" module
+rand = "0.8"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+# instant = { version = "0.1", features = ["wasm-bindgen"]}
+getrandom = { version = "0.2", features = ["js"] }
+parking_lot = { version = "0.11", features = ["wasm-bindgen"] }
+wasm-timer = { version = "0.2" }
+wasm-bindgen-futures = { version = "0.4"}
+wasm-bindgen-test = "0.3"
+wasmtimer = { version = "0.2", features = ["tokio"] }
+
 [dev-dependencies]
-criterion = "0.5"
+backtrace = "0.3"
 function_name = "0.3"
 paste = "1"
 rand = "0.8"
-tokio = { version = "1", features = ["rt", "time", "sync", "macros", "rt-multi-thread", "tracing"] }
 tracing-glog = "0.3"
 tracing-subscriber = { version = "0.3", features = ["env-filter"]}
+
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+console_error_panic_hook = "0.1"
+tokio = { version = "1", features = ["rt", "time", "sync", "macros"] }
+tracing-wasm = "0.2"
+wasm-bindgen = "0.2"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+criterion = "0.5"
+tokio = { version = "1", features = ["rt", "time", "sync", "macros", "rt-multi-thread", "tracing"] }
 tracing-test = "0.2"
 
+
 [[bench]]
 name = "actor"
 harness = false

ractor/benches/actor.rs

@@ -3,9 +3,11 @@
 // This source code is licensed under both the MIT license found in the
 // LICENSE-MIT file in the root directory of this source tree.
 
+#[cfg(not(target_arch = "wasm32"))]
 #[macro_use]
 extern crate criterion;
 
+#[cfg(not(target_arch = "wasm32"))]
 use criterion::{BatchSize, Criterion};
 #[cfg(feature = "cluster")]
 use ractor::Message;
@@ -45,6 +47,7 @@ impl Actor for BenchActor {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn create_actors(c: &mut Criterion) {
     let small = 100;
     let large = 10000;
@@ -130,6 +133,7 @@ fn create_actors(c: &mut Criterion) {
     });
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn schedule_work(c: &mut Criterion) {
     let small = 100;
     let large = 1000;
@@ -239,6 +243,7 @@ fn schedule_work(c: &mut Criterion) {
     });
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 #[allow(clippy::async_yields_async)]
 fn process_messages(c: &mut Criterion) {
     const NUM_MSGS: u64 = 100000;
@@ -328,5 +333,10 @@ fn process_messages(c: &mut Criterion) {
     });
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 criterion_group!(actors, create_actors, schedule_work, process_messages);
+#[cfg(not(target_arch = "wasm32"))]
 criterion_main!(actors);
+
+#[cfg(target_arch = "wasm32")]
+fn main() {}

ractor/examples/counter.rs

@@ -99,7 +99,8 @@ fn init_logging() {
     tracing::subscriber::set_global_default(subscriber).expect("to set global subscriber");
 }
 
-#[tokio::main]
+#[cfg_attr(not(target_arch = "wasm32"), tokio::main)]
+#[cfg_attr(target_arch = "wasm32", tokio::main(flavor = "current_thread"))]
 async fn main() {
     init_logging();
 

ractor/examples/monte_carlo.rs

@@ -228,7 +228,8 @@ fn init_logging() {
     tracing::subscriber::set_global_default(subscriber).expect("to set global subscriber");
 }
 
-#[tokio::main]
+#[cfg_attr(not(target_arch = "wasm32"), tokio::main)]
+#[cfg_attr(target_arch = "wasm32", tokio::main(flavor = "current_thread"))]
 async fn main() {
     init_logging();
 

ractor/examples/output_port.rs

@@ -127,7 +127,8 @@ fn init_logging() {
     tracing::subscriber::set_global_default(subscriber).expect("to set global subscriber");
 }
 
-#[tokio::main]
+#[cfg_attr(not(target_arch = "wasm32"), tokio::main)]
+#[cfg_attr(target_arch = "wasm32", tokio::main(flavor = "current_thread"))]
 async fn main() {
     init_logging();
 

ractor/examples/philosophers.rs

@@ -487,7 +487,8 @@ fn init_logging() {
     tracing::subscriber::set_global_default(subscriber).expect("to set global subscriber");
 }
 
-#[tokio::main]
+#[cfg_attr(not(target_arch = "wasm32"), tokio::main)]
+#[cfg_attr(target_arch = "wasm32", tokio::main(flavor = "current_thread"))]
 async fn main() {
     init_logging();
 

ractor/examples/ping_pong.rs

@@ -105,7 +105,8 @@ fn init_logging() {
     tracing::subscriber::set_global_default(subscriber).expect("to set global subscriber");
 }
 
-#[tokio::main]
+#[cfg_attr(not(target_arch = "wasm32"), tokio::main)]
+#[cfg_attr(target_arch = "wasm32", tokio::main(flavor = "current_thread"))]
 async fn main() {
     init_logging();
 

ractor/examples/supervisor.rs

@@ -44,7 +44,8 @@ fn init_logging() {
     tracing::subscriber::set_global_default(subscriber).expect("to set global subscriber");
 }
 
-#[tokio::main]
+#[cfg_attr(not(target_arch = "wasm32"), tokio::main)]
+#[cfg_attr(target_arch = "wasm32", tokio::main(flavor = "current_thread"))]
 async fn main() {
     init_logging();
 

ractor/src/actor/actor_cell.rs

@@ -12,7 +12,7 @@
 use std::any::TypeId;
 use std::sync::Arc;
 
-#[cfg(feature = "async-std")]
+#[cfg(any(feature = "async-std", target_arch = "wasm32"))]
 use futures::FutureExt;
 
 use super::messages::{Signal, StopMessage};
@@ -110,7 +110,7 @@ impl ActorPortSet {
     where
         TState: crate::State,
     {
-        #[cfg(feature = "async-std")]
+        #[cfg(any(feature = "async-std", target_arch = "wasm32"))]
         {
             crate::concurrency::select! {
                 // supervision or message processing work
@@ -124,7 +124,7 @@ impl ActorPortSet {
                 }
             }
         }
-        #[cfg(not(feature = "async-std"))]
+        #[cfg(not(any(feature = "async-std", target_arch = "wasm32")))]
         {
             crate::concurrency::select! {
                 // supervision or message processing work
@@ -149,7 +149,7 @@ impl ActorPortSet {
     /// Returns [Ok(ActorPortMessage)] on a successful message reception, [MessagingErr]
     /// in the event any of the channels is closed.
     pub async fn listen_in_priority(&mut self) -> Result<ActorPortMessage, MessagingErr<()>> {
-        #[cfg(feature = "async-std")]
+        #[cfg(any(feature = "async-std", target_arch = "wasm32"))]
         {
             crate::concurrency::select! {
                 signal = self.signal_rx.recv().fuse() => {
@@ -166,7 +166,7 @@ impl ActorPortSet {
                 }
             }
         }
-        #[cfg(not(feature = "async-std"))]
+        #[cfg(not(any(feature = "async-std", target_arch = "wasm32")))]
         {
             crate::concurrency::select! {
                 signal = self.signal_rx.recv() => {

ractor/src/actor/tests/mod.rs

@@ -16,15 +16,16 @@
     Actor, ActorCell, ActorProcessingErr, ActorRef, ActorStatus, SpawnErr, SupervisionEvent,
 };
 
-mod supervisor;
+pub mod supervisor;
 
 struct EmptyMessage;
 #[cfg(feature = "cluster")]
 impl crate::Message for EmptyMessage {}
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_panic_on_start_captured() {
+    crate::common_test::setup();
     struct TestActor;
 
     #[async_trait::async_trait]
@@ -47,8 +48,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_error_on_start_captured() {
+    crate::common_test::setup();
     struct TestActor;
 
     #[async_trait::async_trait]
@@ -71,8 +73,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_stop_higher_priority_over_messages() {
+    crate::common_test::setup();
     let message_counter = Arc::new(AtomicU8::new(0u8));
 
     struct TestActor {
@@ -150,8 +153,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_kill_terminates_work() {
+    crate::common_test::setup();
     struct TestActor;
 
     #[async_trait::async_trait]
@@ -196,8 +200,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_stop_does_not_terminate_async_work() {
+    crate::common_test::setup();
     struct TestActor;
 
     #[async_trait::async_trait]
@@ -251,8 +256,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_kill_terminates_supervision_work() {
+    crate::common_test::setup();
     struct TestActor;
 
     #[async_trait::async_trait]
@@ -299,8 +305,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_sending_message_to_invalid_actor_type() {
+    crate::common_test::setup();
     struct TestActor1;
     struct TestMessage1;
     #[cfg(feature = "cluster")]
@@ -357,8 +364,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_sending_message_to_dead_actor() {
+    crate::common_test::setup();
     struct TestActor;
 
     #[async_trait::async_trait]
@@ -391,8 +399,9 @@
 
 #[cfg(feature = "cluster")]
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_serialized_cast() {
+    crate::common_test::setup();
     use crate::message::{BoxedDowncastErr, SerializedMessage};
     use crate::Message;
 
@@ -506,8 +515,9 @@
 
 #[cfg(feature = "cluster")]
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_serialized_rpc() {
+    crate::common_test::setup();
     use crate::message::{BoxedDowncastErr, SerializedMessage};
     use crate::{Message, RpcReplyPort};
 
@@ -616,8 +626,9 @@
 
 #[cfg(feature = "cluster")]
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn test_remote_actor() {
+    crate::common_test::setup();
     use crate::message::{BoxedDowncastErr, SerializedMessage};
     use crate::{ActorId, ActorRuntime, Message};
 
@@ -725,8 +736,9 @@
 
 #[cfg(feature = "cluster")]
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn spawning_local_actor_as_remote_fails() {
+    crate::common_test::setup();
     use crate::ActorProcessingErr;
 
     struct RemoteActor;
@@ -782,8 +794,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn instant_spawns() {
+    crate::common_test::setup();
     let counter = Arc::new(AtomicU8::new(0));
 
     struct EmptyActor;
@@ -843,7 +856,7 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn stop_and_wait() {
     struct SlowActor;
     #[async_trait::async_trait]
@@ -872,8 +885,9 @@
 }
 
 #[crate::concurrency::test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 async fn kill_and_wait() {
+    crate::common_test::setup();
     struct SlowActor;
     #[async_trait::async_trait]
     impl Actor for SlowActor {
@@ -901,8 +915,9 @@
 }
 
 #[test]
-#[tracing_test::traced_test]
+#[cfg_attr(not(target_arch = "wasm32"), tracing_test::traced_test)]
 fn test_err_map() {
+    crate::common_test::setup();
     let err: RactorErr<i32> = RactorErr::Messaging(MessagingErr::SendErr(123));
 
     let _: RactorErr<()> = err.map(|_| ());