InboxDirective StatefulUserInbox(Actor <S, T> actor, IActorInbox inbox, UserControlMessage msg, ActorItem parent) { if (IsPaused) { userQueue = userQueue.Enqueue(msg); } else { while (userQueue.Count > 0) { // Don't process messages if we've been paused if (IsPaused) { return(InboxDirective.Pause); } var qmsg = userQueue.Peek(); userQueue = userQueue.Dequeue(); ProcessInboxDirective(ActorInboxCommon.UserMessageInbox(actor, inbox, qmsg, parent), qmsg); } if (IsPaused) { // Don't process the message if we've been paused userQueue = userQueue.Enqueue(msg); return(InboxDirective.Pause); } return(ProcessInboxDirective(ActorInboxCommon.UserMessageInbox(actor, inbox, msg, parent), msg)); } return(InboxDirective.Default); }
public ActorSystemBootstrap(IActorSystem system, Option <ICluster> cluster, ProcessId rootId, IActor rootProcess, IActorInbox rootInbox, ProcessName rootProcessName, ActorSystemConfig config, ProcessSystemConfig settings, SessionSync sync) { System = system; Sync = sync; var parent = new ActorItem(new NullProcess(system.Name), new NullInbox(), ProcessFlags.Default); rootProcess = new Actor <ActorSystemBootstrap, Unit>( cluster, parent, rootProcessName, SystemInbox, _ => this, null, Process.DefaultStrategy, ProcessFlags.Default, settings, system ); root = new ActorItem(rootProcess, rootInbox, rootProcess.Flags); Config = config; Settings = settings; Cluster = cluster; RootProcess = rootProcess; RootInbox = rootInbox; RootProcessName = rootProcessName; }
public static InboxDirective UserMessageInbox <S, T>(Actor <S, T> actor, IActorInbox inbox, UserControlMessage msg, ActorItem parent) { switch (msg.Tag) { case Message.TagSpec.UserAsk: var rmsg = (ActorRequest)msg; return(ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, rmsg.ReplyTo, rmsg, msg, msg.SessionId, () => actor.ProcessAsk(rmsg))); case Message.TagSpec.UserReply: var urmsg = (ActorResponse)msg; ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, urmsg.ReplyFrom, null, msg, msg.SessionId, () => actor.ProcessResponse(urmsg)); break; case Message.TagSpec.UserTerminated: var utmsg = (TerminatedMessage)msg; return(ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, utmsg.Id, null, msg, msg.SessionId, () => actor.ProcessTerminated(utmsg.Id))); case Message.TagSpec.User: var umsg = (UserMessage)msg; return(ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, umsg.Sender, null, msg, msg.SessionId, () => actor.ProcessMessage(umsg.Content))); case Message.TagSpec.ShutdownProcess: kill(actor.Id); break; } return(InboxDirective.Default); }
InboxDirective StatefulUserInbox(Actor <S, T> actor, IActorInbox inbox, UserControlMessage msg, ActorItem parent) { if (IsPaused) { userQueue = userQueue.Enqueue(msg); } else { while (userQueue.Count > 0) { var qmsg = userQueue.Peek(); userQueue = userQueue.Dequeue(); ActorInboxCommon.UserMessageInbox(actor, inbox, qmsg, parent); } var directive = ActorInboxCommon.UserMessageInbox(actor, inbox, msg, parent); if (directive == InboxDirective.PushToFrontOfQueue) { var newQueue = Que <UserControlMessage> .Empty; while (userQueue.Count > 0) { newQueue = newQueue.Enqueue(userQueue.Peek()); userQueue.Dequeue(); } userQueue = newQueue; } } return(InboxDirective.Default); }
public ActorItem( IActor actor, IActorInbox inbox, ProcessFlags flags ) { Actor = actor; Inbox = inbox; Flags = flags; }
private static void ShutdownProcessRec(ActorItem item, IActorInbox inboxShutdown) { var process = item.Actor; var inbox = item.Inbox; foreach (var child in process.Children.Values) { ShutdownProcessRec(child, inboxShutdown); } ((ILocalActorInbox)inboxShutdown).Tell(inbox, ProcessId.NoSender); process.Shutdown(); }
public static ProcessId ActorCreate <S, T>( ActorItem parent, ProcessName name, Func <S, T, S> actorFn, Func <IActor, S> setupFn, Func <S, ProcessId, S> termFn, State <StrategyContext, Unit> strategy, ProcessFlags flags, int maxMailboxSize, bool lazy) { var actor = new Actor <S, T>(cluster, parent, name, actorFn, setupFn, termFn, strategy, flags); IActorInbox inbox = null; if ((flags & ProcessFlags.ListenRemoteAndLocal) == ProcessFlags.ListenRemoteAndLocal && cluster.IsSome) { inbox = new ActorInboxDual <S, T>(); } else if ((flags & ProcessFlags.PersistInbox) == ProcessFlags.PersistInbox && cluster.IsSome) { inbox = new ActorInboxRemote <S, T>(); } else { inbox = new ActorInboxLocal <S, T>(); } var item = new ActorItem(actor, inbox, flags); parent.Actor.LinkChild(item); try { inbox.Startup(actor, parent, cluster, maxMailboxSize); if (!lazy) { TellSystem(actor.Id, SystemMessage.StartupProcess); } } catch { item?.Actor?.ShutdownProcess(false); throw; } return(item.Actor.Id); }
public ActorItem ActorCreate <S, T>(ActorItem parent, ProcessName name, Func <S, T, S> actorFn, Func <S> setupFn, Func <S, ProcessId, S> termFn, ProcessFlags flags, int maxMailboxSize = -1) { if (ProcessDoesNotExist(nameof(ActorCreate), parent.Actor.Id)) { return(null); } var actor = new Actor <S, T>(Cluster, parent, name, actorFn, _ => setupFn(), termFn, Process.DefaultStrategy, flags, Settings, System); IActorInbox inbox = null; if ((actor.Flags & ProcessFlags.ListenRemoteAndLocal) == ProcessFlags.ListenRemoteAndLocal && Cluster.IsSome) { inbox = new ActorInboxDual <S, T>(); } else if ((actor.Flags & ProcessFlags.PersistInbox) == ProcessFlags.PersistInbox && Cluster.IsSome) { inbox = new ActorInboxRemote <S, T>(); } else { inbox = new ActorInboxLocal <S, T>(); } var item = new ActorItem(actor, inbox, actor.Flags); try { parent.Actor.LinkChild(item); inbox.Startup(actor, actor.Parent, Cluster, maxMailboxSize == -1 ? Settings.GetProcessMailboxSize(actor.Id) : maxMailboxSize ); } catch (Exception e) { item.Actor.ShutdownProcess(false); logSysErr(new ProcessException($"Process failed starting up: {e.Message}", actor.Id.Path, actor.Parent.Actor.Id.Path, e)); } return(item); }
public ActorItem ActorCreate <S, T>(ActorItem parent, ProcessName name, Func <S, T, S> actorFn, Func <S> setupFn, ProcessFlags flags) { if (ProcessDoesNotExist(nameof(ActorCreate), parent.Actor.Id)) { return(null); } var actor = new Actor <S, T>(Cluster, parent, name, actorFn, setupFn, flags); IActorInbox inbox = null; if ((flags & ProcessFlags.ListenRemoteAndLocal) == ProcessFlags.ListenRemoteAndLocal && Cluster.IsSome) { inbox = new ActorInboxDual <S, T>(); } else if ((flags & ProcessFlags.PersistInbox) == ProcessFlags.PersistInbox && Cluster.IsSome) { inbox = new ActorInboxRemote <S, T>(); } else { inbox = new ActorInboxLocal <S, T>(); } var item = new ActorItem(actor, inbox, flags); try { parent.Actor.LinkChild(item); actor.Startup(); inbox.Startup(actor, actor.Parent, Cluster, 0); } catch (Exception e) { ShutdownProcess(item.Actor.Id); logSysErr(new ProcessException("Process failed starting up: " + e.Message, actor.Id.Path, actor.Parent.Actor.Id.Path, e)); } return(item); }
public ActorSystemState(Option <ICluster> cluster, ProcessId rootId, IActor rootProcess, IActorInbox rootInbox, ProcessName rootProcessName, ActorSystemConfig config) { var parent = new ActorItem(new NullProcess(), new NullInbox(), ProcessFlags.Default); rootProcess = new Actor <ActorSystemState, Unit>( cluster, parent, rootProcessName, ActorSystem.Inbox, _ => this, null, Process.DefaultStrategy, ProcessFlags.Default ); root = new ActorItem(rootProcess, RootInbox, rootProcess.Flags); Config = config; Cluster = cluster; RootProcess = rootProcess; RootInbox = rootInbox; RootProcessName = rootProcessName; }
public static void SystemMessageInbox <S, T>(Actor <S, T> actor, IActorInbox inbox, SystemMessage msg, ActorItem parent) { ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, ProcessId.NoSender, null, msg, () => { switch (msg.Tag) { case Message.TagSpec.Restart: actor.Restart(); break; case Message.TagSpec.LinkChild: var lc = msg as SystemLinkChildMessage; actor.LinkChild(lc.Child); break; case Message.TagSpec.UnlinkChild: var ulc = msg as SystemUnLinkChildMessage; actor.UnlinkChild(ulc.Child); break; } }); }
public ActorSystemState(Option <ICluster> cluster, ProcessId rootId, IActor rootProcess, IActorInbox rootInbox, ProcessName rootProcessName, ActorConfig config) { var parent = new ActorItem(new NullProcess(), new NullInbox(), ProcessFlags.Default); rootProcess = new Actor <ActorSystemState, Unit>( cluster, parent, rootProcessName, ActorSystem.Inbox, () => this, ProcessFlags.Default ); root = new ActorItem(rootProcess, RootInbox, rootProcess.Flags); Config = config; Cluster = cluster; RootProcess = rootProcess; RootInbox = rootInbox; RootProcessName = rootProcessName; RootProcess.Id.Child(Config.RegisteredProcessName); }
public static ProcessId ActorCreate <S, T>(ActorItem parent, ProcessName name, Func <S, T, S> actorFn, Func <S> setupFn, ProcessFlags flags) { var actor = new Actor <S, T>(cluster, parent, name, actorFn, setupFn, flags); IActorInbox inbox = null; if ((flags & ProcessFlags.ListenRemoteAndLocal) == ProcessFlags.ListenRemoteAndLocal && cluster.IsSome) { inbox = new ActorInboxDual <S, T>(); } else if ((flags & ProcessFlags.PersistInbox) == ProcessFlags.PersistInbox && cluster.IsSome) { inbox = new ActorInboxRemote <S, T>(); } else { inbox = new ActorInboxLocal <S, T>(); } var item = new ActorItem(actor, inbox, flags); parent.Actor.LinkChild(item); try { if (!started) { actor.Startup(); } inbox.Startup(actor, parent, cluster, 0); } catch { ShutdownProcess(item); throw; } return(item.Actor.Id); }
public static void UserMessageInbox <S, T>(Actor <S, T> actor, IActorInbox inbox, UserControlMessage msg, ActorItem parent) { switch (msg.Tag) { case Message.TagSpec.UserAsk: var rmsg = (ActorRequest)msg; ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, rmsg.ReplyTo, rmsg, msg, () => actor.ProcessAsk(rmsg)); break; case Message.TagSpec.UserReply: var urmsg = (ActorResponse)msg; ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, urmsg.ReplyFrom, null, msg, () => actor.ProcessResponse(urmsg)); break; case Message.TagSpec.User: var umsg = (UserMessage)msg; ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, umsg.Sender, null, msg, () => actor.ProcessMessage(umsg.Content)); break; case Message.TagSpec.ShutdownProcess: kill(actor.Id); break; } }
public static InboxDirective SystemMessageInbox <S, T>(Actor <S, T> actor, IActorInbox inbox, SystemMessage msg, ActorItem parent) { return(ActorContext.WithContext(new ActorItem(actor, inbox, actor.Flags), parent, ProcessId.NoSender, null, msg, msg.SessionId, () => { switch (msg.Tag) { case Message.TagSpec.Restart: if (inbox.IsPaused) { inbox.Unpause(); } actor.Restart(); break; case Message.TagSpec.LinkChild: var lc = msg as SystemLinkChildMessage; actor.LinkChild(lc.Child); break; case Message.TagSpec.UnlinkChild: var ulc = msg as SystemUnLinkChildMessage; actor.UnlinkChild(ulc.Child); break; case Message.TagSpec.ChildFaulted: var cf = msg as SystemChildFaultedMessage; return actor.ChildFaulted(cf.Child, cf.Sender, cf.Exception, cf.Message); case Message.TagSpec.StartupProcess: actor.Startup(); break; case Message.TagSpec.ShutdownProcess: var sp = msg as ShutdownProcessMessage; actor.ShutdownProcess(sp.MaintainState); break; case Message.TagSpec.Unpause: inbox.Unpause(); break; case Message.TagSpec.Pause: inbox.Pause(); break; case Message.TagSpec.Watch: var awm = msg as SystemAddWatcherMessage; actor.AddWatcher(awm.Id); break; case Message.TagSpec.UnWatch: var rwm = msg as SystemRemoveWatcherMessage; actor.RemoveWatcher(rwm.Id); break; case Message.TagSpec.DispatchWatch: var dwm = msg as SystemDispatchWatchMessage; actor.DispatchWatch(dwm.Id); break; case Message.TagSpec.DispatchUnWatch: var duwm = msg as SystemDispatchUnWatchMessage; actor.DispatchUnWatch(duwm.Id); break; } return InboxDirective.Default; })); }
public static InboxDirective SystemMessageInbox <S, T>(Actor <S, T> actor, IActorInbox inbox, SystemMessage msg, ActorItem parent) { var session = msg.SessionId == null ? None : Some(new SessionId(msg.SessionId)); return(ActorContext.System(actor.Id).WithContext(new ActorItem(actor, inbox, actor.Flags), parent, ProcessId.NoSender, null, msg, session, () => { switch (msg.Tag) { case Message.TagSpec.Restart: actor.Restart(inbox.IsPaused); break; case Message.TagSpec.LinkChild: var lc = msg as SystemLinkChildMessage; actor.LinkChild(lc.Child); break; case Message.TagSpec.UnlinkChild: var ulc = (msg as SystemUnLinkChildMessage).SetSystem(actor.Id.System); actor.UnlinkChild(ulc.Child); break; case Message.TagSpec.ChildFaulted: var cf = (msg as SystemChildFaultedMessage).SetSystem(actor.Id.System); return actor.ChildFaulted(cf.Child, cf.Sender, cf.Exception, cf.Message); case Message.TagSpec.StartupProcess: var startupProcess = msg as StartupProcessMessage; var inboxDirective = actor.Startup(); // get feedback whether startup will somehow trigger Unpause itself (i.e. error => strategy => restart) if (startupProcess.UnpauseAfterStartup && !inboxDirective.HasFlag(InboxDirective.Pause)) { inbox.Unpause(); } break; case Message.TagSpec.ShutdownProcess: var shutdownProcess = msg as ShutdownProcessMessage; actor.ShutdownProcess(shutdownProcess.MaintainState); break; case Message.TagSpec.Unpause: inbox.Unpause(); break; case Message.TagSpec.Pause: inbox.Pause(); break; // do not return InboxDirective.Pause because system queue should never pause case Message.TagSpec.Watch: var awm = msg as SystemAddWatcherMessage; actor.AddWatcher(awm.Id); break; case Message.TagSpec.UnWatch: var rwm = msg as SystemRemoveWatcherMessage; actor.RemoveWatcher(rwm.Id); break; case Message.TagSpec.DispatchWatch: var dwm = msg as SystemDispatchWatchMessage; actor.DispatchWatch(dwm.Id); break; case Message.TagSpec.DispatchUnWatch: var duwm = msg as SystemDispatchUnWatchMessage; actor.DispatchUnWatch(duwm.Id); break; } return InboxDirective.Default; })); }
internal static ActorSystemMessage AddToStore(IActor process, IActorInbox inbox, ProcessFlags flags) => new AddToStoreMessage(process, inbox, flags);
public ProcessId ActorCreate <S, T>( ActorItem parent, ProcessName name, Func <S, T, S> actorFn, Func <IActor, S> setupFn, Func <S, ProcessId, S> termFn, State <StrategyContext, Unit> strategy, ProcessFlags flags, int maxMailboxSize, bool lazy) { var actor = new Actor <S, T>(cluster, parent, name, actorFn, setupFn, termFn, strategy, flags, ActorContext.System(parent.Actor.Id).Settings, this); IActorInbox inbox = null; if ((actor.Flags & ProcessFlags.ListenRemoteAndLocal) == ProcessFlags.ListenRemoteAndLocal && cluster.IsSome) { inbox = new ActorInboxDual <S, T>(); } else if ((actor.Flags & ProcessFlags.PersistInbox) == ProcessFlags.PersistInbox && cluster.IsSome) { inbox = new ActorInboxRemote <S, T>(); } else { inbox = new ActorInboxLocal <S, T>(); } var item = new ActorItem(actor, inbox, actor.Flags); parent.Actor.LinkChild(item); // Auto register if there are config settings and we // have the variable name it was assigned to. ActorContext.System(actor.Id).Settings.GetProcessRegisteredName(actor.Id).Iter(regName => { // Also check if 'dispatch' is specified in the config, if so we will // register the Process as a role dispatcher PID instead of just its // PID. ActorContext.System(actor.Id).Settings.GetProcessDispatch(actor.Id) .Match( Some: disp => Process.register(regName, Disp[$"role-{disp}"][Role.Current].Append(actor.Id.Skip(1))), None: () => Process.register(regName, actor.Id) ); }); try { inbox.Startup(actor, parent, cluster, maxMailboxSize); if (!lazy) { TellSystem(actor.Id, SystemMessage.StartupProcess); } } catch { item?.Actor?.ShutdownProcess(false); throw; } return(item.Actor.Id); }
public static ActorSystemMessage AddToStore(IProcess process, IActorInbox inbox, ProcessFlags flags) => new AddToStoreMessage(process, inbox, flags);
public AddToStoreMessage(IProcess process, IActorInbox inbox, ProcessFlags flags) { Process = process; Inbox = inbox; Flags = flags; }