2016-05-13 06:49:15 +03:00
|
|
|
// Copyright 2015 The etcd Authors
|
2015-01-25 06:19:16 +03:00
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
2014-11-03 23:04:24 +03:00
|
|
|
|
|
|
|
package raft
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"fmt"
|
|
|
|
|
|
|
|
pb "github.com/coreos/etcd/raft/raftpb"
|
|
|
|
)
|
|
|
|
|
2014-12-26 04:04:33 +03:00
|
|
|
func (st StateType) MarshalJSON() ([]byte, error) {
|
|
|
|
return []byte(fmt.Sprintf("%q", st.String())), nil
|
|
|
|
}
|
|
|
|
|
2014-11-26 03:21:50 +03:00
|
|
|
// uint64Slice implements sort interface
|
|
|
|
type uint64Slice []uint64
|
|
|
|
|
|
|
|
func (p uint64Slice) Len() int { return len(p) }
|
|
|
|
func (p uint64Slice) Less(i, j int) bool { return p[i] < p[j] }
|
|
|
|
func (p uint64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
|
|
|
|
|
|
|
|
func min(a, b uint64) uint64 {
|
|
|
|
if a > b {
|
|
|
|
return b
|
|
|
|
}
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
|
|
|
|
func max(a, b uint64) uint64 {
|
|
|
|
if a > b {
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
return b
|
|
|
|
}
|
|
|
|
|
2016-03-24 14:59:41 +03:00
|
|
|
func IsLocalMsg(msgt pb.MessageType) bool {
|
|
|
|
return msgt == pb.MsgHup || msgt == pb.MsgBeat || msgt == pb.MsgUnreachable ||
|
|
|
|
msgt == pb.MsgSnapStatus || msgt == pb.MsgCheckQuorum || msgt == pb.MsgTransferLeader
|
2015-02-25 08:38:18 +03:00
|
|
|
}
|
2014-12-05 21:45:05 +03:00
|
|
|
|
2016-03-24 14:59:41 +03:00
|
|
|
func IsResponseMsg(msgt pb.MessageType) bool {
|
|
|
|
return msgt == pb.MsgAppResp || msgt == pb.MsgVoteResp || msgt == pb.MsgHeartbeatResp || msgt == pb.MsgUnreachable
|
2015-01-14 22:42:30 +03:00
|
|
|
}
|
2014-12-05 21:45:05 +03:00
|
|
|
|
2015-01-21 22:12:58 +03:00
|
|
|
// EntryFormatter can be implemented by the application to provide human-readable formatting
|
|
|
|
// of entry data. Nil is a valid EntryFormatter and will use a default format.
|
|
|
|
type EntryFormatter func([]byte) string
|
|
|
|
|
2014-11-03 23:04:24 +03:00
|
|
|
// DescribeMessage returns a concise human-readable description of a
|
|
|
|
// Message for debugging.
|
2015-01-22 03:27:26 +03:00
|
|
|
func DescribeMessage(m pb.Message, f EntryFormatter) string {
|
2014-11-03 23:04:24 +03:00
|
|
|
var buf bytes.Buffer
|
2015-12-16 07:18:21 +03:00
|
|
|
fmt.Fprintf(&buf, "%x->%x %v Term:%d Log:%d/%d", m.From, m.To, m.Type, m.Term, m.LogTerm, m.Index)
|
2014-11-03 23:04:24 +03:00
|
|
|
if m.Reject {
|
|
|
|
fmt.Fprintf(&buf, " Rejected")
|
2016-01-20 18:02:50 +03:00
|
|
|
if m.RejectHint != 0 {
|
|
|
|
fmt.Fprintf(&buf, "(Hint:%d)", m.RejectHint)
|
|
|
|
}
|
2014-11-03 23:04:24 +03:00
|
|
|
}
|
|
|
|
if m.Commit != 0 {
|
|
|
|
fmt.Fprintf(&buf, " Commit:%d", m.Commit)
|
|
|
|
}
|
|
|
|
if len(m.Entries) > 0 {
|
|
|
|
fmt.Fprintf(&buf, " Entries:[")
|
2016-01-20 18:02:50 +03:00
|
|
|
for i, e := range m.Entries {
|
|
|
|
if i != 0 {
|
|
|
|
buf.WriteString(", ")
|
|
|
|
}
|
2015-01-22 03:27:26 +03:00
|
|
|
buf.WriteString(DescribeEntry(e, f))
|
2014-11-03 23:04:24 +03:00
|
|
|
}
|
|
|
|
fmt.Fprintf(&buf, "]")
|
|
|
|
}
|
|
|
|
if !IsEmptySnap(m.Snapshot) {
|
|
|
|
fmt.Fprintf(&buf, " Snapshot:%v", m.Snapshot)
|
|
|
|
}
|
|
|
|
return buf.String()
|
|
|
|
}
|
|
|
|
|
|
|
|
// DescribeEntry returns a concise human-readable description of an
|
|
|
|
// Entry for debugging.
|
2015-01-22 03:27:26 +03:00
|
|
|
func DescribeEntry(e pb.Entry, f EntryFormatter) string {
|
2015-01-21 22:12:58 +03:00
|
|
|
var formatted string
|
2015-02-20 21:51:14 +03:00
|
|
|
if e.Type == pb.EntryNormal && f != nil {
|
2015-01-21 22:12:58 +03:00
|
|
|
formatted = f(e.Data)
|
2015-02-20 21:51:14 +03:00
|
|
|
} else {
|
|
|
|
formatted = fmt.Sprintf("%q", e.Data)
|
2015-01-21 22:12:58 +03:00
|
|
|
}
|
|
|
|
return fmt.Sprintf("%d/%d %s %s", e.Term, e.Index, e.Type, formatted)
|
|
|
|
}
|
2015-03-18 22:36:29 +03:00
|
|
|
|
|
|
|
func limitSize(ents []pb.Entry, maxSize uint64) []pb.Entry {
|
|
|
|
if len(ents) == 0 {
|
|
|
|
return ents
|
|
|
|
}
|
|
|
|
size := ents[0].Size()
|
|
|
|
var limit int
|
|
|
|
for limit = 1; limit < len(ents); limit++ {
|
|
|
|
size += ents[limit].Size()
|
|
|
|
if uint64(size) > maxSize {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ents[:limit]
|
|
|
|
}
|