Paris traceroute (#54)

Add paris-traceroute support to traceroute-caller.

Author: pboothe

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/libparistraceroute"]
+	path = vendor/libparistraceroute
+	url = https://github.com/libparistraceroute/libparistraceroute.git

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.12 as build
+FROM golang:1.13 as build
 ADD . /go/src/github.com/m-lab/traceroute-caller
 ENV GOARCH amd64
 ENV CGO_ENABLED 0
@@ -13,15 +13,25 @@ RUN chmod -R a+rx /go/bin/traceroute-caller
 FROM ubuntu:latest
 # Install all the standard packages we need and then remove the apt-get lists.
 RUN apt-get update && \
-    apt-get install -y python python-pip make iproute2 coreutils autoconf && \
+    apt-get install -y python python-pip make iproute2 coreutils autoconf libtool git build-essential && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
 RUN ls -l
-RUN mkdir /source
-ADD ./vendor/scamper/ /source
-RUN chmod +x /source/scamper-cvs-20190916/configure
-WORKDIR /source/scamper-cvs-20190916/
+RUN mkdir /scamper-src
+ADD ./vendor/scamper/ /scamper-src
+RUN chmod +x /scamper-src/scamper-cvs-20190916/configure
+WORKDIR /scamper-src/scamper-cvs-20190916/
+RUN ./configure
+RUN make -j 8
+RUN make install
+RUN ldconfig
+
+RUN mkdir /pt-src
+ADD ./vendor/libparistraceroute/ /pt-src
+WORKDIR /pt-src
+RUN mkdir m4
+RUN ./autogen.sh
 RUN ./configure
 RUN make -j 8
 RUN make install

caller.go

@@ -5,10 +5,12 @@ import (
 	"context"
 	"flag"
 	"log"
+	"os"
 	"sync"
 	"time"
 
 	"github.com/m-lab/traceroute-caller/connection"
+	"github.com/m-lab/traceroute-caller/tracer"
 
 	"github.com/m-lab/go/flagx"
 	"github.com/m-lab/go/rtx"
@@ -18,23 +20,31 @@ import (
 	"github.com/m-lab/traceroute-caller/connectionlistener"
 	"github.com/m-lab/traceroute-caller/connectionpoller"
 	"github.com/m-lab/traceroute-caller/ipcache"
-	"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")
+	scamperBin        = flag.String("scamper.bin", "scamper", "The path to the scamper binary.")
+	scattachBin       = flag.String("scamper.sc_attach", "sc_attach", "The path to the sc_attach binary.")
+	scwarts2jsonBin   = flag.String("scamper.sc_warts2json", "sc_warts2json", "The path to the sc_warts2json binary.")
 	scamperCtrlSocket = flag.String("scamper.unixsocket", "/tmp/scamperctrl", "The name of the UNIX-domain socket that the scamper daemon should listen on")
+	scamperTimeout    = flag.Duration("scamper.timeout", 300*time.Second, "how long to wait to complete a scamper trace.")
+	parisBin          = flag.String("paris.bin", "paris-traceroute", "The path to the paris-traceroute binary.")
+	parisTimeout      = flag.Duration("paris.timeout", 60*time.Second, "how long to wait to complete a paris-traceroute trace.")
 	outputPath        = flag.String("outputPath", "/var/spool/scamper", "path of output")
 	waitTime          = flag.Duration("waitTime", 5*time.Second, "how long to wait between subsequent listings of open connections")
-	eventsocketDryRun = flag.Bool("tcpinfo.eventsocket.dryrun", false, "Whether the eventsocket machinery should be turned on in print-only mode.")
 	poll              = flag.Bool("poll", true, "Whether the polling method should be used to see new connections.")
-	scamperTimeout    = flag.Duration("scamperTimeout", 300*time.Second, "how long to wait to complete a scamper trace.")
+	tracerType        = flagx.Enum{
+		Options: []string{"paris-traceroute", "scamper"},
+		Value:   "scamper",
+	}
 
 	ctx, cancel = context.WithCancel(context.Background())
 )
 
+func init() {
+	flag.Var(&tracerType, "tracetool", "Choose whether paris-traceroute or scamper should be used.")
+}
+
 // Sample cmd:
 // go build
 // ./traceroute-caller --outputPath scamper_output
@@ -43,27 +53,40 @@ func main() {
 
 	flag.Parse()
 	rtx.Must(flagx.ArgsFromEnv(flag.CommandLine), "Could not get args from environment")
+	rtx.Must(os.MkdirAll(*outputPath, 0557), "Could not create data directory")
 
 	defer cancel()
 
 	promSrv := prometheusx.MustServeMetrics()
 	defer promSrv.Shutdown(ctx)
 
-	daemon := scamper.Daemon{
-		Binary:           *scamperBin,
-		AttachBinary:     *scattachBin,
-		Warts2JSONBinary: *scwarts2jsonBin,
-		OutputPath:       *outputPath,
-		ControlSocket:    *scamperCtrlSocket,
-		ScamperTimeout:   *scamperTimeout,
+	var trace ipcache.Tracer
+	switch tracerType.Value {
+	case "scamper":
+		daemon := &tracer.ScamperDaemon{
+			Binary:           *scamperBin,
+			AttachBinary:     *scattachBin,
+			Warts2JSONBinary: *scwarts2jsonBin,
+			OutputPath:       *outputPath,
+			ControlSocket:    *scamperCtrlSocket,
+			ScamperTimeout:   *scamperTimeout,
+		}
+		go func() {
+			daemon.MustStart(ctx)
+			cancel()
+		}()
+		trace = daemon
+	case "paris-traceroute":
+		trace = &tracer.Paris{
+			Binary:     *parisBin,
+			OutputPath: *outputPath,
+			Timeout:    *parisTimeout,
+		}
 	}
-	go func() {
-		daemon.MustStart(ctx)
-		cancel()
-	}()
 
 	wg := sync.WaitGroup{}
-	cache := ipcache.New(ctx, &daemon, *ipcache.IPCacheTimeout, *ipcache.IPCacheUpdatePeriod)
+	cache := ipcache.New(ctx, trace, *ipcache.IPCacheTimeout, *ipcache.IPCacheUpdatePeriod)
+
 	if *poll {
 		wg.Add(1)
 		go func(c *ipcache.RecentIPCache) {
@@ -84,11 +107,6 @@ func main() {
 		go func() {
 			connCreator, err := connection.NewCreator()
 			rtx.Must(err, "Could not discover local IPs")
-			esdaemon := daemon
-			esdaemon.DryRun = *eventsocketDryRun
-			if *eventsocketDryRun {
-				cache = ipcache.New(ctx, &esdaemon, *ipcache.IPCacheTimeout, *ipcache.IPCacheUpdatePeriod)
-			}
 			connListener := connectionlistener.New(connCreator, cache)
 			eventsocket.MustRun(ctx, *eventsocket.Filename, connListener)
 			wg.Done()

caller_test.go

@@ -27,6 +27,8 @@ func TestMain(t *testing.T) {
 	*prometheusx.ListenAddress = ":0"
 	*scamperCtrlSocket = dir + "/scamper.sock"
 	*waitTime = time.Nanosecond // Run through the loop a few times.
+	*outputPath = dir
+	tracerType.Value = "scamper"
 	ctx, cancel = context.WithCancel(context.Background())
 	go func() {
 		time.Sleep(1 * time.Second)
@@ -44,7 +46,8 @@ func TestMainWithConnectionListener(t *testing.T) {
 	*prometheusx.ListenAddress = ":0"
 	*scamperCtrlSocket = dir + "/scamper.sock"
 	*eventsocket.Filename = dir + "/events.sock"
-	*eventsocketDryRun = true
+	*outputPath = dir
+	tracerType.Value = "paris-traceroute"
 
 	ctx, cancel = context.WithCancel(context.Background())
 	go srv.Serve(ctx)

connectionlistener/connectionlistener_test.go

@@ -38,9 +38,9 @@ func (ft *fakeTracer) Trace(conn connection.Connection, t time.Time) (string, er
 	return "Fake test Result", nil
 }
 
-func (ft *fakeTracer) CreateCacheTest(conn connection.Connection, t time.Time, cachedTest string) {
+func (ft *fakeTracer) TraceFromCachedTrace(conn connection.Connection, t time.Time, cachedTest string) error {
 	log.Println("Create cached test for: ", conn)
-	return
+	return nil
 }
 
 func (*fakeTracer) DontTrace(conn connection.Connection, err error) {}

connectionpoller/connectionpoller.go

@@ -100,7 +100,7 @@ func parseSSLine(line string) (*connection.Connection, error) {
 type ssFinder struct{}
 
 func (f *ssFinder) GetConnections() map[connection.Connection]struct{} {
-	cmd := exec.Command(*ssBinary, "-e")
+	cmd := exec.Command(*ssBinary, "-e", "-n")
 	var out bytes.Buffer
 	var stderr bytes.Buffer
 	cmd.Stdout = &out

connectionpoller/connectionpoller_test.go

@@ -130,8 +130,11 @@ func (tt *testTracer) Trace(conn connection.Connection, t time.Time) (string, er
 	return "Fake Trace test", nil
 }
 
-func (tt *testTracer) CreateCacheTest(conn connection.Connection, t time.Time, cachedTest string) {}
-func (tt *testTracer) DontTrace(conn connection.Connection, err error)                            {}
+func (tt *testTracer) TraceFromCachedTrace(conn connection.Connection, t time.Time, cachedTest string) error {
+	return nil
+}
+
+func (tt *testTracer) DontTrace(conn connection.Connection, err error) {}
 
 type testFinder struct {
 }

ipcache/ipcache.go

@@ -21,7 +21,7 @@ var (
 // Tracer is the generic interface for all things that can perform a traceroute.
 type Tracer interface {
 	Trace(conn connection.Connection, t time.Time) (string, error)
-	CreateCacheTest(conn connection.Connection, t time.Time, cachedTest string)
+	TraceFromCachedTrace(conn connection.Connection, t time.Time, cachedTest string) error
 	DontTrace(conn connection.Connection, err error)
 }
 
@@ -64,7 +64,7 @@ func (rc *RecentIPCache) Trace(conn connection.Connection) (string, error) {
 	if cached {
 		<-c.dataReady
 		if c.err == nil {
-			rc.tracer.CreateCacheTest(conn, time.Now(), c.data)
+			rc.tracer.TraceFromCachedTrace(conn, time.Now(), c.data)
 			return c.data, nil
 		}
 		rc.tracer.DontTrace(conn, c.err)
@@ -86,10 +86,10 @@ func (rc *RecentIPCache) GetCacheLength() int {
 
 // New creates and returns a RecentIPCache. It also starts up a background
 // goroutine that scrubs the cache.
-func New(ctx context.Context, tracer Tracer, ipCacheTimeout, ipCacheUpdatePeriod time.Duration) *RecentIPCache {
+func New(ctx context.Context, trace Tracer, ipCacheTimeout, ipCacheUpdatePeriod time.Duration) *RecentIPCache {
 	m := &RecentIPCache{
 		cache:  make(map[string]*cachedTest),
-		tracer: tracer,
+		tracer: trace,
 	}
 	go func() {
 		ticker := time.NewTicker(ipCacheUpdatePeriod)

ipcache/ipcache_test.go

@@ -26,8 +26,9 @@ func (tf *testTracer) Trace(conn connection.Connection, t time.Time) (string, er
 	return "Fake trace test " + conn.RemoteIP, nil
 }
 
-func (tf *testTracer) CreateCacheTest(conn connection.Connection, t time.Time, cachedTest string) {
+func (tf *testTracer) TraceFromCachedTrace(conn connection.Connection, t time.Time, cachedTest string) error {
 	tf.cctest++
+	return nil
 }
 
 func (tf *testTracer) DontTrace(conn connection.Connection, err error) {
@@ -130,9 +131,10 @@ func (pt *pausingTracer) Trace(conn connection.Connection, t time.Time) (string,
 	return "Trace to " + conn.RemoteIP, nil
 }
 
-func (pt *pausingTracer) CreateCacheTest(conn connection.Connection, t time.Time, cachedTest string) {
+func (pt *pausingTracer) TraceFromCachedTrace(conn connection.Connection, t time.Time, cachedTest string) error {
 	randomDelay()
 	atomic.AddInt64(&pt.successes, 1)
+	return nil
 }
 
 func (pt *pausingTracer) DontTrace(conn connection.Connection, err error) {