Implement contexts

Author: thcyron

README.md

@@ -16,7 +16,8 @@ We do not accept pull requests at the moment.
 
 Configure the `hcloud` program to use your token:
 
-    hcloud configure
+    hcloud context create my-project
+    hcloud context activate my-project
 
 See `hcloud help` for a list of commands.
 

cli.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"context"
+	"errors"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -12,11 +13,14 @@ import (
 	"golang.org/x/crypto/ssh/terminal"
 )
 
+var ErrConfigPathUnknown = errors.New("config file path unknown")
+
 type CLI struct {
-	Token    string
-	Endpoint string
-	Context  context.Context
-	Config   *Config
+	Token      string
+	Endpoint   string
+	Context    context.Context
+	Config     *Config
+	ConfigPath string
 
 	RootCommand *cobra.Command
 
@@ -25,7 +29,12 @@ type CLI struct {
 
 func NewCLI() *CLI {
 	cli := &CLI{
-		Context: context.Background(),
+		Context:    context.Background(),
+		Config:     &Config{},
+		ConfigPath: DefaultConfigPath,
+	}
+	if s := os.Getenv("HCLOUD_CONFIG"); s != "" {
+		cli.ConfigPath = s
 	}
 	cli.RootCommand = NewRootCommand(cli)
 	return cli
@@ -40,8 +49,12 @@ func (c *CLI) ReadEnv() {
 	}
 }
 
-func (c *CLI) ReadConfig(path string) error {
-	data, err := ioutil.ReadFile(path)
+func (c *CLI) ReadConfig() error {
+	if c.ConfigPath == "" {
+		return ErrConfigPathUnknown
+	}
+
+	data, err := ioutil.ReadFile(c.ConfigPath)
 	if err != nil {
 		return err
 	}
@@ -50,10 +63,13 @@ func (c *CLI) ReadConfig(path string) error {
 	if err != nil {
 		return err
 	}
+	if config == nil {
+		return nil
+	}
 	c.Config = config
 
-	if config.Token != "" {
-		c.Token = config.Token
+	if config.ActiveContext != nil {
+		c.Token = config.ActiveContext.Token
 	}
 	if config.Endpoint != "" {
 		c.Endpoint = config.Endpoint
@@ -62,7 +78,10 @@ func (c *CLI) ReadConfig(path string) error {
 	return nil
 }
 
-func (c *CLI) WriteConfig(path string) error {
+func (c *CLI) WriteConfig() error {
+	if c.ConfigPath == "" {
+		return ErrConfigPathUnknown
+	}
 	if c.Config == nil {
 		return nil
 	}
@@ -71,10 +90,10 @@ func (c *CLI) WriteConfig(path string) error {
 	if err != nil {
 		return err
 	}
-	if err := os.MkdirAll(filepath.Dir(path), 0777); err != nil {
+	if err := os.MkdirAll(filepath.Dir(c.ConfigPath), 0777); err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(path, data, 0600); err != nil {
+	if err := ioutil.WriteFile(c.ConfigPath, data, 0600); err != nil {
 		return err
 	}
 	return nil

cmd/hcloud/main.go

@@ -16,17 +16,17 @@ func init() {
 func main() {
 	c := cli.NewCLI()
 
-	if cli.DefaultConfigPath != "" {
-		_, err := os.Stat(cli.DefaultConfigPath)
+	if c.ConfigPath != "" {
+		_, err := os.Stat(c.ConfigPath)
 		switch {
 		case err == nil:
-			if err := c.ReadConfig(cli.DefaultConfigPath); err != nil {
-				log.Fatalf("unable to read config file %q: %s\n", cli.DefaultConfigPath, err)
+			if err := c.ReadConfig(); err != nil {
+				log.Fatalf("unable to read config file %q: %s\n", c.ConfigPath, err)
 			}
 		case os.IsNotExist(err):
 			break
 		default:
-			log.Fatalf("unable to read config file %q: %s\n", cli.DefaultConfigPath, err)
+			log.Fatalf("unable to read config file %q: %s\n", c.ConfigPath, err)
 		}
 	}
 

config.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 
@@ -16,13 +17,42 @@ func init() {
 }
 
 type Config struct {
-	Token    string
-	Endpoint string
+	Endpoint      string
+	ActiveContext *ConfigContext
+	Contexts      []*ConfigContext
+}
+
+type ConfigContext struct {
+	Name  string
+	Token string
+}
+
+func (config *Config) ContextByName(name string) *ConfigContext {
+	for _, c := range config.Contexts {
+		if c.Name == name {
+			return c
+		}
+	}
+	return nil
+}
+
+func (config *Config) RemoveContext(context *ConfigContext) {
+	for i, c := range config.Contexts {
+		if c == context {
+			config.Contexts = append(config.Contexts[:i], config.Contexts[i+1:]...)
+			return
+		}
+	}
 }
 
 type RawConfig struct {
-	Token    string `toml:"token,omitempty"`
-	Endpoint string `toml:"endpoint,omitempty"`
+	ActiveContext string             `toml:"active_context,omitempty"`
+	Contexts      []RawConfigContext `toml:"contexts"`
+}
+
+type RawConfigContext struct {
+	Name  string `toml:"name"`
+	Token string `toml:"token"`
 }
 
 func MarshalConfig(c *Config) ([]byte, error) {
@@ -31,8 +61,15 @@ func MarshalConfig(c *Config) ([]byte, error) {
 	}
 
 	var raw RawConfig
-	raw.Token = c.Token
-	raw.Endpoint = c.Endpoint
+	if c.ActiveContext != nil {
+		raw.ActiveContext = c.ActiveContext.Name
+	}
+	for _, context := range c.Contexts {
+		raw.Contexts = append(raw.Contexts, RawConfigContext{
+			Name:  context.Name,
+			Token: context.Token,
+		})
+	}
 	return toml.Marshal(raw)
 }
 
@@ -41,8 +78,23 @@ func UnmarshalConfig(data []byte) (*Config, error) {
 	if err := toml.Unmarshal(data, &raw); err != nil {
 		return nil, err
 	}
-	return &Config{
-		Token:    raw.Token,
-		Endpoint: raw.Endpoint,
-	}, nil
+	config := &Config{}
+	for _, rawContext := range raw.Contexts {
+		config.Contexts = append(config.Contexts, &ConfigContext{
+			Name:  rawContext.Name,
+			Token: rawContext.Token,
+		})
+	}
+	if raw.ActiveContext != "" {
+		for _, c := range config.Contexts {
+			if c.Name == raw.ActiveContext {
+				config.ActiveContext = c
+				break
+			}
+		}
+		if config.ActiveContext == nil {
+			return config, fmt.Errorf("active context %q not found", raw.ActiveContext)
+		}
+	}
+	return config, nil
 }

configure.go

@@ -0,0 +1,26 @@
+package cli
+
+import "github.com/spf13/cobra"
+
+func newContextCommand(cli *CLI) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:                   "context [FLAGS]",
+		Short:                 "Manage contexts",
+		Args:                  cobra.NoArgs,
+		TraverseChildren:      true,
+		DisableFlagsInUseLine: true,
+		RunE: cli.wrap(runContext),
+	}
+	cmd.AddCommand(
+		newContextCreateCommand(cli),
+		newContextActiveCommand(cli),
+		newContextActivateCommand(cli),
+		newContextDeleteCommand(cli),
+		newContextListCommand(cli),
+	)
+	return cmd
+}
+
+func runContext(cli *CLI, cmd *cobra.Command, args []string) error {
+	return cmd.Usage()
+}

context.go

@@ -0,0 +1,29 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+func newContextActivateCommand(cli *CLI) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:                   "activate [FLAGS] NAME",
+		Short:                 "Activate a context",
+		Args:                  cobra.ExactArgs(1),
+		TraverseChildren:      true,
+		DisableFlagsInUseLine: true,
+		RunE: cli.wrap(runContextActivate),
+	}
+	return cmd
+}
+
+func runContextActivate(cli *CLI, cmd *cobra.Command, args []string) error {
+	name := args[0]
+	context := cli.Config.ContextByName(name)
+	if context == nil {
+		return fmt.Errorf("context not found: %v", name)
+	}
+	cli.Config.ActiveContext = context
+	return cli.WriteConfig()
+}

context_activate.go

@@ -0,0 +1,26 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+func newContextActiveCommand(cli *CLI) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:                   "active [FLAGS]",
+		Short:                 "Show active context",
+		Args:                  cobra.NoArgs,
+		TraverseChildren:      true,
+		DisableFlagsInUseLine: true,
+		RunE: cli.wrap(runContextActive),
+	}
+	return cmd
+}
+
+func runContextActive(cli *CLI, cmd *cobra.Command, args []string) error {
+	if cli.Config.ActiveContext != nil {
+		fmt.Println(cli.Config.ActiveContext.Name)
+	}
+	return nil
+}