public static void HasStateTypeOf <T>(ProcessId pid, string message = null) { if (!ActorContext.GetDispatcher(pid).HasStateTypeOf <T>()) { failwith <Unit>(message == null ? $"Process ({pid}) doesn't have the expected state-type of {typeof(T).FullName} " : message); } }
public static void CanAccept <T>(ProcessId pid, string message = null) { if (!ActorContext.GetDispatcher(pid).CanAccept <T>()) { failwith <Unit>(message == null ? $"Process ({pid}) can't accept messages of type {typeof(T).FullName} " : message); } }
/// <summary> /// Spawns a new process with Count worker processes, each message is mapped /// and sent to the least busy worker /// </summary> /// <typeparam name="S">State type</typeparam> /// <typeparam name="T">Message type</typeparam> /// <param name="Name">Delegator process name</param> /// <param name="Count">Number of worker processes</param> /// <param name="Inbox">Worker message handler</param> /// <param name="Flags">Process flags</param> /// <param name="Strategy">Failure supervision strategy</param> /// <returns>Process ID of the delegator process</returns> public static ProcessId leastBusyMap <S, T, U>( ProcessName Name, int Count, Func <S> Setup, Func <S, U, S> Inbox, Func <T, U> Map, ProcessFlags Flags = ProcessFlags.Default, State <StrategyContext, Unit> Strategy = null, int MaxMailboxSize = ProcessSetting.DefaultMailboxSize, string WorkerName = "worker" ) { if (Inbox == null) { throw new ArgumentNullException(nameof(Inbox)); } if (Setup == null) { throw new ArgumentNullException(nameof(Setup)); } if (Count < 1) { throw new ArgumentException($"{nameof(Count)} should be greater than 0"); } return(spawn <Unit, T>( Name, () => { spawnMany(Count, WorkerName, Setup, Inbox, Flags); return unit; }, (_, msg) => { var umsg = Map(msg); var disps = (from child in Children.Map(c => Tuple(c, ActorContext.GetDispatcher(c))).Values let count = child.Item2.GetInboxCount() where count >= 0 orderby count select child) .ToList(); if (disps.Count == 0) { throw new NoRouterWorkersException(); } else { fwd(disps.First().Item1, umsg); } return unit; }, Flags, Strategy, MaxMailboxSize )); }
public static void HasStateTypeOf <T>(ProcessId pid, string message = null) { var res = ActorContext.GetDispatcher(pid).HasStateTypeOf <T>(); res.IfLeft(err => { failwith <Unit>($"{err} for {pid}"); }); }
/// <summary> /// Spawns a new process with that routes each message is mapped and /// sent to the least busy worker /// </summary> /// <typeparam name="S">State type</typeparam> /// <typeparam name="T">Message type</typeparam> /// <param name="Name">Delegator process name</param> /// <param name="Count">Number of worker processes</param> /// <param name="Inbox">Worker message handler</param> /// <param name="Flags">Process flags</param> /// <param name="Strategy">Failure supervision strategy</param> /// <returns>Process ID of the delegator process</returns> public static ProcessId leastBusyMap <T, U>( ProcessName Name, IEnumerable <ProcessId> Workers, Func <T, U> Map, RouterOption Options = RouterOption.Default, ProcessFlags Flags = ProcessFlags.Default, int MaxMailboxSize = ProcessSetting.DefaultMailboxSize ) { if (Workers == null) { throw new ArgumentNullException(nameof(Workers)); } var workers = Set.createRange(Workers); if (workers.Count < 1) { throw new ArgumentException($"{nameof(Workers)} should have a length of at least 1"); } var router = spawn <T>( Name, msg => { var umsg = Map(msg); var disps = (from child in workers.Map(c => Tuple(c, ActorContext.GetDispatcher(c))) let count = child.Item2.GetInboxCount() where count >= 0 orderby count select child) .ToList(); if (disps.Count == 0) { throw new NoRouterWorkersException(); } else { fwd(disps.First().Item1, msg); } }, Flags, DefaultStrategy, MaxMailboxSize, Terminated: pid => workers = workers.Remove(pid) ); return(WatchWorkers(router, workers, Options)); }
public Unit DispatchUnWatch(ProcessId pid) { ActorContext.GetDispatcher(pid).UnWatch(Id); return(ActorContext.RemoveWatcher(pid, Id)); }
public Unit DispatchWatch(ProcessId pid) { ActorContext.GetDispatcher(pid).Watch(Id); return(ActorContext.AddWatcher(pid, Id)); }
private IEnumerable <IActorDispatch> GetWorkers() => group.Map(pid => ActorContext.GetDispatcher(pid));
/// <summary> /// Find the number of items in the Process inbox /// </summary> /// <param name="pid">Process</param> /// <returns>Number of items in the Process inbox</returns> public static int inboxCount(ProcessId pid) => ActorContext.GetDispatcher(pid).GetInboxCount();
/// <summary> /// Stop watching for the death of the watching process /// </summary> /// <param name="watcher">Watcher</param> /// <param name="watching">Watched</param> public static Unit unwatch(ProcessId watcher, ProcessId watching) => ActorContext.GetDispatcher(watcher).DispatchUnWatch(watching);
/// <summary> /// Find out if a process exists /// /// Rules: /// * Local processes - the process must actually be alive and in-memory /// * Remote processes - the process must have an inbox to receive messages /// and may be active, but it's not required. /// * Dispatchers/roles - at least one process in the collection must exist(pid) /// * JS processes - not current supported /// </summary> /// <param name="pid">Process ID to check</param> /// <returns>True if exists</returns> public static bool exists(ProcessId pid) => ActorContext.GetDispatcher(pid).Exists;