Actor Systems In Rust: Techniques and Tradeoffs

Transcript

1. Actor Systems in Rust: Techniques and Tradeoffs Andrew J. Stone
2. Haret Distributed Coordinator and KV Store
3. Haret Multiple Independent Consensus Groups
4. Haret Protocol Viewstamped Replication Revisited for Consensus
5. Haret Backend • Versioned persistent trie per consensus group • CAS on entire subtrees • Typed Leaves • Blob • Queue • Set
6. node3@10.10.0.3 node1@10.10.0.1 node2@10.10.0.2 p1 p2 p3 Request (1) Prepare (2) PrepareOk (3) Prepare (2) PrepareOk (3) Reply (4)
7. Actors Processes That Communicate Only via Asynchronous Msg Passing
8. Actors Straightforward Representation of Peers in a Consensus Group
9. Rabble Actor Abstractions for Implementing Distributed Algorithms
10. Rabble Dynamic Cluster Membership, Transport and Msg Routing
11. Rabble Designed for Testability
12. Rabble A Work in Progress
13. Rabble Provides a clean way to implement VRR in Haret
14. Naming pub struct Pid { pub group: Option<String>, pub name: String, pub node: NodeId, }
15. Messages pub enum Msg<T> { User(T), ClusterStatus(ClusterStatus), ExecutorStatus(ExecutorStatus), StartTimer(usize), // time in ms CancelTimer(Option<CorrelationId>), Timeout, Shutdown, GetMetrics, Metrics(Vec<(Name, Metric)>) } { Rabble built-ins User Defined
16. Envelopes pub struct Envelope<T> { pub to: Pid, pub from: Pid, pub msg: Msg<T>, pub correlation_id: Option<CorrelationId> }
17. pub trait Process<T> : Send { /// Handle messages from other actors fn handle(&mut self, msg: Msg<T>, from: Pid, correlation_id: Option<CorrelationId>, output: &mut Vec<Envelope<T>>); } Processes
18. Echo Server P1 (Client) Envelope { to: P2, from: P1, msg: Msg::User<Hello>, correlation_id: Some(P1) } Envelope { to: P1, from: P2, msg: Msg::User<Hello>, correlation_id: Some(P1) } P2 (Server)
19. impl Process<T> for EchoServer<T> { fn handle(&mut self, msg: Msg<T>, from: Pid, cid: Option<CorrelationId>, output: &mut Vec<Envelope<T>>) { match msg { Msg::User(Hello) => { let to = from; // P1 let from = self.pid.clone(); // P2 let msg = Msg::User(Hello); let reply = Envelope::new(to, from, msg, cid); output.push(reply); }, _ => () } }
20. Executor Locates and Runs Processes
21. P1 P2 P3 Hashmap<Pid, Process> Executor Channel To: P1 Thread Handle
22. Property Based Testing 1. Construct a group of processes in an initial state 2. Generate a schedule of test messages 3. Call the handle method of a process with a test message 4. Collect output messages of handle method 5. Schedule output messages
23. Test Scheduling Trigger Protocol State Transitions with Explicit Timeouts
24. Test Assertions •Pre/Post conditions •Global state invariants
25. Failing Tests Failing Schedules Run as a Regression Suite
26. Debugging Each Message Receipt is One Step in a Test Schedule
27. Cluster Server Non-blocking Single Threaded Server with TCP Connections to every node
28. Membership Dynamic Membership Maintained in an Observed-Remove Set
29. Services Actors that Run Blocking and CPU Intensive Operations
30. Takeaways
31. Takeaway Dynamic Messaging is Complex Expensive, and Unergonomic for Distributed Actors in Rust
32. Takeaway Writing Good Schedulers is Hard
33. Takeaway Design your systems to make deterministic testing easier
34. Takeaway Compromise and Pragmatism allow a good enough solution that works NOW
35. Links • https://github.com/andrewjstone/rabble • https://github.com/andrewjstone/orset • https://github.com/vmware/haret
36. Thanks! Tom Santero Justin Sheehy VMware