so it should be designed to behave like a persistent actor
where it has an explicit state recovery mechanism and processing stage it executes before it's allowed to process any new messages
since the actors don't get deployed remotely
i have a shardenvilope :
public sealed class ShardEnvelope
{
public readonly string Recipient;
public readonly object Message;
public ShardEnvelope(string recipient, object message)
{
Recipient = recipient;
Message = message;
}
}}
an extrator : public class CustomMessageExtractor : HashCodeMessageExtractor
{
public CustomMessageExtractor(int maxNumberOfShards) : base(maxNumberOfShards) { }
public override string EntityId(object message) => (message as ShardEnvelope)?.Recipient;
public override object EntityMessage(object message) => (message as ShardEnvelope)?.Message ?? message;
// public string ShardId(object message)
// {
// return (message as ShardEnvelope)?.ShardId.ToString();
// }
}
{
public CustomMessageExtractor(int maxNumberOfShards) : base(maxNumberOfShards) { }
public override string EntityId(object message) => (message as ShardEnvelope)?.Recipient;
public override object EntityMessage(object message) => (message as ShardEnvelope)?.Message ?? message;
// public string ShardId(object message)
// {
// return (message as ShardEnvelope)?.ShardId.ToString();
// }
}
message A :smile: public class Message1
{
public Message1(string name1)
{
Name1 = name1;
}
{
public Message1(string name1)
{
Name1 = name1;
}
public string Name1 { get; }
}
Actor A public class ActorA: AtLeastOnceDeliveryReceiveActor
{
{
public override string PersistenceId { get; }
readonly ILoggingAdapter _logger = Context.GetLogger();
public ActorA()
{
PersistenceId = Uri.UnescapeDataString(Self.Path.Name);
_logger.Info($"Instantiating {nameof(ActorA)} in the constructor with path {Self.Path}");
Command<Message1>(msg =>
{
_logger.Info($"log message {msg.Name1}");
IActorRef shardRegion2 = Context.System.BootstrapShard<ActorB>("web-node1");
// Context.ActorOf(Props.Create<ActorB>());
});
//Command<Message2>(msg =>
//{
// _logger.Info($"log message {msg.Name1}");
//});
}
}
public class ActorB : ReceivePersistentActor
{
{
public override string PersistenceId { get; }
readonly ILoggingAdapter _logger = Context.GetLogger();
public ActorB()
{
PersistenceId = Uri.UnescapeDataString(Self.Path.Name);
_logger.Info($"Instantiating {nameof(ActorB)} in the constructor with path {Self.Path.Name}");
Command<Message2>(msg =>
{
_logger.Info($"log message {msg.Name1}");
});
}
}
at start up I configure my shardding as :smile: ClusterSharding sharding = ClusterSharding.Get(eduSaaSSystem);
IActorRef shardRegion = sharding.Start(
typeName: typeof(ActorA).Name,
entityProps: Props.Create<ActorA>(), // the Props used to create entities
settings: ClusterShardingSettings.Create(eduSaaSSystem)
.WithCoordinatorSingletonSettings(ClusterSingletonManagerSettings.Create(eduSaaSSystem))
.WithRole("web-node")
,
messageExtractor: new CustomMessageExtractor(100 * 10)
);
IActorRef shardRegion = sharding.Start(
typeName: typeof(ActorA).Name,
entityProps: Props.Create<ActorA>(), // the Props used to create entities
settings: ClusterShardingSettings.Create(eduSaaSSystem)
.WithCoordinatorSingletonSettings(ClusterSingletonManagerSettings.Create(eduSaaSSystem))
.WithRole("web-node")
,
messageExtractor: new CustomMessageExtractor(100 * 10)
);
if i send message to shard region as shardRegion .Tell(new ShardEnvelope(id, messagea));
@Aaronontheweb are u with me?
ah I see
you're using an envelope for that
but yeah, that message will be received by your persistent actor
@Aaronontheweb thanks for detailed explanation and the valuable video.
I understand the complexity of the problem. I'll try to port this sample to akka.net and see how things go: http://proto.actor/blog/2017/06/24/money-transfer-saga.html
I understand the complexity of the problem. I'll try to port this sample to akka.net and see how things go: http://proto.actor/blog/2017/06/24/money-transfer-saga.html
@jameswilddev no, if you want to be sure its delivered (it will be send to the IActorRef you tell it to, but that actor might not receive it because its remote), you will have to use mechanisms like AtLeastOnceDelivery. So instead of directly sending it to the remote actor (assuming here) you put an atleastoncedelivery actor in between or something.
Or whatever other reliable delivery mechanism you want to use
So what im saying is: emulating a failure to deliver by the Scheduler, is the wrong place to be handling this.
I guess I should mock out the scheduler itself, check that it sends that message, and then test that when the message is received (or not received) that it acts accordingly.
Hello. I remember being recommended to put actor initialization logic in PreStart (such recommendation is also contained in Akka Bootcamp). What are the reasons for that except that before PreStart is called, an actor is not yet capable of receiving messages? For example, if an actor creates some child actors can the child creation logic be executed prior its PreStart? What can go wrong?
just need to add multi-targeting back to the
csproj file
and then executing the following
/// <summary>
/// Used to load HOCON definitions from a dedicated HOCON file
/// </summary>
public static class HoconLoader
{
/// <summary>
/// Parses a HOCON <see cref="Config" /> object from an underlying file
/// </summary>
/// <param name="path">The path to the HOCON file.</param>
/// <returns>A parsed <see cref="Config" /> object.</returns>
public static Config FromFile(string path)
{
return ConfigurationFactory.ParseString(File.ReadAllText(path));
}
}
similar to how you'd use a .JSON file for
Microsoft.Extensions.Configuration
and then I pass that hocon object into the
ActorSystem.Create(string name, Config config) method
we'll probably add something to Akka.NET core to make that easier soon