package main
import (
"crypto/sha256"
"fmt"
"sort"
)
const (
BucketSize = 3 // 每个 bucket 的最大容量
IdSize = 32 // ID 的大小，字节数（改为了32）
MaxPeers = 100
)
type Node struct {
id [IdSize]byte // 节点的 ID，长度为 IdSize
data string // 节点存储的数据
dht map[[32]byte][]byte // DHT 结构体，保存键值对（修改为 [32]byte 类型）
peers []*Peer // 保存其他节点信息（Peer对象）
}
type Peer struct {
dht *Node
}
type Bucket struct {
nodes []Node // 节点列表
}
type KBucket struct {
buckets [IdSize * 8]*Bucket // K-Bucket 中存放 bucket 的数组
selfId [IdSize]byte // 自身节点的 ID
maxNodes int // 每个 bucket 的最大节点数量
}
func NewPeer(dht *Node) *Peer {
return &Peer{
dht: dht,
}
}
func NewNode() *Node {
node := &Node{
dht: make(map[[32]byte][]byte),
peers: make([]*Peer, 0, MaxPeers),
}
for i := 0; i < MaxPeers; i++ {
node.peers = append(node.peers, NewPeer(node))
}
return node
}
func (p *Peer) SetValue(key, value []byte) bool {
hash := sha256.Sum256(value)
if hash != key { // 修改了判断条件，使用 hash 和 key 进行比较
return false
}
p.dht[hash] = value // 修改为使用 hash 作为键进行存储
return true
}
func (p *Peer) GetValue(key [32]byte) []byte {
value, ok := p.dht[key]
if ok {
return value
}
return nil
}
func NewBucket() *Bucket {
return &Bucket{
nodes: make([]Node, 0, BucketSize), // 初始化节点列表，容量为 BUCKET_SIZE
}
}
// … 省略其他未修改的函数 …
func xor(a, b [IdSize]byte) [IdSize]byte {
var result [IdSize]byte
for i := 0; i < IdSize; i++ {
result[i] = a[i] ^ b[i]
}
return result
}
func compare(a, b [IdSize]byte) int {
for i := 0; i < IdSize; i++ {
if a[i] > b[i] {
return 1
} else if a[i] < b[i] {
return -1
}
}
return 0
}
func (kb *KBucket) getClosestPeers(targetId [IdSize]byte, numPeers int) []*Peer {
// 获取距离目标 ID 最近的 numPeers 个节点
type peerDistance struct { // 使用结构体代替匿名结构体，方便后续代码阅读和扩展字段
peer *Peer
distance [IdSize]byte
}
peerDistances := make([]peerDistance, 0, len(kb.peers))
for _, peer := range kb.peers {
distance := xor(peer.dht.id, targetId)
peerDistances = append(peerDistances, peerDistance{
peer: peer,
distance: distance,
})
}
sort.Slice(peerDistances, func(i, j int) bool {
// 修改比较函数，使用 compare 函数进行距离大小的比较
return compare(peerDistances[i].distance, peerDistances[j].distance) < 0
})
result := make([]*Peer, 0, numPeers)
for i := 0; i < numPeers && i < len(peerDistances); i++ {
result = append(result, peerDistances[i].peer)
}
return result
}
func (p *Peer) SetValueOptimized(key, value []byte) bool {
hash := sha256.Sum256(value)
if hash != key { // 修改了判断条件，使用 hash 和 key 进行比较
return false
}
p.dht[hash] = value
closestPeers := p.dht.getClosestPeers(hash, 2)
for _, peer := range closestPeers {
// 修改为使用 hash 进行传递键值对
peer.SetValue(hash, value)
}
return true
}
func (p *Peer) GetValueOptimized(key [32]byte) []byte {
value, ok := p.dht[key]
if ok {
return value
}
closestPeers := p.dht.getClosestPeers(key, 2)
for _, peer := range closestPeers {
// 修改为使用 hash 进行获取键值对的操作
value := peer.GetValue(key)
if value != nil {
return value
}
}
return nil
}
func main() {
node := NewNode() // 创建一个节点
peer := node.peers[0] // 获取节点中的第一个 Peer
// 设置键值对
key := sha256.Sum256([]byte("hello"))
value := []byte("hello")
// 使用 SetValueOptimized 进行设置
peer.SetValueOptimized(key[:], value)
// 获取键值对
result := peer.GetValueOptimized(key)
fmt.Printf("获取到的值为: %s\n", string(result))
}
res.jsonValue["History"]..." />
res.jsonValue["History"];
..." />
