Refactor provision layer

config/config.go

@@ -7,45 +7,65 @@ import (
 	"os"
 	"os/user"
 	"path"
-	"sync"
 
+	dockerInfra "github.com/metrue/fx/infra/docker"
+	"github.com/metrue/fx/types"
 	"github.com/metrue/fx/utils"
 	"github.com/mitchellh/go-homedir"
-	"gopkg.in/yaml.v2"
 )
 
-// Items data of config file
-type Items struct {
-	Clouds       map[string]map[string]string `json:"clouds"`
-	CurrentCloud string                       `json:"current_cloud"`
+// Configer manage fx config
+type Configer interface {
+	GetCurrentCloud() ([]byte, error)
+	GetCurrentCloudType() (string, error)
+	GetKubeConfig() (string, error)
+	UseCloud(name string) error
+	View() ([]byte, error)
+	AddCloud(name string, meta []byte) error
 }
 
 // Config config of fx
 type Config struct {
-	mux        sync.Mutex
 	configFile string
-	Items
+	container  *Container
 }
 
+const defaultFxConfig = "~/.fx/config.yml"
+
 // LoadDefault load default config
 func LoadDefault() (*Config, error) {
-	configFile, err := homedir.Expand("~/.fx/config.yml")
+	configFile, err := homedir.Expand(defaultFxConfig)
 	if err != nil {
 		return nil, err
 	}
 	if os.Getenv("FX_CONFIG") != "" {
 		configFile = os.Getenv("FX_CONFIG")
-
 	}
+
 	if _, err := os.Stat(configFile); os.IsNotExist(err) {
 		if err := utils.EnsureFile(configFile); err != nil {
 			return nil, err
 		}
-		if err := writeDefaultConfig(configFile); err != nil {
+	}
+	return load(configFile)
+}
+
+func load(configFile string) (*Config, error) {
+	container, err := CreateContainer(configFile)
+	if err != nil {
+		return nil, err
+	}
+	config := &Config{
+		configFile: configFile,
+		container:  container,
+	}
+
+	if container.get("clouds") == nil {
+		if err := config.writeDefaultConfig(); err != nil {
 			return nil, err
 		}
 	}
-	return load(configFile)
+	return config, nil
 }
 
 // Load config
@@ -58,138 +78,119 @@ func Load(configFile string) (*Config, error) {
 		if err := utils.EnsureFile(configFile); err != nil {
 			return nil, err
 		}
-		if err := writeDefaultConfig(configFile); err != nil {
-			return nil, err
-		}
 	}
 	return load(configFile)
 }
 
-// AddCloud add a cloud
-func (c *Config) addCloud(name string, cloud map[string]string) error {
-	c.Items.Clouds[name] = cloud
-	return save(c)
-}
-
-// AddDockerCloud add docker cloud
-func (c *Config) AddDockerCloud(name string, config []byte) error {
-	c.mux.Lock()
-	defer c.mux.Unlock()
-
-	var conf map[string]string
-	err := json.Unmarshal(config, &conf)
-	if err != nil {
+// AddCloud add k8s cloud
+func (c *Config) AddCloud(name string, meta []byte) error {
+	var cloudMeta map[string]interface{}
+	if err := json.Unmarshal(meta, &cloudMeta); err != nil {
 		return err
 	}
 
-	cloud := map[string]string{
-		"type": "docker",
-		"host": conf["ip"],
-		"user": conf["user"],
-	}
-	return c.addCloud(name, cloud)
-}
-
-// AddK8SCloud add k8s cloud
-func (c *Config) AddK8SCloud(name string, kubeconfig []byte) error {
-	c.mux.Lock()
-	defer c.mux.Unlock()
-
-	dir := path.Dir(c.configFile)
-	kubecfg := path.Join(dir, name+".kubeconfig")
-	if err := utils.EnsureFile(kubecfg); err != nil {
-		return err
-	}
-	if err := ioutil.WriteFile(kubecfg, kubeconfig, 0666); err != nil {
-		return err
+	cloudType, ok := cloudMeta["type"].(string)
+	if !ok || cloudType == "" {
+		return fmt.Errorf("unknown cloud type")
 	}
 
-	cloud := map[string]string{
-		"type":       "k8s",
-		"kubeconfig": kubecfg,
-	}
-
-	return c.addCloud(name, cloud)
-}
-
-// Use set cloud instance with name as current context
-func (c *Config) Use(name string) error {
-	c.mux.Lock()
-	defer c.mux.Unlock()
-
-	has := false
-	for n := range c.Clouds {
-		if n == name {
-			has = true
-			break
+	if cloudType == types.CloudTypeK8S {
+		dir := path.Dir(c.configFile)
+		kubecfg := path.Join(dir, name+".kubeconfig")
+		if err := utils.EnsureFile(kubecfg); err != nil {
+			return err
+		}
+		config, ok := cloudMeta["config"].(string)
+		if !ok {
+			return fmt.Errorf("invalid k8s config")
+		}
+		if err := ioutil.WriteFile(kubecfg, []byte(config), 0666); err != nil {
+			return err
 		}
 	}
-	if !has {
-		return fmt.Errorf("no cloud with name = %s", name)
+
+	if err := c.container.set("clouds."+name, cloudMeta); err != nil {
+		return err
 	}
-	c.Items.CurrentCloud = name
-	return save(c)
+
+	return nil
+}
+
+// UseCloud set cloud instance with name as current context
+func (c *Config) UseCloud(name string) error {
+	if name == "" {
+		return fmt.Errorf("could not use empty name")
+	}
+
+	if c.container.get("clouds."+name) == nil {
+		return fmt.Errorf("no such cloud with name: %s", name)
+	}
+	return c.container.set("current_cloud", name)
 }
 
 // View view current config
 func (c *Config) View() ([]byte, error) {
-	c.mux.Lock()
-	defer c.mux.Unlock()
-
 	return ioutil.ReadFile(c.configFile)
 }
 
-func load(configFile string) (*Config, error) {
-	conf, err := ioutil.ReadFile(configFile)
-	if err != nil {
-		return nil, err
+// GetCurrentCloud get current using cloud's meta
+func (c *Config) GetCurrentCloud() ([]byte, error) {
+	name, ok := c.container.get("current_cloud").(string)
+	if !ok {
+		return nil, fmt.Errorf("no active cloud")
 	}
-	var items Items
-	if err := yaml.Unmarshal(conf, &items); err != nil {
-		return nil, err
+	meta := c.container.get("clouds." + name)
+	if meta == nil {
+		return nil, fmt.Errorf("invalid config")
 	}
-	var c = Config{
-		configFile: configFile,
-		Items:      items,
-	}
-	return &c, nil
+	return json.Marshal(meta)
 }
 
-func save(c *Config) error {
-	conf, err := yaml.Marshal(c.Items)
-	if err != nil {
-		return err
+// GetCurrentCloudType get current cloud type
+func (c *Config) GetCurrentCloudType() (string, error) {
+	name, ok := c.container.get("current_cloud").(string)
+	if !ok {
+		return "", fmt.Errorf("no active cloud")
 	}
-	if err := ioutil.WriteFile(c.configFile, conf, 0666); err != nil {
-		return err
-	}
-	return nil
+	return c.container.get("clouds." + name + ".type").(string), nil
 }
 
-func writeDefaultConfig(configFile string) error {
+// GetKubeConfig get kubeconfig
+func (c *Config) GetKubeConfig() (string, error) {
+	name, ok := c.container.get("current_cloud").(string)
+	if !ok {
+		return "", fmt.Errorf("no active cloud")
+	}
+	dir := path.Dir(c.configFile)
+	kubecfg := path.Join(dir, name+".kubeconfig")
+	return kubecfg, nil
+}
+
+func (c *Config) writeDefaultConfig() error {
 	me, err := user.Current()
 	if err != nil {
 		return err
 	}
-	items := Items{
-		Clouds: map[string]map[string]string{
-			"default": map[string]string{
-				"type": "docker",
-				"host": "127.0.0.1",
-				"user": me.Username,
-			},
-		},
-		CurrentCloud: "default",
-	}
 
-	body, err := yaml.Marshal(items)
+	defaultCloud := &dockerInfra.Cloud{
+		IP:   "127.0.0.1",
+		User: me.Username,
+		Name: "default",
+		Type: types.CloudTypeDocker,
+	}
+	meta, err := defaultCloud.Dump()
 	if err != nil {
 		return err
 	}
-
-	if err := ioutil.WriteFile(configFile, body, 0666); err != nil {
+	if err := c.container.set("clouds", map[string]interface{}{}); err != nil {
 		return err
 	}
-
-	return nil
+	if err := c.AddCloud("default", meta); err != nil {
+		return err
+	}
+	return c.UseCloud("default")
 }
+
+var (
+	_ Configer = &Config{}
+)

config/config_test.go

@@ -4,57 +4,103 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"os/user"
+	"reflect"
 	"testing"
+
+	k8sInfra "github.com/metrue/fx/infra/k8s"
+	"github.com/metrue/fx/types"
 )
 
 func TestConfig(t *testing.T) {
 	configPath := "./tmp/config.yml"
 	defer func() {
-		if err := os.RemoveAll("./tmp"); err != nil {
+		if err := os.RemoveAll("./tmp/config.yml"); err != nil {
 			t.Fatal(err)
 		}
 	}()
+
+	// default cloud
 	c, err := Load(configPath)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if len(c.Clouds) != 1 {
-		t.Fatal("should contain default cloud")
-	}
-
-	name := "fx_cluster_1"
-	if err := c.Use(name); err == nil {
-		t.Fatal("should get no such cloud error")
-	}
-
-	if err := c.AddK8SCloud(name, []byte("sampe kubeconfg")); err != nil {
-		t.Fatal(err)
-	}
-
-	config := map[string]string{
-		"ip":   "127.0.0.1",
-		"user": "use1",
-	}
-	configData, _ := json.Marshal(config)
-	if err := c.AddDockerCloud("docker-1", configData); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := c.Use(name); err != nil {
-		t.Fatal(err)
-	}
-
-	if c.CurrentCloud != name {
-		t.Fatalf("should get %s but got %s", name, c.CurrentCloud)
-	}
-
-	conf, err := Load(configPath)
+	defaultMeta, err := c.GetCurrentCloud()
 	if err != nil {
 		t.Fatal(err)
 	}
-	if conf.CurrentCloud != name {
-		t.Fatalf("should get %s but got %s", name, c.CurrentCloud)
+	var cloudMeta map[string]string
+	if err := json.Unmarshal(defaultMeta, &cloudMeta); err != nil {
+		t.Fatal(err)
+	}
+	if cloudMeta["ip"] != "127.0.0.1" {
+		t.Fatalf("should get %s but got %s", "127.0.0.1", cloudMeta["ip"])
+	}
+
+	me, _ := user.Current()
+	if cloudMeta["user"] != me.Username {
+		t.Fatalf("should get %s but got %s", me.Username, cloudMeta["user"])
+	}
+	if cloudMeta["type"] != types.CloudTypeDocker {
+		t.Fatalf("should get %s but got %s", types.CloudTypeDocker, cloudMeta["type"])
+	}
+	if cloudMeta["name"] != "default" {
+		t.Fatalf("should get %s but got %s", "default", cloudMeta["name"])
+	}
+
+	// add k8s cloud
+	kCloud := k8sInfra.Cloud{
+		Type:   types.CloudTypeK8S,
+		Config: "sample kubeconfg",
+		Token:  "",
+		URL:    "",
+		Nodes: map[string]k8sInfra.Noder{
+			"master-node": &k8sInfra.Node{
+				IP:   "1.1.1.1",
+				User: "user-1",
+				Type: "k3s-master",
+				Name: "master-node",
+			},
+			"agent-node-1": &k8sInfra.Node{
+				IP:   "1.1.1.1",
+				User: "user-1",
+				Type: "k3s-agent",
+				Name: "agent-node-1",
+			},
+		},
+	}
+	kMeta, err := kCloud.Dump()
+	if err != nil {
+		t.Fatal(err)
+	}
+	kName := "k8s-1"
+	if err := c.AddCloud(kName, kMeta); err != nil {
+		t.Fatal(err)
+	}
+
+	curMeta, err := c.GetCurrentCloud()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(curMeta, defaultMeta) {
+		t.Fatalf("should get %v but got %v", defaultMeta, curMeta)
+	}
+
+	if err := c.UseCloud("cloud-not-existed"); err == nil {
+		t.Fatalf("should get error when there is not given cloud name")
+	}
+
+	if err := c.UseCloud(kName); err != nil {
+		t.Fatal(err)
+	}
+
+	curMeta, err = c.GetCurrentCloud()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if reflect.DeepEqual(curMeta, kMeta) {
+		t.Fatalf("should get %v but got %v", kMeta, curMeta)
 	}
 
 	body, err := c.View()

config/container.go

@@ -0,0 +1,73 @@
+package config
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/metrue/fx/utils"
+	"github.com/spf13/viper"
+)
+
+// Container config container, wrap viper as a key-value store with lock
+type Container struct {
+	mux   sync.Mutex
+	store string
+}
+
+// CreateContainer new a container
+func CreateContainer(storeFile string) (*Container, error) {
+	if err := utils.EnsureFile(storeFile); err != nil {
+		return nil, err
+	}
+
+	dir := filepath.Dir(storeFile)
+	ext := filepath.Ext(storeFile)
+	name := filepath.Base(storeFile)
+	viper.AddConfigPath(dir)
+	viper.SetConfigName(strings.Replace(name, ext, "", 1))
+	viper.SetConfigType(strings.Replace(ext, ".", "", 1))
+	if err := viper.ReadInConfig(); err != nil {
+		return nil, err
+	}
+	return &Container{
+		store: storeFile,
+	}, nil
+
+}
+
+func (c *Container) set(key string, value interface{}) error {
+	c.mux.Lock()
+	defer c.mux.Unlock()
+
+	if key == "" {
+		return fmt.Errorf("empty key not allowed")
+	}
+
+	keys := strings.Split(key, ".")
+	if len(keys) == 1 {
+		viper.Set(key, value)
+	} else {
+		prePath := keys[0]
+		for i := 1; i < len(keys)-2; i++ {
+			prePath += "." + keys[i]
+		}
+		if viper.Get(prePath) == nil {
+			return fmt.Errorf("%s not existed", prePath)
+		}
+		viper.Set(key, value)
+	}
+	// viper.Set(key, value)
+	if err := viper.WriteConfig(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *Container) get(key string) interface{} {
+	c.mux.Lock()
+	defer c.mux.Unlock()
+
+	return viper.Get(key)
+}

config/container_test.go

@@ -0,0 +1,84 @@
+package config
+
+import (
+	"os"
+	"testing"
+)
+
+func TestContainer(t *testing.T) {
+	configPath := "./tmp/container.yml"
+	defer func() {
+		if err := os.RemoveAll("./tmp/container.yml"); err != nil {
+			t.Fatal(err)
+		}
+	}()
+	c, err := CreateContainer(configPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := c.set("", ""); err == nil {
+		t.Fatalf("should get error when key is empty")
+	}
+
+	if c.get("1") != nil {
+		t.Fatalf("should get %v but got %v", nil, c.get("key"))
+	}
+
+	// create
+	if err := c.set("1", "1"); err != nil {
+		t.Fatal(err)
+	}
+
+	// read
+	if c.get("1").(string) != "1" {
+		t.Fatalf("should get %s but got %s", "val-1", c.get("key"))
+	}
+
+	// invaliad set
+	if err := c.set("1.1", "1.1"); err != nil {
+		t.Fatal(err)
+	}
+	if c.get("1.1").(string) != "1.1" {
+		t.Fatalf("should get 1.1 but got %s", c.get("1.1"))
+	}
+
+	// update
+	if err := c.set("1", "11"); err != nil {
+		t.Fatal(err)
+	}
+	if c.get("1").(string) != "11" {
+		t.Fatalf("should get 11 but got %s", c.get("1").(string))
+	}
+
+	// nested set
+	if err := c.set("2.2.2.2", "2222"); err == nil {
+		t.Fatalf("should throw error since 2.2.2 not ready yet")
+	}
+
+	if err := c.set("2", map[string]interface{}{
+		"2": map[string]interface{}{
+			"2": "2",
+		},
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	if c.get("2.2.2").(string) != "2" {
+		t.Fatalf("should get 2 but got %s", c.get("2.2.2"))
+	}
+	if err := c.set("2.2.2.2", "2222"); err != nil {
+		t.Fatal(err)
+	}
+	if c.get("2.2.2.2").(string) != "2222" {
+		t.Fatalf("should get 2222 but got %s", c.get("2.2.2.2"))
+	}
+
+	if err := c.set("2.2.2.1", "1111"); err != nil {
+		t.Fatal(err)
+	}
+
+	if c.get("2.2.2.1").(string) != "1111" {
+		t.Fatalf("should get 1111 but got %s", c.get("2.2.2.1"))
+	}
+}

config/types.go

@@ -1,7 +0,0 @@
-package config
-
-// CloudTypeDocker docker type
-const CloudTypeDocker = "docker"
-
-// CloudTypeK8S k8s type
-const CloudTypeK8S = "k8s"

fx.go

@@ -16,7 +16,7 @@ import (
 	"github.com/urfave/cli"
 )
 
-const version = "0.8.73"
+const version = "0.8.74"
 
 func init() {
 	go checkForUpdate()

go.mod

@@ -22,7 +22,7 @@ require (
 	github.com/gorilla/mux v1.7.3 // indirect
 	github.com/imdario/mergo v0.3.7 // indirect
 	github.com/logrusorgru/aurora v0.0.0-20191017060258-dc85c304c434
-	github.com/metrue/go-ssh-client v0.0.0-20191125030649-4ac058ee958b
+	github.com/metrue/go-ssh-client v0.0.0-20191209160027-5773243a8bc9
 	github.com/mholt/archiver v3.1.1+incompatible
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/morikuni/aec v1.0.0 // indirect
@@ -34,6 +34,7 @@ require (
 	github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2
 	github.com/pierrec/lz4 v0.0.0-20190222153722-062282ea0dcf // indirect
 	github.com/pkg/errors v0.8.1
+	github.com/spf13/viper v1.3.2
 	github.com/stretchr/testify v1.4.0
 	github.com/ugorji/go v1.1.7 // indirect
 	github.com/urfave/cli v1.22.2

go.sum

@@ -151,6 +151,7 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/logrusorgru/aurora v0.0.0-20191017060258-dc85c304c434 h1:im9kkmH0WWwxzegiv18gSUJbuXR9y028rXrWuPp6Jug=
 github.com/logrusorgru/aurora v0.0.0-20191017060258-dc85c304c434/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
+github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
@@ -167,6 +168,8 @@ github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+tw
 github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/metrue/go-ssh-client v0.0.0-20191125030649-4ac058ee958b h1:JGD0sJ44XzhsT1voOg00zji4ubuMNcVNK3m7d9GI88k=
 github.com/metrue/go-ssh-client v0.0.0-20191125030649-4ac058ee958b/go.mod h1:ERHOEBrDy6+8vfoJjjmhdmBpOzdvvP7bLtwYTTK6LOs=
+github.com/metrue/go-ssh-client v0.0.0-20191209160027-5773243a8bc9 h1:HHfMhG77ZLn3FOH3AGXW/F5RpAABVH6Fr5mVZZ97S6w=
+github.com/metrue/go-ssh-client v0.0.0-20191209160027-5773243a8bc9/go.mod h1:aPG/JtXTyLliKDDlkv+nzHbSbz2p2CBMAjNJRK4uhzY=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
 github.com/mholt/archiver v3.1.1+incompatible h1:1dCVxuqs0dJseYEhi5pl7MYPH9zDa1wBi7mF09cbNkU=
 github.com/mholt/archiver v3.1.1+incompatible/go.mod h1:Dh2dOXnSdiLxRiPoVfIr/fI1TwETms9B8CTWfeh7ROU=
@@ -204,6 +207,7 @@ github.com/otiai10/copy v1.0.2 h1:DDNipYy6RkIkjMwy+AWzgKiNTyj2RUI9yEMeETEpVyc=
 github.com/otiai10/copy v1.0.2/go.mod h1:c7RpqBkwMom4bYTSkLSym4VSJz/XtncWRAj/J4PEIMY=
 github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE=
 github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo=
+github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
 github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2 h1:JhzVVoYvbOACxoUmOs6V/G4D5nPVUW73rKvXxP4XUJc=
@@ -240,10 +244,12 @@ github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
 github.com/spf13/cobra v0.0.5 h1:f0B+LkLX6DtmRH1isoNA9VTtNUK9K8xYd28JNNfOv/s=
 github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
+github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/viper v1.3.2 h1:VUFqw5KcqRf7i70GOzW7N+Q7+gxVBkSSqiXB12+JQ4M=
 github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=

handlers/infra.go

@@ -7,7 +7,7 @@ import (
 	"github.com/metrue/fx/config"
 	"github.com/metrue/fx/context"
 	dockerInfra "github.com/metrue/fx/infra/docker"
-	"github.com/metrue/fx/infra/k8s"
+	k8sInfra "github.com/metrue/fx/infra/k8s"
 	"github.com/metrue/fx/pkg/spinner"
 )
 
@@ -16,38 +16,49 @@ func setupK8S(masterInfo string, agentsInfo string) ([]byte, error) {
 	if len(info) != 2 {
 		return nil, fmt.Errorf("incorrect master info, should be <user>@<ip> format")
 	}
-	master := k8s.MasterNode{
-		User: info[0],
-		IP:   info[1],
+	master, err := k8sInfra.CreateNode(info[1], info[0], "k3s_master", "master")
+	if err != nil {
+		return nil, err
 	}
-	agents := []k8s.AgentNode{}
+	nodes := []k8sInfra.Noder{master}
 	if agentsInfo != "" {
 		agentsInfoList := strings.Split(agentsInfo, ",")
-		for _, agent := range agentsInfoList {
+		for idx, agent := range agentsInfoList {
 			info := strings.Split(agent, "@")
 			if len(info) != 2 {
 				return nil, fmt.Errorf("incorrect agent info, should be <user>@<ip> format")
 			}
-			agents = append(agents, k8s.AgentNode{
-				User: info[0],
-				IP:   info[1],
-			})
+			node, err := k8sInfra.CreateNode(info[1], info[0], "k3s_agent", fmt.Sprintf("agent-%d", idx))
+			if err != nil {
+				return nil, err
+			}
+
+			nodes = append(nodes, node)
 		}
 	}
-
-	k8sOperator := k8s.New(master, agents)
-	return k8sOperator.Provision()
+	cloud := k8sInfra.NewCloud(nodes...)
+	if err := cloud.Provision(); err != nil {
+		return nil, err
+	}
+	return cloud.Dump()
 }
 
-func setupDocker(hostInfo string) ([]byte, error) {
+func setupDocker(hostInfo string, name string) ([]byte, error) {
 	info := strings.Split(hostInfo, "@")
 	if len(info) != 2 {
 		return nil, fmt.Errorf("incorrect master info, should be <user>@<ip> format")
 	}
-	user := info[1]
-	host := info[0]
-	dockr := dockerInfra.CreateProvisioner(user, host)
-	return dockr.Provision()
+	user := info[0]
+	host := info[1]
+
+	cloud, err := dockerInfra.Create(host, user, name)
+	if err != nil {
+		return nil, err
+	}
+	if err := cloud.Provision(); err != nil {
+		return nil, err
+	}
+	return cloud.Dump()
 }
 
 // Setup infra
@@ -84,13 +95,13 @@ func Setup(ctx context.Contexter) (err error) {
 		if err != nil {
 			return err
 		}
-		return fxConfig.AddK8SCloud(name, kubeconf)
+		return fxConfig.AddCloud(name, kubeconf)
 	case "docker":
-		config, err := setupDocker(cli.String("host"))
+		config, err := setupDocker(cli.String("host"), name)
 		if err != nil {
 			return err
 		}
-		return fxConfig.AddDockerCloud(name, config)
+		return fxConfig.AddCloud(name, config)
 	}
 	return nil
 }

handlers/use_infra.go

@@ -9,5 +9,5 @@ import (
 func UseInfra(ctx context.Contexter) error {
 	fxConfig := ctx.Get("config").(*config.Config)
 	cli := ctx.GetCliContext()
-	return fxConfig.Use(cli.Args().First())
+	return fxConfig.UseCloud(cli.Args().First())
 }

infra/docker/cloud.go

@@ -0,0 +1,140 @@
+package docker
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+
+	"github.com/metrue/fx/infra"
+	"github.com/metrue/fx/types"
+	"github.com/metrue/go-ssh-client"
+	"github.com/mitchellh/go-homedir"
+)
+
+// Cloud define a docker host
+type Cloud struct {
+	IP   string `json:"ip"`
+	User string `json:"user"`
+	Name string `json:"name"`
+	Type string `json:"type"`
+
+	sshClient ssh.Clienter
+}
+
+// New new a docker cloud
+func New(ip string, user string, name string) *Cloud {
+	return &Cloud{
+		IP:   ip,
+		User: user,
+		Name: name,
+		Type: types.CloudTypeDocker,
+	}
+}
+
+// Create a docker node
+func Create(ip string, user string, name string) (*Cloud, error) {
+	key, err := sshkey()
+	if err != nil {
+		return nil, err
+	}
+	port := sshport()
+	sshClient := ssh.New(ip).WithUser(user).WithKey(key).WithPort(port)
+	return &Cloud{
+		IP:   ip,
+		User: user,
+		Name: name,
+		Type: types.CloudTypeDocker,
+
+		sshClient: sshClient,
+	}, nil
+}
+
+// Load a docker node from meta
+func Load(meta []byte) (*Cloud, error) {
+	var cloud Cloud
+	if err := json.Unmarshal(meta, &cloud); err != nil {
+		return nil, err
+	}
+	key, err := sshkey()
+	if err != nil {
+		return nil, err
+	}
+	port := sshport()
+	sshClient := ssh.New(cloud.IP).WithUser(cloud.User).WithKey(key).WithPort(port)
+	cloud.sshClient = sshClient
+
+	return &cloud, nil
+}
+
+// Provision a host
+func (c *Cloud) Provision() error {
+	if err := c.sshClient.RunCommand(infra.Scripts["docker_version"].(string), ssh.CommandOptions{}); err != nil {
+		if err := c.sshClient.RunCommand(infra.Scripts["install_docker"].(string), ssh.CommandOptions{}); err != nil {
+			return err
+		}
+
+		if err := c.sshClient.RunCommand(infra.Scripts["start_dockerd"].(string), ssh.CommandOptions{}); err != nil {
+			return err
+		}
+	}
+
+	if err := c.sshClient.RunCommand(infra.Scripts["check_fx_agent"].(string), ssh.CommandOptions{}); err != nil {
+		if err := c.sshClient.RunCommand(infra.Scripts["start_fx_agent"].(string), ssh.CommandOptions{}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetType cloud type
+func (c *Cloud) GetType() string {
+	return c.Type
+}
+
+func (c *Cloud) GetConfig() (string, error) {
+	data, err := json.Marshal(c)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func (c *Cloud) Dump() ([]byte, error) {
+	return json.Marshal(c)
+}
+
+// NOTE only using for unit testing
+func (c *Cloud) setsshClient(client ssh.Clienter) {
+	c.sshClient = client
+}
+
+// NOTE the reason putting sshkey() and sshport here inside node.go is because
+// ssh key and ssh port is related to node it self, we may extend this in future
+func sshkey() (string, error) {
+	path := os.Getenv("SSH_KEY_FILE")
+	if path != "" {
+		absPath, err := filepath.Abs(path)
+		if err != nil {
+			return "", err
+		}
+		return absPath, nil
+	}
+
+	key, err := homedir.Expand("~/.ssh/id_rsa")
+	if err != nil {
+		return "", err
+	}
+	return key, nil
+}
+
+func sshport() string {
+	port := os.Getenv("SSH_PORT")
+	if port != "" {
+		return port
+	}
+	return "22"
+}
+
+var (
+	_ infra.Clouder = &Cloud{}
+)

infra/docker/cloud_test.go

@@ -0,0 +1,103 @@
+package docker
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/metrue/fx/infra"
+	"github.com/metrue/go-ssh-client"
+	sshMocks "github.com/metrue/go-ssh-client/mocks"
+	"github.com/mitchellh/go-homedir"
+)
+
+func TestCloud(t *testing.T) {
+	t.Run("fx agent started", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		n := New("127.0.0.1", "fx", "master")
+		sshClient := sshMocks.NewMockClienter(ctrl)
+		n.setsshClient(sshClient)
+		sshClient.EXPECT().RunCommand(infra.Scripts["docker_version"].(string), ssh.CommandOptions{}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["check_fx_agent"].(string), ssh.CommandOptions{}).Return(nil)
+		if err := n.Provision(); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	t.Run("fx agent not started", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		n := New("127.0.0.1", "fx", "master")
+		sshClient := sshMocks.NewMockClienter(ctrl)
+		n.setsshClient(sshClient)
+		sshClient.EXPECT().RunCommand(infra.Scripts["docker_version"].(string), ssh.CommandOptions{}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["check_fx_agent"].(string), ssh.CommandOptions{}).Return(fmt.Errorf("no such container"))
+		sshClient.EXPECT().RunCommand(infra.Scripts["start_fx_agent"].(string), ssh.CommandOptions{}).Return(nil)
+		if err := n.Provision(); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	t.Run("docker not installed and fx agent not started", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		n := New("127.0.0.1", "fx", "master")
+		sshClient := sshMocks.NewMockClienter(ctrl)
+		n.setsshClient(sshClient)
+		sshClient.EXPECT().RunCommand(infra.Scripts["docker_version"].(string), ssh.CommandOptions{}).Return(fmt.Errorf("no such command"))
+		sshClient.EXPECT().RunCommand(infra.Scripts["install_docker"].(string), ssh.CommandOptions{}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["start_dockerd"].(string), ssh.CommandOptions{}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["check_fx_agent"].(string), ssh.CommandOptions{}).Return(fmt.Errorf("no such container"))
+		sshClient.EXPECT().RunCommand(infra.Scripts["start_fx_agent"].(string), ssh.CommandOptions{}).Return(nil)
+		if err := n.Provision(); err != nil {
+			t.Fatal(err)
+		}
+	})
+}
+
+func TestGetSSHKeyFile(t *testing.T) {
+	t.Run("defaut", func(t *testing.T) {
+		defau, err := sshkey()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defaultPath, _ := homedir.Expand("~/.ssh/id_rsa")
+		if defau != defaultPath {
+			t.Fatalf("should get %s but got %s", defaultPath, defau)
+		}
+	})
+
+	t.Run("override from env", func(t *testing.T) {
+		os.Setenv("SSH_KEY_FILE", "/tmp/id_rsa")
+		keyFile, err := sshkey()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if keyFile != "/tmp/id_rsa" {
+			t.Fatalf("should get %s but got %s", "/tmp/id_rsa", keyFile)
+		}
+	})
+}
+
+func TestGetSSHPort(t *testing.T) {
+	t.Run("defaut", func(t *testing.T) {
+		defau := sshport()
+		if defau != "22" {
+			t.Fatalf("should get %s but got %s", "22", defau)
+		}
+	})
+
+	t.Run("override from env", func(t *testing.T) {
+		os.Setenv("SSH_PORT", "2222")
+		defau := sshport()
+		if defau != "2222" {
+			t.Fatalf("should get %s but got %s", "2222", defau)
+		}
+	})
+}

infra/docker/docker.go

@@ -2,11 +2,6 @@ package docker
 
 import containerruntimes "github.com/metrue/fx/container_runtimes"
 
-// CreateProvisioner create a provisioner
-func CreateProvisioner(ip string, user string) *Provisioner {
-	return NewProvisioner(ip, user)
-}
-
 // CreateDeployer create a deployer
 func CreateDeployer(client containerruntimes.ContainerRuntime) (*Deployer, error) {
 	return &Deployer{cli: client}, nil

infra/docker/provisioner.go

@@ -1,217 +0,0 @@
-package docker
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/metrue/fx/constants"
-	"github.com/metrue/fx/infra"
-	"github.com/metrue/fx/pkg/spinner"
-	sshOperator "github.com/metrue/go-ssh-client"
-)
-
-// Provisioner docker host
-type Provisioner struct {
-	IP   string
-	User string
-}
-
-// NewProvisioner new a docker object
-func NewProvisioner(ip string, user string) *Provisioner {
-	return &Provisioner{
-		IP:   ip,
-		User: user,
-	}
-}
-
-// Provision provision a host, install docker and start dockerd
-func (d *Provisioner) Provision() (config []byte, err error) {
-	spinner.Start("provisioning")
-	defer func() {
-		spinner.Stop("provisioning", err)
-	}()
-
-	// TODO clean up, skip check localhost or not if in CICD env
-	if os.Getenv("CICD") != "" {
-		if err := d.Install(); err != nil {
-			return nil, err
-		}
-		if err := d.StartDockerd(); err != nil {
-			return nil, err
-		}
-		if err := d.StartFxAgent(); err != nil {
-			return nil, err
-		}
-		config, _ := json.Marshal(map[string]string{
-			"ip":   d.IP,
-			"user": d.User,
-		})
-		return config, nil
-	}
-
-	if d.isLocalHost() {
-		if !d.hasDocker() {
-			return nil, fmt.Errorf("please make sure docker installed and running")
-		}
-
-		if err := d.StartFxAgentLocally(); err != nil {
-			return nil, err
-		}
-
-		config, _ := json.Marshal(map[string]string{
-			"ip":   d.IP,
-			"user": d.User,
-		})
-		return config, nil
-	}
-
-	if err := d.Install(); err != nil {
-		return nil, err
-	}
-	if err := d.StartDockerd(); err != nil {
-		return nil, err
-	}
-	if err := d.StartFxAgent(); err != nil {
-		return nil, err
-	}
-	return json.Marshal(map[string]string{
-		"ip":   d.IP,
-		"user": d.User,
-	})
-}
-
-func (d *Provisioner) isLocalHost() bool {
-	return strings.ToLower(d.IP) == "localhost" || d.IP == "127.0.0.1"
-}
-
-func (d *Provisioner) hasDocker() bool {
-	cmd := exec.Command("docker", "version")
-	if err := cmd.Run(); err != nil {
-		return false
-	}
-	return true
-}
-
-// HealthCheck check healthy status of host
-func (d *Provisioner) HealthCheck() (bool, error) {
-	if d.isLocalHost() {
-		return d.IfFxAgentRunningLocally(), nil
-	}
-	return d.IfFxAgentRunning(), nil
-}
-
-// Install docker on host
-func (d *Provisioner) Install() error {
-	sudo := ""
-	if d.User != "root" {
-		sudo = "sudo"
-	}
-	installCmd := fmt.Sprintf("curl -fsSL https://download.docker.com/linux/static/stable/x86_64/docker-18.06.3-ce.tgz -o docker.tgz && tar zxvf docker.tgz && %s mv docker/* /usr/bin && rm -rf docker docker.tgz", sudo)
-	sshKeyFile, _ := infra.GetSSHKeyFile()
-	sshPort := infra.GetSSHPort()
-	ssh := sshOperator.New(d.IP).WithUser(d.User).WithKey(sshKeyFile).WithPort(sshPort)
-	if err := ssh.RunCommand(installCmd, sshOperator.CommandOptions{
-		Stdout: os.Stdout,
-		Stdin:  os.Stdin,
-		Stderr: os.Stderr,
-	}); err != nil {
-		fmt.Println("install docker failed \n================")
-		fmt.Println(err)
-		fmt.Println("================")
-		return err
-	}
-
-	return nil
-}
-
-// StartDockerd start dockerd
-func (d *Provisioner) StartDockerd() error {
-	sudo := ""
-	if d.User != "root" {
-		sudo = "sudo"
-	}
-	installCmd := fmt.Sprintf("%s dockerd >/dev/null 2>&1 & sleep 2", sudo)
-	sshKeyFile, _ := infra.GetSSHKeyFile()
-	sshPort := infra.GetSSHPort()
-	ssh := sshOperator.New(d.IP).WithUser(d.User).WithKey(sshKeyFile).WithPort(sshPort)
-	if err := ssh.RunCommand(installCmd, sshOperator.CommandOptions{
-		Stdout: os.Stdout,
-		Stdin:  os.Stdin,
-		Stderr: os.Stderr,
-	}); err != nil {
-		fmt.Println("start dockerd failed \n================")
-		fmt.Println(err)
-		fmt.Println("================")
-		return err
-	}
-
-	return nil
-}
-
-// StartFxAgent start fx agent
-func (d *Provisioner) StartFxAgent() error {
-	startCmd := fmt.Sprintf("sleep 3 && docker stop %s || true && docker run -d --name=%s --rm -v /var/run/docker.sock:/var/run/docker.sock -p 0.0.0.0:%s:1234 bobrik/socat TCP-LISTEN:1234,fork UNIX-CONNECT:/var/run/docker.sock", constants.AgentContainerName, constants.AgentContainerName, constants.AgentPort)
-	sshKeyFile, _ := infra.GetSSHKeyFile()
-	sshPort := infra.GetSSHPort()
-	ssh := sshOperator.New(d.IP).WithUser(d.User).WithKey(sshKeyFile).WithPort(sshPort)
-	if err := ssh.RunCommand(startCmd, sshOperator.CommandOptions{
-		Stdout: os.Stdout,
-		Stdin:  os.Stdin,
-		Stderr: os.Stderr,
-	}); err != nil {
-		fmt.Println("start fx agent failed \n================")
-		fmt.Println(err)
-		fmt.Println("================")
-		return err
-	}
-	return nil
-}
-
-// StartFxAgentLocally start fx agent
-func (d *Provisioner) StartFxAgentLocally() error {
-	startCmd := fmt.Sprintf("docker run -d --name=%s --rm -v /var/run/docker.sock:/var/run/docker.sock -p 0.0.0.0:%s:1234 bobrik/socat TCP-LISTEN:1234,fork UNIX-CONNECT:/var/run/docker.sock", constants.AgentContainerName, constants.AgentPort)
-	params := strings.Split(startCmd, " ")
-	var cmd *exec.Cmd
-	if len(params) > 1 {
-		// nolint: gosec
-		cmd = exec.Command(params[0], params[1:]...)
-	} else {
-		// nolint: gosec
-		cmd = exec.Command(params[0])
-	}
-	if out, err := cmd.CombinedOutput(); err != nil {
-		fmt.Println(string(out))
-		return err
-	}
-	return nil
-}
-
-// IfFxAgentRunningLocally check if fx agent is running
-func (d *Provisioner) IfFxAgentRunningLocally() bool {
-	cmd := exec.Command("docker", "inspect", "fx-agent")
-	if err := cmd.Run(); err != nil {
-		return false
-	}
-	return true
-}
-
-// IfFxAgentRunning check if fx agent is running
-func (d *Provisioner) IfFxAgentRunning() bool {
-	inspectCmd := infra.Sudo("docker inspect fx-agent", d.User)
-	sshKeyFile, _ := infra.GetSSHKeyFile()
-	sshPort := infra.GetSSHPort()
-	ssh := sshOperator.New(d.IP).WithUser(d.User).WithKey(sshKeyFile).WithPort(sshPort)
-	if err := ssh.RunCommand(inspectCmd, sshOperator.CommandOptions{
-		Stdout: os.Stdout,
-		Stdin:  os.Stdin,
-		Stderr: os.Stderr,
-	}); err != nil {
-		return false
-	}
-	return true
-}
-
-var _ infra.Provisioner = &Provisioner{}

infra/docker/provisioner_test.go

@@ -1,23 +0,0 @@
-package docker
-
-import (
-	"os"
-	"testing"
-)
-
-func TestProvisioner(t *testing.T) {
-	if os.Getenv("DOCKER_HOST") == "" ||
-		os.Getenv("DOCKER_USER") == "" {
-		t.Skip("skip test since DOCKER_HOST and DOCKER_USER not ready")
-	}
-	d := NewProvisioner(os.Getenv("DOCKER_HOST"), os.Getenv("DOCKER_USER"))
-	if err := d.Install(); err != nil {
-		t.Fatal(err)
-	}
-	if err := d.StartDockerd(); err != nil {
-		t.Fatal(err)
-	}
-	if err := d.StartFxAgent(); err != nil {
-		t.Fatal(err)
-	}
-}

infra/infra.go

@@ -6,10 +6,12 @@ import (
 	"github.com/metrue/fx/types"
 )
 
-// Provisioner provision interface
-type Provisioner interface {
-	Provision() (config []byte, err error)
-	HealthCheck() (bool, error)
+// Clouder cloud interface
+type Clouder interface {
+	Provision() error
+	GetConfig() (string, error)
+	GetType() string
+	Dump() ([]byte, error)
 }
 
 // Deployer deploy interface
@@ -24,6 +26,5 @@ type Deployer interface {
 
 // Infra infrastructure provision interface
 type Infra interface {
-	Provisioner
 	Deployer
 }

infra/k8s/cloud.go

@@ -0,0 +1,262 @@
+package k8s
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/metrue/fx/infra"
+	"github.com/metrue/fx/types"
+)
+
+// Cloud define a cloud
+type Cloud struct {
+	Config string           `json:"config"`
+	URL    string           `json:"url"`
+	Token  string           `json:"token"`
+	Type   string           `json:"type"`
+	Nodes  map[string]Noder `json:"nodes"`
+}
+
+// Load a cloud from config
+func Load(meta []byte, messup ...func(n Noder) (Noder, error)) (*Cloud, error) {
+	var cloud Cloud
+	if err := json.Unmarshal(meta, &cloud); err != nil {
+		return nil, err
+	}
+
+	for name, n := range cloud.Nodes {
+		// NOTE messup function is just for unit testing
+		// we use it to replace the real not with mock node
+		if len(messup) > 0 {
+			node, err := messup[0](n)
+			if err != nil {
+				return nil, err
+			}
+			cloud.Nodes[name] = node
+		}
+	}
+	return &cloud, nil
+}
+
+// NewCloud new a cloud
+func NewCloud(node ...Noder) *Cloud {
+	nodes := map[string]Noder{}
+	for _, n := range node {
+		nodes[n.GetName()] = n
+	}
+	return &Cloud{
+		Type:  types.CloudTypeK8S,
+		Nodes: nodes,
+	}
+}
+
+// Provision provision cloud
+func (c *Cloud) Provision() error {
+	var master Noder
+	agents := []Noder{}
+	for _, n := range c.Nodes {
+		if n.GetType() == NodeTypeMaster {
+			master = n
+		} else {
+			agents = append(agents, n)
+		}
+	}
+
+	// when it's k3s cluster
+	if master != nil {
+		c.URL = fmt.Sprintf("https://%s:6443", master.GetIP())
+		if err := master.Provision(map[string]string{}); err != nil {
+			return err
+		}
+
+		tok, err := master.GetToken()
+		if err != nil {
+			return err
+		}
+		c.Token = tok
+
+		config, err := master.GetConfig()
+		if err != nil {
+			return err
+		}
+		c.Config = config
+	}
+
+	// when it's a docker agent
+	if len(agents) == 1 && agents[0].GetType() == NodeTypeDocker {
+		config, err := agents[0].GetConfig()
+		if err != nil {
+			return err
+		}
+		c.Config = config
+	}
+
+	if len(agents) > 0 {
+		errCh := make(chan error, len(agents))
+		defer close(errCh)
+
+		for _, agent := range agents {
+			go func(node Noder) {
+				errCh <- node.Provision(map[string]string{
+					"url":   c.URL,
+					"token": c.Token,
+				})
+			}(agent)
+		}
+
+		for range agents {
+			err := <-errCh
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// AddNode a node
+func (c *Cloud) AddNode(n Noder, skipProvision bool) error {
+	if !skipProvision {
+		if err := n.Provision(map[string]string{
+			"url":   c.URL,
+			"token": c.Token,
+		}); err != nil {
+			return err
+		}
+	}
+
+	c.Nodes[n.GetName()] = n
+	return nil
+}
+
+// DeleteNode a node
+func (c *Cloud) DeleteNode(name string) error {
+	node, ok := c.Nodes[name]
+	if ok {
+		delete(c.Nodes, name)
+	}
+	if node.GetType() == NodeTypeMaster && len(c.Nodes) > 0 {
+		return fmt.Errorf("could not delete master node since there is still agent node running")
+	}
+	return nil
+}
+
+// State get cloud state
+func (c *Cloud) State() {}
+
+// UnmarshalJSON unmarsha json
+func (c *Cloud) UnmarshalJSON(data []byte) error {
+	var m map[string]interface{}
+	if err := json.Unmarshal(data, &m); err != nil {
+		return err
+	}
+
+	c.Nodes = make(map[string]Noder)
+
+	for k, v := range m {
+		if k == "nodes" {
+			nodes, ok := v.(map[string]interface{})
+			if !ok {
+				return fmt.Errorf("invalid nodes data")
+			}
+			for name, n := range nodes {
+				node, ok := n.(map[string]interface{})
+				if !ok {
+					return fmt.Errorf("invalid node data")
+				}
+				n, err := CreateNode(node["ip"].(string), node["user"].(string), node["type"].(string), node["name"].(string))
+				if err != nil {
+					return err
+				}
+				c.Nodes[name] = n
+			}
+		} else if k == "token" {
+			tok, ok := v.(string)
+			if ok {
+				c.Token = tok
+			} else {
+				c.Token = ""
+			}
+		} else if k == "config" {
+			config, ok := v.(string)
+			if ok {
+				c.Config = config
+			} else {
+				c.Config = ""
+			}
+		} else if k == "type" {
+			typ, ok := v.(string)
+			if ok {
+				c.Type = typ
+			} else {
+				c.Type = ""
+			}
+		} else if k == "url" {
+			url, ok := v.(string)
+			if ok {
+				c.URL = url
+			} else {
+				c.URL = ""
+			}
+		}
+	}
+
+	return nil
+}
+
+// MarshalJSON cloud information
+func (c *Cloud) MarshalJSON() ([]byte, error) {
+	nodes := map[string]Node{}
+	for name, node := range c.Nodes {
+		nodes[name] = Node{
+			IP:   node.GetIP(),
+			Type: node.GetType(),
+			User: node.GetUser(),
+			Name: node.GetName(),
+		}
+	}
+
+	body, err := json.Marshal(struct {
+		URL    string          `json:"url"`
+		Config string          `json:"config"`
+		Type   string          `json:"type"`
+		Token  string          `json:"token"`
+		Nodes  map[string]Node `json:"nodes"`
+	}{
+		URL:    c.URL,
+		Config: c.Config,
+		Type:   c.Type,
+		Token:  c.Token,
+		Nodes:  nodes,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return body, nil
+}
+
+// GetType get type of cloud
+func (c *Cloud) GetType() string {
+	return c.Type
+}
+
+// Dump cloud data
+func (c *Cloud) Dump() ([]byte, error) {
+	return json.Marshal(c)
+}
+
+// GetConfig get config
+func (c *Cloud) GetConfig() (string, error) {
+	if c.Config != "" {
+		return c.Config, nil
+	}
+	if err := c.Provision(); err != nil {
+		return "", err
+	}
+	return c.Config, nil
+}
+
+var (
+	_ infra.Clouder = &Cloud{}
+)

infra/k8s/cloud_test.go

@@ -0,0 +1,137 @@
+package k8s
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	mock_infra "github.com/metrue/fx/infra/k8s/mocks"
+)
+
+func TestLoad(t *testing.T) {
+	t.Run("empty meta", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		var createNodeFn = func(n Noder) (Noder, error) {
+			return nil, nil
+		}
+
+		_, err := Load([]byte{}, createNodeFn)
+		if err == nil {
+			t.Fatalf("should load with error")
+		}
+	})
+
+	t.Run("only master node", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		master := mock_infra.NewMockNoder(ctrl)
+		var createNodeFn = func(n Noder) (Noder, error) {
+			return master, nil
+		}
+		typ := NodeTypeMaster
+		name := "master"
+		ip := "127.0.0.1"
+		user := "testuser"
+		master.EXPECT().GetName().Return(name)
+		master.EXPECT().GetType().Return(typ).Times(2)
+		master.EXPECT().GetIP().Return(ip).Times(2)
+		master.EXPECT().GetUser().Return(user)
+		master.EXPECT().GetConfig().Return("sample-config", nil)
+
+		claud := &Cloud{
+			Config: "",
+			URL:    "",
+			Token:  "",
+			Type:   "k8s",
+			Nodes:  map[string]Noder{"master-node": master},
+		}
+
+		meta, err := json.Marshal(claud)
+		if err != nil {
+			t.Fatal(err)
+		}
+		cloud, err := Load(meta, createNodeFn)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(cloud.Nodes) != 1 {
+			t.Fatalf("should get %d but got %d", 1, len(cloud.Nodes))
+		}
+
+		master.EXPECT().Provision(map[string]string{}).Return(nil)
+		master.EXPECT().GetToken().Return("tok-1", nil)
+		if err := cloud.Provision(); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	t.Run("one master node and one agent", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		master := mock_infra.NewMockNoder(ctrl)
+		node := mock_infra.NewMockNoder(ctrl)
+		var createNodeFn = func(n Noder) (Noder, error) {
+			if n.GetType() == NodeTypeMaster {
+				return master, nil
+			}
+			return node, nil
+		}
+		typ := NodeTypeMaster
+		name := "master"
+		ip := "127.0.0.1"
+		user := "testuser"
+		master.EXPECT().GetName().Return(name)
+		master.EXPECT().GetType().Return(typ).Times(2)
+		master.EXPECT().GetIP().Return(ip).Times(3)
+		master.EXPECT().GetConfig().Return("sample-config", nil)
+		master.EXPECT().GetUser().Return(user)
+
+		nodeType := NodeTypeAgent
+		nodeName := "agent_name"
+		nodeIP := "12.12.12.12"
+		nodeUser := "testuser"
+		node.EXPECT().GetName().Return(nodeName)
+		node.EXPECT().GetType().Return(nodeType).Times(3)
+		node.EXPECT().GetIP().Return(nodeIP)
+		node.EXPECT().GetUser().Return(nodeUser)
+
+		url := fmt.Sprintf("https://%s:6443", master.GetIP())
+		tok := "tok-1"
+		claud := &Cloud{
+			Config: "",
+			URL:    url,
+			Token:  tok,
+			Type:   "k8s",
+			Nodes:  map[string]Noder{"master-node": master, "agent-node": node},
+		}
+		meta, err := json.Marshal(claud)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		cloud, err := Load(meta, createNodeFn)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(cloud.Nodes) != 2 {
+			t.Fatalf("should get %d but got %d", 2, len(cloud.Nodes))
+		}
+
+		master.EXPECT().Provision(map[string]string{}).Return(nil)
+		master.EXPECT().GetToken().Return(tok, nil)
+		node.EXPECT().Provision(map[string]string{
+			"url":   cloud.URL,
+			"token": cloud.Token,
+		}).Return(nil)
+		if err := cloud.Provision(); err != nil {
+			t.Fatal(err)
+		}
+	})
+}
+
+func TestProvision(t *testing.T) {}

infra/k8s/doc.go

@@ -0,0 +1,5 @@
+/*
+
+ */
+
+package k8s

infra/k8s/k8s.go

@@ -1,10 +1,5 @@
 package k8s
 
-// CreateProvisioner create a provisioner
-func CreateProvisioner(master MasterNode, agents []AgentNode) *Provisioner {
-	return New(master, agents)
-}
-
 // CreateDeployer create a deployer
 func CreateDeployer(kubeconfig string) (*K8S, error) {
 	return Create(kubeconfig)

infra/k8s/k8s_node.go

@@ -0,0 +1,15 @@
+package k8s
+
+import (
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// ListNodes list node
+func (k *K8S) ListNodes() (*v1.NodeList, error) {
+	nodes, err := k.CoreV1().Nodes().List(metav1.ListOptions{})
+	if err != nil {
+		return nil, err
+	}
+	return nodes, nil
+}

infra/k8s/mocks/node.go

@@ -0,0 +1,147 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: node.go
+
+// Package mock_k8s is a generated GoMock package.
+package mock_k8s
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockNoder is a mock of Noder interface
+type MockNoder struct {
+	ctrl     *gomock.Controller
+	recorder *MockNoderMockRecorder
+}
+
+// MockNoderMockRecorder is the mock recorder for MockNoder
+type MockNoderMockRecorder struct {
+	mock *MockNoder
+}
+
+// NewMockNoder creates a new mock instance
+func NewMockNoder(ctrl *gomock.Controller) *MockNoder {
+	mock := &MockNoder{ctrl: ctrl}
+	mock.recorder = &MockNoderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockNoder) EXPECT() *MockNoderMockRecorder {
+	return m.recorder
+}
+
+// Provision mocks base method
+func (m *MockNoder) Provision(meta map[string]string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Provision", meta)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Provision indicates an expected call of Provision
+func (mr *MockNoderMockRecorder) Provision(meta interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provision", reflect.TypeOf((*MockNoder)(nil).Provision), meta)
+}
+
+// GetConfig mocks base method
+func (m *MockNoder) GetConfig() (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetConfig")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetConfig indicates an expected call of GetConfig
+func (mr *MockNoderMockRecorder) GetConfig() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfig", reflect.TypeOf((*MockNoder)(nil).GetConfig))
+}
+
+// GetType mocks base method
+func (m *MockNoder) GetType() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetType")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetType indicates an expected call of GetType
+func (mr *MockNoderMockRecorder) GetType() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetType", reflect.TypeOf((*MockNoder)(nil).GetType))
+}
+
+// GetName mocks base method
+func (m *MockNoder) GetName() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetName")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetName indicates an expected call of GetName
+func (mr *MockNoderMockRecorder) GetName() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockNoder)(nil).GetName))
+}
+
+// GetUser mocks base method
+func (m *MockNoder) GetUser() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUser")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetUser indicates an expected call of GetUser
+func (mr *MockNoderMockRecorder) GetUser() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockNoder)(nil).GetUser))
+}
+
+// GetToken mocks base method
+func (m *MockNoder) GetToken() (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetToken")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetToken indicates an expected call of GetToken
+func (mr *MockNoderMockRecorder) GetToken() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetToken", reflect.TypeOf((*MockNoder)(nil).GetToken))
+}
+
+// GetIP mocks base method
+func (m *MockNoder) GetIP() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetIP")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetIP indicates an expected call of GetIP
+func (mr *MockNoderMockRecorder) GetIP() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIP", reflect.TypeOf((*MockNoder)(nil).GetIP))
+}
+
+// Dump mocks base method
+func (m *MockNoder) Dump() map[string]string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Dump")
+	ret0, _ := ret[0].(map[string]string)
+	return ret0
+}
+
+// Dump indicates an expected call of Dump
+func (mr *MockNoderMockRecorder) Dump() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockNoder)(nil).Dump))
+}

infra/k8s/node.go

@@ -1,15 +1,216 @@
 package k8s
 
 import (
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/metrue/fx/infra"
+	"github.com/metrue/go-ssh-client"
+	"github.com/mitchellh/go-homedir"
 )
 
-// ListNodes list node
-func (k *K8S) ListNodes() (*v1.NodeList, error) {
-	nodes, err := k.CoreV1().Nodes().List(metav1.ListOptions{})
+const NodeTypeMaster = "k3s_master"
+const NodeTypeAgent = "k3s_agent"
+const NodeTypeDocker = "docker_agent"
+
+// Noder node interface
+type Noder interface {
+	Provision(meta map[string]string) error
+	GetConfig() (string, error)
+	GetType() string
+	GetName() string
+	GetUser() string
+	GetToken() (string, error)
+	GetIP() string
+	Dump() map[string]string
+}
+
+// Node define a node
+type Node struct {
+	IP   string `json:"ip"`
+	User string `json:"user"`
+
+	Type string `json:"type"`
+	Name string `json:"name"`
+
+	sshClient ssh.Clienter
+}
+
+// CreateNode create a node
+func CreateNode(ip string, user string, typ string, name string) (*Node, error) {
+	key, err := sshkey()
 	if err != nil {
 		return nil, err
 	}
-	return nodes, nil
+	port := sshport()
+	sshClient := ssh.New(ip).WithUser(user).WithKey(key).WithPort(port)
+
+	return &Node{
+		IP:   ip,
+		User: user,
+		Type: typ,
+		Name: name,
+
+		sshClient: sshClient,
+	}, nil
 }
+
+func (n *Node) runCmd(script string) error {
+	return n.sshClient.RunCommand(script, ssh.CommandOptions{
+		Stdout: os.Stdout,
+		Stdin:  os.Stdin,
+		Stderr: os.Stderr,
+	})
+}
+
+// Provision provision node
+func (n *Node) Provision(meta map[string]string) error {
+	if err := n.runCmd(infra.Scripts["docker_version"].(string)); err != nil {
+		if err := n.runCmd(infra.Scripts["install_docker"].(string)); err != nil {
+			return err
+		}
+
+		if err := n.runCmd(infra.Scripts["start_dockerd"].(string)); err != nil {
+			return err
+		}
+	}
+
+	if n.Type == NodeTypeMaster {
+		if err := n.runCmd(infra.Scripts["check_k3s_server"].(string)); err != nil {
+			cmd := infra.Scripts["setup_k3s_master"].(func(ip string) string)(n.IP)
+			if err := n.runCmd(cmd); err != nil {
+				return err
+			}
+		}
+	} else if n.Type == NodeTypeAgent {
+		if err := n.runCmd(infra.Scripts["check_k3s_agent"].(string)); err != nil {
+			cmd := infra.Scripts["setup_k3s_agent"].(func(url string, tok string) string)(meta["url"], meta["token"])
+			if err := n.runCmd(cmd); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+// GetToken get token from master node
+func (n *Node) GetToken() (string, error) {
+	if n.Type != NodeTypeMaster {
+		return "", fmt.Errorf("could not get token from a non-master node")
+	}
+	var outPipe bytes.Buffer
+	if err := n.sshClient.RunCommand(infra.Scripts["get_k3s_token"].(string), ssh.CommandOptions{Stdout: bufio.NewWriter(&outPipe)}); err != nil {
+		return "", err
+	}
+	return outPipe.String(), nil
+}
+
+// State get node state
+func (n *Node) State() {}
+
+// Dump node information to json
+func (n *Node) Dump() map[string]string {
+	return map[string]string{
+		"ip":   n.IP,
+		"name": n.Name,
+		"user": n.User,
+		"type": n.Type,
+	}
+}
+
+// GetType get node type
+func (n *Node) GetType() string {
+	return n.Type
+}
+
+// GetName get node type
+func (n *Node) GetName() string {
+	return n.Name
+}
+
+// GetIP get node type
+func (n *Node) GetIP() string {
+	return n.IP
+}
+
+// GetUser get user
+func (n *Node) GetUser() string {
+	return n.User
+}
+
+// GetConfig get config
+func (n *Node) GetConfig() (string, error) {
+	if n.Type == NodeTypeMaster {
+		var outPipe bytes.Buffer
+		if err := n.sshClient.RunCommand(infra.Scripts["get_k3s_kubeconfig"].(string), ssh.CommandOptions{
+			Stdout: bufio.NewWriter(&outPipe),
+		}); err != nil {
+			return "", err
+		}
+		return string(rewriteKubeconfig(outPipe.String(), n.IP, "default")), nil
+	} else if n.Type == NodeTypeDocker {
+		data, err := json.Marshal(n.Dump())
+		if err != nil {
+			return "", err
+		}
+		return string(data), nil
+	}
+	return "", fmt.Errorf("no config for node type of %s", n.Type)
+}
+
+// NOTE only using for unit testing
+func (n *Node) setsshClient(client ssh.Clienter) {
+	n.sshClient = client
+}
+
+// NOTE the reason putting sshkey() and sshport here inside node.go is because
+// ssh key and ssh port is related to node it self, we may extend this in future
+func sshkey() (string, error) {
+	path := os.Getenv("SSH_KEY_FILE")
+	if path != "" {
+		absPath, err := filepath.Abs(path)
+		if err != nil {
+			return "", err
+		}
+		return absPath, nil
+	}
+
+	key, err := homedir.Expand("~/.ssh/id_rsa")
+	if err != nil {
+		return "", err
+	}
+	return key, nil
+}
+
+func sshport() string {
+	port := os.Getenv("SSH_PORT")
+	if port != "" {
+		return port
+	}
+	return "22"
+}
+
+func rewriteKubeconfig(kubeconfig string, ip string, context string) []byte {
+	if context == "" {
+		// nolint
+		context = "default"
+	}
+
+	kubeconfigReplacer := strings.NewReplacer(
+		"127.0.0.1", ip,
+		"localhost", ip,
+		"default", context,
+	)
+
+	return []byte(kubeconfigReplacer.Replace(kubeconfig))
+}
+
+var (
+	_ Noder = &Node{}
+)

infra/k8s/node_test.go

@@ -0,0 +1,211 @@
+package k8s
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/metrue/fx/infra"
+	"github.com/metrue/go-ssh-client"
+	sshMocks "github.com/metrue/go-ssh-client/mocks"
+	"github.com/mitchellh/go-homedir"
+)
+
+func TestGetSSHKeyFile(t *testing.T) {
+	t.Run("defaut", func(t *testing.T) {
+		defau, err := sshkey()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		defaultPath, _ := homedir.Expand("~/.ssh/id_rsa")
+		if defau != defaultPath {
+			t.Fatalf("should get %s but got %s", defaultPath, defau)
+		}
+	})
+
+	t.Run("override from env", func(t *testing.T) {
+		os.Setenv("SSH_KEY_FILE", "/tmp/id_rsa")
+		keyFile, err := sshkey()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if keyFile != "/tmp/id_rsa" {
+			t.Fatalf("should get %s but got %s", "/tmp/id_rsa", keyFile)
+		}
+	})
+}
+
+func TestGetSSHPort(t *testing.T) {
+	t.Run("defaut", func(t *testing.T) {
+		defau := sshport()
+		if defau != "22" {
+			t.Fatalf("should get %s but got %s", "22", defau)
+		}
+	})
+
+	t.Run("override from env", func(t *testing.T) {
+		os.Setenv("SSH_PORT", "2222")
+		defau := sshport()
+		if defau != "2222" {
+			t.Fatalf("should get %s but got %s", "2222", defau)
+		}
+	})
+}
+
+func TestNode(t *testing.T) {
+	t.Run("master node already has docker and k3s server", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		n, err := CreateNode("127.0.0.1", "fx", NodeTypeMaster, "master")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if n.sshClient == nil {
+			t.Fatal("ssh client should not be nil")
+		}
+
+		sshClient := sshMocks.NewMockClienter(ctrl)
+		n.setsshClient(sshClient)
+		sshClient.EXPECT().RunCommand(infra.Scripts["docker_version"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["check_k3s_server"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		if err := n.Provision(map[string]string{}); err != nil {
+			t.Fatal(err)
+		}
+	})
+	t.Run("master node no docker and k3s server", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		n, err := CreateNode("127.0.0.1", "fx", NodeTypeMaster, "master")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if n.sshClient == nil {
+			t.Fatal("ssh client should not be nil")
+		}
+
+		sshClient := sshMocks.NewMockClienter(ctrl)
+		n.setsshClient(sshClient)
+		sshClient.EXPECT().RunCommand(infra.Scripts["docker_version"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(fmt.Errorf("no such command"))
+		sshClient.EXPECT().RunCommand(infra.Scripts["install_docker"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["start_dockerd"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["check_k3s_server"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(fmt.Errorf("no such progress"))
+
+		cmd := infra.Scripts["setup_k3s_master"].(func(ip string) string)(n.IP)
+		sshClient.EXPECT().RunCommand(cmd, ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		if err := n.Provision(map[string]string{}); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	t.Run("agent node already has docker and k3s agent", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		n, err := CreateNode("127.0.0.1", "fx", NodeTypeAgent, "agent")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if n.sshClient == nil {
+			t.Fatal("ssh client should not be nil")
+		}
+
+		sshClient := sshMocks.NewMockClienter(ctrl)
+		n.setsshClient(sshClient)
+		sshClient.EXPECT().RunCommand(infra.Scripts["docker_version"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["check_k3s_agent"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		if err := n.Provision(map[string]string{}); err != nil {
+			t.Fatal(err)
+		}
+	})
+	t.Run("agent node no docker and k3s agent", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		n, err := CreateNode("127.0.0.1", "fx", NodeTypeAgent, "agent")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if n.sshClient == nil {
+			t.Fatal("ssh client should not be nil")
+		}
+
+		sshClient := sshMocks.NewMockClienter(ctrl)
+		n.setsshClient(sshClient)
+		sshClient.EXPECT().RunCommand(infra.Scripts["docker_version"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(fmt.Errorf("no such command"))
+		sshClient.EXPECT().RunCommand(infra.Scripts["install_docker"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["start_dockerd"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		sshClient.EXPECT().RunCommand(infra.Scripts["check_k3s_agent"].(string), ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(fmt.Errorf("no such progress"))
+
+		url := "url-1"
+		token := "token-1"
+		cmd := infra.Scripts["setup_k3s_agent"].(func(url string, ip string) string)(url, token)
+		sshClient.EXPECT().RunCommand(cmd, ssh.CommandOptions{
+			Stdout: os.Stdout,
+			Stdin:  os.Stdin,
+			Stderr: os.Stderr,
+		}).Return(nil)
+		if err := n.Provision(map[string]string{"url": url, "token": token}); err != nil {
+			t.Fatal(err)
+		}
+	})
+}

infra/k8s/provisioner.go

@@ -1,154 +0,0 @@
-package k8s
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/metrue/fx/infra"
-	sshOperator "github.com/metrue/go-ssh-client"
-)
-
-// MasterNode master node instance
-type MasterNode struct {
-	IP   string
-	User string
-}
-
-// AgentNode agent node instance
-type AgentNode struct {
-	IP   string
-	User string
-}
-
-// Provisioner k3s operator
-type Provisioner struct {
-	master MasterNode
-	agents []AgentNode
-}
-
-// TODO upgrade to latest when k3s fix the tls scan issue
-// https://github.com/rancher/k3s/issues/556
-const version = "v0.9.1"
-
-// New new a operator
-func New(master MasterNode, agents []AgentNode) *Provisioner {
-	return &Provisioner{
-		master: master,
-		agents: agents,
-	}
-}
-
-// Provision provision k3s cluster
-func (k *Provisioner) Provision() ([]byte, error) {
-	if err := k.SetupMaster(); err != nil {
-		return nil, err
-	}
-	if err := k.SetupAgent(); err != nil {
-		return nil, err
-	}
-	return k.GetKubeConfig()
-}
-
-// HealthCheck check healthy status of host
-func (k *Provisioner) HealthCheck() (bool, error) {
-	// TODO
-	return true, nil
-}
-
-// SetupMaster setup master node
-func (k *Provisioner) SetupMaster() error {
-	sshKeyFile, _ := infra.GetSSHKeyFile()
-	ssh := sshOperator.New(k.master.IP).WithUser(k.master.User).WithKey(sshKeyFile)
-	installCmd := fmt.Sprintf("curl -sLS https://get.k3s.io | INSTALL_K3S_EXEC='server --docker --tls-san %s' INSTALL_K3S_VERSION='%s' sh -", k.master.IP, version)
-	if err := ssh.RunCommand(infra.Sudo(installCmd, k.master.User), sshOperator.CommandOptions{
-		Stdout: os.Stdout,
-		Stdin:  os.Stdin,
-		Stderr: os.Stderr,
-	}); err != nil {
-		fmt.Println("setup master failed \n ===========")
-		fmt.Println(err)
-		fmt.Println("===========")
-	}
-	return nil
-}
-
-func (k *Provisioner) getToken() (string, error) {
-	sshKeyFile, _ := infra.GetSSHKeyFile()
-	ssh := sshOperator.New(k.master.IP).WithUser(k.master.User).WithKey(sshKeyFile)
-	script := "cat /var/lib/rancher/k3s/server/node-token"
-	var outPipe bytes.Buffer
-	if err := ssh.RunCommand(infra.Sudo(script, k.master.User), sshOperator.CommandOptions{
-		Stdout: bufio.NewWriter(&outPipe),
-		Stdin:  os.Stdin,
-		Stderr: os.Stderr,
-	}); err != nil {
-		return "", err
-	}
-	return outPipe.String(), nil
-}
-
-// SetupAgent set agent node
-func (k *Provisioner) SetupAgent() error {
-	sshKeyFile, _ := infra.GetSSHKeyFile()
-	tok, err := k.getToken()
-	if err != nil {
-		return err
-	}
-	const k3sExtraArgs = "--docker"
-	joinCmd := fmt.Sprintf("curl -fL https://get.k3s.io/ | K3S_URL='https://%s:6443' K3S_TOKEN='%s' INSTALL_K3S_VERSION='%s' sh -s - %s", k.master.IP, tok, version, k3sExtraArgs)
-	for _, agent := range k.agents {
-		ssh := sshOperator.New(agent.IP).WithUser(agent.User).WithKey(sshKeyFile)
-		if err := ssh.RunCommand(joinCmd, sshOperator.CommandOptions{
-			Stdout: os.Stdout,
-			Stdin:  os.Stdin,
-			Stderr: os.Stderr,
-		}); err != nil {
-			fmt.Println("setup agent failed \n================")
-			fmt.Println(err)
-			fmt.Println("================")
-			return err
-		}
-	}
-
-	return nil
-}
-
-// GetKubeConfig get kubeconfig of k3s cluster
-func (k *Provisioner) GetKubeConfig() ([]byte, error) {
-	sshKeyFile, _ := infra.GetSSHKeyFile()
-	var config []byte
-	getConfigCmd := "cat /etc/rancher/k3s/k3s.yaml\n"
-	ssh := sshOperator.New(k.master.IP).WithUser(k.master.User).WithKey(sshKeyFile)
-	var outPipe bytes.Buffer
-	if err := ssh.RunCommand(infra.Sudo(getConfigCmd, k.master.User), sshOperator.CommandOptions{
-		Stdout: bufio.NewWriter(&outPipe),
-		Stdin:  os.Stdin,
-		Stderr: os.Stderr,
-	}); err != nil {
-		fmt.Println("setup agent failed \n================")
-		fmt.Println("================")
-		fmt.Println(err)
-		return config, err
-	}
-	return rewriteKubeconfig(outPipe.String(), k.master.IP, "default"), nil
-}
-
-func rewriteKubeconfig(kubeconfig string, ip string, context string) []byte {
-	if context == "" {
-		// nolint
-		context = "default"
-	}
-
-	kubeconfigReplacer := strings.NewReplacer(
-		"127.0.0.1", ip,
-		"localhost", ip,
-		"default", context,
-	)
-
-	return []byte(kubeconfigReplacer.Replace(kubeconfig))
-}
-
-var _ infra.Provisioner = &Provisioner{}

infra/k8s/provisioner_test.go

@@ -1,45 +0,0 @@
-package k8s
-
-import (
-	"fmt"
-	"os"
-	"testing"
-)
-
-func TestProvisioner(t *testing.T) {
-	if os.Getenv("K3S_MASTER_IP") == "" ||
-		os.Getenv("K3S_MASTER_USER") == "" ||
-		os.Getenv("K3S_AGENT_IP") == "" ||
-		os.Getenv("K3S_AGENT_USER") == "" {
-		t.Skip("skip k3s test since K3S_MASTER_IP, K3S_MASTER_USER and K3S_AGENT_IP, K3S_AGENT_USER not ready")
-	}
-
-	master := MasterNode{
-		IP:   os.Getenv("K3S_MASTER_IP"),
-		User: os.Getenv("K3S_MASTER_USER"),
-	}
-	agents := []AgentNode{
-		AgentNode{
-			IP:   os.Getenv("K3S_AGENT_IP"),
-			User: os.Getenv("K3S_AGENT_USER"),
-		},
-	}
-	k3s := New(master, agents)
-	if err := k3s.SetupMaster(); err != nil {
-		t.Fatal(err)
-	}
-
-	kubeconfig, err := k3s.GetKubeConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	fmt.Println(string(kubeconfig))
-
-	if _, err := k3s.getToken(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := k3s.SetupAgent(); err != nil {
-		t.Fatal(err)
-	}
-}

infra/scripts.go

@@ -0,0 +1,28 @@
+package infra
+
+import (
+	"fmt"
+)
+
+// TODO upgrade to latest when k3s fix the tls scan issue
+// https://github.com/rancher/k3s/issues/556
+const k3sVersion = "v0.9.1"
+
+// Scripts to provision host
+var Scripts = map[string]interface{}{
+	"docker_version":   "docker version",
+	"install_docker":   "curl -fsSL https://download.docker.com/linux/static/stable/x86_64/docker-18.06.3-ce.tgz -o docker.tgz && tar zxvf docker.tgz && mv docker/* /usr/bin && rm -rf docker docker.tgz",
+	"start_dockerd":    "dockerd >/dev/null 2>&1 & sleep 2",
+	"check_fx_agent":   "docker inspect fx-agent",
+	"start_fx_agent":   "docker run -d --name=fx-agent --rm -v /var/run/docker.sock:/var/run/docker.sock -p 0.0.0.0:8866:1234 bobrik/socat TCP-LISTEN:1234,fork UNIX-CONNECT:/var/run/docker.sock",
+	"check_k3s_server": "ps aux | grep 'k3s server --docker'",
+	"setup_k3s_master": func(ip string) string {
+		return fmt.Sprintf("curl -sLS https://get.k3s.io | INSTALL_K3S_EXEC='server --docker --tls-san %s' INSTALL_K3S_VERSION='%s' sh -", ip, k3sVersion)
+	},
+	"check_k3s_agent": "ps aux | grep 'k3s agent --docker'",
+	"setup_k3s_agent": func(masterURL string, tok string) string {
+		return fmt.Sprintf("curl -fL https://get.k3s.io/ | K3S_URL='%s' K3S_TOKEN='%s' INSTALL_K3S_VERSION='%s' sh -s - --docker", masterURL, tok, k3sVersion)
+	},
+	"get_k3s_token":      "cat /var/lib/rancher/k3s/server/node-token",
+	"get_k3s_kubeconfig": "cat /etc/rancher/k3s/k3s.yaml",
+}

infra/ssh.go

@@ -1,35 +0,0 @@
-package infra
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/mitchellh/go-homedir"
-)
-
-// GetSSHKeyFile get ssh private key file
-func GetSSHKeyFile() (string, error) {
-	path := os.Getenv("SSH_KEY_FILE")
-	if path != "" {
-		absPath, err := filepath.Abs(path)
-		if err != nil {
-			return "", err
-		}
-		return absPath, nil
-	}
-
-	key, err := homedir.Expand("~/.ssh/id_rsa")
-	if err != nil {
-		return "", err
-	}
-	return key, nil
-}
-
-// GetSSHPort get ssh port
-func GetSSHPort() string {
-	port := os.Getenv("SSH_PORT")
-	if port != "" {
-		return port
-	}
-	return "22"
-}

infra/ssh_test.go

@@ -1,50 +0,0 @@
-package infra
-
-import (
-	"os"
-	"testing"
-
-	"github.com/mitchellh/go-homedir"
-)
-
-func TestGetSSHKeyFile(t *testing.T) {
-	t.Run("defaut", func(t *testing.T) {
-		defau, err := GetSSHKeyFile()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		defaultPath, _ := homedir.Expand("~/.ssh/id_rsa")
-		if defau != defaultPath {
-			t.Fatalf("should get %s but got %s", defaultPath, defau)
-		}
-	})
-
-	t.Run("override from env", func(t *testing.T) {
-		os.Setenv("SSH_KEY_FILE", "/tmp/id_rsa")
-		keyFile, err := GetSSHKeyFile()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if keyFile != "/tmp/id_rsa" {
-			t.Fatalf("should get %s but got %s", "/tmp/id_rsa", keyFile)
-		}
-	})
-}
-
-func TestGetSSHPort(t *testing.T) {
-	t.Run("defaut", func(t *testing.T) {
-		defau := GetSSHPort()
-		if defau != "22" {
-			t.Fatalf("should get %s but got %s", "22", defau)
-		}
-	})
-
-	t.Run("override from env", func(t *testing.T) {
-		os.Setenv("SSH_PORT", "2222")
-		defau := GetSSHPort()
-		if defau != "2222" {
-			t.Fatalf("should get %s but got %s", "2222", defau)
-		}
-	})
-}

middlewares/build.go

@@ -5,11 +5,11 @@ import (
 	"os"
 	"time"
 
-	"github.com/metrue/fx/config"
 	containerruntimes "github.com/metrue/fx/container_runtimes"
 	"github.com/metrue/fx/context"
 	"github.com/metrue/fx/packer"
 	"github.com/metrue/fx/pkg/spinner"
+	"github.com/metrue/fx/types"
 	"github.com/metrue/fx/utils"
 	"github.com/otiai10/copy"
 )
@@ -55,7 +55,7 @@ func Build(ctx context.Contexter) (err error) {
 
 	cloudType := ctx.Get("cloud_type").(string)
 	name := ctx.Get("name").(string)
-	if cloudType == config.CloudTypeK8S && os.Getenv("K3S") == "" {
+	if cloudType == types.CloudTypeK8S {
 		data, err := packer.PackIntoK8SConfigMapFile(workdir)
 		if err != nil {
 			return err
@@ -72,17 +72,6 @@ func Build(ctx context.Contexter) (err error) {
 			return err
 		}
 		ctx.Set("image", nameWithTag)
-
-		if os.Getenv("K3S") != "" {
-			username := os.Getenv("DOCKER_USERNAME")
-			password := os.Getenv("DOCKER_PASSWORD")
-			if username != "" && password != "" {
-				if _, err := docker.PushImage(ctx.GetContext(), name); err != nil {
-					return err
-				}
-				ctx.Set("image", username+"/"+name)
-			}
-		}
 	}
 
 	return nil

middlewares/provision.go

@@ -1,6 +1,7 @@
 package middlewares
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
 
@@ -11,34 +12,52 @@ import (
 	"github.com/metrue/fx/infra"
 	dockerInfra "github.com/metrue/fx/infra/docker"
 	k8sInfra "github.com/metrue/fx/infra/k8s"
+	"github.com/metrue/fx/types"
 	"github.com/pkg/errors"
 )
 
 // Provision make sure infrastructure is healthy
 func Provision(ctx context.Contexter) (err error) {
 	fxConfig := ctx.Get("config").(*config.Config)
-	cloud := fxConfig.Clouds[fxConfig.CurrentCloud]
+	meta, err := fxConfig.GetCurrentCloud()
+	if err != nil {
+		return err
+	}
+	cloudType, err := fxConfig.GetCurrentCloudType()
+	if err != nil {
+		return err
+	}
 
+	ctx.Set("cloud_type", cloudType)
+	var cloud infra.Clouder
+	switch cloudType {
+	case types.CloudTypeK8S:
+		cloud, err = k8sInfra.Load(meta)
+	case types.CloudTypeDocker:
+		cloud, err = dockerInfra.Load(meta)
+	}
+	if err != nil {
+		return err
+	}
+	ctx.Set("cloud", cloud)
+
+	conf, err := cloud.GetConfig()
+	if err != nil {
+		return err
+	}
 	var deployer infra.Deployer
 	if os.Getenv("KUBECONFIG") != "" {
 		deployer, err = k8sInfra.CreateDeployer(os.Getenv("KUBECONFIG"))
 		if err != nil {
 			return err
 		}
-		ctx.Set("cloud_type", config.CloudTypeK8S)
-	} else if cloud["type"] == config.CloudTypeDocker {
-		provisioner := dockerInfra.CreateProvisioner(cloud["host"], cloud["user"])
-		ok, err := provisioner.HealthCheck()
-		if err != nil {
+		ctx.Set("cloud_type", types.CloudTypeK8S)
+	} else if cloud.GetType() == types.CloudTypeDocker {
+		var meta map[string]string
+		if err := json.Unmarshal([]byte(conf), &meta); err != nil {
 			return err
 		}
-		if !ok {
-			if _, err := provisioner.Provision(); err != nil {
-				return err
-			}
-		}
-
-		docker, err := dockerHTTP.Create(cloud["host"], constants.AgentPort)
+		docker, err := dockerHTTP.Create(meta["ip"], constants.AgentPort)
 		if err != nil {
 			return errors.Wrapf(err, "please make sure docker is installed and running on your host")
 		}
@@ -49,15 +68,17 @@ func Provision(ctx context.Contexter) (err error) {
 		if err != nil {
 			return err
 		}
-		ctx.Set("cloud_type", config.CloudTypeDocker)
-	} else if cloud["type"] == config.CloudTypeK8S {
-		deployer, err = k8sInfra.CreateDeployer(cloud["kubeconfig"])
+	} else if cloud.GetType() == types.CloudTypeK8S {
+		kubeconfig, err := fxConfig.GetKubeConfig()
+		if err != nil {
+			return err
+		}
+		deployer, err = k8sInfra.CreateDeployer(kubeconfig)
 		if err != nil {
 			return err
 		}
-		ctx.Set("cloud_type", config.CloudTypeK8S)
 	} else {
-		return fmt.Errorf("unsupport cloud type %s, please make sure you config is correct", cloud["type"])
+		return fmt.Errorf("unsupport cloud type %s, please make sure you config is correct", cloud.GetType())
 	}
 
 	ctx.Set("deployer", deployer)

types/cloud.go

@@ -0,0 +1,7 @@
+package types
+
+// CloudTypeDocker docker cloud type
+const CloudTypeDocker = "docker"
+
+// CloudTypeK8S k8s cloud type
+const CloudTypeK8S = "k8s"