git add

Hunter0x7c7

2022-08-11 a82f9cb69f63aaeba40c024960deda7d75b9fece

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
//go:build !confonly 
// +build !confonly 
 
package router 
 
import ( 
    "context" 
 
    core "github.com/v2fly/v2ray-core/v5" 
    "github.com/v2fly/v2ray-core/v5/app/observatory" 
    "github.com/v2fly/v2ray-core/v5/common" 
    "github.com/v2fly/v2ray-core/v5/features" 
    "github.com/v2fly/v2ray-core/v5/features/extension" 
) 
 
type LeastPingStrategy struct { 
    ctx         context.Context 
    observatory extension.Observatory 
 
    config *StrategyLeastPingConfig 
} 
 
func (l *LeastPingStrategy) GetPrincipleTarget(strings []string) []string { 
    return []string{l.PickOutbound(strings)} 
} 
 
func (l *LeastPingStrategy) InjectContext(ctx context.Context) { 
    l.ctx = ctx 
} 
 
func (l *LeastPingStrategy) PickOutbound(strings []string) string { 
    if l.observatory == nil { 
        common.Must(core.RequireFeatures(l.ctx, func(observatory extension.Observatory) error { 
            if l.config.ObserverTag != "" { 
                l.observatory = common.Must2(observatory.(features.TaggedFeatures).GetFeaturesByTag(l.config.ObserverTag)).(extension.Observatory) 
            } else { 
                l.observatory = observatory 
            } 
            return nil 
        })) 
    } 
 
    observeReport, err := l.observatory.GetObservation(l.ctx) 
    if err != nil { 
        newError("cannot get observe report").Base(err).WriteToLog() 
        return "" 
    } 
    outboundsList := outboundList(strings) 
    if result, ok := observeReport.(*observatory.ObservationResult); ok { 
        status := result.Status 
        leastPing := int64(99999999) 
        selectedOutboundName := "" 
        for _, v := range status { 
            if outboundsList.contains(v.OutboundTag) && v.Alive && v.Delay < leastPing { 
                selectedOutboundName = v.OutboundTag 
                leastPing = v.Delay 
            } 
        } 
        return selectedOutboundName 
    } 
 
    // No way to understand observeReport 
    return "" 
} 
 
type outboundList []string 
 
func (o outboundList) contains(name string) bool { 
    for _, v := range o { 
        if v == name { 
            return true 
        } 
    } 
    return false 
} 
 
func init() { 
    common.Must(common.RegisterConfig((*StrategyLeastPingConfig)(nil), nil)) 
}