Feature/support ipv6 dual

Makefile

@@ -28,6 +28,7 @@ build: clean ## build binaries by default
 linux: clean ## build binaries for linux
 	@echo "build sealer and seautil bin for linux"
 	GOOS=linux GOARCH=amd64 hack/build.sh $(GitTag)
+	GOOS=linux GOARCH=arm64 hack/build.sh $(GitTag)
 
 test-sealer:
 	@echo "run e2e test for sealer bin"

apply/apply.go

@@ -16,16 +16,21 @@ package apply
 
 import (
 	"fmt"
+	"net"
 	"os"
 	"path/filepath"
 
+	k8snet "k8s.io/utils/net"
+
 	"github.com/sealerio/sealer/apply/applydriver"
 	"github.com/sealerio/sealer/common"
 	"github.com/sealerio/sealer/pkg/clusterfile"
+	"github.com/sealerio/sealer/pkg/env"
 	"github.com/sealerio/sealer/pkg/filesystem"
 	"github.com/sealerio/sealer/pkg/image"
 	"github.com/sealerio/sealer/pkg/image/store"
 	v2 "github.com/sealerio/sealer/types/api/v2"
+	"github.com/sealerio/sealer/utils"
 )
 
 type Args struct {
@@ -37,6 +42,9 @@ type Args struct {
 	Masters string
 	Nodes   string
 
+	MasterSlice []string
+	NodeSlice   []string
+
 	User       string
 	Password   string
 	Port       uint16
@@ -49,7 +57,7 @@ type Args struct {
 	CMDArgs    []string
 }
 
-func NewApplierFromFile(path string) (applydriver.Interface, error) {
+func NewApplierFromFile(path, action string) (applydriver.Interface, error) {
 	if !filepath.IsAbs(path) {
 		pa, err := os.Getwd()
 		if err != nil {
@@ -61,44 +69,19 @@ func NewApplierFromFile(path string) (applydriver.Interface, error) {
 	if err != nil {
 		return nil, err
 	}
-	imgSvc, err := image.NewImageService()
-	if err != nil {
-		return nil, err
-	}
-
-	mounter, err := filesystem.NewClusterImageMounter()
-	if err != nil {
-		return nil, err
-	}
 
-	is, err := store.NewDefaultImageStore()
-	if err != nil {
-		return nil, err
-	}
 	cluster := Clusterfile.GetCluster()
-	if cluster.Name == "" {
-		return nil, fmt.Errorf("cluster name cannot be empty, make sure %s file is correct", path)
-	}
 	if cluster.GetAnnotationsByKey(common.ClusterfileName) == "" {
 		cluster.SetAnnotations(common.ClusterfileName, path)
 	}
-	return &applydriver.Applier{
-		ClusterDesired:      &cluster,
-		ClusterFile:         Clusterfile,
-		ImageManager:        imgSvc,
-		ClusterImageMounter: mounter,
-		ImageStore:          is,
-	}, nil
-}
 
-// NewApplier news an applier.
-// In NewApplier, we guarantee that no raw data could be passed in.
-// And all data has to be validated and processed in the pre-process layer.
-func NewApplier(cluster *v2.Cluster) (applydriver.Interface, error) {
-	return NewDefaultApplier(cluster)
+	return NewDefaultApplier(&cluster, action, Clusterfile)
 }
 
-func NewDefaultApplier(cluster *v2.Cluster) (applydriver.Interface, error) {
+// NewDefaultApplier news an applier.
+// In NewDefaultApplier, we guarantee that no raw data could be passed in.
+// And all data has to be validated and processed in the pre-process layer.
+func NewDefaultApplier(cluster *v2.Cluster, action string, file clusterfile.Interface) (applydriver.Interface, error) {
 	if cluster.Name == "" {
 		return nil, fmt.Errorf("cluster name cannot be empty")
 	}
@@ -117,10 +100,44 @@ func NewDefaultApplier(cluster *v2.Cluster) (applydriver.Interface, error) {
 		return nil, err
 	}
 
+	hostList := utils.GetIPListFromHosts(cluster.Spec.Hosts)
+
+	if err := checkAllHostsSameFamily(hostList); err != nil {
+		return nil, err
+	}
+
+	if len(hostList) > 0 && k8snet.IsIPv6String(hostList[0]) &&
+		env.ConvertEnv(cluster.Spec.Env)[v2.EnvHostIPFamily] == nil {
+		cluster.Spec.Env = append(cluster.Spec.Env, fmt.Sprintf("%s=%s", v2.EnvHostIPFamily, k8snet.IPv6))
+	}
+
 	return &applydriver.Applier{
 		ClusterDesired:      cluster,
+		ClusterFile:         file,
 		ImageManager:        imgSvc,
 		ClusterImageMounter: mounter,
 		ImageStore:          is,
 	}, nil
 }
+
+func checkAllHostsSameFamily(nodeList []string) error {
+	hasIPv4 := false
+	hasIPv6 := false
+	for _, ip := range nodeList {
+		parsed := net.ParseIP(ip)
+		if parsed == nil {
+			return fmt.Errorf("failed to parse %s as a valid ip", ip)
+		}
+		if k8snet.IsIPv4(parsed) {
+			hasIPv4 = true
+		} else if k8snet.IsIPv6(parsed) {
+			hasIPv6 = true
+		}
+	}
+
+	if hasBoth := hasIPv4 && hasIPv6; hasBoth {
+		return fmt.Errorf("all hosts must be in same ip family, but the node list given are mixed with ipv4 and ipv6: %v", nodeList)
+	}
+
+	return nil
+}

apply/applydriver/interface.go

@@ -15,7 +15,32 @@
 package applydriver
 
 type Interface interface {
-	Apply() error
+	Apply(args *Args) error
 	Delete() error
 	Upgrade(imageName string) error
 }
+
+type Action string
+
+const (
+	ActionJoin   = "Join"
+	ActionDelete = "Delete"
+	ActionRun    = "Run"
+	ActionApply  = "Apply"
+)
+
+type Args struct {
+	Action       Action
+	JoiningArgs  *JoiningArgs
+	DeletingArgs *DeletingArgs
+}
+
+type DeletingArgs struct {
+	MastersToDelete []string
+	WorkersToDelete []string
+}
+
+type JoiningArgs struct {
+	MastersToJoin []string
+	WorkersToJoin []string
+}

apply/applydriver/local.go

@@ -58,7 +58,10 @@ func (c *Applier) Delete() (err error) {
 }
 
 // Apply different actions between ClusterDesired and ClusterCurrent.
-func (c *Applier) Apply() (err error) {
+func (c *Applier) Apply(args *Args) (err error) {
+	if args == nil {
+		return fmt.Errorf("args can't be empty")
+	}
 	// first time to init cluster
 	if c.ClusterFile == nil {
 		c.ClusterFile, err = clusterfile.NewClusterFile(c.ClusterDesired.GetAnnotationsByKey(common.ClusterfileName))
@@ -71,7 +74,10 @@ func (c *Applier) Apply() (err error) {
 			return err
 		}
 	} else {
-		if err = c.reconcileCluster(); err != nil {
+		if args.Action == ActionRun {
+			return fmt.Errorf("sealer run can only be use for init a new cluster, but we find a cluster is already existing")
+		}
+		if err = c.reconcileCluster(args); err != nil {
 			return err
 		}
 	}
@@ -117,7 +123,8 @@ func (c *Applier) unMountClusterImage() error {
 	return c.ClusterImageMounter.UnMountImage(c.ClusterDesired)
 }
 
-func (c *Applier) reconcileCluster() error {
+// only ActionJoin/ActionDelete/ActionApply will into this func
+func (c *Applier) reconcileCluster(args *Args) error {
 	client, err := k8s.Newk8sClient()
 	if err != nil {
 		return err
@@ -153,9 +160,24 @@ func (c *Applier) reconcileCluster() error {
 
 	mj, md := strings.Diff(c.ClusterCurrent.GetMasterIPList(), c.ClusterDesired.GetMasterIPList())
 	nj, nd := strings.Diff(c.ClusterCurrent.GetNodeIPList(), c.ClusterDesired.GetNodeIPList())
+
+	switch args.Action {
+	case ActionJoin:
+		if len(md) > 0 || len(nd) > 0 {
+			logrus.Warnf(`we found these master(%v) or node(%v) are in cluster but not in you Kubefile, we will do nothing for them.`, md, nd)
+		}
+		return c.scaleCluster(args.JoiningArgs.MastersToJoin, nil, args.JoiningArgs.WorkersToJoin, nil)
+	case ActionDelete:
+		if len(mj) > 0 || len(nj) > 0 {
+			logrus.Warnf(`we found these master(%v) or node(%v) are not in cluster but in you Kubefile, we will do nothing for them.`, mj, nj)
+		}
+		return c.scaleCluster(nil, args.DeletingArgs.MastersToDelete, nil, args.DeletingArgs.WorkersToDelete)
+	}
+
 	if len(mj) == 0 && len(md) == 0 && len(nj) == 0 && len(nd) == 0 {
 		return c.upgrade()
 	}
+
 	return c.scaleCluster(mj, md, nj, nd)
 }
 

apply/processor/create.go

@@ -104,6 +104,9 @@ func (c *CreateProcessor) RunConfig(cluster *v2.Cluster) error {
 }
 
 func (c *CreateProcessor) MountRootfs(cluster *v2.Cluster) error {
+	if cluster.Annotations["skip-mount"] == "true" {
+		return nil
+	}
 	hosts := append(cluster.GetMasterIPList(), cluster.GetNodeIPList()...)
 	regConfig := runtime.GetRegistryConfig(platform.DefaultMountClusterImageDir(cluster.Name), cluster.GetMaster0IP())
 	if net.NotInIPList(regConfig.IP, hosts) {

apply/processor/scale.go

@@ -103,6 +103,9 @@ func (s *ScaleProcessor) RunConfig(cluster *v2.Cluster) error {
 }
 
 func (s *ScaleProcessor) MountRootfs(cluster *v2.Cluster) error {
+	if cluster.Annotations["skip-mount"] == "true" {
+		return nil
+	}
 	return s.fileSystem.MountRootfs(cluster, append(s.MastersToJoin, s.NodesToJoin...), true)
 }
 

apply/run.go

@@ -55,14 +55,18 @@ func ConstructClusterFromArg(imageName string, runArgs *Args) (*v2.Cluster, erro
 }
 
 func NewApplierFromArgs(imageName string, runArgs *Args) (applydriver.Interface, error) {
+	if len(runArgs.Masters) == 0 {
+		return nil, fmt.Errorf("master ip list cannot be empty")
+	}
 	if err := validateArgs(runArgs); err != nil {
 		return nil, fmt.Errorf("failed to validate input run args: %v", err)
 	}
+
 	cluster, err := ConstructClusterFromArg(imageName, runArgs)
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize cluster instance with command args: %v", err)
 	}
-	return NewDefaultApplier(cluster)
+	return NewDefaultApplier(cluster, common.ApplySubCmd, nil)
 }
 
 // validateArgs validates all the input args from sealer run command.
@@ -71,8 +75,10 @@ func validateArgs(runArgs *Args) error {
 	var errMsg []string
 
 	// validate input masters IP info
-	if err := validateIPStr(runArgs.Masters); err != nil {
-		errMsg = append(errMsg, err.Error())
+	if len(runArgs.Masters) != 0 {
+		if err := validateIPStr(runArgs.Masters); err != nil {
+			errMsg = append(errMsg, err.Error())
+		}
 	}
 
 	// validate input nodes IP info
@@ -86,6 +92,7 @@ func validateArgs(runArgs *Args) error {
 	if len(errMsg) == 0 {
 		return nil
 	}
+
 	return fmt.Errorf(strings.Join(errMsg, ","))
 }
 
@@ -109,8 +116,12 @@ func getHosts(inMasters, inNodes string) ([]v2.Host, error) {
 	}
 
 	masters := strings.Split(inMasters, ",")
-	masterHosts := make([]v2.Host, len(masters))
+	var masterHosts []v2.Host
 	for index, master := range masters {
+		if master == "" {
+			continue
+		}
+
 		if index == 0 {
 			// only master0 should add two roles: master and master0
 			masterHosts = append(masterHosts, v2.Host{
@@ -128,16 +139,19 @@ func getHosts(inMasters, inNodes string) ([]v2.Host, error) {
 	}
 
 	nodes := strings.Split(inNodes, ",")
-	nodeHosts := make([]v2.Host, len(nodes))
+	var nodeHosts []v2.Host
 	for _, node := range nodes {
+		if node == "" {
+			continue
+		}
+
 		nodeHosts = append(nodeHosts, v2.Host{
 			IPS:   []string{node},
 			Roles: []string{common.NODE},
 		})
 	}
 
-	result := make([]v2.Host, len(masters)+len(nodes))
-	result = append(result, masterHosts...)
+	result := masterHosts
 	result = append(result, nodeHosts...)
 
 	return result, nil