private void RelayPing(MessageBase message)
        {
            var m = message as PingReqMessage;

            if (m.CorrelationId.HasValue)
            {
                _logger.LogInformation(
                    $"Relaying PING {m.SourceNode} -> {m.SubjectNode}");

                CorrelatedMessages.TryAdd(m.CorrelationId.Value, m);
                _swimProtocolProvider.SendMessage(m.SubjectNode, new PingMessage(m.CorrelationId.Value)
                {
                    SourceNode = _swimProtocolProvider.Node
                });
            }
        }
Exemplo n.º 2
0
        private void HandleMessage(MessageBase message)
        {
            Debug.WriteLine($"Processing {message.MessageType} Message from {message.SourceNode?.Endpoint ?? "unidentified node"}");
            Logger.LogInformation($"Processing {message.MessageType} Message from {message.SourceNode?.Endpoint ?? "unidentified node"}");

            try
            {
                switch (message.MessageType)
                {
                case MessageType.Composite:
                {
                    var cm = message as CompositeMessage;

                    if (cm.Messages != null)
                    {
                        foreach (var em in cm.Messages)
                        {
                            HandleMessage(em);
                        }
                    }
                }

                break;

                case MessageType.Alive:
                {
                    lock (_nodesLock)
                    {
                        if (!Nodes.Any(x => x == message.SourceNode))
                        {
                            AddNode(message.SourceNode);
                        }
                    }

                    AddBroadcastMessage(message);
                }

                break;

                case MessageType.Dead:
                {
                    lock (_nodesLock)
                    {
                        if (Nodes.Any(x => x == message.SourceNode))
                        {
                            RemoveNode(message.SourceNode);
                        }
                    }

                    AddBroadcastMessage(message);
                }

                break;

                case MessageType.Ping:
                {
                    lock (_nodesLock)
                    {
                        if (!Nodes.Any(x => x == message.SourceNode))
                        {
                            AddNode(message.SourceNode);
                        }
                    }

                    if (message.SourceNode != null && ProtocolProvider?.Node?.Endpoint != null)
                    {
                        ProtocolProvider.SendMessage(message.SourceNode,
                                                     new AckMessage(message.CorrelationId, ProtocolProvider.Node));
                    }
                }

                break;

                case MessageType.Ack:
                {
                    if (message.SourceNode == ActiveNode)
                    {
                        lock (_receivedAckLock)
                        {
                            ReceivedAck = true;
                        }
                    }

                    if (message.CorrelationId.HasValue)
                    {
                        MessageBase ms = null;

                        //  Send message back to originating node.
                        if (CorrelatedMessages.TryRemove(message.CorrelationId.Value, out ms))
                        {
                            var cm = ms as PingReqMessage;
                            ProtocolProvider.SendMessage(cm.SourceNode, message);
                        }
                    }
                }

                break;

                case MessageType.PingReq:
                {
                    var m = message as PingReqMessage;

                    if (m.CorrelationId.HasValue)
                    {
                        CorrelatedMessages.TryAdd(m.CorrelationId.Value, m);
                    }

                    ProtocolProvider.SendMessage(m.Endpoint, new PingMessage(m.CorrelationId.Value)
                        {
                            SourceNode = ProtocolProvider.Node
                        });
                }

                break;

                default:
                    Debug.WriteLine($"Unknown message type {message.MessageType}, skipping...");
                    Logger.LogWarning($"Unknown message type {message.MessageType}, skipping...");

                    break;
                }
            }
            catch (Exception e)
            {
                Debug.WriteLine($"{e.ToString()}: {e.StackTrace}");
                Logger.LogError(e, string.Empty);
            }
        }