public void Schedule(ActorRef actor, TimeSpan timeout) { var name = Name; var message = Message; Action send; if (_debugLog != null) { send = () => { _debugLog.Debug("{3}Timer '{0}' went off. Sending {1} -> {2}", name, message, actor, _ref.IsCancellationRequested ? "Cancelled " : ""); actor.Tell(this, Context.Self); } } ; else { send = () => actor.Tell(this, Context.Self); } if (Repeat) { _scheduler.Schedule(timeout, timeout, send, _ref.Token); } else { _scheduler.ScheduleOnce(timeout, send, _ref.Token); } }
/// <summary> /// Delivers the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="sender">The sender.</param> /// <param name="pathIndex">Index of the path.</param> /// <param name="current">The current.</param> private void Deliver(object message, ActorRef sender, int pathIndex, ActorRef current) { if (pathIndex == Elements.Length) { current.Tell(message, sender); } else { SelectionPathElement element = Elements[pathIndex]; if (current is ActorRefWithCell) { var withCell = (ActorRefWithCell)current; if (element is SelectParent) { Deliver(message, sender, pathIndex + 1, withCell.Parent); } else if (element is SelectChildName) { Deliver(message, sender, pathIndex + 1, withCell.GetSingleChild(element.AsInstanceOf <SelectChildName>().Name)); } } else { SelectionPathElement[] rest = Elements.Skip(pathIndex).ToArray(); current.Tell(new ActorSelectionMessage(message, rest), sender); } } }
public ClientReceiveActor(ActorRef actor, long repeat, TaskCompletionSource<bool> latch) { var received=0L; var sent=0L; Receive<Messages.Msg>(m => { received++; if(sent < repeat) { actor.Tell(m); sent++; } else if(received >= repeat) { latch.SetResult(true); } }); Receive<Messages.Run>(r => { var msg = new Messages.Msg(); for(int i = 0; i < Math.Min(1000, repeat); i++) { actor.Tell(msg); sent++; } }); Receive<Messages.Started>(s => Sender.Tell(s)); }
public PersistentViewSpec() : base(Configuration("inmem", "PersistentViewSpec")) { _prefProbe = CreateTestProbe(); _viewProbe = CreateTestProbe(); _pref = ActorOf(() => new TestPersistentActor(Name, _prefProbe.Ref)); _pref.Tell("a"); _pref.Tell("b"); _prefProbe.ExpectMsg("a-1"); _prefProbe.ExpectMsg("b-2"); }
public Dispatcher(ActorRef journalWriter, ActorRef executor) { _executor = executor; _journalWriter = journalWriter; Receive<Command>(command => _journalWriter.Tell(new RequestContext(command, Sender))); Receive<Query>(query => _executor.Tell(new RequestContext(query, Sender))); }
protected override void PreStart() { //Fire up a TestRunCoordinator instance and subscribe to FactData messages when they arrive if (UseTestCoordinator) { TestCoordinatorActorRef = Context.ActorOf<TestRunCoordinator>(); TestCoordinatorActorRef.Tell(new TestRunCoordinator.SubscribeFactCompletionMessages(Self)); } }
public void PersistentView_should_run_updates_on_user_request() { _view = ActorOf(() => new TestPersistentView(Name, _viewProbe.Ref, TimeSpan.FromSeconds(5), null)); _viewProbe.ExpectMsg("replicated-a-1"); _viewProbe.ExpectMsg("replicated-b-2"); _pref.Tell("c"); _prefProbe.ExpectMsg("c-3"); _view.Tell(new Update(isAwait: false)); _viewProbe.ExpectMsg("replicated-c-3"); }
protected virtual bool SpecialHandle(object message, ActorRef sender) { var w = message as Watch; if (w != null) { if (w.Watchee == this && w.Watcher != this) { w.Watcher.Tell(new DeathWatchNotification(w.Watchee, existenceConfirmed: false, addressTerminated: false)); } return(true); } if (message is Unwatch) { return(true); //Just ignore } var identify = message as Identify; if (identify != null) { sender.Tell(new ActorIdentity(identify.MessageId, null)); return(true); } var sel = message as ActorSelectionMessage; if (sel != null) { var selectionIdentify = sel.Message as Identify; if (selectionIdentify != null) { if (!sel.WildCardFanOut) { sender.Tell(new ActorIdentity(selectionIdentify.MessageId, null)); } } else { _eventStream.Publish(new DeadLetter(sel.Message, sender.IsNobody() ? _provider.DeadLetters : sender, this)); } return(true); } return(false); }
public AkkaJournaler(ActorRef executor, int batchSize, IJournalWriter journalWriter) { _journalWriter = journalWriter; BatchSize = batchSize; _executor = executor; Receive<RequestContext>(t => Accept(t)); Receive<ReceiveTimeout>(_ => Go()); Receive<JournalAcknowledgement>(_ => _executor.Tell(_waitingForJournalAck.Dequeue())); SetReceiveTimeout(Interval); }
public override void Post(Envelope envelope) { var message = envelope.Message; if (message is SystemMessage) { Mailbox.DebugPrint("DeadLetterMailbox forwarded system message " + envelope + " as a DeadLetter"); _deadLetters.Tell(new DeadLetter(message, _deadLetters, _deadLetters), _deadLetters);//TODO: When we have refactored Post to SystemEnqueue(ActorRef receiver, Envelope envelope), replace _deadLetters with receiver } else if (message is DeadLetter) { //Just drop it like it's hot Mailbox.DebugPrint("DeadLetterMailbox dropped DeadLetter " + envelope); } else { Mailbox.DebugPrint("DeadLetterMailbox forwarded message " + envelope + " as a DeadLetter"); var sender = envelope.Sender; _deadLetters.Tell(new DeadLetter(message, sender, _deadLetters), sender);//TODO: When we have refactored Post to Enqueue(ActorRef receiver, Envelope envelope), replace _deadLetters with receiver } }
protected override void TellInternal(object message, ActorRef sender) { unregister(); if (sender != NoSender) { sender.Tell(new CompleteFuture(() => result.TrySetResult(message))); } else { result.TrySetResult(message); } }
public override void Post(ActorRef receiver, Envelope envelope) { var message = envelope.Message; if (message is SystemMessage) { Mailbox.DebugPrint("DeadLetterMailbox forwarded system message " + envelope + " as a DeadLetter"); _deadLetters.Tell(new DeadLetter(message, receiver, receiver), receiver); } else if (message is DeadLetter) { //Just drop it like it's hot Mailbox.DebugPrint("DeadLetterMailbox dropped DeadLetter " + envelope); } else { Mailbox.DebugPrint("DeadLetterMailbox forwarded message " + envelope + " as a DeadLetter"); var sender = envelope.Sender; _deadLetters.Tell(new DeadLetter(message, sender, receiver), sender); } }
public ClusterDomainEventPublisherSpec() { _memberSubscriber = CreateTestProbe(); Sys.EventStream.Subscribe(_memberSubscriber.Ref, typeof(ClusterEvent.IMemberEvent)); Sys.EventStream.Subscribe(_memberSubscriber.Ref, typeof(ClusterEvent.LeaderChanged)); _publisher = Sys.ActorOf(Props.Create<ClusterDomainEventPublisher>()); //TODO: If parent told of exception then test should fail (if not expected in some way)? _publisher.Tell(new InternalClusterAction.PublishChanges(g0)); _memberSubscriber.ExpectMsg(new ClusterEvent.MemberUp(aUp)); _memberSubscriber.ExpectMsg(new ClusterEvent.LeaderChanged(aUp.Address)); }
/// <summary> /// Delivers the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="sender">The sender.</param> /// <param name="pathIndex">Index of the path.</param> /// <param name="current">The current.</param> private void Deliver(object message, ActorRef sender, int pathIndex, ActorRef current) { if (pathIndex == Elements.Length) { current.Tell(message, sender); } else { var element = Elements[pathIndex]; if (current is ActorRefWithCell) { var withCell = (ActorRefWithCell)current; if (element is SelectParent) { Deliver(message, sender, pathIndex + 1, withCell.Parent); } else if (element is SelectChildName) { Deliver(message, sender, pathIndex + 1, withCell.GetSingleChild(element.AsInstanceOf <SelectChildName>().Name)); } else if (element is SelectChildPattern) { var pattern = element as SelectChildPattern; var children = withCell.Children.Where(c => c.Path.Name.Like(pattern.PatternStr)); foreach (ActorRef matchingChild in children) { Deliver(message, sender, pathIndex + 1, matchingChild); } } } else { var rest = Elements.Skip(pathIndex).ToArray(); current.Tell(new ActorSelectionMessage(message, rest), sender); } } }
protected override void Print(LogEvent m) { if(m.Message is ForwardAllEventsTo) { _forwarder = ((ForwardAllEventsTo)m.Message).Forwarder; _forwarder.Tell("OK"); } else if(_forwarder != null) { _forwarder.Forward(m); } else { base.Print(m); } }
public static Task <bool> GracefulStop(this ActorRef target, TimeSpan timeout, object stopMessage) { var internalTarget = target.AsInstanceOf <InternalActorRef>(); if (internalTarget.IsTerminated) { return(Task.Run(() => true)); } var provider = Futures.ResolveProvider(target); var promise = new TaskCompletionSource <object>(); //set up the timeout var cancellationSource = new CancellationTokenSource(); cancellationSource.Token.Register(() => promise.TrySetCanceled()); cancellationSource.CancelAfter(timeout); //create a new tempcontainer path var path = provider.TempPath(); //callback to unregister from tempcontainer Action unregister = () => provider.UnregisterTempActor(path); var fref = new FutureActorRef(promise, ActorRef.NoSender, unregister, path); internalTarget.Tell(new Watch(internalTarget, fref)); target.Tell(stopMessage, ActorRef.NoSender); return(promise.Task.ContinueWith(t => { var returnResult = false; PatternMatch.Match(t.Result) .With <Terminated>(terminated => { returnResult = (terminated.ActorRef.Path.Equals(target.Path)); }) .Default(m => { returnResult = false; }); internalTarget.Tell(new Unwatch(target, fref)); return returnResult; }, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.AttachedToParent)); }
/// <summary> /// Tells the internal. /// </summary> /// <param name="message">The message.</param> /// <param name="sender">The sender.</param> protected override void TellInternal(object message, ActorRef sender) { message .Match() .With <Identify>(m => sender.Tell(new ActorIdentity(m.MessageId, this))) .With <DeadLetter>(m => { if (!SpecialHandle(m.Message, m.Sender)) { eventStream.Publish(m); } }) .Default(m => { if (!SpecialHandle(message, sender)) { eventStream.Publish(new DeadLetter(message, sender == NoSender ? provider.DeadLetters : sender, this)); } }); }
protected override void TellInternal(object message, ActorRef sender) { if (message is SystemMessage) //we have special handling for system messages { SendSystemMessage(message.AsInstanceOf <SystemMessage>(), sender); } else { if (Interlocked.Exchange(ref status, COMPLETED) == INITIATED) { _unregister(); if (_sender == NoSender || message is Terminated) { _result.TrySetResult(message); } else { _sender.Tell(new CompleteFuture(() => _result.TrySetResult(message))); } } } }
protected override bool ReceiveMessage(object message) { var strMessage = message as string; switch(strMessage) { case "complexRequest": _replyTo = Sender; var worker = TestActorRef.Create<WorkerActor>(System); worker.Tell("work"); return true; case "complexRequest2": var worker2 = TestActorRef.Create<WorkerActor>(System); worker2.Tell(Sender, Self); return true; case "workDone": _replyTo.Tell("complexReply", Self); return true; case "simpleRequest": Sender.Tell("simpleReply", Self); return true; } return false; }
protected virtual bool SpecialHandle(object message, ActorRef sender) { var w = message as Watch; if(w != null) { if(w.Watchee == this && w.Watcher != this) { w.Watcher.Tell(new DeathWatchNotification(w.Watchee, existenceConfirmed: false, addressTerminated: false)); } return true; } if(message is Unwatch) return true; //Just ignore var identify = message as Identify; if(identify != null) { sender.Tell(new ActorIdentity(identify.MessageId, null)); return true; } var sel = message as ActorSelectionMessage; if(sel != null) { var selectionIdentify = sel.Message as Identify; if(selectionIdentify != null) { if(!sel.WildCardFanOut) sender.Tell(new ActorIdentity(selectionIdentify.MessageId, null)); } else { _eventStream.Publish(new DeadLetter(sel.Message, sender.IsNobody() ? _provider.DeadLetters : sender, this)); } return true; } return false; }
/// <summary> /// Tells the internal. /// </summary> /// <param name="message">The message.</param> /// <param name="sender">The sender.</param> protected override void TellInternal(object message, ActorRef sender) { message .Match() .With<Identify>(m => sender.Tell(new ActorIdentity(m.MessageId, this))) .With<DeadLetter>(m => { if (!SpecialHandle(m.Message, m.Sender)) eventStream.Publish(m); }) .Default(m => { if (!SpecialHandle(message, sender)) eventStream.Publish(new DeadLetter(message, sender == NoSender ? provider.DeadLetters : sender, this)); }); }
public ChaosApp(ActorRef probe) { _probe = probe; _destination = Context.ActorOf(Props.Create(() => new ChaosDestination(_probe)), "destination"); _sender = Context.ActorOf(Props.Create(() => new ChaosSender(_destination, _probe)), "sender"); Receive<Start>(_ => { for (int i = 1; i < GuaranteedDeliveryFailureSpec.NumberOfMessages; i++) { _sender.Tell(i); } }); Receive<ProcessingFailure>(x => _sender.Tell(x.I)); Receive<JournalingFailure>(x => _sender.Tell(x.I)); }
public override void Start() { log.Info("Starting remoting"); if (_endpointManager == null) { _endpointManager = System.SystemActorOf( Props.Create(() => new EndpointManager(System.Settings.Config, log)).WithDeploy(Deploy.Local), EndpointManagerName); try { var addressPromise = new TaskCompletionSource<IList<ProtocolTransportAddressPair>>(); _endpointManager.Tell(new EndpointManager.Listen(addressPromise)); addressPromise.Task.Wait(Provider.RemoteSettings.StartupTimeout); var akkaProtocolTransports = addressPromise.Task.Result; if(akkaProtocolTransports.Count==0) throw new Exception("No transports enabled"); Addresses = new HashSet<Address>(akkaProtocolTransports.Select(a => a.Address)); // this.transportMapping = akkaProtocolTransports // .ToDictionary(p => p.ProtocolTransport.Transport.SchemeIdentifier,); IEnumerable<IGrouping<string, ProtocolTransportAddressPair>> tmp = akkaProtocolTransports.GroupBy(t => t.ProtocolTransport.SchemeIdentifier); _transportMapping = new Dictionary<string, HashSet<ProtocolTransportAddressPair>>(); foreach (var g in tmp) { var set = new HashSet<ProtocolTransportAddressPair>(g); _transportMapping.Add(g.Key, set); } DefaultAddress = akkaProtocolTransports.Head().Address; _addresses = new HashSet<Address>(akkaProtocolTransports.Select(x => x.Address)); log.Info("Remoting started; listening on addresses : [{0}]", string.Join(",", _addresses.Select(x => x.ToString()))); _endpointManager.Tell(new EndpointManager.StartupFinished()); _eventPublisher.NotifyListeners(new RemotingListenEvent(_addresses.ToList())); } catch (TaskCanceledException ex) { NotifyError("Startup was cancelled due to timeout", ex); throw; } catch (TimeoutException ex) { NotifyError("Startup timed out", ex); throw; } catch (Exception ex) { NotifyError("Startup failed", ex); throw; } } else { log.Warning("Remoting was already started. Ignoring start attempt."); } }
/// <summary> /// Send message to an actor while using the probe as the sender. /// Replies will be available for inspection with all of TestKit's assertion /// methods. /// </summary> /// <param name="actor">The actor.</param> /// <param name="message">The message.</param> public void Send(ActorRef actor, object message) { actor.Tell(message, TestActor); }
protected override void OnReceive(object message) { PatternMatch.Match(message) .With<InitializeLogger>(m => { var bus = m.LoggingBus; bus.Subscribe(this.Self, typeof(SetTarget)); bus.Subscribe(this.Self, typeof(UnhandledMessage)); Sender.Tell(new LoggerInitialized()); }) .With<SetTarget>(m => { dst = m.Ref; dst.Tell("OK"); }) .With<LogEvent>(m => dst.Tell(m)) .With<UnhandledMessage>(m => dst.Tell(m)); }
/// <summary> /// Delivers the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="sender">The sender.</param> /// <param name="pathIndex">Index of the path.</param> /// <param name="current">The current.</param> private void Deliver(object message, ActorRef sender, int pathIndex, ActorRef current) { if (pathIndex == Elements.Length) { current.Tell(message, sender); } else { SelectionPathElement element = Elements[pathIndex]; if (current is ActorRefWithCell) { var withCell = (ActorRefWithCell) current; if (element is SelectParent) Deliver(message, sender, pathIndex + 1, withCell.Parent); else if (element is SelectChildName) Deliver(message, sender, pathIndex + 1, withCell.GetSingleChild(element.AsInstanceOf<SelectChildName>().Name)); } else { SelectionPathElement[] rest = Elements.Skip(pathIndex).ToArray(); current.Tell(new ActorSelectionMessage(message, rest), sender); } } }
/// <summary> /// May only be called from the owner actor /// </summary> /// <param name="watchee"></param> public void Watch(ActorRef watchee) { watchees.Add(watchee); watchee.Tell(new Watch(watchee, Self), Self); }
public DumbObserver(ActorPath path2, ActorRef testActorRef) { _testActorRef = testActorRef; Receive<ActorIdentity>(identity => { Context.Watch(identity.Subject); }); Receive<Terminated>(terminated => { _testActorRef.Tell(terminated.ActorRef.Path); }); Context.ActorSelection(path2).Tell(new Identify(path2)); }
public Observer(ActorPath path2, ActorPath path3, TestLatch watchEstablished, ActorRef testActorRef) { _watchEstablished = watchEstablished; _testActorRef = testActorRef; Receive<ActorIdentity>(identity => identity.MessageId.Equals(path2), identity => { Context.Watch(identity.Subject); _watchEstablished.CountDown(); }); Receive<ActorIdentity>(identity => identity.MessageId.Equals(path3), identity => { Context.Watch(identity.Subject); _watchEstablished.CountDown(); }); Receive<Terminated>(terminated => { _testActorRef.Tell(terminated.ActorRef.Path); }); Context.ActorSelection(path2).Tell(new Identify(path2)); Context.ActorSelection(path3).Tell(new Identify(path3)); }
/// <summary> /// Forwards the last received message to the specified actor as if the /// <see cref="TestKitBase.LastMessage"/> was sent directly to the actor in the first place. /// </summary> /// <param name="actor">The actor to forward to.</param> public void Forward(ActorRef actor) { actor.Tell(LastMessage, Sender); }
public void PersistentView_should_check_if_incoming_message_is_persistent() { _pref.Tell("c"); _prefProbe.ExpectMsg("c-3"); _view = ActorOf(() => new PersistentOrNotTestPersistentView(Name, _viewProbe.Ref)); _view.Tell("d"); _view.Tell("e"); _viewProbe.ExpectMsg("replicated-a-1"); _viewProbe.ExpectMsg("replicated-b-2"); _viewProbe.ExpectMsg("replicated-c-3"); _viewProbe.ExpectMsg("normal-d-3"); _viewProbe.ExpectMsg("normal-e-3"); _pref.Tell("f"); _viewProbe.ExpectMsg("replicated-f-4"); }
public void PersistentView_should_run_size_limited_updates_on_user_request() { _pref.Tell("c"); _pref.Tell("d"); _pref.Tell("e"); _pref.Tell("f"); _prefProbe.ExpectMsg("c-3"); _prefProbe.ExpectMsg("d-4"); _prefProbe.ExpectMsg("e-5"); _prefProbe.ExpectMsg("f-6"); _view = ActorOf(() => new PassiveTestPersistentView(Name, _viewProbe.Ref, null)); _view.Tell(new Update(isAwait: true, replayMax: 2)); _view.Tell("get"); _viewProbe.ExpectMsg("replicated-b-2"); _view.Tell(new Update(isAwait: true, replayMax: 1)); _view.Tell("get"); _viewProbe.ExpectMsg("replicated-c-3"); _view.Tell(new Update(isAwait: true, replayMax: 4)); _view.Tell("get"); _viewProbe.ExpectMsg("replicated-f-6"); }
private void Subscribe(ActorRef subscriber, ClusterEvent.SubscriptionInitialStateMode initMode, IEnumerable<Type> to) { if (initMode == ClusterEvent.SubscriptionInitialStateMode.InitialStateAsEvents) { Action<object> pub = @event => { var eventType = @event.GetType(); //TODO: IsAssignableFrom same as in scala? if (to.Any(o => o.IsAssignableFrom(eventType))) subscriber.Tell(@event); }; PublishDiff(Gossip.Empty, _latestGossip, pub); } else if(initMode == ClusterEvent.SubscriptionInitialStateMode.InitialStateAsSnapshot) { SendCurrentClusterState(subscriber); } foreach (var t in to) _eventStream.Subscribe(subscriber, t); }
/// <summary> /// Schedules a message to a receiver. /// </summary> /// <param name="initialDelay">The initial delay.</param> /// <param name="interval">The interval.</param> /// <param name="receiver">The receiver.</param> /// <param name="message">The message.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>Task.</returns> public Task Schedule(TimeSpan initialDelay, TimeSpan interval, ActorRef receiver, object message, CancellationToken cancellationToken) { return(InternalSchedule(initialDelay, interval, () => receiver.Tell(message), cancellationToken)); }
protected override bool Receive(object message) { var type = message.ToString(); switch (type) { case "complexRequest": { _replyTo = Sender; var worker = Context.ActorOf(Props.Create<WorkerActor>()); worker.Tell("work"); break; } case "complexRequest2": { var worker = Context.ActorOf(Props.Create<WorkerActor>()); worker.Tell(new ReplyTo(Sender)); break; } case "workDone": _replyTo.Tell("complexReply"); break; case "simpleRequest": Sender.Tell("simpleReply"); break; } return true; }
private void DropFork(ActorRef fork) { if (this.LeftFork == fork) { //Console.WriteLine("{0} doesn't have {1} in his left hand", this.Self.Name(), fork.Name()); this.OwnsLeftFork = false; } else if(this.RightFork == fork) { //Console.WriteLine("{0} doesn't have {1} in his right hand", this.Self.Name(), fork.Name()); this.OwnsRightFork = false; } fork.Tell(new ForkDropRequest(this.Self)); }
/// <summary> /// May only be called from the owner actor /// </summary> /// <param name="watchee"></param> public void Unwatch(ActorRef watchee) { watchees.Remove(watchee); watchee.Tell(new Unwatch(watchee, Self)); }
public void Send(ActorRef actorRef, object msg) { actorRef.Tell(msg, Receiver); }
/// <summary> /// Delivers the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="sender">The sender.</param> /// <param name="pathIndex">Index of the path.</param> /// <param name="current">The current.</param> private void Deliver(object message, ActorRef sender, int pathIndex, ActorRef current) { if (pathIndex == Elements.Length) { current.Tell(message, sender); } else { SelectionPathElement element = Elements[pathIndex]; if (current is ActorRefWithCell) { var withCell = (ActorRefWithCell) current; if (element is SelectParent) Deliver(message, sender, pathIndex + 1, withCell.Parent); else if (element is SelectChildName) Deliver(message, sender, pathIndex + 1, withCell.GetSingleChild(element.AsInstanceOf<SelectChildName>().Name)); else if (element is SelectChildPattern) { var pattern = element as SelectChildPattern; var children = withCell.Children.Where(c => c.Path.Name.Like(pattern.PatternStr)); foreach(var matchingChild in children) { Deliver(message, sender, pathIndex + 1, matchingChild); } } } else { SelectionPathElement[] rest = Elements.Skip(pathIndex).ToArray(); current.Tell(new ActorSelectionMessage(message, rest), sender); } } }
public void PersistentView_should_take_snapshots() { _view = ActorOf(() => new SnapshottingPersistentView(Name, _viewProbe.Ref)); _viewProbe.ExpectMsg("replicated-a-1"); _viewProbe.ExpectMsg("replicated-b-2"); _view.Tell("snap"); _viewProbe.ExpectMsg("snapped"); _view.Tell("restart"); _pref.Tell("c"); _viewProbe.ExpectMsg("replicated-b-2"); _viewProbe.ExpectMsg("replicated-c-3"); }
/// <summary> /// Forwards a message to the specified actor. As sender the sender of the last message is used. /// </summary> /// <param name="actor">The actor to forward to.</param> /// <param name="message">The message.</param> public void Forward(ActorRef actor, object message) { actor.Tell(message, Sender); }
public void PersistentView_should_run_updates_again_on_failure_outside_an_update_cycle() { _view = ActorOf(() => new TestPersistentView(Name, _viewProbe.Ref, TimeSpan.FromSeconds(5), null)); _viewProbe.ExpectMsg("replicated-a-1"); _viewProbe.ExpectMsg("replicated-b-2"); _view.Tell("boom"); _viewProbe.ExpectMsg("replicated-a-1"); _viewProbe.ExpectMsg("replicated-b-2"); }
/// <summary> /// The current snapshot state corresponding to latest gossip /// to mimic what you would have seen if you were listening to the events. /// </summary> private void SendCurrentClusterState(ActorRef receiver) { var state = new ClusterEvent.CurrentClusterState( _latestGossip.Members, _latestGossip.Overview.Reachability.AllUnreachableOrTerminated.Select(_latestGossip.GetMember) .ToImmutableHashSet(), _latestGossip.SeenBy.Select(s => s.Address).ToImmutableHashSet(), _latestGossip.Leader == null ? null : _latestGossip.Leader.Address, _latestGossip.AllRoles.ToImmutableDictionary(r => r, r => _latestGossip.RoleLeader(r).Address) ); receiver.Tell(state); }