Bytom的P2P网络地址簿结构体是怎样的
这篇文章主要讲解了“Bytom的P2P网络地址簿结构体是怎样的”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Bytom的P2P网络地址簿结构体是怎样的”吧！
成都创新互联主营庆元网站建设的网络公司,主营网站建设方案,app软件开发公司,庆元h5重庆小程序开发搭建,庆元网站营销推广欢迎庆元等地区企业咨询
addrbook介绍
addrbook用于存储P2P网络中保留最近的对端节点地址 在MacOS下，默认的地址簿路径存储在~/Library/Bytom/addrbook.json
地址簿格式
** ~/Library/Bytom/addrbook.json **
{
"Key": "359be6d08bc0c6e21c84bbb2",
"Addrs": [
{
"Addr": {
"IP": "122.224.11.144",
"Port": 46657
},
"Src": {
"IP": "198.74.61.131",
"Port": 46657
},
"Attempts": 0,
"LastAttempt": "2018-05-04T12:58:23.894057702+08:00",
"LastSuccess": "0001-01-01T00:00:00Z",
"BucketType": 1,
"Buckets": [
181,
10
]
}
]
}地址类型
在addrbook中存储的地址有两种： ** p2p/addrbook.go **
const ( bucketTypeNew = 0x01 // 标识新地址，不可靠地址（未成功连接过）。只存储在一个bucket中 bucketTypeOld = 0x02 // 标识旧地址，可靠地址（已成功连接过）。可以存储在多个bucket中，最多为maxNewBucketsPerAddress个 )
注意: 一个地址的类型变更不在此文章中做介绍，后期的文章会讨论该问题
地址簿相关结构体
地址簿
type AddrBook struct {
cmn.BaseService
mtx sync.Mutex
filePath string // 地址簿路径
routabilityStrict bool // 是否可路由，默认为true
rand *rand.Rand
key string // 地址簿标识，用于计算addrNew和addrOld的索引
ourAddrs map[string]*NetAddress // 存储本地网络地址，用于添加p2p地址时做排除使用
addrLookup map[string]*knownAddress // 存储新、旧地址集，用于查询
addrNew []map[string]*knownAddress // 存储新地址
addrOld []map[string]*knownAddress // 存储旧地址
wg sync.WaitGroup
nOld int // 旧地址数量
nNew int // 新地址数量
}已知地址
type knownAddress struct {
Addr *NetAddress // 已知peer的addr
Src *NetAddress // 已知peer的addr的来源addr
Attempts int32 // 连接peer的重试次数
LastAttempt time.Time // 最近一次尝试连接的时间
LastSuccess time.Time // 最近一次尝试成功连接的时间
BucketType byte // 地址的类型（表示可靠地址或不可靠地址）
Buckets []int // 当前addr所属的buckets
}routabilityStrict参数表示地址簿是否存储的ip是否可路由。可路由是根据RFC划分，具体参考资料：RFC标准
初始化地址簿
// NewAddrBook creates a new address book.
// Use Start to begin processing asynchronous address updates.
func NewAddrBook(filePath string, routabilityStrict bool) *AddrBook {
am := &AddrBook{
rand: rand.New(rand.NewSource(time.Now().UnixNano())),
ourAddrs: make(map[string]*NetAddress),
addrLookup: make(map[string]*knownAddress),
filePath: filePath,
routabilityStrict: routabilityStrict,
}
am.init()
am.BaseService = *cmn.NewBaseService(nil, "AddrBook", am)
return am
}
// When modifying this, don't forget to update loadFromFile()
func (a *AddrBook) init() {
// 地址簿唯一标识
a.key = crypto.CRandHex(24) // 24/2 * 8 = 96 bits
// New addr buckets， 默认为256个大小
a.addrNew = make([]map[string]*knownAddress, newBucketCount)
for i := range a.addrNew {
a.addrNew[i] = make(map[string]*knownAddress)
}
// Old addr buckets，默认为64个大小
a.addrOld = make([]map[string]*knownAddress, oldBucketCount)
for i := range a.addrOld {
a.addrOld[i] = make(map[string]*knownAddress)
}
}bytomd启动时加载本地地址簿
loadFromFile在bytomd启动时，首先会加载本地的地址簿
// OnStart implements Service.
func (a *AddrBook) OnStart() error {
a.BaseService.OnStart()
a.loadFromFile(a.filePath)
a.wg.Add(1)
go a.saveRoutine()
return nil
}
// Returns false if file does not exist.
// cmn.Panics if file is corrupt.
func (a *AddrBook) loadFromFile(filePath string) bool {
// If doesn't exist, do nothing.
// 如果本地地址簿不存在则直接返回
_, err := os.Stat(filePath)
if os.IsNotExist(err) {
return false
}
// 加载地址簿json内容
// Load addrBookJSON{}
r, err := os.Open(filePath)
if err != nil {
cmn.PanicCrisis(cmn.Fmt("Error opening file %s: %v", filePath, err))
}
defer r.Close()
aJSON := &addrBookJSON{}
dec := json.NewDecoder(r)
err = dec.Decode(aJSON)
if err != nil {
cmn.PanicCrisis(cmn.Fmt("Error reading file %s: %v", filePath, err))
}
// 填充addrNew、addrOld等
// Restore all the fields...
// Restore the key
a.key = aJSON.Key
// Restore .addrNew & .addrOld
for _, ka := range aJSON.Addrs {
for _, bucketIndex := range ka.Buckets {
bucket := a.getBucket(ka.BucketType, bucketIndex)
bucket[ka.Addr.String()] = ka
}
a.addrLookup[ka.Addr.String()] = ka
if ka.BucketType == bucketTypeNew {
a.nNew++
} else {
a.nOld++
}
}
return true
}定时更新地址簿
bytomd会定时更新本地地址簿，默认2分钟一次
func (a *AddrBook) saveRoutine() {
dumpAddressTicker := time.NewTicker(dumpAddressInterval)
out:
for {
select {
case <-dumpAddressTicker.C:
a.saveToFile(a.filePath)
case <-a.Quit:
break out
}
}
dumpAddressTicker.Stop()
a.saveToFile(a.filePath)
a.wg.Done()
log.Info("Address handler done")
}
func (a *AddrBook) saveToFile(filePath string) {
log.WithField("size", a.Size()).Info("Saving AddrBook to file")
a.mtx.Lock()
defer a.mtx.Unlock()
// Compile Addrs
addrs := []*knownAddress{}
for _, ka := range a.addrLookup {
addrs = append(addrs, ka)
}
aJSON := &addrBookJSON{
Key: a.key,
Addrs: addrs,
}
jsonBytes, err := json.MarshalIndent(aJSON, "", "\t")
if err != nil {
log.WithField("err", err).Error("Failed to save AddrBook to file")
return
}
err = cmn.WriteFileAtomic(filePath, jsonBytes, 0644)
if err != nil {
log.WithFields(log.Fields{
"file": filePath,
"err": err,
}).Error("Failed to save AddrBook to file")
}
}添加新地址
当peer之间交换addr时，节点会收到对端节点已知的地址信息，这些信息会被当前节点添加到地址簿中
func (a *AddrBook) AddAddress(addr *NetAddress, src *NetAddress) {
a.mtx.Lock()
defer a.mtx.Unlock()
log.WithFields(log.Fields{
"addr": addr,
"src": src,
}).Debug("Add address to book")
a.addAddress(addr, src)
}
func (a *AddrBook) addAddress(addr, src *NetAddress) {
// 验证地址是否为可路由地址
if a.routabilityStrict && !addr.Routable() {
log.Error(cmn.Fmt("Cannot add non-routable address %v", addr))
return
}
// 验证地址是否为本地节点地址
if _, ok := a.ourAddrs[addr.String()]; ok {
// Ignore our own listener address.
return
}
// 验证地址是否存在地址集中
// 如果存在：则判断该地址是否为old可靠地址、是否超过了最大buckets中。否则根据该地址已经被ka.Buckets引用的个数来随机决定是否添加到地址集中
// 如果不存在：则添加到地址集中。并标识为bucketTypeNew地址类型
ka := a.addrLookup[addr.String()]
if ka != nil {
// Already old.
if ka.isOld() {
return
}
// Already in max new buckets.
if len(ka.Buckets) == maxNewBucketsPerAddress {
return
}
// The more entries we have, the less likely we are to add more.
factor := int32(2 * len(ka.Buckets))
if a.rand.Int31n(factor) != 0 {
return
}
} else {
ka = newKnownAddress(addr, src)
}
// 找到该地址在地址集的索引位置并添加
bucket := a.calcNewBucket(addr, src)
a.addToNewBucket(ka, bucket)
log.Info("Added new address ", "address:", addr, " total:", a.size())
}选择最优节点
地址簿中存储众多地址，在p2p网络中需选择最优的地址去连接 PickAddress(newBias int)函数中newBias是由pex_reactor产生的地址评分。如何计算地址分数在其他章节中再讲 根据地址评分随机选择地址可增加区块链安全性
// Pick an address to connect to with new/old bias.
func (a *AddrBook) PickAddress(newBias int) *NetAddress {
a.mtx.Lock()
defer a.mtx.Unlock()
if a.size() == 0 {
return nil
}
// newBias地址分数限制在0-100分数之间
if newBias > 100 {
newBias = 100
}
if newBias < 0 {
newBias = 0
}
// Bias between new and old addresses.
oldCorrelation := math.Sqrt(float64(a.nOld)) * (100.0 - float64(newBias))
newCorrelation := math.Sqrt(float64(a.nNew)) * float64(newBias)
// 根据地址分数计算是否从addrOld或addrNew中随机选择一个地址
if (newCorrelation+oldCorrelation)*a.rand.Float64() < oldCorrelation {
// pick random Old bucket.
var bucket map[string]*knownAddress = nil
num := 0
for len(bucket) == 0 && num < oldBucketCount {
bucket = a.addrOld[a.rand.Intn(len(a.addrOld))]
num++
}
if num == oldBucketCount {
return nil
}
// pick a random ka from bucket.
randIndex := a.rand.Intn(len(bucket))
for _, ka := range bucket {
if randIndex == 0 {
return ka.Addr
}
randIndex--
}
cmn.PanicSanity("Should not happen")
} else {
// pick random New bucket.
var bucket map[string]*knownAddress = nil
num := 0
for len(bucket) == 0 && num < newBucketCount {
bucket = a.addrNew[a.rand.Intn(len(a.addrNew))]
num++
}
if num == newBucketCount {
return nil
}
// pick a random ka from bucket.
randIndex := a.rand.Intn(len(bucket))
for _, ka := range bucket {
if randIndex == 0 {
return ka.Addr
}
randIndex--
}
cmn.PanicSanity("Should not happen")
}
return nil
}移除一个地址
当一个地址被标记为Bad时则从地址集中移除。目前bytomd的代码版本并未调用过
func (a *AddrBook) MarkBad(addr *NetAddress) {
a.RemoveAddress(addr)
}
// RemoveAddress removes the address from the book.
func (a *AddrBook) RemoveAddress(addr *NetAddress) {
a.mtx.Lock()
defer a.mtx.Unlock()
ka := a.addrLookup[addr.String()]
if ka == nil {
return
}
log.WithField("addr", addr).Info("Remove address from book")
a.removeFromAllBuckets(ka)
}
func (a *AddrBook) removeFromAllBuckets(ka *knownAddress) {
for _, bucketIdx := range ka.Buckets {
bucket := a.getBucket(ka.BucketType, bucketIdx)
delete(bucket, ka.Addr.String())
}
ka.Buckets = nil
if ka.BucketType == bucketTypeNew {
a.nNew--
} else {
a.nOld--
}
delete(a.addrLookup, ka.Addr.String())
}感谢各位的阅读，以上就是“Bytom的P2P网络地址簿结构体是怎样的”的内容了，经过本文的学习后，相信大家对Bytom的P2P网络地址簿结构体是怎样的这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是创新互联，小编将为大家推送更多相关知识点的文章，欢迎关注！
本文题目：Bytom的P2P网络地址簿结构体是怎样的
分享地址：http://azwzsj.com/article/gecpis.html
