mirror of
https://github.com/luscis/openlan.git
synced 2025-10-05 00:32:59 +08:00
fea:support nexthop group for routing ha (#57)
This commit is contained in:
Teddy_Zhu
456
pkg/switch/nextgroup.go
Normal file
456
pkg/switch/nextgroup.go
Normal file
@@ -0,0 +1,456 @@
|
||||
package cswitch
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/luscis/openlan/pkg/cache"
|
||||
co "github.com/luscis/openlan/pkg/config"
|
||||
"github.com/luscis/openlan/pkg/libol"
|
||||
"github.com/luscis/openlan/pkg/models"
|
||||
nl "github.com/vishvananda/netlink"
|
||||
"net"
|
||||
"os/exec"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
type NextGroup struct {
|
||||
Network string
|
||||
cfg map[string]co.NextGroup
|
||||
strategies map[string]NextGroupStrategy
|
||||
out *libol.SubLogger
|
||||
}
|
||||
|
||||
func NewNextGroup(network string, cfg map[string]co.NextGroup) *NextGroup {
|
||||
strategies := make(map[string]NextGroupStrategy, 32)
|
||||
for key, ng := range cfg {
|
||||
strategy := newCheckStrategy(key, network, ng)
|
||||
|
||||
if strategy != nil {
|
||||
strategies[key] = strategy
|
||||
}
|
||||
}
|
||||
|
||||
return &NextGroup{
|
||||
Network: network,
|
||||
cfg: cfg,
|
||||
strategies: strategies,
|
||||
out: libol.NewSubLogger("nextgroup"),
|
||||
}
|
||||
}
|
||||
|
||||
func newCheckStrategy(name string, network string, cfg co.NextGroup) NextGroupStrategy {
|
||||
switch cfg.Check {
|
||||
case "ping":
|
||||
return NewPingStrategy(name, network, &cfg)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (ng *NextGroup) Start() {
|
||||
ng.out.Info("NextGroup.Start: nextgroup, ng strategies size: %d", len(ng.strategies))
|
||||
if len(ng.strategies) > 0 {
|
||||
for _, checker := range ng.strategies {
|
||||
checker.Start()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (ng *NextGroup) Stop() {
|
||||
if len(ng.strategies) > 0 {
|
||||
for _, strategy := range ng.strategies {
|
||||
strategy.Stop()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// for add nextgrou dynamicly
|
||||
func (ng *NextGroup) AddNextGroup(name string, cfg co.NextGroup) {
|
||||
if _, ok := ng.strategies[name]; ok {
|
||||
ng.out.Error("NextGroup.addNextGroup: checker already exists %s", name)
|
||||
return
|
||||
}
|
||||
|
||||
strategy := newCheckStrategy(name, ng.Network, cfg)
|
||||
if strategy != nil {
|
||||
ng.strategies[name] = strategy
|
||||
} else {
|
||||
ng.out.Error("NextGroup.AddNextGroup: don't support this strategy %s", name)
|
||||
}
|
||||
strategy.Start()
|
||||
}
|
||||
|
||||
// for del nextgrou dynamicly
|
||||
func (ng *NextGroup) DelNextGroup(name string, cfg co.NextGroup) {
|
||||
if strategy, ok := ng.strategies[name]; !ok {
|
||||
ng.out.Error("NextGroup.addNextGroup: checker not exists %s", name)
|
||||
return
|
||||
} else {
|
||||
if strategy.HasRoute() {
|
||||
ng.out.Error("NextGroup.delNextGroup: checker has route %s", name)
|
||||
return
|
||||
}
|
||||
strategy.Stop()
|
||||
delete(ng.strategies, name)
|
||||
}
|
||||
}
|
||||
|
||||
func (ng *NextGroup) LoadRoute(nextgroup string, nlr *nl.Route) {
|
||||
if strategy, ok := ng.strategies[nextgroup]; ok {
|
||||
ng.out.Debug("NextGroup.loadRoute: %v", nlr)
|
||||
strategy.LoadRoute(nlr)
|
||||
} else {
|
||||
ng.out.Error("NextGroup.loadRoute: checker not found %s", nextgroup)
|
||||
}
|
||||
}
|
||||
|
||||
func (ng *NextGroup) UnloadRoute(nextgroup string, nlr *nl.Route) {
|
||||
if strategy, ok := ng.strategies[nextgroup]; ok {
|
||||
ng.out.Debug("NextGroup.unloadRoute: %v", nlr)
|
||||
strategy.UnloadRoute(nlr)
|
||||
} else {
|
||||
ng.out.Error("NextGroup.unloadRoute: checker not found %s", nextgroup)
|
||||
}
|
||||
}
|
||||
|
||||
type NextGroupStrategy interface {
|
||||
Name() string
|
||||
Check([]string) []co.MultiPath
|
||||
Start()
|
||||
Stop()
|
||||
ReloadRoute()
|
||||
LoadRoute(route *nl.Route)
|
||||
UnloadRoute(route *nl.Route)
|
||||
HasRoute() bool
|
||||
}
|
||||
|
||||
type NextGroupStrategyImpl struct {
|
||||
Network string
|
||||
routes []*nl.Route
|
||||
cfg *co.NextGroup
|
||||
out *libol.SubLogger
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) Name() string {
|
||||
return "common"
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) Start() {
|
||||
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) Stop() {
|
||||
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) HasRoute() bool {
|
||||
return len(c.routes) > 0
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) Check(ipList []string) []co.MultiPath {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) UpdateAvailableNexthops(mp []co.MultiPath) bool {
|
||||
if c.cfg.Mode == "active-backup" {
|
||||
var newPath co.MultiPath
|
||||
if len(mp) > 0 {
|
||||
newPath = mp[0]
|
||||
}
|
||||
var oldPath co.MultiPath
|
||||
if len(c.cfg.AvailableNextHop) > 0 {
|
||||
oldPath = c.cfg.AvailableNextHop[0]
|
||||
}
|
||||
if !newPath.CompareEqual(oldPath) {
|
||||
c.cfg.AvailableNextHop = []co.MultiPath{newPath}
|
||||
c.out.Debug("NextGroupStrategyImpl.UpdateAvailableNexthops: final available nexthops %v", c.cfg.AvailableNextHop)
|
||||
return true
|
||||
}
|
||||
|
||||
} else if c.cfg.Mode == "load-balance" {
|
||||
if !compareMultiPaths(mp, c.cfg.AvailableNextHop) {
|
||||
c.cfg.AvailableNextHop = mp
|
||||
c.out.Debug("NextGroupStrategyImpl.UpdateAvailableNexthops: final available nexthops %v", c.cfg.AvailableNextHop)
|
||||
|
||||
return true
|
||||
}
|
||||
} else {
|
||||
c.cfg.AvailableNextHop = []co.MultiPath{}
|
||||
c.out.Debug("NextGroupStrategyImpl.UpdateAvailableNexthops: final available nexthops %v", c.cfg.AvailableNextHop)
|
||||
//ignore
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) ReloadRoute() {
|
||||
c.out.Debug("NextGroupStrategyImpl.ReloadRoute: route reload %d", len(c.routes))
|
||||
for _, rt := range c.routes {
|
||||
c.updateRoute(rt)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) modelMultiPath() []models.MultiPath {
|
||||
var modelMultiPath []models.MultiPath
|
||||
for _, mp := range c.cfg.AvailableNextHop {
|
||||
modelMultiPath = append(modelMultiPath, models.MultiPath{
|
||||
NextHop: mp.NextHop,
|
||||
Weight: mp.Weight,
|
||||
})
|
||||
}
|
||||
|
||||
return modelMultiPath
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) buildNexthopInfos() []*nl.NexthopInfo {
|
||||
multiPath := make([]*nl.NexthopInfo, 0, len(c.cfg.AvailableNextHop))
|
||||
|
||||
if len(c.cfg.AvailableNextHop) > 0 {
|
||||
for _, mr := range c.cfg.AvailableNextHop {
|
||||
nxhe := &nl.NexthopInfo{
|
||||
Hops: mr.Weight,
|
||||
Gw: net.ParseIP(mr.NextHop),
|
||||
}
|
||||
multiPath = append(multiPath, nxhe)
|
||||
}
|
||||
}
|
||||
|
||||
return multiPath
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) updateRoute(nlr *nl.Route) {
|
||||
c.out.Debug("NextGroupStrategyImpl.updateRoute: %v ", nlr)
|
||||
multiPath := c.buildNexthopInfos()
|
||||
modelMultiPath := c.modelMultiPath()
|
||||
|
||||
nlr.MultiPath = multiPath
|
||||
|
||||
cache.Network.UpdateRoute(c.Network, co.PrefixRoute{
|
||||
Prefix: nlr.Dst.String(),
|
||||
}, func(obj *models.Route) {
|
||||
obj.MultiPath = modelMultiPath
|
||||
})
|
||||
|
||||
promise := libol.NewPromise()
|
||||
promise.Go(func() error {
|
||||
if err := nl.RouteReplace(nlr); err != nil {
|
||||
c.out.Warn("NextGroupStrategyImpl.updateRoute: %v %s", nlr, err)
|
||||
return err
|
||||
}
|
||||
c.out.Info("NextGroupStrategyImpl.updateRoute: %v success", nlr.String())
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) LoadRoute(nlr *nl.Route) {
|
||||
c.out.Debug("NextGroupStrategyImpl.LoadRoute: %v", nlr)
|
||||
c.routes = append(c.routes, nlr)
|
||||
nlr.MultiPath = c.buildNexthopInfos()
|
||||
nlr.Gw = nil
|
||||
c.updateRoute(nlr)
|
||||
}
|
||||
|
||||
func (c *NextGroupStrategyImpl) UnloadRoute(rt *nl.Route) {
|
||||
c.out.Debug("NextGroupStrategyImpl.UnLoadRoute: %v", rt)
|
||||
//find route in routes
|
||||
var nlr *nl.Route
|
||||
for i, r := range c.routes {
|
||||
if r.Dst == rt.Dst && r.Table == rt.Table {
|
||||
nlr = r
|
||||
c.routes = append(c.routes[:i], c.routes[i+1:]...)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if nlr != nil {
|
||||
if err := nl.RouteDel(nlr); err != nil {
|
||||
c.out.Warn("NextGroupStrategyImpl.UnLoadRoute: %s", err)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
type PingCheckResult struct {
|
||||
Ip string
|
||||
AvgLatency float64
|
||||
PacketLoss int
|
||||
}
|
||||
|
||||
type PingCheckStrategy struct {
|
||||
*NextGroupStrategyImpl
|
||||
CfgName string
|
||||
Running bool
|
||||
PingParams *co.PingParams
|
||||
out *libol.SubLogger
|
||||
}
|
||||
|
||||
func NewPingStrategy(name string, network string, cfg *co.NextGroup) *PingCheckStrategy {
|
||||
return &PingCheckStrategy{
|
||||
CfgName: name,
|
||||
NextGroupStrategyImpl: &NextGroupStrategyImpl{
|
||||
Network: network,
|
||||
cfg: cfg,
|
||||
out: libol.NewSubLogger(cfg.Check + "_common_" + name),
|
||||
},
|
||||
PingParams: &cfg.Ping,
|
||||
out: libol.NewSubLogger(cfg.Check + "_" + name),
|
||||
}
|
||||
}
|
||||
|
||||
func (pc *PingCheckStrategy) Name() string {
|
||||
return "ping"
|
||||
}
|
||||
|
||||
func filter(results []PingCheckResult, condition func(PingCheckResult) bool) []PingCheckResult {
|
||||
var filteredResults []PingCheckResult
|
||||
for _, result := range results {
|
||||
if condition(result) {
|
||||
filteredResults = append(filteredResults, result)
|
||||
}
|
||||
}
|
||||
return filteredResults
|
||||
}
|
||||
|
||||
func compareMultiPaths(a []co.MultiPath, b []co.MultiPath) bool {
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
|
||||
for i := range a {
|
||||
if !a[i].CompareEqual(b[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// check the ipList and return the available NextHops
|
||||
func (pc *PingCheckStrategy) Check(ipList []string) []co.MultiPath {
|
||||
count := pc.PingParams.Count
|
||||
loss := pc.PingParams.Loss
|
||||
|
||||
pc.out.Debug("PingCheckStrategy.Check: start check ips")
|
||||
var resultIps []PingCheckResult
|
||||
for _, ip := range ipList {
|
||||
avgLatency, packetLoss, err := pc.ping(ip, count)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
resultIps = append(resultIps, PingCheckResult{
|
||||
Ip: ip,
|
||||
AvgLatency: avgLatency,
|
||||
PacketLoss: packetLoss,
|
||||
})
|
||||
}
|
||||
// filter loss
|
||||
filterResultIps := filter(resultIps, func(result PingCheckResult) bool {
|
||||
return result.PacketLoss <= loss
|
||||
})
|
||||
|
||||
sort.Slice(filterResultIps, func(i, j int) bool {
|
||||
if filterResultIps[i].PacketLoss != filterResultIps[j].PacketLoss {
|
||||
return filterResultIps[i].PacketLoss < filterResultIps[j].PacketLoss
|
||||
}
|
||||
return filterResultIps[i].AvgLatency < filterResultIps[j].AvgLatency
|
||||
})
|
||||
|
||||
var sortedIPs []co.MultiPath
|
||||
for _, result := range filterResultIps {
|
||||
sortedIPs = append(sortedIPs, co.MultiPath{
|
||||
NextHop: result.Ip,
|
||||
Weight: 1,
|
||||
})
|
||||
pc.out.Debug("PingCheckStrategy.Check: available ip : %s , rtt:%.4f, loss: %d ", result.Ip, result.AvgLatency, result.PacketLoss)
|
||||
}
|
||||
|
||||
return sortedIPs
|
||||
}
|
||||
|
||||
func (pc *PingCheckStrategy) updateNextHop() {
|
||||
ipList := pc.Check(pc.cfg.NextHop)
|
||||
if pc.UpdateAvailableNexthops(ipList) {
|
||||
pc.ReloadRoute()
|
||||
}
|
||||
}
|
||||
|
||||
func (pc *PingCheckStrategy) update() {
|
||||
frequency := pc.cfg.Ping.CheckFrequency
|
||||
|
||||
if frequency <= 0 {
|
||||
frequency = 10
|
||||
}
|
||||
//wait tun device start
|
||||
time.Sleep(time.Second * time.Duration(2))
|
||||
for pc.Running = true; pc.Running; {
|
||||
pc.updateNextHop()
|
||||
time.Sleep(time.Second * time.Duration(frequency))
|
||||
}
|
||||
}
|
||||
|
||||
func (pc *PingCheckStrategy) Start() {
|
||||
libol.Go(pc.update)
|
||||
}
|
||||
|
||||
func (pc *PingCheckStrategy) Stop() {
|
||||
pc.Running = false
|
||||
}
|
||||
|
||||
func (pc *PingCheckStrategy) ping(ip string, count int) (float64, int, error) {
|
||||
pingPath, err := exec.LookPath("ping")
|
||||
if err != nil {
|
||||
pc.out.Warn("PingCheckStrategy.Ping: cmd not found :", err)
|
||||
}
|
||||
|
||||
output, err := libol.Exec(pingPath, ip, "-c", strconv.Itoa(count))
|
||||
if err != nil {
|
||||
pc.out.Error("PingCheckStrategy.Ping: exec ping ip: %s, error: %s", ip, err)
|
||||
return 0, 0, err
|
||||
}
|
||||
|
||||
avgLatency := pc.extractAvgLatency(output)
|
||||
|
||||
packetLossRate, err := pc.extractPacketLoss(output)
|
||||
if err != nil {
|
||||
pc.out.Error("PingCheckStrategy.Ping:parse loss error : %s", err)
|
||||
return 0, 0, err
|
||||
}
|
||||
packetLoss := int(packetLossRate * float64(count) / 100)
|
||||
|
||||
pc.out.Debug("PingCheckStrategy.Ping: ping ip[%s], rtt:%.4f, loss: %.f%%", ip, avgLatency, packetLossRate)
|
||||
return avgLatency, packetLoss, nil
|
||||
}
|
||||
|
||||
func (pc *PingCheckStrategy) extractAvgLatency(outputStr string) float64 {
|
||||
pattern := `rtt min/avg/max/mdev = (\d+\.*\d*)/(\d+\.*\d*)/(\d+\.*\d*)/(\d+\.*\d*) ms`
|
||||
|
||||
re := regexp.MustCompile(pattern)
|
||||
subMatches := re.FindStringSubmatch(outputStr)
|
||||
if len(subMatches) != 5 {
|
||||
pc.out.Error("PingCheckStrategy.Ping: Cannot extract average delay.")
|
||||
return 0
|
||||
}
|
||||
|
||||
avgLatencyStr := subMatches[2]
|
||||
|
||||
avgLatency, err := strconv.ParseFloat(avgLatencyStr, 64)
|
||||
if err != nil {
|
||||
pc.out.Error("PingCheckStrategy.Ping: parse float error : %s", err)
|
||||
return 0
|
||||
}
|
||||
return avgLatency
|
||||
}
|
||||
|
||||
func (pc *PingCheckStrategy) extractPacketLoss(outputStr string) (float64, error) {
|
||||
re := regexp.MustCompile(`(\d+)% packet loss`)
|
||||
match := re.FindStringSubmatch(outputStr)
|
||||
if len(match) < 2 {
|
||||
return 0, fmt.Errorf("PingCheckStrategy.Ping: packet loss parse error")
|
||||
}
|
||||
lossRate, err := strconv.ParseFloat(match[1], 64)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return lossRate, nil
|
||||
}
|
||||
Reference in New Issue
Block a user