proto-cheatsheet.md

define actor:

• var props = Props.FromProducer(() => actor);
• var props = Props.FromFunc(context => { ... });

configure actor:

• props.WithDispatcher(dispatcher);
• props.WithMailbox(() => mailbox);
• props.WithSupervisor(strategy);
• props.WithSenderMiddleware(middleware[]);
• props.WithReceiveMiddleware(middleware[]);
• props.WithProducer(() => actor); ???
• props.WithSpawner(); ???

create context:

• var context = new RootContext();

create actor:

• var pid = context.Spawn(props);
• var pid = context.SpawnNamed(props, name);
• var pid = context.SpawnPrefix(props, prefix);

---

serve actor system:

• Serialization.RegisterFileDescriptor(MessagesReflection.Descriptor);
• Remote.Start("127.0.0.1", 8000);

connect to actor system:

• Serialization.RegisterFileDescriptor(MessagesReflection.Descriptor);
• Remote.Start("127.0.0.1", 0);
• var pid = new PID("127.0.0.1:8000", "actorname");

remote activation

• Remote.RegisterKnownKind("hello", props); // need to be done before Remote.Start
• Remote.Start("127.0.0.1", port);
• var pid = Remote.SpawnAsync("host:port", "hello", timeout);
• var pid = Remote.SpawnNamedAsync("host:port", "remote", "hello", TimeSpan.FromSeconds(5));

send message:

• pid.Tell(message);

request a response:

• pid.ReqestAsync<Response>(message);
• context.Respond(response);

request a response (as message):

• context.Request(pid, message); // response will be sent as message

router:

• var router_props = Router.NewBroadcastGroup(actor_props, pid[])
• var router_props = Router.NewBroadcastPool(actor_props, 5);

supervision

• type Decision = Resume | Restart | Stop | Escalate
• type Decider = (pid, exception) -> decision
• var strategy = new AllForOneStrategy(decider, retries, window)
• var strategy = new OneForOneStrategy(decider, retries, window)
• var strategy = new ExponentialBackoffStrategy(window, interval)
• what escalation does?

event stream

• var eventstream = new EventStream()
• var eventstream = new EventStream<T>()
• eventstream.Subscribe(Action<T> handler)
• eventstream.Publish(event)

persistence

• var provider = new SqliteProvider(new SqliteConnectionStringBuilder { DataSource = "states.db" });
• WithEventSourcing, WithSnapshotting, WithEventSourcingAndSnapshotting
• var persistence = Persistence.WithEventSourcingAndSnapshotting(provider, "name???", event => {...}, snapshot => {...});
• persistence.RecoverStateAsync()
• persistence.PersistSnapshotAsync(state);
• persistence.PersistEventAsync(event);

behavior

• context.SetBehavior(receive);
• context.PushBehavior(receive);
• context.PopBehavior(receive);

life cycle

• Proto.Started, Proto.Restarting, Proto.Stopping, Proto.Stopped

timeout

• context.SetReceiveTimeout(timespan);
• case ReceiveTimeout _: WriteLine("Timeout!")

monitor

• context.Watch(pid)
• case Proto.Terminated _: WriteLine("Other died");

schedulers

• var scheduler = new SimpleScheduler();
• scheduler.ScheduleTellOnce(...);
• scheduler.ScheduleTellRepeatedly(...);

cluster

• Cluster.Start("MyCluster", "127.0.0.1", 9876, new ConsulProvider(new ConsulProviderOptions()));
• Cluster.StartWithConfig(new ClusterConfig(...));
• var pid = Cluster.GetAsync("name", "kind");

skeleton (json)

var serializationBinder = new KnownTypesSerializationBinder();
var serializationSettings = new JsonSerializerSettings {
  TypeNameHandling = TypeNameHandling.Auto,
  SerializationBinder = serializationBinder,
};
Serialization.RegisterSerializer(
  new NewtonsoftSerializer(serializationSettings), true);
var clusterProvider = new ConsulProvider(
  new ConsulProviderOptions(),
  c => c.Address = new Uri($"http://{consulAddress.Host}:{consulAddress.Port}"));
var clusterConfig = new ClusterConfig(
  clusterName,
  advertisedAddress.Host,
  advertisedAddress.Port,
  clusterProvider);
Cluster.StartWithConfig(clusterConfig);
Remote.RegisterKnownKind("null", Props.FromFunc(_ => Actor.Done));

• process registry
• grains