-
Notifications
You must be signed in to change notification settings - Fork 159
/
sesspathpool.go
137 lines (122 loc) · 3.46 KB
/
sesspathpool.go
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
// Copyright 2018 ETH Zurich
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package iface
import (
"math"
"time"
"github.com/scionproto/scion/go/lib/snet"
"github.com/scionproto/scion/go/lib/spath/spathmeta"
)
const pathFailExpiration = 5 * time.Minute
type SessPathPool map[snet.PathFingerprint]*SessPathStats
func NewSessPathPool() *SessPathPool {
return &SessPathPool{}
}
// Get returns the most suitable path. Excludes a specific path, if possible.
func (spp SessPathPool) Get(exclude snet.PathFingerprint) *SessPath {
var bestSessPath *SessPathStats
var minFail uint16 = math.MaxUint16
var bestNonExpiringSessPath *SessPathStats
var minNonExpiringFail uint16 = math.MaxUint16
for k, v := range spp {
if k == exclude {
continue
}
if v.failCount < minFail {
bestSessPath = v
minFail = v.failCount
}
if v.failCount < minNonExpiringFail && !v.SessPath.IsCloseToExpiry() {
bestNonExpiringSessPath = v
minNonExpiringFail = v.failCount
}
}
// Return a non-expiring path with least failures.
if bestNonExpiringSessPath != nil {
return bestNonExpiringSessPath.SessPath
}
// If not possible, return the best path that's close to expiry.
if bestSessPath != nil {
return bestSessPath.SessPath
}
// In the worst case return the excluded path. Given that the caller asked to exclude it
// it's probably non-functional, but it's the only option we have.
res := spp[exclude]
if res == nil {
return nil
}
return res.SessPath
}
func (spp SessPathPool) GetByKey(key snet.PathFingerprint) *SessPath {
res := spp[key]
if res == nil {
return nil
}
return res.SessPath
}
func (spp SessPathPool) PathCount() int {
return len(spp)
}
func (spp SessPathPool) Update(aps spathmeta.AppPathSet) {
// Remove any old entries that aren't present in the update.
for key := range spp {
if _, ok := aps[key]; !ok {
delete(spp, key)
}
}
for key, path := range aps {
e, ok := spp[key]
if !ok {
// This is a new path, add an entry.
spp[key] = newSessPathStats(key, path)
} else {
// This path already exists, update it.
e.SessPath.path = path
}
}
}
// Reply is called when a probe reply arrives.
// 'sent' is the time when the original probe was sent.
func (spp SessPathPool) Reply(path *SessPath, sent time.Time) {
}
// Timeout is called when a reply to a probe is not received in time.
// 'sent' is the time when the original probe was sent.
func (spp SessPathPool) Timeout(path *SessPath, sent time.Time) {
sp := spp[path.Key()]
if sp == nil {
return
}
sp.lastFail = time.Now()
if sp.failCount < math.MaxInt16 {
sp.failCount += 1
}
}
func (spp SessPathPool) ExpireFails() {
for _, sp := range spp {
if time.Since(sp.lastFail) > pathFailExpiration {
sp.failCount /= 2
}
}
}
type SessPathStats struct {
SessPath *SessPath
lastFail time.Time
failCount uint16
}
func newSessPathStats(key snet.PathFingerprint, path snet.Path) *SessPathStats {
return &SessPathStats{
SessPath: NewSessPath(key, path),
lastFail: time.Now(),
}
}