|
|
@@ -25,6 +25,7 @@ package discover
|
|
|
import (
|
|
|
"crypto/rand"
|
|
|
"encoding/binary"
|
|
|
+ "fmt"
|
|
|
"net"
|
|
|
"sort"
|
|
|
"sync"
|
|
|
@@ -56,7 +57,7 @@ type Table struct {
|
|
|
nursery []*Node // bootstrap nodes
|
|
|
db *nodeDB // database of known nodes
|
|
|
|
|
|
- refreshReq chan struct{}
|
|
|
+ refreshReq chan chan struct{}
|
|
|
closeReq chan struct{}
|
|
|
closed chan struct{}
|
|
|
|
|
|
@@ -102,7 +103,7 @@ func newTable(t transport, ourID NodeID, ourAddr *net.UDPAddr, nodeDBPath string
|
|
|
self: NewNode(ourID, ourAddr.IP, uint16(ourAddr.Port), uint16(ourAddr.Port)),
|
|
|
bonding: make(map[NodeID]*bondproc),
|
|
|
bondslots: make(chan struct{}, maxBondingPingPongs),
|
|
|
- refreshReq: make(chan struct{}),
|
|
|
+ refreshReq: make(chan chan struct{}),
|
|
|
closeReq: make(chan struct{}),
|
|
|
closed: make(chan struct{}),
|
|
|
}
|
|
|
@@ -179,21 +180,27 @@ func (tab *Table) Close() {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-// Bootstrap sets the bootstrap nodes. These nodes are used to connect
|
|
|
-// to the network if the table is empty. Bootstrap will also attempt to
|
|
|
-// fill the table by performing random lookup operations on the
|
|
|
-// network.
|
|
|
-func (tab *Table) Bootstrap(nodes []*Node) {
|
|
|
+// SetFallbackNodes sets the initial points of contact. These nodes
|
|
|
+// are used to connect to the network if the table is empty and there
|
|
|
+// are no known nodes in the database.
|
|
|
+func (tab *Table) SetFallbackNodes(nodes []*Node) error {
|
|
|
+ for _, n := range nodes {
|
|
|
+ if err := n.validateComplete(); err != nil {
|
|
|
+ return fmt.Errorf("bad bootstrap/fallback node %q (%v)", n, err)
|
|
|
+ }
|
|
|
+ }
|
|
|
tab.mutex.Lock()
|
|
|
- // TODO: maybe filter nodes with bad fields (nil, etc.) to avoid strange crashes
|
|
|
tab.nursery = make([]*Node, 0, len(nodes))
|
|
|
for _, n := range nodes {
|
|
|
cpy := *n
|
|
|
+ // Recompute cpy.sha because the node might not have been
|
|
|
+ // created by NewNode or ParseNode.
|
|
|
cpy.sha = crypto.Sha3Hash(n.ID[:])
|
|
|
tab.nursery = append(tab.nursery, &cpy)
|
|
|
}
|
|
|
tab.mutex.Unlock()
|
|
|
- tab.requestRefresh()
|
|
|
+ tab.refresh()
|
|
|
+ return nil
|
|
|
}
|
|
|
|
|
|
// Resolve searches for a specific node with the given ID.
|
|
|
@@ -224,26 +231,36 @@ func (tab *Table) Resolve(targetID NodeID) *Node {
|
|
|
// The given target does not need to be an actual node
|
|
|
// identifier.
|
|
|
func (tab *Table) Lookup(targetID NodeID) []*Node {
|
|
|
+ return tab.lookup(targetID, true)
|
|
|
+}
|
|
|
+
|
|
|
+func (tab *Table) lookup(targetID NodeID, refreshIfEmpty bool) []*Node {
|
|
|
var (
|
|
|
target = crypto.Sha3Hash(targetID[:])
|
|
|
asked = make(map[NodeID]bool)
|
|
|
seen = make(map[NodeID]bool)
|
|
|
reply = make(chan []*Node, alpha)
|
|
|
pendingQueries = 0
|
|
|
+ result *nodesByDistance
|
|
|
)
|
|
|
// don't query further if we hit ourself.
|
|
|
// unlikely to happen often in practice.
|
|
|
asked[tab.self.ID] = true
|
|
|
|
|
|
- tab.mutex.Lock()
|
|
|
- // generate initial result set
|
|
|
- result := tab.closest(target, bucketSize)
|
|
|
- tab.mutex.Unlock()
|
|
|
-
|
|
|
- // If the result set is empty, all nodes were dropped, refresh.
|
|
|
- if len(result.entries) == 0 {
|
|
|
- tab.requestRefresh()
|
|
|
- return nil
|
|
|
+ for {
|
|
|
+ tab.mutex.Lock()
|
|
|
+ // generate initial result set
|
|
|
+ result = tab.closest(target, bucketSize)
|
|
|
+ tab.mutex.Unlock()
|
|
|
+ if len(result.entries) > 0 || !refreshIfEmpty {
|
|
|
+ break
|
|
|
+ }
|
|
|
+ // The result set is empty, all nodes were dropped, refresh.
|
|
|
+ // We actually wait for the refresh to complete here. The very
|
|
|
+ // first query will hit this case and run the bootstrapping
|
|
|
+ // logic.
|
|
|
+ <-tab.refresh()
|
|
|
+ refreshIfEmpty = false
|
|
|
}
|
|
|
|
|
|
for {
|
|
|
@@ -287,24 +304,24 @@ func (tab *Table) Lookup(targetID NodeID) []*Node {
|
|
|
return result.entries
|
|
|
}
|
|
|
|
|
|
-func (tab *Table) requestRefresh() {
|
|
|
+func (tab *Table) refresh() <-chan struct{} {
|
|
|
+ done := make(chan struct{})
|
|
|
select {
|
|
|
- case tab.refreshReq <- struct{}{}:
|
|
|
+ case tab.refreshReq <- done:
|
|
|
case <-tab.closed:
|
|
|
+ close(done)
|
|
|
}
|
|
|
+ return done
|
|
|
}
|
|
|
|
|
|
+// refreshLoop schedules doRefresh runs and coordinates shutdown.
|
|
|
func (tab *Table) refreshLoop() {
|
|
|
- defer func() {
|
|
|
- tab.db.close()
|
|
|
- if tab.net != nil {
|
|
|
- tab.net.close()
|
|
|
- }
|
|
|
- close(tab.closed)
|
|
|
- }()
|
|
|
-
|
|
|
- timer := time.NewTicker(autoRefreshInterval)
|
|
|
- var done chan struct{}
|
|
|
+ var (
|
|
|
+ timer = time.NewTicker(autoRefreshInterval)
|
|
|
+ waiting []chan struct{} // accumulates waiting callers while doRefresh runs
|
|
|
+ done chan struct{} // where doRefresh reports completion
|
|
|
+ )
|
|
|
+loop:
|
|
|
for {
|
|
|
select {
|
|
|
case <-timer.C:
|
|
|
@@ -312,20 +329,34 @@ func (tab *Table) refreshLoop() {
|
|
|
done = make(chan struct{})
|
|
|
go tab.doRefresh(done)
|
|
|
}
|
|
|
- case <-tab.refreshReq:
|
|
|
+ case req := <-tab.refreshReq:
|
|
|
+ waiting = append(waiting, req)
|
|
|
if done == nil {
|
|
|
done = make(chan struct{})
|
|
|
go tab.doRefresh(done)
|
|
|
}
|
|
|
case <-done:
|
|
|
+ for _, ch := range waiting {
|
|
|
+ close(ch)
|
|
|
+ }
|
|
|
+ waiting = nil
|
|
|
done = nil
|
|
|
case <-tab.closeReq:
|
|
|
- if done != nil {
|
|
|
- <-done
|
|
|
- }
|
|
|
- return
|
|
|
+ break loop
|
|
|
}
|
|
|
}
|
|
|
+
|
|
|
+ if tab.net != nil {
|
|
|
+ tab.net.close()
|
|
|
+ }
|
|
|
+ if done != nil {
|
|
|
+ <-done
|
|
|
+ }
|
|
|
+ for _, ch := range waiting {
|
|
|
+ close(ch)
|
|
|
+ }
|
|
|
+ tab.db.close()
|
|
|
+ close(tab.closed)
|
|
|
}
|
|
|
|
|
|
// doRefresh performs a lookup for a random target to keep buckets
|
|
|
@@ -342,7 +373,7 @@ func (tab *Table) doRefresh(done chan struct{}) {
|
|
|
// We perform a lookup with a random target instead.
|
|
|
var target NodeID
|
|
|
rand.Read(target[:])
|
|
|
- result := tab.Lookup(target)
|
|
|
+ result := tab.lookup(target, false)
|
|
|
if len(result) > 0 {
|
|
|
return
|
|
|
}
|
|
|
@@ -366,7 +397,7 @@ func (tab *Table) doRefresh(done chan struct{}) {
|
|
|
tab.mutex.Unlock()
|
|
|
|
|
|
// Finally, do a self lookup to fill up the buckets.
|
|
|
- tab.Lookup(tab.self.ID)
|
|
|
+ tab.lookup(tab.self.ID, false)
|
|
|
}
|
|
|
|
|
|
// closest returns the n nodes in the table that are closest to the
|
Felix Lange