Merge lp:~mvo/snappy/15.04-watchdog-config into lp:~snappy-dev/snappy/15.04-deprecated

[Michael Vogt]

Enable watchdog configuration via ubuntu-core-config

[lp:~mvo/snappy/15.04-watchdog-config]

473. By Michael Vogt on 2015-09-11

merged parent

Unmerged revisions

=== modified file 'coreconfig/config.go'
--- coreconfig/config.go	2015-04-14 16:46:57 +0000
+++ coreconfig/config.go	2015-09-09 15:59:02 +0000
@@ -22,6 +22,7 @@
 	"io/ioutil"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"reflect"
 	"strings"
 	"syscall"
@@ -40,14 +41,36 @@
 	autopilotTimerDisabled string = "disabled"
 )
 
+var (
+	modprobePath        string = "/etc/modprobe.d/ubuntu-core.conf"
+	networkRoot         string = "/etc/network/interfaces.d/"
+	pppRoot             string = "/etc/ppp/"
+	watchdogConfigPath  string = "/etc/watchdog.conf"
+	watchdogStartupPath string = "/etc/default/watchdog"
+)
+
 // ErrInvalidUnitStatus signals that a unit is not returning a status
 // of "enabled" or "disabled".
 var ErrInvalidUnitStatus = errors.New("invalid unit status")
 
 type systemConfig struct {
-	Autopilot *bool   `yaml:"autopilot,omitempty"`
-	Timezone  *string `yaml:"timezone,omitempty"`
-	Hostname  *string `yaml:"hostname,omitempty"`
+	Autopilot *bool               `yaml:"autopilot,omitempty"`
+	Timezone  *string             `yaml:"timezone,omitempty"`
+	Hostname  *string             `yaml:"hostname,omitempty"`
+	Modprobe  *string             `yaml:"modprobe,omitempty"`
+	Network   []passthroughConfig `yaml:"network,omitempty"`
+	PPP       []passthroughConfig `yaml:"ppp,omitempty"`
+	Watchdog  *watchdogConfig     `yaml:"watchdog,omitempty"`
+}
+
+type passthroughConfig struct {
+	Name    string `yaml:"name,omitempty"`
+	Content string `yaml:"content,omitempty"`
+}
+
+type watchdogConfig struct {
+	Startup string `yaml:"startup,omitempty"`
+	Config  string `yaml:"config,omitempty"`
 }
 
 type coreConfig struct {
@@ -73,11 +96,31 @@
 	if err != nil {
 		return nil, err
 	}
+	modprobe, err := getModprobe()
+	if err != nil {
+		return nil, err
+	}
+	network, err := getNetwork()
+	if err != nil {
+		return nil, err
+	}
+	ppp, err := getPPP()
+	if err != nil {
+		return nil, err
+	}
+	watchdog, err := getWatchdog()
+	if err != nil {
+		return nil, err
+	}
 
 	config := &systemConfig{
 		Autopilot: &autopilot,
 		Timezone:  &tz,
 		Hostname:  &hostname,
+		Modprobe:  &modprobe,
+		Network:   network,
+		PPP:       ppp,
+		Watchdog:  watchdog,
 	}
 
 	return config, nil
@@ -103,6 +146,18 @@
 	return string(out), nil
 }
 
+func passthroughEqual(a, b []passthroughConfig) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i, v := range a {
+		if v != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
 // Set is used to configure settings for the system, this is meant to
 // be used as an interface for snappy config to satisfy the ubuntu-core
 // hook.
@@ -151,6 +206,38 @@
 			if err := setHostname(*newConfig.Hostname); err != nil {
 				return "", err
 			}
+		case "Modprobe":
+			if *oldConfig.Modprobe == *newConfig.Modprobe {
+				continue
+			}
+
+			if err := setModprobe(*newConfig.Modprobe); err != nil {
+				return "", err
+			}
+		case "Network":
+			if passthroughEqual(oldConfig.Network, newConfig.Network) {
+				continue
+			}
+
+			if err := setNetwork(newConfig.Network); err != nil {
+				return "", err
+			}
+		case "PPP":
+			if passthroughEqual(oldConfig.PPP, newConfig.PPP) {
+				continue
+			}
+
+			if err := setPPP(newConfig.PPP); err != nil {
+				return "", err
+			}
+		case "Watchdog":
+			if oldConfig.Watchdog != nil && *oldConfig.Watchdog == *newConfig.Watchdog {
+				continue
+			}
+
+			if err := setWatchdog(newConfig.Watchdog); err != nil {
+				return "", err
+			}
 		}
 	}
 
@@ -184,6 +271,102 @@
 	return ioutil.WriteFile(tzFile(), []byte(timezone), 0644)
 }
 
+func getPassthrough(rootDir string) (pc []passthroughConfig, err error) {
+	filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
+		if info.IsDir() {
+			return nil
+		}
+		content, err := ioutil.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		pc = append(pc, passthroughConfig{
+			Name:    path[len(rootDir)+1:],
+			Content: string(content),
+		})
+		return nil
+	})
+
+	return pc, nil
+
+}
+func setPassthrough(rootDir string, pc []passthroughConfig) error {
+	for _, c := range pc {
+		path := filepath.Join(rootDir, c.Name)
+		if c.Content == "" {
+			os.Remove(path)
+			continue
+		}
+
+		if err := ioutil.WriteFile(path, []byte(c.Content), 0644); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+var getNetwork = func() (pc []passthroughConfig, err error) {
+	return getPassthrough(networkRoot)
+}
+
+var setNetwork = func(pc []passthroughConfig) error {
+	return setPassthrough(networkRoot, pc)
+}
+
+var getPPP = func() (pc []passthroughConfig, err error) {
+	return getPassthrough(pppRoot)
+}
+
+var setPPP = func(pc []passthroughConfig) error {
+	return setPassthrough(pppRoot, pc)
+}
+
+// getModprobe returns the current modprobe config
+var getModprobe = func() (string, error) {
+	modprobe, err := ioutil.ReadFile(modprobePath)
+	if err != nil && !os.IsNotExist(err) {
+		return "", err
+	}
+
+	return string(modprobe), nil
+}
+
+// setModprobe sets the specified modprobe config
+var setModprobe = func(modprobe string) error {
+	return ioutil.WriteFile(modprobePath, []byte(modprobe), 0644)
+}
+
+// getWatchdog returns the current watchdog config
+var getWatchdog = func() (*watchdogConfig, error) {
+	startup, err := ioutil.ReadFile(watchdogStartupPath)
+	if err != nil && !os.IsNotExist(err) {
+		return nil, err
+	}
+	config, err := ioutil.ReadFile(watchdogConfigPath)
+	if err != nil && !os.IsNotExist(err) {
+		return nil, err
+	}
+
+	// nil to make the yaml empty
+	if len(startup) == 0 && len(config) == 0 {
+		return nil, nil
+	}
+
+	return &watchdogConfig{
+		Startup: string(startup),
+		Config:  string(config)}, nil
+}
+
+// setWatchdog sets the specified watchdog config
+var setWatchdog = func(wf *watchdogConfig) error {
+	if err := ioutil.WriteFile(watchdogStartupPath, []byte(wf.Startup), 0644); err != nil {
+		return err
+	}
+
+	return ioutil.WriteFile(watchdogConfigPath, []byte(wf.Config), 0644)
+}
+
 // for testing purposes
 var (
 	cmdAutopilotEnabled = []string{"is-enabled", autopilotTimer}

=== modified file 'coreconfig/config_test.go'
--- coreconfig/config_test.go	2015-08-02 12:21:07 +0000
+++ coreconfig/config_test.go	2015-09-09 15:59:02 +0000
@@ -25,6 +25,7 @@
 	"testing"
 
 	. "gopkg.in/check.v1"
+	"launchpad.net/snappy/helpers"
 )
 
 // Hook up check.v1 into the "go test" runner.
@@ -46,6 +47,11 @@
 	originalCmdAutopilotEnabled = cmdAutopilotEnabled
 	originalCmdSystemctl        = cmdSystemctl
 	originalHostnamePath        = hostnamePath
+	originalModprobePath        = modprobePath
+	originalNetworkRoot         = networkRoot
+	originalPppRoot             = pppRoot
+	originalWatchdogStartupPath = watchdogStartupPath
+	originalWatchdogConfigPath  = watchdogConfigPath
 )
 
 type ConfigTestSuite struct {
@@ -72,6 +78,11 @@
 		hostname = host
 		return nil
 	}
+
+	networkRoot = c.MkDir()
+	pppRoot = c.MkDir()
+	watchdogConfigPath = filepath.Join(c.MkDir(), "watchdog-config")
+	watchdogStartupPath = filepath.Join(c.MkDir(), "watchdog-startup")
 }
 
 func (cts *ConfigTestSuite) TearDownTest(c *C) {
@@ -90,6 +101,11 @@
 	cmdStopAutopilot = originalCmdStopAutopilot
 	cmdAutopilotEnabled = originalCmdAutopilotEnabled
 	cmdSystemctl = originalCmdSystemctl
+	modprobePath = originalModprobePath
+	networkRoot = originalNetworkRoot
+	pppRoot = originalPppRoot
+	watchdogStartupPath = originalWatchdogStartupPath
+	watchdogConfigPath = originalWatchdogConfigPath
 }
 
 // TestGet is a broad test, close enough to be an integration test for
@@ -101,6 +117,7 @@
     autopilot: false
     timezone: America/Argentina/Cordoba
     hostname: testhost
+    modprobe: ""
 `
 
 	rawConfig, err := Get()
@@ -116,6 +133,7 @@
     autopilot: true
     timezone: America/Argentina/Mendoza
     hostname: testhost
+    modprobe: ""
 `
 
 	cmdAutopilotEnabled = []string{"-c", "echo enabled"}
@@ -132,6 +150,7 @@
     autopilot: false
     timezone: America/Argentina/Mendoza
     hostname: testhost
+    modprobe: ""
 `
 
 	rawConfig, err := Set(expected)
@@ -147,6 +166,7 @@
     autopilot: true
     timezone: America/Argentina/Cordoba
     hostname: testhost
+    modprobe: ""
 `
 
 	enabled := false
@@ -165,6 +185,7 @@
     autopilot: false
     timezone: America/Argentina/Cordoba
     hostname: NEWtesthost
+    modprobe: ""
 `
 
 	rawConfig, err := Set(expected)
@@ -178,6 +199,7 @@
     autopilot: false
     timezone America/Argentina/Mendoza
     hostname: testhost
+    modprobe: ""
 `
 
 	rawConfig, err := Set(input)
@@ -191,6 +213,7 @@
     autopilot: false
     timezone: America/Argentina/Cordoba
     hostname: testhost
+    modprobe: ""
 `
 
 	rawConfig, err := Set(input)
@@ -204,12 +227,14 @@
     autopilot: false
     timezone: America/Argentina/Cordoba
     hostname: testhost
+    modprobe: ""
 `
 
 	input := `config:
   ubuntu-core:
     autopilot: false
     timezone: America/Argentina/Cordoba
+    modprobe: ""
 `
 
 	rawConfig, err := Set(input)
@@ -247,6 +272,7 @@
     autopilot: false
     timezone: America/Argentina/Mendoza
     hostname: testhost
+    modprobe: ""
 `
 
 	rawConfig, err := Set(input)
@@ -268,6 +294,7 @@
     autopilot: true
     timezone: America/Argentina/Mendoza
     hostname: testhost
+    modprobe: ""
 `
 
 	enabled := false
@@ -285,6 +312,7 @@
     autopilot: false
     timezone: America/Argentina/Cordoba
     hostname: NEWtesthost
+    modprobe: ""
 `
 
 	setHostname = func(string) error { return errors.New("this is bad") }
@@ -300,6 +328,7 @@
     autopilot: false
     timezone: America/Argentina/Cordoba
     hostname: NEWtesthost
+    modprobe: ""
 `
 
 	getHostname = func() (string, error) { return "", errors.New("this is bad") }
@@ -396,3 +425,217 @@
 	err := setHostname("newhostname")
 	c.Assert(err, DeepEquals, expectedErr)
 }
+
+func (cts *ConfigTestSuite) TestModprobe(c *C) {
+	modprobePath = filepath.Join(c.MkDir(), "test.conf")
+
+	err := setModprobe("blacklist floppy")
+	c.Assert(err, IsNil)
+
+	modprobe, err := getModprobe()
+	c.Assert(err, IsNil)
+	c.Assert(modprobe, Equals, "blacklist floppy")
+}
+
+func (cts *ConfigTestSuite) TestModprobeYaml(c *C) {
+	modprobePath = filepath.Join(c.MkDir(), "test.conf")
+
+	input := `config:
+  ubuntu-core:
+    modprobe: |
+      blacklist floppy
+      softdep mlx4_core post: mlx4_en
+`
+	_, err := Set(input)
+	c.Assert(err, IsNil)
+
+	// ensure its really there
+	content, err := ioutil.ReadFile(modprobePath)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, "blacklist floppy\nsoftdep mlx4_core post: mlx4_en\n")
+}
+
+func (cts *ConfigTestSuite) TestNetworkGet(c *C) {
+	path := filepath.Join(networkRoot, "eth0")
+	content := "auto eth0"
+	err := ioutil.WriteFile(path, []byte(content), 0644)
+	c.Assert(err, IsNil)
+
+	nc, err := getNetwork()
+	c.Assert(err, IsNil)
+	c.Assert(nc, DeepEquals, []passthroughConfig{
+		{Name: "eth0", Content: "auto eth0"},
+	})
+}
+
+func (cts *ConfigTestSuite) TestNetworkSet(c *C) {
+	nc := []passthroughConfig{
+		{Name: "eth0", Content: "auto eth0"},
+	}
+	path := filepath.Join(networkRoot, nc[0].Name)
+	err := setNetwork(nc)
+	c.Assert(err, IsNil)
+	content, err := ioutil.ReadFile(path)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, nc[0].Content)
+}
+
+func (cts *ConfigTestSuite) TestNetworkSetEmptyRemoves(c *C) {
+	path := filepath.Join(networkRoot, "eth0")
+	content := "auto eth0"
+	err := ioutil.WriteFile(path, []byte(content), 0644)
+	c.Assert(err, IsNil)
+
+	// empty content removes
+	nc := []passthroughConfig{
+		{Name: "eth0", Content: ""},
+	}
+	err = setNetwork(nc)
+	c.Assert(err, IsNil)
+	_, err = ioutil.ReadFile(path)
+	c.Assert(helpers.FileExists(path), Equals, false)
+}
+
+func (cts *ConfigTestSuite) TestPppGet(c *C) {
+	path := filepath.Join(pppRoot, "chap-secrets")
+	content := "password"
+	err := ioutil.WriteFile(path, []byte(content), 0644)
+	c.Assert(err, IsNil)
+
+	nc, err := getPPP()
+	c.Assert(err, IsNil)
+	c.Assert(nc, DeepEquals, []passthroughConfig{
+		{Name: "chap-secrets", Content: "password"},
+	})
+}
+
+func (cts *ConfigTestSuite) TestPppSet(c *C) {
+	nc := []passthroughConfig{
+		{Name: "chap-secrets", Content: "another secret"},
+	}
+	path := filepath.Join(pppRoot, nc[0].Name)
+	err := setPPP(nc)
+	c.Assert(err, IsNil)
+	content, err := ioutil.ReadFile(path)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, nc[0].Content)
+}
+
+func (cts *ConfigTestSuite) TestNetworkSetViaYaml(c *C) {
+	modprobePath = filepath.Join(c.MkDir(), "test.conf")
+
+	input := `
+config:
+  ubuntu-core:
+    network:
+      - name: eth0
+        content: auto dhcp
+`
+	_, err := Set(input)
+	c.Assert(err, IsNil)
+
+	// ensure its really there
+	content, err := ioutil.ReadFile(filepath.Join(networkRoot, "eth0"))
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, "auto dhcp")
+}
+
+func (cts *ConfigTestSuite) TestPPPSetViaYaml(c *C) {
+	modprobePath = filepath.Join(c.MkDir(), "test.conf")
+
+	input := `
+config:
+  ubuntu-core:
+    ppp:
+      - name: chap-secret
+        content: password
+`
+	_, err := Set(input)
+	c.Assert(err, IsNil)
+
+	// ensure its really there
+	content, err := ioutil.ReadFile(filepath.Join(pppRoot, "chap-secret"))
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, "password")
+}
+
+func (cts *ConfigTestSuite) TestPassthroughConfigEqual(c *C) {
+	a := []passthroughConfig{
+		{Name: "key", Content: "value"},
+	}
+	b := []passthroughConfig{
+		{Name: "key", Content: "value"},
+	}
+	c.Assert(passthroughEqual(a, b), Equals, true)
+}
+
+func (cts *ConfigTestSuite) TestPassthroughConfigNotEqualDifferentSize(c *C) {
+	a := []passthroughConfig{}
+	b := []passthroughConfig{
+		{Name: "key", Content: "value"},
+	}
+	c.Assert(passthroughEqual(a, b), Equals, false)
+}
+
+func (cts *ConfigTestSuite) TestPassthroughConfigNotEqualDifferentKeys(c *C) {
+	a := []passthroughConfig{
+		{Name: "key", Content: "value"},
+	}
+	b := []passthroughConfig{
+		{Name: "other-key", Content: "value"},
+	}
+	c.Assert(passthroughEqual(a, b), Equals, false)
+}
+
+func (cts *ConfigTestSuite) TestWatchdogGet(c *C) {
+	startup := "# some startup watchdog config"
+	err := ioutil.WriteFile(watchdogStartupPath, []byte(startup), 0644)
+	c.Assert(err, IsNil)
+
+	config := "# some watchdog config"
+	err = ioutil.WriteFile(watchdogConfigPath, []byte(config), 0644)
+	c.Assert(err, IsNil)
+
+	wc, err := getWatchdog()
+	c.Assert(err, IsNil)
+	c.Assert(wc, DeepEquals, &watchdogConfig{
+		Startup: startup, Config: config,
+	})
+}
+
+func (cts *ConfigTestSuite) TestWatchdogSet(c *C) {
+	wc := &watchdogConfig{
+		Startup: "startup", Config: "secret",
+	}
+	err := setWatchdog(wc)
+	c.Assert(err, IsNil)
+
+	content, err := ioutil.ReadFile(watchdogStartupPath)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, wc.Startup)
+
+	content, err = ioutil.ReadFile(watchdogConfigPath)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, wc.Config)
+}
+
+func (cts *ConfigTestSuite) TestWatchdogSetViaYaml(c *C) {
+	input := `
+config:
+  ubuntu-core:
+    watchdog:
+      startup: some startup
+      config: some config
+`
+	_, err := Set(input)
+	c.Assert(err, IsNil)
+
+	// ensure its really there
+	content, err := ioutil.ReadFile(watchdogStartupPath)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, "some startup")
+
+	content, err = ioutil.ReadFile(watchdogConfigPath)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, "some config")
+}