Merge pull request #9 from m-lab/convert-to-config

Move the config into the k8s deployment, where it belongs.

Author: pboothe

Dockerfile

@@ -8,12 +8,8 @@ RUN go get \
     ./...
 
 FROM alpine:3.7
+# Add all binaries that we may want to run that are not in alpine by default.
 RUN apk add --no-cache lshw
 COPY --from=build /go/bin/nodeinfo /
 WORKDIR /
-# Run things once to verify that every command invoked can be invoked inside the container.
-RUN mkdir smoketest && /nodeinfo -smoketest -datadir smoketest && rm -Rf /smoketest
-# Remove the created directory to allow it to be a mountpoint when deployed.
-RUN rm -Rf /var/spool/nodeinfo
-# If we made it here, then everything works!
 ENTRYPOINT ["/nodeinfo"]

README.md

@@ -12,8 +12,65 @@ Available as a container in
 [measurementlab/nodeinfo](https://hub.docker.com/r/measurementlab/nodeinfo/) on
 Docker Hub.
 
-# design
+## design
 
-As simple as possible. This system is called `nodeinfo`. Every command produces its own type of data, and so is it own datatype.  These two facts, together with [M-Lab's unified naming scheme for data](http://example.com), and the best practices for [Pusher](http://github.com/m-lab/pusher) mean that the directory structure for output is fully determined. 
+As simple as possible. This system is called `nodeinfo`. Every command produces its own type of data, and so is it own datatype.  These two facts, together with [M-Lab's unified naming scheme for data](http://example.com), and the best practices for [Pusher](http://github.com/m-lab/pusher) mean that the directory structure for output is fully determined.
 
 This program calls a series of other programs, and directs the output of each call to the appropriate output file. The set of programs to call is currently hard-coded in the binary. If any of the commands run unsuccessfully, this crashes.  Every command is rerun every hour on average, with some randomness. The inter-run times are drawn from the exponential distribution to try and make sure the resulting series of measurements has the [PASTA property](https://en.wikipedia.org/wiki/Arrival_theorem).
+
+## example config file
+
+```json
+[
+  {
+    "Dataype": "lshw",
+    "Filename": "lshw.json",
+    "Cmd":      ["lshw", "-json"]
+  },
+  {
+    "Dataype": "lspci",
+    "Filename": "lspci.txt",
+    "Cmd":      ["lspci", "-mm", "-vv", "-k", "-nn"]
+  },
+  {
+    "Dataype": "lsusb",
+    "Filename": "lsusb.txt",
+    "Cmd":      ["lsusb", "-v"]
+  },
+  {
+    "Dataype": "ip-address",
+    "Filename": "ip-address.txt",
+    "Cmd":      ["ip", "address", "show"]
+  },
+  {
+    "Dataype": "ip-route-4",
+    "Filename": "ip-route-4.txt",
+    "Cmd":      ["ip", "-4", "route", "show"]
+  },
+  {
+    "Dataype": "ip-route-6",
+    "Filename": "ip-route-6.txt",
+    "Cmd":      ["ip", "-6", "route", "show"]
+  },
+  {
+    "Dataype": "uname",
+    "Filename": "uname.txt",
+    "Cmd":      ["uname", "-a"]
+  },
+  {
+    "Dataype": "os-release",
+    "Filename": "os-release.txt",
+    "Cmd":      ["cat", "/etc/os-release"]
+  },
+  {
+    "Dataype": "bios_version",
+    "Filename": "bios_version.txt",
+    "Cmd":      ["cat", "/sys/class/dmi/id/bios_version"]
+  },
+  {
+    "Dataype": "chassis_serial",
+    "Filename": "chassis_serial.txt",
+    "Cmd":      ["cat", "/sys/class/dmi/id/chassis_serial"]
+  }
+]
+```

config/config.go

@@ -0,0 +1,59 @@
+package config
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"log"
+
+	"github.com/m-lab/nodeinfo/data"
+	"github.com/m-lab/nodeinfo/metrics"
+)
+
+// Config contains the configuration of nodeinfo that is stored in a separate
+// config file.
+type Config interface {
+	Reload() error
+	Gatherers() []data.Gatherer
+}
+
+// Create creates a new config based on the passed-in file name and contents. If
+// the file can't be read or parsed, then this will return a non-nil error.
+func Create(filename string) (Config, error) {
+	c := &fileconfig{
+		filename: filename,
+	}
+	err := c.Reload()
+	return c, err
+}
+
+// fileconfig contains the full runtime config of nodeinfo.
+type fileconfig struct {
+	filename  string
+	gatherers []data.Gatherer
+}
+
+// Reload the list of gatherers from the original config filename. Returns a
+// non-nil error if unsuccessful.
+func (c *fileconfig) Reload() error {
+	metrics.ConfigLoadCount.Inc()
+	contents, err := ioutil.ReadFile(c.filename)
+	if err != nil {
+		log.Println("Could not read file")
+		return err
+	}
+	var g []data.Gatherer
+	err = json.Unmarshal(contents, &g)
+	if err != nil {
+		log.Printf("Could not parse %q", c.filename)
+		return err
+	}
+	c.gatherers = g
+	metrics.ConfigLoadTime.SetToCurrentTime()
+	return nil
+}
+
+// Gatherers returns a slice of data gatherers. The backing storage for a given
+// slice should be immutable.
+func (c *fileconfig) Gatherers() []data.Gatherer {
+	return c.gatherers
+}

config/config_test.go

@@ -0,0 +1,77 @@
+package config_test
+
+import (
+	"io/ioutil"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/m-lab/nodeinfo/config"
+	"github.com/m-lab/nodeinfo/data"
+
+	"github.com/m-lab/go/rtx"
+)
+
+func TestConfigCreationAndReload(t *testing.T) {
+	dir, err := ioutil.TempDir("", "TestConfigCreation")
+	rtx.Must(err, "Could not create tempdir")
+	defer os.RemoveAll(dir)
+
+	filecontents := `[
+		{
+			"Datatype": "uname",
+			"Filename": "uname.txt",
+			"Cmd": ["uname", "-a"]
+		},
+		{
+			"Datatype": "ifconfig",
+			"Filename": "ifconfig.txt",
+			"Cmd": ["ifconfig"]
+		}
+	]
+	`
+	expected := []data.Gatherer{
+		{Datatype: "uname", Filename: "uname.txt", Cmd: []string{"uname", "-a"}},
+		{Datatype: "ifconfig", Filename: "ifconfig.txt", Cmd: []string{"ifconfig"}},
+	}
+	rtx.Must(ioutil.WriteFile(dir+"/config.json", []byte(filecontents), 0666), "Could not write config")
+	c, err := config.Create(dir + "/config.json")
+	rtx.Must(err, "Could not read config.json")
+	g := c.Gatherers()
+	if !reflect.DeepEqual(g, expected) {
+		t.Errorf("%v != %v", g, expected)
+	}
+
+	filecontents2 := `[
+		{
+			"Datatype": "ls",
+			"Filename": "ls.txt",
+			"Cmd": ["ls", "-l"]
+		}
+	]
+	`
+	expected2 := []data.Gatherer{
+		{Datatype: "ls", Filename: "ls.txt", Cmd: []string{"ls", "-l"}},
+	}
+	rtx.Must(ioutil.WriteFile(dir+"/config.json", []byte(filecontents2), 0666), "Could not write replacement config")
+	rtx.Must(c.Reload(), "Could not reload config")
+	g = c.Gatherers()
+	if !reflect.DeepEqual(g, expected2) {
+		t.Errorf("%v != %v", g, expected2)
+	}
+	rtx.Must(ioutil.WriteFile(dir+"/config.json", []byte("bad content"), 0666), "Could not write replacement config")
+	if c.Reload() == nil {
+		t.Error("We should not have been able to reload the config")
+	}
+	g = c.Gatherers()
+	if !reflect.DeepEqual(g, expected2) {
+		t.Errorf("%v != %v", g, expected2)
+	}
+}
+
+func TestConfigOnBadFile(t *testing.T) {
+	_, err := config.Create("/this/file/does/not/exist")
+	if err == nil {
+		t.Error("This should not have succeeded")
+	}
+}

main.go

@@ -3,113 +3,70 @@
 // small files, each with the output of "ifconfig" or "lshw" or another command
 // like that. The hope is that by doing this, we will be able to track over
 // time what hardware was installed, what software versions were running, and
-// how the network was configured on every node in the M-Lab fleet.  Every time
-// we turn out to need a new small diagnostic command, that command should be
-// added to the list and a new image pushed.
+// how the network was configured on every node in the M-Lab fleet.
+//
+// nodeinfo reads the list of commands and datatypes in from a config file. It
+// rereads the config file every time it runs, to allow that file to be deployed
+// as a ConfigMap in kubernetes.
 package main
 
 import (
 	"context"
 	"flag"
 	"log"
-	"strings"
 	"time"
 
-	"github.com/m-lab/go/prometheusx"
-
 	"github.com/m-lab/go/flagx"
 	"github.com/m-lab/go/memoryless"
+	"github.com/m-lab/go/prometheusx"
 	"github.com/m-lab/go/rtx"
-
-	"github.com/m-lab/nodeinfo/data"
+	"github.com/m-lab/nodeinfo/config"
+	"github.com/m-lab/nodeinfo/metrics"
 )
 
+// Command-line flags
 var (
-	datadir     = flag.String("datadir", "/var/spool/nodeinfo", "The root directory in which to put all produced data")
-	once        = flag.Bool("once", false, "Only gather data once")
-	smoketest   = flag.Bool("smoketest", false, "Gather every type of data once. Used to test that all data types can be gathered.")
-	waittime    = flag.Duration("wait", 1*time.Hour, "How long (in expectation) to wait between runs")
-	datatypes   = flagx.StringArray{}
-	ctx, cancel = context.WithCancel(context.Background())
+	datadir    = flag.String("datadir", "/var/spool/nodeinfo", "The root directory in which to put all produced data")
+	once       = flag.Bool("once", false, "Only gather data once")
+	smoketest  = flag.Bool("smoketest", false, "Gather every type of data once. Used to test that all configured data types can be gathered.")
+	waittime   = flag.Duration("wait", 1*time.Hour, "How long (in expectation) to wait between runs")
+	configFile = flag.String("config", "/etc/nodeinfo/config.json", "The name of the config file to load from disk.")
 
-	gatherers = map[string]data.Gatherer{
-		"lshw": {
-			Datatype: "lshw",
-			Filename: "lshw.json",
-			Cmd:      []string{"lshw", "-json"},
-		},
-		"lspci": {
-			Datatype: "lspci",
-			Filename: "lspci.txt",
-			Cmd:      []string{"lspci", "-mm", "-vv", "-k", "-nn"},
-		},
-		"lsusb": {
-			Datatype: "lsusb",
-			Filename: "lsusb.txt",
-			Cmd:      []string{"lsusb", "-v"},
-		},
-		"ifconfig": {
-			Datatype: "ifconfig",
-			Filename: "ifconfig.txt",
-			Cmd:      []string{"ifconfig", "-a"},
-		},
-		"route-v4": {
-			Datatype: "route",
-			Filename: "route-ipv4.txt",
-			Cmd:      []string{"route", "-n", "-A", "inet"},
-		},
-		"route-v6": {
-			Datatype: "route",
-			Filename: "route-ipv6.txt",
-			Cmd:      []string{"route", "-n", "-A", "inet6"},
-		},
-		"uname": {
-			Datatype: "uname",
-			Filename: "uname.txt",
-			Cmd:      []string{"uname", "-a"},
-		},
-	}
-)
+	// A context and associate cancellation function which, when called, should cause main to exit.
+	mainCtx, mainCancel = context.WithCancel(context.Background())
 
-func possibleTypes() []string {
-	datatypes := []string{}
-	for datatype := range gatherers {
-		datatypes = append(datatypes, datatype)
-	}
-	return datatypes
-}
+	// Contents of this should be filled in as part of parsing commandline flags.
+	gatherers config.Config
+)
 
 func init() {
 	log.SetFlags(log.Lshortfile | log.LUTC | log.LstdFlags)
-
-	flag.Var(&datatypes, "datatype", "What datatype should be collected. This flag can be used multiple times.  The set of possible datatypes is: {"+strings.Join(possibleTypes(), ", ")+"}")
 }
 
 // Runs every data gatherer.
 func gather() {
+	err := gatherers.Reload()
+	if err != nil {
+		metrics.ConfigLoadFailures.Inc()
+		log.Println("Could not reload the config. Using old config.")
+	}
 	t := time.Now()
-	for _, datatype := range datatypes {
-		g, ok := gatherers[datatype]
-		if ok {
-			g.Gather(t, *datadir, *smoketest)
-		} else {
-			log.Println("Unknown datatype:", datatype)
-		}
+	for _, g := range gatherers.Gatherers() {
+		g.Gather(t, *datadir, *smoketest)
 	}
 }
 
 func main() {
 	flag.Parse()
-	flagx.ArgsFromEnv(flag.CommandLine)
-	if *smoketest {
-		*once = true
-		datatypes = possibleTypes()
-	}
+	rtx.Must(flagx.ArgsFromEnv(flag.CommandLine), "Could not parse args from environment")
 
-	srv := prometheusx.MustServeMetrics()
-	defer srv.Close()
+	metricSrv := prometheusx.MustServeMetrics()
+	defer metricSrv.Shutdown(mainCtx)
 
+	var err error
+	gatherers, err = config.Create(*configFile)
+	rtx.Must(err, "Could not read config on the first try. Shutting down.")
 	rtx.Must(
-		memoryless.Run(ctx, gather, memoryless.Config{Expected: *waittime, Max: 4 * (*waittime), Once: *once}),
+		memoryless.Run(mainCtx, gather, memoryless.Config{Expected: *waittime, Max: 4 * (*waittime), Once: *once || *smoketest}),
 		"Bad time arguments.")
 }