以太坊節點廣播block的時候一部分節點廣播整個block內容，其餘節點廣播block的hash，

本篇分析一下節點收到block hash後的處理

1. case msg.Code == NewBlockHashesMsg:  

2.     var announces newBlockHashesData  

3.     if err := msg.Decode(&announces); err != nil {  

4.     return errResp(ErrDecode, "%v: %v", msg, err)  

5.     }  

6.     // Mark the hashes as present at the remote node  

7.     for _, block := range announces {  

8.     p.MarkBlock(block.Hash)  

9.     }  

10.     // Schedule all the unknown hashes for retrieval  

11.     unknown := make(newBlockHashesData, 0, len(announces))  

12.     for _, block := range announces {  

13.     if !pm.blockchain.HasBlock(block.Hash, block.Number) {  

14.         unknown = append(unknown, block)  

15.     }  

16.     }  

17.     for _, block := range unknown {  

18.     pm.fetcher.Notify(p.id, block.Hash, block.Number, time.Now(), p.RequestOneHeader, p.RequestBodies)  

19.     }  

收到訊息後：

1 遍歷收到的block hashes，mark下對端節點擁有此block

2 再遍歷收到的hashes，與本地對比看是否已有該block，沒有的append到unknown

3 遍歷unknown，然後呼叫fetcher的Notify，帶hash，block num，request header函式和request body函式

[plain]

1. func (f *Fetcher) Notify(peer string, hash common.Hash, number uint64, time time.Time,  

2.     headerFetcher headerRequesterFn, bodyFetcher bodyRequesterFn) error {  

3.     block := &announce{  

4.         hash:        hash,  

5.         number:      number,  

6.         time:        time,  

7.         origin:      peer,  

8.         fetchHeader: headerFetcher,  

9.         fetchBodies: bodyFetcher,  

10.     }  

11.     select {  

12.     case f.notify 

13.         return nil  

14.     case 

15.         return errTerminated  

16.     }  

17. }  

Notify做的事情也很簡單，new了一個announce結構，然後寫到channel notify，實現了notify的作用，想必是有個地方一直在監聽notify channel做事情，找到監聽notify的地方

1. func (f *Fetcher) loop() {  

2.     // Iterate the block fetching until a quit is requested  

3.     fetchTimer := time.NewTimer(0)  

4.     completeTimer := time.NewTimer(0)  

5.   

6.     for {  

7.         // Clean up any expired block fetches  

8.         for hash, announce := range f.fetching {  

9.             if time.Since(announce.time) > fetchTimeout {  

10.                 f.forgetHash(hash)  

11.             }  

12.         }  

13.         // Import any queued blocks that could potentially fit  

14.         height := f.chainHeight()  

15.         for !f.queue.Empty() {  

16.             op := f.queue.PopItem().(*inject)  

17.             if f.queueChangeHook != nil {  

18.                 f.queueChangeHook(op.block.Hash(), false)  

19.             }  

20.             // If too high up the chain or phase, continue later  

21.             number := op.block.NumberU64()  

22.             if number > height+1 {  

23.                 f.queue.Push(op, -float32(op.block.NumberU64()))  

24.                 if f.queueChangeHook != nil {  

25.                     f.queueChangeHook(op.block.Hash(), true)  

26.                 }  

27.                 break  

28.             }  

29.             // Otherwise if fresh and still unknown, try and import  

30.             hash := op.block.Hash()  

31.             if number+maxUncleDist 

32.                 f.forgetBlock(hash)  

33.                 continue  

34.             }  

35.             f.insert(op.origin, op.block)  

36.         }  

37.         // Wait for an outside event to occur  

38.         select {  

39.         case 

40.             // Fetcher terminating, abort all operations  

41.             return  

42.   

43.         case notification := 

44.             // A block was announced, make sure the peer isn't DOSing us  

45.             propAnnounceInMeter.Mark(1)  

46.   

47.             count := f.announces[notification.origin] + 1  

48.             if count > hashLimit {  

49.                 log.Debug("Peer exceeded outstanding announces", "peer", notification.origin, "limit", hashLimit)  

50.                 propAnnounceDOSMeter.Mark(1)  

51.                 break  

52.             }  

53.             // If we have a valid block number, check that it's potentially useful  

54.             if notification.number > 0 {  

55.                 if dist := int64(notification.number) - int64(f.chainHeight()); dist  maxQueueDist {  

56.                     log.Debug("Peer discarded announcement", "peer", notification.origin, "number", notification.number, "hash", notification.hash, "distance", dist)  

57.                     propAnnounceDropMeter.Mark(1)  

58.                     break  

59.                 }  

60.             }  

61.             // All is well, schedule the announce if block's not yet downloading  

62.             if _, ok := f.fetching[notification.hash]; ok {  

63.                 break  

64.             }  

65.             if _, ok := f.completing[notification.hash]; ok {  

66.                 break  

67.             }  

68.             f.announces[notification.origin] = count  

69.             f.announced[notification.hash] = append(f.announced[notification.hash], notification)  

70.             if f.announceChangeHook != nil && len(f.announced[notification.hash]) == 1 {  

71.                 f.announceChangeHook(notification.hash, true)  

72.             }  

73.             if len(f.announced) == 1 {  

74.                 f.rescheduleFetch(fetchTimer)  

75.             }  

76.   

77.         case op := 

78.             // A direct block insertion was requested, try and fill any pending gaps  

79.             propBroadcastInMeter.Mark(1)  

80.             f.enqueue(op.origin, op.block)  

81.   

82.         case hash := 

83.             // A pending import finished, remove all traces of the notification  

84.             f.forgetHash(hash)  

85.             f.forgetBlock(hash)  

86.   

87.         case 

88.             // At least one block's timer ran out, check for needing retrieval  

89.             request := make(map[string][]common.Hash)  

90.   

91.             for hash, announces := range f.announced {  

92.                 if time.Since(announces[0].time) > arriveTimeout-gatherSlack {  

93.                     // Pick a random peer to retrieve from, reset all others  

94.                     announce := announces[rand.Intn(len(announces))]  

95.                     f.forgetHash(hash)  

96.   

97.                     // If the block still didn't arrive, queue for fetching  

98.                     if f.getBlock(hash) == nil {  

99.                         request[announce.origin] = append(request[announce.origin], hash)  

100.                         f.fetching[hash] = announce  

101.                     }  

102.                 }  

103.             }  

104.             // Send out all block header requests  

105.             for peer, hashes := range request {  

106.                 log.Trace("Fetching scheduled headers", "peer", peer, "list", hashes)  

107.   

108.                 // Create a closure of the fetch and schedule in on a new thread  

109.                 fetchHeader, hashes := f.fetching[hashes[0]].fetchHeader, hashes  

110.                 go func() {  

111.                     if f.fetchingHook != nil {  

112.                         f.fetchingHook(hashes)  

113.                     }  

114.                     for _, hash := range hashes {  

115.                         headerFetchMeter.Mark(1)  

116.                         fetchHeader(hash) // Suboptimal, but protocol doesn't allow batch header retrievals  

117.                     }  

118.                 }()  

119.             }  

120.             // Schedule the next fetch if blocks are still pending  

121.             f.rescheduleFetch(fetchTimer)  

122.   

123.         case 

124.             // At least one header's timer ran out, retrieve everything  

125.             request := make(map[string][]common.Hash)  

126.   

127.             for hash, announces := range f.fetched {  

128.                 // Pick a random peer to retrieve from, reset all others  

129.                 announce := announces[rand.Intn(len(announces))]  

130.                 f.forgetHash(hash)  

131.   

132.                 // If the block still didn't arrive, queue for completion  

133.                 if f.getBlock(hash) == nil {  

134.                     request[announce.origin] = append(request[announce.origin], hash)  

135.                     f.completing[hash] = announce  

136.                 }  

137.             }  

138.             // Send out all block body requests  

139.             for peer, hashes := range request {  

140.                 log.Trace("Fetching scheduled bodies", "peer", peer, "list", hashes)  

141.   

142.                 // Create a closure of the fetch and schedule in on a new thread  

143.                 if f.completingHook != nil {  

144.                     f.completingHook(hashes)  

145.                 }  

146.                 bodyFetchMeter.Mark(int64(len(hashes)))  

147.                 go f.completing[hashes[0]].fetchBodies(hashes)  

148.             }  

149.             // Schedule the next fetch if blocks are still pending  

150.             f.rescheduleComplete(completeTimer)  

151.   

152.         case filter := 

153.             // Headers arrived from a remote peer. Extract those that were explicitly  

154.             // requested by the fetcher, and return everything else so it's delivered  

155.             // to other parts of the system.  

156.             var task *headerFilterTask  

157.             select {  

158.             case task = 

159.             case 

160.                 return  

161.             }  

162.             headerFilterInMeter.Mark(int64(len(task.headers)))  

163.   

164.             // Split the batch of headers into unknown ones (to return to the caller),  

165.             // known incomplete ones (requiring body retrievals) and completed blocks.  

166.             unknown, incomplete, complete := []*types.Header{}, []*announce{}, []*types.Block{}  

167.             for _, header := range task.headers {  

168.                 hash := header.Hash()  

169.   

170.                 // Filter fetcher-requested headers from other synchronisation algorithms  

171.                 if announce := f.fetching[hash]; announce != nil && announce.origin == task.peer && f.fetched[hash] == nil && f.completing[hash] == nil && f.queued[hash] == nil {  

172.                     // If the delivered header does not match the promised number, drop the announcer  

173.                     if header.Number.Uint64() != announce.number {  

174.                         log.Trace("Invalid block number fetched", "peer", announce.origin, "hash", header.Hash(), "announced", announce.number, "provided", header.Number)  

175.                         f.dropPeer(announce.origin)  

176.                         f.forgetHash(hash)  

177.                         continue  

178.                     }  

179.                     // Only keep if not imported by other means  

180.                     if f.getBlock(hash) == nil {  

181.                         announce.header = header  

182.                         announce.time = task.time  

183.   

184.                         // If the block is empty (header only), short circuit into the final import queue  

185.                         if header.TxHash == types.DeriveSha(types.Transactions{}) && header.UncleHash == types.CalcUncleHash([]*types.Header{}) {  

186.                             log.Trace("Block empty, skipping body retrieval", "peer", announce.origin, "number", header.Number, "hash", header.Hash())  

187.   

188.                             block := types.NewBlockWithHeader(header)  

189.                             block.ReceivedAt = task.time  

190.   

191.                             complete = append(complete, block)  

192.                             f.completing[hash] = announce  

193.                             continue  

194.                         }  

195.                         // Otherwise add to the list of blocks needing completion  

196.                         incomplete = append(incomplete, announce)  

197.                     } else {  

198.                         log.Trace("Block already imported, discarding header", "peer", announce.origin, "number", header.Number, "hash", header.Hash())  

199.                         f.forgetHash(hash)  

200.                     }  

201.                 } else {  

202.                     // Fetcher doesn't know about it, add to the return list  

203.                     unknown = append(unknown, header)  

204.                 }  

205.             }  

206.             headerFilterOutMeter.Mark(int64(len(unknown)))  

207.             select {  

208.             case filter 

209.             case 

210.                 return  

211.             }  

212.             // Schedule the retrieved headers for body completion  

213.             for _, announce := range incomplete {  

214.                 hash := announce.header.Hash()  

215.                 if _, ok := f.completing[hash]; ok {  

216.                     continue  

217.                 }  

218.                 f.fetched[hash] = append(f.fetched[hash], announce)  

219.                 if len(f.fetched) == 1 {  

220.                     f.rescheduleComplete(completeTimer)  

221.                 }  

222.             }  

223.             // Schedule the header-only blocks for import  

224.             for _, block := range complete {  

225.                 if announce := f.completing[block.Hash()]; announce != nil {  

226.                     f.enqueue(announce.origin, block)  

227.                 }  

228.             }  

229.   

230.         case filter := 

231.             // Block bodies arrived, extract any explicitly requested blocks, return the rest  

232.             var task *bodyFilterTask  

233.             select {  

234.             case task = 

235.             case 

236.                 return  

237.             }  

238.             bodyFilterInMeter.Mark(int64(len(task.transactions)))  

239.   

240.             blocks := []*types.Block{}  

241.             for i := 0; i 

242.                 // Match up a body to any possible completion request  

243.                 matched := false  

244.   

245.                 for hash, announce := range f.completing {  

246.                     if f.queued[hash] == nil {  

247.                         txnHash := types.DeriveSha(types.Transactions(task.transactions[i]))  

248.                         uncleHash := types.CalcUncleHash(task.uncles[i])  

249.   

250.                         if txnHash == announce.header.TxHash && uncleHash == announce.header.UncleHash && announce.origin == task.peer {  

251.                             // Mark the body matched, reassemble if still unknown  

252.                             matched = true  

253.   

254.                             if f.getBlock(hash) == nil {  

255.                                 block := types.NewBlockWithHeader(announce.header).WithBody(task.transactions[i], task.uncles[i])  

256.                                 block.ReceivedAt = task.time  

257.   

258.                                 blocks = append(blocks, block)  

259.                             } else {  

260.                                 f.forgetHash(hash)  

261.                             }  

262.                         }  

263.                     }  

264.                 }  

265.                 if matched {  

266.                     task.transactions = append(task.transactions[:i], task.transactions[i+1:]...)  

267.                     task.uncles = append(task.uncles[:i], task.uncles[i+1:]...)  

268.                     i--  

269.                     continue  

270.                 }  

271.             }  

272.   

273.             bodyFilterOutMeter.Mark(int64(len(task.transactions)))  

274.             select {  

275.             case filter 

276.             case 

277.                 return  

278.             }  

279.             // Schedule the retrieved blocks for ordered import  

280.             for _, block := range blocks {  

281.                 if announce := f.completing[block.Hash()]; announce != nil {  

282.                     f.enqueue(announce.origin, block)  

283.                 }  

284.             }  

285.         }  

286.     }  

287. }