Prepared for integration test.v0.1.32

1 files changed, 27 insertions, 31 deletions

diff --git a/src/gnunet/service/dht/routingtable.go b/src/gnunet/service/dht/routingtable.go
index 20bf5fc..21c8823 100644
--- a/src/gnunet/service/dht/routingtable.go
+++ b/src/gnunet/service/dht/routingtable.go
@@ -66,7 +66,7 @@ func NewPeerAddress(peer *util.PeerID) *PeerAddress {
 func NewQueryAddress(key *crypto.HashCode) *PeerAddress {
         return &PeerAddress{
                 Peer:     nil,
-                Key:      crypto.NewHashCode(key.Bits),
+                Key:      crypto.NewHashCode(key.Data),
                 lastSeen: util.AbsoluteTimeNow(),
                 lastUsed: util.AbsoluteTimeNow(),
         }
@@ -74,18 +74,18 @@ func NewQueryAddress(key *crypto.HashCode) *PeerAddress {
 
 // String returns a human-readble representation of an address.
 func (addr *PeerAddress) String() string {
-        return hex.EncodeToString(addr.Key.Bits)
+        return hex.EncodeToString(addr.Key.Data)
 }
 
-// Equals returns true if two peer addresses are the same.
-func (addr *PeerAddress) Equals(p *PeerAddress) bool {
-        return bytes.Equal(addr.Key.Bits, p.Key.Bits)
+// Equal returns true if two peer addresses are the same.
+func (addr *PeerAddress) Equal(p *PeerAddress) bool {
+        return bytes.Equal(addr.Key.Data, p.Key.Data)
 }
 
 // Distance between two addresses: returns a distance value and a
 // bucket index (smaller index = less distant).
 func (addr *PeerAddress) Distance(p *PeerAddress) (*math.Int, int) {
-        r := util.Distance(addr.Key.Bits, p.Key.Bits)
+        r := util.Distance(addr.Key.Data, p.Key.Data)
         return r, 512 - r.BitLen()
 }
 
@@ -136,24 +136,22 @@ func NewRoutingTable(ref *PeerAddress, cfg *config.RoutingConfig) *RoutingTable
 // Returns true if the entry was added, false otherwise.
 func (rt *RoutingTable) Add(p *PeerAddress, label string) bool {
         k := p.String()
-        logger.Printf(logger.DBG, "[%s] Add(%s)", label, k)
 
         // check if peer is already known
         if px, ok := rt.list.Get(k, 0); ok {
-                logger.Printf(logger.DBG, "[%s] --> already known", label)
                 px.lastSeen = util.AbsoluteTimeNow()
                 return false
         }
         // compute distance (bucket index) and insert address.
         _, idx := p.Distance(rt.ref)
         if rt.buckets[idx].Add(p) {
-                logger.Printf(logger.DBG, "[%s] --> entry added", label)
                 p.lastUsed = util.AbsoluteTimeNow()
                 rt.list.Put(k, p, 0)
+                logger.Printf(logger.INFO, "[%s] %s added to routing table",
+                        label, p.Peer.Short())
                 return true
         }
         // Full bucket: we did not add the address to the routing table.
-        logger.Printf(logger.DBG, "[%s] --> bucket[%d] full -- discarded", label, idx)
         return false
 }
 
@@ -178,41 +176,39 @@ func (rt *RoutingTable) Check(p *PeerAddress) int {
 
 // Remove peer address from routing table.
 // Returns true if the entry was removed, false otherwise.
-func (rt *RoutingTable) Remove(p *PeerAddress, pid int) bool {
-        k := p.String()
-        logger.Printf(logger.DBG, "[RT] Remove(%s)", k)
-
+func (rt *RoutingTable) Remove(p *PeerAddress, label string, pid int) bool {
         // compute distance (bucket index) and remove entry from bucket
         rc := false
         _, idx := p.Distance(rt.ref)
         if rt.buckets[idx].Remove(p) {
-                logger.Println(logger.DBG, "[RT] --> entry removed from bucket and internal lists")
+                logger.Printf(logger.DBG, "[%s] %s removed from RT (bucket and internal lists)", label, p.Peer.Short())
                 rc = true
         } else {
                 // remove from internal list
-                logger.Println(logger.DBG, "[RT] --> entry removed from internal lists only")
+                logger.Printf(logger.DBG, "[%s] %s removed from RT (internal lists only)", label, p.Peer.Short())
         }
-        rt.list.Delete(k, 0)
+        rt.list.Delete(p.String(), 0)
         // delete from HELLO cache
         rt.helloCache.Delete(p.Peer.String(), pid)
         return rc
 }
 
 // Contains checks if a peer is available in the routing table
-func (rt *RoutingTable) Contains(p *PeerAddress) bool {
+func (rt *RoutingTable) Contains(p *PeerAddress, label string) bool {
         k := p.String()
-        logger.Printf(logger.DBG, "[RT] Contains(%s)?", k)
 
         // check for peer in internal list
         px, ok := rt.list.Get(k, 0)
         if !ok {
-                logger.Println(logger.DBG, "[RT] --> NOT found in current list:")
+                logger.Printf(logger.WARN, "[%s] %s NOT found in RT", label, p.Peer.Short())
+                var list []string
                 _ = rt.list.ProcessRange(func(key string, val *PeerAddress, _ int) error {
-                        logger.Printf(logger.DBG, "[RT]    * %s", val)
+                        list = append(list, val.Peer.Short())
                         return nil
                 }, true)
+                logger.Printf(logger.DBG, "[%s] RT=%v", list)
         } else {
-                logger.Println(logger.DBG, "[RT] --> found in current list")
+                //logger.Println(logger.DBG, "[RT] --> found in current list")
                 px.lastSeen = util.AbsoluteTimeNow()
         }
         return ok
@@ -310,7 +306,7 @@ func (rt *RoutingTable) IsClosestPeer(p, k *PeerAddress, pf *blocks.PeerFilter,
                 return d1.Cmp(d0) < 0
         }
         // check if p is closest peer
-        return n.Equals(p)
+        return n.Equal(p)
 }
 
 // ComputeOutDegree computes the number of neighbors that a message should be forwarded to.
@@ -340,23 +336,23 @@ func (rt *RoutingTable) ComputeOutDegree(repl, hop uint16) int {
 func (rt *RoutingTable) heartbeat(ctx context.Context) {
 
         // check for dead or expired peers
-        logger.Println(logger.DBG, "[dht] RT heartbeat...")
+        logger.Println(logger.DBG, "[dht-rt-hb] RT heartbeat...")
         timeout := util.NewRelativeTime(time.Duration(rt.cfg.PeerTTL) * time.Second)
         if err := rt.list.ProcessRange(func(k string, p *PeerAddress, pid int) error {
                 // check if we can/need to drop a peer
                 drop := timeout.Compare(p.lastSeen.Elapsed()) < 0
                 if drop || timeout.Compare(p.lastUsed.Elapsed()) < 0 {
-                        logger.Printf(logger.DBG, "[RT] removing %v: %v, %v", p, p.lastSeen.Elapsed(), p.lastUsed.Elapsed())
-                        rt.Remove(p, pid)
+                        logger.Printf(logger.DBG, "[dht-rt-hb] removing %v: %v, %v", p, p.lastSeen.Elapsed(), p.lastUsed.Elapsed())
+                        rt.Remove(p, "dht-rt-hb", pid)
                 }
                 return nil
         }, false); err != nil {
-                logger.Println(logger.ERROR, "[dht] RT heartbeat failed: "+err.Error())
+                logger.Println(logger.ERROR, "[dht-rt-hb] RT heartbeat failed: "+err.Error())
         }
 
         // drop expired entries from the HELLO cache
         _ = rt.helloCache.ProcessRange(func(key string, val *blocks.HelloBlock, pid int) error {
-                if val.Expires.Expired() {
+                if val.Expire_.Expired() {
                         rt.helloCache.Delete(key, pid)
                 }
                 return nil
@@ -369,7 +365,7 @@ func (rt *RoutingTable) heartbeat(ctx context.Context) {
 //----------------------------------------------------------------------
 
 // LookupHello returns blocks from the HELLO cache for given query.
-func (rt *RoutingTable) LookupHello(addr *PeerAddress, rf blocks.ResultFilter, approx bool) (results []*store.DHTResult) {
+func (rt *RoutingTable) LookupHello(addr *PeerAddress, rf blocks.ResultFilter, approx bool, label string) (results []*store.DHTResult) {
         // iterate over cached HELLOs to find matches;
         // approximate search is limited by distance (max. diff for bucket index is 16)
         _ = rt.helloCache.ProcessRange(func(key string, hb *blocks.HelloBlock, _ int) error {
@@ -390,7 +386,7 @@ func (rt *RoutingTable) LookupHello(addr *PeerAddress, rf blocks.ResultFilter, a
                                 results = append(results, result)
                         }
                 } else {
-                        logger.Printf(logger.DBG, "[RT] GET-HELLO: cache block is filtered")
+                        logger.Printf(logger.DBG, "[%s] LookupHello: cached HELLO block is filtered")
                 }
                 return nil
         }, true)
@@ -479,7 +475,7 @@ func (b *Bucket) Remove(p *PeerAddress) bool {
         defer b.Unlock()
 
         for i, pe := range b.list {
-                if pe.Equals(p) {
+                if pe.Equal(p) {
                         // found entry: remove it
                         b.list = append(b.list[:i], b.list[i+1:]...)
                         return true