Merge pull request #10 from m-lab/cleanup

Cleanup and add support for sc_attach

Author: pboothe

.travis.yml

@@ -0,0 +1,22 @@
+language: go
+
+sudo: true
+
+before_install:
+- go get github.com/mattn/goveralls
+# Install dependencies, including test dependencies.
+- sudo apt-get update && sudo apt-get install -y scamper
+- go get -v -t ./...
+
+script:
+# Vet the code, build the code, and run all the tests.
+- go vet ./...
+- go build ./...
+- go test ./... -v -coverpkg=./... -coverprofile=_coverage.cov
+
+# Build a Docker image to make sure that we can.
+- docker build .
+
+# Coveralls
+# Upload coverage information for unit tests.
+- $HOME/gopath/bin/goveralls -coverprofile=_coverage.cov -service=travis-ci

Dockerfile

@@ -1,25 +1,28 @@
-FROM golang:alpine as build
-RUN apk update && apk add bash git pkgconfig geoip-dev geoip gcc libc-dev
+FROM golang:1.12 as build
 ADD . /go/src/github.com/m-lab/traceroute-caller
-RUN GOARCH=amd64 CGO_ENABLED=0 GOOS=linux go get github.com/m-lab/traceroute-caller
+ENV GOARCH amd64
+ENV CGO_ENABLED 0
+ENV GOOS linux
+WORKDIR /go/src/github.com/m-lab/traceroute-caller
+RUN go get -v \
+      -ldflags "-X github.com/m-lab/go/prometheusx.GitShortCommit=$(git log -1 --format=%h)" \
+      .
 RUN chmod -R a+rx /go/bin/traceroute-caller
 
+
 FROM ubuntu:latest
 # Install all the standard packages we need
 RUN apt-get update && apt-get install -y python python-pip make iproute2 coreutils
 
 RUN ls -l
 RUN mkdir /source
-ADD . /go/src/github.com/m-lab/traceroute-caller
-RUN mv /go/src/github.com/m-lab/traceroute-caller/vendor/scamper/scamper-cvs-20190113 /source
+ADD ./vendor/scamper/ /source
 RUN chmod +x /source/scamper-cvs-20190113/configure
-RUN /source/scamper-cvs-20190113/configure
-RUN cd /source/scamper-cvs-20190113/
-RUN ls -l /source/scamper-cvs-20190113/scamper
+WORKDIR /source/scamper-cvs-20190113/
+RUN ./configure
 RUN make
 RUN make install
-
-RUN chmod 4755 /usr/local/bin/scamper
+RUN ldconfig
 
 COPY --from=build /go/bin/traceroute-caller /
 

caller.go

@@ -1,31 +1,57 @@
 package main
 
 import (
+	"context"
 	"flag"
 	"fmt"
 	"log"
 	"time"
 
+	"github.com/m-lab/go/flagx"
+	"github.com/m-lab/go/rtx"
+
+	"github.com/m-lab/go/prometheusx"
 	"github.com/m-lab/traceroute-caller/connectionwatcher"
 	"github.com/m-lab/traceroute-caller/scamper"
 )
 
+var (
+	scamperBin        = flag.String("scamper.bin", "scamper", "path of scamper binary")
+	scattachBin       = flag.String("scamper.sc_attach", "sc_attach", "path of sc_attach binary")
+	scwarts2jsonBin   = flag.String("scamper.sc_warts2json", "sc_warts2json", "path of sc_warts2json binary")
+	scamperCtrlSocket = flag.String("scamper.unixsocket", "/tmp/scamperctrl", "The name of the UNIX-domain socket that the scamper daemon should listen on")
+	outputPath        = flag.String("outputPath", "/var/spool/scamper", "path of output")
+
+	ctx, cancel = context.WithCancel(context.Background())
+)
+
 // Sample cmd:
 // go build
 // ./traceroute-caller --outputPath scamper_output
 func main() {
-	var outputPath string
-	flag.StringVar(&outputPath, "outputPath", "/var/spool/scamper", "path of output")
 	flag.Parse()
+	rtx.Must(flagx.ArgsFromEnv(flag.CommandLine), "Could not get args from environment")
+
+	promSrv := prometheusx.MustServeMetrics()
+
+	daemon := scamper.Daemon{
+		Binary:           *scamperBin,
+		AttachBinary:     *scattachBin,
+		Warts2JSONBinary: *scwarts2jsonBin,
+		OutputPath:       *outputPath,
+		ControlSocket:    *scamperCtrlSocket,
+	}
+	go daemon.MustStart(ctx)
 
 	connWatcher := connectionwatcher.New()
-	for {
+	for ctx.Err() == nil {
 		closedCollection := connWatcher.GetClosedCollection()
 		fmt.Printf("length of closed connections: %d\n", len(closedCollection))
 		for _, conn := range closedCollection {
-			log.Printf("PT start: %s %d", conn.Remote_ip, conn.Remote_port)
-			go scamper.Run(conn, outputPath)
+			log.Printf("PT start: %s %d", conn.RemoteIP, conn.RemotePort)
+			go daemon.Trace(&conn, time.Now())
 		}
 		time.Sleep(5 * time.Second)
 	}
+	promSrv.Shutdown(ctx)
 }

caller_test.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"context"
+	"testing"
+
+	"github.com/m-lab/go/prometheusx"
+
+	"github.com/m-lab/go/prometheusx/promtest"
+)
+
+func TestMetrics(t *testing.T) {
+	promtest.LintMetrics(t)
+}
+
+func TestMain(t *testing.T) {
+	// Verify that main doesn't crash, and that it does exit when the context is canceled.
+	// TODO: verify more in this test.
+	*prometheusx.ListenAddress = ":0"
+	ctx, cancel = context.WithCancel(context.Background())
+	cancel()
+	main()
+}

connection/connection.go

@@ -7,11 +7,11 @@ import (
 )
 
 type Connection struct {
-	Remote_ip   string
-	Remote_port int
-	Local_ip    string
-	Local_port  int
-	Cookie      string
+	RemoteIP   string
+	RemotePort int
+	LocalIP    string
+	LocalPort  int
+	Cookie     string
 }
 
 // UUID returns uuid from cookie parsed from "ss -e" output.

connection/connection_test.go

@@ -11,7 +11,7 @@ func TestUUID(t *testing.T) {
 	conn := connection.Connection{Cookie: "1be3"}
 	tmp, err := conn.UUID()
 	s := strings.Split(tmp, "_")
-	if err != nil || len(s) != 3 || s[2] != "0000000000001BE3" {
+	if err != nil || s[len(s)-1] != "0000000000001BE3" {
 		t.Error("Make uuid from cookie incorrect")
 	}
 }

connectionwatcher/connectionwatcher.go

@@ -16,8 +16,8 @@ import (
 )
 
 // The new test output filename is joint of hostname, server boot time, and socker TCO cookie.
-// like: pboothe2.nyc.corp.google.com_1548788619_00000000000084FF
-var IGNORE_IPV4_NETS = []string{"127.", "128.112.139.", "::ffff:127.0.0.1"}
+// like: myhost.example.com_1548788619_00000000000084FF
+var localIPv4 = []string{"127.", "128.112.139.", "::ffff:127.0.0.1"}
 
 // parseIPAndPort returns a valid IP and port from "ss -e" output.
 func parseIPAndPort(input string) (string, int, error) {
@@ -29,7 +29,7 @@ func parseIPAndPort(input string) (string, int, error) {
 	if IPStr[0] == '[' {
 		IPStr = IPStr[1 : len(IPStr)-1]
 	}
-	for _, prefix := range IGNORE_IPV4_NETS {
+	for _, prefix := range localIPv4 {
 		if strings.HasPrefix(IPStr, prefix) {
 			return "", 0, errors.New("ignore this IP address")
 		}
@@ -78,7 +78,14 @@ func parseSSLine(line string) (*connection.Connection, error) {
 		return nil, err
 	}
 
-	output := &connection.Connection{Remote_ip: remoteIP, Remote_port: remotePort, Local_ip: localIP, Local_port: localPort, Cookie: cookie}
+	output := &connection.Connection{
+		RemoteIP:   remoteIP,
+		RemotePort: remotePort,
+		LocalIP:    localIP,
+		LocalPort:  localPort,
+		Cookie:     cookie,
+	}
+
 	return output, nil
 }
 
@@ -118,11 +125,11 @@ func (c *ConnectionWatcher) GetClosedCollection() []connection.Connection {
 	c.getConnections()
 	fmt.Printf("new connection size %d\n", len(c.connectionPool))
 	var closed []connection.Connection
-	for conn, _ := range oldConn {
-		if !c.connectionPool[conn] && !c.recentIPCache.Has(conn.Remote_ip) {
+	for conn := range oldConn {
+		if !c.connectionPool[conn] && !c.recentIPCache.Has(conn.RemoteIP) {
 			closed = append(closed, conn)
-			log.Printf("Try to add " + conn.Remote_ip)
-			c.recentIPCache.Add(conn.Remote_ip)
+			log.Printf("Try to add " + conn.RemoteIP)
+			c.recentIPCache.Add(conn.RemoteIP)
 		}
 	}
 	return closed

connectionwatcher/connectionwatcher_test.go

@@ -34,11 +34,11 @@ func TestParseSSLine(t *testing.T) {
 		t.Error("ss output not parsed correctly")
 	}
 	expected := &connection.Connection{
-		Remote_ip:   "2607:f8b0:400d:c0d::81",
-		Remote_port: 5034,
-		Local_ip:    "2620:0:1003:416:a0ad:fd1a:62f:c862",
-		Local_port:  58790,
-		Cookie:      "10f3d"}
+		RemoteIP:   "2607:f8b0:400d:c0d::81",
+		RemotePort: 5034,
+		LocalIP:    "2620:0:1003:416:a0ad:fd1a:62f:c862",
+		LocalPort:  58790,
+		Cookie:     "10f3d"}
 	if !reflect.DeepEqual(conn, expected) {
 		t.Errorf("Expected %v, got %v for parse ss line", expected, conn)
 	}

ipcache/ipcache.go

@@ -9,7 +9,7 @@ import (
 )
 
 // Do not traceroute to an IP more than once in this many seconds
-var IpCacheTimeout = flag.Duration("IpCacheTimeout", 120*time.Second, "Timeout duration in seconds for IPCache")
+var IPCacheTimeout = flag.Duration("IPCacheTimeout", 120*time.Second, "Timeout duration in seconds for IPCache")
 
 type RecentIPCache struct {
 	cache map[string]time.Time
@@ -29,7 +29,7 @@ func New(ctx context.Context) *RecentIPCache {
 				return
 			}
 			for k, v := range m.cache {
-				if now.Sub(v) > *IpCacheTimeout {
+				if now.Sub(v) > *IPCacheTimeout {
 					fmt.Println("try to delete " + k)
 					m.mu.Lock()
 					delete(m.cache, k)

ipcache/ipcache_test.go

@@ -2,24 +2,24 @@ package ipcache_test
 
 import (
 	"context"
-	"flag"
 	"testing"
 	"time"
 
 	"github.com/m-lab/traceroute-caller/ipcache"
 )
 
 func TestRecentIPCache(t *testing.T) {
-	f := flag.Lookup("IpCacheTimeout")
-	f.Value.Set("20")
+	*ipcache.IPCacheTimeout = 2 * time.Second
 
-	tmp := ipcache.New(context.Background())
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	tmp := ipcache.New(ctx)
 	tmp.Add("1.2.3.4")
 	if !tmp.Has("1.2.3.4") {
 		t.Error("cache not working correctly")
 	}
 
-	time.Sleep(22 * time.Second)
+	time.Sleep(4 * time.Second)
 	if tmp.Has("1.2.3.4") {
 		t.Error("cache not expire correctly")
 	}