chore: lint repo (use american english) (#9144)

behavior/doc.go

@@ -0,0 +1,42 @@
+/*
+Package Behavior provides a mechanism for reactors to report behavior of peers.
+
+Instead of a reactor calling the switch directly it will call the behavior module which will
+handle the stoping and marking peer as good on behalf of the reactor.
+
+There are four different behaviors a reactor can report.
+
+1. bad message
+
+type badMessage struct {
+	explanation string
+}
+
+This message will request the peer be stopped for an error
+
+2. message out of order
+
+type messageOutOfOrder struct {
+	explanation string
+}
+
+This message will request the peer be stopped for an error
+
+3. consesnsus Vote
+
+type consensusVote struct {
+	explanation string
+}
+
+This message will request the peer be marked as good
+
+4. block part
+
+type blockPart struct {
+	explanation string
+}
+
+This message will request the peer be marked as good
+
+*/
+package behavior

behavior/peer_behavior.go

@@ -0,0 +1,49 @@
+package behavior
+
+import (
+	"github.com/tendermint/tendermint/p2p"
+)
+
+// PeerBehavior is a struct describing a behavior a peer performed.
+// `peerID` identifies the peer and reason characterizes the specific
+// behavior performed by the peer.
+type PeerBehavior struct {
+	peerID p2p.ID
+	reason interface{}
+}
+
+type badMessage struct {
+	explanation string
+}
+
+// BadMessage returns a badMessage PeerBehavior.
+func BadMessage(peerID p2p.ID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: badMessage{explanation}}
+}
+
+type messageOutOfOrder struct {
+	explanation string
+}
+
+// MessageOutOfOrder returns a messagOutOfOrder PeerBehavior.
+func MessageOutOfOrder(peerID p2p.ID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: messageOutOfOrder{explanation}}
+}
+
+type consensusVote struct {
+	explanation string
+}
+
+// ConsensusVote returns a consensusVote PeerBehavior.
+func ConsensusVote(peerID p2p.ID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: consensusVote{explanation}}
+}
+
+type blockPart struct {
+	explanation string
+}
+
+// BlockPart returns blockPart PeerBehavior.
+func BlockPart(peerID p2p.ID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: blockPart{explanation}}
+}

behavior/reporter.go

@@ -0,0 +1,86 @@
+package behavior
+
+import (
+	"errors"
+
+	tmsync "github.com/tendermint/tendermint/libs/sync"
+	"github.com/tendermint/tendermint/p2p"
+)
+
+// Reporter provides an interface for reactors to report the behavior
+// of peers synchronously to other components.
+type Reporter interface {
+	Report(behavior PeerBehavior) error
+}
+
+// SwitchReporter reports peer behavior to an internal Switch.
+type SwitchReporter struct {
+	sw *p2p.Switch
+}
+
+// NewSwitchReporter return a new SwitchReporter instance which wraps the Switch.
+func NewSwitchReporter(sw *p2p.Switch) *SwitchReporter {
+	return &SwitchReporter{
+		sw: sw,
+	}
+}
+
+// Report reports the behavior of a peer to the Switch.
+func (spbr *SwitchReporter) Report(behavior PeerBehavior) error {
+	peer := spbr.sw.Peers().Get(behavior.peerID)
+	if peer == nil {
+		return errors.New("peer not found")
+	}
+
+	switch reason := behavior.reason.(type) {
+	case consensusVote, blockPart:
+		spbr.sw.MarkPeerAsGood(peer)
+	case badMessage:
+		spbr.sw.StopPeerForError(peer, reason.explanation)
+	case messageOutOfOrder:
+		spbr.sw.StopPeerForError(peer, reason.explanation)
+	default:
+		return errors.New("unknown reason reported")
+	}
+
+	return nil
+}
+
+// MockReporter is a concrete implementation of the Reporter
+// interface used in reactor tests to ensure reactors report the correct
+// behavior in manufactured scenarios.
+type MockReporter struct {
+	mtx tmsync.RWMutex
+	pb  map[p2p.ID][]PeerBehavior
+}
+
+// NewMockReporter returns a Reporter which records all reported
+// behaviors in memory.
+func NewMockReporter() *MockReporter {
+	return &MockReporter{
+		pb: map[p2p.ID][]PeerBehavior{},
+	}
+}
+
+// Report stores the PeerBehavior produced by the peer identified by peerID.
+func (mpbr *MockReporter) Report(behavior PeerBehavior) error {
+	mpbr.mtx.Lock()
+	defer mpbr.mtx.Unlock()
+	mpbr.pb[behavior.peerID] = append(mpbr.pb[behavior.peerID], behavior)
+
+	return nil
+}
+
+// GetBehaviours returns all behaviors reported on the peer identified by peerID.
+func (mpbr *MockReporter) GetBehaviours(peerID p2p.ID) []PeerBehavior {
+	mpbr.mtx.RLock()
+	defer mpbr.mtx.RUnlock()
+	if items, ok := mpbr.pb[peerID]; ok {
+		result := make([]PeerBehavior, len(items))
+		copy(result, items)
+
+		return result
+	}
+
+	return []PeerBehavior{}
+}

behavior/reporter_test.go

@@ -0,0 +1,205 @@
+package behavior_test
+
+import (
+	"sync"
+	"testing"
+
+	bh "github.com/tendermint/tendermint/behavior"
+	"github.com/tendermint/tendermint/p2p"
+)
+
+// TestMockReporter tests the MockReporter's ability to store reported
+// peer behavior in memory indexed by the peerID.
+func TestMockReporter(t *testing.T) {
+	var peerID p2p.ID = "MockPeer"
+	pr := bh.NewMockReporter()
+
+	behaviors := pr.GetBehaviours(peerID)
+	if len(behaviors) != 0 {
+		t.Error("Expected to have no behaviors reported")
+	}
+
+	badMessage := bh.BadMessage(peerID, "bad message")
+	if err := pr.Report(badMessage); err != nil {
+		t.Error(err)
+	}
+	behaviors = pr.GetBehaviours(peerID)
+	if len(behaviors) != 1 {
+		t.Error("Expected the peer have one reported behavior")
+	}
+
+	if behaviors[0] != badMessage {
+		t.Error("Expected Bad Message to have been reported")
+	}
+}
+
+type scriptItem struct {
+	peerID   p2p.ID
+	behavior bh.PeerBehavior
+}
+
+// equalBehaviours returns true if a and b contain the same PeerBehaviors with
+// the same freequencies and otherwise false.
+func equalBehaviours(a []bh.PeerBehavior, b []bh.PeerBehavior) bool {
+	aHistogram := map[bh.PeerBehavior]int{}
+	bHistogram := map[bh.PeerBehavior]int{}
+
+	for _, behavior := range a {
+		aHistogram[behavior]++
+	}
+
+	for _, behavior := range b {
+		bHistogram[behavior]++
+	}
+
+	if len(aHistogram) != len(bHistogram) {
+		return false
+	}
+
+	for _, behavior := range a {
+		if aHistogram[behavior] != bHistogram[behavior] {
+			return false
+		}
+	}
+
+	for _, behavior := range b {
+		if bHistogram[behavior] != aHistogram[behavior] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// TestEqualPeerBehaviors tests that equalBehaviours can tell that two slices
+// of peer behaviors can be compared for the behaviors they contain and the
+// freequencies that those behaviors occur.
+func TestEqualPeerBehaviors(t *testing.T) {
+	var (
+		peerID        p2p.ID = "MockPeer"
+		consensusVote        = bh.ConsensusVote(peerID, "voted")
+		blockPart            = bh.BlockPart(peerID, "blocked")
+		equals               = []struct {
+			left  []bh.PeerBehavior
+			right []bh.PeerBehavior
+		}{
+			// Empty sets
+			{[]bh.PeerBehavior{}, []bh.PeerBehavior{}},
+			// Single behaviors
+			{[]bh.PeerBehavior{consensusVote}, []bh.PeerBehavior{consensusVote}},
+			// Equal Frequencies
+			{[]bh.PeerBehavior{consensusVote, consensusVote},
+				[]bh.PeerBehavior{consensusVote, consensusVote}},
+			// Equal frequencies different orders
+			{[]bh.PeerBehavior{consensusVote, blockPart},
+				[]bh.PeerBehavior{blockPart, consensusVote}},
+		}
+		unequals = []struct {
+			left  []bh.PeerBehavior
+			right []bh.PeerBehavior
+		}{
+			// Comparing empty sets to non empty sets
+			{[]bh.PeerBehavior{}, []bh.PeerBehavior{consensusVote}},
+			// Different behaviors
+			{[]bh.PeerBehavior{consensusVote}, []bh.PeerBehavior{blockPart}},
+			// Same behavior with different frequencies
+			{[]bh.PeerBehavior{consensusVote},
+				[]bh.PeerBehavior{consensusVote, consensusVote}},
+		}
+	)
+
+	for _, test := range equals {
+		if !equalBehaviours(test.left, test.right) {
+			t.Errorf("expected %#v and %#v to be equal", test.left, test.right)
+		}
+	}
+
+	for _, test := range unequals {
+		if equalBehaviours(test.left, test.right) {
+			t.Errorf("expected %#v and %#v to be unequal", test.left, test.right)
+		}
+	}
+}
+
+// TestPeerBehaviorConcurrency constructs a scenario in which
+// multiple goroutines are using the same MockReporter instance.
+// This test reproduces the conditions in which MockReporter will
+// be used within a Reactor `Receive` method tests to ensure thread safety.
+func TestMockPeerBehaviorReporterConcurrency(t *testing.T) {
+	var (
+		behaviorScript = []struct {
+			peerID    p2p.ID
+			behaviors []bh.PeerBehavior
+		}{
+			{"1", []bh.PeerBehavior{bh.ConsensusVote("1", "")}},
+			{"2", []bh.PeerBehavior{bh.ConsensusVote("2", ""), bh.ConsensusVote("2", ""), bh.ConsensusVote("2", "")}},
+			{
+				"3",
+				[]bh.PeerBehavior{bh.BlockPart("3", ""),
+					bh.ConsensusVote("3", ""),
+					bh.BlockPart("3", ""),
+					bh.ConsensusVote("3", "")}},
+			{
+				"4",
+				[]bh.PeerBehavior{bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", "")}},
+			{
+				"5",
+				[]bh.PeerBehavior{bh.BlockPart("5", ""),
+					bh.ConsensusVote("5", ""),
+					bh.BlockPart("5", ""),
+					bh.ConsensusVote("5", "")}},
+		}
+	)
+
+	var receiveWg sync.WaitGroup
+	pr := bh.NewMockReporter()
+	scriptItems := make(chan scriptItem)
+	done := make(chan int)
+	numConsumers := 3
+	for i := 0; i < numConsumers; i++ {
+		receiveWg.Add(1)
+		go func() {
+			defer receiveWg.Done()
+			for {
+				select {
+				case pb := <-scriptItems:
+					if err := pr.Report(pb.behavior); err != nil {
+						t.Error(err)
+					}
+				case <-done:
+					return
+				}
+			}
+		}()
+	}
+
+	var sendingWg sync.WaitGroup
+	sendingWg.Add(1)
+	go func() {
+		defer sendingWg.Done()
+		for _, item := range behaviorScript {
+			for _, reason := range item.behaviors {
+				scriptItems <- scriptItem{item.peerID, reason}
+			}
+		}
+	}()
+
+	sendingWg.Wait()
+
+	for i := 0; i < numConsumers; i++ {
+		done <- 1
+	}
+
+	receiveWg.Wait()
+
+	for _, items := range behaviorScript {
+		reported := pr.GetBehaviours(items.peerID)
+		if !equalBehaviours(reported, items.behaviors) {
+			t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
+				items.peerID, items.behaviors, reported)
+		}
+	}
+}