private void OnMessage(ClusterActorDiscoveryMessage.ActorDown m)
 {
     _consumers.Remove(m.Actor);
 }
        private void Handle(ClusterActorDiscoveryMessage.UnmonitorActor m)
        {
            _log.Debug($"UnmonitorActor: Monitor={Sender.Path} Tag={m.Tag}");

            var count = _monitorItems.RemoveAll(w => w.Actor.Equals(Sender) && w.Tag == m.Tag);
            for (var i = 0; i < count; i++)
                UnwatchActor(Sender, 1);
        }
 private void OnMessage(ClusterActorDiscoveryMessage.ActorUp m)
 {
     _consumers.Add(m.Actor);
 }
        private void Handle(ClusterActorDiscoveryMessage.UnregisterActor m)
        {
            _log.Debug($"UnregisterActor: Actor={m.Actor.Path}");

            // remove actor from _actorItems

            var index = _actorItems.FindIndex(a => a.Actor.Equals(m.Actor));
            if (index == -1)
                return;

            var tag = _actorItems[index].Tag;
            _actorItems.RemoveAt(index);
            UnwatchActor(m.Actor, 0);

            // tell monitors & other discovery actors that local actor down

            NotifyActorDownToMonitor(m.Actor, tag);
            foreach (var discoveryActor in _nodeMap.Keys)
                discoveryActor.Tell(new ClusterActorDiscoveryMessage.ClusterActorDown(m.Actor));
        }
        private void Handle(ClusterActorDiscoveryMessage.MonitorActor m)
        {
            _log.Debug($"MonitorActor: Monitor={Sender.Path} Tag={m.Tag}");

            _monitorItems.Add(new MonitorItem { Actor = Sender, Tag = m.Tag });
            WatchActor(Sender, 1);

            // Send actor up message to just registered monitor

            foreach (var actor in _actorItems.Where(a => a.Tag == m.Tag))
                Sender.Tell(new ClusterActorDiscoveryMessage.ActorUp(actor.Actor, actor.Tag));

            foreach (var node in _nodeMap.Values)
            {
                foreach (var actor in node.ActorItems.Where(a => a.Tag == m.Tag))
                    Sender.Tell(new ClusterActorDiscoveryMessage.ActorUp(actor.Actor, actor.Tag));
            }
        }
        private void Handle(ClusterActorDiscoveryMessage.RegisterActor m)
        {
            _log.Debug($"RegisterActor: Actor={m.Actor.Path} Tag={m.Tag}");

            // add actor to _actorItems

            var index = _actorItems.FindIndex(a => a.Actor.Equals(m.Actor));
            if (index != -1)
            {
                _log.Error($"Already registered actor: Actor={m.Actor.Path} Tag={m.Tag}");
                return;
            }

            _actorItems.Add(new ActorItem { Actor = m.Actor, Tag = m.Tag });
            WatchActor(m.Actor, 0);

            // tell monitors & other discovery actors that local actor up

            NotifyActorUpToMonitor(m.Actor, m.Tag);
            foreach (var discoveryActor in _nodeMap.Keys)
                discoveryActor.Tell(new ClusterActorDiscoveryMessage.ClusterActorUp(m.Actor, m.Tag));
        }
        private void Handle(ClusterActorDiscoveryMessage.ClusterActorDown m)
        {
            _log.Debug($"ClusterActorDown: Actor={m.Actor.Path}");

            NodeItem node;
            if (_nodeMap.TryGetValue(Sender, out node) == false)
            {
                _log.Error($"Cannot find node: Discovery={Sender.Path}");
                return;
            }

            // remove actor from node.ActorItems

            var index = node.ActorItems.FindIndex(a => a.Actor.Equals(m.Actor));
            if (index == -1)
            {
                _log.Error($"Cannot find actor: Discovery={Sender.Path} Actor={m.Actor.Path}");
                return;
            }

            var tag = node.ActorItems[index].Tag;
            node.ActorItems.RemoveAt(index);

            NotifyActorDownToMonitor(m.Actor, tag);
        }
        private void Handle(ClusterActorDiscoveryMessage.ClusterActorUp m)
        {
            _log.Debug($"ClusterActorUp: Actor={m.Actor.Path} Tag={m.Tag}");

            NodeItem node;
            if (_nodeMap.TryGetValue(Sender, out node) == false)
            {
                _log.Error($"Cannot find node: Discovery={Sender.Path}");
                return;
            }

            node.ActorItems.Add(new ActorItem { Actor = m.Actor, Tag = m.Tag });

            NotifyActorUpToMonitor(m.Actor, m.Tag);
        }
        private void Handle(ClusterActorDiscoveryMessage.ResyncCluster m)
        {
            _log.Info($"ResyncCluster: {m.ClusterAddress} Request={m.Request}");

            // Reregister node

            var item = _nodeMap.FirstOrDefault(i => i.Value.ClusterAddress == m.ClusterAddress);
            if (item.Key != null)
                RemoveNode(item.Key);

            _nodeMap.Add(Sender, new NodeItem
            {
                ClusterAddress = m.ClusterAddress,
                ActorItems = new List<ActorItem>()
            });

            // Process attached actorUp messages

            if (m.ActorUpList != null)
            {
                foreach (var actorUp in m.ActorUpList)
                    Handle(actorUp);
            }

            // Response

            if (m.Request)
            {
                Sender.Tell(
                    new ClusterActorDiscoveryMessage.ResyncCluster(
                        _cluster.SelfUniqueAddress,
                        _actorItems.Select(a => new ClusterActorDiscoveryMessage.ClusterActorUp(a.Actor, a.Tag)).ToList(),
                        false));
            }
        }
        private void Handle(ClusterActorDiscoveryMessage.RegisterCluster m)
        {
            _log.Info($"RegisterCluster: {m.ClusterAddress}");

            // Register node

            var item = _nodeMap.FirstOrDefault(i => i.Value.ClusterAddress == m.ClusterAddress);
            if (item.Key != null)
            {
                _log.Error($"Already registered node. {m.ClusterAddress}");
                return;
            }

            _nodeMap.Add(Sender, new NodeItem
            {
                ClusterAddress = m.ClusterAddress,
                ActorItems = new List<ActorItem>()
            });

            // Process attached actorUp messages

            if (m.ActorUpList != null)
            {
                foreach (var actorUp in m.ActorUpList)
                    Handle(actorUp);
            }
        }