feat: add and delete master or worker nodes with different ssh settings

cmd/sealos/cmd/add.go

@@ -30,20 +30,25 @@ add to nodes :
 add to default cluster:
 	sealos add --masters x.x.x.x --nodes x.x.x.x
 	sealos add --masters x.x.x.x-x.x.x.y --nodes x.x.x.x-x.x.x.y
+
+add with different ssh setting:
+	sealos add --masters x.x.x.x --nodes x.x.x.x --passwd your_diff_passwd
+Please note that the masters and nodes added in one command should have the save password.
 `
 
-// addCmd represents the delete command
+// addCmd represents the add command
 func newAddCmd() *cobra.Command {
 	addArgs := &apply.ScaleArgs{
 		Cluster: &apply.Cluster{},
+		SSH:     &apply.SSH{},
 	}
 	var addCmd = &cobra.Command{
 		Use:     "add",
 		Short:   "Add nodes into cluster",
 		Args:    cobra.NoArgs,
 		Example: exampleAdd,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			applier, err := apply.NewScaleApplierFromArgs(addArgs, "add")
+			applier, err := apply.NewScaleApplierFromArgs(cmd, addArgs)
 			if err != nil {
 				return err
 			}

cmd/sealos/cmd/delete.go

@@ -55,7 +55,7 @@ func newDeleteCmd() *cobra.Command {
 			if err := processor.ConfirmDeleteNodes(); err != nil {
 				return err
 			}
-			applier, err := apply.NewScaleApplierFromArgs(deleteArgs, "delete")
+			applier, err := apply.NewScaleApplierFromArgs(cmd, deleteArgs)
 			if err != nil {
 				return err
 			}

pkg/apply/args.go

@@ -100,8 +100,13 @@ func (arg *ResetArgs) RegisterFlags(fs *pflag.FlagSet) {
 
 type ScaleArgs struct {
 	*Cluster
+	*SSH
 }
 
 func (arg *ScaleArgs) RegisterFlags(fs *pflag.FlagSet, verb, action string) {
 	arg.Cluster.RegisterFlags(fs, verb, action)
+	// delete cmd does not support setting ssh, it reads from clusterfile
+	if arg.SSH != nil {
+		arg.SSH.RegisterFlags(fs)
+	}
 }

pkg/apply/args_test.go

@@ -213,12 +213,15 @@ func TestParseScaleArgsFlagsCorrect(t *testing.T) {
 		{
 			[]string{
 				"--masters", "10.74.22.22:22", "--nodes", "10.74.22.44:22", "--cluster", "default",
+				"-u", "root", "-p", "passwd", "--port", "22",
 			},
 			&ScaleArgs{
 				Cluster: &Cluster{},
+				SSH:     &SSH{},
 			},
 			&ScaleArgs{
 				Cluster: &Cluster{Masters: "10.74.22.22:22", Nodes: "10.74.22.44:22", ClusterName: "default"},
+				SSH:     &SSH{User: "root", Password: "passwd", Port: 22, Pk: path.Join(constants.GetHomeDir(), ".ssh", "id_rsa")},
 			},
 		},
 	}

pkg/apply/processor/delete.go

@@ -74,7 +74,7 @@ func (d *DeleteProcessor) PreProcess(cluster *v2.Cluster) error {
 func (d *DeleteProcessor) UndoBootstrap(cluster *v2.Cluster) error {
 	logger.Info("Executing pipeline Bootstrap in DeleteProcessor")
 	hosts := append(cluster.GetMasterIPAndPortList(), cluster.GetNodeIPAndPortList()...)
-	bs := bootstrap.New(cluster)
+	bs := bootstrap.New(d.ClusterFile.GetCluster())
 	return bs.Delete(hosts...)
 }
 
@@ -96,7 +96,7 @@ func (d *DeleteProcessor) UnMountRootfs(cluster *v2.Cluster) error {
 	if err != nil {
 		return err
 	}
-	return fs.UnMountRootfs(cluster, hosts)
+	return fs.UnMountRootfs(d.ClusterFile.GetCluster(), hosts)
 }
 
 func (d *DeleteProcessor) UnMountImage(cluster *v2.Cluster) error {

pkg/apply/processor/scale.go

@@ -131,7 +131,7 @@ func (c ScaleProcessor) UnMountRootfs(cluster *v2.Cluster) error {
 	if err != nil {
 		return err
 	}
-	return fs.UnMountRootfs(cluster, hosts)
+	return fs.UnMountRootfs(c.ClusterFile.GetCluster(), hosts)
 }
 
 func (c *ScaleProcessor) JoinCheck(cluster *v2.Cluster) error {
@@ -184,11 +184,16 @@ func (c *ScaleProcessor) preProcess(cluster *v2.Cluster) error {
 	if err = SyncClusterStatus(cluster, c.Buildah, false); err != nil {
 		return err
 	}
-	runTime, err := runtime.NewDefaultRuntime(cluster, c.ClusterFile.GetKubeadmConfig())
+	var rt runtime.Interface
+	if c.IsScaleUp {
+		rt, err = runtime.NewDefaultRuntimeWithCurrentCluster(cluster, c.ClusterFile.GetKubeadmConfig())
+	} else {
+		rt, err = runtime.NewDefaultRuntimeWithCurrentCluster(c.ClusterFile.GetCluster(), c.ClusterFile.GetKubeadmConfig())
+	}
 	if err != nil {
 		return fmt.Errorf("failed to init runtime: %v", err)
 	}
-	c.Runtime = runTime
+	c.Runtime = rt
 
 	return err
 }
@@ -258,10 +263,10 @@ func (c *ScaleProcessor) Bootstrap(cluster *v2.Cluster) error {
 	return bs.Apply(hosts...)
 }
 
-func (c *ScaleProcessor) UndoBootstrap(cluster *v2.Cluster) error {
+func (c *ScaleProcessor) UndoBootstrap(_ *v2.Cluster) error {
 	logger.Info("Executing pipeline UndoBootstrap in ScaleProcessor")
 	hosts := append(c.MastersToDelete, c.NodesToDelete...)
-	bs := bootstrap.New(cluster)
+	bs := bootstrap.New(c.ClusterFile.GetCluster())
 	return bs.Delete(hosts...)
 }
 

pkg/apply/scale.go

@@ -20,44 +20,44 @@
 	"strconv"
 	"strings"
 
-	"github.com/labring/sealos/pkg/constants"
-	"github.com/labring/sealos/pkg/ssh"
-	fileutil "github.com/labring/sealos/pkg/utils/file"
-	"github.com/labring/sealos/pkg/utils/iputils"
-	strings2 "github.com/labring/sealos/pkg/utils/strings"
-
+	"github.com/spf13/cobra"
 	"k8s.io/apimachinery/pkg/util/sets"
 
 	"github.com/labring/sealos/pkg/apply/applydrivers"
 	"github.com/labring/sealos/pkg/clusterfile"
+	"github.com/labring/sealos/pkg/constants"
+	"github.com/labring/sealos/pkg/ssh"
 	v2 "github.com/labring/sealos/pkg/types/v1beta1"
+	fileutil "github.com/labring/sealos/pkg/utils/file"
+	"github.com/labring/sealos/pkg/utils/iputils"
+	strings2 "github.com/labring/sealos/pkg/utils/strings"
 )
 
 // NewScaleApplierFromArgs will filter ip list from command parameters.
-func NewScaleApplierFromArgs(scaleArgs *ScaleArgs, flag string) (applydrivers.Interface, error) {
+func NewScaleApplierFromArgs(cmd *cobra.Command, scaleArgs *ScaleArgs) (applydrivers.Interface, error) {
 	var cluster *v2.Cluster
-	var curr *v2.Cluster
 	clusterPath := constants.Clusterfile(scaleArgs.Cluster.ClusterName)
+
 	if !fileutil.IsExist(clusterPath) {
 		cluster = initCluster(scaleArgs.Cluster.ClusterName)
-		curr = cluster
 	} else {
 		clusterFile := clusterfile.NewClusterFile(clusterPath)
 		err := clusterFile.Process()
 		if err != nil {
 			return nil, err
 		}
 		cluster = clusterFile.GetCluster()
-		curr = clusterFile.GetCluster().DeepCopy()
 	}
 
+	curr := cluster.DeepCopy()
+
 	if scaleArgs.Cluster.Nodes == "" && scaleArgs.Cluster.Masters == "" {
 		return nil, fmt.Errorf("the node or master parameter was not committed")
 	}
 	var err error
-	switch flag {
+	switch cmd.Name() {
 	case "add":
-		err = Join(cluster, scaleArgs)
+		err = verifyAndSetNodes(cmd, cluster, scaleArgs)
 	case "delete":
 		err = Delete(cluster, scaleArgs)
 	}
@@ -68,14 +68,52 @@
 	return applydrivers.NewDefaultScaleApplier(curr, cluster)
 }
 
-func Join(cluster *v2.Cluster, scalingArgs *ScaleArgs) error {
-	return joinNodes(cluster, scalingArgs)
+func getSSHFromCommand(cmd *cobra.Command) *v2.SSH {
+	var (
+		ret     = &v2.SSH{}
+		fs      = cmd.Flags()
+		changed bool
+	)
+	if flagChanged(cmd, "user") {
+		ret.User, _ = fs.GetString("user")
+		changed = true
+	}
+	if flagChanged(cmd, "passwd") {
+		ret.Passwd, _ = fs.GetString("passwd")
+		changed = true
+	}
+	if flagChanged(cmd, "pk") {
+		ret.Pk, _ = fs.GetString("pk")
+		changed = true
+	}
+	if flagChanged(cmd, "pk-passwd") {
+		ret.PkPasswd, _ = fs.GetString("pk-passwd")
+		changed = true
+	}
+	if flagChanged(cmd, "port") {
+		ret.Port, _ = fs.GetUint16("port")
+		changed = true
+	}
+	if changed {
+		return ret
+	}
+	return nil
+}
+
+func flagChanged(cmd *cobra.Command, name string) bool {
+	if cmd != nil {
+		if fs := cmd.Flag(name); fs != nil && fs.Changed {
+			return true
+		}
+	}
+	return false
 }
 
-func joinNodes(cluster *v2.Cluster, scaleArgs *ScaleArgs) error {
+func verifyAndSetNodes(cmd *cobra.Command, cluster *v2.Cluster, scaleArgs *ScaleArgs) error {
 	if err := PreProcessIPList(scaleArgs.Cluster); err != nil {
 		return err
 	}
+
 	masters, nodes := scaleArgs.Cluster.Masters, scaleArgs.Cluster.Nodes
 	if len(masters) > 0 {
 		if err := validateIPList(masters); err != nil {
@@ -94,7 +132,7 @@
 	var hasMaster bool
 	// check duplicate
 	alreadyIn := sets.NewString()
-	// add already add masters and nodes
+	// add already joined masters and nodes
 	for i := range cluster.Spec.Hosts {
 		h := cluster.Spec.Hosts[i]
 		if strings2.InList(v2.MASTER, h.Roles) {
@@ -106,11 +144,14 @@
 			IPS:   ips,
 			Roles: h.Roles,
 			Env:   h.Env,
+			SSH:   h.SSH,
 		})
 	}
 	if !hasMaster {
 		return fmt.Errorf("`master` role not found, due to Clusterfile may have been corrupted?")
 	}
+	override := getSSHFromCommand(cmd)
+
 	getHostFunc := func(sliceStr string, role string, exclude []string) (*v2.Host, error) {
 		ss := strings.Split(sliceStr, ",")
 		addrs := make([]string, 0)
@@ -128,13 +169,19 @@
 			}
 		}
 		if len(addrs) > 0 {
-			clusterSSH := cluster.GetSSH()
-			sshClient := ssh.NewSSHClient(&clusterSSH, true)
+			global := cluster.Spec.SSH.DeepCopy()
+			ssh.OverSSHConfig(global, override)
 
-			return &v2.Host{
+			sshClient := ssh.NewSSHClient(global, true)
+
+			host := &v2.Host{
 				IPS:   addrs,
 				Roles: []string{role, GetHostArch(sshClient, addrs[0])},
-			}, nil
+			}
+			if override != nil {
+				host.SSH = override
+			}
+			return host, nil
 		}
 		return nil, nil
 	}