coreos-cloudinit: bump to 0.11.2

config: fix parsing of file permissions

Documentation/cloud-config.md

@@ -97,6 +97,29 @@ For more information on fleet configuration, see the [fleet documentation][fleet
 
 [fleet-config]: https://github.com/coreos/fleet/blob/master/Documentation/deployment-and-configuration.md#configuration
 
+#### flannel
+
+The `coreos.flannel.*` parameters also work very similarly to `coreos.etcd.*` and `coreos.fleet.*`. They can be used to set enviornment variables for flanneld. Given the following cloud-config...
+
+```yaml
+#cloud-config
+
+coreos:
+    flannel:
+        etcd-prefix: /coreos.com/network2
+```
+
+...will generate systemd unit drop-in like so:
+
+```
+[Service]
+Environment="FLANNELD_ETCD_PREFIX=/coreos.com/network2"
+```
+
+For complete list of flannel configuraion parameters, see the [flannel documentation][flannel-readme].
+
+[flannel-readme]: https://github.com/coreos/flannel/blob/master/README.md
+
 #### update
 
 The `coreos.update.*` parameters manipulate settings related to how CoreOS instances are updated.
@@ -303,7 +326,7 @@ Each item in the list may have the following keys:
 
 - **path**: Absolute location on disk where contents should be written
 - **content**: Data to write at the provided `path`
-- **permissions**: String representing file permissions in octal notation (i.e. '0644')
+- **permissions**: Integer representing file permissions, typically in octal notation (i.e. 0644)
 - **owner**: User and group that should own the file written to disk. This is equivalent to the `<user>:<group>` argument to `chown <user>:<group> <path>`.
 
 Explicitly not implemented is the **encoding** attribute.

config/config.go

@@ -0,0 +1,186 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/coreos/coreos-cloudinit/Godeps/_workspace/src/gopkg.in/yaml.v1"
+)
+
+// CloudConfig encapsulates the entire cloud-config configuration file and maps
+// directly to YAML. Fields that cannot be set in the cloud-config (fields
+// used for internal use) have the YAML tag '-' so that they aren't marshalled.
+type CloudConfig struct {
+	SSHAuthorizedKeys []string `yaml:"ssh_authorized_keys"`
+	Coreos            struct {
+		Etcd    Etcd    `yaml:"etcd"`
+		Flannel Flannel `yaml:"flannel"`
+		Fleet   Fleet   `yaml:"fleet"`
+		OEM     OEM     `yaml:"oem"`
+		Update  Update  `yaml:"update"`
+		Units   []Unit  `yaml:"units"`
+	} `yaml:"coreos"`
+	WriteFiles        []File   `yaml:"write_files"`
+	Hostname          string   `yaml:"hostname"`
+	Users             []User   `yaml:"users"`
+	ManageEtcHosts    EtcHosts `yaml:"manage_etc_hosts"`
+	NetworkConfigPath string   `yaml:"-"`
+	NetworkConfig     string   `yaml:"-"`
+}
+
+func IsCloudConfig(userdata string) bool {
+	header := strings.SplitN(userdata, "\n", 2)[0]
+
+	// Explicitly trim the header so we can handle user-data from
+	// non-unix operating systems. The rest of the file is parsed
+	// by yaml, which correctly handles CRLF.
+	header = strings.TrimSuffix(header, "\r")
+
+	return (header == "#cloud-config")
+}
+
+// NewCloudConfig instantiates a new CloudConfig from the given contents (a
+// string of YAML), returning any error encountered. It will ignore unknown
+// fields but log encountering them.
+func NewCloudConfig(contents string) (*CloudConfig, error) {
+	var cfg CloudConfig
+	ncontents, err := normalizeConfig(contents)
+	if err != nil {
+		return &cfg, err
+	}
+	if err = yaml.Unmarshal(ncontents, &cfg); err != nil {
+		return &cfg, err
+	}
+	return &cfg, nil
+}
+
+func (cc CloudConfig) String() string {
+	bytes, err := yaml.Marshal(cc)
+	if err != nil {
+		return ""
+	}
+
+	stringified := string(bytes)
+	stringified = fmt.Sprintf("#cloud-config\n%s", stringified)
+
+	return stringified
+}
+
+// IsZero returns whether or not the parameter is the zero value for its type.
+// If the parameter is a struct, only the exported fields are considered.
+func IsZero(c interface{}) bool {
+	return isZero(reflect.ValueOf(c))
+}
+
+type ErrorValid struct {
+	Value string
+	Valid []string
+	Field string
+}
+
+func (e ErrorValid) Error() string {
+	return fmt.Sprintf("invalid value %q for option %q (valid options: %q)", e.Value, e.Field, e.Valid)
+}
+
+// AssertStructValid checks the fields in the structure and makes sure that
+// they contain valid values as specified by the 'valid' flag. Empty fields are
+// implicitly valid.
+func AssertStructValid(c interface{}) error {
+	ct := reflect.TypeOf(c)
+	cv := reflect.ValueOf(c)
+	for i := 0; i < ct.NumField(); i++ {
+		ft := ct.Field(i)
+		if !isFieldExported(ft) {
+			continue
+		}
+
+		if err := AssertValid(cv.Field(i), ft.Tag.Get("valid")); err != nil {
+			err.Field = ft.Name
+			return err
+		}
+	}
+	return nil
+}
+
+// AssertValid checks to make sure that the given value is in the list of
+// valid values. Zero values are implicitly valid.
+func AssertValid(value reflect.Value, valid string) *ErrorValid {
+	if valid == "" || isZero(value) {
+		return nil
+	}
+	vs := fmt.Sprintf("%v", value.Interface())
+	valids := strings.Split(valid, ",")
+	for _, valid := range valids {
+		if vs == valid {
+			return nil
+		}
+	}
+	return &ErrorValid{
+		Value: vs,
+		Valid: valids,
+	}
+}
+
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Struct:
+		vt := v.Type()
+		for i := 0; i < v.NumField(); i++ {
+			if isFieldExported(vt.Field(i)) && !isZero(v.Field(i)) {
+				return false
+			}
+		}
+		return true
+	default:
+		return v.Interface() == reflect.Zero(v.Type()).Interface()
+	}
+}
+
+func isFieldExported(f reflect.StructField) bool {
+	return f.PkgPath == ""
+}
+
+func normalizeConfig(config string) ([]byte, error) {
+	var cfg map[interface{}]interface{}
+	if err := yaml.Unmarshal([]byte(config), &cfg); err != nil {
+		return nil, err
+	}
+	return yaml.Marshal(normalizeKeys(cfg))
+}
+
+func normalizeKeys(m map[interface{}]interface{}) map[interface{}]interface{} {
+	for k, v := range m {
+		if m, ok := m[k].(map[interface{}]interface{}); ok {
+			normalizeKeys(m)
+		}
+
+		if s, ok := m[k].([]interface{}); ok {
+			for _, e := range s {
+				if m, ok := e.(map[interface{}]interface{}); ok {
+					normalizeKeys(m)
+				}
+			}
+		}
+
+		delete(m, k)
+		m[strings.Replace(fmt.Sprint(k), "-", "_", -1)] = v
+	}
+	return m
+}

config/config_test.go

@@ -0,0 +1,525 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestIsZero(t *testing.T) {
+	for _, tt := range []struct {
+		c     interface{}
+		empty bool
+	}{
+		{struct{}{}, true},
+		{struct{ a, b string }{}, true},
+		{struct{ A, b string }{}, true},
+		{struct{ A, B string }{}, true},
+		{struct{ A string }{A: "hello"}, false},
+		{struct{ A int }{}, true},
+		{struct{ A int }{A: 1}, false},
+	} {
+		if empty := IsZero(tt.c); tt.empty != empty {
+			t.Errorf("bad result (%q): want %t, got %t", tt.c, tt.empty, empty)
+		}
+	}
+}
+
+func TestAssertStructValid(t *testing.T) {
+	for _, tt := range []struct {
+		c   interface{}
+		err error
+	}{
+		{struct{}{}, nil},
+		{struct {
+			A, b string `valid:"1,2"`
+		}{}, nil},
+		{struct {
+			A, b string `valid:"1,2"`
+		}{A: "1", b: "2"}, nil},
+		{struct {
+			A, b string `valid:"1,2"`
+		}{A: "1", b: "hello"}, nil},
+		{struct {
+			A, b string `valid:"1,2"`
+		}{A: "hello", b: "2"}, &ErrorValid{Value: "hello", Field: "A", Valid: []string{"1", "2"}}},
+		{struct {
+			A, b int `valid:"1,2"`
+		}{}, nil},
+		{struct {
+			A, b int `valid:"1,2"`
+		}{A: 1, b: 2}, nil},
+		{struct {
+			A, b int `valid:"1,2"`
+		}{A: 1, b: 9}, nil},
+		{struct {
+			A, b int `valid:"1,2"`
+		}{A: 9, b: 2}, &ErrorValid{Value: "9", Field: "A", Valid: []string{"1", "2"}}},
+	} {
+		if err := AssertStructValid(tt.c); !reflect.DeepEqual(tt.err, err) {
+			t.Errorf("bad result (%q): want %q, got %q", tt.c, tt.err, err)
+		}
+	}
+}
+
+func TestCloudConfigInvalidKeys(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("panic while instantiating CloudConfig with nil keys: %v", r)
+		}
+	}()
+
+	for _, tt := range []struct {
+		contents string
+	}{
+		{"coreos:"},
+		{"ssh_authorized_keys:"},
+		{"ssh_authorized_keys:\n  -"},
+		{"ssh_authorized_keys:\n  - 0:"},
+		{"write_files:"},
+		{"write_files:\n  -"},
+		{"write_files:\n  - 0:"},
+		{"users:"},
+		{"users:\n  -"},
+		{"users:\n  - 0:"},
+	} {
+		_, err := NewCloudConfig(tt.contents)
+		if err != nil {
+			t.Fatalf("error instantiating CloudConfig with invalid keys: %v", err)
+		}
+	}
+}
+
+func TestCloudConfigUnknownKeys(t *testing.T) {
+	contents := `
+coreos: 
+  etcd:
+    discovery: "https://discovery.etcd.io/827c73219eeb2fa5530027c37bf18877"
+  coreos_unknown:
+    foo: "bar"
+section_unknown:
+  dunno:
+    something
+bare_unknown:
+  bar
+write_files:
+  - content: fun
+    path: /var/party
+    file_unknown: nofun
+users:
+  - name: fry
+    passwd: somehash
+    user_unknown: philip
+hostname:
+  foo
+`
+	cfg, err := NewCloudConfig(contents)
+	if err != nil {
+		t.Fatalf("error instantiating CloudConfig with unknown keys: %v", err)
+	}
+	if cfg.Hostname != "foo" {
+		t.Fatalf("hostname not correctly set when invalid keys are present")
+	}
+	if cfg.Coreos.Etcd.Discovery != "https://discovery.etcd.io/827c73219eeb2fa5530027c37bf18877" {
+		t.Fatalf("etcd section not correctly set when invalid keys are present")
+	}
+	if len(cfg.WriteFiles) < 1 || cfg.WriteFiles[0].Content != "fun" || cfg.WriteFiles[0].Path != "/var/party" {
+		t.Fatalf("write_files section not correctly set when invalid keys are present")
+	}
+	if len(cfg.Users) < 1 || cfg.Users[0].Name != "fry" || cfg.Users[0].PasswordHash != "somehash" {
+		t.Fatalf("users section not correctly set when invalid keys are present")
+	}
+}
+
+// Assert that the parsing of a cloud config file "generally works"
+func TestCloudConfigEmpty(t *testing.T) {
+	cfg, err := NewCloudConfig("")
+	if err != nil {
+		t.Fatalf("Encountered unexpected error :%v", err)
+	}
+
+	keys := cfg.SSHAuthorizedKeys
+	if len(keys) != 0 {
+		t.Error("Parsed incorrect number of SSH keys")
+	}
+
+	if len(cfg.WriteFiles) != 0 {
+		t.Error("Expected zero WriteFiles")
+	}
+
+	if cfg.Hostname != "" {
+		t.Errorf("Expected hostname to be empty, got '%s'", cfg.Hostname)
+	}
+}
+
+// Assert that the parsing of a cloud config file "generally works"
+func TestCloudConfig(t *testing.T) {
+	contents := `
+coreos: 
+  etcd:
+    discovery: "https://discovery.etcd.io/827c73219eeb2fa5530027c37bf18877"
+  update:
+    reboot_strategy: reboot
+  units:
+    - name: 50-eth0.network
+      runtime: yes
+      content: '[Match]
+ 
+    Name=eth47
+ 
+ 
+    [Network]
+ 
+    Address=10.209.171.177/19
+ 
+'
+  oem:
+    id: rackspace
+    name: Rackspace Cloud Servers
+    version_id: 168.0.0
+    home_url: https://www.rackspace.com/cloud/servers/
+    bug_report_url: https://github.com/coreos/coreos-overlay
+ssh_authorized_keys:
+  - foobar
+  - foobaz
+write_files:
+  - content: |
+      penny
+      elroy
+    path: /etc/dogepack.conf
+    permissions: '0644'
+    owner: root:dogepack
+hostname: trontastic
+`
+	cfg, err := NewCloudConfig(contents)
+	if err != nil {
+		t.Fatalf("Encountered unexpected error :%v", err)
+	}
+
+	keys := cfg.SSHAuthorizedKeys
+	if len(keys) != 2 {
+		t.Error("Parsed incorrect number of SSH keys")
+	} else if keys[0] != "foobar" {
+		t.Error("Expected first SSH key to be 'foobar'")
+	} else if keys[1] != "foobaz" {
+		t.Error("Expected first SSH key to be 'foobaz'")
+	}
+
+	if len(cfg.WriteFiles) != 1 {
+		t.Error("Failed to parse correct number of write_files")
+	} else {
+		wf := cfg.WriteFiles[0]
+		if wf.Content != "penny\nelroy\n" {
+			t.Errorf("WriteFile has incorrect contents '%s'", wf.Content)
+		}
+		if wf.Encoding != "" {
+			t.Errorf("WriteFile has incorrect encoding %s", wf.Encoding)
+		}
+		if wf.RawFilePermissions != "0644" {
+			t.Errorf("WriteFile has incorrect permissions %s", wf.RawFilePermissions)
+		}
+		if wf.Path != "/etc/dogepack.conf" {
+			t.Errorf("WriteFile has incorrect path %s", wf.Path)
+		}
+		if wf.Owner != "root:dogepack" {
+			t.Errorf("WriteFile has incorrect owner %s", wf.Owner)
+		}
+	}
+
+	if len(cfg.Coreos.Units) != 1 {
+		t.Error("Failed to parse correct number of units")
+	} else {
+		u := cfg.Coreos.Units[0]
+		expect := `[Match]
+Name=eth47
+
+[Network]
+Address=10.209.171.177/19
+`
+		if u.Content != expect {
+			t.Errorf("Unit has incorrect contents '%s'.\nExpected '%s'.", u.Content, expect)
+		}
+		if u.Runtime != true {
+			t.Errorf("Unit has incorrect runtime value")
+		}
+		if u.Name != "50-eth0.network" {
+			t.Errorf("Unit has incorrect name %s", u.Name)
+		}
+		if u.Type() != "network" {
+			t.Errorf("Unit has incorrect type '%s'", u.Type())
+		}
+	}
+
+	if cfg.Coreos.OEM.ID != "rackspace" {
+		t.Errorf("Failed parsing coreos.oem. Expected ID 'rackspace', got %q.", cfg.Coreos.OEM.ID)
+	}
+
+	if cfg.Hostname != "trontastic" {
+		t.Errorf("Failed to parse hostname")
+	}
+	if cfg.Coreos.Update.RebootStrategy != "reboot" {
+		t.Errorf("Failed to parse locksmith strategy")
+	}
+
+	contents = `
+coreos:
+write_files:
+  - path: /home/me/notes
+    permissions: 0744
+`
+	cfg, err = NewCloudConfig(contents)
+	if err != nil {
+		t.Fatalf("Encountered unexpected error :%v", err)
+	}
+
+	if len(cfg.WriteFiles) != 1 {
+		t.Error("Failed to parse correct number of write_files")
+	} else {
+		wf := cfg.WriteFiles[0]
+		if wf.Content != "" {
+			t.Errorf("WriteFile has incorrect contents '%s'", wf.Content)
+		}
+		if wf.Encoding != "" {
+			t.Errorf("WriteFile has incorrect encoding %s", wf.Encoding)
+		}
+		// Verify that the normalization of the config converted 0744 to its decimal
+		// representation, 484.
+		if wf.RawFilePermissions != "484" {
+			t.Errorf("WriteFile has incorrect permissions %s", wf.RawFilePermissions)
+		}
+		if wf.Path != "/home/me/notes" {
+			t.Errorf("WriteFile has incorrect path %s", wf.Path)
+		}
+		if wf.Owner != "" {
+			t.Errorf("WriteFile has incorrect owner %s", wf.Owner)
+		}
+	}
+}
+
+// Assert that our interface conversion doesn't panic
+func TestCloudConfigKeysNotList(t *testing.T) {
+	contents := `
+ssh_authorized_keys:
+  - foo: bar
+`
+	cfg, err := NewCloudConfig(contents)
+	if err != nil {
+		t.Fatalf("Encountered unexpected error: %v", err)
+	}
+
+	keys := cfg.SSHAuthorizedKeys
+	if len(keys) != 0 {
+		t.Error("Parsed incorrect number of SSH keys")
+	}
+}
+
+func TestCloudConfigSerializationHeader(t *testing.T) {
+	cfg, _ := NewCloudConfig("")
+	contents := cfg.String()
+	header := strings.SplitN(contents, "\n", 2)[0]
+	if header != "#cloud-config" {
+		t.Fatalf("Serialized config did not have expected header")
+	}
+}
+
+// TestDropInIgnored asserts that users are unable to set DropIn=True on units
+func TestDropInIgnored(t *testing.T) {
+	contents := `
+coreos:
+  units:
+    - name: test
+      dropin: true
+`
+	cfg, err := NewCloudConfig(contents)
+	if err != nil || len(cfg.Coreos.Units) != 1 {
+		t.Fatalf("Encountered unexpected error: %v", err)
+	}
+	if len(cfg.Coreos.Units) != 1 || cfg.Coreos.Units[0].Name != "test" {
+		t.Fatalf("Expected 1 unit, but got %d: %v", len(cfg.Coreos.Units), cfg.Coreos.Units)
+	}
+	if cfg.Coreos.Units[0].DropIn {
+		t.Errorf("dropin option on unit in cloud-config was not ignored!")
+	}
+}
+
+func TestCloudConfigUsers(t *testing.T) {
+	contents := `
+users:
+  - name: elroy
+    passwd: somehash
+    ssh_authorized_keys:
+      - somekey
+    gecos: arbitrary comment
+    homedir: /home/place
+    no_create_home: yes
+    primary_group: things
+    groups:
+      - ping
+      - pong
+    no_user_group: true
+    system: y
+    no_log_init: True
+`
+	cfg, err := NewCloudConfig(contents)
+	if err != nil {
+		t.Fatalf("Encountered unexpected error: %v", err)
+	}
+
+	if len(cfg.Users) != 1 {
+		t.Fatalf("Parsed %d users, expected 1", len(cfg.Users))
+	}
+
+	user := cfg.Users[0]
+
+	if user.Name != "elroy" {
+		t.Errorf("User name is %q, expected 'elroy'", user.Name)
+	}
+
+	if user.PasswordHash != "somehash" {
+		t.Errorf("User passwd is %q, expected 'somehash'", user.PasswordHash)
+	}
+
+	if keys := user.SSHAuthorizedKeys; len(keys) != 1 {
+		t.Errorf("Parsed %d ssh keys, expected 1", len(keys))
+	} else {
+		key := user.SSHAuthorizedKeys[0]
+		if key != "somekey" {
+			t.Errorf("User SSH key is %q, expected 'somekey'", key)
+		}
+	}
+
+	if user.GECOS != "arbitrary comment" {
+		t.Errorf("Failed to parse gecos field, got %q", user.GECOS)
+	}
+
+	if user.Homedir != "/home/place" {
+		t.Errorf("Failed to parse homedir field, got %q", user.Homedir)
+	}
+
+	if !user.NoCreateHome {
+		t.Errorf("Failed to parse no_create_home field")
+	}
+
+	if user.PrimaryGroup != "things" {
+		t.Errorf("Failed to parse primary_group field, got %q", user.PrimaryGroup)
+	}
+
+	if len(user.Groups) != 2 {
+		t.Errorf("Failed to parse 2 goups, got %d", len(user.Groups))
+	} else {
+		if user.Groups[0] != "ping" {
+			t.Errorf("First group was %q, not expected value 'ping'", user.Groups[0])
+		}
+		if user.Groups[1] != "pong" {
+			t.Errorf("First group was %q, not expected value 'pong'", user.Groups[1])
+		}
+	}
+
+	if !user.NoUserGroup {
+		t.Errorf("Failed to parse no_user_group field")
+	}
+
+	if !user.System {
+		t.Errorf("Failed to parse system field")
+	}
+
+	if !user.NoLogInit {
+		t.Errorf("Failed to parse no_log_init field")
+	}
+}
+
+func TestCloudConfigUsersGithubUser(t *testing.T) {
+
+	contents := `
+users:
+  - name: elroy
+    coreos_ssh_import_github: bcwaldon
+`
+	cfg, err := NewCloudConfig(contents)
+	if err != nil {
+		t.Fatalf("Encountered unexpected error: %v", err)
+	}
+
+	if len(cfg.Users) != 1 {
+		t.Fatalf("Parsed %d users, expected 1", len(cfg.Users))
+	}
+
+	user := cfg.Users[0]
+
+	if user.Name != "elroy" {
+		t.Errorf("User name is %q, expected 'elroy'", user.Name)
+	}
+
+	if user.SSHImportGithubUser != "bcwaldon" {
+		t.Errorf("github user is %q, expected 'bcwaldon'", user.SSHImportGithubUser)
+	}
+}
+
+func TestCloudConfigUsersSSHImportURL(t *testing.T) {
+	contents := `
+users:
+  - name: elroy
+    coreos_ssh_import_url: https://token:x-auth-token@github.enterprise.com/api/v3/polvi/keys
+`
+	cfg, err := NewCloudConfig(contents)
+	if err != nil {
+		t.Fatalf("Encountered unexpected error: %v", err)
+	}
+
+	if len(cfg.Users) != 1 {
+		t.Fatalf("Parsed %d users, expected 1", len(cfg.Users))
+	}
+
+	user := cfg.Users[0]
+
+	if user.Name != "elroy" {
+		t.Errorf("User name is %q, expected 'elroy'", user.Name)
+	}
+
+	if user.SSHImportURL != "https://token:x-auth-token@github.enterprise.com/api/v3/polvi/keys" {
+		t.Errorf("ssh import url is %q, expected 'https://token:x-auth-token@github.enterprise.com/api/v3/polvi/keys'", user.SSHImportURL)
+	}
+}
+
+func TestNormalizeKeys(t *testing.T) {
+	for _, tt := range []struct {
+		in  string
+		out string
+	}{
+		{"my_key_name: the-value\n", "my_key_name: the-value\n"},
+		{"my-key_name: the-value\n", "my_key_name: the-value\n"},
+		{"my-key-name: the-value\n", "my_key_name: the-value\n"},
+
+		{"a:\n- key_name: the-value\n", "a:\n- key_name: the-value\n"},
+		{"a:\n- key-name: the-value\n", "a:\n- key_name: the-value\n"},
+
+		{"a:\n  b:\n  - key_name: the-value\n", "a:\n  b:\n  - key_name: the-value\n"},
+		{"a:\n  b:\n  - key-name: the-value\n", "a:\n  b:\n  - key_name: the-value\n"},
+
+		{"coreos:\n  update:\n    reboot-strategy: off\n", "coreos:\n  update:\n    reboot_strategy: false\n"},
+	} {
+		out, err := normalizeConfig(tt.in)
+		if err != nil {
+			t.Fatalf("bad error (%q): want nil, got %s", tt.in, err)
+		}
+		if string(out) != tt.out {
+			t.Fatalf("bad normalization (%q): want %q, got %q", tt.in, tt.out, out)
+		}
+	}
+}

config/etc_hosts.go

@@ -0,0 +1,19 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+type EtcHosts string

config/etcd.go

@@ -0,0 +1,48 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+type Etcd struct {
+	Addr                string `yaml:"addr"                  env:"ETCD_ADDR"`
+	BindAddr            string `yaml:"bind_addr"             env:"ETCD_BIND_ADDR"`
+	CAFile              string `yaml:"ca_file"               env:"ETCD_CA_FILE"`
+	CertFile            string `yaml:"cert_file"             env:"ETCD_CERT_FILE"`
+	ClusterActiveSize   string `yaml:"cluster_active_size"   env:"ETCD_CLUSTER_ACTIVE_SIZE"`
+	ClusterRemoveDelay  string `yaml:"cluster_remove_delay"  env:"ETCD_CLUSTER_REMOVE_DELAY"`
+	ClusterSyncInterval string `yaml:"cluster_sync_interval" env:"ETCD_CLUSTER_SYNC_INTERVAL"`
+	Cors                string `yaml:"cors"                  env:"ETCD_CORS"`
+	CPUProfileFile      string `yaml:"cpu_profile_file"      env:"ETCD_CPU_PROFILE_FILE"`
+	DataDir             string `yaml:"data_dir"              env:"ETCD_DATA_DIR"`
+	Discovery           string `yaml:"discovery"             env:"ETCD_DISCOVERY"`
+	HTTPReadTimeout     string `yaml:"http_read_timeout"     env:"ETCD_HTTP_READ_TIMEOUT"`
+	HTTPWriteTimeout    string `yaml:"http_write_timeout"    env:"ETCD_HTTP_WRITE_TIMEOUT"`
+	KeyFile             string `yaml:"key_file"              env:"ETCD_KEY_FILE"`
+	MaxClusterSize      string `yaml:"max_cluster_size"      env:"ETCD_MAX_CLUSTER_SIZE"`
+	MaxResultBuffer     string `yaml:"max_result_buffer"     env:"ETCD_MAX_RESULT_BUFFER"`
+	MaxRetryAttempts    string `yaml:"max_retry_attempts"    env:"ETCD_MAX_RETRY_ATTEMPTS"`
+	Name                string `yaml:"name"                  env:"ETCD_NAME"`
+	PeerAddr            string `yaml:"peer_addr"             env:"ETCD_PEER_ADDR"`
+	PeerBindAddr        string `yaml:"peer_bind_addr"        env:"ETCD_PEER_BIND_ADDR"`
+	PeerCAFile          string `yaml:"peer_ca_file"          env:"ETCD_PEER_CA_FILE"`
+	PeerCertFile        string `yaml:"peer_cert_file"        env:"ETCD_PEER_CERT_FILE"`
+	PeerKeyFile         string `yaml:"peer_key_file"         env:"ETCD_PEER_KEY_FILE"`
+	Peers               string `yaml:"peers"                 env:"ETCD_PEERS"`
+	PeersFile           string `yaml:"peers_file"            env:"ETCD_PEERS_FILE"`
+	Snapshot            string `yaml:"snapshot"              env:"ETCD_SNAPSHOT"`
+	Verbose             string `yaml:"verbose"               env:"ETCD_VERBOSE"`
+	VeryVerbose         string `yaml:"very_verbose"          env:"ETCD_VERY_VERBOSE"`
+}

config/file.go

@@ -0,0 +1,25 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+type File struct {
+	Encoding           string `yaml:"-"`
+	Content            string `yaml:"content"`
+	Owner              string `yaml:"owner"`
+	Path               string `yaml:"path"`
+	RawFilePermissions string `yaml:"permissions"`
+}

config/flannel.go

@@ -0,0 +1,9 @@
+package config
+
+type Flannel struct {
+	EtcdEndpoint string `yaml:"etcd-endpoint" env:"FLANNELD_ETCD_ENDPOINT"`
+	EtcdPrefix   string `yaml:"etcd-prefix"   env:"FLANNELD_ETCD_PREFIX"`
+	IPMasq       string `yaml:"ip-masq"       env:"FLANNELD_IP_MASQ"`
+	SubnetFile   string `yaml:"subnet-file"   env:"FLANNELD_SUBNET_FILE"`
+	Iface        string `yaml:"interface"     env:"FLANNELD_IFACE"`
+}

config/fleet.go

@@ -0,0 +1,30 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+type Fleet struct {
+	AgentTTL                string `yaml:"agent_ttl"                 env:"FLEET_AGENT_TTL"`
+	EngineReconcileInterval string `yaml:"engine_reconcile_interval" env:"FLEET_ENGINE_RECONCILE_INTERVAL"`
+	EtcdCAFile              string `yaml:"etcd_cafile"               env:"FLEET_ETCD_CAFILE"`
+	EtcdCertFile            string `yaml:"etcd_certfile"             env:"FLEET_ETCD_CERTFILE"`
+	EtcdKeyFile             string `yaml:"etcd_keyfile"              env:"FLEET_ETCD_KEYFILE"`
+	EtcdRequestTimeout      string `yaml:"etcd_request_timeout"      env:"FLEET_ETCD_REQUEST_TIMEOUT"`
+	EtcdServers             string `yaml:"etcd_servers"              env:"FLEET_ETCD_SERVERS"`
+	Metadata                string `yaml:"metadata"                  env:"FLEET_METADATA"`
+	PublicIP                string `yaml:"public_ip"                 env:"FLEET_PUBLIC_IP"`
+	Verbosity               string `yaml:"verbosity"                 env:"FLEET_VERBOSITY"`
+}

config/oem.go

@@ -0,0 +1,25 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+type OEM struct {
+	ID           string `yaml:"id"`
+	Name         string `yaml:"name"`
+	VersionID    string `yaml:"version_id"`
+	HomeURL      string `yaml:"home_url"`
+	BugReportURL string `yaml:"bug_report_url"`
+}

config/script.go

@@ -0,0 +1,32 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+import (
+	"strings"
+)
+
+type Script []byte
+
+func IsScript(userdata string) bool {
+	header := strings.SplitN(userdata, "\n", 2)[0]
+	return strings.HasPrefix(header, "#!")
+}
+
+func NewScript(userdata string) (Script, error) {
+	return Script(userdata), nil
+}

config/unit.go

@@ -0,0 +1,50 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+import (
+	"path/filepath"
+	"strings"
+)
+
+type Unit struct {
+	Name    string `yaml:"name"`
+	Mask    bool   `yaml:"mask"`
+	Enable  bool   `yaml:"enable"`
+	Runtime bool   `yaml:"runtime"`
+	Content string `yaml:"content"`
+	Command string `yaml:"command" valid:"start,stop,restart,reload,try-restart,reload-or-restart,reload-or-try-restart"`
+
+	// For drop-in units, a cloudinit.conf is generated.
+	// This is currently unbound in YAML (and hence unsettable in cloud-config files)
+	// until the correct behaviour for multiple drop-in units is determined.
+	DropIn bool `yaml:"-"`
+}
+
+func (u *Unit) Type() string {
+	ext := filepath.Ext(u.Name)
+	return strings.TrimLeft(ext, ".")
+}
+
+func (u *Unit) Group() string {
+	switch u.Type() {
+	case "network", "netdev", "link":
+		return "network"
+	default:
+		return "system"
+	}
+}

config/update.go

@@ -0,0 +1,23 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+type Update struct {
+	RebootStrategy string `yaml:"reboot_strategy" env:"REBOOT_STRATEGY" valid:"best-effort,etcd-lock,reboot,false"`
+	Group          string `yaml:"group"           env:"GROUP"`
+	Server         string `yaml:"server"          env:"SERVER"`
+}

config/user.go

@@ -0,0 +1,33 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package config
+
+type User struct {
+	Name                string   `yaml:"name"`
+	PasswordHash        string   `yaml:"passwd"`
+	SSHAuthorizedKeys   []string `yaml:"ssh_authorized_keys"`
+	SSHImportGithubUser string   `yaml:"coreos_ssh_import_github"`
+	SSHImportURL        string   `yaml:"coreos_ssh_import_url"`
+	GECOS               string   `yaml:"gecos"`
+	Homedir             string   `yaml:"homedir"`
+	NoCreateHome        bool     `yaml:"no_create_home"`
+	PrimaryGroup        string   `yaml:"primary_group"`
+	Groups              []string `yaml:"groups"`
+	NoUserGroup         bool     `yaml:"no_user_group"`
+	System              bool     `yaml:"system"`
+	NoLogInit           bool     `yaml:"no_log_init"`
+}

config/validate/context.go

@@ -0,0 +1,54 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"strings"
+)
+
+// context represents the current position within a newline-delimited string.
+// Each line is loaded, one by one, into currentLine (newline omitted) and
+// lineNumber keeps track of its position within the original string.
+type context struct {
+	currentLine    string
+	remainingLines string
+	lineNumber     int
+}
+
+// Increment moves the context to the next line (if available).
+func (c *context) Increment() {
+	if c.currentLine == "" && c.remainingLines == "" {
+		return
+	}
+
+	lines := strings.SplitN(c.remainingLines, "\n", 2)
+	c.currentLine = lines[0]
+	if len(lines) == 2 {
+		c.remainingLines = lines[1]
+	} else {
+		c.remainingLines = ""
+	}
+	c.lineNumber++
+}
+
+// NewContext creates a context from the provided data. It strips out all
+// carriage returns and moves to the first line (if available).
+func NewContext(content []byte) context {
+	c := context{remainingLines: strings.Replace(string(content), "\r", "", -1)}
+	c.Increment()
+	return c
+}

config/validate/context_test.go

@@ -0,0 +1,133 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestNewContext(t *testing.T) {
+	tests := []struct {
+		in string
+
+		out context
+	}{
+		{
+			out: context{
+				currentLine:    "",
+				remainingLines: "",
+				lineNumber:     0,
+			},
+		},
+		{
+			in: "this\r\nis\r\na\r\ntest",
+			out: context{
+				currentLine:    "this",
+				remainingLines: "is\na\ntest",
+				lineNumber:     1,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		if out := NewContext([]byte(tt.in)); !reflect.DeepEqual(tt.out, out) {
+			t.Errorf("bad context (%q): want %#v, got %#v", tt.in, tt.out, out)
+		}
+	}
+}
+
+func TestIncrement(t *testing.T) {
+	tests := []struct {
+		init context
+		op   func(c *context)
+
+		res context
+	}{
+		{
+			init: context{
+				currentLine:    "",
+				remainingLines: "",
+				lineNumber:     0,
+			},
+			res: context{
+				currentLine:    "",
+				remainingLines: "",
+				lineNumber:     0,
+			},
+			op: func(c *context) {
+				c.Increment()
+			},
+		},
+		{
+			init: context{
+				currentLine:    "test",
+				remainingLines: "",
+				lineNumber:     1,
+			},
+			res: context{
+				currentLine:    "",
+				remainingLines: "",
+				lineNumber:     2,
+			},
+			op: func(c *context) {
+				c.Increment()
+				c.Increment()
+				c.Increment()
+			},
+		},
+		{
+			init: context{
+				currentLine:    "this",
+				remainingLines: "is\na\ntest",
+				lineNumber:     1,
+			},
+			res: context{
+				currentLine:    "is",
+				remainingLines: "a\ntest",
+				lineNumber:     2,
+			},
+			op: func(c *context) {
+				c.Increment()
+			},
+		},
+		{
+			init: context{
+				currentLine:    "this",
+				remainingLines: "is\na\ntest",
+				lineNumber:     1,
+			},
+			res: context{
+				currentLine:    "test",
+				remainingLines: "",
+				lineNumber:     4,
+			},
+			op: func(c *context) {
+				c.Increment()
+				c.Increment()
+				c.Increment()
+			},
+		},
+	}
+
+	for i, tt := range tests {
+		res := tt.init
+		if tt.op(&res); !reflect.DeepEqual(tt.res, res) {
+			t.Errorf("bad context (%d, %#v): want %#v, got %#v", i, tt.init, tt.res, res)
+		}
+	}
+}

config/validate/node.go

@@ -0,0 +1,159 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+)
+
+var (
+	yamlKey  = regexp.MustCompile(`^ *-? ?(?P<key>.*?):`)
+	yamlElem = regexp.MustCompile(`^ *-`)
+)
+
+type node struct {
+	name     string
+	line     int
+	children []node
+	field    reflect.StructField
+	reflect.Value
+}
+
+// Child attempts to find the child with the given name in the node's list of
+// children. If no such child is found, an invalid node is returned.
+func (n node) Child(name string) node {
+	for _, c := range n.children {
+		if c.name == name {
+			return c
+		}
+	}
+	return node{}
+}
+
+// HumanType returns the human-consumable string representation of the type of
+// the node.
+func (n node) HumanType() string {
+	switch k := n.Kind(); k {
+	case reflect.Slice:
+		c := n.Type().Elem()
+		return "[]" + node{Value: reflect.New(c).Elem()}.HumanType()
+	default:
+		return k.String()
+	}
+}
+
+// NewNode returns the node representation of the given value. The context
+// will be used in an attempt to determine line numbers for the given value.
+func NewNode(value interface{}, context context) node {
+	var n node
+	toNode(value, context, &n)
+	return n
+}
+
+// toNode converts the given value into a node and then recursively processes
+// each of the nodes components (e.g. fields, array elements, keys).
+func toNode(v interface{}, c context, n *node) {
+	vv := reflect.ValueOf(v)
+	if !vv.IsValid() {
+		return
+	}
+
+	n.Value = vv
+	switch vv.Kind() {
+	case reflect.Struct:
+		// Walk over each field in the structure, skipping unexported fields,
+		// and create a node for it.
+		for i := 0; i < vv.Type().NumField(); i++ {
+			ft := vv.Type().Field(i)
+			k := ft.Tag.Get("yaml")
+			if k == "-" || k == "" {
+				continue
+			}
+
+			cn := node{name: k, field: ft}
+			c, ok := findKey(cn.name, c)
+			if ok {
+				cn.line = c.lineNumber
+			}
+			toNode(vv.Field(i).Interface(), c, &cn)
+			n.children = append(n.children, cn)
+		}
+	case reflect.Map:
+		// Walk over each key in the map and create a node for it.
+		v := v.(map[interface{}]interface{})
+		for k, cv := range v {
+			cn := node{name: fmt.Sprintf("%s", k)}
+			c, ok := findKey(cn.name, c)
+			if ok {
+				cn.line = c.lineNumber
+			}
+			toNode(cv, c, &cn)
+			n.children = append(n.children, cn)
+		}
+	case reflect.Slice:
+		// Walk over each element in the slice and create a node for it.
+		// While iterating over the slice, preserve the context after it
+		// is modified. This allows the line numbers to reflect the current
+		// element instead of the first.
+		for i := 0; i < vv.Len(); i++ {
+			cn := node{
+				name:  fmt.Sprintf("%s[%d]", n.name, i),
+				field: n.field,
+			}
+			var ok bool
+			c, ok = findElem(c)
+			if ok {
+				cn.line = c.lineNumber
+			}
+			toNode(vv.Index(i).Interface(), c, &cn)
+			n.children = append(n.children, cn)
+			c.Increment()
+		}
+	case reflect.String, reflect.Int, reflect.Bool:
+	default:
+		panic(fmt.Sprintf("toNode(): unhandled kind %s", vv.Kind()))
+	}
+}
+
+// findKey attempts to find the requested key within the provided context.
+// A modified copy of the context is returned with every line up to the key
+// incremented past. A boolean, true if the key was found, is also returned.
+func findKey(key string, context context) (context, bool) {
+	return find(yamlKey, key, context)
+}
+
+// findElem attempts to find an array element within the provided context.
+// A modified copy of the context is returned with every line up to the array
+// element incremented past. A boolean, true if the key was found, is also
+// returned.
+func findElem(context context) (context, bool) {
+	return find(yamlElem, "", context)
+}
+
+func find(exp *regexp.Regexp, key string, context context) (context, bool) {
+	for len(context.currentLine) > 0 || len(context.remainingLines) > 0 {
+		matches := exp.FindStringSubmatch(context.currentLine)
+		if len(matches) > 0 && (key == "" || matches[1] == key) {
+			return context, true
+		}
+
+		context.Increment()
+	}
+	return context, false
+}

config/validate/node_test.go

@@ -0,0 +1,286 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestChild(t *testing.T) {
+	tests := []struct {
+		parent node
+		name   string
+
+		child node
+	}{
+		{},
+		{
+			name: "c1",
+		},
+		{
+			parent: node{
+				children: []node{
+					node{name: "c1"},
+					node{name: "c2"},
+					node{name: "c3"},
+				},
+			},
+		},
+		{
+			parent: node{
+				children: []node{
+					node{name: "c1"},
+					node{name: "c2"},
+					node{name: "c3"},
+				},
+			},
+			name:  "c2",
+			child: node{name: "c2"},
+		},
+	}
+
+	for _, tt := range tests {
+		if child := tt.parent.Child(tt.name); !reflect.DeepEqual(tt.child, child) {
+			t.Errorf("bad child (%q): want %#v, got %#v", tt.name, tt.child, child)
+		}
+	}
+}
+
+func TestHumanType(t *testing.T) {
+	tests := []struct {
+		node node
+
+		humanType string
+	}{
+		{
+			humanType: "invalid",
+		},
+		{
+			node:      node{Value: reflect.ValueOf("hello")},
+			humanType: "string",
+		},
+		{
+			node: node{
+				Value: reflect.ValueOf([]int{1, 2}),
+				children: []node{
+					node{Value: reflect.ValueOf(1)},
+					node{Value: reflect.ValueOf(2)},
+				}},
+			humanType: "[]int",
+		},
+	}
+
+	for _, tt := range tests {
+		if humanType := tt.node.HumanType(); tt.humanType != humanType {
+			t.Errorf("bad type (%q): want %q, got %q", tt.node, tt.humanType, humanType)
+		}
+	}
+}
+
+func TestToNode(t *testing.T) {
+	tests := []struct {
+		value   interface{}
+		context context
+
+		node node
+	}{
+		{},
+		{
+			value: struct{}{},
+			node:  node{Value: reflect.ValueOf(struct{}{})},
+		},
+		{
+			value: struct {
+				A int `yaml:"a"`
+			}{},
+			node: node{
+				children: []node{
+					node{
+						name: "a",
+						field: reflect.TypeOf(struct {
+							A int `yaml:"a"`
+						}{}).Field(0),
+					},
+				},
+			},
+		},
+		{
+			value: struct {
+				A []int `yaml:"a"`
+			}{},
+			node: node{
+				children: []node{
+					node{
+						name: "a",
+						field: reflect.TypeOf(struct {
+							A []int `yaml:"a"`
+						}{}).Field(0),
+					},
+				},
+			},
+		},
+		{
+			value: map[interface{}]interface{}{
+				"a": map[interface{}]interface{}{
+					"b": 2,
+				},
+			},
+			context: NewContext([]byte("a:\n  b: 2")),
+			node: node{
+				children: []node{
+					node{
+						line: 1,
+						name: "a",
+						children: []node{
+							node{name: "b", line: 2},
+						},
+					},
+				},
+			},
+		},
+		{
+			value: struct {
+				A struct {
+					Jon bool `yaml:"b"`
+				} `yaml:"a"`
+			}{},
+			node: node{
+				children: []node{
+					node{
+						name: "a",
+						children: []node{
+							node{
+								name: "b",
+								field: reflect.TypeOf(struct {
+									Jon bool `yaml:"b"`
+								}{}).Field(0),
+								Value: reflect.ValueOf(false),
+							},
+						},
+						field: reflect.TypeOf(struct {
+							A struct {
+								Jon bool `yaml:"b"`
+							} `yaml:"a"`
+						}{}).Field(0),
+						Value: reflect.ValueOf(struct {
+							Jon bool `yaml:"b"`
+						}{}),
+					},
+				},
+				Value: reflect.ValueOf(struct {
+					A struct {
+						Jon bool `yaml:"b"`
+					} `yaml:"a"`
+				}{}),
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		var node node
+		toNode(tt.value, tt.context, &node)
+		if !nodesEqual(tt.node, node) {
+			t.Errorf("bad node (%#v): want %#v, got %#v", tt.value, tt.node, node)
+		}
+	}
+}
+
+func TestFindKey(t *testing.T) {
+	tests := []struct {
+		key     string
+		context context
+
+		found bool
+	}{
+		{},
+		{
+			key:     "key1",
+			context: NewContext([]byte("key1: hi")),
+			found:   true,
+		},
+		{
+			key:     "key2",
+			context: NewContext([]byte("key1: hi")),
+			found:   false,
+		},
+		{
+			key:     "key3",
+			context: NewContext([]byte("key1:\n  key2:\n    key3: hi")),
+			found:   true,
+		},
+		{
+			key:     "key4",
+			context: NewContext([]byte("key1:\n  - key4: hi")),
+			found:   true,
+		},
+		{
+			key:     "key5",
+			context: NewContext([]byte("#key5")),
+			found:   false,
+		},
+	}
+
+	for _, tt := range tests {
+		if _, found := findKey(tt.key, tt.context); tt.found != found {
+			t.Errorf("bad find (%q): want %t, got %t", tt.key, tt.found, found)
+		}
+	}
+}
+
+func TestFindElem(t *testing.T) {
+	tests := []struct {
+		context context
+
+		found bool
+	}{
+		{},
+		{
+			context: NewContext([]byte("test: hi")),
+			found:   false,
+		},
+		{
+			context: NewContext([]byte("test:\n  - a\n  -b")),
+			found:   true,
+		},
+		{
+			context: NewContext([]byte("test:\n  -\n    a")),
+			found:   true,
+		},
+	}
+
+	for _, tt := range tests {
+		if _, found := findElem(tt.context); tt.found != found {
+			t.Errorf("bad find (%q): want %t, got %t", tt.context, tt.found, found)
+		}
+	}
+}
+
+func nodesEqual(a, b node) bool {
+	if a.name != b.name ||
+		a.line != b.line ||
+		!reflect.DeepEqual(a.field, b.field) ||
+		len(a.children) != len(b.children) {
+		return false
+	}
+	for i := 0; i < len(a.children); i++ {
+		if !nodesEqual(a.children[i], b.children[i]) {
+			return false
+		}
+	}
+	return true
+}

config/validate/report.go

@@ -0,0 +1,90 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// Report represents the list of entries resulting from validation.
+type Report struct {
+	entries []Entry
+}
+
+// Error adds an error entry to the report.
+func (r *Report) Error(line int, message string) {
+	r.entries = append(r.entries, Entry{entryError, message, line})
+}
+
+// Warning adds a warning entry to the report.
+func (r *Report) Warning(line int, message string) {
+	r.entries = append(r.entries, Entry{entryWarning, message, line})
+}
+
+// Info adds an info entry to the report.
+func (r *Report) Info(line int, message string) {
+	r.entries = append(r.entries, Entry{entryInfo, message, line})
+}
+
+// Entries returns the list of entries in the report.
+func (r *Report) Entries() []Entry {
+	return r.entries
+}
+
+// Entry represents a single generic item in the report.
+type Entry struct {
+	kind    entryKind
+	message string
+	line    int
+}
+
+// String returns a human-readable representation of the entry.
+func (e Entry) String() string {
+	return fmt.Sprintf("line %d: %s: %s", e.line, e.kind, e.message)
+}
+
+// MarshalJSON satisfies the json.Marshaler interface, returning the entry
+// encoded as a JSON object.
+func (e Entry) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]interface{}{
+		"kind":    e.kind.String(),
+		"message": e.message,
+		"line":    e.line,
+	})
+}
+
+type entryKind int
+
+const (
+	entryError entryKind = iota
+	entryWarning
+	entryInfo
+)
+
+func (k entryKind) String() string {
+	switch k {
+	case entryError:
+		return "error"
+	case entryWarning:
+		return "warning"
+	case entryInfo:
+		return "info"
+	default:
+		panic(fmt.Sprintf("invalid kind %d", k))
+	}
+}

config/validate/report_test.go

@@ -0,0 +1,98 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+)
+
+func TestEntry(t *testing.T) {
+	tests := []struct {
+		entry Entry
+
+		str  string
+		json []byte
+	}{
+		{
+			Entry{entryInfo, "test info", 1},
+			"line 1: info: test info",
+			[]byte(`{"kind":"info","line":1,"message":"test info"}`),
+		},
+		{
+			Entry{entryWarning, "test warning", 1},
+			"line 1: warning: test warning",
+			[]byte(`{"kind":"warning","line":1,"message":"test warning"}`),
+		},
+		{
+			Entry{entryError, "test error", 2},
+			"line 2: error: test error",
+			[]byte(`{"kind":"error","line":2,"message":"test error"}`),
+		},
+	}
+
+	for _, tt := range tests {
+		if str := tt.entry.String(); tt.str != str {
+			t.Errorf("bad string (%q): want %q, got %q", tt.entry, tt.str, str)
+		}
+		json, err := tt.entry.MarshalJSON()
+		if err != nil {
+			t.Errorf("bad error (%q): want %v, got %q", tt.entry, nil, err)
+		}
+		if !bytes.Equal(tt.json, json) {
+			t.Errorf("bad JSON (%q): want %q, got %q", tt.entry, tt.json, json)
+		}
+	}
+}
+
+func TestReport(t *testing.T) {
+	type reportFunc struct {
+		fn      func(*Report, int, string)
+		line    int
+		message string
+	}
+
+	tests := []struct {
+		fs []reportFunc
+
+		es []Entry
+	}{
+		{
+			[]reportFunc{
+				{(*Report).Warning, 1, "test warning 1"},
+				{(*Report).Error, 2, "test error 2"},
+				{(*Report).Info, 10, "test info 10"},
+			},
+			[]Entry{
+				Entry{entryWarning, "test warning 1", 1},
+				Entry{entryError, "test error 2", 2},
+				Entry{entryInfo, "test info 10", 10},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		r := Report{}
+		for _, f := range tt.fs {
+			f.fn(&r, f.line, f.message)
+		}
+		if es := r.Entries(); !reflect.DeepEqual(tt.es, es) {
+			t.Errorf("bad entries (%v): want %#v, got %#v", tt.fs, tt.es, es)
+		}
+	}
+}

config/validate/rules.go

@@ -0,0 +1,115 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+type rule func(config node, report *Report)
+
+// Rules contains all of the validation rules.
+var Rules []rule = []rule{
+	checkStructure,
+	checkValidity,
+}
+
+// checkStructure compares the provided config to the empty config.CloudConfig
+// structure. Each node is checked to make sure that it exists in the known
+// structure and that its type is compatible.
+func checkStructure(cfg node, report *Report) {
+	g := NewNode(config.CloudConfig{}, NewContext([]byte{}))
+	checkNodeStructure(cfg, g, report)
+}
+
+func checkNodeStructure(n, g node, r *Report) {
+	if !isCompatible(n.Kind(), g.Kind()) {
+		r.Warning(n.line, fmt.Sprintf("incorrect type for %q (want %s)", n.name, g.HumanType()))
+		return
+	}
+
+	switch g.Kind() {
+	case reflect.Struct:
+		for _, cn := range n.children {
+			if cg := g.Child(cn.name); cg.IsValid() {
+				checkNodeStructure(cn, cg, r)
+			} else {
+				r.Warning(cn.line, fmt.Sprintf("unrecognized key %q", cn.name))
+			}
+		}
+	case reflect.Slice:
+		for _, cn := range n.children {
+			var cg node
+			c := g.Type().Elem()
+			toNode(reflect.New(c).Elem().Interface(), context{}, &cg)
+			checkNodeStructure(cn, cg, r)
+		}
+	case reflect.String, reflect.Int, reflect.Bool:
+	default:
+		panic(fmt.Sprintf("checkNodeStructure(): unhandled kind %s", g.Kind()))
+	}
+}
+
+// checkValidity checks the value of every node in the provided config by
+// running config.AssertValid() on it.
+func checkValidity(cfg node, report *Report) {
+	g := NewNode(config.CloudConfig{}, NewContext([]byte{}))
+	checkNodeValidity(cfg, g, report)
+}
+
+func checkNodeValidity(n, g node, r *Report) {
+	if err := config.AssertValid(n.Value, g.field.Tag.Get("valid")); err != nil {
+		r.Warning(n.line, fmt.Sprintf("invalid value %v", n.Value))
+	}
+	switch g.Kind() {
+	case reflect.Struct:
+		for _, cn := range n.children {
+			if cg := g.Child(cn.name); cg.IsValid() {
+				checkNodeValidity(cn, cg, r)
+			}
+		}
+	case reflect.Slice:
+		for _, cn := range n.children {
+			var cg node
+			c := g.Type().Elem()
+			toNode(reflect.New(c).Elem().Interface(), context{}, &cg)
+			checkNodeValidity(cn, cg, r)
+		}
+	case reflect.String, reflect.Int, reflect.Bool:
+	default:
+		panic(fmt.Sprintf("checkNodeValidity(): unhandled kind %s", g.Kind()))
+	}
+}
+
+// isCompatible determines if the type of kind n can be converted to the type
+// of kind g in the context of YAML. This is not an exhaustive list, but its
+// enough for the purposes of cloud-config validation.
+func isCompatible(n, g reflect.Kind) bool {
+	switch g {
+	case reflect.String:
+		return n == reflect.String || n == reflect.Int || n == reflect.Bool
+	case reflect.Struct:
+		return n == reflect.Struct || n == reflect.Map
+	case reflect.Bool, reflect.Slice:
+		return n == g
+	default:
+		panic(fmt.Sprintf("isCompatible(): unhandled kind %s", g))
+	}
+}

config/validate/rules_test.go

@@ -0,0 +1,251 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestCheckStructure(t *testing.T) {
+	tests := []struct {
+		config string
+
+		entries []Entry
+	}{
+		{},
+
+		// Test for unrecognized keys
+		{
+			config:  "test:",
+			entries: []Entry{{entryWarning, "unrecognized key \"test\"", 1}},
+		},
+		{
+			config:  "coreos:\n  etcd:\n    bad:",
+			entries: []Entry{{entryWarning, "unrecognized key \"bad\"", 3}},
+		},
+		{
+			config: "coreos:\n  etcd:\n    discovery: good",
+		},
+
+		// Test for error on list of nodes
+		{
+			config: "coreos:\n  units:\n    - hello\n    - goodbye",
+			entries: []Entry{
+				{entryWarning, "incorrect type for \"units[0]\" (want struct)", 3},
+				{entryWarning, "incorrect type for \"units[1]\" (want struct)", 4},
+			},
+		},
+
+		// Test for incorrect types
+		// Want boolean
+		{
+			config: "coreos:\n  units:\n    - enable: true",
+		},
+		{
+			config:  "coreos:\n  units:\n    - enable: 4",
+			entries: []Entry{{entryWarning, "incorrect type for \"enable\" (want bool)", 3}},
+		},
+		{
+			config:  "coreos:\n  units:\n    - enable: bad",
+			entries: []Entry{{entryWarning, "incorrect type for \"enable\" (want bool)", 3}},
+		},
+		{
+			config:  "coreos:\n  units:\n    - enable:\n        bad:",
+			entries: []Entry{{entryWarning, "incorrect type for \"enable\" (want bool)", 3}},
+		},
+		{
+			config:  "coreos:\n  units:\n    - enable:\n      - bad",
+			entries: []Entry{{entryWarning, "incorrect type for \"enable\" (want bool)", 3}},
+		},
+		// Want string
+		{
+			config: "hostname: true",
+		},
+		{
+			config: "hostname: 4",
+		},
+		{
+			config: "hostname: host",
+		},
+		{
+			config:  "hostname:\n  name:",
+			entries: []Entry{{entryWarning, "incorrect type for \"hostname\" (want string)", 1}},
+		},
+		{
+			config:  "hostname:\n  - name",
+			entries: []Entry{{entryWarning, "incorrect type for \"hostname\" (want string)", 1}},
+		},
+		// Want struct
+		{
+			config:  "coreos: true",
+			entries: []Entry{{entryWarning, "incorrect type for \"coreos\" (want struct)", 1}},
+		},
+		{
+			config:  "coreos: 4",
+			entries: []Entry{{entryWarning, "incorrect type for \"coreos\" (want struct)", 1}},
+		},
+		{
+			config:  "coreos: hello",
+			entries: []Entry{{entryWarning, "incorrect type for \"coreos\" (want struct)", 1}},
+		},
+		{
+			config: "coreos:\n  etcd:\n    discovery: fire in the disco",
+		},
+		{
+			config:  "coreos:\n  - hello",
+			entries: []Entry{{entryWarning, "incorrect type for \"coreos\" (want struct)", 1}},
+		},
+		// Want []string
+		{
+			config:  "ssh_authorized_keys: true",
+			entries: []Entry{{entryWarning, "incorrect type for \"ssh_authorized_keys\" (want []string)", 1}},
+		},
+		{
+			config:  "ssh_authorized_keys: 4",
+			entries: []Entry{{entryWarning, "incorrect type for \"ssh_authorized_keys\" (want []string)", 1}},
+		},
+		{
+			config:  "ssh_authorized_keys: key",
+			entries: []Entry{{entryWarning, "incorrect type for \"ssh_authorized_keys\" (want []string)", 1}},
+		},
+		{
+			config:  "ssh_authorized_keys:\n  key: value",
+			entries: []Entry{{entryWarning, "incorrect type for \"ssh_authorized_keys\" (want []string)", 1}},
+		},
+		{
+			config: "ssh_authorized_keys:\n  - key",
+		},
+		{
+			config:  "ssh_authorized_keys:\n  - key: value",
+			entries: []Entry{{entryWarning, "incorrect type for \"ssh_authorized_keys[0]\" (want string)", 2}},
+		},
+		// Want []struct
+		{
+			config:  "users:\n  true",
+			entries: []Entry{{entryWarning, "incorrect type for \"users\" (want []struct)", 1}},
+		},
+		{
+			config:  "users:\n  4",
+			entries: []Entry{{entryWarning, "incorrect type for \"users\" (want []struct)", 1}},
+		},
+		{
+			config:  "users:\n  bad",
+			entries: []Entry{{entryWarning, "incorrect type for \"users\" (want []struct)", 1}},
+		},
+		{
+			config:  "users:\n  bad:",
+			entries: []Entry{{entryWarning, "incorrect type for \"users\" (want []struct)", 1}},
+		},
+		{
+			config: "users:\n  - name: good",
+		},
+		// Want struct within array
+		{
+			config:  "users:\n  - true",
+			entries: []Entry{{entryWarning, "incorrect type for \"users[0]\" (want struct)", 2}},
+		},
+		{
+			config:  "users:\n  - name: hi\n  - true",
+			entries: []Entry{{entryWarning, "incorrect type for \"users[1]\" (want struct)", 3}},
+		},
+		{
+			config:  "users:\n  - 4",
+			entries: []Entry{{entryWarning, "incorrect type for \"users[0]\" (want struct)", 2}},
+		},
+		{
+			config:  "users:\n  - bad",
+			entries: []Entry{{entryWarning, "incorrect type for \"users[0]\" (want struct)", 2}},
+		},
+		{
+			config:  "users:\n  - - bad",
+			entries: []Entry{{entryWarning, "incorrect type for \"users[0]\" (want struct)", 2}},
+		},
+	}
+
+	for i, tt := range tests {
+		r := Report{}
+		n, err := parseCloudConfig([]byte(tt.config), &r)
+		if err != nil {
+			panic(err)
+		}
+		checkStructure(n, &r)
+
+		if e := r.Entries(); !reflect.DeepEqual(tt.entries, e) {
+			t.Errorf("bad report (%d, %q): want %#v, got %#v", i, tt.config, tt.entries, e)
+		}
+	}
+}
+
+func TestCheckValidity(t *testing.T) {
+	tests := []struct {
+		config string
+
+		entries []Entry
+	}{
+		// string
+		{
+			config: "hostname: test",
+		},
+
+		// int
+		{
+			config: "coreos:\n  fleet:\n    verbosity: 2",
+		},
+
+		// bool
+		{
+			config: "coreos:\n  units:\n    - enable: true",
+		},
+
+		// slice
+		{
+			config: "coreos:\n  units:\n    - command: start\n    - name: stop",
+		},
+		{
+			config:  "coreos:\n  units:\n    - command: lol",
+			entries: []Entry{{entryWarning, "invalid value lol", 3}},
+		},
+
+		// struct
+		{
+			config: "coreos:\n  update:\n    reboot_strategy: off",
+		},
+		{
+			config:  "coreos:\n  update:\n    reboot_strategy: always",
+			entries: []Entry{{entryWarning, "invalid value always", 3}},
+		},
+
+		// unknown
+		{
+			config: "unknown: hi",
+		},
+	}
+
+	for i, tt := range tests {
+		r := Report{}
+		n, err := parseCloudConfig([]byte(tt.config), &r)
+		if err != nil {
+			panic(err)
+		}
+		checkValidity(n, &r)
+
+		if e := r.Entries(); !reflect.DeepEqual(tt.entries, e) {
+			t.Errorf("bad report (%d, %q): want %#v, got %#v", i, tt.config, tt.entries, e)
+		}
+	}
+}

config/validate/validate.go

@@ -0,0 +1,114 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/coreos/coreos-cloudinit/config"
+
+	"github.com/coreos/coreos-cloudinit/Godeps/_workspace/src/gopkg.in/yaml.v1"
+)
+
+var (
+	yamlLineError = regexp.MustCompile(`^YAML error: line (?P<line>[[:digit:]]+): (?P<msg>.*)$`)
+	yamlError     = regexp.MustCompile(`^YAML error: (?P<msg>.*)$`)
+)
+
+// Validate runs a series of validation tests against the given userdata and
+// returns a report detailing all of the issues. Presently, only cloud-configs
+// can be validated.
+func Validate(userdataBytes []byte) (Report, error) {
+	switch {
+	case config.IsScript(string(userdataBytes)):
+		return Report{}, nil
+	case config.IsCloudConfig(string(userdataBytes)):
+		return validateCloudConfig(userdataBytes, Rules)
+	default:
+		return Report{entries: []Entry{
+			Entry{kind: entryError, message: `must be "#cloud-config" or begin with "#!"`, line: 1},
+		}}, nil
+	}
+}
+
+// validateCloudConfig runs all of the validation rules in Rules and returns
+// the resulting report and any errors encountered.
+func validateCloudConfig(config []byte, rules []rule) (report Report, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("%v", r)
+		}
+	}()
+
+	c, err := parseCloudConfig(config, &report)
+	if err != nil {
+		return report, err
+	}
+
+	c = normalizeNodeNames(c, &report)
+	for _, r := range rules {
+		r(c, &report)
+	}
+	return report, nil
+}
+
+// parseCloudConfig parses the provided config into a node structure and logs
+// any parsing issues into the provided report. Unrecoverable errors are
+// returned as an error.
+func parseCloudConfig(config []byte, report *Report) (n node, err error) {
+	var raw map[interface{}]interface{}
+	if err := yaml.Unmarshal(config, &raw); err != nil {
+		matches := yamlLineError.FindStringSubmatch(err.Error())
+		if len(matches) == 3 {
+			line, err := strconv.Atoi(matches[1])
+			if err != nil {
+				return n, err
+			}
+			msg := matches[2]
+			report.Error(line, msg)
+			return n, nil
+		}
+
+		matches = yamlError.FindStringSubmatch(err.Error())
+		if len(matches) == 2 {
+			report.Error(1, matches[1])
+			return n, nil
+		}
+
+		return n, errors.New("couldn't parse yaml error")
+	}
+
+	return NewNode(raw, NewContext(config)), nil
+}
+
+// normalizeNodeNames replaces all occurences of '-' with '_' within key names
+// and makes a note of each replacement in the report.
+func normalizeNodeNames(node node, report *Report) node {
+	if strings.Contains(node.name, "-") {
+		// TODO(crawford): Enable this message once the new validator hits stable.
+		//report.Info(node.line, fmt.Sprintf("%q uses '-' instead of '_'", node.name))
+		node.name = strings.Replace(node.name, "-", "_", -1)
+	}
+	for i := range node.children {
+		node.children[i] = normalizeNodeNames(node.children[i], report)
+	}
+	return node
+}

config/validate/validate_test.go

@@ -0,0 +1,121 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package validate
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+func TestParseCloudConfig(t *testing.T) {
+	tests := []struct {
+		config string
+
+		entries []Entry
+	}{
+		{},
+		{
+			config: "	",
+			entries: []Entry{{entryError, "found character that cannot start any token", 1}},
+		},
+		{
+			config:  "a:\na",
+			entries: []Entry{{entryError, "could not find expected ':'", 2}},
+		},
+		{
+			config:  "#hello\na:\na",
+			entries: []Entry{{entryError, "could not find expected ':'", 3}},
+		},
+	}
+
+	for _, tt := range tests {
+		r := Report{}
+		parseCloudConfig([]byte(tt.config), &r)
+
+		if e := r.Entries(); !reflect.DeepEqual(tt.entries, e) {
+			t.Errorf("bad report (%s): want %#v, got %#v", tt.config, tt.entries, e)
+		}
+	}
+}
+
+func TestValidateCloudConfig(t *testing.T) {
+	tests := []struct {
+		config string
+		rules  []rule
+
+		report Report
+		err    error
+	}{
+		{
+			rules: []rule{func(_ node, _ *Report) { panic("something happened") }},
+			err:   errors.New("something happened"),
+		},
+	}
+
+	for _, tt := range tests {
+		r, err := validateCloudConfig([]byte(tt.config), tt.rules)
+		if !reflect.DeepEqual(tt.err, err) {
+			t.Errorf("bad error (%s): want %v, got %v", tt.config, tt.err, err)
+		}
+		if !reflect.DeepEqual(tt.report, r) {
+			t.Errorf("bad report (%s): want %+v, got %+v", tt.config, tt.report, r)
+		}
+	}
+}
+
+func BenchmarkValidate(b *testing.B) {
+	config := `#cloud-config
+hostname: test
+
+coreos:
+  etcd:
+    name:      node001
+    discovery: https://discovery.etcd.io/disco
+    addr:      $public_ipv4:4001
+    peer-addr: $private_ipv4:7001
+  fleet:
+    verbosity: 2
+    metadata:  "hi"
+  update:
+    reboot-strategy: off
+  units:
+    - name:    hi.service
+      command: start
+      enable:  true
+    - name:    bye.service
+      command: stop
+
+ssh_authorized_keys:
+  - ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC0g+ZTxC7weoIJLUafOgrm+h...
+  - ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC0g+ZTxC7weoIJLUafOgrm+h...
+
+users:
+  - name: me
+
+write_files:
+  - path: /etc/yes
+    content: "Hi"
+
+manage_etc_hosts: localhost`
+
+	for i := 0; i < b.N; i++ {
+		if _, err := Validate([]byte(config)); err != nil {
+			panic(err)
+		}
+	}
+}

coreos-cloudinit.go

@@ -23,6 +23,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/coreos/coreos-cloudinit/config"
+	"github.com/coreos/coreos-cloudinit/config/validate"
 	"github.com/coreos/coreos-cloudinit/datasource"
 	"github.com/coreos/coreos-cloudinit/datasource/configdrive"
 	"github.com/coreos/coreos-cloudinit/datasource/file"
@@ -38,7 +40,7 @@ import (
 )
 
 const (
-	version               = "0.10.7"
+	version               = "0.11.2"
 	datasourceInterval    = 100 * time.Millisecond
 	datasourceMaxInterval = 30 * time.Second
 	datasourceTimeout     = 5 * time.Minute
@@ -63,6 +65,7 @@ var (
 		workspace      string
 		sshKeyName     string
 		oem            string
+		validate       bool
 	}{}
 )
 
@@ -82,6 +85,7 @@ func init() {
 	flag.StringVar(&flags.convertNetconf, "convert-netconf", "", "Read the network config provided in cloud-drive and translate it from the specified format into networkd unit files")
 	flag.StringVar(&flags.workspace, "workspace", "/var/lib/coreos-cloudinit", "Base directory coreos-cloudinit should use to store data")
 	flag.StringVar(&flags.sshKeyName, "ssh-key-name", initialize.DefaultSSHKeyName, "Add SSH keys to the system with the given name")
+	flag.BoolVar(&flags.validate, "validate", false, "[EXPERIMENTAL] Validate the user-data but do not apply it to the system")
 }
 
 type oemConfig map[string]string
@@ -157,6 +161,22 @@ func main() {
 		failure = true
 	}
 
+	if report, err := validate.Validate(userdataBytes); err == nil {
+		ret := 0
+		for _, e := range report.Entries() {
+			fmt.Println(e)
+			ret = 1
+		}
+		if flags.validate {
+			os.Exit(ret)
+		}
+	} else {
+		fmt.Printf("Failed while validating user_data (%q)\n", err)
+		if flags.validate {
+			os.Exit(1)
+		}
+	}
+
 	fmt.Printf("Fetching meta-data from datasource of type %q\n", ds.Type())
 	metadataBytes, err := ds.FetchMetadata()
 	if err != nil {
@@ -178,8 +198,8 @@ func main() {
 	env := initialize.NewEnvironment("/", ds.ConfigRoot(), flags.workspace, flags.convertNetconf, flags.sshKeyName, subs)
 	userdata := env.Apply(string(userdataBytes))
 
-	var ccm, ccu *initialize.CloudConfig
-	var script *system.Script
+	var ccm, ccu *config.CloudConfig
+	var script *config.Script
 	if ccm, err = initialize.ParseMetaData(string(metadataBytes)); err != nil {
 		fmt.Printf("Failed to parse meta-data: %v\n", err)
 		os.Exit(1)
@@ -200,14 +220,14 @@ func main() {
 		failure = true
 	} else {
 		switch t := ud.(type) {
-		case *initialize.CloudConfig:
+		case *config.CloudConfig:
 			ccu = t
-		case system.Script:
+		case config.Script:
 			script = &t
 		}
 	}
 
-	var cc *initialize.CloudConfig
+	var cc *config.CloudConfig
 	if ccm != nil && ccu != nil {
 		fmt.Println("Merging cloud-config from meta-data and user-data")
 		merged := mergeCloudConfig(*ccm, *ccu)
@@ -246,7 +266,7 @@ func main() {
 // not already set on udcc (i.e. user-data always takes precedence)
 // NB: This needs to be kept in sync with ParseMetadata so that it tracks all
 // elements of a CloudConfig which that function can populate.
-func mergeCloudConfig(mdcc, udcc initialize.CloudConfig) (cc initialize.CloudConfig) {
+func mergeCloudConfig(mdcc, udcc config.CloudConfig) (cc config.CloudConfig) {
 	if mdcc.Hostname != "" {
 		if udcc.Hostname != "" {
 			fmt.Printf("Warning: user-data hostname (%s) overrides metadata hostname (%s)\n", udcc.Hostname, mdcc.Hostname)
@@ -361,7 +381,7 @@ func selectDatasource(sources []datasource.Datasource) datasource.Datasource {
 }
 
 // TODO(jonboulle): this should probably be refactored and moved into a different module
-func runScript(script system.Script, env *initialize.Environment) error {
+func runScript(script config.Script, env *initialize.Environment) error {
 	err := initialize.PrepWorkspace(env.Workspace())
 	if err != nil {
 		fmt.Printf("Failed preparing workspace: %v\n", err)

coreos-cloudinit_test.go

@@ -20,37 +20,37 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/coreos/coreos-cloudinit/initialize"
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 func TestMergeCloudConfig(t *testing.T) {
-	simplecc := initialize.CloudConfig{
+	simplecc := config.CloudConfig{
 		SSHAuthorizedKeys: []string{"abc", "def"},
 		Hostname:          "foobar",
 		NetworkConfigPath: "/path/somewhere",
 		NetworkConfig:     `{}`,
 	}
 	for i, tt := range []struct {
-		udcc initialize.CloudConfig
-		mdcc initialize.CloudConfig
-		want initialize.CloudConfig
+		udcc config.CloudConfig
+		mdcc config.CloudConfig
+		want config.CloudConfig
 	}{
 		{
 			// If mdcc is empty, udcc should be returned unchanged
 			simplecc,
-			initialize.CloudConfig{},
+			config.CloudConfig{},
 			simplecc,
 		},
 		{
 			// If udcc is empty, mdcc should be returned unchanged(overridden)
-			initialize.CloudConfig{},
+			config.CloudConfig{},
 			simplecc,
 			simplecc,
 		},
 		{
 			// user-data should override completely in the case of conflicts
 			simplecc,
-			initialize.CloudConfig{
+			config.CloudConfig{
 				Hostname:          "meta-hostname",
 				NetworkConfigPath: "/path/meta",
 				NetworkConfig:     `{"hostname":"test"}`,
@@ -59,17 +59,17 @@ func TestMergeCloudConfig(t *testing.T) {
 		},
 		{
 			// Mixed merge should succeed
-			initialize.CloudConfig{
+			config.CloudConfig{
 				SSHAuthorizedKeys: []string{"abc", "def"},
 				Hostname:          "user-hostname",
 				NetworkConfigPath: "/path/somewhere",
 				NetworkConfig:     `{"hostname":"test"}`,
 			},
-			initialize.CloudConfig{
+			config.CloudConfig{
 				SSHAuthorizedKeys: []string{"woof", "qux"},
 				Hostname:          "meta-hostname",
 			},
-			initialize.CloudConfig{
+			config.CloudConfig{
 				SSHAuthorizedKeys: []string{"abc", "def", "woof", "qux"},
 				Hostname:          "user-hostname",
 				NetworkConfigPath: "/path/somewhere",
@@ -78,15 +78,15 @@ func TestMergeCloudConfig(t *testing.T) {
 		},
 		{
 			// Completely non-conflicting merge should be fine
-			initialize.CloudConfig{
+			config.CloudConfig{
 				Hostname: "supercool",
 			},
-			initialize.CloudConfig{
+			config.CloudConfig{
 				SSHAuthorizedKeys: []string{"zaphod", "beeblebrox"},
 				NetworkConfigPath: "/dev/fun",
 				NetworkConfig:     `{"hostname":"test"}`,
 			},
-			initialize.CloudConfig{
+			config.CloudConfig{
 				Hostname:          "supercool",
 				SSHAuthorizedKeys: []string{"zaphod", "beeblebrox"},
 				NetworkConfigPath: "/dev/fun",
@@ -95,33 +95,33 @@ func TestMergeCloudConfig(t *testing.T) {
 		},
 		{
 			// Non-mergeable settings in user-data should not be affected
-			initialize.CloudConfig{
+			config.CloudConfig{
 				Hostname:       "mememe",
-				ManageEtcHosts: initialize.EtcHosts("lolz"),
+				ManageEtcHosts: config.EtcHosts("lolz"),
 			},
-			initialize.CloudConfig{
+			config.CloudConfig{
 				Hostname:          "youyouyou",
 				NetworkConfigPath: "meta-meta-yo",
 				NetworkConfig:     `{"hostname":"test"}`,
 			},
-			initialize.CloudConfig{
+			config.CloudConfig{
 				Hostname:          "mememe",
-				ManageEtcHosts:    initialize.EtcHosts("lolz"),
+				ManageEtcHosts:    config.EtcHosts("lolz"),
 				NetworkConfigPath: "meta-meta-yo",
 				NetworkConfig:     `{"hostname":"test"}`,
 			},
 		},
 		{
 			// Non-mergeable (unexpected) settings in meta-data are ignored
-			initialize.CloudConfig{
+			config.CloudConfig{
 				Hostname: "mememe",
 			},
-			initialize.CloudConfig{
-				ManageEtcHosts:    initialize.EtcHosts("lolz"),
+			config.CloudConfig{
+				ManageEtcHosts:    config.EtcHosts("lolz"),
 				NetworkConfigPath: "meta-meta-yo",
 				NetworkConfig:     `{"hostname":"test"}`,
 			},
-			initialize.CloudConfig{
+			config.CloudConfig{
 				Hostname:          "mememe",
 				NetworkConfigPath: "meta-meta-yo",
 				NetworkConfig:     `{"hostname":"test"}`,

initialize/config.go

@@ -22,8 +22,7 @@ import (
 	"log"
 	"path"
 
-	"github.com/coreos/coreos-cloudinit/Godeps/_workspace/src/gopkg.in/yaml.v1"
-
+	"github.com/coreos/coreos-cloudinit/config"
 	"github.com/coreos/coreos-cloudinit/network"
 	"github.com/coreos/coreos-cloudinit/system"
 )
@@ -33,146 +32,19 @@ import (
 type CloudConfigFile interface {
 	// File should either return (*system.File, error), or (nil, nil) if nothing
 	// needs to be done for this configuration option.
-	File(root string) (*system.File, error)
+	File() (*system.File, error)
 }
 
 // CloudConfigUnit represents a CoreOS specific configuration option that can generate
 // associated system.Units to be created/enabled appropriately
 type CloudConfigUnit interface {
-	Units(root string) ([]system.Unit, error)
-}
-
-// CloudConfig encapsulates the entire cloud-config configuration file and maps directly to YAML
-type CloudConfig struct {
-	SSHAuthorizedKeys []string `yaml:"ssh_authorized_keys"`
-	Coreos            struct {
-		Etcd   EtcdEnvironment
-		Fleet  FleetEnvironment
-		OEM    OEMRelease
-		Update UpdateConfig
-		Units  []system.Unit
-	}
-	WriteFiles        []system.File `yaml:"write_files"`
-	Hostname          string
-	Users             []system.User
-	ManageEtcHosts    EtcHosts `yaml:"manage_etc_hosts"`
-	NetworkConfigPath string
-	NetworkConfig     string
-}
-
-type warner func(format string, v ...interface{})
-
-// warnOnUnrecognizedKeys parses the contents of a cloud-config file and calls
-// warn(msg, key) for every unrecognized key (i.e. those not present in CloudConfig)
-func warnOnUnrecognizedKeys(contents string, warn warner) {
-	// Generate a map of all understood cloud config options
-	var cc map[string]interface{}
-	b, _ := yaml.Marshal(&CloudConfig{})
-	yaml.Unmarshal(b, &cc)
-
-	// Now unmarshal the entire provided contents
-	var c map[string]interface{}
-	yaml.Unmarshal([]byte(contents), &c)
-
-	// Check that every key in the contents exists in the cloud config
-	for k, _ := range c {
-		if _, ok := cc[k]; !ok {
-			warn("Warning: unrecognized key %q in provided cloud config - ignoring section", k)
-		}
-	}
-
-	// Check for unrecognized coreos options, if any are set
-	if coreos, ok := c["coreos"]; ok {
-		if set, ok := coreos.(map[interface{}]interface{}); ok {
-			known := cc["coreos"].(map[interface{}]interface{})
-			for k, _ := range set {
-				if key, ok := k.(string); ok {
-					if _, ok := known[key]; !ok {
-						warn("Warning: unrecognized key %q in coreos section of provided cloud config - ignoring", key)
-					}
-				} else {
-					warn("Warning: unrecognized key %q in coreos section of provided cloud config - ignoring", k)
-				}
-			}
-		}
-	}
-
-	// Check for any badly-specified users, if any are set
-	if users, ok := c["users"]; ok {
-		var known map[string]interface{}
-		b, _ := yaml.Marshal(&system.User{})
-		yaml.Unmarshal(b, &known)
-
-		if set, ok := users.([]interface{}); ok {
-			for _, u := range set {
-				if user, ok := u.(map[interface{}]interface{}); ok {
-					for k, _ := range user {
-						if key, ok := k.(string); ok {
-							if _, ok := known[key]; !ok {
-								warn("Warning: unrecognized key %q in user section of cloud config - ignoring", key)
-							}
-						} else {
-							warn("Warning: unrecognized key %q in user section of cloud config - ignoring", k)
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// Check for any badly-specified files, if any are set
-	if files, ok := c["write_files"]; ok {
-		var known map[string]interface{}
-		b, _ := yaml.Marshal(&system.File{})
-		yaml.Unmarshal(b, &known)
-
-		if set, ok := files.([]interface{}); ok {
-			for _, f := range set {
-				if file, ok := f.(map[interface{}]interface{}); ok {
-					for k, _ := range file {
-						if key, ok := k.(string); ok {
-							if _, ok := known[key]; !ok {
-								warn("Warning: unrecognized key %q in file section of cloud config - ignoring", key)
-							}
-						} else {
-							warn("Warning: unrecognized key %q in file section of cloud config - ignoring", k)
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-// NewCloudConfig instantiates a new CloudConfig from the given contents (a
-// string of YAML), returning any error encountered. It will ignore unknown
-// fields but log encountering them.
-func NewCloudConfig(contents string) (*CloudConfig, error) {
-	var cfg CloudConfig
-	err := yaml.Unmarshal([]byte(contents), &cfg)
-	if err != nil {
-		return &cfg, err
-	}
-	warnOnUnrecognizedKeys(contents, log.Printf)
-	return &cfg, nil
-}
-
-func (cc CloudConfig) String() string {
-	bytes, err := yaml.Marshal(cc)
-	if err != nil {
-		return ""
-	}
-
-	stringified := string(bytes)
-	stringified = fmt.Sprintf("#cloud-config\n%s", stringified)
-
-	return stringified
+	Units() []system.Unit
 }
 
 // Apply renders a CloudConfig to an Environment. This can involve things like
 // configuring the hostname, adding new users, writing various configuration
 // files to disk, and manipulating systemd services.
-func Apply(cfg CloudConfig, env *Environment) error {
+func Apply(cfg config.CloudConfig, env *Environment) error {
 	if cfg.Hostname != "" {
 		if err := system.SetHostname(cfg.Hostname); err != nil {
 			return err
@@ -232,26 +104,41 @@ func Apply(cfg CloudConfig, env *Environment) error {
 		}
 	}
 
-	for _, ccf := range []CloudConfigFile{cfg.Coreos.OEM, cfg.Coreos.Update, cfg.ManageEtcHosts} {
-		f, err := ccf.File(env.Root())
+	var writeFiles []system.File
+	for _, file := range cfg.WriteFiles {
+		writeFiles = append(writeFiles, system.File{File: file})
+	}
+
+	for _, ccf := range []CloudConfigFile{
+		system.OEM{OEM: cfg.Coreos.OEM},
+		system.Update{Update: cfg.Coreos.Update, ReadConfig: system.DefaultReadConfig},
+		system.EtcHosts{EtcHosts: cfg.ManageEtcHosts},
+	} {
+		f, err := ccf.File()
 		if err != nil {
 			return err
 		}
 		if f != nil {
-			cfg.WriteFiles = append(cfg.WriteFiles, *f)
+			writeFiles = append(writeFiles, *f)
 		}
 	}
 
-	for _, ccu := range []CloudConfigUnit{cfg.Coreos.Etcd, cfg.Coreos.Fleet, cfg.Coreos.Update} {
-		u, err := ccu.Units(env.Root())
-		if err != nil {
-			return err
-		}
-		cfg.Coreos.Units = append(cfg.Coreos.Units, u...)
+	var units []system.Unit
+	for _, u := range cfg.Coreos.Units {
+		units = append(units, system.Unit{Unit: u})
+	}
+
+	for _, ccu := range []CloudConfigUnit{
+		system.Etcd{Etcd: cfg.Coreos.Etcd},
+		system.Fleet{Fleet: cfg.Coreos.Fleet},
+		system.Flannel{Flannel: cfg.Coreos.Flannel},
+		system.Update{Update: cfg.Coreos.Update, ReadConfig: system.DefaultReadConfig},
+	} {
+		units = append(units, ccu.Units()...)
 	}
 
 	wroteEnvironment := false
-	for _, file := range cfg.WriteFiles {
+	for _, file := range writeFiles {
 		fullPath, err := system.WriteFile(&file, env.Root())
 		if err != nil {
 			return err
@@ -298,7 +185,7 @@ func Apply(cfg CloudConfig, env *Environment) error {
 	}
 
 	um := system.NewUnitManager(env.Root())
-	return processUnits(cfg.Coreos.Units, env.Root(), um)
+	return processUnits(units, env.Root(), um)
 
 }
 

initialize/config_test.go

@@ -17,368 +17,12 @@
 package initialize
 
 import (
-	"fmt"
-	"strings"
 	"testing"
 
+	"github.com/coreos/coreos-cloudinit/config"
 	"github.com/coreos/coreos-cloudinit/system"
 )
 
-func TestCloudConfigInvalidKeys(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			t.Fatalf("panic while instantiating CloudConfig with nil keys: %v", r)
-		}
-	}()
-
-	for _, tt := range []struct {
-		contents string
-	}{
-		{"coreos:"},
-		{"ssh_authorized_keys:"},
-		{"ssh_authorized_keys:\n  -"},
-		{"ssh_authorized_keys:\n  - 0:"},
-		{"write_files:"},
-		{"write_files:\n  -"},
-		{"write_files:\n  - 0:"},
-		{"users:"},
-		{"users:\n  -"},
-		{"users:\n  - 0:"},
-	} {
-		_, err := NewCloudConfig(tt.contents)
-		if err != nil {
-			t.Fatalf("error instantiating CloudConfig with invalid keys: %v", err)
-		}
-	}
-}
-
-func TestCloudConfigUnknownKeys(t *testing.T) {
-	contents := `
-coreos: 
-  etcd:
-    discovery: "https://discovery.etcd.io/827c73219eeb2fa5530027c37bf18877"
-  coreos_unknown:
-    foo: "bar"
-section_unknown:
-  dunno:
-    something
-bare_unknown:
-  bar
-write_files:
-  - content: fun
-    path: /var/party
-    file_unknown: nofun
-users:
-  - name: fry
-    passwd: somehash
-    user_unknown: philip
-hostname:
-  foo
-`
-	cfg, err := NewCloudConfig(contents)
-	if err != nil {
-		t.Fatalf("error instantiating CloudConfig with unknown keys: %v", err)
-	}
-	if cfg.Hostname != "foo" {
-		t.Fatalf("hostname not correctly set when invalid keys are present")
-	}
-	if len(cfg.Coreos.Etcd) < 1 {
-		t.Fatalf("etcd section not correctly set when invalid keys are present")
-	}
-	if len(cfg.WriteFiles) < 1 || cfg.WriteFiles[0].Content != "fun" || cfg.WriteFiles[0].Path != "/var/party" {
-		t.Fatalf("write_files section not correctly set when invalid keys are present")
-	}
-	if len(cfg.Users) < 1 || cfg.Users[0].Name != "fry" || cfg.Users[0].PasswordHash != "somehash" {
-		t.Fatalf("users section not correctly set when invalid keys are present")
-	}
-
-	var warnings string
-	catchWarn := func(f string, v ...interface{}) {
-		warnings += fmt.Sprintf(f, v...)
-	}
-
-	warnOnUnrecognizedKeys(contents, catchWarn)
-
-	if !strings.Contains(warnings, "coreos_unknown") {
-		t.Errorf("warnings did not catch unrecognized coreos option coreos_unknown")
-	}
-	if !strings.Contains(warnings, "bare_unknown") {
-		t.Errorf("warnings did not catch unrecognized key bare_unknown")
-	}
-	if !strings.Contains(warnings, "section_unknown") {
-		t.Errorf("warnings did not catch unrecognized key section_unknown")
-	}
-	if !strings.Contains(warnings, "user_unknown") {
-		t.Errorf("warnings did not catch unrecognized user key user_unknown")
-	}
-	if !strings.Contains(warnings, "file_unknown") {
-		t.Errorf("warnings did not catch unrecognized file key file_unknown")
-	}
-}
-
-// Assert that the parsing of a cloud config file "generally works"
-func TestCloudConfigEmpty(t *testing.T) {
-	cfg, err := NewCloudConfig("")
-	if err != nil {
-		t.Fatalf("Encountered unexpected error :%v", err)
-	}
-
-	keys := cfg.SSHAuthorizedKeys
-	if len(keys) != 0 {
-		t.Error("Parsed incorrect number of SSH keys")
-	}
-
-	if len(cfg.WriteFiles) != 0 {
-		t.Error("Expected zero WriteFiles")
-	}
-
-	if cfg.Hostname != "" {
-		t.Errorf("Expected hostname to be empty, got '%s'", cfg.Hostname)
-	}
-}
-
-// Assert that the parsing of a cloud config file "generally works"
-func TestCloudConfig(t *testing.T) {
-	contents := `
-coreos: 
-  etcd:
-    discovery: "https://discovery.etcd.io/827c73219eeb2fa5530027c37bf18877"
-  update:
-    reboot-strategy: reboot
-  units:
-    - name: 50-eth0.network
-      runtime: yes
-      content: '[Match]
- 
-    Name=eth47
- 
- 
-    [Network]
- 
-    Address=10.209.171.177/19
- 
-'
-  oem:
-    id: rackspace
-    name: Rackspace Cloud Servers
-    version-id: 168.0.0
-    home-url: https://www.rackspace.com/cloud/servers/
-    bug-report-url: https://github.com/coreos/coreos-overlay
-ssh_authorized_keys:
-  - foobar
-  - foobaz
-write_files:
-  - content: |
-      penny
-      elroy
-    path: /etc/dogepack.conf
-    permissions: '0644'
-    owner: root:dogepack
-hostname: trontastic
-`
-	cfg, err := NewCloudConfig(contents)
-	if err != nil {
-		t.Fatalf("Encountered unexpected error :%v", err)
-	}
-
-	keys := cfg.SSHAuthorizedKeys
-	if len(keys) != 2 {
-		t.Error("Parsed incorrect number of SSH keys")
-	} else if keys[0] != "foobar" {
-		t.Error("Expected first SSH key to be 'foobar'")
-	} else if keys[1] != "foobaz" {
-		t.Error("Expected first SSH key to be 'foobaz'")
-	}
-
-	if len(cfg.WriteFiles) != 1 {
-		t.Error("Failed to parse correct number of write_files")
-	} else {
-		wf := cfg.WriteFiles[0]
-		if wf.Content != "penny\nelroy\n" {
-			t.Errorf("WriteFile has incorrect contents '%s'", wf.Content)
-		}
-		if wf.Encoding != "" {
-			t.Errorf("WriteFile has incorrect encoding %s", wf.Encoding)
-		}
-		if perm, _ := wf.Permissions(); perm != 0644 {
-			t.Errorf("WriteFile has incorrect permissions %s", perm)
-		}
-		if wf.Path != "/etc/dogepack.conf" {
-			t.Errorf("WriteFile has incorrect path %s", wf.Path)
-		}
-		if wf.Owner != "root:dogepack" {
-			t.Errorf("WriteFile has incorrect owner %s", wf.Owner)
-		}
-	}
-
-	if len(cfg.Coreos.Units) != 1 {
-		t.Error("Failed to parse correct number of units")
-	} else {
-		u := cfg.Coreos.Units[0]
-		expect := `[Match]
-Name=eth47
-
-[Network]
-Address=10.209.171.177/19
-`
-		if u.Content != expect {
-			t.Errorf("Unit has incorrect contents '%s'.\nExpected '%s'.", u.Content, expect)
-		}
-		if u.Runtime != true {
-			t.Errorf("Unit has incorrect runtime value")
-		}
-		if u.Name != "50-eth0.network" {
-			t.Errorf("Unit has incorrect name %s", u.Name)
-		}
-		if u.Type() != "network" {
-			t.Errorf("Unit has incorrect type '%s'", u.Type())
-		}
-	}
-
-	if cfg.Coreos.OEM.ID != "rackspace" {
-		t.Errorf("Failed parsing coreos.oem. Expected ID 'rackspace', got %q.", cfg.Coreos.OEM.ID)
-	}
-
-	if cfg.Hostname != "trontastic" {
-		t.Errorf("Failed to parse hostname")
-	}
-	if cfg.Coreos.Update["reboot-strategy"] != "reboot" {
-		t.Errorf("Failed to parse locksmith strategy")
-	}
-}
-
-// Assert that our interface conversion doesn't panic
-func TestCloudConfigKeysNotList(t *testing.T) {
-	contents := `
-ssh_authorized_keys:
-  - foo: bar
-`
-	cfg, err := NewCloudConfig(contents)
-	if err != nil {
-		t.Fatalf("Encountered unexpected error: %v", err)
-	}
-
-	keys := cfg.SSHAuthorizedKeys
-	if len(keys) != 0 {
-		t.Error("Parsed incorrect number of SSH keys")
-	}
-}
-
-func TestCloudConfigSerializationHeader(t *testing.T) {
-	cfg, _ := NewCloudConfig("")
-	contents := cfg.String()
-	header := strings.SplitN(contents, "\n", 2)[0]
-	if header != "#cloud-config" {
-		t.Fatalf("Serialized config did not have expected header")
-	}
-}
-
-// TestDropInIgnored asserts that users are unable to set DropIn=True on units
-func TestDropInIgnored(t *testing.T) {
-	contents := `
-coreos:
-  units:
-    - name: test
-      dropin: true
-`
-	cfg, err := NewCloudConfig(contents)
-	if err != nil || len(cfg.Coreos.Units) != 1 {
-		t.Fatalf("Encountered unexpected error: %v", err)
-	}
-	if len(cfg.Coreos.Units) != 1 || cfg.Coreos.Units[0].Name != "test" {
-		t.Fatalf("Expected 1 unit, but got %d: %v", len(cfg.Coreos.Units), cfg.Coreos.Units)
-	}
-	if cfg.Coreos.Units[0].DropIn {
-		t.Errorf("dropin option on unit in cloud-config was not ignored!")
-	}
-}
-
-func TestCloudConfigUsers(t *testing.T) {
-	contents := `
-users:
-  - name: elroy
-    passwd: somehash
-    ssh-authorized-keys:
-      - somekey
-    gecos: arbitrary comment
-    homedir: /home/place
-    no-create-home: yes
-    primary-group: things
-    groups:
-      - ping
-      - pong
-    no-user-group: true
-    system: y
-    no-log-init: True
-`
-	cfg, err := NewCloudConfig(contents)
-	if err != nil {
-		t.Fatalf("Encountered unexpected error: %v", err)
-	}
-
-	if len(cfg.Users) != 1 {
-		t.Fatalf("Parsed %d users, expected 1", len(cfg.Users))
-	}
-
-	user := cfg.Users[0]
-
-	if user.Name != "elroy" {
-		t.Errorf("User name is %q, expected 'elroy'", user.Name)
-	}
-
-	if user.PasswordHash != "somehash" {
-		t.Errorf("User passwd is %q, expected 'somehash'", user.PasswordHash)
-	}
-
-	if keys := user.SSHAuthorizedKeys; len(keys) != 1 {
-		t.Errorf("Parsed %d ssh keys, expected 1", len(keys))
-	} else {
-		key := user.SSHAuthorizedKeys[0]
-		if key != "somekey" {
-			t.Errorf("User SSH key is %q, expected 'somekey'", key)
-		}
-	}
-
-	if user.GECOS != "arbitrary comment" {
-		t.Errorf("Failed to parse gecos field, got %q", user.GECOS)
-	}
-
-	if user.Homedir != "/home/place" {
-		t.Errorf("Failed to parse homedir field, got %q", user.Homedir)
-	}
-
-	if !user.NoCreateHome {
-		t.Errorf("Failed to parse no-create-home field")
-	}
-
-	if user.PrimaryGroup != "things" {
-		t.Errorf("Failed to parse primary-group field, got %q", user.PrimaryGroup)
-	}
-
-	if len(user.Groups) != 2 {
-		t.Errorf("Failed to parse 2 goups, got %d", len(user.Groups))
-	} else {
-		if user.Groups[0] != "ping" {
-			t.Errorf("First group was %q, not expected value 'ping'", user.Groups[0])
-		}
-		if user.Groups[1] != "pong" {
-			t.Errorf("First group was %q, not expected value 'pong'", user.Groups[1])
-		}
-	}
-
-	if !user.NoUserGroup {
-		t.Errorf("Failed to parse no-user-group field")
-	}
-
-	if !user.System {
-		t.Errorf("Failed to parse system field")
-	}
-
-	if !user.NoLogInit {
-		t.Errorf("Failed to parse no-log-init field")
-	}
-}
-
 type TestUnitManager struct {
 	placed   []string
 	enabled  []string
@@ -417,10 +61,10 @@ func (tum *TestUnitManager) UnmaskUnit(unit *system.Unit) error {
 func TestProcessUnits(t *testing.T) {
 	tum := &TestUnitManager{}
 	units := []system.Unit{
-		system.Unit{
+		system.Unit{Unit: config.Unit{
 			Name: "foo",
 			Mask: true,
-		},
+		}},
 	}
 	if err := processUnits(units, "", tum); err != nil {
 		t.Fatalf("unexpected error calling processUnits: %v", err)
@@ -431,9 +75,9 @@ func TestProcessUnits(t *testing.T) {
 
 	tum = &TestUnitManager{}
 	units = []system.Unit{
-		system.Unit{
+		system.Unit{Unit: config.Unit{
 			Name: "bar.network",
-		},
+		}},
 	}
 	if err := processUnits(units, "", tum); err != nil {
 		t.Fatalf("unexpected error calling processUnits: %v", err)
@@ -444,10 +88,10 @@ func TestProcessUnits(t *testing.T) {
 
 	tum = &TestUnitManager{}
 	units = []system.Unit{
-		system.Unit{
+		system.Unit{Unit: config.Unit{
 			Name:    "baz.service",
 			Content: "[Service]\nExecStart=/bin/true",
-		},
+		}},
 	}
 	if err := processUnits(units, "", tum); err != nil {
 		t.Fatalf("unexpected error calling processUnits: %v", err)
@@ -458,10 +102,10 @@ func TestProcessUnits(t *testing.T) {
 
 	tum = &TestUnitManager{}
 	units = []system.Unit{
-		system.Unit{
+		system.Unit{Unit: config.Unit{
 			Name:    "locksmithd.service",
 			Runtime: true,
-		},
+		}},
 	}
 	if err := processUnits(units, "", tum); err != nil {
 		t.Fatalf("unexpected error calling processUnits: %v", err)
@@ -472,10 +116,10 @@ func TestProcessUnits(t *testing.T) {
 
 	tum = &TestUnitManager{}
 	units = []system.Unit{
-		system.Unit{
+		system.Unit{Unit: config.Unit{
 			Name:   "woof",
 			Enable: true,
-		},
+		}},
 	}
 	if err := processUnits(units, "", tum); err != nil {
 		t.Fatalf("unexpected error calling processUnits: %v", err)

initialize/env.go

@@ -22,6 +22,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/coreos/coreos-cloudinit/config"
 	"github.com/coreos/coreos-cloudinit/system"
 )
 
@@ -97,9 +98,9 @@ func (e *Environment) Apply(data string) string {
 
 func (e *Environment) DefaultEnvironmentFile() *system.EnvFile {
 	ef := system.EnvFile{
-		File: &system.File{
+		File: &system.File{File: config.File{
 			Path: "/etc/environment",
-		},
+		}},
 		Vars: map[string]string{},
 	}
 	if ip, ok := e.substitutions["$public_ipv4"]; ok && len(ip) > 0 {
@@ -120,16 +121,3 @@ func (e *Environment) DefaultEnvironmentFile() *system.EnvFile {
 		return &ef
 	}
 }
-
-// normalizeSvcEnv standardizes the keys of the map (environment variables for a service)
-// by replacing any dashes with underscores and ensuring they are entirely upper case.
-// For example, "some-env" --> "SOME_ENV"
-func normalizeSvcEnv(m map[string]string) map[string]string {
-	out := make(map[string]string, len(m))
-	for key, val := range m {
-		key = strings.ToUpper(key)
-		key = strings.Replace(key, "-", "_", -1)
-		out[key] = val
-	}
-	return out
-}

initialize/etcd.go

@@ -1,63 +0,0 @@
-package initialize
-
-import (
-	"errors"
-	"fmt"
-	"sort"
-
-	"github.com/coreos/coreos-cloudinit/system"
-)
-
-type EtcdEnvironment map[string]string
-
-func (ee EtcdEnvironment) String() (out string) {
-	norm := normalizeSvcEnv(ee)
-
-	if val, ok := norm["DISCOVERY_URL"]; ok {
-		delete(norm, "DISCOVERY_URL")
-		if _, ok := norm["DISCOVERY"]; !ok {
-			norm["DISCOVERY"] = val
-		}
-	}
-
-	var sorted sort.StringSlice
-	for k, _ := range norm {
-		sorted = append(sorted, k)
-	}
-	sorted.Sort()
-
-	out += "[Service]\n"
-
-	for _, key := range sorted {
-		val := norm[key]
-		out += fmt.Sprintf("Environment=\"ETCD_%s=%s\"\n", key, val)
-	}
-
-	return
-}
-
-// Units creates a Unit file drop-in for etcd, using any configured
-// options and adding a default MachineID if unset.
-func (ee EtcdEnvironment) Units(root string) ([]system.Unit, error) {
-	if len(ee) < 1 {
-		return nil, nil
-	}
-
-	if _, ok := ee["name"]; !ok {
-		if machineID := system.MachineID(root); machineID != "" {
-			ee["name"] = machineID
-		} else if hostname, err := system.Hostname(); err == nil {
-			ee["name"] = hostname
-		} else {
-			return nil, errors.New("Unable to determine default etcd name")
-		}
-	}
-
-	etcd := system.Unit{
-		Name:    "etcd.service",
-		Runtime: true,
-		DropIn:  true,
-		Content: ee.String(),
-	}
-	return []system.Unit{etcd}, nil
-}

initialize/etcd_test.go

@@ -1,184 +0,0 @@
-package initialize
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-
-	"github.com/coreos/coreos-cloudinit/system"
-)
-
-func TestEtcdEnvironment(t *testing.T) {
-	cfg := make(EtcdEnvironment, 0)
-	cfg["discovery"] = "http://disco.example.com/foobar"
-	cfg["peer-bind-addr"] = "127.0.0.1:7002"
-
-	env := cfg.String()
-	expect := `[Service]
-Environment="ETCD_DISCOVERY=http://disco.example.com/foobar"
-Environment="ETCD_PEER_BIND_ADDR=127.0.0.1:7002"
-`
-
-	if env != expect {
-		t.Errorf("Generated environment:\n%s\nExpected environment:\n%s", env, expect)
-	}
-}
-
-func TestEtcdEnvironmentDiscoveryURLTranslated(t *testing.T) {
-	cfg := make(EtcdEnvironment, 0)
-	cfg["discovery_url"] = "http://disco.example.com/foobar"
-	cfg["peer-bind-addr"] = "127.0.0.1:7002"
-
-	env := cfg.String()
-	expect := `[Service]
-Environment="ETCD_DISCOVERY=http://disco.example.com/foobar"
-Environment="ETCD_PEER_BIND_ADDR=127.0.0.1:7002"
-`
-
-	if env != expect {
-		t.Errorf("Generated environment:\n%s\nExpected environment:\n%s", env, expect)
-	}
-}
-
-func TestEtcdEnvironmentDiscoveryOverridesDiscoveryURL(t *testing.T) {
-	cfg := make(EtcdEnvironment, 0)
-	cfg["discovery_url"] = "ping"
-	cfg["discovery"] = "pong"
-	cfg["peer-bind-addr"] = "127.0.0.1:7002"
-
-	env := cfg.String()
-	expect := `[Service]
-Environment="ETCD_DISCOVERY=pong"
-Environment="ETCD_PEER_BIND_ADDR=127.0.0.1:7002"
-`
-
-	if env != expect {
-		t.Errorf("Generated environment:\n%s\nExpected environment:\n%s", env, expect)
-	}
-}
-
-func TestEtcdEnvironmentWrittenToDisk(t *testing.T) {
-	ee := EtcdEnvironment{
-		"name":           "node001",
-		"discovery":      "http://disco.example.com/foobar",
-		"peer-bind-addr": "127.0.0.1:7002",
-	}
-	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
-	if err != nil {
-		t.Fatalf("Unable to create tempdir: %v", err)
-	}
-	defer os.RemoveAll(dir)
-
-	sd := system.NewUnitManager(dir)
-
-	uu, err := ee.Units(dir)
-	if err != nil {
-		t.Fatalf("Generating etcd unit failed: %v", err)
-	}
-	if len(uu) != 1 {
-		t.Fatalf("Expected 1 unit to be returned, got %d", len(uu))
-	}
-	u := uu[0]
-
-	dst := u.Destination(dir)
-	os.Stderr.WriteString("writing to " + dir + "\n")
-	if err := sd.PlaceUnit(&u, dst); err != nil {
-		t.Fatalf("Writing of EtcdEnvironment failed: %v", err)
-	}
-
-	fullPath := path.Join(dir, "run", "systemd", "system", "etcd.service.d", "20-cloudinit.conf")
-
-	fi, err := os.Stat(fullPath)
-	if err != nil {
-		t.Fatalf("Unable to stat file: %v", err)
-	}
-
-	if fi.Mode() != os.FileMode(0644) {
-		t.Errorf("File has incorrect mode: %v", fi.Mode())
-	}
-
-	contents, err := ioutil.ReadFile(fullPath)
-	if err != nil {
-		t.Fatalf("Unable to read expected file: %v", err)
-	}
-
-	expect := `[Service]
-Environment="ETCD_DISCOVERY=http://disco.example.com/foobar"
-Environment="ETCD_NAME=node001"
-Environment="ETCD_PEER_BIND_ADDR=127.0.0.1:7002"
-`
-	if string(contents) != expect {
-		t.Fatalf("File has incorrect contents")
-	}
-}
-
-func TestEtcdEnvironmentEmptyNoOp(t *testing.T) {
-	ee := EtcdEnvironment{}
-	uu, err := ee.Units("")
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-	if len(uu) > 0 {
-		t.Fatalf("Generated etcd units unexpectedly: %v", uu)
-	}
-}
-
-func TestEtcdEnvironmentWrittenToDiskDefaultToMachineID(t *testing.T) {
-	ee := EtcdEnvironment{"foo": "bar"}
-	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
-	if err != nil {
-		t.Fatalf("Unable to create tempdir: %v", err)
-	}
-	defer os.RemoveAll(dir)
-
-	sd := system.NewUnitManager(dir)
-
-	os.Mkdir(path.Join(dir, "etc"), os.FileMode(0755))
-	err = ioutil.WriteFile(path.Join(dir, "etc", "machine-id"), []byte("node007"), os.FileMode(0444))
-	if err != nil {
-		t.Fatalf("Failed writing out /etc/machine-id: %v", err)
-	}
-
-	uu, err := ee.Units(dir)
-	if err != nil {
-		t.Fatalf("Generating etcd unit failed: %v", err)
-	}
-	if len(uu) == 0 {
-		t.Fatalf("Returned empty etcd units unexpectedly")
-	}
-	u := uu[0]
-
-	dst := u.Destination(dir)
-	os.Stderr.WriteString("writing to " + dir + "\n")
-	if err := sd.PlaceUnit(&u, dst); err != nil {
-		t.Fatalf("Writing of EtcdEnvironment failed: %v", err)
-	}
-
-	fullPath := path.Join(dir, "run", "systemd", "system", "etcd.service.d", "20-cloudinit.conf")
-
-	contents, err := ioutil.ReadFile(fullPath)
-	if err != nil {
-		t.Fatalf("Unable to read expected file: %v", err)
-	}
-
-	expect := `[Service]
-Environment="ETCD_FOO=bar"
-Environment="ETCD_NAME=node007"
-`
-	if string(contents) != expect {
-		t.Fatalf("File has incorrect contents")
-	}
-}
-
-func TestEtcdEnvironmentWhenNil(t *testing.T) {
-	// EtcdEnvironment will be a nil map if it wasn't in the yaml
-	var ee EtcdEnvironment
-	if ee != nil {
-		t.Fatalf("EtcdEnvironment is not nil")
-	}
-	uu, err := ee.Units("")
-	if len(uu) != 0 || err != nil {
-		t.Fatalf("Units returned value for nil input")
-	}
-}

initialize/fleet.go

@@ -1,35 +0,0 @@
-package initialize
-
-import (
-	"fmt"
-
-	"github.com/coreos/coreos-cloudinit/system"
-)
-
-type FleetEnvironment map[string]string
-
-func (fe FleetEnvironment) String() (out string) {
-	norm := normalizeSvcEnv(fe)
-	out += "[Service]\n"
-
-	for key, val := range norm {
-		out += fmt.Sprintf("Environment=\"FLEET_%s=%s\"\n", key, val)
-	}
-
-	return
-}
-
-// Units generates a Unit file drop-in for fleet, if any fleet options were
-// configured in cloud-config
-func (fe FleetEnvironment) Units(root string) ([]system.Unit, error) {
-	if len(fe) < 1 {
-		return nil, nil
-	}
-	fleet := system.Unit{
-		Name:    "fleet.service",
-		Runtime: true,
-		DropIn:  true,
-		Content: fe.String(),
-	}
-	return []system.Unit{fleet}, nil
-}

initialize/fleet_test.go

@@ -1,43 +0,0 @@
-package initialize
-
-import "testing"
-
-func TestFleetEnvironment(t *testing.T) {
-	cfg := make(FleetEnvironment, 0)
-	cfg["public-ip"] = "12.34.56.78"
-
-	env := cfg.String()
-
-	expect := `[Service]
-Environment="FLEET_PUBLIC_IP=12.34.56.78"
-`
-
-	if env != expect {
-		t.Errorf("Generated environment:\n%s\nExpected environment:\n%s", env, expect)
-	}
-}
-
-func TestFleetUnit(t *testing.T) {
-	cfg := make(FleetEnvironment, 0)
-	uu, err := cfg.Units("/")
-	if len(uu) != 0 {
-		t.Errorf("unexpectedly generated unit with empty FleetEnvironment")
-	}
-
-	cfg["public-ip"] = "12.34.56.78"
-
-	uu, err = cfg.Units("/")
-	if err != nil {
-		t.Errorf("error generating fleet unit: %v", err)
-	}
-	if len(uu) != 1 {
-		t.Fatalf("expected 1 unit generated, got %d", len(uu))
-	}
-	u := uu[0]
-	if !u.Runtime {
-		t.Errorf("bad Runtime for generated fleet unit!")
-	}
-	if !u.DropIn {
-		t.Errorf("bad DropIn for generated fleet unit!")
-	}
-}

initialize/github_test.go

@@ -1,32 +0,0 @@
-package initialize
-
-import (
-	"testing"
-)
-
-func TestCloudConfigUsersGithubUser(t *testing.T) {
-
-	contents := `
-users:
-  - name: elroy
-    coreos-ssh-import-github: bcwaldon
-`
-	cfg, err := NewCloudConfig(contents)
-	if err != nil {
-		t.Fatalf("Encountered unexpected error: %v", err)
-	}
-
-	if len(cfg.Users) != 1 {
-		t.Fatalf("Parsed %d users, expected 1", len(cfg.Users))
-	}
-
-	user := cfg.Users[0]
-
-	if user.Name != "elroy" {
-		t.Errorf("User name is %q, expected 'elroy'", user.Name)
-	}
-
-	if user.SSHImportGithubUser != "bcwaldon" {
-		t.Errorf("github user is %q, expected 'bcwaldon'", user.SSHImportGithubUser)
-	}
-}

initialize/manage_etc_hosts_test.go

@@ -1,83 +0,0 @@
-package initialize
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-
-	"github.com/coreos/coreos-cloudinit/system"
-)
-
-func TestCloudConfigManageEtcHosts(t *testing.T) {
-	contents := `
-manage_etc_hosts: localhost
-`
-	cfg, err := NewCloudConfig(contents)
-	if err != nil {
-		t.Fatalf("Encountered unexpected error: %v", err)
-	}
-
-	manageEtcHosts := cfg.ManageEtcHosts
-
-	if manageEtcHosts != "localhost" {
-		t.Errorf("ManageEtcHosts value is %q, expected 'localhost'", manageEtcHosts)
-	}
-}
-
-func TestManageEtcHostsInvalidValue(t *testing.T) {
-	eh := EtcHosts("invalid")
-	if f, err := eh.File(""); err == nil || f != nil {
-		t.Fatalf("EtcHosts File succeeded with invalid value!")
-	}
-}
-
-func TestEtcHostsWrittenToDisk(t *testing.T) {
-	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
-	if err != nil {
-		t.Fatalf("Unable to create tempdir: %v", err)
-	}
-	defer os.RemoveAll(dir)
-
-	eh := EtcHosts("localhost")
-
-	f, err := eh.File(dir)
-	if err != nil {
-		t.Fatalf("Error calling File on EtcHosts: %v", err)
-	}
-	if f == nil {
-		t.Fatalf("manageEtcHosts returned nil file unexpectedly")
-	}
-
-	if _, err := system.WriteFile(f, dir); err != nil {
-		t.Fatalf("Error writing EtcHosts: %v", err)
-	}
-
-	fullPath := path.Join(dir, "etc", "hosts")
-
-	fi, err := os.Stat(fullPath)
-	if err != nil {
-		t.Fatalf("Unable to stat file: %v", err)
-	}
-
-	if fi.Mode() != os.FileMode(0644) {
-		t.Errorf("File has incorrect mode: %v", fi.Mode())
-	}
-
-	contents, err := ioutil.ReadFile(fullPath)
-	if err != nil {
-		t.Fatalf("Unable to read expected file: %v", err)
-	}
-
-	hostname, err := os.Hostname()
-	if err != nil {
-		t.Fatalf("Unable to read OS hostname: %v", err)
-	}
-
-	expect := fmt.Sprintf("%s %s\n", DefaultIpv4Address, hostname)
-
-	if string(contents) != expect {
-		t.Fatalf("File has incorrect contents")
-	}
-}

initialize/meta_data.go

@@ -19,11 +19,13 @@ package initialize
 import (
 	"encoding/json"
 	"sort"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 // ParseMetaData parses a JSON blob in the OpenStack metadata service format,
 // and converts it to a partially hydrated CloudConfig.
-func ParseMetaData(contents string) (*CloudConfig, error) {
+func ParseMetaData(contents string) (*config.CloudConfig, error) {
 	if len(contents) == 0 {
 		return nil, nil
 	}
@@ -38,7 +40,7 @@ func ParseMetaData(contents string) (*CloudConfig, error) {
 		return nil, err
 	}
 
-	var cfg CloudConfig
+	var cfg config.CloudConfig
 	if len(metadata.SSHAuthorizedKeyMap) > 0 {
 		cfg.SSHAuthorizedKeys = make([]string, 0, len(metadata.SSHAuthorizedKeyMap))
 		for _, name := range sortedKeys(metadata.SSHAuthorizedKeyMap) {

initialize/meta_data_test.go

@@ -16,22 +16,26 @@
 
 package initialize
 
-import "reflect"
-import "testing"
+import (
+	"reflect"
+	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
 
 func TestParseMetadata(t *testing.T) {
 	for i, tt := range []struct {
 		in   string
-		want *CloudConfig
+		want *config.CloudConfig
 		err  bool
 	}{
 		{"", nil, false},
 		{`garbage, invalid json`, nil, true},
-		{`{"foo": "bar"}`, &CloudConfig{}, false},
-		{`{"network_config": {"content_path": "asdf"}}`, &CloudConfig{NetworkConfigPath: "asdf"}, false},
-		{`{"hostname": "turkleton"}`, &CloudConfig{Hostname: "turkleton"}, false},
-		{`{"public_keys": {"jack": "jill", "bob": "alice"}}`, &CloudConfig{SSHAuthorizedKeys: []string{"alice", "jill"}}, false},
-		{`{"unknown": "thing", "hostname": "my_host", "public_keys": {"do": "re", "mi": "fa"}, "network_config": {"content_path": "/root", "blah": "zzz"}}`, &CloudConfig{SSHAuthorizedKeys: []string{"re", "fa"}, Hostname: "my_host", NetworkConfigPath: "/root"}, false},
+		{`{"foo": "bar"}`, &config.CloudConfig{}, false},
+		{`{"network_config": {"content_path": "asdf"}}`, &config.CloudConfig{NetworkConfigPath: "asdf"}, false},
+		{`{"hostname": "turkleton"}`, &config.CloudConfig{Hostname: "turkleton"}, false},
+		{`{"public_keys": {"jack": "jill", "bob": "alice"}}`, &config.CloudConfig{SSHAuthorizedKeys: []string{"alice", "jill"}}, false},
+		{`{"unknown": "thing", "hostname": "my_host", "public_keys": {"do": "re", "mi": "fa"}, "network_config": {"content_path": "/root", "blah": "zzz"}}`, &config.CloudConfig{SSHAuthorizedKeys: []string{"re", "fa"}, Hostname: "my_host", NetworkConfigPath: "/root"}, false},
 	} {
 		got, err := ParseMetaData(tt.in)
 		if tt.err != (err != nil) {

initialize/oem.go

@@ -1,41 +0,0 @@
-package initialize
-
-import (
-	"fmt"
-	"path"
-	"strings"
-
-	"github.com/coreos/coreos-cloudinit/system"
-)
-
-type OEMRelease struct {
-	ID           string `yaml:"id"`
-	Name         string `yaml:"name"`
-	VersionID    string `yaml:"version-id"`
-	HomeURL      string `yaml:"home-url"`
-	BugReportURL string `yaml:"bug-report-url"`
-}
-
-func (oem OEMRelease) String() string {
-	fields := []string{
-		fmt.Sprintf("ID=%s", oem.ID),
-		fmt.Sprintf("VERSION_ID=%s", oem.VersionID),
-		fmt.Sprintf("NAME=%q", oem.Name),
-		fmt.Sprintf("HOME_URL=%q", oem.HomeURL),
-		fmt.Sprintf("BUG_REPORT_URL=%q", oem.BugReportURL),
-	}
-
-	return strings.Join(fields, "\n") + "\n"
-}
-
-func (oem OEMRelease) File(root string) (*system.File, error) {
-	if oem.ID == "" {
-		return nil, nil
-	}
-
-	return &system.File{
-		Path:               path.Join("etc", "oem-release"),
-		RawFilePermissions: "0644",
-		Content:            oem.String(),
-	}, nil
-}

initialize/oem_test.go

@@ -1,63 +0,0 @@
-package initialize
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-
-	"github.com/coreos/coreos-cloudinit/system"
-)
-
-func TestOEMReleaseWrittenToDisk(t *testing.T) {
-	oem := OEMRelease{
-		ID:           "rackspace",
-		Name:         "Rackspace Cloud Servers",
-		VersionID:    "168.0.0",
-		HomeURL:      "https://www.rackspace.com/cloud/servers/",
-		BugReportURL: "https://github.com/coreos/coreos-overlay",
-	}
-	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
-	if err != nil {
-		t.Fatalf("Unable to create tempdir: %v", err)
-	}
-	defer os.RemoveAll(dir)
-
-	f, err := oem.File(dir)
-	if err != nil {
-		t.Fatalf("Processing of OEMRelease failed: %v", err)
-	}
-	if f == nil {
-		t.Fatalf("OEMRelease returned nil file unexpectedly")
-	}
-
-	if _, err := system.WriteFile(f, dir); err != nil {
-		t.Fatalf("Writing of OEMRelease failed: %v", err)
-	}
-
-	fullPath := path.Join(dir, "etc", "oem-release")
-
-	fi, err := os.Stat(fullPath)
-	if err != nil {
-		t.Fatalf("Unable to stat file: %v", err)
-	}
-
-	if fi.Mode() != os.FileMode(0644) {
-		t.Errorf("File has incorrect mode: %v", fi.Mode())
-	}
-
-	contents, err := ioutil.ReadFile(fullPath)
-	if err != nil {
-		t.Fatalf("Unable to read expected file: %v", err)
-	}
-
-	expect := `ID=rackspace
-VERSION_ID=168.0.0
-NAME="Rackspace Cloud Servers"
-HOME_URL="https://www.rackspace.com/cloud/servers/"
-BUG_REPORT_URL="https://github.com/coreos/coreos-overlay"
-`
-	if string(contents) != expect {
-		t.Fatalf("File has incorrect contents")
-	}
-}

initialize/ssh_keys_test.go

@@ -55,31 +55,4 @@ func TestCloudConfigUsersUrlMarshal(t *testing.T) {
 	if keys[2] != expected {
 		t.Fatalf("expected %s, got %s", expected, keys[2])
 	}
-
-}
-func TestCloudConfigUsersSSHImportURL(t *testing.T) {
-
-	contents := `
-users:
-  - name: elroy
-    coreos-ssh-import-url: https://token:x-auth-token@github.enterprise.com/api/v3/polvi/keys
-`
-	cfg, err := NewCloudConfig(contents)
-	if err != nil {
-		t.Fatalf("Encountered unexpected error: %v", err)
-	}
-
-	if len(cfg.Users) != 1 {
-		t.Fatalf("Parsed %d users, expected 1", len(cfg.Users))
-	}
-
-	user := cfg.Users[0]
-
-	if user.Name != "elroy" {
-		t.Errorf("User name is %q, expected 'elroy'", user.Name)
-	}
-
-	if user.SSHImportURL != "https://token:x-auth-token@github.enterprise.com/api/v3/polvi/keys" {
-		t.Errorf("ssh import url is %q, expected 'https://token:x-auth-token@github.enterprise.com/api/v3/polvi/keys'", user.SSHImportURL)
-	}
 }

initialize/update.go

@@ -1,165 +0,0 @@
-package initialize
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/coreos/coreos-cloudinit/system"
-)
-
-const (
-	locksmithUnit    = "locksmithd.service"
-	updateEngineUnit = "update-engine.service"
-)
-
-// updateOption represents a configurable update option, which, if set, will be
-// written into update.conf, replacing any existing value for the option
-type updateOption struct {
-	key    string   // key used to configure this option in cloud-config
-	valid  []string // valid values for the option
-	prefix string   // prefix for the option in the update.conf file
-	value  string   // used to store the new value in update.conf (including prefix)
-	seen   bool     // whether the option has been seen in any existing update.conf
-}
-
-// updateOptions defines the update options understood by cloud-config.
-// The keys represent the string used in cloud-config to configure the option.
-var updateOptions = []*updateOption{
-	&updateOption{
-		key:    "reboot-strategy",
-		prefix: "REBOOT_STRATEGY=",
-		valid:  []string{"best-effort", "etcd-lock", "reboot", "off"},
-	},
-	&updateOption{
-		key:    "group",
-		prefix: "GROUP=",
-	},
-	&updateOption{
-		key:    "server",
-		prefix: "SERVER=",
-	},
-}
-
-// isValid checks whether a supplied value is valid for this option
-func (uo updateOption) isValid(val string) bool {
-	if len(uo.valid) == 0 {
-		return true
-	}
-	for _, v := range uo.valid {
-		if val == v {
-			return true
-		}
-	}
-	return false
-}
-
-type UpdateConfig map[string]string
-
-// File generates an `/etc/coreos/update.conf` file (if any update
-// configuration options are set in cloud-config) by either rewriting the
-// existing file on disk, or starting from `/usr/share/coreos/update.conf`
-func (uc UpdateConfig) File(root string) (*system.File, error) {
-	if len(uc) < 1 {
-		return nil, nil
-	}
-
-	var out string
-
-	// Generate the list of possible substitutions to be performed based on the options that are configured
-	subs := make([]*updateOption, 0)
-	for _, uo := range updateOptions {
-		val, ok := uc[uo.key]
-		if !ok {
-			continue
-		}
-		if !uo.isValid(val) {
-			return nil, errors.New(fmt.Sprintf("invalid value %v for option %v (valid options: %v)", val, uo.key, uo.valid))
-		}
-		uo.value = uo.prefix + val
-		subs = append(subs, uo)
-	}
-
-	etcUpdate := path.Join(root, "etc", "coreos", "update.conf")
-	usrUpdate := path.Join(root, "usr", "share", "coreos", "update.conf")
-
-	conf, err := os.Open(etcUpdate)
-	if os.IsNotExist(err) {
-		conf, err = os.Open(usrUpdate)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	scanner := bufio.NewScanner(conf)
-
-	for scanner.Scan() {
-		line := scanner.Text()
-		for _, s := range subs {
-			if strings.HasPrefix(line, s.prefix) {
-				line = s.value
-				s.seen = true
-				break
-			}
-		}
-		out += line
-		out += "\n"
-		if err := scanner.Err(); err != nil {
-			return nil, err
-		}
-	}
-
-	for _, s := range subs {
-		if !s.seen {
-			out += s.value
-			out += "\n"
-		}
-	}
-
-	return &system.File{
-		Path:               path.Join("etc", "coreos", "update.conf"),
-		RawFilePermissions: "0644",
-		Content:            out,
-	}, nil
-}
-
-// Units generates units for the cloud-init initializer to act on:
-// - a locksmith system.Unit, if "reboot-strategy" was set in cloud-config
-// - an update_engine system.Unit, if "group" was set in cloud-config
-func (uc UpdateConfig) Units(root string) ([]system.Unit, error) {
-	var units []system.Unit
-	if strategy, ok := uc["reboot-strategy"]; ok {
-		ls := &system.Unit{
-			Name:    locksmithUnit,
-			Command: "restart",
-			Mask:    false,
-			Runtime: true,
-		}
-
-		if strategy == "off" {
-			ls.Command = "stop"
-			ls.Mask = true
-		}
-		units = append(units, *ls)
-	}
-
-	rue := false
-	if _, ok := uc["group"]; ok {
-		rue = true
-	}
-	if _, ok := uc["server"]; ok {
-		rue = true
-	}
-	if rue {
-		ue := system.Unit{
-			Name:    updateEngineUnit,
-			Command: "restart",
-		}
-		units = append(units, ue)
-	}
-
-	return units, nil
-}

initialize/update_test.go

@@ -1,232 +0,0 @@
-package initialize
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-	"sort"
-	"strings"
-	"testing"
-
-	"github.com/coreos/coreos-cloudinit/system"
-)
-
-const (
-	base = `SERVER=https://example.com
-GROUP=thegroupc`
-	configured = base + `
-REBOOT_STRATEGY=awesome
-`
-	expected = base + `
-REBOOT_STRATEGY=etcd-lock
-`
-)
-
-func setupFixtures(dir string) {
-	os.MkdirAll(path.Join(dir, "usr", "share", "coreos"), 0755)
-	os.MkdirAll(path.Join(dir, "run", "systemd", "system"), 0755)
-
-	ioutil.WriteFile(path.Join(dir, "usr", "share", "coreos", "update.conf"), []byte(base), 0644)
-}
-
-func TestEmptyUpdateConfig(t *testing.T) {
-	uc := &UpdateConfig{}
-	f, err := uc.File("")
-	if err != nil {
-		t.Error("unexpected error getting file from empty UpdateConfig")
-	}
-	if f != nil {
-		t.Errorf("getting file from empty UpdateConfig should have returned nil, got %v", f)
-	}
-	uu, err := uc.Units("")
-	if err != nil {
-		t.Error("unexpected error getting unit from empty UpdateConfig")
-	}
-	if len(uu) != 0 {
-		t.Errorf("getting unit from empty UpdateConfig should have returned zero units, got %d", len(uu))
-	}
-}
-
-func TestInvalidUpdateOptions(t *testing.T) {
-	uon := &updateOption{
-		key:    "numbers",
-		prefix: "numero_",
-		valid:  []string{"one", "two"},
-	}
-	uoa := &updateOption{
-		key:    "any_will_do",
-		prefix: "any_",
-	}
-
-	if !uon.isValid("one") {
-		t.Error("update option did not accept valid option \"one\"")
-	}
-	if uon.isValid("three") {
-		t.Error("update option accepted invalid option \"three\"")
-	}
-	for _, s := range []string{"one", "asdf", "foobarbaz"} {
-		if !uoa.isValid(s) {
-			t.Errorf("update option with no \"valid\" field did not accept %q", s)
-		}
-	}
-
-	uc := &UpdateConfig{"reboot-strategy": "wizzlewazzle"}
-	f, err := uc.File("")
-	if err == nil {
-		t.Errorf("File did not give an error on invalid UpdateOption")
-	}
-	if f != nil {
-		t.Errorf("File did not return a nil file on invalid UpdateOption")
-	}
-}
-
-func TestServerGroupOptions(t *testing.T) {
-	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
-	if err != nil {
-		t.Fatalf("unable to create tempdir: %v", err)
-	}
-	defer os.RemoveAll(dir)
-	setupFixtures(dir)
-	u := &UpdateConfig{"group": "master", "server": "http://foo.com"}
-
-	want := `
-GROUP=master
-SERVER=http://foo.com`
-
-	f, err := u.File(dir)
-	if err != nil {
-		t.Errorf("unexpected error getting file from UpdateConfig: %v", err)
-	} else if f == nil {
-		t.Error("unexpectedly got empty file from UpdateConfig")
-	} else {
-		out := strings.Split(f.Content, "\n")
-		sort.Strings(out)
-		got := strings.Join(out, "\n")
-		if got != want {
-			t.Errorf("File has incorrect contents, got %v, want %v", got, want)
-		}
-	}
-
-	uu, err := u.Units(dir)
-	if err != nil {
-		t.Errorf("unexpected error getting units from UpdateConfig: %v", err)
-	} else if len(uu) != 1 {
-		t.Errorf("unexpected number of files returned from UpdateConfig: want 1, got %d", len(uu))
-	} else {
-		unit := uu[0]
-		if unit.Name != "update-engine.service" {
-			t.Errorf("bad name for generated unit: want update-engine.service, got %s", unit.Name)
-		}
-		if unit.Command != "restart" {
-			t.Errorf("bad command for generated unit: want restart, got %s", unit.Command)
-		}
-	}
-}
-
-func TestRebootStrategies(t *testing.T) {
-	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
-	if err != nil {
-		t.Fatalf("Unable to create tempdir: %v", err)
-	}
-	defer os.RemoveAll(dir)
-	setupFixtures(dir)
-	strategies := []struct {
-		name     string
-		line     string
-		uMask    bool
-		uCommand string
-	}{
-		{"best-effort", "REBOOT_STRATEGY=best-effort", false, "restart"},
-		{"etcd-lock", "REBOOT_STRATEGY=etcd-lock", false, "restart"},
-		{"reboot", "REBOOT_STRATEGY=reboot", false, "restart"},
-		{"off", "REBOOT_STRATEGY=off", true, "stop"},
-	}
-	for _, s := range strategies {
-		uc := &UpdateConfig{"reboot-strategy": s.name}
-		f, err := uc.File(dir)
-		if err != nil {
-			t.Errorf("update failed to generate file for reboot-strategy=%v: %v", s.name, err)
-		} else if f == nil {
-			t.Errorf("generated empty file for reboot-strategy=%v", s.name)
-		} else {
-			seen := false
-			for _, line := range strings.Split(f.Content, "\n") {
-				if line == s.line {
-					seen = true
-					break
-				}
-			}
-			if !seen {
-				t.Errorf("couldn't find expected line %v for reboot-strategy=%v", s.line, s.name)
-			}
-		}
-		uu, err := uc.Units(dir)
-		if err != nil {
-			t.Errorf("failed to generate unit for reboot-strategy=%v!", s.name)
-		} else if len(uu) != 1 {
-			t.Errorf("unexpected number of units for reboot-strategy=%v: %d", s.name, len(uu))
-		} else {
-			u := uu[0]
-			if u.Name != locksmithUnit {
-				t.Errorf("unit generated for reboot strategy=%v had bad name: %v", s.name, u.Name)
-			}
-			if u.Mask != s.uMask {
-				t.Errorf("unit generated for reboot strategy=%v had bad mask: %t", s.name, u.Mask)
-			}
-			if u.Command != s.uCommand {
-				t.Errorf("unit generated for reboot strategy=%v had bad command: %v", s.name, u.Command)
-			}
-		}
-	}
-
-}
-
-func TestUpdateConfWrittenToDisk(t *testing.T) {
-	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
-	if err != nil {
-		t.Fatalf("Unable to create tempdir: %v", err)
-	}
-	defer os.RemoveAll(dir)
-	setupFixtures(dir)
-
-	for i := 0; i < 2; i++ {
-		if i == 1 {
-			err = ioutil.WriteFile(path.Join(dir, "etc", "coreos", "update.conf"), []byte(configured), 0644)
-			if err != nil {
-				t.Fatal(err)
-			}
-		}
-		uc := &UpdateConfig{"reboot-strategy": "etcd-lock"}
-
-		f, err := uc.File(dir)
-		if err != nil {
-			t.Fatalf("Processing UpdateConfig failed: %v", err)
-		} else if f == nil {
-			t.Fatal("Unexpectedly got nil updateconfig file")
-		}
-
-		if _, err := system.WriteFile(f, dir); err != nil {
-			t.Fatalf("Error writing update config: %v", err)
-		}
-
-		fullPath := path.Join(dir, "etc", "coreos", "update.conf")
-
-		fi, err := os.Stat(fullPath)
-		if err != nil {
-			t.Fatalf("Unable to stat file: %v", err)
-		}
-
-		if fi.Mode() != os.FileMode(0644) {
-			t.Errorf("File has incorrect mode: %v", fi.Mode())
-		}
-
-		contents, err := ioutil.ReadFile(fullPath)
-		if err != nil {
-			t.Fatalf("Unable to read expected file: %v", err)
-		}
-
-		if string(contents) != expected {
-			t.Fatalf("File has incorrect contents, got %v, wanted %v", string(contents), expected)
-		}
-	}
-}

initialize/user_data.go

@@ -17,31 +17,25 @@
 package initialize
 
 import (
-	"fmt"
+	"errors"
 	"log"
-	"strings"
 
-	"github.com/coreos/coreos-cloudinit/system"
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 func ParseUserData(contents string) (interface{}, error) {
 	if len(contents) == 0 {
 		return nil, nil
 	}
-	header := strings.SplitN(contents, "\n", 2)[0]
 
-	// Explicitly trim the header so we can handle user-data from
-	// non-unix operating systems. The rest of the file is parsed
-	// by yaml, which correctly handles CRLF.
-	header = strings.TrimSpace(header)
-
-	if strings.HasPrefix(header, "#!") {
+	switch {
+	case config.IsScript(contents):
 		log.Printf("Parsing user-data as script")
-		return system.Script(contents), nil
-	} else if header == "#cloud-config" {
+		return config.NewScript(contents)
+	case config.IsCloudConfig(contents):
 		log.Printf("Parsing user-data as cloud-config")
-		return NewCloudConfig(contents)
-	} else {
-		return nil, fmt.Errorf("Unrecognized user-data header: %s", header)
+		return config.NewCloudConfig(contents)
+	default:
+		return nil, errors.New("Unrecognized user-data format")
 	}
 }

initialize/user_data_test.go

@@ -18,6 +18,8 @@ package initialize
 
 import (
 	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 func TestParseHeaderCRLF(t *testing.T) {
@@ -53,7 +55,7 @@ func TestParseConfigCRLF(t *testing.T) {
 		t.Fatalf("Failed parsing config: %v", err)
 	}
 
-	cfg := ud.(*CloudConfig)
+	cfg := ud.(*config.CloudConfig)
 
 	if cfg.Hostname != "foo" {
 		t.Error("Failed parsing hostname from config")

initialize/workspace.go

@@ -21,6 +21,7 @@ import (
 	"path"
 	"strings"
 
+	"github.com/coreos/coreos-cloudinit/config"
 	"github.com/coreos/coreos-cloudinit/system"
 )
 
@@ -37,7 +38,7 @@ func PrepWorkspace(workspace string) error {
 	return nil
 }
 
-func PersistScriptInWorkspace(script system.Script, workspace string) (string, error) {
+func PersistScriptInWorkspace(script config.Script, workspace string) (string, error) {
 	scriptsPath := path.Join(workspace, "scripts")
 	tmp, err := ioutil.TempFile(scriptsPath, "")
 	if err != nil {
@@ -47,21 +48,21 @@ func PersistScriptInWorkspace(script system.Script, workspace string) (string, e
 
 	relpath := strings.TrimPrefix(tmp.Name(), workspace)
 
-	file := system.File{
+	file := system.File{File: config.File{
 		Path:               relpath,
 		RawFilePermissions: "0744",
 		Content:            string(script),
-	}
+	}}
 
 	return system.WriteFile(&file, workspace)
 }
 
 func PersistUnitNameInWorkspace(name string, workspace string) error {
-	file := system.File{
+	file := system.File{File: config.File{
 		Path:               path.Join("scripts", "unit-name"),
 		RawFilePermissions: "0644",
 		Content:            name,
-	}
+	}}
 	_, err := system.WriteFile(&file, workspace)
 	return err
 }

system/env.go

@@ -19,6 +19,8 @@ package system
 import (
 	"fmt"
 	"reflect"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 // dropinContents generates the contents for a drop-in unit given the config.
@@ -40,3 +42,16 @@ func dropinContents(e interface{}) string {
 	}
 	return "[Service]\n" + out
 }
+
+func dropinFromConfig(cfg interface{}, name string) []Unit {
+	content := dropinContents(cfg)
+	if content == "" {
+		return nil
+	}
+	return []Unit{{config.Unit{
+		Name:    name,
+		Runtime: true,
+		DropIn:  true,
+		Content: content,
+	}}}
+}

system/env_file_test.go

@@ -23,6 +23,8 @@ import (
 	"strings"
 	"syscall"
 	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 const (
@@ -64,9 +66,9 @@ func TestWriteEnvFileUpdate(t *testing.T) {
 	}
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueUpdate,
 	}
 
@@ -111,9 +113,9 @@ func TestWriteEnvFileUpdateNoNewline(t *testing.T) {
 	}
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueUpdate,
 	}
 
@@ -152,9 +154,9 @@ func TestWriteEnvFileCreate(t *testing.T) {
 	fullPath := path.Join(dir, name)
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueUpdate,
 	}
 
@@ -190,9 +192,9 @@ func TestWriteEnvFileNoop(t *testing.T) {
 	}
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueNoop,
 	}
 
@@ -237,9 +239,9 @@ func TestWriteEnvFileUpdateDos(t *testing.T) {
 	}
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueUpdate,
 	}
 
@@ -286,9 +288,9 @@ func TestWriteEnvFileDos2Unix(t *testing.T) {
 	}
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueNoop,
 	}
 
@@ -334,9 +336,9 @@ func TestWriteEnvFileEmpty(t *testing.T) {
 	}
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueEmpty,
 	}
 
@@ -376,9 +378,9 @@ func TestWriteEnvFileEmptyNoCreate(t *testing.T) {
 	fullPath := path.Join(dir, name)
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueEmpty,
 	}
 
@@ -407,9 +409,9 @@ func TestWriteEnvFilePermFailure(t *testing.T) {
 	ioutil.WriteFile(fullPath, []byte(base), 0000)
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueUpdate,
 	}
 
@@ -429,9 +431,9 @@ func TestWriteEnvFileNameFailure(t *testing.T) {
 	name := "foo.conf"
 
 	ef := EnvFile{
-		File: &File{
+		File: &File{config.File{
 			Path: name,
-		},
+		}},
 		Vars: valueInvalid,
 	}
 

system/etc_hosts.go

@@ -14,7 +14,7 @@
    limitations under the License.
 */
 
-package initialize
+package system
 
 import (
 	"errors"
@@ -22,15 +22,17 @@ import (
 	"os"
 	"path"
 
-	"github.com/coreos/coreos-cloudinit/system"
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 const DefaultIpv4Address = "127.0.0.1"
 
-type EtcHosts string
+type EtcHosts struct {
+	config.EtcHosts
+}
 
 func (eh EtcHosts) generateEtcHosts() (out string, err error) {
-	if eh != "localhost" {
+	if eh.EtcHosts != "localhost" {
 		return "", errors.New("Invalid option to manage_etc_hosts")
 	}
 
@@ -44,8 +46,8 @@ func (eh EtcHosts) generateEtcHosts() (out string, err error) {
 
 }
 
-func (eh EtcHosts) File(root string) (*system.File, error) {
-	if eh == "" {
+func (eh EtcHosts) File() (*File, error) {
+	if eh.EtcHosts == "" {
 		return nil, nil
 	}
 
@@ -54,9 +56,9 @@ func (eh EtcHosts) File(root string) (*system.File, error) {
 		return nil, err
 	}
 
-	return &system.File{
+	return &File{config.File{
 		Path:               path.Join("etc", "hosts"),
 		RawFilePermissions: "0644",
 		Content:            etcHosts,
-	}, nil
+	}}, nil
 }

system/etc_hosts_test.go

@@ -0,0 +1,62 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+func TestEtcdHostsFile(t *testing.T) {
+	hostname, err := os.Hostname()
+	if err != nil {
+		panic(err)
+	}
+
+	for _, tt := range []struct {
+		config config.EtcHosts
+		file   *File
+		err    error
+	}{
+		{
+			"invalid",
+			nil,
+			fmt.Errorf("Invalid option to manage_etc_hosts"),
+		},
+		{
+			"localhost",
+			&File{config.File{
+				Content:            fmt.Sprintf("127.0.0.1 %s\n", hostname),
+				Path:               "etc/hosts",
+				RawFilePermissions: "0644",
+			}},
+			nil,
+		},
+	} {
+		file, err := EtcHosts{tt.config}.File()
+		if !reflect.DeepEqual(tt.err, err) {
+			t.Errorf("bad error (%q): want %q, got %q", tt.config, tt.err, err)
+		}
+		if !reflect.DeepEqual(tt.file, file) {
+			t.Errorf("bad units (%q): want %#v, got %#v", tt.config, tt.file, file)
+		}
+	}
+}

system/etcd.go

@@ -0,0 +1,32 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+// Etcd is a top-level structure which embeds its underlying configuration,
+// config.Etcd, and provides the system-specific Unit().
+type Etcd struct {
+	config.Etcd
+}
+
+// Units creates a Unit file drop-in for etcd, using any configured options.
+func (ee Etcd) Units() []Unit {
+	return dropinFromConfig(ee.Etcd, "etcd.service")
+}

system/etcd_test.go

@@ -0,0 +1,73 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+func TestEtcdUnits(t *testing.T) {
+	for _, tt := range []struct {
+		config config.Etcd
+		units  []Unit
+	}{
+		{
+			config.Etcd{},
+			nil,
+		},
+		{
+			config.Etcd{
+				Discovery:    "http://disco.example.com/foobar",
+				PeerBindAddr: "127.0.0.1:7002",
+			},
+			[]Unit{{config.Unit{
+				Name:    "etcd.service",
+				Runtime: true,
+				DropIn:  true,
+				Content: `[Service]
+Environment="ETCD_DISCOVERY=http://disco.example.com/foobar"
+Environment="ETCD_PEER_BIND_ADDR=127.0.0.1:7002"
+`,
+			}}},
+		},
+		{
+			config.Etcd{
+				Name:         "node001",
+				Discovery:    "http://disco.example.com/foobar",
+				PeerBindAddr: "127.0.0.1:7002",
+			},
+			[]Unit{{config.Unit{
+				Name:    "etcd.service",
+				Runtime: true,
+				DropIn:  true,
+				Content: `[Service]
+Environment="ETCD_DISCOVERY=http://disco.example.com/foobar"
+Environment="ETCD_NAME=node001"
+Environment="ETCD_PEER_BIND_ADDR=127.0.0.1:7002"
+`,
+			}}},
+		},
+	} {
+		units := Etcd{tt.config}.Units()
+		if !reflect.DeepEqual(tt.units, units) {
+			t.Errorf("bad units (%q): want %#v, got %#v", tt.config, tt.units, units)
+		}
+	}
+}

system/file.go

@@ -17,21 +17,20 @@
 package system
 
 import (
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path"
 	"strconv"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
+// File is a top-level structure which embeds its underlying configuration,
+// config.File, and provides the system-specific Permissions().
 type File struct {
-	Encoding           string
-	Content            string
-	Owner              string
-	Path               string
-	RawFilePermissions string `yaml:"permissions"`
+	config.File
 }
 
 func (f *File) Permissions() (os.FileMode, error) {
@@ -39,10 +38,10 @@ func (f *File) Permissions() (os.FileMode, error) {
 		return os.FileMode(0644), nil
 	}
 
-	// Parse string representation of file mode as octal
-	perm, err := strconv.ParseInt(f.RawFilePermissions, 8, 32)
+	// Parse string representation of file mode as integer
+	perm, err := strconv.ParseInt(f.RawFilePermissions, 0, 32)
 	if err != nil {
-		return 0, errors.New("Unable to parse file permissions as octal integer")
+		return 0, fmt.Errorf("Unable to parse file permissions %q as integer", f.RawFilePermissions)
 	}
 	return os.FileMode(perm), nil
 }

system/file_test.go

@@ -21,6 +21,8 @@ import (
 	"os"
 	"path"
 	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 func TestWriteFileUnencodedContent(t *testing.T) {
@@ -33,11 +35,11 @@ func TestWriteFileUnencodedContent(t *testing.T) {
 	fn := "foo"
 	fullPath := path.Join(dir, fn)
 
-	wf := File{
+	wf := File{config.File{
 		Path:               fn,
 		Content:            "bar",
 		RawFilePermissions: "0644",
-	}
+	}}
 
 	path, err := WriteFile(&wf, dir)
 	if err != nil {
@@ -72,17 +74,49 @@ func TestWriteFileInvalidPermission(t *testing.T) {
 	}
 	defer os.RemoveAll(dir)
 
-	wf := File{
+	wf := File{config.File{
 		Path:               path.Join(dir, "tmp", "foo"),
 		Content:            "bar",
 		RawFilePermissions: "pants",
-	}
+	}}
 
 	if _, err := WriteFile(&wf, dir); err == nil {
 		t.Fatalf("Expected error to be raised when writing file with invalid permission")
 	}
 }
 
+func TestDecimalFilePermissions(t *testing.T) {
+	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
+	if err != nil {
+		t.Fatalf("Unable to create tempdir: %v", err)
+	}
+	defer os.RemoveAll(dir)
+
+	fn := "foo"
+	fullPath := path.Join(dir, fn)
+
+	wf := File{config.File{
+		Path:               fn,
+		RawFilePermissions: "484", // Decimal representation of 0744
+	}}
+
+	path, err := WriteFile(&wf, dir)
+	if err != nil {
+		t.Fatalf("Processing of WriteFile failed: %v", err)
+	} else if path != fullPath {
+		t.Fatalf("WriteFile returned bad path: want %s, got %s", fullPath, path)
+	}
+
+	fi, err := os.Stat(fullPath)
+	if err != nil {
+		t.Fatalf("Unable to stat file: %v", err)
+	}
+
+	if fi.Mode() != os.FileMode(0744) {
+		t.Errorf("File has incorrect mode: %v", fi.Mode())
+	}
+}
+
 func TestWriteFilePermissions(t *testing.T) {
 	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
 	if err != nil {
@@ -93,10 +127,10 @@ func TestWriteFilePermissions(t *testing.T) {
 	fn := "foo"
 	fullPath := path.Join(dir, fn)
 
-	wf := File{
+	wf := File{config.File{
 		Path:               fn,
 		RawFilePermissions: "0755",
-	}
+	}}
 
 	path, err := WriteFile(&wf, dir)
 	if err != nil {
@@ -122,11 +156,11 @@ func TestWriteFileEncodedContent(t *testing.T) {
 	}
 	defer os.RemoveAll(dir)
 
-	wf := File{
+	wf := File{config.File{
 		Path:     path.Join(dir, "tmp", "foo"),
 		Content:  "",
 		Encoding: "base64",
-	}
+	}}
 
 	if _, err := WriteFile(&wf, dir); err == nil {
 		t.Fatalf("Expected error to be raised when writing file with encoding")

system/flannel.go

@@ -0,0 +1,17 @@
+package system
+
+import (
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+// flannel is a top-level structure which embeds its underlying configuration,
+// config.Flannel, and provides the system-specific Unit().
+type Flannel struct {
+	config.Flannel
+}
+
+// Units generates a Unit file drop-in for flannel, if any flannel options were
+// configured in cloud-config
+func (fl Flannel) Units() []Unit {
+	return dropinFromConfig(fl.Flannel, "flannel.service")
+}

system/flannel_test.go

@@ -0,0 +1,40 @@
+package system
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+func TestFlannelUnits(t *testing.T) {
+	for _, tt := range []struct {
+		config config.Flannel
+		units  []Unit
+	}{
+		{
+			config.Flannel{},
+			nil,
+		},
+		{
+			config.Flannel{
+				EtcdEndpoint: "http://12.34.56.78:4001",
+				EtcdPrefix:   "/coreos.com/network/tenant1",
+			},
+			[]Unit{{config.Unit{
+				Name: "flannel.service",
+				Content: `[Service]
+Environment="FLANNELD_ETCD_ENDPOINT=http://12.34.56.78:4001"
+Environment="FLANNELD_ETCD_PREFIX=/coreos.com/network/tenant1"
+`,
+				Runtime: true,
+				DropIn:  true,
+			}}},
+		},
+	} {
+		units := Flannel{tt.config}.Units()
+		if !reflect.DeepEqual(units, tt.units) {
+			t.Errorf("bad units (%q): want %v, got %v", tt.config, tt.units, units)
+		}
+	}
+}

system/fleet.go

@@ -0,0 +1,33 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+// Fleet is a top-level structure which embeds its underlying configuration,
+// config.Fleet, and provides the system-specific Unit().
+type Fleet struct {
+	config.Fleet
+}
+
+// Units generates a Unit file drop-in for fleet, if any fleet options were
+// configured in cloud-config
+func (fe Fleet) Units() []Unit {
+	return dropinFromConfig(fe.Fleet, "fleet.service")
+}

system/fleet_test.go

@@ -0,0 +1,54 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+func TestFleetUnits(t *testing.T) {
+	for _, tt := range []struct {
+		config config.Fleet
+		units  []Unit
+	}{
+		{
+			config.Fleet{},
+			nil,
+		},
+		{
+			config.Fleet{
+				PublicIP: "12.34.56.78",
+			},
+			[]Unit{{config.Unit{
+				Name: "fleet.service",
+				Content: `[Service]
+Environment="FLEET_PUBLIC_IP=12.34.56.78"
+`,
+				Runtime: true,
+				DropIn:  true,
+			}}},
+		},
+	} {
+		units := Fleet{tt.config}.Units()
+		if !reflect.DeepEqual(units, tt.units) {
+			t.Errorf("bad units (%q): want %#v, got %#v", tt.config, tt.units, units)
+		}
+	}
+}

system/networkd.go

@@ -23,6 +23,7 @@ import (
 	"os/exec"
 	"strings"
 
+	"github.com/coreos/coreos-cloudinit/config"
 	"github.com/coreos/coreos-cloudinit/network"
 
 	"github.com/coreos/coreos-cloudinit/Godeps/_workspace/src/github.com/dotcloud/docker/pkg/netlink"
@@ -117,11 +118,11 @@ func WriteNetworkdConfigs(interfaces []network.InterfaceGenerator) error {
 	return nil
 }
 
-func writeConfig(filename string, config string) error {
-	if config == "" {
+func writeConfig(filename string, content string) error {
+	if content == "" {
 		return nil
 	}
 	log.Printf("Writing networkd unit %q\n", filename)
-	_, err := WriteFile(&File{Content: config, Path: filename}, runtimeNetworkPath)
+	_, err := WriteFile(&File{config.File{Content: content, Path: filename}}, runtimeNetworkPath)
 	return err
 }

system/oem.go

@@ -0,0 +1,48 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"fmt"
+	"path"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+// OEM is a top-level structure which embeds its underlying configuration,
+// config.OEM, and provides the system-specific File().
+type OEM struct {
+	config.OEM
+}
+
+func (oem OEM) File() (*File, error) {
+	if oem.ID == "" {
+		return nil, nil
+	}
+
+	content := fmt.Sprintf("ID=%s\n", oem.ID)
+	content += fmt.Sprintf("VERSION_ID=%s\n", oem.VersionID)
+	content += fmt.Sprintf("NAME=%q\n", oem.Name)
+	content += fmt.Sprintf("HOME_URL=%q\n", oem.HomeURL)
+	content += fmt.Sprintf("BUG_REPORT_URL=%q\n", oem.BugReportURL)
+
+	return &File{config.File{
+		Path:               path.Join("etc", "oem-release"),
+		RawFilePermissions: "0644",
+		Content:            content,
+	}}, nil
+}

system/oem_test.go

@@ -0,0 +1,63 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+func TestOEMFile(t *testing.T) {
+	for _, tt := range []struct {
+		config config.OEM
+		file   *File
+	}{
+		{
+			config.OEM{},
+			nil,
+		},
+		{
+			config.OEM{
+				ID:           "rackspace",
+				Name:         "Rackspace Cloud Servers",
+				VersionID:    "168.0.0",
+				HomeURL:      "https://www.rackspace.com/cloud/servers/",
+				BugReportURL: "https://github.com/coreos/coreos-overlay",
+			},
+			&File{config.File{
+				Path:               "etc/oem-release",
+				RawFilePermissions: "0644",
+				Content: `ID=rackspace
+VERSION_ID=168.0.0
+NAME="Rackspace Cloud Servers"
+HOME_URL="https://www.rackspace.com/cloud/servers/"
+BUG_REPORT_URL="https://github.com/coreos/coreos-overlay"
+`,
+			}},
+		},
+	} {
+		file, err := OEM{tt.config}.File()
+		if err != nil {
+			t.Errorf("bad error (%q): want %v, got %q", tt.config, nil, err)
+		}
+		if !reflect.DeepEqual(tt.file, file) {
+			t.Errorf("bad file (%q): want %#v, got %#v", tt.config, tt.file, file)
+		}
+	}
+}

system/systemd.go

@@ -27,6 +27,7 @@ import (
 	"strings"
 
 	"github.com/coreos/coreos-cloudinit/Godeps/_workspace/src/github.com/coreos/go-systemd/dbus"
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 func NewUnitManager(root string) UnitManager {
@@ -51,11 +52,11 @@ func (s *systemd) PlaceUnit(u *Unit, dst string) error {
 		}
 	}
 
-	file := File{
+	file := File{config.File{
 		Path:               filepath.Base(dst),
 		Content:            u.Content,
 		RawFilePermissions: "0644",
-	}
+	}}
 
 	_, err := WriteFile(&file, dir)
 	if err != nil {

system/systemd_test.go

@@ -21,10 +21,12 @@ import (
 	"os"
 	"path"
 	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 func TestPlaceNetworkUnit(t *testing.T) {
-	u := Unit{
+	u := Unit{config.Unit{
 		Name:    "50-eth0.network",
 		Runtime: true,
 		Content: `[Match]
@@ -33,7 +35,7 @@ Name=eth47
 [Network]
 Address=10.209.171.177/19
 `,
-	}
+	}}
 
 	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
 	if err != nil {
@@ -82,10 +84,10 @@ func TestUnitDestination(t *testing.T) {
 	dir := "/some/dir"
 	name := "foobar.service"
 
-	u := Unit{
+	u := Unit{config.Unit{
 		Name:   name,
 		DropIn: false,
-	}
+	}}
 
 	dst := u.Destination(dir)
 	expectDst := path.Join(dir, "etc", "systemd", "system", "foobar.service")
@@ -103,14 +105,14 @@ func TestUnitDestination(t *testing.T) {
 }
 
 func TestPlaceMountUnit(t *testing.T) {
-	u := Unit{
+	u := Unit{config.Unit{
 		Name:    "media-state.mount",
 		Runtime: false,
 		Content: `[Mount]
 What=/dev/sdb1
 Where=/media/state
 `,
-	}
+	}}
 
 	dir, err := ioutil.TempDir(os.TempDir(), "coreos-cloudinit-")
 	if err != nil {
@@ -178,7 +180,7 @@ func TestMaskUnit(t *testing.T) {
 	sd := &systemd{dir}
 
 	// Ensure mask works with units that do not currently exist
-	uf := &Unit{Name: "foo.service"}
+	uf := &Unit{config.Unit{Name: "foo.service"}}
 	if err := sd.MaskUnit(uf); err != nil {
 		t.Fatalf("Unable to mask new unit: %v", err)
 	}
@@ -192,7 +194,7 @@ func TestMaskUnit(t *testing.T) {
 	}
 
 	// Ensure mask works with unit files that already exist
-	ub := &Unit{Name: "bar.service"}
+	ub := &Unit{config.Unit{Name: "bar.service"}}
 	barPath := path.Join(dir, "etc", "systemd", "system", "bar.service")
 	if _, err := os.Create(barPath); err != nil {
 		t.Fatalf("Error creating new unit file: %v", err)
@@ -218,12 +220,12 @@ func TestUnmaskUnit(t *testing.T) {
 
 	sd := &systemd{dir}
 
-	nilUnit := &Unit{Name: "null.service"}
+	nilUnit := &Unit{config.Unit{Name: "null.service"}}
 	if err := sd.UnmaskUnit(nilUnit); err != nil {
 		t.Errorf("unexpected error from unmasking nonexistent unit: %v", err)
 	}
 
-	uf := &Unit{Name: "foo.service", Content: "[Service]\nExecStart=/bin/true"}
+	uf := &Unit{config.Unit{Name: "foo.service", Content: "[Service]\nExecStart=/bin/true"}}
 	dst := uf.Destination(dir)
 	if err := os.MkdirAll(path.Dir(dst), os.FileMode(0755)); err != nil {
 		t.Fatalf("Unable to create unit directory: %v", err)
@@ -243,7 +245,7 @@ func TestUnmaskUnit(t *testing.T) {
 		t.Errorf("unmask of non-empty unit mutated unit contents unexpectedly")
 	}
 
-	ub := &Unit{Name: "bar.service"}
+	ub := &Unit{config.Unit{Name: "bar.service"}}
 	dst = ub.Destination(dir)
 	if err := os.Symlink("/dev/null", dst); err != nil {
 		t.Fatalf("Unable to create masked unit: %v", err)

system/unit.go

@@ -19,8 +19,8 @@ package system
 import (
 	"fmt"
 	"path"
-	"path/filepath"
-	"strings"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
 // Name for drop-in service configuration files created by cloudconfig
@@ -35,37 +35,12 @@ type UnitManager interface {
 	UnmaskUnit(unit *Unit) error
 }
 
+// Unit is a top-level structure which embeds its underlying configuration,
+// config.Unit, and provides the system-specific Destination().
 type Unit struct {
-	Name    string
-	Mask    bool
-	Enable  bool
-	Runtime bool
-	Content string
-	Command string
-
-	// For drop-in units, a cloudinit.conf is generated.
-	// This is currently unbound in YAML (and hence unsettable in cloud-config files)
-	// until the correct behaviour for multiple drop-in units is determined.
-	DropIn bool `yaml:"-"`
+	config.Unit
 }
 
-func (u *Unit) Type() string {
-	ext := filepath.Ext(u.Name)
-	return strings.TrimLeft(ext, ".")
-}
-
-func (u *Unit) Group() (group string) {
-	t := u.Type()
-	if t == "network" || t == "netdev" || t == "link" {
-		group = "network"
-	} else {
-		group = "system"
-	}
-	return
-}
-
-type Script []byte
-
 // Destination builds the appropriate absolute file path for
 // the Unit. The root argument indicates the effective base
 // directory of the system (similar to a chroot).

system/update.go

@@ -0,0 +1,153 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+const (
+	locksmithUnit    = "locksmithd.service"
+	updateEngineUnit = "update-engine.service"
+)
+
+// Update is a top-level structure which contains its underlying configuration,
+// config.Update, a function for reading the configuration (the default
+// implementation reading from the filesystem), and provides the system-specific
+// File() and Unit().
+type Update struct {
+	ReadConfig func() (io.Reader, error)
+	config.Update
+}
+
+func DefaultReadConfig() (io.Reader, error) {
+	etcUpdate := path.Join("/etc", "coreos", "update.conf")
+	usrUpdate := path.Join("/usr", "share", "coreos", "update.conf")
+
+	f, err := os.Open(etcUpdate)
+	if os.IsNotExist(err) {
+		f, err = os.Open(usrUpdate)
+	}
+	return f, err
+}
+
+// File generates an `/etc/coreos/update.conf` file (if any update
+// configuration options are set in cloud-config) by either rewriting the
+// existing file on disk, or starting from `/usr/share/coreos/update.conf`
+func (uc Update) File() (*File, error) {
+	if config.IsZero(uc.Update) {
+		return nil, nil
+	}
+	if err := config.AssertStructValid(uc.Update); err != nil {
+		return nil, err
+	}
+
+	// Generate the list of possible substitutions to be performed based on the options that are configured
+	subs := map[string]string{}
+	uct := reflect.TypeOf(uc.Update)
+	ucv := reflect.ValueOf(uc.Update)
+	for i := 0; i < uct.NumField(); i++ {
+		val := ucv.Field(i).String()
+		if val == "" {
+			continue
+		}
+		env := uct.Field(i).Tag.Get("env")
+		subs[env] = fmt.Sprintf("%s=%s", env, val)
+	}
+
+	conf, err := uc.ReadConfig()
+	if err != nil {
+		return nil, err
+	}
+	scanner := bufio.NewScanner(conf)
+
+	var out string
+	for scanner.Scan() {
+		line := scanner.Text()
+		for env, value := range subs {
+			if strings.HasPrefix(line, env) {
+				line = value
+				delete(subs, env)
+				break
+			}
+		}
+		out += line
+		out += "\n"
+		if err := scanner.Err(); err != nil {
+			return nil, err
+		}
+	}
+
+	for _, key := range sortedKeys(subs) {
+		out += subs[key]
+		out += "\n"
+	}
+
+	return &File{config.File{
+		Path:               path.Join("etc", "coreos", "update.conf"),
+		RawFilePermissions: "0644",
+		Content:            out,
+	}}, nil
+}
+
+// Units generates units for the cloud-init initializer to act on:
+// - a locksmith Unit, if "reboot-strategy" was set in cloud-config
+// - an update_engine Unit, if "group" or "server" was set in cloud-config
+func (uc Update) Units() []Unit {
+	var units []Unit
+	if uc.Update.RebootStrategy != "" {
+		ls := &Unit{config.Unit{
+			Name:    locksmithUnit,
+			Command: "restart",
+			Mask:    false,
+			Runtime: true,
+		}}
+
+		if uc.Update.RebootStrategy == "false" {
+			ls.Command = "stop"
+			ls.Mask = true
+		}
+		units = append(units, *ls)
+	}
+
+	if uc.Update.Group != "" || uc.Update.Server != "" {
+		ue := Unit{config.Unit{
+			Name:    updateEngineUnit,
+			Command: "restart",
+		}}
+		units = append(units, ue)
+	}
+
+	return units
+}
+
+func sortedKeys(m map[string]string) (keys []string) {
+	for key := range m {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return
+}

system/update_test.go

@@ -0,0 +1,163 @@
+/*
+   Copyright 2014 CoreOS, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package system
+
+import (
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/coreos/coreos-cloudinit/config"
+)
+
+func testReadConfig(config string) func() (io.Reader, error) {
+	return func() (io.Reader, error) {
+		return strings.NewReader(config), nil
+	}
+}
+
+func TestUpdateUnits(t *testing.T) {
+	for _, tt := range []struct {
+		config config.Update
+		units  []Unit
+		err    error
+	}{
+		{
+			config: config.Update{},
+		},
+		{
+			config: config.Update{Group: "master", Server: "http://foo.com"},
+			units: []Unit{{config.Unit{
+				Name:    "update-engine.service",
+				Command: "restart",
+			}}},
+		},
+		{
+			config: config.Update{RebootStrategy: "best-effort"},
+			units: []Unit{{config.Unit{
+				Name:    "locksmithd.service",
+				Command: "restart",
+				Runtime: true,
+			}}},
+		},
+		{
+			config: config.Update{RebootStrategy: "etcd-lock"},
+			units: []Unit{{config.Unit{
+				Name:    "locksmithd.service",
+				Command: "restart",
+				Runtime: true,
+			}}},
+		},
+		{
+			config: config.Update{RebootStrategy: "reboot"},
+			units: []Unit{{config.Unit{
+				Name:    "locksmithd.service",
+				Command: "restart",
+				Runtime: true,
+			}}},
+		},
+		{
+			config: config.Update{RebootStrategy: "false"},
+			units: []Unit{{config.Unit{
+				Name:    "locksmithd.service",
+				Command: "stop",
+				Runtime: true,
+				Mask:    true,
+			}}},
+		},
+	} {
+		units := Update{Update: tt.config, ReadConfig: testReadConfig("")}.Units()
+		if !reflect.DeepEqual(tt.units, units) {
+			t.Errorf("bad units (%q): want %#v, got %#v", tt.config, tt.units, units)
+		}
+	}
+}
+
+func TestUpdateFile(t *testing.T) {
+	for _, tt := range []struct {
+		config config.Update
+		orig   string
+		file   *File
+		err    error
+	}{
+		{
+			config: config.Update{},
+		},
+		{
+			config: config.Update{RebootStrategy: "wizzlewazzle"},
+			err:    &config.ErrorValid{Value: "wizzlewazzle", Field: "RebootStrategy", Valid: []string{"best-effort", "etcd-lock", "reboot", "false"}},
+		},
+		{
+			config: config.Update{Group: "master", Server: "http://foo.com"},
+			file: &File{config.File{
+				Content:            "GROUP=master\nSERVER=http://foo.com\n",
+				Path:               "etc/coreos/update.conf",
+				RawFilePermissions: "0644",
+			}},
+		},
+		{
+			config: config.Update{RebootStrategy: "best-effort"},
+			file: &File{config.File{
+				Content:            "REBOOT_STRATEGY=best-effort\n",
+				Path:               "etc/coreos/update.conf",
+				RawFilePermissions: "0644",
+			}},
+		},
+		{
+			config: config.Update{RebootStrategy: "etcd-lock"},
+			file: &File{config.File{
+				Content:            "REBOOT_STRATEGY=etcd-lock\n",
+				Path:               "etc/coreos/update.conf",
+				RawFilePermissions: "0644",
+			}},
+		},
+		{
+			config: config.Update{RebootStrategy: "reboot"},
+			file: &File{config.File{
+				Content:            "REBOOT_STRATEGY=reboot\n",
+				Path:               "etc/coreos/update.conf",
+				RawFilePermissions: "0644",
+			}},
+		},
+		{
+			config: config.Update{RebootStrategy: "false"},
+			file: &File{config.File{
+				Content:            "REBOOT_STRATEGY=false\n",
+				Path:               "etc/coreos/update.conf",
+				RawFilePermissions: "0644",
+			}},
+		},
+		{
+			config: config.Update{RebootStrategy: "etcd-lock"},
+			orig:   "SERVER=https://example.com\nGROUP=thegroupc\nREBOOT_STRATEGY=awesome",
+			file: &File{config.File{
+				Content:            "SERVER=https://example.com\nGROUP=thegroupc\nREBOOT_STRATEGY=etcd-lock\n",
+				Path:               "etc/coreos/update.conf",
+				RawFilePermissions: "0644",
+			}},
+		},
+	} {
+		file, err := Update{Update: tt.config, ReadConfig: testReadConfig(tt.orig)}.File()
+		if !reflect.DeepEqual(tt.err, err) {
+			t.Errorf("bad error (%q): want %q, got %q", tt.config, tt.err, err)
+		}
+		if !reflect.DeepEqual(tt.file, file) {
+			t.Errorf("bad units (%q): want %#v, got %#v", tt.config, tt.file, file)
+		}
+	}
+}

system/user.go

@@ -22,30 +22,16 @@ import (
 	"os/exec"
 	"os/user"
 	"strings"
+
+	"github.com/coreos/coreos-cloudinit/config"
 )
 
-type User struct {
-	Name                string   `yaml:"name"`
-	PasswordHash        string   `yaml:"passwd"`
-	SSHAuthorizedKeys   []string `yaml:"ssh-authorized-keys"`
-	SSHImportGithubUser string   `yaml:"coreos-ssh-import-github"`
-	SSHImportURL        string   `yaml:"coreos-ssh-import-url"`
-	GECOS               string   `yaml:"gecos"`
-	Homedir             string   `yaml:"homedir"`
-	NoCreateHome        bool     `yaml:"no-create-home"`
-	PrimaryGroup        string   `yaml:"primary-group"`
-	Groups              []string `yaml:"groups"`
-	NoUserGroup         bool     `yaml:"no-user-group"`
-	System              bool     `yaml:"system"`
-	NoLogInit           bool     `yaml:"no-log-init"`
-}
-
-func UserExists(u *User) bool {
+func UserExists(u *config.User) bool {
 	_, err := user.Lookup(u.Name)
 	return err == nil
 }
 
-func CreateUser(u *User) error {
+func CreateUser(u *config.User) error {
 	args := []string{}
 
 	if u.PasswordHash != "" {

test

@@ -14,6 +14,8 @@ COVER=${COVER:-"-cover"}
 source ./build
 
 declare -a TESTPKGS=(
+	config
+	config/validate
 	datasource
 	datasource/configdrive
 	datasource/file