// PutValue adds value corresponding to given Key. // This is the top level "Store" operation of the DHT func (dht *IpfsDHT) PutValue(ctx context.Context, key u.Key, value []byte) error { log.Debugf("PutValue %s", key) err := dht.putLocal(key, value) if err != nil { return err } rec, err := dht.makePutRecord(key, value) if err != nil { log.Error("Creation of record failed!") return err } var peers []peer.Peer for _, route := range dht.routingTables { npeers := route.NearestPeers(kb.ConvertKey(key), KValue) peers = append(peers, npeers...) } query := newQuery(key, dht.dialer, func(ctx context.Context, p peer.Peer) (*dhtQueryResult, error) { log.Debugf("%s PutValue qry part %v", dht.self, p) err := dht.putValueToNetwork(ctx, p, string(key), rec) if err != nil { return nil, err } return &dhtQueryResult{success: true}, nil }) _, err = query.Run(ctx, peers) return err }
func (dht *IpfsDHT) FindProvidersAsync(ctx context.Context, key u.Key, count int) <-chan peer.Peer { peerOut := make(chan peer.Peer, count) go func() { ps := newPeerSet() provs := dht.providers.GetProviders(key) for _, p := range provs { count-- // NOTE: assuming that this list of peers is unique ps.Add(p) peerOut <- p if count <= 0 { return } } wg := new(sync.WaitGroup) peers := dht.routingTables[0].NearestPeers(kb.ConvertKey(key), AlphaValue) for _, pp := range peers { wg.Add(1) go func(p peer.Peer) { defer wg.Done() pmes, err := dht.findProvidersSingle(ctx, p, key, 0) if err != nil { log.Error(err) return } dht.addPeerListAsync(ctx, key, pmes.GetProviderPeers(), ps, count, peerOut) }(pp) } wg.Wait() close(peerOut) }() return peerOut }
// nearestPeersToQuery returns the routing tables closest peers. func (dht *IpfsDHT) nearestPeersToQuery(pmes *pb.Message, count int) []peer.Peer { level := pmes.GetClusterLevel() cluster := dht.routingTables[level] key := u.Key(pmes.GetKey()) closer := cluster.NearestPeers(kb.ConvertKey(key), count) return closer }
// GetValue searches for the value corresponding to given Key. // If the search does not succeed, a multiaddr string of a closer peer is // returned along with util.ErrSearchIncomplete func (dht *IpfsDHT) GetValue(ctx context.Context, key u.Key) ([]byte, error) { log.Debugf("Get Value [%s]", key) // If we have it local, dont bother doing an RPC! // NOTE: this might not be what we want to do... val, err := dht.getLocal(key) if err == nil { log.Debug("Got value locally!") return val, nil } // get closest peers in the routing tables routeLevel := 0 closest := dht.routingTables[routeLevel].NearestPeers(kb.ConvertKey(key), PoolSize) if closest == nil || len(closest) == 0 { log.Warning("Got no peers back from routing table!") return nil, kb.ErrLookupFailure } // setup the Query query := newQuery(key, dht.dialer, func(ctx context.Context, p peer.Peer) (*dhtQueryResult, error) { val, peers, err := dht.getValueOrPeers(ctx, p, key, routeLevel) if err != nil { return nil, err } res := &dhtQueryResult{value: val, closerPeers: peers} if val != nil { res.success = true } return res, nil }) // run it! result, err := query.Run(ctx, closest) if err != nil { return nil, err } log.Debugf("GetValue %v %v", key, result.value) if result.value == nil { return nil, routing.ErrNotFound } return result.value, nil }
// Provide makes this node announce that it can provide a value for the given key func (dht *IpfsDHT) Provide(ctx context.Context, key u.Key) error { dht.providers.AddProvider(key, dht.self) peers := dht.routingTables[0].NearestPeers(kb.ConvertKey(key), PoolSize) if len(peers) == 0 { return nil } //TODO FIX: this doesn't work! it needs to be sent to the actual nearest peers. // `peers` are the closest peers we have, not the ones that should get the value. for _, p := range peers { err := dht.putProvider(ctx, p, string(key)) if err != nil { return err } } return nil }
// PingRoutine periodically pings nearest neighbors. func (dht *IpfsDHT) PingRoutine(t time.Duration) { defer dht.Children().Done() tick := time.Tick(t) for { select { case <-tick: id := make([]byte, 16) rand.Read(id) peers := dht.routingTables[0].NearestPeers(kb.ConvertKey(u.Key(id)), 5) for _, p := range peers { ctx, _ := context.WithTimeout(dht.Context(), time.Second*5) err := dht.Ping(ctx, p) if err != nil { log.Errorf("Ping error: %s", err) } } case <-dht.Closing(): return } } }