@olanod - I had a similar requirement - I just use BasicActorRef and use try_tell - the gotcha is looking out for issue #129. There is a work around there where you just need to be explicit when you send your message type in.
@here - Is there any documentation around how to explicitly manage child actors? I have a scenario where I want to shut down a child actor once its done. Looking at Context.shutdown() or explicitly using a Stop message. Akka has a PoisonPill which would kill the actor once it hit that message in the mailbox. Anything similar? And what are the rules when ActorTerminated system message is sent to the parent? Is this before or after the child is shutdown and removed from the children list?
Hi. are there any examples out there on how to send a message to an actor, and, await it’s response (perhaps, something similar to the one on actix with it’s Ping). I guess if i’m sending a message from an actor, i could include it’s address in the send, and, message a response back. But, what if i’m sending it from
main etc?
oh..i guess i’d use the
ask pattern
if i send a message between two actors (say, add 2 + 2) - in order to handle the response (assuming, i do a send back from the compute actor to the asking actor), would my message necessarily also need to include a id of sorts? Wondering what would happen if i send two messages (2,2) and (3,3) one after the other? would the responses be sent back in order? thanks
@georgemp I haven't confirmed it yet(and perhaps you did already?) but my assumption is that because messages arrive to the letter inbox in order because you send them in order from the same place and from there are handed one by one to the handler, on the way back the same should happen and you would get things in order unless you do some async stuff when processing the messages
@olanod - did you ever find a way to run a future to completion from within an actor's recv method? Just using block_on results in the error
cannot execute
LocalPoolexecutor from within another executor: EnterError
and trying to use the ctx.run() method complains about a lifetime issue as the future that I'm trying to execute is a method on an S3 bucket client from rusoto. Thanks!
Never mind, was implementing it incorrectly. The docs work as expected. The key was using the
move keyword
For anyone else that has this issue, which is generally described as trying to use the Riker actor system within another runtime, you do need the top-level runtime to execute futures. So, when using the Tokio runtime, I needed to get a handle to it via
tokio::runtime::Handle::current() and then pass this handle around to the actor system whenever an actor needed to be able to block on a future. Hope this helps others! I think this should be added to the docs, and if I get motivated I may submit a PR for this.
Hello! I'm trying to make a web game using websocket and riker, but I can barely find any resources about how to connect them (e.g. feeding websocket messages into actors, using tokio runtime with riker because some of websocket crates depend on it). Has anybody tried to use websocket with riker?
3 replies
Can someone with merge rights take a look into riker-rs/riker#145 request. Github actions much better then travis. Travis has contant problems and slow.
Version 0.4.2 is now available. Special thanks to @olexiyb and @nothingismagick for:
- Updated to use stable dashmap
- Fixed clippy and pre-commit errors
- Migration from Travis to GitHub Actions
Next up we'll be expanding on the migration to GHA to improve cadence with regards to code merges and version releases. Thank you to the team and community.
[dependencies]
riker = "0.4.2"
we are working on using libp2p-noise (XX flavor handshake) for remote actors (sort of like the
ask pattern here: https://riker.rs/patterns/ )
Does anyone know what to do about
'there is no timer running, must be called from the context of Tokio runtime' when using Context::run? riker-rs/riker#150
[tokio::main]
async fn main() -> std::io::Result<()> {let rt = tokio::runtime::Handle::current() ;
let sys = ActorSystem::new().unwrap(); // how do i add rt to the sys handle
Does anybody have a suggestion for how to access to an actor from a future spawned with
Context::run? I would basically like to use self when running a future using ctx.run(async move { self.data = something().await; }) but of course that doesn't work. Can I use messages?
Pony community is steadily growing and they're doing some updates to the lang runtime with https://github.com/jemc/mare
Bringing some ideas from Project Verona of Microsoft, where one of the Pony creators, Sylvan Clebsch is working on an evolution of Rust and Pony ideas.
Just a quick question
Does anyone know how to have actors messaging each other (cycles)
That's Scala pseudocode
@isubasinghe Well I was curious so I tried it out myself and it works just fine. Code -
#[derive(Debug, Clone)]
enum Actor1Command {
Ping,
Pong,
Init { a2: ActorRef<Actor2Command> },
}
struct Actor1 {
a2: Option<ActorRef<Actor2Command>>,
}
impl ActorFactoryArgs<Option<ActorRef<Actor2Command>>> for Actor1 {
fn create_args(args: Option<ActorRef<Actor2Command>>) -> Self {
Actor1 { a2: args }
}
}
impl Actor for Actor1 {
type Msg = Actor1Command;
fn recv(&mut self, _ctx: &Context<Self::Msg>, msg: Self::Msg, _sender: Sender) {
match msg {
Actor1Command::Ping => {
println!("Actor 1 received message");
_ctx.schedule_once(
Duration::from_millis(1000),
_ctx.myself(),
None,
Actor1Command::Pong,
);
}
Actor1Command::Pong => {
self.a2
.as_ref()
.map(|aref| aref.tell(Actor2Command::Ping, None));
}
Actor1Command::Init { a2 } => self.a2 = Some(a2),
}
}
}
struct Actor2 {
a1: ActorRef<Actor1Command>,
}
#[derive(Debug, Clone)]
enum Actor2Command {
Ping,
Pong,
}
impl ActorFactoryArgs<ActorRef<Actor1Command>> for Actor2 {
fn create_args(args: ActorRef<Actor1Command>) -> Self {
Actor2 { a1: args }
}
}
impl Actor for Actor2 {
type Msg = Actor2Command;
fn recv(&mut self, _ctx: &Context<Self::Msg>, msg: Self::Msg, _sender: Sender) {
match msg {
Actor2Command::Ping => {
println!("Actor 2 received message");
_ctx.schedule_once(
Duration::from_millis(1000),
_ctx.myself(),
None,
Actor2Command::Pong,
);
}
Actor2Command::Pong => {
self.a1.tell(Actor1Command::Ping, None);
}
}
}
}
let sys = ActorSystem::new().unwrap();
let actor1: ActorRef<Actor1Command> = sys
.actor_of_props::<Actor1>("actor1", Props::new_args(None))
.expect("blargh");
let actor2: ActorRef<Actor2Command> = sys
.actor_of_props::<Actor2>("actor2", Props::new_args(actor1.clone()))
.expect("blargh");
actor1
.clone()
.tell(Actor1Command::Init { a2: actor2.clone() }, None);
actor1.clone().tell(Actor1Command::Ping, None);
std::thread::sleep(Duration::from_millis(10_000));