Rename addon to service

cmd/control/cli.go

@@ -25,11 +25,11 @@ func Main() {
 			Subcommands: configSubcommands(),
 		},
 		{
-			Name:        "addon",
-			ShortName:   "a",
-			Usage:       "addon settings",
+			Name:        "service",
+			ShortName:   "s",
+			Usage:       "service settings",
 			HideHelp:    true,
-			Subcommands: addonSubCommands(),
+			Subcommands: serviceSubCommands(),
 		},
 		//{
 		//	Name:      "reload",

cmd/control/service.go

@@ -9,21 +9,21 @@ import (
 	"github.com/rancherio/os/util"
 )
 
-func addonSubCommands() []cli.Command {
+func serviceSubCommands() []cli.Command {
 	return []cli.Command{
 		{
 			Name:   "enable",
-			Usage:  "turn on an addon",
+			Usage:  "turn on an service",
 			Action: enable,
 		},
 		{
 			Name:   "disable",
-			Usage:  "turn off an addon",
+			Usage:  "turn off an service",
 			Action: disable,
 		},
 		{
 			Name:   "list",
-			Usage:  "list addons and state",
+			Usage:  "list services and state",
 			Action: list,
 		},
 	}
@@ -36,22 +36,22 @@ func disable(c *cli.Context) {
 		log.Fatal(err)
 	}
 
-	for _, addon := range c.Args() {
+	for _, service := range c.Args() {
 		filtered := make([]string, 0, len(c.Args()))
-		for _, existing := range cfg.EnabledAddons {
-			if existing != addon {
+		for _, existing := range cfg.EnabledServices {
+			if existing != service {
 				filtered = append(filtered, existing)
 			}
 		}
 
 		if len(filtered) != len(c.Args()) {
-			cfg.EnabledAddons = filtered
+			cfg.EnabledServices = filtered
 			changed = true
 		}
 	}
 
 	if changed {
-		if err = cfg.Set("enabled_addons", cfg.EnabledAddons); err != nil {
+		if err = cfg.Set("enabled_services", cfg.EnabledServices); err != nil {
 			log.Fatal(err)
 		}
 	}
@@ -64,15 +64,15 @@ func enable(c *cli.Context) {
 		log.Fatal(err)
 	}
 
-	for _, addon := range c.Args() {
-		if _, ok := cfg.Addons[addon]; ok && !util.Contains(cfg.EnabledAddons, addon) {
-			cfg.EnabledAddons = append(cfg.EnabledAddons, addon)
+	for _, service := range c.Args() {
+		if _, ok := cfg.Services[service]; ok && !util.Contains(cfg.EnabledServices, service) {
+			cfg.EnabledServices = append(cfg.EnabledServices, service)
 			changed = true
 		}
 	}
 
 	if changed {
-		if err = cfg.Set("enabled_addons", cfg.EnabledAddons); err != nil {
+		if err = cfg.Set("enabled_services", cfg.EnabledServices); err != nil {
 			log.Fatal(err)
 		}
 	}
@@ -86,15 +86,15 @@ func list(c *cli.Context) {
 
 	enabled := map[string]bool{}
 
-	for _, addon := range cfg.EnabledAddons {
-		enabled[addon] = true
+	for _, service := range cfg.EnabledServices {
+		enabled[service] = true
 	}
 
-	for addon, _ := range cfg.Addons {
-		if _, ok := enabled[addon]; ok {
-			fmt.Printf("%s enabled\n", addon)
+	for service, _ := range cfg.Services {
+		if _, ok := enabled[service]; ok {
+			fmt.Printf("%s enabled\n", service)
 		} else {
-			fmt.Printf("%s disabled\n", addon)
+			fmt.Printf("%s disabled\n", service)
 		}
 	}
 }

config/default.go

@@ -305,8 +305,8 @@ func NewConfig() *Config {
 				Net:     "host",
 			},
 		},
-		EnabledAddons: []string{},
-		Addons: map[string]Config{
+		EnabledServices: []string{},
+		Services: map[string]Config{
 			"ubuntu-console": {
 				SystemContainers: map[string]*project.ServiceConfig{
 					"console": {

config/types.go

@@ -42,14 +42,14 @@ type ContainerConfig struct {
 }
 
 type Config struct {
-	Addons              map[string]Config                 `yaml:"addons,omitempty"`
+	Services            map[string]Config                 `yaml:"services,omitempty"`
 	BootstrapContainers map[string]*project.ServiceConfig `yaml:"bootstrap_containers,omitempty"`
 	BootstrapDocker     DockerConfig                      `yaml:"bootstrap_docker,omitempty"`
 	CloudInit           CloudInit                         `yaml:"cloud_init,omitempty"`
 	Console             ConsoleConfig                     `yaml:"console,omitempty"`
 	Debug               bool                              `yaml:"debug,omitempty"`
 	Disable             []string                          `yaml:"disable,omitempty"`
-	EnabledAddons       []string                          `yaml:"enabled_addons,omitempty"`
+	EnabledServices     []string                          `yaml:"enabled_services,omitempty"`
 	Modules             []string                          `yaml:"modules,omitempty"`
 	Network             NetworkConfig                     `yaml:"network,omitempty"`
 	Ssh                 SshConfig                         `yaml:"ssh,omitempty"`

init/sysinit.go

@@ -125,32 +125,32 @@ func runServices(name string, cfg *config.Config, configs map[string]*project.Se
 			return err
 		}
 
-		for _, addon := range cfg.EnabledAddons {
-			if _, ok := enabled[addon]; ok {
+		for _, service := range cfg.EnabledServices {
+			if _, ok := enabled[service]; ok {
 				continue
 			}
 
-			if config, ok := cfg.Addons[addon]; ok {
+			if config, ok := cfg.Services[service]; ok {
 				for name, s := range config.SystemContainers {
 					if err := project.AddConfig(name, s); err != nil {
 						log.Errorf("Failed to load %s : %v", name, err)
 					}
 				}
 			} else {
-				bytes, err := util.LoadResource(addon)
+				bytes, err := util.LoadResource(service)
 				if err != nil {
-					log.Errorf("Failed to load %s : %v", addon, err)
+					log.Errorf("Failed to load %s : %v", service, err)
 					continue
 				}
 
 				err = project.Load(bytes)
 				if err != nil {
-					log.Errorf("Failed to load %s : %v", addon, err)
+					log.Errorf("Failed to load %s : %v", service, err)
 					continue
 				}
 			}
 
-			enabled[addon] = true
+			enabled[service] = true
 		}
 
 		return nil