You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

538 lines
18 KiB

new pubsub package comment out failing consensus tests for now rewrite rpc httpclient to use new pubsub package import pubsub as tmpubsub, query as tmquery make event IDs constants EventKey -> EventTypeKey rename EventsPubsub to PubSub mempool does not use pubsub rename eventsSub to pubsub new subscribe API fix channel size issues and consensus tests bugs refactor rpc client add missing discardFromChan method add mutex rename pubsub to eventBus remove IsRunning from WSRPCConnection interface (not needed) add a comment in broadcastNewRoundStepsAndVotes rename registerEventCallbacks to broadcastNewRoundStepsAndVotes See https://dave.cheney.net/2014/03/19/channel-axioms stop eventBuses after reactor tests remove unnecessary Unsubscribe return subscribe helper function move discardFromChan to where it is used subscribe now returns an err this gives us ability to refuse to subscribe if pubsub is at its max capacity. use context for control overflow cache queries handle err when subscribing in replay_test rename testClientID to testSubscriber extract var set channel buffer capacity to 1 in replay_file fix byzantine_test unsubscribe from single event, not all events refactor httpclient to return events to appropriate channels return failing testReplayCrashBeforeWriteVote test fix TestValidatorSetChanges refactor code a bit fix testReplayCrashBeforeWriteVote add comment fix TestValidatorSetChanges fixes from Bucky's review update comment [ci skip] test TxEventBuffer update changelog fix TestValidatorSetChanges (2nd attempt) only do wg.Done when no errors benchmark event bus create pubsub server inside NewEventBus only expose config params (later if needed) set buffer capacity to 0 so we are not testing cache new tx event format: key = "Tx" plus a tag {"tx.hash": XYZ} This should allow to subscribe to all transactions! or a specific one using a query: "tm.events.type = Tx and tx.hash = '013ABF99434...'" use TimeoutCommit instead of afterPublishEventNewBlockTimeout TimeoutCommit is the time a node waits after committing a block, before it goes into the next height. So it will finish everything from the last block, but then wait a bit. The idea is this gives it time to hear more votes from other validators, to strengthen the commit it includes in the next block. But it also gives it time to hear about new transactions. waitForBlockWithUpdatedVals rewrite WAL crash tests Task: test that we can recover from any WAL crash. Solution: the old tests were relying on event hub being run in the same thread (we were injecting the private validator's last signature). when considering a rewrite, we considered two possible solutions: write a "fuzzy" testing system where WAL is crashing upon receiving a new message, or inject failures and trigger them in tests using something like https://github.com/coreos/gofail. remove sleep no cs.Lock around wal.Save test different cases (empty block, non-empty block, ...) comments add comments test 4 cases: empty block, non-empty block, non-empty block with smaller part size, many blocks fixes as per Bucky's last review reset subscriptions on UnsubscribeAll use a simple counter to track message for which we panicked also, set a smaller part size for all test cases
7 years ago
cleanup: Reduce and normalize import path aliasing. (#6975) The code in the Tendermint repository makes heavy use of import aliasing. This is made necessary by our extensive reuse of common base package names, and by repetition of similar names across different subdirectories. Unfortunately we have not been very consistent about which packages we alias in various circumstances, and the aliases we use vary. In the spirit of the advice in the style guide and https://github.com/golang/go/wiki/CodeReviewComments#imports, his change makes an effort to clean up and normalize import aliasing. This change makes no API or behavioral changes. It is a pure cleanup intended o help make the code more readable to developers (including myself) trying to understand what is being imported where. Only unexported names have been modified, and the changes were generated and applied mechanically with gofmt -r and comby, respecting the lexical and syntactic rules of Go. Even so, I did not fix every inconsistency. Where the changes would be too disruptive, I left it alone. The principles I followed in this cleanup are: - Remove aliases that restate the package name. - Remove aliases where the base package name is unambiguous. - Move overly-terse abbreviations from the import to the usage site. - Fix lexical issues (remove underscores, remove capitalization). - Fix import groupings to more closely match the style guide. - Group blank (side-effecting) imports and ensure they are commented. - Add aliases to multiple imports with the same base package name.
3 years ago
  1. package consensus
  2. import (
  3. "context"
  4. "fmt"
  5. "os"
  6. "path"
  7. "sync"
  8. "testing"
  9. "github.com/stretchr/testify/assert"
  10. "github.com/stretchr/testify/require"
  11. dbm "github.com/tendermint/tm-db"
  12. abciclient "github.com/tendermint/tendermint/abci/client"
  13. abci "github.com/tendermint/tendermint/abci/types"
  14. "github.com/tendermint/tendermint/internal/evidence"
  15. tmsync "github.com/tendermint/tendermint/internal/libs/sync"
  16. mempoolv0 "github.com/tendermint/tendermint/internal/mempool/v0"
  17. "github.com/tendermint/tendermint/internal/p2p"
  18. sm "github.com/tendermint/tendermint/internal/state"
  19. "github.com/tendermint/tendermint/internal/store"
  20. "github.com/tendermint/tendermint/internal/test/factory"
  21. "github.com/tendermint/tendermint/libs/log"
  22. tmcons "github.com/tendermint/tendermint/proto/tendermint/consensus"
  23. tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
  24. "github.com/tendermint/tendermint/types"
  25. )
  26. // Byzantine node sends two different prevotes (nil and blockID) to the same
  27. // validator.
  28. func TestByzantinePrevoteEquivocation(t *testing.T) {
  29. config := configSetup(t)
  30. nValidators := 4
  31. prevoteHeight := int64(2)
  32. testName := "consensus_byzantine_test"
  33. tickerFunc := newMockTickerFunc(true)
  34. appFunc := newKVStore
  35. genDoc, privVals := factory.RandGenesisDoc(config, nValidators, false, 30)
  36. states := make([]*State, nValidators)
  37. for i := 0; i < nValidators; i++ {
  38. func() {
  39. logger := consensusLogger().With("test", "byzantine", "validator", i)
  40. stateDB := dbm.NewMemDB() // each state needs its own db
  41. stateStore := sm.NewStore(stateDB)
  42. state, err := sm.MakeGenesisState(genDoc)
  43. require.NoError(t, err)
  44. require.NoError(t, stateStore.Save(state))
  45. thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
  46. defer os.RemoveAll(thisConfig.RootDir)
  47. ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
  48. app := appFunc()
  49. vals := types.TM2PB.ValidatorUpdates(state.Validators)
  50. app.InitChain(abci.RequestInitChain{Validators: vals})
  51. blockDB := dbm.NewMemDB()
  52. blockStore := store.NewBlockStore(blockDB)
  53. // one for mempool, one for consensus
  54. mtx := new(tmsync.Mutex)
  55. proxyAppConnMem := abciclient.NewLocalClient(mtx, app)
  56. proxyAppConnCon := abciclient.NewLocalClient(mtx, app)
  57. // Make Mempool
  58. mempool := mempoolv0.NewCListMempool(thisConfig.Mempool, proxyAppConnMem, 0)
  59. mempool.SetLogger(log.TestingLogger().With("module", "mempool"))
  60. if thisConfig.Consensus.WaitForTxs() {
  61. mempool.EnableTxsAvailable()
  62. }
  63. // Make a full instance of the evidence pool
  64. evidenceDB := dbm.NewMemDB()
  65. evpool, err := evidence.NewPool(logger.With("module", "evidence"), evidenceDB, stateStore, blockStore)
  66. require.NoError(t, err)
  67. // Make State
  68. blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyAppConnCon, mempool, evpool, blockStore)
  69. cs := NewState(thisConfig.Consensus, state, blockExec, blockStore, mempool, evpool)
  70. cs.SetLogger(cs.Logger)
  71. // set private validator
  72. pv := privVals[i]
  73. cs.SetPrivValidator(pv)
  74. eventBus := types.NewEventBus()
  75. eventBus.SetLogger(log.TestingLogger().With("module", "events"))
  76. err = eventBus.Start()
  77. require.NoError(t, err)
  78. cs.SetEventBus(eventBus)
  79. cs.SetTimeoutTicker(tickerFunc())
  80. cs.SetLogger(logger)
  81. states[i] = cs
  82. }()
  83. }
  84. rts := setup(t, nValidators, states, 100) // buffer must be large enough to not deadlock
  85. var bzNodeID types.NodeID
  86. // Set the first state's reactor as the dedicated byzantine reactor and grab
  87. // the NodeID that corresponds to the state so we can reference the reactor.
  88. bzNodeState := states[0]
  89. for nID, s := range rts.states {
  90. if s == bzNodeState {
  91. bzNodeID = nID
  92. break
  93. }
  94. }
  95. bzReactor := rts.reactors[bzNodeID]
  96. // alter prevote so that the byzantine node double votes when height is 2
  97. bzNodeState.doPrevote = func(height int64, round int32) {
  98. // allow first height to happen normally so that byzantine validator is no longer proposer
  99. if height == prevoteHeight {
  100. prevote1, err := bzNodeState.signVote(
  101. tmproto.PrevoteType,
  102. bzNodeState.ProposalBlock.Hash(),
  103. bzNodeState.ProposalBlockParts.Header(),
  104. )
  105. require.NoError(t, err)
  106. prevote2, err := bzNodeState.signVote(tmproto.PrevoteType, nil, types.PartSetHeader{})
  107. require.NoError(t, err)
  108. // send two votes to all peers (1st to one half, 2nd to another half)
  109. i := 0
  110. for _, ps := range bzReactor.peers {
  111. if i < len(bzReactor.peers)/2 {
  112. bzNodeState.Logger.Info("signed and pushed vote", "vote", prevote1, "peer", ps.peerID)
  113. bzReactor.voteCh.Out <- p2p.Envelope{
  114. To: ps.peerID,
  115. Message: &tmcons.Vote{
  116. Vote: prevote1.ToProto(),
  117. },
  118. }
  119. } else {
  120. bzNodeState.Logger.Info("signed and pushed vote", "vote", prevote2, "peer", ps.peerID)
  121. bzReactor.voteCh.Out <- p2p.Envelope{
  122. To: ps.peerID,
  123. Message: &tmcons.Vote{
  124. Vote: prevote2.ToProto(),
  125. },
  126. }
  127. }
  128. i++
  129. }
  130. } else {
  131. bzNodeState.Logger.Info("behaving normally")
  132. bzNodeState.defaultDoPrevote(height, round)
  133. }
  134. }
  135. // Introducing a lazy proposer means that the time of the block committed is
  136. // different to the timestamp that the other nodes have. This tests to ensure
  137. // that the evidence that finally gets proposed will have a valid timestamp.
  138. // lazyProposer := states[1]
  139. lazyNodeState := states[1]
  140. lazyNodeState.decideProposal = func(height int64, round int32) {
  141. lazyNodeState.Logger.Info("Lazy Proposer proposing condensed commit")
  142. require.NotNil(t, lazyNodeState.privValidator)
  143. var commit *types.Commit
  144. switch {
  145. case lazyNodeState.Height == lazyNodeState.state.InitialHeight:
  146. // We're creating a proposal for the first block.
  147. // The commit is empty, but not nil.
  148. commit = types.NewCommit(0, 0, types.BlockID{}, nil)
  149. case lazyNodeState.LastCommit.HasTwoThirdsMajority():
  150. // Make the commit from LastCommit
  151. commit = lazyNodeState.LastCommit.MakeCommit()
  152. default: // This shouldn't happen.
  153. lazyNodeState.Logger.Error("enterPropose: Cannot propose anything: No commit for the previous block")
  154. return
  155. }
  156. // omit the last signature in the commit
  157. commit.Signatures[len(commit.Signatures)-1] = types.NewCommitSigAbsent()
  158. if lazyNodeState.privValidatorPubKey == nil {
  159. // If this node is a validator & proposer in the current round, it will
  160. // miss the opportunity to create a block.
  161. lazyNodeState.Logger.Error(fmt.Sprintf("enterPropose: %v", errPubKeyIsNotSet))
  162. return
  163. }
  164. proposerAddr := lazyNodeState.privValidatorPubKey.Address()
  165. block, blockParts := lazyNodeState.blockExec.CreateProposalBlock(
  166. lazyNodeState.Height, lazyNodeState.state, commit, proposerAddr,
  167. )
  168. // Flush the WAL. Otherwise, we may not recompute the same proposal to sign,
  169. // and the privValidator will refuse to sign anything.
  170. if err := lazyNodeState.wal.FlushAndSync(); err != nil {
  171. lazyNodeState.Logger.Error("Error flushing to disk")
  172. }
  173. // Make proposal
  174. propBlockID := types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()}
  175. proposal := types.NewProposal(height, round, lazyNodeState.ValidRound, propBlockID)
  176. p := proposal.ToProto()
  177. if err := lazyNodeState.privValidator.SignProposal(context.Background(), lazyNodeState.state.ChainID, p); err == nil {
  178. proposal.Signature = p.Signature
  179. // send proposal and block parts on internal msg queue
  180. lazyNodeState.sendInternalMessage(msgInfo{&ProposalMessage{proposal}, ""})
  181. for i := 0; i < int(blockParts.Total()); i++ {
  182. part := blockParts.GetPart(i)
  183. lazyNodeState.sendInternalMessage(msgInfo{&BlockPartMessage{lazyNodeState.Height, lazyNodeState.Round, part}, ""})
  184. }
  185. lazyNodeState.Logger.Info("Signed proposal", "height", height, "round", round, "proposal", proposal)
  186. lazyNodeState.Logger.Debug(fmt.Sprintf("Signed proposal block: %v", block))
  187. } else if !lazyNodeState.replayMode {
  188. lazyNodeState.Logger.Error("enterPropose: Error signing proposal", "height", height, "round", round, "err", err)
  189. }
  190. }
  191. for _, reactor := range rts.reactors {
  192. state := reactor.state.GetState()
  193. reactor.SwitchToConsensus(state, false)
  194. }
  195. // Evidence should be submitted and committed at the third height but
  196. // we will check the first six just in case
  197. evidenceFromEachValidator := make([]types.Evidence, nValidators)
  198. wg := new(sync.WaitGroup)
  199. i := 0
  200. for _, sub := range rts.subs {
  201. wg.Add(1)
  202. go func(j int, s types.Subscription) {
  203. defer wg.Done()
  204. for {
  205. select {
  206. case msg := <-s.Out():
  207. require.NotNil(t, msg)
  208. block := msg.Data().(types.EventDataNewBlock).Block
  209. if len(block.Evidence.Evidence) != 0 {
  210. evidenceFromEachValidator[j] = block.Evidence.Evidence[0]
  211. return
  212. }
  213. case <-s.Canceled():
  214. require.Fail(t, "subscription failed for %d", j)
  215. return
  216. }
  217. }
  218. }(i, sub)
  219. i++
  220. }
  221. wg.Wait()
  222. pubkey, err := bzNodeState.privValidator.GetPubKey(context.Background())
  223. require.NoError(t, err)
  224. for idx, ev := range evidenceFromEachValidator {
  225. if assert.NotNil(t, ev, idx) {
  226. ev, ok := ev.(*types.DuplicateVoteEvidence)
  227. assert.True(t, ok)
  228. assert.Equal(t, pubkey.Address(), ev.VoteA.ValidatorAddress)
  229. assert.Equal(t, prevoteHeight, ev.Height())
  230. }
  231. }
  232. }
  233. // 4 validators. 1 is byzantine. The other three are partitioned into A (1 val) and B (2 vals).
  234. // byzantine validator sends conflicting proposals into A and B,
  235. // and prevotes/precommits on both of them.
  236. // B sees a commit, A doesn't.
  237. // Heal partition and ensure A sees the commit
  238. func TestByzantineConflictingProposalsWithPartition(t *testing.T) {
  239. // TODO: https://github.com/tendermint/tendermint/issues/6092
  240. t.SkipNow()
  241. // n := 4
  242. // logger := consensusLogger().With("test", "byzantine")
  243. // app := newCounter
  244. // states, cleanup := randConsensusState(n, "consensus_byzantine_test", newMockTickerFunc(false), app)
  245. // t.Cleanup(cleanup)
  246. // // give the byzantine validator a normal ticker
  247. // ticker := NewTimeoutTicker()
  248. // ticker.SetLogger(states[0].Logger)
  249. // states[0].SetTimeoutTicker(ticker)
  250. // p2pLogger := logger.With("module", "p2p")
  251. // blocksSubs := make([]types.Subscription, n)
  252. // reactors := make([]p2p.Reactor, n)
  253. // for i := 0; i < n; i++ {
  254. // // enable txs so we can create different proposals
  255. // assertMempool(states[i].txNotifier).EnableTxsAvailable()
  256. // eventBus := states[i].eventBus
  257. // eventBus.SetLogger(logger.With("module", "events", "validator", i))
  258. // var err error
  259. // blocksSubs[i], err = eventBus.Subscribe(context.Background(), testSubscriber, types.EventQueryNewBlock)
  260. // require.NoError(t, err)
  261. // conR := NewReactor(states[i], true) // so we don't start the consensus states
  262. // conR.SetLogger(logger.With("validator", i))
  263. // conR.SetEventBus(eventBus)
  264. // var conRI p2p.Reactor = conR
  265. // // make first val byzantine
  266. // if i == 0 {
  267. // conRI = NewByzantineReactor(conR)
  268. // }
  269. // reactors[i] = conRI
  270. // err = states[i].blockExec.Store().Save(states[i].state) // for save height 1's validators info
  271. // require.NoError(t, err)
  272. // }
  273. // switches := p2p.MakeConnectedSwitches(config.P2P, N, func(i int, sw *p2p.Switch) *p2p.Switch {
  274. // sw.SetLogger(p2pLogger.With("validator", i))
  275. // sw.AddReactor("CONSENSUS", reactors[i])
  276. // return sw
  277. // }, func(sws []*p2p.Switch, i, j int) {
  278. // // the network starts partitioned with globally active adversary
  279. // if i != 0 {
  280. // return
  281. // }
  282. // p2p.Connect2Switches(sws, i, j)
  283. // })
  284. // // make first val byzantine
  285. // // NOTE: Now, test validators are MockPV, which by default doesn't
  286. // // do any safety checks.
  287. // states[0].privValidator.(types.MockPV).DisableChecks()
  288. // states[0].decideProposal = func(j int32) func(int64, int32) {
  289. // return func(height int64, round int32) {
  290. // byzantineDecideProposalFunc(t, height, round, states[j], switches[j])
  291. // }
  292. // }(int32(0))
  293. // // We are setting the prevote function to do nothing because the prevoting
  294. // // and precommitting are done alongside the proposal.
  295. // states[0].doPrevote = func(height int64, round int32) {}
  296. // defer func() {
  297. // for _, sw := range switches {
  298. // err := sw.Stop()
  299. // require.NoError(t, err)
  300. // }
  301. // }()
  302. // // start the non-byz state machines.
  303. // // note these must be started before the byz
  304. // for i := 1; i < n; i++ {
  305. // cr := reactors[i].(*Reactor)
  306. // cr.SwitchToConsensus(cr.conS.GetState(), false)
  307. // }
  308. // // start the byzantine state machine
  309. // byzR := reactors[0].(*ByzantineReactor)
  310. // s := byzR.reactor.conS.GetState()
  311. // byzR.reactor.SwitchToConsensus(s, false)
  312. // // byz proposer sends one block to peers[0]
  313. // // and the other block to peers[1] and peers[2].
  314. // // note peers and switches order don't match.
  315. // peers := switches[0].Peers().List()
  316. // // partition A
  317. // ind0 := getSwitchIndex(switches, peers[0])
  318. // // partition B
  319. // ind1 := getSwitchIndex(switches, peers[1])
  320. // ind2 := getSwitchIndex(switches, peers[2])
  321. // p2p.Connect2Switches(switches, ind1, ind2)
  322. // // wait for someone in the big partition (B) to make a block
  323. // <-blocksSubs[ind2].Out()
  324. // t.Log("A block has been committed. Healing partition")
  325. // p2p.Connect2Switches(switches, ind0, ind1)
  326. // p2p.Connect2Switches(switches, ind0, ind2)
  327. // // wait till everyone makes the first new block
  328. // // (one of them already has)
  329. // wg := new(sync.WaitGroup)
  330. // for i := 1; i < N-1; i++ {
  331. // wg.Add(1)
  332. // go func(j int) {
  333. // <-blocksSubs[j].Out()
  334. // wg.Done()
  335. // }(i)
  336. // }
  337. // done := make(chan struct{})
  338. // go func() {
  339. // wg.Wait()
  340. // close(done)
  341. // }()
  342. // tick := time.NewTicker(time.Second * 10)
  343. // select {
  344. // case <-done:
  345. // case <-tick.C:
  346. // for i, reactor := range reactors {
  347. // t.Log(fmt.Sprintf("Consensus Reactor %v", i))
  348. // t.Log(fmt.Sprintf("%v", reactor))
  349. // }
  350. // t.Fatalf("Timed out waiting for all validators to commit first block")
  351. // }
  352. }
  353. // func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *State, sw *p2p.Switch) {
  354. // // byzantine user should create two proposals and try to split the vote.
  355. // // Avoid sending on internalMsgQueue and running consensus state.
  356. // // Create a new proposal block from state/txs from the mempool.
  357. // block1, blockParts1 := cs.createProposalBlock()
  358. // polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartSetHeader: blockParts1.Header()}
  359. // proposal1 := types.NewProposal(height, round, polRound, propBlockID)
  360. // p1 := proposal1.ToProto()
  361. // if err := cs.privValidator.SignProposal(cs.state.ChainID, p1); err != nil {
  362. // t.Error(err)
  363. // }
  364. // proposal1.Signature = p1.Signature
  365. // // some new transactions come in (this ensures that the proposals are different)
  366. // deliverTxsRange(cs, 0, 1)
  367. // // Create a new proposal block from state/txs from the mempool.
  368. // block2, blockParts2 := cs.createProposalBlock()
  369. // polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartSetHeader: blockParts2.Header()}
  370. // proposal2 := types.NewProposal(height, round, polRound, propBlockID)
  371. // p2 := proposal2.ToProto()
  372. // if err := cs.privValidator.SignProposal(cs.state.ChainID, p2); err != nil {
  373. // t.Error(err)
  374. // }
  375. // proposal2.Signature = p2.Signature
  376. // block1Hash := block1.Hash()
  377. // block2Hash := block2.Hash()
  378. // // broadcast conflicting proposals/block parts to peers
  379. // peers := sw.Peers().List()
  380. // t.Logf("Byzantine: broadcasting conflicting proposals to %d peers", len(peers))
  381. // for i, peer := range peers {
  382. // if i < len(peers)/2 {
  383. // go sendProposalAndParts(height, round, cs, peer, proposal1, block1Hash, blockParts1)
  384. // } else {
  385. // go sendProposalAndParts(height, round, cs, peer, proposal2, block2Hash, blockParts2)
  386. // }
  387. // }
  388. // }
  389. // func sendProposalAndParts(
  390. // height int64,
  391. // round int32,
  392. // cs *State,
  393. // peer p2p.Peer,
  394. // proposal *types.Proposal,
  395. // blockHash []byte,
  396. // parts *types.PartSet,
  397. // ) {
  398. // // proposal
  399. // msg := &ProposalMessage{Proposal: proposal}
  400. // peer.Send(DataChannel, MustEncode(msg))
  401. // // parts
  402. // for i := 0; i < int(parts.Total()); i++ {
  403. // part := parts.GetPart(i)
  404. // msg := &BlockPartMessage{
  405. // Height: height, // This tells peer that this part applies to us.
  406. // Round: round, // This tells peer that this part applies to us.
  407. // Part: part,
  408. // }
  409. // peer.Send(DataChannel, MustEncode(msg))
  410. // }
  411. // // votes
  412. // cs.mtx.Lock()
  413. // prevote, _ := cs.signVote(tmproto.PrevoteType, blockHash, parts.Header())
  414. // precommit, _ := cs.signVote(tmproto.PrecommitType, blockHash, parts.Header())
  415. // cs.mtx.Unlock()
  416. // peer.Send(VoteChannel, MustEncode(&VoteMessage{prevote}))
  417. // peer.Send(VoteChannel, MustEncode(&VoteMessage{precommit}))
  418. // }
  419. // type ByzantineReactor struct {
  420. // service.Service
  421. // reactor *Reactor
  422. // }
  423. // func NewByzantineReactor(conR *Reactor) *ByzantineReactor {
  424. // return &ByzantineReactor{
  425. // Service: conR,
  426. // reactor: conR,
  427. // }
  428. // }
  429. // func (br *ByzantineReactor) SetSwitch(s *p2p.Switch) { br.reactor.SetSwitch(s) }
  430. // func (br *ByzantineReactor) GetChannels() []*p2p.ChannelDescriptor { return br.reactor.GetChannels() }
  431. // func (br *ByzantineReactor) AddPeer(peer p2p.Peer) {
  432. // if !br.reactor.IsRunning() {
  433. // return
  434. // }
  435. // // Create peerState for peer
  436. // peerState := NewPeerState(peer).SetLogger(br.reactor.Logger)
  437. // peer.Set(types.PeerStateKey, peerState)
  438. // // Send our state to peer.
  439. // // If we're syncing, broadcast a RoundStepMessage later upon SwitchToConsensus().
  440. // if !br.reactor.waitSync {
  441. // br.reactor.sendNewRoundStepMessage(peer)
  442. // }
  443. // }
  444. // func (br *ByzantineReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
  445. // br.reactor.RemovePeer(peer, reason)
  446. // }
  447. // func (br *ByzantineReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
  448. // br.reactor.Receive(chID, peer, msgBytes)
  449. // }
  450. // func (br *ByzantineReactor) InitPeer(peer p2p.Peer) p2p.Peer { return peer }