コード例 #1
0
        public Bcl.IEnumerable <PeerConnection> FindRoutes(ExternalRouteLookupRequest lookupRequest)
        {
            var peers = new Bcl.List <PeerConnection>();

            if (lookupRequest.ReceiverNodeIdentity.IsSet())
            {
                if (nodeToConnectionMap.TryGetValue(lookupRequest.ReceiverNodeIdentity, out var peerConnection))
                {
                    peers.Add(peerConnection);
                }
            }
            else
            {
                if (messageToNodeMap.TryGetValue(lookupRequest.Message, out var nodes))
                {
                    if (lookupRequest.Distribution == DistributionPattern.Unicast)
                    {
                        peers.Add(nodeToConnectionMap[nodes.RoundRobinGet()]);
                    }
                    else
                    {
                        if (lookupRequest.Distribution == DistributionPattern.Broadcast)
                        {
                            foreach (var node in nodes)
                            {
                                peers.Add(nodeToConnectionMap[node]);
                            }
                        }
                    }
                }
            }

            return(peers);
        }
コード例 #2
0
        private void RemoveActorsByMessage(ExternalRouteRemoval routeRemoval, ReceiverIdentifier nodeIdentifier)
        {
            if (messageToNodeMap.TryGetValue(routeRemoval.Route.Message, out var nodes))
            {
                if (nodes.Remove(nodeIdentifier))
                {
                    if (!nodes.Any())
                    {
                        messageToNodeMap.Remove(routeRemoval.Route.Message);
                    }

                    var emptyActors = new Bcl.List <ReceiverIdentifier>();
                    if (nodeActors.TryGetValue(nodeIdentifier, out var actors))
                    {
                        foreach (var actor in actors)
                        {
                            if (actorToMessageMap.TryGetValue(actor, out var messages))
                            {
                                if (messages.Remove(routeRemoval.Route.Message))
                                {
                                    if (!messages.Any())
                                    {
                                        actorToMessageMap.Remove(actor);
                                        emptyActors.Add(actor);
                                    }
                                }
                            }
                        }

                        foreach (var emptyActor in emptyActors)
                        {
                            actors.Remove(emptyActor);
                        }

                        if (!actors.Any())
                        {
                            nodeActors.Remove(nodeIdentifier);
                        }
                    }
                }
            }
        }
コード例 #3
0
        public Bcl.IEnumerable <NodeActors> FindAllActors(MessageIdentifier messageIdentifier)
        {
            var messageRoutes = new Bcl.List <NodeActors>();

            if (messageToNodeMap.TryGetValue(messageIdentifier, out var nodes))
            {
                foreach (var node in nodes)
                {
                    if (nodeActors.TryGetValue(node, out var actors))
                    {
                        messageRoutes.Add(new NodeActors
                        {
                            NodeIdentifier = node,
                            Actors         = actorToMessageMap.Where(kv => actors.Contains(kv.Key) &&
                                                                     kv.Value.Contains(messageIdentifier))
                                             .Select(kv => kv.Key)
                                             .ToList()
                        });
                    }
                }
            }

            return(messageRoutes);
        }
コード例 #4
0
        public Bcl.IEnumerable <ILocalSendingSocket <IMessage> > FindRoutes(InternalRouteLookupRequest lookupRequest)
        {
            HashedLinkedList <ReceiverIdentifier> actors;
            var sockets = new Bcl.List <ILocalSendingSocket <IMessage> >();
            ILocalSendingSocket <IMessage> socket;

            if (lookupRequest.ReceiverIdentity.IsSet())
            {
                if (lookupRequest.ReceiverIdentity.IsMessageHub())
                {
                    if (messageHubs.TryGetValue(lookupRequest.ReceiverIdentity, out socket))
                    {
                        sockets.Add(socket);
                    }
                }
                else
                {
                    if (lookupRequest.ReceiverIdentity.IsActor())
                    {
                        if (actorToSocketMap.TryGetValue(lookupRequest.ReceiverIdentity, out socket))
                        {
                            if (messageToActorMap.TryGetValue(lookupRequest.Message, out actors))
                            {
                                if (actors.Contains(lookupRequest.ReceiverIdentity))
                                {
                                    sockets.Add(socket);
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                if (messageToActorMap.TryGetValue(lookupRequest.Message, out actors))
                {
                    if (lookupRequest.Distribution == DistributionPattern.Unicast)
                    {
                        if (actorToSocketMap.TryGetValue(Get(actors), out socket))
                        {
                            sockets.Add(socket);
                        }
                    }
                    else
                    {
                        if (lookupRequest.Distribution == DistributionPattern.Broadcast)
                        {
                            foreach (var actor in actors)
                            {
                                if (actorToSocketMap.TryGetValue(actor, out socket))
                                {
                                    sockets.Add(socket);
                                }
                            }
                        }
                    }
                }
            }

            return(sockets);
        }