Exemple #1
0
        public async Task OnRecieve(IChannelHandlerContext context, string msgstr)
        {
            //
            if (!string.IsNullOrEmpty(msgstr))
            {
                //RaftCommand  msgObj = Newtonsoft.Json.JsonConvert.DeserializeObject<RaftCommand>(msgstr, new JsonSerializerSettings()
                //{
                //    NullValueHandling = NullValueHandling.Ignore,
                //    TypeNameHandling = TypeNameHandling.All,
                //    TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Full
                //}
                //);
                int         index  = msgstr.IndexOf(',');
                string      num    = msgstr.Substring(0, index);
                string      base64 = msgstr.Substring(index + 1);
                byte[]      data   = Convert.FromBase64String(base64);
                RaftCommand cmd    = new RaftCommand();
                cmd.Code = Convert.ToInt32(num);
                switch (cmd.Code)
                {
                case RaftCommand.Handshake:
                    cmd.Message = TcpMsgHandshake.BiserDecode(data);
                    break;

                case RaftCommand.HandshakeACK:
                    cmd.Message = TcpMsgHandshake.BiserDecode(data);
                    break;

                case RaftCommand.RaftMessage:
                    cmd.Message = TcpMsgRaft.BiserDecode(data);
                    TcpMsgRaft t = (TcpMsgRaft)cmd.Message;
                    switch (t.RaftSignalType)
                    {
                    case eRaftSignalType.LeaderHearthbeat:
                        t.orginalObject = LeaderHeartbeat.BiserDecode(t.Data);
                        break;

                    case eRaftSignalType.CandidateRequest:
                        t.orginalObject = CandidateRequest.BiserDecode(t.Data);
                        break;

                    case eRaftSignalType.StateLogEntryAccepted:
                        t.orginalObject = StateLogEntryApplied.BiserDecode(t.Data);
                        break;

                    case eRaftSignalType.StateLogEntryRequest:
                        t.orginalObject = StateLogEntryRequest.BiserDecode(t.Data);
                        break;

                    case eRaftSignalType.StateLogEntrySuggestion:
                        t.orginalObject = StateLogEntrySuggestion.BiserDecode(t.Data);
                        break;

                    case eRaftSignalType.StateLogRedirectRequest:
                        t.orginalObject = StateLogEntryRedirectRequest.BiserDecode(t.Data);
                        break;

                    case eRaftSignalType.VoteOfCandidate:
                        t.orginalObject = VoteOfCandidate.BiserDecode(t.Data);
                        break;
                    }
                    break;

                case RaftCommand.FreeMessage:
                    cmd.Message = TcpMsg.BiserDecode(data);
                    break;
                }
                this.packetParser(cmd as RaftCommand);
            }
        }
Exemple #2
0
        private void packetParser(RaftCommand message)
        {
            try
            {
                switch (message.Code)
                {
                case RaftCommand.Handshake:     //Handshake

                    Handshake = message.Message as TcpMsgHandshake;
                    trn.peerNetwork.AddPeerToClusterEndPoints(this, true);
                    return;

                case RaftCommand.RaftMessage:     //RaftMessage

                    if (this.na == null)
                    {
                        return;
                    }
                    var msg = message.Message as TcpMsgRaft;
                    Task.Run(() =>
                    {
                        try
                        {
                            var node = trn.GetNode();
                            if (node != null)
                            {
                                node.HandleRaftSignal(this.na, msg.RaftSignalType, msg.orginalObject);
                            }
                            else
                            {
                                Console.WriteLine("cant find node");
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex);
                        }
                    });
                    return;

                case RaftCommand.HandshakeACK:     //Handshake ACK
                    Handshake = message.Message as TcpMsgHandshake;
                    trn.peerNetwork.AddPeerToClusterEndPoints(this, false);
                    return;

                case RaftCommand.FreeMessage:     //Free Message protocol
                    var Tcpmsg = message.Message as TcpMsg;
                    if (na != null)
                    {
                        trn.log.Log(new WarningLogEntry()
                        {
                            LogType     = WarningLogEntry.eLogType.DEBUG,
                            Description = $"{trn.port} ({trn.GetNode().States.NodeState})> peer {na.NodeAddressId} sent: { Tcpmsg.MsgType }"
                        });
                    }
                    return;

                case RaftCommand.Ping:     //Ping
                    return;
                }
            }
            catch (Exception ex)
            {
                Dispose();
            }
        }