v0.0: run with fedv2

Dockerfile_cm

@@ -0,0 +1,15 @@
+FROM hub.cloud.ctripcorp.com/k8s-mirror/golang:1.14 as builder
+
+RUN mkdir -p /go/src/github.com/karmada-io/karmada
+
+ADD . /go/src/github.com/karmada-io/karmada
+
+WORKDIR /go/src/github.com/karmada-io/karmada/cmd/controller-manager
+
+RUN GOPROXY="https://goproxy.io" GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o /go/bin/controller-manager .
+
+FROM hub.cloud.ctripcorp.com/container/alpine:3.5
+
+WORKDIR /usr/local/bin
+
+COPY --from=builder /go/bin/controller-manager .

Dockerfile_webhook

@@ -0,0 +1,15 @@
+FROM hub.cloud.ctripcorp.com/k8s-mirror/golang:1.14 as builder
+
+RUN mkdir -p /go/src/github.com/karmada-io/karmada
+
+ADD . /go/src/github.com/karmada-io/karmada
+
+WORKDIR /go/src/github.com/karmada-io/karmada/cmd/webhook
+
+RUN GOPROXY="https://goproxy.io" GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o /go/bin/webhook .
+
+FROM hub.cloud.ctripcorp.com/container/alpine:3.5
+
+WORKDIR /usr/local/bin
+
+COPY --from=builder /go/bin/webhook .

cmd/controller-manager/app/controllermanager.go

@@ -10,21 +10,21 @@ import (
 	"github.com/spf13/cobra"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/dynamic"
-	kubeclientset "k8s.io/client-go/kubernetes"
+	//kubeclientset "k8s.io/client-go/kubernetes"
 	"k8s.io/klog/v2"
 	controllerruntime "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/event"
+	//"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/healthz"
-	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	//"sigs.k8s.io/controller-runtime/pkg/predicate"
 
 	"github.com/karmada-io/karmada/cmd/controller-manager/app/options"
-	clusterv1alpha1 "github.com/karmada-io/karmada/pkg/apis/cluster/v1alpha1"
+	//clusterv1alpha1 "github.com/karmada-io/karmada/pkg/apis/cluster/v1alpha1"
 	"github.com/karmada-io/karmada/pkg/controllers/binding"
 	"github.com/karmada-io/karmada/pkg/controllers/cluster"
 	"github.com/karmada-io/karmada/pkg/controllers/execution"
-	"github.com/karmada-io/karmada/pkg/controllers/hpa"
+	//"github.com/karmada-io/karmada/pkg/controllers/hpa"
 	"github.com/karmada-io/karmada/pkg/controllers/mcs"
-	"github.com/karmada-io/karmada/pkg/controllers/namespace"
+	//"github.com/karmada-io/karmada/pkg/controllers/namespace"
 	"github.com/karmada-io/karmada/pkg/controllers/propagationpolicy"
 	"github.com/karmada-io/karmada/pkg/controllers/status"
 	"github.com/karmada-io/karmada/pkg/util"
@@ -69,6 +69,7 @@ func Run(ctx context.Context, opts *options.Options) error {
 		LeaderElectionID:       "karmada-controller-manager",
 		HealthProbeBindAddress: fmt.Sprintf("%s:%d", opts.BindAddress, opts.SecurePort),
 		LivenessEndpointName:   "/healthz",
+		MetricsBindAddress:     opts.MetricsBindAddress,
 	})
 	if err != nil {
 		klog.Errorf("failed to build controller manager: %v", err)
@@ -119,6 +120,7 @@ func setupControllers(mgr controllerruntime.Manager, opts *options.Options, stop
 		DynamicClient:                dynamicClientSet,
 		SkippedResourceConfig:        skippedResourceConfig,
 		SkippedPropagatingNamespaces: skippedPropagatingNamespaces,
+		ManagedGroups:                opts.ManagedGroups,
 	}
 
 	resourceDetector.EventHandler = informermanager.NewFilteringHandlerOnAllEvents(resourceDetector.EventFilter, resourceDetector.OnAdd, resourceDetector.OnUpdate, resourceDetector.OnDelete)
@@ -137,51 +139,55 @@ func setupControllers(mgr controllerruntime.Manager, opts *options.Options, stop
 	if err := clusterController.SetupWithManager(mgr); err != nil {
 		klog.Fatalf("Failed to setup cluster controller: %v", err)
 	}
+	/*
+			clusterPredicateFunc := predicate.Funcs{
+				CreateFunc: func(createEvent event.CreateEvent) bool {
+					obj := createEvent.Object.(*clusterv1alpha1.Cluster)
+					return obj.Spec.SyncMode == clusterv1alpha1.Push
+				},
+				UpdateFunc: func(updateEvent event.UpdateEvent) bool {
+					obj := updateEvent.ObjectNew.(*clusterv1alpha1.Cluster)
+					return obj.Spec.SyncMode == clusterv1alpha1.Push
+				},
+				DeleteFunc: func(deleteEvent event.DeleteEvent) bool {
+					obj := deleteEvent.Object.(*clusterv1alpha1.Cluster)
+					return obj.Spec.SyncMode == clusterv1alpha1.Push
+				},
+				GenericFunc: func(genericEvent event.GenericEvent) bool {
+					return false
+				},
+			}
 
-	clusterPredicateFunc := predicate.Funcs{
-		CreateFunc: func(createEvent event.CreateEvent) bool {
-			obj := createEvent.Object.(*clusterv1alpha1.Cluster)
-			return obj.Spec.SyncMode == clusterv1alpha1.Push
-		},
-		UpdateFunc: func(updateEvent event.UpdateEvent) bool {
-			obj := updateEvent.ObjectNew.(*clusterv1alpha1.Cluster)
-			return obj.Spec.SyncMode == clusterv1alpha1.Push
-		},
-		DeleteFunc: func(deleteEvent event.DeleteEvent) bool {
-			obj := deleteEvent.Object.(*clusterv1alpha1.Cluster)
-			return obj.Spec.SyncMode == clusterv1alpha1.Push
-		},
-		GenericFunc: func(genericEvent event.GenericEvent) bool {
-			return false
-		},
-	}
 
-	clusterStatusController := &status.ClusterStatusController{
-		Client:                            mgr.GetClient(),
-		KubeClient:                        kubeclientset.NewForConfigOrDie(mgr.GetConfig()),
-		EventRecorder:                     mgr.GetEventRecorderFor(status.ControllerName),
-		PredicateFunc:                     clusterPredicateFunc,
-		InformerManager:                   informermanager.GetInstance(),
-		StopChan:                          stopChan,
-		ClusterClientSetFunc:              util.NewClusterClientSet,
-		ClusterDynamicClientSetFunc:       util.NewClusterDynamicClientSet,
-		ClusterStatusUpdateFrequency:      opts.ClusterStatusUpdateFrequency,
-		ClusterLeaseDuration:              opts.ClusterLeaseDuration,
-		ClusterLeaseRenewIntervalFraction: opts.ClusterLeaseRenewIntervalFraction,
-	}
-	if err := clusterStatusController.SetupWithManager(mgr); err != nil {
-		klog.Fatalf("Failed to setup cluster status controller: %v", err)
-	}
+		clusterStatusController := &status.ClusterStatusController{
+			Client:                            mgr.GetClient(),
+			KubeClient:                        kubeclientset.NewForConfigOrDie(mgr.GetConfig()),
+			EventRecorder:                     mgr.GetEventRecorderFor(status.ControllerName),
+			PredicateFunc:                     clusterPredicateFunc,
+			InformerManager:                   informermanager.GetInstance(),
+			StopChan:                          stopChan,
+			ClusterClientSetFunc:              util.NewClusterClientSet,
+			ClusterDynamicClientSetFunc:       util.NewClusterDynamicClientSet,
+			ClusterStatusUpdateFrequency:      opts.ClusterStatusUpdateFrequency,
+			ClusterLeaseDuration:              opts.ClusterLeaseDuration,
+			ClusterLeaseRenewIntervalFraction: opts.ClusterLeaseRenewIntervalFraction,
+		}
+		if err := clusterStatusController.SetupWithManager(mgr); err != nil {
+			klog.Fatalf("Failed to setup cluster status controller: %v", err)
+		}
+	*/
 
-	hpaController := &hpa.HorizontalPodAutoscalerController{
-		Client:        mgr.GetClient(),
-		DynamicClient: dynamicClientSet,
-		EventRecorder: mgr.GetEventRecorderFor(hpa.ControllerName),
-		RESTMapper:    mgr.GetRESTMapper(),
-	}
-	if err := hpaController.SetupWithManager(mgr); err != nil {
-		klog.Fatalf("Failed to setup hpa controller: %v", err)
-	}
+	/*
+		hpaController := &hpa.HorizontalPodAutoscalerController{
+			Client:        mgr.GetClient(),
+			DynamicClient: dynamicClientSet,
+			EventRecorder: mgr.GetEventRecorderFor(hpa.ControllerName),
+			RESTMapper:    mgr.GetRESTMapper(),
+		}
+		if err := hpaController.SetupWithManager(mgr); err != nil {
+			klog.Fatalf("Failed to setup hpa controller: %v", err)
+		}
+	*/
 
 	policyController := &propagationpolicy.Controller{
 		Client: mgr.GetClient(),
@@ -240,14 +246,16 @@ func setupControllers(mgr controllerruntime.Manager, opts *options.Options, stop
 		klog.Fatalf("Failed to setup work status controller: %v", err)
 	}
 
-	namespaceSyncController := &namespace.Controller{
-		Client:                       mgr.GetClient(),
-		EventRecorder:                mgr.GetEventRecorderFor(namespace.ControllerName),
-		SkippedPropagatingNamespaces: skippedPropagatingNamespaces,
-	}
-	if err := namespaceSyncController.SetupWithManager(mgr); err != nil {
-		klog.Fatalf("Failed to setup namespace sync controller: %v", err)
-	}
+	/*
+		namespaceSyncController := &namespace.Controller{
+			Client:                       mgr.GetClient(),
+			EventRecorder:                mgr.GetEventRecorderFor(namespace.ControllerName),
+			SkippedPropagatingNamespaces: skippedPropagatingNamespaces,
+		}
+		if err := namespaceSyncController.SetupWithManager(mgr); err != nil {
+			klog.Fatalf("Failed to setup namespace sync controller: %v", err)
+		}
+	*/
 
 	serviceExportController := &mcs.ServiceExportController{
 		Client:                      mgr.GetClient(),

cmd/controller-manager/app/options/options.go

@@ -17,14 +17,20 @@ var (
 )
 
 const (
-	defaultBindAddress = "0.0.0.0"
-	defaultPort        = 10357
+	defaultMetricsBindAddress = ":8080"
+	defaultBindAddress        = "0.0.0.0"
+	defaultPort               = 10357
 )
 
 // Options contains everything necessary to create and run controller-manager.
 type Options struct {
 	HostNamespace  string
 	LeaderElection componentbaseconfig.LeaderElectionConfiguration
+
+	ManagedGroups []string
+	// MetricsBindAddress is the TCP address that the controller should bind to for serving prometheus metrics.
+	// It can be set to "0" to disable the metrics serving.
+	MetricsBindAddress string
 	// BindAddress is the IP address on which to listen for the --secure-port port.
 	BindAddress string
 	// SecurePort is the port that the the server serves at.
@@ -90,6 +96,8 @@ func (o *Options) Complete() {
 
 // AddFlags adds flags to the specified FlagSet.
 func (o *Options) AddFlags(flags *pflag.FlagSet) {
+	flags.StringSliceVar(&o.ManagedGroups, "managed-groups", []string{"autoscaling.karrier.io"}, "Groups managed by federation.")
+	flags.StringVar(&o.MetricsBindAddress, "metrics-bind-address", defaultMetricsBindAddress, "The TCP address for serving prometheus metrics.")
 	flags.StringVar(&o.BindAddress, "bind-address", defaultBindAddress,
 		"The IP address on which to listen for the --secure-port port.")
 	flags.IntVar(&o.SecurePort, "secure-port", defaultPort,

pkg/controllers/cluster/cluster_controller.go

@@ -13,8 +13,8 @@ import (
 	"k8s.io/apimachinery/pkg/api/meta"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
-	utilerrors "k8s.io/apimachinery/pkg/util/errors"
-	"k8s.io/apimachinery/pkg/util/wait"
+	//utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	//"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/tools/record"
 	"k8s.io/klog/v2"
 	controllerruntime "sigs.k8s.io/controller-runtime"
@@ -86,6 +86,7 @@ func (c *Controller) Reconcile(ctx context.Context, req controllerruntime.Reques
 }
 
 // Start starts an asynchronous loop that monitors the status of cluster.
+/*
 func (c *Controller) Start(ctx context.Context) error {
 	klog.Infof("Starting cluster health monitor")
 	defer klog.Infof("Shutting cluster health monitor")
@@ -100,13 +101,17 @@ func (c *Controller) Start(ctx context.Context) error {
 
 	return nil
 }
+*/
 
 // SetupWithManager creates a controller and register to controller manager.
 func (c *Controller) SetupWithManager(mgr controllerruntime.Manager) error {
-	return utilerrors.NewAggregate([]error{
-		controllerruntime.NewControllerManagedBy(mgr).For(&v1alpha1.Cluster{}).Complete(c),
-		mgr.Add(c),
-	})
+	/*
+		return utilerrors.NewAggregate([]error{
+			controllerruntime.NewControllerManagedBy(mgr).For(&v1alpha1.Cluster{}).Complete(c),
+			mgr.Add(c),
+		})
+	*/
+	return controllerruntime.NewControllerManagedBy(mgr).For(&v1alpha1.Cluster{}).Complete(c)
 }
 
 func (c *Controller) syncCluster(cluster *v1alpha1.Cluster) (controllerruntime.Result, error) {
@@ -246,6 +251,7 @@ func (c *Controller) createExecutionSpace(cluster *v1alpha1.Cluster) error {
 	return nil
 }
 
+/*
 func (c *Controller) monitorClusterHealth() error {
 	clusterList := &v1alpha1.ClusterList{}
 	if err := c.Client.List(context.TODO(), clusterList); err != nil {
@@ -279,6 +285,7 @@ func (c *Controller) monitorClusterHealth() error {
 
 	return nil
 }
+*/
 
 // tryUpdateClusterHealth checks a given cluster's conditions and tries to update it.
 //nolint:gocyclo

pkg/controllers/execution/execution_controller.go

@@ -19,7 +19,7 @@ import (
 	"github.com/karmada-io/karmada/pkg/apis/cluster/v1alpha1"
 	workv1alpha1 "github.com/karmada-io/karmada/pkg/apis/work/v1alpha1"
 	"github.com/karmada-io/karmada/pkg/util"
-	"github.com/karmada-io/karmada/pkg/util/helper"
+	//"github.com/karmada-io/karmada/pkg/util/helper"
 	"github.com/karmada-io/karmada/pkg/util/names"
 	"github.com/karmada-io/karmada/pkg/util/objectwatcher"
 	"github.com/karmada-io/karmada/pkg/util/restmapper"
@@ -69,13 +69,21 @@ func (c *Controller) Reconcile(ctx context.Context, req controllerruntime.Reques
 	}
 
 	if !work.DeletionTimestamp.IsZero() {
-		applied := helper.IsResourceApplied(&work.Status)
-		if applied {
-			err := c.tryDeleteWorkload(cluster, work)
-			if err != nil {
-				klog.Errorf("Failed to delete work %v, namespace is %v, err is %v", work.Name, work.Namespace, err)
-				return controllerruntime.Result{Requeue: true}, err
+		/*
+			applied := helper.IsResourceApplied(&work.Status)
+			if applied {
+				err := c.tryDeleteWorkload(cluster, work)
+				if err != nil {
+					klog.Errorf("Failed to delete work %v, namespace is %v, err is %v", work.Name, work.Namespace, err)
+					return controllerruntime.Result{Requeue: true}, err
+				}
+				return c.removeFinalizer(work)
 			}
+		*/
+		err := c.tryDeleteWorkload(cluster, work)
+		if err != nil {
+			klog.Errorf("Failed to delete work %v, namespace is %v, err is %v", work.Name, work.Namespace, err)
+			return controllerruntime.Result{Requeue: true}, err
 		}
 		return c.removeFinalizer(work)
 	}
@@ -166,21 +174,29 @@ func (c *Controller) syncToClusters(cluster *v1alpha1.Cluster, work *workv1alpha
 			continue
 		}
 
-		applied := helper.IsResourceApplied(&work.Status)
-		if applied {
-			err = c.tryUpdateWorkload(cluster, workload, clusterDynamicClient)
-			if err != nil {
-				klog.Errorf("Failed to update resource(%v/%v) in the given member cluster %s, err is %v", workload.GetNamespace(), workload.GetName(), cluster.Name, err)
-				errs = append(errs, err)
-				continue
-			}
-		} else {
-			err = c.tryCreateWorkload(cluster, workload)
-			if err != nil {
-				klog.Errorf("Failed to create resource(%v/%v) in the given member cluster %s, err is %v", workload.GetNamespace(), workload.GetName(), cluster.Name, err)
-				errs = append(errs, err)
-				continue
+		/*
+			applied := helper.IsResourceApplied(&work.Status)
+			if applied {
+				err = c.tryUpdateWorkload(cluster, workload, clusterDynamicClient)
+				if err != nil {
+					klog.Errorf("Failed to update resource(%v/%v) in the given member cluster %s, err is %v", workload.GetNamespace(), workload.GetName(), cluster.Name, err)
+					errs = append(errs, err)
+					continue
+				}
+			} else {
+				err = c.tryCreateWorkload(cluster, workload)
+				if err != nil {
+					klog.Errorf("Failed to create resource(%v/%v) in the given member cluster %s, err is %v", workload.GetNamespace(), workload.GetName(), cluster.Name, err)
+					errs = append(errs, err)
+					continue
+				}
 			}
+		*/
+		err = c.tryUpdateWorkload(cluster, workload, clusterDynamicClient)
+		if err != nil {
+			klog.Errorf("Failed to update resource(%v/%v) in the given member cluster %s, err is %v", workload.GetNamespace(), workload.GetName(), cluster.Name, err)
+			errs = append(errs, err)
+			continue
 		}
 		syncSucceedNum++
 	}