Automated cherry pick of #391: fix: tc batch command compat kernel 3.10

pkg/agent/server/guest.go

@@ -80,7 +80,7 @@ func (g *Guest) reloadDesc(ctx context.Context) error {
 	if g.NeedsSync() {
 		go func() {
 			// desc change will be picked up by watcher
-			log.Infof("guest sync %s", g.Id)
+			log.Debugf("guest sync %s", g.Id)
 			hc := g.watcher.hostConfig
 			s := auth.GetAdminSession(ctx, hc.Region)
 			_, err := mcclient_modules.Servers.PerformAction(s, g.Id, "sync", nil)
@@ -245,15 +245,15 @@ func (g *Guest) clearOvn(ctx context.Context) {
 func (g *Guest) UpdateSettings(ctx context.Context, sync bool) {
 	start := time.Now()
 	err := g.refresh(ctx)
-	log.Infof("guest UpdateSettings refresh %f", time.Since(start).Seconds())
+	log.Debugf("guest UpdateSettings refresh %f", time.Since(start).Seconds())
 	switch err {
 	case nil:
 		g.updateClassicFlows(ctx)
-		log.Infof("guest UpdateSettings updateClassicFlows %f", time.Since(start).Seconds())
+		log.Debugf("guest UpdateSettings updateClassicFlows %f", time.Since(start).Seconds())
 		g.updateTc(ctx, sync)
-		log.Infof("guest UpdateSettings updateTc %f", time.Since(start).Seconds())
+		log.Debugf("guest UpdateSettings updateTc %f", time.Since(start).Seconds())
 		g.updateOvn(ctx)
-		log.Infof("guest UpdateSettings updateOvn %f", time.Since(start).Seconds())
+		log.Debugf("guest UpdateSettings updateOvn %f", time.Since(start).Seconds())
 		if g.HostId != "" {
 			g.watcher.agent.HostId(g.HostId)
 		}

pkg/agent/server/tcman.go

@@ -19,7 +19,6 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"strings"
 	"sync"
 	"time"
 
@@ -80,7 +79,7 @@ func NewTcMan() *TcMan {
 	return &TcMan{
 		book:    map[string]*TcManSection{},
 		tcCli:   tc.NewTcCli().Details(true).Force(true),
-		cmdChan: make(chan *TcManCmd),
+		cmdChan: make(chan *TcManCmd, 1024),
 	}
 }
 
@@ -205,7 +204,7 @@ func (tm *TcMan) doCheckGuestIfbTcData(ctx context.Context, tcdata *utils.TcData
 	expectTree := tcdata.GuestIfbQdiscTree()
 	cmds := expectTree.Delta(qt, tcdata.IfbIfname())
 	if len(cmds) > 0 {
-		output, stderr, err := tm.tcCli.Batch(ctx, strings.Join(cmds, "\n"))
+		output, stderr, err := tm.tcCli.Batch(ctx, cmds)
 		if err != nil {
 			log.Errorf("tcman: batch failed: %s cmds: %s\n%s\nstderr:\n%s", err, cmds, output, stderr)
 			return errors.Wrapf(err, "batch failed: %s cmds: %s\n%s\nstderr:\n%s", err, cmds, output, stderr)
@@ -229,7 +228,7 @@ func (tm *TcMan) doCheckGuestTcData(ctx context.Context, tcdata *utils.TcData) e
 
 	cmds := expectTree.Delta(qt, tcdata.Ifname)
 	if len(cmds) > 0 {
-		output, stderr, err := tm.tcCli.Batch(ctx, strings.Join(cmds, "\n"))
+		output, stderr, err := tm.tcCli.Batch(ctx, cmds)
 		if err != nil {
 			log.Errorf("tcman: batch failed: %s cmds: %s\n%s\nstderr:\n%s", err, cmds, output, stderr)
 			return errors.Wrapf(err, "batch failed: %s cmds: %s\n%s\nstderr:\n%s", err, cmds, output, stderr)
@@ -269,9 +268,9 @@ func (tm *TcMan) doCheckHostTcData(ctx context.Context, tcdata *utils.TcData) {
 
 	cmds := expectTree.Delta(qt, tcdata.Ifname)
 	if len(cmds) > 0 {
-		output, stderr, err := tm.tcCli.Batch(ctx, strings.Join(cmds, "\n"))
+		output, stderr, err := tm.tcCli.Batch(ctx, cmds)
 		if err != nil {
-			log.Errorf("tcman: batch failed: %s cnds: %s\n%s\nstderr:\n%s", err, cmds, output, stderr)
+			log.Errorf("tcman: batch failed: %s cmds: %s\n%s\nstderr:\n%s", err, cmds, output, stderr)
 			for _, cmd := range cmds {
 				log.Debugf("tcman: %s", cmd)
 			}

pkg/agent/server/watch.go

@@ -147,15 +147,15 @@ func (w *serversWatcher) scan(ctx context.Context) {
 		id := fi.Name()
 		if REGEX_UUID.MatchString(id) {
 			guestStart := time.Now()
-			log.Infof("scan guest %s", id)
+			log.Debugf("scan guest %s", id)
 			path := path.Join(serversPath, id)
 			g, err := w.addGuestWatch(id, path)
 			if err != nil {
 				log.Errorf("inotify events watch guest failed during scan: %s: %s", path, err)
 			}
-			log.Infof("end of scan guest %s addGuestWatch: %f", id, time.Since(guestStart).Seconds())
+			log.Debugf("end of scan guest %s addGuestWatch: %f", id, time.Since(guestStart).Seconds())
 			g.UpdateSettings(ctx, false)
-			log.Infof("end of scan guest %s: %f", id, time.Since(guestStart).Seconds())
+			log.Debugf("end of scan guest %s: %f", id, time.Since(guestStart).Seconds())
 		}
 	}
 }
@@ -186,9 +186,9 @@ func (w *serversWatcher) withWait(ctx context.Context, f func(context.Context))
 	ctx = context.WithValue(ctx, "waitData", waitData)
 	start := time.Now()
 	funcName := GetFunctionName(f)
-	log.Debugf("[serversWatcher] start wait %s context ....", funcName)
+	log.Debugf("serversWatcher.withWait start wait %s context ....", funcName)
 	f(ctx)
-	log.Debugf("[serversWatcher] end wait %s context %f....", funcName, time.Since(start).Seconds())
+	log.Debugf("serversWatcher.withWait end wait %s context %f....", funcName, time.Since(start).Seconds())
 	for _, wd := range waitData {
 		wd.FlowMan.waitDecr(wd.Count)
 		wd.FlowMan.SyncFlows(ctx)
@@ -266,7 +266,6 @@ func (w *serversWatcher) Start(ctx context.Context, agent *AgentServer) {
 				log.Errorf("fsnotity.watch.Events error")
 				goto out
 			}
-			log.Infof("receive inotify events!")
 			wev := w.watchEvent(&ev)
 			if wev == nil {
 				log.Debugf("inotify events ignored: %s", ev)
@@ -276,7 +275,7 @@ func (w *serversWatcher) Start(ctx context.Context, agent *AgentServer) {
 				guestPath := wev.guestPath
 				switch wev.evType {
 				case watchEventTypeAddServerDir:
-					log.Infof("received guest path add event: %s", guestPath)
+					log.Debugf("received guest path add event: %s", guestPath)
 					g, err := w.addGuestWatch(guestId, guestPath)
 					if err != nil {
 						log.Errorf("watch guest failed: %s: %s", guestPath, err)
@@ -288,25 +287,21 @@ func (w *serversWatcher) Start(ctx context.Context, agent *AgentServer) {
 						g.ClearSettings(ctx)
 						delete(w.guests, guestId)
 					}
-					log.Infof("guest path deleted: %s", guestPath)
 				case watchEventTypeUpdServer:
-					log.Infof("watchEventTypeUpdServer %s", guestId)
 					if g, ok := w.guests[guestId]; ok {
 						g.UpdateSettings(ctx, true)
 					} else {
 						log.Warningf("unexpected guest update event: %s", guestPath)
 					}
 				case watchEventTypeDelServer:
 					if g, ok := w.guests[guestId]; ok {
-						log.Infof("remove guest settings %s", guestId)
 						g.ClearSettings(ctx)
 					} else {
 						log.Warningf("unexpected guest down event: %s", guestPath)
 					}
 				}
 			}
 		case <-pendingChan:
-			log.Infof("watcher refresh pendings")
 			w.withWait(ctx, func(ctx context.Context) {
 				for _, g := range w.guests {
 					if g.IsPending() {
@@ -315,13 +310,12 @@ func (w *serversWatcher) Start(ctx context.Context, agent *AgentServer) {
 				}
 			})
 		case <-refreshTicker.C:
-			log.Infof("watcher refresh time ;)")
 			w.withWait(ctx, func(ctx context.Context) {
 				w.hostLocal.UpdateSettings(ctx, false)
 				w.scan(ctx)
-				// for _, g := range w.guests {
-				//	g.UpdateSettings(ctx)
-				// }
+				for _, g := range w.guests {
+					g.UpdateSettings(ctx, false)
+				}
 			})
 		case err, ok := <-w.watcher.Errors:
 			if !ok {

pkg/agent/utils/cache_port_stats.go

@@ -5,6 +5,8 @@ import (
 	"time"
 
 	"github.com/digitalocean/go-openvswitch/ovs"
+
+	"yunion.io/x/log"
 )
 
 const (
@@ -57,6 +59,7 @@ func (cache *PortStatsCache) DumpPort(bridge, port string) (*ovs.PortStats, erro
 	if data, ok := cache.store[key]; ok && !data.staled() {
 		ps := data.get()
 		cache.rw.RUnlock()
+		log.Debugf("DumpPort %s, %s, %d from cache", bridge, port, ps.PortID)
 		return ps, nil
 	}
 	cache.rw.RUnlock()
@@ -65,6 +68,7 @@ func (cache *PortStatsCache) DumpPort(bridge, port string) (*ovs.PortStats, erro
 	if err != nil {
 		return ps, err
 	}
+	log.Debugf("DumpPort %s, %s, %d from ovs", bridge, port, ps.PortID)
 
 	cache.rw.Lock()
 	defer cache.rw.Unlock()

pkg/agent/utils/cls_md.go

@@ -121,8 +121,8 @@ type sClassicMetadataDescGetter struct {
 
 func (g *sClassicMetadataDescGetter) Get(ip string) *desc.SGuestDesc {
 	start := time.Now()
-	log.Infof("Get guest desc by ip %s", ip)
+	log.Debugf("Get guest desc by ip %s", ip)
 	guestDesc := g.watcher.FindGuestDescByHostLocalIp(g.hostLocal, ip)
-	log.Infof("Get guest desc by ip %s cost %f seconds", ip, time.Since(start).Seconds())
+	log.Debugf("Get guest desc by ip %s cost %f seconds", ip, time.Since(start).Seconds())
 	return guestDesc
 }

pkg/tc/class.go

@@ -105,19 +105,19 @@ func (q *SBaseTcClass) Equals(qi IComparable) bool {
 	return q.Compare(qi) == 0
 }
 
-func (cls *SBaseTcClass) AddLine(ifname string) string {
+func (cls *SBaseTcClass) AddLine(ifname string) []string {
 	elms := cls.basicLineElements("add", ifname)
-	return strings.Join(elms, " ")
+	return elms
 }
 
-func (cls *SBaseTcClass) ReplaceLine(ifname string) string {
+func (cls *SBaseTcClass) ReplaceLine(ifname string) []string {
 	elms := cls.basicLineElements("replace", ifname)
-	return strings.Join(elms, " ")
+	return elms
 }
 
-func (cls *SBaseTcClass) DeleteLine(ifname string) string {
+func (cls *SBaseTcClass) DeleteLine(ifname string) []string {
 	elms := cls.basicLineElements("delete", ifname)
-	return strings.Join(elms, " ")
+	return elms
 }
 
 func (cls *SBaseTcClass) Base() *SBaseTcClass {
@@ -220,19 +220,19 @@ func (cls *SHtbClass) basicLineElements(action string, ifname string) []string {
 	return elms
 }
 
-func (cls *SHtbClass) AddLine(ifname string) string {
+func (cls *SHtbClass) AddLine(ifname string) []string {
 	elms := cls.basicLineElements("add", ifname)
-	return strings.Join(elms, " ")
+	return elms
 }
 
-func (cls *SHtbClass) ReplaceLine(ifname string) string {
+func (cls *SHtbClass) ReplaceLine(ifname string) []string {
 	elms := cls.basicLineElements("replace", ifname)
-	return strings.Join(elms, " ")
+	return elms
 }
 
-func (cls *SHtbClass) DeleteLine(ifname string) string {
+func (cls *SHtbClass) DeleteLine(ifname string) []string {
 	elms := cls.basicLineElements("delete", ifname)
-	return strings.Join(elms, " ")
+	return elms
 }
 
 func parseHtbClass(chunks []string) (*SHtbClass, error) {

pkg/tc/class_test.go

@@ -21,8 +21,8 @@ func TestParseClassLines(t *testing.T) {
 		ifname      string
 		in          []string
 		want        []IClass
-		delLine     []string
-		replaceLine []string
+		delLine     [][]string
+		replaceLine [][]string
 	}{
 		{
 			ifname: "eth0",
@@ -52,15 +52,15 @@ func TestParseClassLines(t *testing.T) {
 					Ceil: 100000000,
 				},
 			},
-			delLine: []string{
-				"class delete dev eth0 parent 1: classid 1:1 htb rate 10Gbit ceil 10Gbit",
-				"class delete dev eth0 parent 1:1 classid 1:2 htb rate 1Gbit ceil 10Gbit",
-				"class delete dev eth0 parent 1:1 classid 1:3 htb rate 100Mbit ceil 100Mbit",
+			delLine: [][]string{
+				[]string{"class", "delete", "dev", "eth0", "parent", "1:", "classid", "1:1", "htb", "rate", "10Gbit", "ceil", "10Gbit"},
+				[]string{"class", "delete", "dev", "eth0", "parent", "1:1", "classid", "1:2", "htb", "rate", "1Gbit", "ceil", "10Gbit"},
+				[]string{"class", "delete", "dev", "eth0", "parent", "1:1", "classid", "1:3", "htb", "rate", "100Mbit", "ceil", "100Mbit"},
 			},
-			replaceLine: []string{
-				"class add dev eth0 parent 1: classid 1:1 htb rate 10Gbit ceil 10Gbit",
-				"class add dev eth0 parent 1:1 classid 1:2 htb rate 1Gbit ceil 10Gbit",
-				"class add dev eth0 parent 1:1 classid 1:3 htb rate 100Mbit ceil 100Mbit",
+			replaceLine: [][]string{
+				[]string{"class", "add", "dev", "eth0", "parent", "1:", "classid", "1:1", "htb", "rate", "10Gbit", "ceil", "10Gbit"},
+				[]string{"class", "add", "dev", "eth0", "parent", "1:1", "classid", "1:2", "htb", "rate", "1Gbit", "ceil", "10Gbit"},
+				[]string{"class", "add", "dev", "eth0", "parent", "1:1", "classid", "1:3", "htb", "rate", "100Mbit", "ceil", "100Mbit"},
 			},
 		},
 	}
@@ -78,14 +78,14 @@ func TestParseClassLines(t *testing.T) {
 				t.Fatalf("class %d: want %s, got %s", i, jsonutils.Marshal(c.want[i]), jsonutils.Marshal(got[i]))
 			}
 		}
-		delLines := []string{}
+		delLines := [][]string{}
 		for _, cls := range got {
 			delLines = append(delLines, cls.DeleteLine(c.ifname))
 		}
 		if !reflect.DeepEqual(delLines, c.delLine) {
 			t.Fatalf("want %v, got %v", c.delLine, delLines)
 		}
-		replaceLines := []string{}
+		replaceLines := [][]string{}
 		for _, cls := range got {
 			replaceLines = append(replaceLines, cls.AddLine(c.ifname))
 		}