What is the correct way of disabling recovery of ReceivePersistentActor after some particular evert

[AlexanderKapelyukhovskiy]

Dear Akka.Persistence Team,

I'm using ReceivePersistentActor for representing Video Chat Session. Inside of Actor I'm storing current state and timers. I already implement the behavior I need but the problem is that after the Session finishes I don't need to recover this actor any more. So if the host restarted I don't need to restore all the old sessions. I need to restore state and timers only for active sessions. I resolved it by running a timer which sends a command 15 min after the Video Session End timer and then I execute DeleteMessages(long.MaxValue); It is working with only small issues - all actor's events deleted from the journal. I can see in the events table is_deleted column. Is there a way to set it to true from actor code and ignore duding recovery instead of deleting events from the table completely?

Am I using DeleteMessages in the correct way?
Could you recommend a better approach for storing session's state in persistent actors?

[Aaronontheweb]

I am going to assume that you have 1 actor per Video Chat Session.

The best approach here is to not activate those actors at all, if you can help it (i.e. don't ping them / raise them again) so they never even attempt to recover. But in the event that they are somehow activated anyway, here is what I'd recommend:

// If you see this, this entity is dead and cannot be recovered
public sealed class SessionTombstone{

}

"Tombstoning" is a popular strategy for setting a marker down in an event journal (in systems OUTSIDE of Akka.NET, FWIW) - have the actor do the following:

 case EndSessionCommand _: // or whatever
            // When ending a session, instead of deleting messages,
            // you could append a SessionTombstone event to mark its end.
            Persist(new SessionTombstone(), tombstone =>
            {
                // Optionally perform additional cleanup or state updates here
                Context.Stop(Self);
            });
            break;

If you don't want any of your state, you can call DeleteMessages inside that persist callback - leaving ONLY the tombstone.

When the actor "Recovers" and it notices the tombstone:

Recover<SessionTombstone>(tombstone =>
    {
        // When a tombstone is recovered, stop the actor from recovering further.
        // This effectively makes the actor ignore its past events and not perform any recovery logic.
        Context.Stop(Self);
    });

You can just show yourself down and not do any further processing this way. Does this help?

[Aaronontheweb]

An example of how to do cleanup here

 case EndSessionCommand _: // or whatever
            Persist(new SessionTombstone(), tombstone =>
            {
                DeleteMessages(LastSeqNr - 1); // hard delete EVERYTHING ELSE other than the tombstone
                Context.Stop(Self);
            });
            break;

[AlexanderKapelyukhovskiy]

Thank you for your response, @Aaronontheweb. I greatly appreciate today's conference and your insightful answer.

I am inclined towards the approach you suggested. However, I would like to clarify one aspect. It seems that even with the SessionTombstone event, Akka.Net will attempt to restore my actor after a host restart. So, if my system serves 1 million video sessions over the course of two years, does this mean there will be 1 million attempts to restore actors?

I'm concerned about the potential overhead of having to call Context.Stop(Self); for each actor instance every time the host restarts. Could you please suggest a more efficient approach to avoid this?

Thank you once again for your guidance.

[AlexanderKapelyukhovskiy]

one probably important point to mention is that I'm using shard region in same way you showed in https://github.com/petabridge/akkadotnet-code-samples

.WithShardRegion<VideoSessionMarker>(
    typeName: "video-sessions",
    entityPropsFactory: (persistenceId) =>
    {
        var videoChatServices = provider.GetService<IVideoChatServices>();
        return VideoSessionActor.GetProps(persistenceId, videoChatServices);
    },
    messageExtractor: new VideoSessionMessageRouter(),
    shardOptions: new ShardOptions
    {
        Role = VideoSessionProps.SingletonActorRole,
        RememberEntities = true,
        StateStoreMode = StateStoreMode.DData,
        RememberEntitiesStore = RememberEntitiesStore.Eventsourced,
        FailOnInvalidEntityStateTransition = true
    })

[Aaronontheweb]

Ah, this is your issue: RememberEntities = true - now this makes more sense. The "dead" entities are automatically being restarted.

I have an even easier solution for you then - you just need to tell the Sharding system "stop remembering me" when the session is terminated. You can do this via the following:

 // send Passivate to parent (shard actor) to stop remembering this entity.
// shard actor will send us back a `PoisonPill.Instance` message
// as our "shutdown" signal - at which point we can terminate normally.
Context.Parent.Tell(new Passivate(PoisonPill.Instance));

Documentation showing how to do this is here: https://getakka.net/articles/clustering/cluster-sharding.html#terminating-remembered-entities

That should solve your problem - these entities will no longer be automatically started after you do this. You can still cleanup and delete the data if you wish, but this should prevent them from recovering entirely.

[Aaronontheweb]

cc @AlexanderKapelyukhovskiy

[AlexanderKapelyukhovskiy]

Thank you so much @Aaronontheweb. I also realized it after watching great video about sharding you posted https://www.youtube.com/watch?v=2apFt9v0Vjw week ago.

Thank you for support!

[Aaronontheweb]

Thank you so much @Aaronontheweb. I also realized it after watching great video about sharding you posted https://www.youtube.com/watch?v=2apFt9v0Vjw week ago.

Thank you for support!

You're welcome!