From e29c0daa4f4972a985bcc83a811ef8da8a69db4b Mon Sep 17 00:00:00 2001 From: mzz2017 Date: Thu, 26 Aug 2021 13:28:13 +0800 Subject: [PATCH] fix: panic and wrong balancer latency display --- service/core/v2ray/status.go | 10 +-- service/core/v2ray/v2rayTmpl.go | 123 +++++++++++++++++++------------- 2 files changed, 80 insertions(+), 53 deletions(-) diff --git a/service/core/v2ray/status.go b/service/core/v2ray/status.go index 4458debe..1eb5f23d 100644 --- a/service/core/v2ray/status.go +++ b/service/core/v2ray/status.go @@ -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 } diff --git a/service/core/v2ray/v2rayTmpl.go b/service/core/v2ray/v2rayTmpl.go index 5412819d..c9ff48ed 100644 --- a/service/core/v2ray/v2rayTmpl.go +++ b/service/core/v2ray/v2rayTmpl.go @@ -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,