|
|
--- |
|
|
license: gpl-3.0 |
|
|
pretty_name: Typed Actor Model for Rust |
|
|
--- |
|
|
# 🧠 Actory — Typed Actor Model for Rust |
|
|
|
|
|
`actory` is a lightweight, strongly typed actor framework for Dart that enables building concurrent, message-driven systems with: |
|
|
|
|
|
* ✅ Async & sync actors |
|
|
* ✅ Isolate-based concurrency |
|
|
* ✅ Typed message passing (no use of `dynamic`) |
|
|
* ✅ Ask/reply patterns with `Future`-based messaging |
|
|
* ✅ Supervision strategies for fault tolerance |
|
|
* ✅ Remote actors with WebSocket clustering support |
|
|
* ✅ Thread-safe data structures (SafeMap) for shared state |
|
|
|
|
|
--- |
|
|
|
|
|
## 🚀 Basic Usage |
|
|
|
|
|
```dart |
|
|
final system = ActorSystem(); |
|
|
|
|
|
final greeter = await system.spawn<Greet>( |
|
|
Greeter(), |
|
|
(msg) => msg as Greet, |
|
|
); |
|
|
|
|
|
greeter.send(Greet('Alice')); |
|
|
``` |
|
|
|
|
|
--- |
|
|
|
|
|
## 🌐 Remote Actors |
|
|
|
|
|
Actory supports distributed actor systems spanning multiple nodes. |
|
|
|
|
|
### Using `RemoteActorFactory` (Recommended) |
|
|
|
|
|
```dart |
|
|
final factory = RemoteActorFactory( |
|
|
host: 'localhost', |
|
|
port: 8080, |
|
|
peerUrls: ['ws://localhost:8081'], |
|
|
); |
|
|
|
|
|
await factory.start(); |
|
|
|
|
|
await factory.createLocalActor<ChatMessage>( |
|
|
'chat-actor', |
|
|
ChatActor(), |
|
|
(msg) => msg as ChatMessage, |
|
|
); |
|
|
|
|
|
factory.registerRemoteActor('remote-chat', 'ws://localhost:8081'); |
|
|
|
|
|
factory.sendMessage('chat-actor', ChatMessage('User', 'Hello!')); |
|
|
factory.sendMessage('remote-chat', ChatMessage('User', 'Hello remote!')); |
|
|
``` |
|
|
|
|
|
### Manual Remote Actor Setup |
|
|
|
|
|
```dart |
|
|
final clusterNode = ClusterNode('localhost', 8080); |
|
|
final registry = ActorRegistry(); |
|
|
|
|
|
await clusterNode.start(); |
|
|
|
|
|
final localActor = await system.spawn<Message>(actor, decoder); |
|
|
registry.registerLocal('my-actor', localActor); |
|
|
|
|
|
registry.registerRemote('remote-actor', 'ws://localhost:8081'); |
|
|
|
|
|
final localRef = registry.get('my-actor'); |
|
|
final remoteRef = registry.get('remote-actor'); // Returns RemoteActorRef |
|
|
|
|
|
localRef?.send(message); |
|
|
remoteRef?.send(message); |
|
|
``` |
|
|
|
|
|
--- |
|
|
|
|
|
## 🔒 SafeMap — Thread-Safe Data Structure |
|
|
|
|
|
`SafeMap` provides atomic and thread-safe operations on shared state **within a single Dart isolate**. Since each actor runs in its own isolate, `SafeMap` is useful for shared data inside an isolate, while cross-isolate communication should use message passing. |
|
|
|
|
|
### Usage Example |
|
|
|
|
|
```dart |
|
|
final sharedData = SafeMap<String, String>(); |
|
|
|
|
|
sharedData.set('key', 'value'); |
|
|
final value = sharedData.get('key'); |
|
|
|
|
|
final wasAdded = sharedData.putIfAbsent('key', () => 'default'); |
|
|
final computed = sharedData.getOrCompute('key', () => 'computed'); |
|
|
|
|
|
final wasUpdated = sharedData.updateIfPresent('key', (v) => 'updated_$v'); |
|
|
|
|
|
final keys = sharedData.keys; |
|
|
final values = sharedData.values; |
|
|
final entries = sharedData.entries; |
|
|
|
|
|
final filtered = sharedData.where((key, value) => key.startsWith('user_')); |
|
|
final transformed = sharedData.map((key, value) => MapEntry('new_$key', value.toUpperCase())); |
|
|
|
|
|
sharedData.merge({'key2': 'value2'}); |
|
|
sharedData.mergeSafeMap(otherSafeMap); |
|
|
|
|
|
final copy = sharedData.copy(); |
|
|
final regularMap = sharedData.toMap(); |
|
|
sharedData.clear(); |
|
|
``` |
|
|
|
|
|
### SafeMap in an Actor |
|
|
|
|
|
```dart |
|
|
class SharedStateActor extends Actor<dynamic> { |
|
|
final SafeMap<String, int> _counters = SafeMap<String, int>(); |
|
|
|
|
|
@override |
|
|
Future<void> onMessage(dynamic message, ActorContext<dynamic> context) async { |
|
|
if (message is IncrementCounter) { |
|
|
final current = _counters.get(message.key) ?? 0; |
|
|
_counters.set(message.key, current + 1); |
|
|
context.send('Counter ${message.key}: ${current + 1}'); |
|
|
} |
|
|
} |
|
|
} |
|
|
``` |
|
|
|
|
|
--- |
|
|
|
|
|
## 📁 Examples |
|
|
|
|
|
* `/example/main.dart` — Basic actor usage |
|
|
* `/example/cluster_main.dart` — Cluster node example |
|
|
* `/example/simple_remote_actor.dart` — Simple remote actor |
|
|
* `/example/remote_actor_example.dart` — Full remote actor demo |
|
|
* `/example/factory_remote_actor.dart` — `RemoteActorFactory` usage |
|
|
* `/example/safe_map_example.dart` — SafeMap usage with actors |
|
|
* `/example/safe_map_actor_example.dart` — Focused SafeMap actor demo |
|
|
|
|
|
--- |
|
|
|
|
|
## 🔧 Architecture Overview |
|
|
|
|
|
* **Actor** — Basic message processing unit |
|
|
* **ActorSystem** — Manages actor lifecycle and supervision |
|
|
* **ClusterNode** — WebSocket-based cluster node for distributed communication |
|
|
* **ActorRegistry** — Maps actor IDs to local or remote references |
|
|
* **RemoteActorRef** — Proxy to communicate with remote actors |
|
|
* **RemoteActorFactory** — High-level API to manage local and remote actors |
|
|
* **SafeMap** — Thread-safe map implementation for shared state within isolates |
