Merge pull request #15 from m-lab/sandbox-soltesz-rename-throughput1

Rename "ndt8" to "throughput1" throughout

Author: stephen-soltesz

Dockerfile

@@ -16,7 +16,7 @@ COPY --from=build /msak/msak-server /msak/
 COPY --from=build /msak/generate-schema /msak/
 
 # Generate msak's JSON schema.
-RUN /msak/generate-schema -ndt8=/msak/ndt8.json
+RUN /msak/generate-schema -throughput1=/msak/throughput1.json
 
 # Verify that the msak-server binary can be run.
 RUN ./msak-server -h

cmd/generate-schema/main.go

@@ -6,27 +6,27 @@ import (
 
 	"github.com/m-lab/go/cloud/bqx"
 	"github.com/m-lab/go/rtx"
-	"github.com/m-lab/msak/pkg/ndt8/model"
+	"github.com/m-lab/msak/pkg/throughput1/model"
 
 	"cloud.google.com/go/bigquery"
 )
 
 var (
-	ndt8Schema string
+	throughput1Schema string
 )
 
 func init() {
-	flag.StringVar(&ndt8Schema, "ndt8", "/var/spool/datatypes/ndt8.json", "filename to write ndt8 schema")
+	flag.StringVar(&throughput1Schema, "throughput1", "/var/spool/datatypes/throughput1.json", "filename to write throughput1 schema")
 }
 
 func main() {
 	flag.Parse()
 	// Generate and save ndt7 schema for autoloading.
-	ndt8Result := model.NDT8Result{}
-	sch, err := bigquery.InferSchema(ndt8Result)
-	rtx.Must(err, "failed to generate ndt8 schema")
+	throughput1Result := model.Throughput1Result{}
+	sch, err := bigquery.InferSchema(throughput1Result)
+	rtx.Must(err, "failed to generate throughput1 schema")
 	sch = bqx.RemoveRequired(sch)
 	b, err := sch.ToJSONFields()
 	rtx.Must(err, "failed to marshal schema")
-	ioutil.WriteFile(ndt8Schema, b, 0o644)
+	ioutil.WriteFile(throughput1Schema, b, 0o644)
 }

cmd/msak-server/server.go

@@ -16,7 +16,7 @@ import (
 	"github.com/m-lab/go/rtx"
 	"github.com/m-lab/msak/internal/handler"
 	"github.com/m-lab/msak/internal/netx"
-	"github.com/m-lab/msak/pkg/ndt8/spec"
+	"github.com/m-lab/msak/pkg/throughput1/spec"
 )
 
 var (
@@ -71,54 +71,54 @@ func main() {
 		rtx.Must(err, "Failed to load verifier")
 	}
 	// Enforce tokens on uploads and downloads.
-	ndt8TxPaths := controller.Paths{
+	throughput1TxPaths := controller.Paths{
 		spec.DownloadPath: true,
 		spec.UploadPath:   true,
 	}
-	ndt8TokenPaths := controller.Paths{
+	throughput1TokenPaths := controller.Paths{
 		spec.DownloadPath: true,
 		spec.UploadPath:   true,
 	}
 	acm, _ := controller.Setup(ctx, v, tokenVerify, tokenMachine,
-		ndt8TxPaths, ndt8TokenPaths)
+		throughput1TxPaths, throughput1TokenPaths)
 
-	ndt8Mux := http.NewServeMux()
-	ndt8Handler := handler.New(*flagDataDir)
-	ndt8Mux.Handle(spec.DownloadPath, http.HandlerFunc(ndt8Handler.Download))
-	ndt8Mux.Handle(spec.UploadPath, http.HandlerFunc(ndt8Handler.Upload))
-	ndt8ServerCleartext := httpServer(
+	throughput1Mux := http.NewServeMux()
+	throughput1Handler := handler.New(*flagDataDir)
+	throughput1Mux.Handle(spec.DownloadPath, http.HandlerFunc(throughput1Handler.Download))
+	throughput1Mux.Handle(spec.UploadPath, http.HandlerFunc(throughput1Handler.Upload))
+	throughput1ServerCleartext := httpServer(
 		*flagEndpointCleartext,
-		acm.Then(ndt8Mux))
+		acm.Then(throughput1Mux))
 
 	log.Info("About to listen for ws tests", "endpoint", *flagEndpointCleartext)
 
-	tcpl, err := net.Listen("tcp", ndt8ServerCleartext.Addr)
+	tcpl, err := net.Listen("tcp", throughput1ServerCleartext.Addr)
 	rtx.Must(err, "failed to create listener")
 	l := netx.NewListener(tcpl.(*net.TCPListener))
 	defer l.Close()
 
 	go func() {
-		err := ndt8ServerCleartext.Serve(l)
+		err := throughput1ServerCleartext.Serve(l)
 		rtx.Must(err, "Could not start cleartext server")
-		defer ndt8ServerCleartext.Close()
+		defer throughput1ServerCleartext.Close()
 	}()
 
 	// Only start TLS-based services if certs and keys are provided
 	if *flagCertFile != "" && *flagKeyFile != "" {
-		ndt8Server := httpServer(
+		throughput1Server := httpServer(
 			*flagEndpoint,
-			acm.Then(ndt8Mux))
+			acm.Then(throughput1Mux))
 		log.Info("About to listen for wss tests", "endpoint", *flagEndpoint)
 
-		tcpl, err := net.Listen("tcp", ndt8Server.Addr)
+		tcpl, err := net.Listen("tcp", throughput1Server.Addr)
 		rtx.Must(err, "failed to create listener")
 		l := netx.NewListener(tcpl.(*net.TCPListener))
 		defer l.Close()
 
 		go func() {
-			err := ndt8Server.ServeTLS(l, *flagCertFile, *flagKeyFile)
+			err := throughput1Server.ServeTLS(l, *flagCertFile, *flagKeyFile)
 			rtx.Must(err, "Could not start cleartext server")
-			defer ndt8Server.Close()
+			defer throughput1Server.Close()
 		}()
 	}
 

internal/handler/handler.go

@@ -14,13 +14,13 @@ import (
 	"github.com/m-lab/go/prometheusx"
 	"github.com/m-lab/msak/internal/netx"
 	"github.com/m-lab/msak/internal/persistence"
-	"github.com/m-lab/msak/pkg/ndt8"
-	"github.com/m-lab/msak/pkg/ndt8/model"
+	"github.com/m-lab/msak/pkg/throughput1"
+	"github.com/m-lab/msak/pkg/throughput1/model"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 )
 
-// knownOptions are the known ndt8 options.
+// knownOptions are the known throughput1 options.
 var knownOptions = map[string]struct{}{
 	"streams":      {},
 	"duration":     {},
@@ -41,7 +41,7 @@ var (
 	ClientConnections = promauto.NewCounterVec(
 		prometheus.CounterOpts{
 			Namespace: "msak",
-			Subsystem: "ndt8",
+			Subsystem: "throughput1",
 			Name:      "client_connections_total",
 		},
 		[]string{"direction", "status"},
@@ -142,10 +142,10 @@ func (h *Handler) upgradeAndRunMeasurement(kind model.TestDirection, rw http.Res
 	}
 
 	// Everything looks good, try upgrading the connection to WebSocket.
-	// Once upgraded, the underlying TCP connection is hijacked and the ndt8
+	// Once upgraded, the underlying TCP connection is hijacked and the throughput1
 	// protocol code will take care of closing it. Note that for this reason
 	// we cannot call writeBadRequest after attempting an Upgrade.
-	wsConn, err := ndt8.Upgrade(rw, req)
+	wsConn, err := throughput1.Upgrade(rw, req)
 	if err != nil {
 		ClientConnections.WithLabelValues(string(kind),
 			"websocket-upgrade-failed").Inc()
@@ -182,7 +182,7 @@ func (h *Handler) upgradeAndRunMeasurement(kind model.TestDirection, rw http.Res
 		wsConn.Close()
 		return
 	}
-	archivalData := model.NDT8Result{
+	archivalData := model.Throughput1Result{
 		MeasurementID:  mid,
 		UUID:           uuid,
 		StartTime:      time.Now(),
@@ -203,7 +203,7 @@ func (h *Handler) upgradeAndRunMeasurement(kind model.TestDirection, rw http.Res
 	timeout, cancel := context.WithTimeout(req.Context(), duration)
 	defer cancel()
 
-	proto := ndt8.New(wsConn)
+	proto := throughput1.New(wsConn)
 	var senderCh, receiverCh <-chan model.WireMeasurement
 	var errCh <-chan error
 	if kind == model.DirectionDownload {
@@ -243,12 +243,12 @@ func (h *Handler) upgradeAndRunMeasurement(kind model.TestDirection, rw http.Res
 	}
 }
 
-func (h *Handler) writeResult(uuid string, kind model.TestDirection, result *model.NDT8Result) {
+func (h *Handler) writeResult(uuid string, kind model.TestDirection, result *model.Throughput1Result) {
 	_, err := persistence.WriteDataFile(
-		h.archivalDataDir, "ndt8", string(kind), uuid,
+		h.archivalDataDir, "throughput1", string(kind), uuid,
 		result)
 	if err != nil {
-		log.Error("failed to write ndt8 result", "uuid", uuid, "error", err)
+		log.Error("failed to write throughput1 result", "uuid", uuid, "error", err)
 		return
 	}
 }

internal/handler/handler_test.go

@@ -15,9 +15,9 @@ import (
 	"github.com/m-lab/go/rtx"
 	"github.com/m-lab/msak/internal/handler"
 	"github.com/m-lab/msak/internal/netx"
-	"github.com/m-lab/msak/pkg/ndt8"
-	"github.com/m-lab/msak/pkg/ndt8/model"
-	"github.com/m-lab/msak/pkg/ndt8/spec"
+	"github.com/m-lab/msak/pkg/throughput1"
+	"github.com/m-lab/msak/pkg/throughput1/model"
+	"github.com/m-lab/msak/pkg/throughput1/spec"
 )
 
 func TestNew(t *testing.T) {
@@ -76,7 +76,7 @@ func TestHandler_Upload(t *testing.T) {
 	if conn == nil {
 		t.Fatalf("websocket dial returned nil")
 	}
-	proto := ndt8.New(conn)
+	proto := throughput1.New(conn)
 	timeout, cancel := context.WithTimeout(context.Background(), 1*time.Second)
 	defer cancel()
 	senderCh, receiverCh, errCh := proto.SenderLoop(timeout)
@@ -123,7 +123,7 @@ func TestHandler_Download(t *testing.T) {
 		t.Fatalf("websocket dial returned nil")
 	}
 
-	proto := ndt8.New(conn)
+	proto := throughput1.New(conn)
 	timeout, cancel := context.WithTimeout(context.Background(), 1*time.Second)
 	defer cancel()
 	senderCh, receiverCh, errCh := proto.ReceiverLoop(timeout)

internal/measurer/measurer.go

@@ -1,6 +1,6 @@
 // The measurer package provides functions to periodically read kernel metrics
 // for a given network connection and return them over a channel wrapped in an
-// ndt8 Measurement object.
+// throughput1 Measurement object.
 package measurer
 
 import (
@@ -12,11 +12,11 @@ import (
 	"github.com/m-lab/go/memoryless"
 	"github.com/m-lab/go/rtx"
 	"github.com/m-lab/msak/internal/netx"
-	"github.com/m-lab/msak/pkg/ndt8/model"
-	"github.com/m-lab/msak/pkg/ndt8/spec"
+	"github.com/m-lab/msak/pkg/throughput1/model"
+	"github.com/m-lab/msak/pkg/throughput1/spec"
 )
 
-type ndt8Measurer struct {
+type throughput1Measurer struct {
 	connInfo            netx.ConnInfo
 	startTime           time.Time
 	bytesReadAtStart    int64
@@ -33,7 +33,7 @@ type ndt8Measurer struct {
 // If passed a connection that is not a netx.Conn, this function will panic.
 func Start(ctx context.Context, conn net.Conn) <-chan model.Measurement {
 	// Implementation note: this channel must be buffered to account for slow
-	// readers. The "typical" reader is an ndt8 send or receive loop, which
+	// readers. The "typical" reader is an throughput1 send or receive loop, which
 	// might be busy with data r/w. The buffer size corresponds to at least 10
 	// seconds:
 	//
@@ -42,7 +42,7 @@ func Start(ctx context.Context, conn net.Conn) <-chan model.Measurement {
 
 	connInfo := netx.ToConnInfo(conn)
 	read, written := connInfo.ByteCounters()
-	m := &ndt8Measurer{
+	m := &throughput1Measurer{
 		connInfo:  connInfo,
 		dstChan:   dst,
 		startTime: time.Now(),
@@ -58,7 +58,7 @@ func Start(ctx context.Context, conn net.Conn) <-chan model.Measurement {
 	return dst
 }
 
-func (m *ndt8Measurer) loop(ctx context.Context) {
+func (m *throughput1Measurer) loop(ctx context.Context) {
 	log.Debug("Measurer started", "context", ctx)
 	defer log.Debug("Measurer stopped", "context", ctx)
 	t, err := memoryless.NewTicker(ctx, memoryless.Config{
@@ -81,7 +81,7 @@ func (m *ndt8Measurer) loop(ctx context.Context) {
 	}
 }
 
-func (m *ndt8Measurer) measure(ctx context.Context) {
+func (m *throughput1Measurer) measure(ctx context.Context) {
 	// On non-Linux systems, collecting kernel metrics WILL fail. In that case,
 	// we still want to return a (empty) Measurement.
 	bbrInfo, tcpInfo, err := m.connInfo.Info()

pkg/ndt8/model/measurement.go pkg/throughput1/model/measurement.gopkg/ndt8/model/measurement.go renamed to pkg/throughput1/model/measurement.go

@@ -4,9 +4,9 @@ import (
 	"time"
 )
 
-// NDT8Result is the struct that is serialized as JSON to disk as the archival
-// record of an ndt8 test.
-type NDT8Result struct {
+// Throughput1Result is the struct that is serialized as JSON to disk as the archival
+// record of an throughput1 test.
+type Throughput1Result struct {
 	// GitShortCommit is the Git commit (short form) of the running server code.
 	GitShortCommit string
 	// Version is the symbolic version (if any) of the running server code.

pkg/ndt8/model/namevalue.go pkg/throughput1/model/namevalue.gopkg/ndt8/model/namevalue.go renamed to pkg/throughput1/model/namevalue.go

@@ -1,4 +1,4 @@
-package ndt8
+package throughput1
 
 import (
 	"context"
@@ -15,8 +15,8 @@ import (
 	"github.com/gorilla/websocket"
 	"github.com/m-lab/msak/internal/measurer"
 	"github.com/m-lab/msak/internal/netx"
-	"github.com/m-lab/msak/pkg/ndt8/model"
-	"github.com/m-lab/msak/pkg/ndt8/spec"
+	"github.com/m-lab/msak/pkg/throughput1/model"
+	"github.com/m-lab/msak/pkg/throughput1/spec"
 )
 
 type senderFunc func(ctx context.Context,
@@ -27,7 +27,7 @@ type Measurer interface {
 	Start(context.Context, net.Conn) <-chan model.Measurement
 }
 
-// DefaultMeasurer is the default ndt8 measurer that wraps the measurer
+// DefaultMeasurer is the default throughput1 measurer that wraps the measurer
 // package's Start function.
 type DefaultMeasurer struct{}
 
@@ -36,7 +36,7 @@ func (*DefaultMeasurer) Start(ctx context.Context,
 	return measurer.Start(ctx, c)
 }
 
-// Protocol is the implementation of the ndt8 protocol.
+// Protocol is the implementation of the throughput1 protocol.
 type Protocol struct {
 	conn     *websocket.Conn
 	connInfo netx.ConnInfo
@@ -61,7 +61,7 @@ func New(conn *websocket.Conn) *Protocol {
 // Upgrade takes a HTTP request and upgrades the connection to WebSocket.
 // Returns a websocket Conn if the upgrade succeeded, and an error otherwise.
 func Upgrade(w http.ResponseWriter, r *http.Request) (*websocket.Conn, error) {
-	// We expect WebSocket's subprotocol to be ndt8's. The same subprotocol is
+	// We expect WebSocket's subprotocol to be throughput1's. The same subprotocol is
 	// added as a header on the response.
 	if r.Header.Get("Sec-WebSocket-Protocol") != spec.SecWebSocketProtocol {
 		w.WriteHeader(http.StatusBadRequest)
@@ -91,7 +91,7 @@ func (p *Protocol) makePreparedMessage(size int) (*websocket.PreparedMessage, er
 	return websocket.NewPreparedMessage(websocket.BinaryMessage, data)
 }
 
-// SenderLoop starts the send loop of the ndt8 protocol. The context's lifetime
+// SenderLoop starts the send loop of the throughput1 protocol. The context's lifetime
 // determines how long to run for. It returns one channel for sender-side
 // measurements, one channel for receiver-side measurements and one channel for
 // errors. While the measurements channels could be ignored, the errors channel
@@ -101,7 +101,7 @@ func (p *Protocol) SenderLoop(ctx context.Context) (<-chan model.WireMeasurement
 	return p.senderReceiverLoop(ctx, p.sender)
 }
 
-// ReceiverLoop starts the receiver loop of the ndt8 protocol. The context's
+// ReceiverLoop starts the receiver loop of the throughput1 protocol. The context's
 // lifetime determines how long to run for. It returns one channel for
 // sender-side measurements, one channel for receiver-side measurements and one
 // channel for errors. While the measurements channels could be ignored, the