public void Init(bool sendSupervise, Func<Mailbox> createMailbox /*, MailboxType mailboxType*/) //TODO: switch from Func<Mailbox> createMailbox to MailboxType mailboxType
{
var mailbox = createMailbox(); //Akka: dispatcher.createMailbox(this, mailboxType)
Dispatcher.Attach(this);
mailbox.Setup(Dispatcher);
mailbox.SetActor(this);
_mailbox = mailbox;
var createMessage = new Create();
// AKKA:
// /*
// * The mailboxType was calculated taking into account what the MailboxType
// * has promised to produce. If that was more than the default, then we need
// * to reverify here because the dispatcher may well have screwed it up.
// */
//// we need to delay the failure to the point of actor creation so we can handle
//// it properly in the normal way
//val actorClass = props.actorClass
//val createMessage = mailboxType match {
// case _: ProducesMessageQueue[_] if system.mailboxes.hasRequiredType(actorClass) ⇒
// val req = system.mailboxes.getRequiredType(actorClass)
// if (req isInstance mbox.messageQueue) Create(None)
// else {
// val gotType = if (mbox.messageQueue == null) "null" else mbox.messageQueue.getClass.getName
// Create(Some(ActorInitializationException(self,
// s"Actor [$self] requires mailbox type [$req] got [$gotType]")))
// }
// case _ ⇒ Create(None)
//}
//swapMailbox(mbox)
//mailbox.setActor(this)
//// ➡➡➡ NEVER SEND THE SAME SYSTEM MESSAGE OBJECT TO TWO ACTORS ⬅⬅⬅
//mailbox.systemEnqueue(self, createMessage)
var self = Self;
mailbox.Post(self, new Envelope {Message = createMessage, Sender = self});
if(sendSupervise)
{
Parent.Tell(new Supervise(self, async: false), self);
}
}
private bool Equals(Create other)
{
return(Equals(Failure, other.Failure));
}
/// <summary>
/// Initialize this cell, i.e. set up mailboxes and supervision. The UID must be
/// reasonably different from the previous UID of a possible actor with the same path,
/// which can be achieved by using <see cref="ThreadLocalRandom"/>
/// </summary>
/// <param name="sendSupervise"></param>
/// <param name="mailboxType"></param>
public void Init(bool sendSupervise, MailboxType mailboxType)
{
/*
* Create the mailbox and enqueue the Create() message to ensure that
* this is processed before anything else.
*/
var mailbox = Dispatcher.CreateMailbox(this, mailboxType);
Create createMessage;
/*
* The mailboxType was calculated taking into account what the MailboxType
* has promised to produce. If that was more than the default, then we need
* to reverify here because the dispatcher may well have screwed it up.
*/
// we need to delay the failure to the point of actor creation so we can handle
// it properly in the normal way
var actorClass = Props.Type;
if (System.Mailboxes.ProducesMessageQueue(mailboxType.GetType()) && System.Mailboxes.HasRequiredType(actorClass))
{
var req = System.Mailboxes.GetRequiredType(actorClass);
if (req.IsInstanceOfType(mailbox.MessageQueue)) createMessage = new Create(null); //success
else
{
var gotType = mailbox.MessageQueue == null ? "null" : mailbox.MessageQueue.GetType().FullName;
createMessage = new Create(new ActorInitializationException(Self,$"Actor [{Self}] requires mailbox type [{req}] got [{gotType}]"));
}
}
else
{
createMessage = new Create(null);
}
SwapMailbox(mailbox);
Mailbox.SetActor(this);
//// ➡➡➡ NEVER SEND THE SAME SYSTEM MESSAGE OBJECT TO TWO ACTORS ⬅⬅⬅
var self = Self;
mailbox.SystemEnqueue(self, createMessage);
if(sendSupervise)
{
Parent.SendSystemMessage(new Supervise(self, async: false));
}
}
private void HandleCreate(Create obj) //Called create in Akka (ActorCell.scala)
{
//TODO: this is missing bits and pieces compared to Akka
try
{
var instance = NewActor();
_actor = instance;
UseThreadContext(() => instance.AroundPreStart());
CheckReceiveTimeout();
if(System.Settings.DebugLifecycle)
Publish(new Debug(Self.Path.ToString(),instance.GetType(),"Started ("+instance+")"));
}
catch
{
throw;
}
}
