diff --git a/operator/pkg/apis/operator/v1alpha1/defaults.go b/operator/pkg/apis/operator/v1alpha1/defaults.go new file mode 100644 index 000000000..f285395ba --- /dev/null +++ b/operator/pkg/apis/operator/v1alpha1/defaults.go @@ -0,0 +1,208 @@ +package v1alpha1 + +import ( + "fmt" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/utils/pointer" + + "github.com/karmada-io/karmada/operator/pkg/constants" +) + +var ( + etcdImageRepository = fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.Etcd) + karmadaAPIServiceImageRepository = fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.KarmadaAPIServer) + karmadaAggregratedAPIServerImageRepository = fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaAggregatedAPIServer) + kubeControllerManagerImageRepository = fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.KubeControllerManager) + karmadaControllerManagerImageRepository = fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaControllerManager) + karmadaSchedulerImageRepository = fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaScheduler) + karmadaWebhookImageRepository = fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaWebhook) +) + +func addDefaultingFuncs(scheme *runtime.Scheme) error { + return RegisterDefaults(scheme) +} + +// RegisterDefaults adds defaulters functions to the given scheme. +// Public to allow building arbitrary schemes. +// All generated defaulters are covering - they call all nested defaulters. +func RegisterDefaults(scheme *runtime.Scheme) error { + scheme.AddTypeDefaultingFunc(&Karmada{}, func(obj interface{}) { SetObjectDefaultsKarmada(obj.(*Karmada)) }) + return nil +} + +// SetObjectDefaultsKarmada set defaults for karmada +func SetObjectDefaultsKarmada(in *Karmada) { + setDefaultsKarmada(in) +} + +func setDefaultsKarmada(obj *Karmada) { + setDefaultsHostCluster(obj) + setDefaultsKarmadaComponents(obj) +} + +func setDefaultsKarmadaComponents(obj *Karmada) { + if obj.Spec.Components == nil { + obj.Spec.Components = &KarmadaComponents{} + } + + setDefaultsEtcd(obj.Spec.Components) + setDefaultsKarmadaAPIServer(obj.Spec.Components) + setDefaultsKarmadaAggregratedAPIServer(obj.Spec.Components) + setDefaultsKubeControllerManager(obj.Spec.Components) + setDefaultsKarmadaControllerManager(obj.Spec.Components) + setDefaultsKarmadaScheduler(obj.Spec.Components) + setDefaultsKarmadaWebhook(obj.Spec.Components) +} + +func setDefaultsHostCluster(obj *Karmada) { + if obj.Spec.HostCluster == nil { + obj.Spec.HostCluster = &HostCluster{} + } + + hc := obj.Spec.HostCluster + if hc.Networking == nil { + hc.Networking = &Networking{} + } + if hc.Networking.DNSDomain == nil { + hc.Networking.DNSDomain = pointer.String(constants.KarmadaDefaultDNSDomain) + } +} + +func setDefaultsEtcd(obj *KarmadaComponents) { + if obj.Etcd == nil { + obj.Etcd = &Etcd{} + } + + if obj.Etcd.External == nil { + if obj.Etcd.Local == nil { + obj.Etcd.Local = &LocalEtcd{} + } + + if obj.Etcd.Local.Replicas == nil { + obj.Etcd.Local.Replicas = pointer.Int32(1) + } + if len(obj.Etcd.Local.Image.ImageRepository) == 0 { + obj.Etcd.Local.Image.ImageRepository = etcdImageRepository + } + if len(obj.Etcd.Local.Image.ImageTag) == 0 { + obj.Etcd.Local.Image.ImageTag = constants.EtcdDefaultVersion + } + + if obj.Etcd.Local.VolumeData == nil { + obj.Etcd.Local.VolumeData = &VolumeData{} + } + if obj.Etcd.Local.VolumeData.EmptyDir == nil && obj.Etcd.Local.VolumeData.HostPath == nil && obj.Etcd.Local.VolumeData.VolumeClaim == nil { + obj.Etcd.Local.VolumeData.EmptyDir = &corev1.EmptyDirVolumeSource{} + } + } +} + +func setDefaultsKarmadaAPIServer(obj *KarmadaComponents) { + if obj.KarmadaAPIServer == nil { + obj.KarmadaAPIServer = &KarmadaAPIServer{} + } + + apiserver := obj.KarmadaAPIServer + if len(apiserver.Image.ImageRepository) == 0 { + apiserver.Image.ImageRepository = karmadaAPIServiceImageRepository + } + if len(apiserver.Image.ImageTag) == 0 { + apiserver.Image.ImageTag = constants.KubeDefaultVersion + } + if apiserver.Replicas == nil { + apiserver.Replicas = pointer.Int32(1) + } + if apiserver.ServiceSubnet == nil { + apiserver.ServiceSubnet = pointer.String(constants.KarmadaDefaultServiceSubnet) + } + if len(apiserver.ServiceType) == 0 { + apiserver.ServiceType = corev1.ServiceTypeClusterIP + } +} + +func setDefaultsKarmadaAggregratedAPIServer(obj *KarmadaComponents) { + if obj.KarmadaAggregratedAPIServer == nil { + obj.KarmadaAggregratedAPIServer = &KarmadaAggregratedAPIServer{} + } + + aggregrated := obj.KarmadaAggregratedAPIServer + if len(aggregrated.Image.ImageRepository) == 0 { + aggregrated.Image.ImageRepository = karmadaAggregratedAPIServerImageRepository + } + if len(aggregrated.Image.ImageTag) == 0 { + aggregrated.Image.ImageTag = constants.KarmadaDefaultVersion + } + if aggregrated.Replicas == nil { + aggregrated.Replicas = pointer.Int32(1) + } +} + +func setDefaultsKubeControllerManager(obj *KarmadaComponents) { + if obj.KubeControllerManager == nil { + obj.KubeControllerManager = &KubeControllerManager{} + } + + kubeControllerManager := obj.KubeControllerManager + if len(kubeControllerManager.Image.ImageRepository) == 0 { + kubeControllerManager.Image.ImageRepository = kubeControllerManagerImageRepository + } + if len(kubeControllerManager.Image.ImageTag) == 0 { + kubeControllerManager.Image.ImageTag = constants.KubeDefaultVersion + } + if kubeControllerManager.Replicas == nil { + kubeControllerManager.Replicas = pointer.Int32(1) + } +} + +func setDefaultsKarmadaControllerManager(obj *KarmadaComponents) { + if obj.KarmadaControllerManager == nil { + obj.KarmadaControllerManager = &KarmadaControllerManager{} + } + + karmadaControllerManager := obj.KarmadaControllerManager + if len(karmadaControllerManager.Image.ImageRepository) == 0 { + karmadaControllerManager.Image.ImageRepository = karmadaControllerManagerImageRepository + } + if len(karmadaControllerManager.Image.ImageTag) == 0 { + karmadaControllerManager.Image.ImageTag = constants.KarmadaDefaultVersion + } + if karmadaControllerManager.Replicas == nil { + karmadaControllerManager.Replicas = pointer.Int32(1) + } +} + +func setDefaultsKarmadaScheduler(obj *KarmadaComponents) { + if obj.KarmadaScheduler == nil { + obj.KarmadaScheduler = &KarmadaScheduler{} + } + + scheduler := obj.KarmadaScheduler + if len(scheduler.Image.ImageRepository) == 0 { + scheduler.Image.ImageRepository = karmadaSchedulerImageRepository + } + if len(scheduler.Image.ImageTag) == 0 { + scheduler.Image.ImageTag = constants.KarmadaDefaultVersion + } + if scheduler.Replicas == nil { + scheduler.Replicas = pointer.Int32(1) + } +} + +func setDefaultsKarmadaWebhook(obj *KarmadaComponents) { + if obj.KarmadaWebhook == nil { + obj.KarmadaWebhook = &KarmadaWebhook{} + } + + webhook := obj.KarmadaWebhook + if len(webhook.Image.ImageRepository) == 0 { + webhook.Image.ImageRepository = karmadaWebhookImageRepository + } + if len(webhook.Image.ImageTag) == 0 { + webhook.Image.ImageTag = constants.KarmadaDefaultVersion + } + if webhook.Replicas == nil { + webhook.Replicas = pointer.Int32(1) + } +} diff --git a/operator/pkg/apis/operator/v1alpha1/doc.go b/operator/pkg/apis/operator/v1alpha1/doc.go index 2afd30ae0..463a168f3 100644 --- a/operator/pkg/apis/operator/v1alpha1/doc.go +++ b/operator/pkg/apis/operator/v1alpha1/doc.go @@ -1,4 +1,5 @@ // +k8s:deepcopy-gen=package +// +k8s:defaulter-gen=ObjectMeta // +groupName=operator.karmada.io package v1alpha1 diff --git a/operator/pkg/apis/operator/v1alpha1/zz_generated.register.go b/operator/pkg/apis/operator/v1alpha1/register.go similarity index 83% rename from operator/pkg/apis/operator/v1alpha1/zz_generated.register.go rename to operator/pkg/apis/operator/v1alpha1/register.go index bf3c40d46..a40fb8efc 100644 --- a/operator/pkg/apis/operator/v1alpha1/zz_generated.register.go +++ b/operator/pkg/apis/operator/v1alpha1/register.go @@ -1,5 +1,3 @@ -// Code generated by register-gen. DO NOT EDIT. - package v1alpha1 import ( @@ -24,19 +22,19 @@ func Resource(resource string) schema.GroupResource { } var ( - // localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes. - SchemeBuilder runtime.SchemeBuilder + // SchemeBuilder will stay in k8s.io/kubernetes. + SchemeBuilder runtime.SchemeBuilder + // localSchemeBuilder will stay in k8s.io/kubernetes. localSchemeBuilder = &SchemeBuilder - // Depreciated: use Install instead + // AddToScheme applies all the stored functions to the scheme AddToScheme = localSchemeBuilder.AddToScheme - Install = localSchemeBuilder.AddToScheme ) func init() { // We only register manually written functions here. The registration of the // generated functions takes place in the generated files. The separation // makes the code compile even when the generated files are missing. - localSchemeBuilder.Register(addKnownTypes) + localSchemeBuilder.Register(addKnownTypes, addDefaultingFuncs) } // Adds the list of known types to Scheme. diff --git a/operator/pkg/constants/constants.go b/operator/pkg/constants/constants.go index 663618eef..f0ab75e20 100644 --- a/operator/pkg/constants/constants.go +++ b/operator/pkg/constants/constants.go @@ -17,6 +17,10 @@ const ( KarmadaDefaultVersion = "v1.4.0" // KubeDefaultVersion defines the default of the karmada apiserver and kubeControllerManager image tag KubeDefaultVersion = "v1.25.2" + // KarmadaDefaultServiceSubnet defines the default of the subnet used by k8s services. + KarmadaDefaultServiceSubnet = "10.96.0.0/12" + // KarmadaDefaultDNSDomain defines the default of the DNSDomain + KarmadaDefaultDNSDomain = "cluster.local" // KarmadaOperator defines the name of the karmada operator. KarmadaOperator = "karmada-operator" diff --git a/operator/pkg/controller/karmada/controller.go b/operator/pkg/controller/karmada/controller.go index f71cda641..693ad0cd8 100644 --- a/operator/pkg/controller/karmada/controller.go +++ b/operator/pkg/controller/karmada/controller.go @@ -2,6 +2,7 @@ package karmada import ( "context" + "reflect" "time" "k8s.io/apimachinery/pkg/api/errors" @@ -13,6 +14,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" operatorv1alpha1 "github.com/karmada-io/karmada/operator/pkg/apis/operator/v1alpha1" + operatorscheme "github.com/karmada-io/karmada/operator/pkg/scheme" ) const ( @@ -52,14 +54,8 @@ func (ctrl *Controller) Reconcile(ctx context.Context, req controllerruntime.Req // examine DeletionTimestamp to determine if object is under deletion if karmada.DeletionTimestamp.IsZero() { - // The object is not being deleted, so if it does not have our finalizer, - // then lets add the finalizer and update the object. This is equivalent - // registering our finalizer. - if !controllerutil.ContainsFinalizer(karmada, ControllerFinalizerName) { - controllerutil.AddFinalizer(karmada, ControllerFinalizerName) - if err := ctrl.Update(ctx, karmada); err != nil { - return controllerruntime.Result{}, err - } + if err := ctrl.ensureKarmada(ctx, karmada); err != nil { + return controllerruntime.Result{}, err } } @@ -92,6 +88,25 @@ func (ctrl *Controller) removeFinalizer(ctx context.Context, karmada *operatorv1 return controllerruntime.Result{}, nil } +func (ctrl *Controller) ensureKarmada(ctx context.Context, karmada *operatorv1alpha1.Karmada) error { + // The object is not being deleted, so if it does not have our finalizer, + // then lets add the finalizer and update the object. This is equivalent + // registering our finalizer. + updated := controllerutil.AddFinalizer(karmada, ControllerFinalizerName) + older := karmada.DeepCopy() + + // Set the defaults for karmada + operatorscheme.Scheme.Default(karmada) + + if updated || !reflect.DeepEqual(karmada.Spec, older.Spec) { + if err := ctrl.Update(ctx, karmada); err != nil { + return err + } + } + + return nil +} + // SetupWithManager creates a controller and register to controller manager. func (ctrl *Controller) SetupWithManager(mgr controllerruntime.Manager) error { return controllerruntime.NewControllerManagedBy(mgr).For(&operatorv1alpha1.Karmada{}).Complete(ctrl) diff --git a/operator/pkg/init.go b/operator/pkg/init.go index 9bab4c7f3..20b6bc1bd 100644 --- a/operator/pkg/init.go +++ b/operator/pkg/init.go @@ -6,16 +6,15 @@ import ( "net/url" "sync" - corev1 "k8s.io/api/core/v1" utilversion "k8s.io/apimachinery/pkg/util/version" clientset "k8s.io/client-go/kubernetes" "k8s.io/client-go/rest" "k8s.io/klog/v2" - "k8s.io/utils/pointer" operatorv1alpha1 "github.com/karmada-io/karmada/operator/pkg/apis/operator/v1alpha1" "github.com/karmada-io/karmada/operator/pkg/certs" "github.com/karmada-io/karmada/operator/pkg/constants" + operatorscheme "github.com/karmada-io/karmada/operator/pkg/scheme" tasks "github.com/karmada-io/karmada/operator/pkg/tasks/init" workflow "github.com/karmada-io/karmada/operator/pkg/workflow" ) @@ -26,16 +25,13 @@ var ( // InitOptions defines all the init workflow options. type InitOptions struct { - Name string - Namespace string - Kubeconfig *rest.Config - KarmadaVersion string - CrdRemoteURL string - KarmadaDataDir string - PrivateRegistry string - HostCluster *operatorv1alpha1.HostCluster - Components *operatorv1alpha1.KarmadaComponents - FeatureGates map[string]bool + Name string + Namespace string + Kubeconfig *rest.Config + KarmadaVersion string + CrdRemoteURL string + KarmadaDataDir string + Karmada *operatorv1alpha1.Karmada } // InitOpt defines a type of function to set InitOptions values. @@ -81,60 +77,70 @@ func NewInitJob(opt *InitOptions) *workflow.Job { initJob.AppendTask(tasks.NewWaitControlPlaneTask()) initJob.SetDataInitializer(func() (workflow.RunData, error) { - // if there is no endpoint info, we are consider that the local cluster - // is remote cluster to install karmada. - var remoteClient clientset.Interface - if opt.HostCluster.SecretRef == nil && len(opt.HostCluster.APIEndpoint) == 0 { - client, err := clientset.NewForConfig(opt.Kubeconfig) - if err != nil { - return nil, fmt.Errorf("error when create cluster client to install karmada, err: %w", err) - } - - remoteClient = client - } - - if len(opt.Name) == 0 || len(opt.Namespace) == 0 { - return nil, errors.New("unexpected empty name or namespace") - } - - version, err := utilversion.ParseGeneric(opt.KarmadaVersion) - if err != nil { - return nil, fmt.Errorf("unexpected karmada invalid version %s", opt.KarmadaVersion) - } - - if len(opt.CrdRemoteURL) > 0 { - if _, err := url.Parse(opt.CrdRemoteURL); err != nil { - return nil, fmt.Errorf("unexpected invalid crds remote url %s", opt.CrdRemoteURL) - } - } - - if opt.Components.Etcd.Local != nil && opt.Components.Etcd.Local.CommonSettings.Replicas != nil { - replicas := *opt.Components.Etcd.Local.CommonSettings.Replicas - if (replicas % 2) == 0 { - klog.Warningf("invalid etcd replicas %d, expected an odd number", replicas) - } - } - - // TODO: Verify whether important values of initData is valid - - return &initData{ - name: opt.Name, - namespace: opt.Namespace, - karmadaVersion: version, - remoteClient: remoteClient, - crdRemoteURL: opt.CrdRemoteURL, - karmadaDataDir: opt.KarmadaDataDir, - privateRegistry: opt.PrivateRegistry, - components: opt.Components, - featureGates: opt.FeatureGates, - dnsDomain: *opt.HostCluster.Networking.DNSDomain, - CertStore: certs.NewCertStore(), - }, nil + return newRunData(opt) }) return initJob } +func newRunData(opt *InitOptions) (*initData, error) { + // if there is no endpoint info, we are consider that the local cluster + // is remote cluster to install karmada. + var remoteClient clientset.Interface + if opt.Karmada.Spec.HostCluster.SecretRef == nil && len(opt.Karmada.Spec.HostCluster.APIEndpoint) == 0 { + client, err := clientset.NewForConfig(opt.Kubeconfig) + if err != nil { + return nil, fmt.Errorf("error when create cluster client to install karmada, err: %w", err) + } + + remoteClient = client + } + + var privateRegistry string + if opt.Karmada.Spec.PrivateRegistry != nil { + privateRegistry = opt.Karmada.Spec.PrivateRegistry.Registry + } + + if len(opt.Name) == 0 || len(opt.Namespace) == 0 { + return nil, errors.New("unexpected empty name or namespace") + } + + version, err := utilversion.ParseGeneric(opt.KarmadaVersion) + if err != nil { + return nil, fmt.Errorf("unexpected karmada invalid version %s", opt.KarmadaVersion) + } + + if len(opt.CrdRemoteURL) > 0 { + if _, err := url.Parse(opt.CrdRemoteURL); err != nil { + return nil, fmt.Errorf("unexpected invalid crds remote url %s", opt.CrdRemoteURL) + } + } + + if opt.Karmada.Spec.Components.Etcd.Local != nil && opt.Karmada.Spec.Components.Etcd.Local.CommonSettings.Replicas != nil { + replicas := *opt.Karmada.Spec.Components.Etcd.Local.CommonSettings.Replicas + + if (replicas % 2) == 0 { + klog.Warningf("invalid etcd replicas %d, expected an odd number", replicas) + } + } + + // TODO: Verify whether important values of initData is valid + + return &initData{ + name: opt.Name, + namespace: opt.Namespace, + karmadaVersion: version, + remoteClient: remoteClient, + crdRemoteURL: opt.CrdRemoteURL, + karmadaDataDir: opt.KarmadaDataDir, + privateRegistry: privateRegistry, + components: opt.Karmada.Spec.Components, + featureGates: opt.Karmada.Spec.FeatureGates, + dnsDomain: *opt.Karmada.Spec.HostCluster.Networking.DNSDomain, + CertStore: certs.NewCertStore(), + }, nil +} + func (data *initData) GetName() string { return data.name } @@ -197,120 +203,25 @@ func NewJobInitOptions(opts ...InitOpt) *InitOptions { } func defaultJobInitOptions() *InitOptions { + karmada := &operatorv1alpha1.Karmada{} + + // set defaults for karmada. + operatorscheme.Scheme.Default(karmada) + return &InitOptions{ CrdRemoteURL: fmt.Sprintf(defaultCrdURL, constants.KarmadaDefaultVersion), - Name: "karmada", - Namespace: constants.KarmadaSystemNamespace, KarmadaVersion: constants.KarmadaDefaultVersion, KarmadaDataDir: constants.KarmadaDataDir, - Components: defaultComponents(), - HostCluster: defaultHostCluster(), - } -} - -func defaultHostCluster() *operatorv1alpha1.HostCluster { - return &operatorv1alpha1.HostCluster{ - Networking: &operatorv1alpha1.Networking{ - DNSDomain: pointer.String("cluster.local"), - }, - } -} - -func defaultComponents() *operatorv1alpha1.KarmadaComponents { - return &operatorv1alpha1.KarmadaComponents{ - Etcd: &operatorv1alpha1.Etcd{ - Local: &operatorv1alpha1.LocalEtcd{ - CommonSettings: operatorv1alpha1.CommonSettings{ - Image: operatorv1alpha1.Image{ - ImageRepository: fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.Etcd), - ImageTag: constants.EtcdDefaultVersion, - }, - Replicas: pointer.Int32(1), - }, - - VolumeData: &operatorv1alpha1.VolumeData{ - EmptyDir: &corev1.EmptyDirVolumeSource{}, - }, - }, - }, - - KarmadaAPIServer: &operatorv1alpha1.KarmadaAPIServer{ - CommonSettings: operatorv1alpha1.CommonSettings{ - Replicas: pointer.Int32(1), - Image: operatorv1alpha1.Image{ - ImageRepository: fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.KarmadaAPIServer), - ImageTag: constants.KubeDefaultVersion, - }, - }, - ServiceSubnet: pointer.String("10.96.0.0/12"), - ServiceType: corev1.ServiceTypeClusterIP, - }, - KarmadaAggregratedAPIServer: &operatorv1alpha1.KarmadaAggregratedAPIServer{ - CommonSettings: operatorv1alpha1.CommonSettings{ - Replicas: pointer.Int32(1), - Image: operatorv1alpha1.Image{ - ImageRepository: fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaAggregatedAPIServer), - ImageTag: constants.KarmadaDefaultVersion, - }, - }, - }, - KubeControllerManager: &operatorv1alpha1.KubeControllerManager{ - CommonSettings: operatorv1alpha1.CommonSettings{ - Replicas: pointer.Int32(1), - Image: operatorv1alpha1.Image{ - ImageRepository: fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.KubeControllerManager), - ImageTag: constants.KubeDefaultVersion, - }, - }, - }, - KarmadaControllerManager: &operatorv1alpha1.KarmadaControllerManager{ - CommonSettings: operatorv1alpha1.CommonSettings{ - Replicas: pointer.Int32(1), - Image: operatorv1alpha1.Image{ - ImageRepository: fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaControllerManager), - ImageTag: constants.KarmadaDefaultVersion, - }, - }, - }, - KarmadaScheduler: &operatorv1alpha1.KarmadaScheduler{ - CommonSettings: operatorv1alpha1.CommonSettings{ - Replicas: pointer.Int32(1), - Image: operatorv1alpha1.Image{ - ImageRepository: fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaScheduler), - ImageTag: constants.KarmadaDefaultVersion, - }, - }, - }, - KarmadaWebhook: &operatorv1alpha1.KarmadaWebhook{ - CommonSettings: operatorv1alpha1.CommonSettings{ - Replicas: pointer.Int32(1), - Image: operatorv1alpha1.Image{ - ImageRepository: fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaWebhook), - ImageTag: constants.KarmadaDefaultVersion, - }, - }, - }, + Karmada: karmada, } } // NewInitOptWithKarmada returns a InitOpt function to initialize InitOptions with karmada resource func NewInitOptWithKarmada(karmada *operatorv1alpha1.Karmada) InitOpt { return func(opt *InitOptions) { + opt.Karmada = karmada opt.Name = karmada.GetName() opt.Namespace = karmada.GetNamespace() - opt.FeatureGates = karmada.Spec.FeatureGates - - if karmada.Spec.PrivateRegistry != nil && len(karmada.Spec.PrivateRegistry.Registry) > 0 { - opt.PrivateRegistry = karmada.Spec.PrivateRegistry.Registry - } - - if karmada.Spec.Components != nil { - opt.Components = karmada.Spec.Components - } - - if karmada.Spec.HostCluster != nil { - opt.HostCluster = karmada.Spec.HostCluster - } } } diff --git a/operator/pkg/karmadaresource/apiservice/apiservice.go b/operator/pkg/karmadaresource/apiservice/apiservice.go index 5781027c5..48723d7d9 100644 --- a/operator/pkg/karmadaresource/apiservice/apiservice.go +++ b/operator/pkg/karmadaresource/apiservice/apiservice.go @@ -6,7 +6,6 @@ import ( corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" - kuberuntime "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/runtime/serializer" utilruntime "k8s.io/apimachinery/pkg/util/runtime" @@ -51,7 +50,7 @@ func aggregatedAPIService(client *aggregator.Clientset, name, namespace string) } apiService := &apiregistrationv1.APIService{} - if err := kuberuntime.DecodeInto(codecs.UniversalDecoder(), apiServiceBytes, apiService); err != nil { + if err := runtime.DecodeInto(codecs.UniversalDecoder(), apiServiceBytes, apiService); err != nil { return fmt.Errorf("err when decoding AggregatedApiserver APIService: %w", err) } @@ -74,7 +73,7 @@ func aggregatedApiserverService(client clientset.Interface, name, namespace stri } aggregatedService := &corev1.Service{} - if err := kuberuntime.DecodeInto(clientsetscheme.Codecs.UniversalDecoder(), aggregatedApiserverServiceBytes, aggregatedService); err != nil { + if err := runtime.DecodeInto(clientsetscheme.Codecs.UniversalDecoder(), aggregatedApiserverServiceBytes, aggregatedService); err != nil { return fmt.Errorf("err when decoding AggregatedApiserver Service: %w", err) }