func mustMarshalMsg(t *testing.T, m raftpb.Message) []byte { json, err := m.Marshal() if err != nil { t.Fatalf("error marshalling raft Message: %#v", err) } return json }
func send(p Peers, m raftpb.Message) { // TODO (xiangli): reasonable retry logic for i := 0; i < 3; i++ { url := p.Pick(m.To) if url == "" { // TODO: unknown peer id.. what do we do? I // don't think his should ever happen, need to // look into this further. log.Printf("etcdhttp: no addr for %d", m.To) return } url += raftPrefix // TODO: don't block. we should be able to have 1000s // of messages out at a time. data, err := m.Marshal() if err != nil { log.Println("etcdhttp: dropping message:", err) return // drop bad message } if httpPost(url, data) { return // success } // TODO: backoff } }
func send(c *http.Client, cls ClusterStore, m raftpb.Message) { // TODO (xiangli): reasonable retry logic for i := 0; i < 3; i++ { u := cls.Get().Pick(m.To) if u == "" { // TODO: unknown peer id.. what do we do? I // don't think his should ever happen, need to // look into this further. log.Printf("etcdhttp: no addr for %d", m.To) return } u = fmt.Sprintf("%s%s", u, raftPrefix) // TODO: don't block. we should be able to have 1000s // of messages out at a time. data, err := m.Marshal() if err != nil { log.Println("etcdhttp: dropping message:", err) return // drop bad message } if httpPost(c, u, data) { return // success } // TODO: backoff } }
func (n *node) send(m raftpb.Message) { x.AssertTruef(n.id != m.To, "Seding message to itself") data, err := m.Marshal() x.Check(err) if m.Type != raftpb.MsgHeartbeat && m.Type != raftpb.MsgHeartbeatResp { fmt.Printf("\t\tSENDING: %v %v-->%v\n", m.Type, m.From, m.To) } select { case n.messages <- sendmsg{to: m.To, data: data}: // pass default: log.Fatalf("Unable to push messages to channel in send") } }
func (t *tcpTransport) send(msg pb.Message) error { data, err := msg.Marshal() if err != nil { fmt.Fprint(os.Stdout, "marshal message err:", err) return err } fmt.Println(msg) p := GenPacket(data) fmt.Println(len(p)) n, err := t.peerC[msg.To].Write(p) if err != nil { fmt.Fprintf(os.Stdout, "socket write data err:%s\n", err.Error()) return err } if n != 4+len(data) { fmt.Fprintln(os.Stdout, "write data short", n, 4+len(data)) return ErrShortPacket } fmt.Fprint(os.Stdout, msg.From, "--->", msg.To, "\n") return nil }
func (rn *raftNetwork) send(m raftpb.Message) { rn.mu.Lock() to := rn.recvQueues[m.To] if rn.disconnected[m.To] { to = nil } drop := rn.dropmap[conn{m.From, m.To}] dl := rn.delaymap[conn{m.From, m.To}] rn.mu.Unlock() if to == nil { return } if drop != 0 && rand.Float64() < drop { return } // TODO: shall we dl without blocking the send call? if dl.d != 0 && rand.Float64() < dl.rate { rd := rand.Int63n(int64(dl.d)) time.Sleep(time.Duration(rd)) } // use marshal/unmarshal to copy message to avoid data race. b, err := m.Marshal() if err != nil { panic(err) } var cm raftpb.Message err = cm.Unmarshal(b) if err != nil { panic(err) } select { case to <- cm: default: // drop messages when the receiver queue is full. } }
// send uses the given client to send a message to a member in the given // ClusterStore, retrying up to 3 times for each message. The given // ServerStats and LeaderStats are updated appropriately func send(c *http.Client, cl *Cluster, m raftpb.Message, ss *stats.ServerStats, ls *stats.LeaderStats) { cid := cl.ID() // TODO (xiangli): reasonable retry logic for i := 0; i < 3; i++ { memb := cl.Member(m.To) if memb == nil { // TODO: unknown peer id.. what do we do? I // don't think his should ever happen, need to // look into this further. log.Printf("etcdhttp: no member for %d", m.To) return } u := fmt.Sprintf("%s%s", memb.PickPeerURL(), raftPrefix) // TODO: don't block. we should be able to have 1000s // of messages out at a time. data, err := m.Marshal() if err != nil { log.Println("etcdhttp: dropping message:", err) return // drop bad message } if m.Type == raftpb.MsgApp { ss.SendAppendReq(len(data)) } to := strutil.IDAsHex(m.To) fs := ls.Follower(to) start := time.Now() sent := httpPost(c, u, cid, data) end := time.Now() if sent { fs.Succ(end.Sub(start)) return } fs.Fail() // TODO: backoff } }