mirror of
https://github.com/v2rayA/v2rayA.git
synced 2026-11-20 23:02:25 +03:00
fix: panic and wrong balancer latency display
This commit is contained in:
1 parent
11941e3941
commit
e29c0daa4f
2 files changed
+80
-53
No files matched your search
@@ -194,14 +194,14 @@ func UpdateV2RayConfig() (err error) {
|
||||
if css.Len() == 0 { //no connected server. stop v2ray-core.
|
||||
return StopV2rayService(true)
|
||||
}
|
||||
outboundInfos := make([]OutboundInfo, 0, css.Len())
|
||||
serverInfos := make([]serverInfo, 0, css.Len())
|
||||
vms := make([]vmessInfo.VmessInfo, 0, css.Len())
|
||||
for _, cs := range css.Get() {
|
||||
sr, err = cs.LocateServerRaw()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
outboundInfos = append(outboundInfos, OutboundInfo{
|
||||
serverInfos = append(serverInfos, serverInfo{
|
||||
Info: sr.VmessInfo,
|
||||
OutboundName: cs.Outbound,
|
||||
})
|
||||
@@ -211,13 +211,13 @@ func UpdateV2RayConfig() (err error) {
|
||||
if pluginPorts, err = findAvailablePluginPorts(vms); err != nil {
|
||||
return err
|
||||
}
|
||||
for i := range outboundInfos {
|
||||
for i := range serverInfos {
|
||||
if port, ok := pluginPorts[i]; ok {
|
||||
outboundInfos[i].PluginPort = port
|
||||
serverInfos[i].PluginPort = port
|
||||
}
|
||||
}
|
||||
var outboundTags []string
|
||||
tmpl, outboundTags, err = NewTemplate(outboundInfos)
|
||||
tmpl, outboundTags, err = NewTemplate(serverInfos)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
@@ -215,7 +215,7 @@ type OutboundObject struct {
|
||||
StreamSettings *StreamSettings `json:"streamSettings,omitempty"`
|
||||
ProxySettings *ProxySettings `json:"proxySettings,omitempty"`
|
||||
Mux *Mux `json:"mux,omitempty"`
|
||||
groups []string
|
||||
balancers []string
|
||||
}
|
||||
type OutboundUser struct {
|
||||
User string `json:"user"`
|
||||
@@ -636,8 +636,8 @@ func appendDnsServers(d *DNS, lines []string, domains []string) {
|
||||
func (t *Template) outNames() map[string]bool {
|
||||
tags := make(map[string]bool)
|
||||
for _, o := range t.Outbounds {
|
||||
if len(o.groups) > 0 {
|
||||
for _, groupName := range o.groups {
|
||||
if len(o.balancers) > 0 {
|
||||
for _, groupName := range o.balancers {
|
||||
tags[groupName] = true
|
||||
}
|
||||
} else {
|
||||
@@ -661,8 +661,8 @@ func (t *Template) FirstProxyOutboundName(filter func(outboundName string, isGro
|
||||
case "direct", "block", "dns-out":
|
||||
continue
|
||||
}
|
||||
if len(o.groups) > 0 {
|
||||
for _, v := range o.groups {
|
||||
if len(o.balancers) > 0 {
|
||||
for _, v := range o.balancers {
|
||||
if _, ok := m[v]; !ok {
|
||||
if filter(v, true) {
|
||||
return v, true
|
||||
@@ -679,7 +679,7 @@ func (t *Template) FirstProxyOutboundName(filter func(outboundName string, isGro
|
||||
return
|
||||
}
|
||||
|
||||
func (t *Template) SetDNS(outbounds []OutboundInfo, setting *configure.Setting, supportUDP map[string]bool) (routing []RoutingRule, err error) {
|
||||
func (t *Template) SetDNS(outbounds []serverInfo, setting *configure.Setting, supportUDP map[string]bool) (routing []RoutingRule, err error) {
|
||||
firstOutboundTag, _ := t.FirstProxyOutboundName(nil)
|
||||
firstUDPSupportedOutboundTag, _ := t.FirstProxyOutboundName(func(outboundName string, isGroup bool) bool {
|
||||
return supportUDP[outboundName]
|
||||
@@ -1522,7 +1522,7 @@ func (t *Template) SetInbound(setting *configure.Setting) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
type OutboundInfo struct {
|
||||
type serverInfo struct {
|
||||
Info vmessInfo.VmessInfo
|
||||
OutboundName string
|
||||
PluginPort int
|
||||
@@ -1612,19 +1612,19 @@ func (t *Template) SetGroupRouting(outboundName2VmessInfos map[string][]vmessInf
|
||||
return nil
|
||||
}
|
||||
|
||||
func RefineOutboundInfos(outboundInfos []OutboundInfo) (
|
||||
vmessInfo2OutboundInfos map[vmessInfo.VmessInfo][]*OutboundInfo,
|
||||
func RefineOutboundInfos(serverInfos []serverInfo) (
|
||||
vmessInfo2ServerInfos map[vmessInfo.VmessInfo][]*serverInfo,
|
||||
outboundName2VmessInfos map[string][]vmessInfo.VmessInfo,
|
||||
) {
|
||||
// guarantee that an v2ray outbound is reusable for groups
|
||||
vmessInfo2OutboundInfos = make(map[vmessInfo.VmessInfo][]*OutboundInfo)
|
||||
for i, info := range outboundInfos {
|
||||
vmessInfo2OutboundInfos[info.Info] = append(vmessInfo2OutboundInfos[info.Info], &outboundInfos[i])
|
||||
// guarantee that an v2ray outbound is reusable for balancers
|
||||
vmessInfo2ServerInfos = make(map[vmessInfo.VmessInfo][]*serverInfo)
|
||||
for i, info := range serverInfos {
|
||||
vmessInfo2ServerInfos[info.Info] = append(vmessInfo2ServerInfos[info.Info], &serverInfos[i])
|
||||
}
|
||||
// make ps unique
|
||||
vmessInfo2OutboundInfoAfter := make(map[vmessInfo.VmessInfo][]*OutboundInfo)
|
||||
vmessInfo2OutboundInfoAfter := make(map[vmessInfo.VmessInfo][]*serverInfo)
|
||||
mPsRenaming := make(map[string]struct{})
|
||||
for vi, ois := range vmessInfo2OutboundInfos {
|
||||
for vi, ois := range vmessInfo2ServerInfos {
|
||||
ps := vi.Ps
|
||||
cnt := 2
|
||||
for {
|
||||
@@ -1648,68 +1648,96 @@ func RefineOutboundInfos(outboundInfos []OutboundInfo) (
|
||||
}
|
||||
|
||||
func (t *Template) ResolveOutbounds(
|
||||
outboundInfos []OutboundInfo,
|
||||
vmessInfo2OutboundInfos map[vmessInfo.VmessInfo][]*OutboundInfo,
|
||||
serverInfos []serverInfo,
|
||||
vmessInfo2ServerInfos map[vmessInfo.VmessInfo][]*serverInfo,
|
||||
outboundName2VmessInfos map[string][]vmessInfo.VmessInfo) (supportUDP map[string]bool, outboundTags []string, err error) {
|
||||
|
||||
supportUDP = make(map[string]bool)
|
||||
type _outbound struct {
|
||||
index int
|
||||
weight int
|
||||
outbound OutboundObject
|
||||
balancer bool
|
||||
}
|
||||
outboundInfo2Index := make(map[*OutboundInfo]int)
|
||||
for i := range outboundInfos {
|
||||
outboundInfo2Index[&outboundInfos[i]] = i
|
||||
serverInfo2Index := make(map[*serverInfo]int)
|
||||
for i := range serverInfos {
|
||||
serverInfo2Index[&serverInfos[i]] = i
|
||||
}
|
||||
// keep order with outboundInfos
|
||||
// keep order with serverInfos
|
||||
outboundTags = make([]string, len(serverInfos))
|
||||
var outbounds []_outbound
|
||||
for vmessinfo, infos := range vmessInfo2OutboundInfos {
|
||||
for vmessinfo, sInfos := range vmessInfo2ServerInfos {
|
||||
vi := vmessinfo
|
||||
var (
|
||||
usedByBalancer bool
|
||||
balancerPluginPort int
|
||||
minIndex = -1
|
||||
)
|
||||
var groups []string
|
||||
for _, info := range infos {
|
||||
if len(outboundName2VmessInfos[info.OutboundName]) > 1 {
|
||||
// a vmessInfo(server template) may is used by multiple serverInfos(a connected server)
|
||||
|
||||
// outbound name is not just v2ray outbound tag, it may is a balancer
|
||||
type balancer struct {
|
||||
name string
|
||||
serverInfo *serverInfo
|
||||
}
|
||||
var balancers []balancer
|
||||
for _, sInfo := range sInfos {
|
||||
if len(outboundName2VmessInfos[sInfo.OutboundName]) > 1 {
|
||||
// balancer
|
||||
if err = CheckBalancerSupported(); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
usedByBalancer = true
|
||||
balancerPluginPort = info.PluginPort
|
||||
if minIndex == -1 || outboundInfo2Index[info] < minIndex {
|
||||
minIndex = outboundInfo2Index[info]
|
||||
if !usedByBalancer {
|
||||
usedByBalancer = true
|
||||
balancerPluginPort = sInfo.PluginPort
|
||||
}
|
||||
groups = append(groups, info.OutboundName)
|
||||
balancers = append(balancers, balancer{
|
||||
name: sInfo.OutboundName,
|
||||
serverInfo: sInfo,
|
||||
})
|
||||
} else {
|
||||
// pure outbound
|
||||
o, err := ResolveOutbound(&vi, info.OutboundName, &info.PluginPort)
|
||||
outboundTag := sInfo.OutboundName
|
||||
o, err := ResolveOutbound(&vi, outboundTag, &sInfo.PluginPort)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
outbounds = append(outbounds, _outbound{
|
||||
index: outboundInfo2Index[info],
|
||||
weight: serverInfo2Index[sInfo],
|
||||
outbound: o,
|
||||
balancer: false,
|
||||
})
|
||||
|
||||
supportUDP[info.OutboundName] = !plugin.HasProperPlugin(info.Info)
|
||||
outboundTags[serverInfo2Index[sInfo]] = outboundTag
|
||||
supportUDP[sInfo.OutboundName] = !plugin.HasProperPlugin(sInfo.Info)
|
||||
}
|
||||
}
|
||||
if usedByBalancer {
|
||||
// the outbound is shared by balancers
|
||||
o, err := ResolveOutbound(&vi, Ps2OutboundTag(vi.Ps), &balancerPluginPort)
|
||||
// the v2ray outbound is shared by balancers
|
||||
outboundTag := Ps2OutboundTag(vi.Ps)
|
||||
o, err := ResolveOutbound(&vi, outboundTag, &balancerPluginPort)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
o.groups = groups
|
||||
for _, v := range balancers {
|
||||
o.balancers = append(o.balancers, v.name)
|
||||
}
|
||||
|
||||
// we use the lowest serverInfo index as the order weight of the balancer outbound
|
||||
weight := -1
|
||||
for _, v := range balancers {
|
||||
index := serverInfo2Index[v.serverInfo]
|
||||
if weight == -1 || weight > index {
|
||||
weight = index
|
||||
}
|
||||
// tag
|
||||
outboundTags[index] = outboundTag
|
||||
}
|
||||
outbounds = append(outbounds, _outbound{
|
||||
index: minIndex,
|
||||
weight: weight,
|
||||
outbound: o,
|
||||
balancer: true,
|
||||
})
|
||||
|
||||
// if any node does not support UDP, the outbound should be tagged as UDP unsupported
|
||||
for _, outboundName := range o.groups {
|
||||
for _, outboundName := range o.balancers {
|
||||
_supportUDP := !plugin.HasProperPlugin(vi)
|
||||
if _, ok := supportUDP[outboundName]; !ok {
|
||||
supportUDP[outboundName] = _supportUDP
|
||||
@@ -1721,10 +1749,9 @@ func (t *Template) ResolveOutbounds(
|
||||
}
|
||||
}
|
||||
sort.Slice(outbounds, func(i, j int) bool {
|
||||
return outbounds[i].index < outbounds[j].index
|
||||
return outbounds[i].weight < outbounds[j].weight
|
||||
})
|
||||
for _, v := range outbounds {
|
||||
outboundTags = append(outboundTags, v.outbound.Tag)
|
||||
t.Outbounds = append(t.Outbounds, v.outbound)
|
||||
}
|
||||
t.Outbounds = append(t.Outbounds, OutboundObject{
|
||||
@@ -1791,8 +1818,8 @@ func (t *Template) SetVlessGrpcRouting() {
|
||||
}
|
||||
}
|
||||
|
||||
func NewTemplate(outboundInfos []OutboundInfo) (t Template, outboundTags []string, err error) {
|
||||
vmessInfo2OutboundInfos, outboundName2VmessInfos := RefineOutboundInfos(outboundInfos)
|
||||
func NewTemplate(serverInfos []serverInfo) (t Template, outboundTags []string, err error) {
|
||||
vmessInfo2ServerInfos, outboundName2VmessInfos := RefineOutboundInfos(serverInfos)
|
||||
ps2OutboundNames := make(map[string][]string)
|
||||
for outboundName, vis := range outboundName2VmessInfos {
|
||||
for _, vi := range vis {
|
||||
@@ -1829,7 +1856,7 @@ func NewTemplate(outboundInfos []OutboundInfo) (t Template, outboundTags []strin
|
||||
}
|
||||
}
|
||||
// resolve Outbounds
|
||||
supportUDP, outboundTags, err := t.ResolveOutbounds(outboundInfos, vmessInfo2OutboundInfos, outboundName2VmessInfos)
|
||||
supportUDP, outboundTags, err := t.ResolveOutbounds(serverInfos, vmessInfo2ServerInfos, outboundName2VmessInfos)
|
||||
if err != nil {
|
||||
return Template{}, nil, err
|
||||
}
|
||||
@@ -1839,7 +1866,7 @@ func NewTemplate(outboundInfos []OutboundInfo) (t Template, outboundTags []strin
|
||||
return Template{}, nil, err
|
||||
}
|
||||
//set DNS
|
||||
dnsRouting, err := t.SetDNS(outboundInfos, setting, supportUDP)
|
||||
dnsRouting, err := t.SetDNS(serverInfos, setting, supportUDP)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
@@ -1867,7 +1894,7 @@ func NewTemplate(outboundInfos []OutboundInfo) (t Template, outboundTags []strin
|
||||
|
||||
// set routing whitelist
|
||||
var whitelist []Addr
|
||||
for _, info := range outboundInfos {
|
||||
for _, info := range serverInfos {
|
||||
whitelist = append(whitelist, Addr{
|
||||
host: info.Info.Add,
|
||||
port: info.Info.Port,
|
||||
|
||||
Reference in new issue
Block a user