aboutsummaryrefslogtreecommitdiffstats
path: root/p2p/dial.go
blob: 45cd8116b6d441f553910c772f10f011496c243c (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
package p2p

import (
    "container/heap"
    "crypto/rand"
    "fmt"
    "net"
    "time"

    "github.com/ethereum/go-ethereum/logger"
    "github.com/ethereum/go-ethereum/logger/glog"
    "github.com/ethereum/go-ethereum/p2p/discover"
)

const (
    // This is the amount of time spent waiting in between
    // redialing a certain node.
    dialHistoryExpiration = 30 * time.Second

    // Discovery lookups are throttled and can only run
    // once every few seconds.
    lookupInterval = 4 * time.Second
)

// dialstate schedules dials and discovery lookups.
// it get's a chance to compute new tasks on every iteration
// of the main loop in Server.run.
type dialstate struct {
    maxDynDials int
    ntab        discoverTable

    lookupRunning bool
    bootstrapped  bool

    dialing     map[discover.NodeID]connFlag
    lookupBuf   []*discover.Node // current discovery lookup results
    randomNodes []*discover.Node // filled from Table
    static      map[discover.NodeID]*discover.Node
    hist        *dialHistory
}

type discoverTable interface {
    Self() *discover.Node
    Close()
    Bootstrap([]*discover.Node)
    Lookup(target discover.NodeID) []*discover.Node
    ReadRandomNodes([]*discover.Node) int
}

// the dial history remembers recent dials.
type dialHistory []pastDial

// pastDial is an entry in the dial history.
type pastDial struct {
    id  discover.NodeID
    exp time.Time
}

type task interface {
    Do(*Server)
}

// A dialTask is generated for each node that is dialed.
type dialTask struct {
    flags connFlag
    dest  *discover.Node
}

// discoverTask runs discovery table operations.
// Only one discoverTask is active at any time.
//
// If bootstrap is true, the task runs Table.Bootstrap,
// otherwise it performs a random lookup and leaves the
// results in the task.
type discoverTask struct {
    bootstrap bool
    results   []*discover.Node
}

// A waitExpireTask is generated if there are no other tasks
// to keep the loop in Server.run ticking.
type waitExpireTask struct {
    time.Duration
}

func newDialState(static []*discover.Node, ntab discoverTable, maxdyn int) *dialstate {
    s := &dialstate{
        maxDynDials: maxdyn,
        ntab:        ntab,
        static:      make(map[discover.NodeID]*discover.Node),
        dialing:     make(map[discover.NodeID]connFlag),
        randomNodes: make([]*discover.Node, maxdyn/2),
        hist:        new(dialHistory),
    }
    for _, n := range static {
        s.static[n.ID] = n
    }
    return s
}

func (s *dialstate) addStatic(n *discover.Node) {
    s.static[n.ID] = n
}

func (s *dialstate) newTasks(nRunning int, peers map[discover.NodeID]*Peer, now time.Time) []task {
    var newtasks []task
    addDial := func(flag connFlag, n *discover.Node) bool {
        _, dialing := s.dialing[n.ID]
        if dialing || peers[n.ID] != nil || s.hist.contains(n.ID) {
            return false
        }
        s.dialing[n.ID] = flag
        newtasks = append(newtasks, &dialTask{flags: flag, dest: n})
        return true
    }

    // Compute number of dynamic dials necessary at this point.
    needDynDials := s.maxDynDials
    for _, p := range peers {
        if p.rw.is(dynDialedConn) {
            needDynDials--
        }
    }
    for _, flag := range s.dialing {
        if flag&dynDialedConn != 0 {
            needDynDials--
        }
    }

    // Expire the dial history on every invocation.
    s.hist.expire(now)

    // Create dials for static nodes if they are not connected.
    for _, n := range s.static {
        addDial(staticDialedConn, n)
    }

    // Use random nodes from the table for half of the necessary
    // dynamic dials.
    randomCandidates := needDynDials / 2
    if randomCandidates > 0 && s.bootstrapped {
        n := s.ntab.ReadRandomNodes(s.randomNodes)
        for i := 0; i < randomCandidates && i < n; i++ {
            if addDial(dynDialedConn, s.randomNodes[i]) {
                needDynDials--
            }
        }
    }
    // Create dynamic dials from random lookup results, removing tried
    // items from the result buffer.
    i := 0
    for ; i < len(s.lookupBuf) && needDynDials > 0; i++ {
        if addDial(dynDialedConn, s.lookupBuf[i]) {
            needDynDials--
        }
    }
    s.lookupBuf = s.lookupBuf[:copy(s.lookupBuf, s.lookupBuf[i:])]
    // Launch a discovery lookup if more candidates are needed. The
    // first discoverTask bootstraps the table and won't return any
    // results.
    if len(s.lookupBuf) < needDynDials && !s.lookupRunning {
        s.lookupRunning = true
        newtasks = append(newtasks, &discoverTask{bootstrap: !s.bootstrapped})
    }

    // Launch a timer to wait for the next node to expire if all
    // candidates have been tried and no task is currently active.
    // This should prevent cases where the dialer logic is not ticked
    // because there are no pending events.
    if nRunning == 0 && len(newtasks) == 0 && s.hist.Len() > 0 {
        t := &waitExpireTask{s.hist.min().exp.Sub(now)}
        newtasks = append(newtasks, t)
    }
    return newtasks
}

func (s *dialstate) taskDone(t task, now time.Time) {
    switch t := t.(type) {
    case *dialTask:
        s.hist.add(t.dest.ID, now.Add(dialHistoryExpiration))
        delete(s.dialing, t.dest.ID)
    case *discoverTask:
        if t.bootstrap {
            s.bootstrapped = true
        }
        s.lookupRunning = false
        s.lookupBuf = append(s.lookupBuf, t.results...)
    }
}

func (t *dialTask) Do(srv *Server) {
    addr := &net.TCPAddr{IP: t.dest.IP, Port: int(t.dest.TCP)}
    glog.V(logger.Debug).Infof("dialing %v\n", t.dest)
    fd, err := srv.Dialer.Dial("tcp", addr.String())
    if err != nil {
        glog.V(logger.Detail).Infof("dial error: %v", err)
        return
    }
    mfd := newMeteredConn(fd, false)

    srv.setupConn(mfd, t.flags, t.dest)
}
func (t *dialTask) String() string {
    return fmt.Sprintf("%v %x %v:%d", t.flags, t.dest.ID[:8], t.dest.IP, t.dest.TCP)
}

func (t *discoverTask) Do(srv *Server) {
    if t.bootstrap {
        srv.ntab.Bootstrap(srv.BootstrapNodes)
        return
    }
    // newTasks generates a lookup task whenever dynamic dials are
    // necessary. Lookups need to take some time, otherwise the
    // event loop spins too fast.
    next := srv.lastLookup.Add(lookupInterval)
    if now := time.Now(); now.Before(next) {
        time.Sleep(next.Sub(now))
    }
    srv.lastLookup = time.Now()
    var target discover.NodeID
    rand.Read(target[:])
    t.results = srv.ntab.Lookup(target)
}

func (t *discoverTask) String() (s string) {
    if t.bootstrap {
        s = "discovery bootstrap"
    } else {
        s = "discovery lookup"
    }
    if len(t.results) > 0 {
        s += fmt.Sprintf(" (%d results)", len(t.results))
    }
    return s
}

func (t waitExpireTask) Do(*Server) {
    time.Sleep(t.Duration)
}
func (t waitExpireTask) String() string {
    return fmt.Sprintf("wait for dial hist expire (%v)", t.Duration)
}

// Use only these methods to access or modify dialHistory.
func (h dialHistory) min() pastDial {
    return h[0]
}
func (h *dialHistory) add(id discover.NodeID, exp time.Time) {
    heap.Push(h, pastDial{id, exp})
}
func (h dialHistory) contains(id discover.NodeID) bool {
    for _, v := range h {
        if v.id == id {
            return true
        }
    }
    return false
}
func (h *dialHistory) expire(now time.Time) {
    for h.Len() > 0 && h.min().exp.Before(now) {
        heap.Pop(h)
    }
}

// heap.Interface boilerplate
func (h dialHistory) Len() int           { return len(h) }
func (h dialHistory) Less(i, j int) bool { return h[i].exp.Before(h[j].exp) }
func (h dialHistory) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *dialHistory) Push(x interface{}) {
    *h = append(*h, x.(pastDial))
}
func (h *dialHistory) Pop() interface{} {
    old := *h
    n := len(old)
    x := old[n-1]
    *h = old[0 : n-1]
    return x
}