kubevirt / hyperconverged-cluster-operator / 16164807415

coverage: 75.273% (+0.04%) from 75.231%
16164807415

Pull #3600

github

web-flow 
Merge ce328a81a into ab9b9c136
Pull Request #3600: network, passt: Introduce deployPasstNetworkBinding annotation

33 of 37 new or added lines in 2 files covered. (89.19%)

16 existing lines in 1 file now uncovered.

6542 of 8691 relevant lines covered (75.27%)

1.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

3.02
/pkg/components/components.go
1 
package components
2 









3



import (










4



        "encoding/json"










5



        "fmt"










6



        "strconv"










7



        "time"










8












9



        "github.com/blang/semver/v4"










10



        csvVersion "github.com/operator-framework/api/pkg/lib/version"










11



        csvv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"










12



        "golang.org/x/tools/go/packages"










13



        admissionregistrationv1 "k8s.io/api/admissionregistration/v1"










14



        appsv1 "k8s.io/api/apps/v1"










15



        corev1 "k8s.io/api/core/v1"










16



        rbacv1 "k8s.io/api/rbac/v1"










17



        extv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"










18



        "k8s.io/apimachinery/pkg/api/resource"










19



        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"










20



        "k8s.io/apimachinery/pkg/runtime"










21



        "k8s.io/apimachinery/pkg/runtime/schema"










22



        "k8s.io/apimachinery/pkg/util/intstr"










23



        "k8s.io/utils/ptr"










24



        crdgen "sigs.k8s.io/controller-tools/pkg/crd"










25



        crdmarkers "sigs.k8s.io/controller-tools/pkg/crd/markers"










26



        "sigs.k8s.io/controller-tools/pkg/loader"










27



        "sigs.k8s.io/controller-tools/pkg/markers"










28












29



        cnaoapi "github.com/kubevirt/cluster-network-addons-operator/pkg/apis/networkaddonsoperator/v1"










30



        kvapi "kubevirt.io/api/core"










31



        aaqapi "kubevirt.io/application-aware-quota/staging/src/kubevirt.io/application-aware-quota-api/pkg/apis/core"










32



        cdiapi "kubevirt.io/containerized-data-importer-api/pkg/apis/core"










33



        sspapi "kubevirt.io/ssp-operator/api/v1beta3"










34












35



        hcov1beta1 "github.com/kubevirt/hyperconverged-cluster-operator/api/v1beta1"










36



        "github.com/kubevirt/hyperconverged-cluster-operator/pkg/util"










37



)










38












39



const DisableOperandDeletionAnnotation = "console.openshift.io/disable-operand-delete"










40












41



const (










42



        crName              = util.HyperConvergedName










43



        packageName         = util.HyperConvergedName










44



        hcoName             = "hyperconverged-cluster-operator"










45



        hcoNameWebhook      = "hyperconverged-cluster-webhook"










46



        hcoDeploymentName   = "hco-operator"










47



        hcoWhDeploymentName = "hco-webhook"










48



        certVolume          = "apiservice-cert"










49












50



        cliDownloadsName = "hyperconverged-cluster-cli-download"










51












52



        kubevirtProjectName = "KubeVirt project"










53



        rbacVersionV1       = "rbac.authorization.k8s.io/v1"










54



)










55












56



var deploymentType = metav1.TypeMeta{










57



        APIVersion: "apps/v1",










58



        Kind:       "Deployment",










59



}










60












61



type DeploymentOperatorParams struct {










62



        Namespace              string










63



        Image                  string










64



        WebhookImage           string










65



        CliDownloadsImage      string










66



        KVUIPluginImage        string










67



        KVUIProxyImage         string










68



        PasstImage             string










69



        ImagePullPolicy        string










70



        ConversionContainer    string










71



        VmwareContainer        string










72



        VirtIOWinContainer     string










73



        Smbios                 string










74



        Machinetype            string










75



        Amd64MachineType       string










76



        Arm64MachineType       string










77



        HcoKvIoVersion         string










78



        KubevirtVersion        string










79



        KvVirtLancherOsVersion string










80



        CdiVersion             string










81



        CnaoVersion            string










82



        SspVersion             string










83



        HppoVersion            string










84



        MtqVersion             string










85



        AaqVersion             string










86



        Env                    []corev1.EnvVar










87



}










88












89



func GetDeploymentOperator(params *DeploymentOperatorParams) appsv1.Deployment {




×







90



        return appsv1.Deployment{




×







91



                TypeMeta: deploymentType,




×







92



                ObjectMeta: metav1.ObjectMeta{




×







93



                        Name: hcoName,




×







94



                        Labels: map[string]string{




×







95



                                "name": hcoName,




×







96



                        },




×







97



                },




×







98



                Spec: GetDeploymentSpecOperator(params),




×







99



        }




×







100



}




×







101












102



func GetDeploymentWebhook(namespace, image, imagePullPolicy, hcoKvIoVersion string, env []corev1.EnvVar) appsv1.Deployment {




×







103



        deploy := appsv1.Deployment{




×







104



                TypeMeta: deploymentType,




×







105



                ObjectMeta: metav1.ObjectMeta{




×







106



                        Name: hcoNameWebhook,




×







107



                        Labels: map[string]string{




×







108



                                "name": hcoNameWebhook,




×







109



                        },




×







110



                },




×







111



                Spec: GetDeploymentSpecWebhook(namespace, image, imagePullPolicy, hcoKvIoVersion, env),




×







112



        }




×







113






×







114



        InjectVolumesForWebHookCerts(&deploy)




×







115



        return deploy




×







116



}




×







117












118



func GetDeploymentCliDownloads(params *DeploymentOperatorParams) appsv1.Deployment {




×







119



        return appsv1.Deployment{




×







120



                TypeMeta: deploymentType,




×







121



                ObjectMeta: metav1.ObjectMeta{




×







122



                        Name: cliDownloadsName,




×







123



                        Labels: map[string]string{




×







124



                                "name": cliDownloadsName,




×







125



                        },




×







126



                },




×







127



                Spec: GetDeploymentSpecCliDownloads(params),




×







128



        }




×







129



}




×







130












131



func GetServiceWebhook() corev1.Service {




×







132



        return corev1.Service{




×







133



                TypeMeta: metav1.TypeMeta{




×







134



                        APIVersion: "v1",




×







135



                        Kind:       "Service",




×







136



                },




×







137



                ObjectMeta: metav1.ObjectMeta{




×







138



                        Name: hcoNameWebhook + "-service",




×







139



                },




×







140



                Spec: corev1.ServiceSpec{




×







141



                        Selector: map[string]string{




×







142



                                "name": hcoNameWebhook,




×







143



                        },




×







144



                        Ports: []corev1.ServicePort{




×







145



                                {




×







146



                                        Name:       strconv.Itoa(util.WebhookPort),




×







147



                                        Port:       util.WebhookPort,




×







148



                                        Protocol:   corev1.ProtocolTCP,




×







149



                                        TargetPort: intstr.FromInt32(util.WebhookPort),




×







150



                                },




×







151



                        },




×







152



                        Type: corev1.ServiceTypeClusterIP,




×







153



                },




×







154



        }




×







155



}




×







156












157



func GetDeploymentSpecOperator(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







158



        envs := buildEnvVars(params)




×







159






×







160



        return appsv1.DeploymentSpec{




×







161



                Replicas: ptr.To[int32](1),




×







162



                Selector: &metav1.LabelSelector{




×







163



                        MatchLabels: map[string]string{




×







164



                                "name": hcoName,




×







165



                        },




×







166



                },




×







167



                Strategy: appsv1.DeploymentStrategy{




×







168



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







169



                },




×







170



                Template: corev1.PodTemplateSpec{




×







171



                        ObjectMeta: metav1.ObjectMeta{




×







172



                                Labels: getLabels(hcoName, params.HcoKvIoVersion),




×







173



                        },




×







174



                        Spec: corev1.PodSpec{




×







175



                                ServiceAccountName: hcoName,




×







176



                                SecurityContext:    GetStdPodSecurityContext(),




×







177



                                Containers: []corev1.Container{




×







178



                                        {




×







179



                                                Name:            hcoName,




×







180



                                                Image:           params.Image,




×







181



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







182



                                                Command:         stringListToSlice(hcoName),




×







183



                                                ReadinessProbe:  getReadinessProbe(util.ReadinessEndpointName, util.HealthProbePort),




×







184



                                                LivenessProbe:   getLivenessProbe(util.LivenessEndpointName, util.HealthProbePort),




×







185



                                                Env:             envs,




×







186



                                                Resources: corev1.ResourceRequirements{




×







187



                                                        Requests: map[corev1.ResourceName]resource.Quantity{




×







188



                                                                corev1.ResourceCPU:    resource.MustParse("10m"),




×







189



                                                                corev1.ResourceMemory: resource.MustParse("96Mi"),




×







190



                                                        },




×







191



                                                },




×







192



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







193



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







194



                                                Ports: []corev1.ContainerPort{




×







195



                                                        getMetricsPort(),




×







196



                                                },




×







197



                                        },




×







198



                                },




×







199



                                PriorityClassName: "system-cluster-critical",




×







200



                        },




×







201



                },




×







202



        }




×







203



}




×







204












205



func buildEnvVars(params *DeploymentOperatorParams) []corev1.EnvVar {




×







206



        envs := append([]corev1.EnvVar{




×







207



                {




×







208



                        // deprecated: left here for CI test.




×







209



                        Name:  util.OperatorWebhookModeEnv,




×







210



                        Value: "false",




×







211



                },




×







212



                {




×







213



                        Name:  util.ContainerAppName,




×







214



                        Value: util.ContainerOperatorApp,




×







215



                },




×







216



                {




×







217



                        Name:  "KVM_EMULATION",




×







218



                        Value: "",




×







219



                },




×







220



                {




×







221



                        Name:  "OPERATOR_IMAGE",




×







222



                        Value: params.Image,




×







223



                },




×







224



                {




×







225



                        Name:  "OPERATOR_NAME",




×







226



                        Value: hcoName,




×







227



                },




×







228



                {




×







229



                        Name:  "OPERATOR_NAMESPACE",




×







230



                        Value: params.Namespace,




×







231



                },




×







232



                {




×







233



                        Name: "POD_NAME",




×







234



                        ValueFrom: &corev1.EnvVarSource{




×







235



                                FieldRef: &corev1.ObjectFieldSelector{




×







236



                                        FieldPath: "metadata.name",




×







237



                                },




×







238



                        },




×







239



                },




×







240



                {




×







241



                        Name:  "VIRTIOWIN_CONTAINER",




×







242



                        Value: params.VirtIOWinContainer,




×







243



                },




×







244



                {




×







245



                        Name:  "SMBIOS",




×







246



                        Value: params.Smbios,




×







247



                },




×







248



                {




×







249



                        Name:  "MACHINETYPE",




×







250



                        Value: params.Machinetype,




×







251



                },




×







252



                {




×







253



                        Name:  "AMD64_MACHINETYPE",




×







254



                        Value: params.Amd64MachineType,




×







255



                },




×







256



                {




×







257



                        Name:  "ARM64_MACHINETYPE",




×







258



                        Value: params.Arm64MachineType,




×







259



                },




×







260



                {




×







261



                        Name:  util.HcoKvIoVersionName,




×







262



                        Value: params.HcoKvIoVersion,




×







263



                },




×







264



                {




×







265



                        Name:  util.KubevirtVersionEnvV,




×







266



                        Value: params.KubevirtVersion,




×







267



                },




×







268



                {




×







269



                        Name:  util.CdiVersionEnvV,




×







270



                        Value: params.CdiVersion,




×







271



                },




×







272



                {




×







273



                        Name:  util.CnaoVersionEnvV,




×







274



                        Value: params.CnaoVersion,




×







275



                },




×







276



                {




×







277



                        Name:  util.SspVersionEnvV,




×







278



                        Value: params.SspVersion,




×







279



                },




×







280



                {




×







281



                        Name:  util.HppoVersionEnvV,




×







282



                        Value: params.HppoVersion,




×







283



                },




×







284



                {




×







285



                        Name:  util.AaqVersionEnvV,




×







286



                        Value: params.AaqVersion,




×







287



                },




×







288



                {




×







289



                        Name:  util.KVUIPluginImageEnvV,




×







290



                        Value: params.KVUIPluginImage,




×







291



                },




×







292



                {




×







293



                        Name:  util.KVUIProxyImageEnvV,




×







294



                        Value: params.KVUIProxyImage,




×







295



                },




×








NEW


296



                {




×








NEW


297



                        Name:  util.PasstImageEnvV,




×








NEW


298



                        Value: params.PasstImage,




×








NEW


299



                },




×







300



        }, params.Env...)




×







301






×







302



        if params.KvVirtLancherOsVersion != "" {




×







303



                envs = append(envs, corev1.EnvVar{




×







304



                        Name:  util.KvVirtLauncherOSVersionEnvV,




×







305



                        Value: params.KvVirtLancherOsVersion,




×







306



                })




×







307



        }




×







308












309



        return envs




×







310



}










311












312



func GetDeploymentSpecCliDownloads(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







313



        return appsv1.DeploymentSpec{




×







314



                Replicas: ptr.To[int32](1),




×







315



                Selector: &metav1.LabelSelector{




×







316



                        MatchLabels: map[string]string{




×







317



                                "name": cliDownloadsName,




×







318



                        },




×







319



                },




×







320



                Strategy: appsv1.DeploymentStrategy{




×







321



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







322



                },




×







323



                Template: corev1.PodTemplateSpec{




×







324



                        ObjectMeta: metav1.ObjectMeta{




×







325



                                Labels: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







326



                        },




×







327



                        Spec: corev1.PodSpec{




×







328



                                ServiceAccountName:           cliDownloadsName,




×







329



                                AutomountServiceAccountToken: ptr.To(false),




×







330



                                SecurityContext:              GetStdPodSecurityContext(),




×







331



                                Containers: []corev1.Container{




×







332



                                        {




×







333



                                                Name:            "server",




×







334



                                                Image:           params.CliDownloadsImage,




×







335



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







336



                                                Resources: corev1.ResourceRequirements{




×







337



                                                        Requests: map[corev1.ResourceName]resource.Quantity{




×







338



                                                                corev1.ResourceCPU:    resource.MustParse("10m"),




×







339



                                                                corev1.ResourceMemory: resource.MustParse("96Mi"),




×







340



                                                        },




×







341



                                                },




×







342



                                                Ports: []corev1.ContainerPort{




×







343



                                                        {




×







344



                                                                Protocol:      corev1.ProtocolTCP,




×







345



                                                                ContainerPort: util.CliDownloadsServerPort,




×







346



                                                        },




×







347



                                                },




×







348



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







349



                                                ReadinessProbe:           getReadinessProbe("/health", util.CliDownloadsServerPort),




×







350



                                                LivenessProbe:            getLivenessProbe("/health", util.CliDownloadsServerPort),




×







351



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







352



                                        },




×







353



                                },




×







354



                                PriorityClassName: "system-cluster-critical",




×







355



                        },




×







356



                },




×







357



        }




×







358



}




×







359












360



func getLabels(name, hcoKvIoVersion string) map[string]string {




×







361



        return map[string]string{




×







362



                "name":                 name,




×







363



                util.AppLabelVersion:   hcoKvIoVersion,




×







364



                util.AppLabelPartOf:    util.HyperConvergedCluster,




×







365



                util.AppLabelComponent: string(util.AppComponentDeployment),




×







366



        }




×







367



}




×







368












369



func GetStdPodSecurityContext() *corev1.PodSecurityContext {




3✔





370



        return &corev1.PodSecurityContext{




3✔





371



                RunAsNonRoot: ptr.To(true),




3✔





372



                SeccompProfile: &corev1.SeccompProfile{




3✔





373



                        Type: corev1.SeccompProfileTypeRuntimeDefault,




3✔





374



                },




3✔





375



        }




3✔





376



}




3✔





377












378



func GetStdContainerSecurityContext() *corev1.SecurityContext {




3✔





379



        return &corev1.SecurityContext{




3✔





380



                AllowPrivilegeEscalation: ptr.To(false),




3✔





381



                Capabilities: &corev1.Capabilities{




3✔





382



                        Drop: []corev1.Capability{"ALL"},




3✔





383



                },




3✔





384



        }




3✔





385



}




3✔





386












387



// Currently we are abusing the pod readiness to signal to OLM that HCO is not ready










388



// for an upgrade. This has a lot of side effects, one of this is the validating webhook










389



// being not able to receive traffic when exposed by a pod that is not reporting ready=true.










390



// This can cause a lot of side effects if not deadlocks when the system reach a status where,










391



// for any possible reason, HCO pod cannot be ready and so HCO pod cannot validate any further update or










392



// delete request on HCO CR.










393



// A proper solution is properly use the readiness probe only to report the pod readiness and communicate










394



// status to OLM via conditions once OLM will be ready for:










395



// https://github.com/operator-framework/enhancements/blob/master/enhancements/operator-conditions.md










396



// in the meanwhile a quick (but dirty!) solution is to expose the same hco binary on two distinct pods:










397



// the first one will run only the controller and the second one (almost always ready) just the validating










398



// webhook one.










399



func GetDeploymentSpecWebhook(namespace, image, imagePullPolicy, hcoKvIoVersion string, env []corev1.EnvVar) appsv1.DeploymentSpec {




×







400



        return appsv1.DeploymentSpec{




×







401



                Replicas: ptr.To[int32](1),




×







402



                Selector: &metav1.LabelSelector{




×







403



                        MatchLabels: map[string]string{




×







404



                                "name": hcoNameWebhook,




×







405



                        },




×







406



                },




×







407



                Strategy: appsv1.DeploymentStrategy{




×







408



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







409



                },




×







410



                Template: corev1.PodTemplateSpec{




×







411



                        ObjectMeta: metav1.ObjectMeta{




×







412



                                Labels: getLabels(hcoNameWebhook, hcoKvIoVersion),




×







413



                        },




×







414



                        Spec: corev1.PodSpec{




×







415



                                ServiceAccountName: hcoName,




×







416



                                SecurityContext:    GetStdPodSecurityContext(),




×







417



                                Containers: []corev1.Container{




×







418



                                        {




×







419



                                                Name:            hcoNameWebhook,




×







420



                                                Image:           image,




×







421



                                                ImagePullPolicy: corev1.PullPolicy(imagePullPolicy),




×







422



                                                Command:         stringListToSlice(hcoNameWebhook),




×







423



                                                ReadinessProbe:  getReadinessProbe(util.ReadinessEndpointName, util.HealthProbePort),




×







424



                                                LivenessProbe:   getLivenessProbe(util.LivenessEndpointName, util.HealthProbePort),




×







425



                                                Env: append([]corev1.EnvVar{




×







426



                                                        {




×







427



                                                                // deprecated: left here for CI test.




×







428



                                                                Name:  util.OperatorWebhookModeEnv,




×







429



                                                                Value: "true",




×







430



                                                        },




×







431



                                                        {




×







432



                                                                Name:  util.ContainerAppName,




×







433



                                                                Value: util.ContainerWebhookApp,




×







434



                                                        },




×







435



                                                        {




×







436



                                                                Name:  "OPERATOR_IMAGE",




×







437



                                                                Value: image,




×







438



                                                        },




×







439



                                                        {




×







440



                                                                Name:  "OPERATOR_NAME",




×







441



                                                                Value: hcoNameWebhook,




×







442



                                                        },




×







443



                                                        {




×







444



                                                                Name:  "OPERATOR_NAMESPACE",




×







445



                                                                Value: namespace,




×







446



                                                        },




×







447



                                                        {




×







448



                                                                Name: "POD_NAME",




×







449



                                                                ValueFrom: &corev1.EnvVarSource{




×







450



                                                                        FieldRef: &corev1.ObjectFieldSelector{




×







451



                                                                                FieldPath: "metadata.name",




×







452



                                                                        },




×







453



                                                                },




×







454



                                                        },




×







455



                                                }, env...),




×







456



                                                Resources: corev1.ResourceRequirements{




×







457



                                                        Requests: map[corev1.ResourceName]resource.Quantity{




×







458



                                                                corev1.ResourceCPU:    resource.MustParse("5m"),




×







459



                                                                corev1.ResourceMemory: resource.MustParse("48Mi"),




×







460



                                                        },




×







461



                                                },




×







462



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







463



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







464



                                                Ports: []corev1.ContainerPort{




×







465



                                                        getMetricsPort(),




×







466



                                                },




×







467



                                        },




×







468



                                },




×







469



                                PriorityClassName: "system-node-critical",




×







470



                        },




×







471



                },




×







472



        }




×







473



}




×







474












475



func GetClusterRole() rbacv1.ClusterRole {




×







476



        return rbacv1.ClusterRole{




×







477



                TypeMeta: metav1.TypeMeta{




×







478



                        APIVersion: rbacVersionV1,




×







479



                        Kind:       "ClusterRole",




×







480



                },




×







481



                ObjectMeta: metav1.ObjectMeta{




×







482



                        Name: hcoName,




×







483



                        Labels: map[string]string{




×







484



                                "name": hcoName,




×







485



                        },




×







486



                },




×







487



                Rules: GetClusterPermissions(),




×







488



        }




×







489



}




×







490












491



var (










492



        emptyAPIGroup = []string{""}










493



)










494












495



func GetClusterPermissions() []rbacv1.PolicyRule {




×







496



        const configOpenshiftIO = "config.openshift.io"




×







497



        const operatorOpenshiftIO = "operator.openshift.io"




×







498



        return []rbacv1.PolicyRule{




×







499



                {




×







500



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







501



                        Resources: stringListToSlice("hyperconvergeds"),




×







502



                        Verbs:     stringListToSlice("get", "list", "update", "watch"),




×







503



                },




×







504



                {




×







505



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







506



                        Resources: stringListToSlice("hyperconvergeds/finalizers", "hyperconvergeds/status"),




×







507



                        Verbs:     stringListToSlice("get", "list", "create", "update", "watch"),




×







508



                },




×







509



                roleWithAllPermissions(kvapi.GroupName, stringListToSlice("kubevirts", "kubevirts/finalizers")),




×







510



                roleWithAllPermissions(cdiapi.GroupName, stringListToSlice("cdis", "cdis/finalizers")),




×







511



                roleWithAllPermissions(sspapi.GroupVersion.Group, stringListToSlice("ssps", "ssps/finalizers")),




×







512



                roleWithAllPermissions(cnaoapi.GroupVersion.Group, stringListToSlice("networkaddonsconfigs", "networkaddonsconfigs/finalizers")),




×







513



                roleWithAllPermissions(aaqapi.GroupName, stringListToSlice("aaqs", "aaqs/finalizers")),




×







514



                roleWithAllPermissions("", stringListToSlice("configmaps")),




×







515



                {




×







516



                        APIGroups: emptyAPIGroup,




×







517



                        Resources: stringListToSlice("events"),




×







518



                        Verbs:     stringListToSlice("get", "list", "watch", "create", "patch"),




×







519



                },




×







520



                roleWithAllPermissions("", stringListToSlice("services")),




×







521



                {




×







522



                        APIGroups: emptyAPIGroup,




×







523



                        Resources: stringListToSlice("pods", "nodes"),




×







524



                        Verbs:     stringListToSlice("get", "list", "watch"),




×







525



                },




×







526



                {




×







527



                        APIGroups: emptyAPIGroup,




×







528



                        Resources: stringListToSlice("secrets"),




×







529



                        Verbs:     stringListToSlice("get", "list", "watch", "create", "update"),




×







530



                },




×







531



                {




×







532



                        APIGroups: emptyAPIGroup,




×







533



                        Resources: stringListToSlice("endpoints"),




×







534



                        Verbs:     stringListToSlice("get", "list", "delete", "watch"),




×







535



                },




×







536



                {




×







537



                        APIGroups: emptyAPIGroup,




×







538



                        Resources: stringListToSlice("namespaces"),




×







539



                        Verbs:     stringListToSlice("get", "list", "watch", "patch", "update"),




×







540



                },




×







541



                {




×







542



                        APIGroups: stringListToSlice("apps"),




×







543



                        Resources: stringListToSlice("deployments", "replicasets"),




×







544



                        Verbs:     stringListToSlice("get", "list", "watch", "create", "update", "delete"),




×







545



                },




×







546



                roleWithAllPermissions("rbac.authorization.k8s.io", stringListToSlice("roles", "rolebindings")),




×







547



                {




×







548



                        APIGroups: stringListToSlice("apiextensions.k8s.io"),




×







549



                        Resources: stringListToSlice("customresourcedefinitions"),




×







550



                        Verbs:     stringListToSlice("get", "list", "watch", "delete"),




×







551



                },




×







552



                {




×







553



                        APIGroups: stringListToSlice("apiextensions.k8s.io"),




×







554



                        Resources: stringListToSlice("customresourcedefinitions/status"),




×







555



                        Verbs:     stringListToSlice("get", "list", "watch", "patch", "update"),




×







556



                },




×







557



                roleWithAllPermissions("monitoring.coreos.com", stringListToSlice("servicemonitors", "prometheusrules")),




×







558



                {




×







559



                        APIGroups: stringListToSlice("operators.coreos.com"),




×







560



                        Resources: stringListToSlice("clusterserviceversions"),




×







561



                        Verbs:     stringListToSlice("get", "list", "watch", "update", "patch"),




×







562



                },




×







563



                {




×







564



                        APIGroups: stringListToSlice("scheduling.k8s.io"),




×







565



                        Resources: stringListToSlice("priorityclasses"),




×







566



                        Verbs:     stringListToSlice("get", "list", "watch", "create", "delete", "patch"),




×







567



                },




×







568



                {




×







569



                        APIGroups: stringListToSlice("admissionregistration.k8s.io"),




×







570



                        Resources: stringListToSlice("validatingwebhookconfigurations"),




×







571



                        Verbs:     stringListToSlice("list", "watch", "update", "patch"),




×







572



                },




×







573



                roleWithAllPermissions("console.openshift.io", stringListToSlice("consoleclidownloads", "consolequickstarts")),




×







574



                {




×







575



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







576



                        Resources: stringListToSlice("clusterversions", "infrastructures", "networks"),




×







577



                        Verbs:     stringListToSlice("get", "list"),




×







578



                },




×







579



                {




×







580



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







581



                        Resources: stringListToSlice("ingresses"),




×







582



                        Verbs:     stringListToSlice("get", "list", "watch"),




×







583



                },




×







584



                {




×







585



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







586



                        Resources: stringListToSlice("ingresses/status"),




×







587



                        Verbs:     stringListToSlice("update"),




×







588



                },




×







589



                {




×







590



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







591



                        Resources: stringListToSlice("apiservers"),




×







592



                        Verbs:     stringListToSlice("get", "list", "watch"),




×







593



                },




×







594



                {




×







595



                        APIGroups: stringListToSlice(operatorOpenshiftIO),




×







596



                        Resources: stringListToSlice("kubedeschedulers"),




×







597



                        Verbs:     stringListToSlice("get", "list", "watch"),




×







598



                },




×







599



                {




×







600



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







601



                        Resources: stringListToSlice("dnses"),




×







602



                        Verbs:     stringListToSlice("get"),




×







603



                },




×







604



                roleWithAllPermissions("coordination.k8s.io", stringListToSlice("leases")),




×







605



                roleWithAllPermissions("route.openshift.io", stringListToSlice("routes")),




×







606



                {




×







607



                        APIGroups: stringListToSlice("route.openshift.io"),




×







608



                        Resources: stringListToSlice("routes/custom-host"),




×







609



                        Verbs:     stringListToSlice("create", "update", "patch"),




×







610



                },




×







611



                {




×







612



                        APIGroups: stringListToSlice("operators.coreos.com"),




×







613



                        Resources: stringListToSlice("operatorconditions"),




×







614



                        Verbs:     stringListToSlice("get", "list", "watch", "update", "patch"),




×







615



                },




×







616



                roleWithAllPermissions("image.openshift.io", stringListToSlice("imagestreams")),




×







617



                roleWithAllPermissions("console.openshift.io", stringListToSlice("consoleplugins")),




×







618



                {




×







619



                        APIGroups: stringListToSlice("operator.openshift.io"),




×







620



                        Resources: stringListToSlice("consoles"),




×







621



                        Verbs:     stringListToSlice("get", "list", "watch", "update"),




×







622



                },




×







623



                {




×







624



                        APIGroups: stringListToSlice("monitoring.coreos.com"),




×







625



                        Resources: stringListToSlice("alertmanagers", "alertmanagers/api"),




×







626



                        Verbs:     stringListToSlice("get", "list", "create", "delete"),




×







627



                },




×







628



        }




×







629



}




×







630












631



func roleWithAllPermissions(apiGroup string, resources []string) rbacv1.PolicyRule {




×







632



        return rbacv1.PolicyRule{




×







633



                APIGroups: stringListToSlice(apiGroup),




×







634



                Resources: resources,




×







635



                Verbs:     stringListToSlice("get", "list", "watch", "create", "update", "delete", "patch"),




×







636



        }




×







637



}




×







638












639



func GetServiceAccount(namespace string) corev1.ServiceAccount {




×







640



        return createServiceAccount(namespace, hcoName)




×







641



}




×







642












643



func GetCLIDownloadServiceAccount(namespace string) corev1.ServiceAccount {




×







644



        return createServiceAccount(namespace, cliDownloadsName)




×







645



}




×







646












647



func createServiceAccount(namespace, name string) corev1.ServiceAccount {




×







648



        return corev1.ServiceAccount{




×







649



                TypeMeta: metav1.TypeMeta{




×







650



                        APIVersion: "v1",




×







651



                        Kind:       "ServiceAccount",




×







652



                },




×







653



                ObjectMeta: metav1.ObjectMeta{




×







654



                        Name:      name,




×







655



                        Namespace: namespace,




×







656



                        Labels: map[string]string{




×







657



                                "name": name,




×







658



                        },




×







659



                },




×







660



        }




×







661



}




×







662












663



func GetClusterRoleBinding(namespace string) rbacv1.ClusterRoleBinding {




×







664



        return rbacv1.ClusterRoleBinding{




×







665



                TypeMeta: metav1.TypeMeta{




×







666



                        APIVersion: rbacVersionV1,




×







667



                        Kind:       "ClusterRoleBinding",




×







668



                },




×







669



                ObjectMeta: metav1.ObjectMeta{




×







670



                        Name: hcoName,




×







671



                        Labels: map[string]string{




×







672



                                "name": hcoName,




×







673



                        },




×







674



                },




×







675



                RoleRef: rbacv1.RoleRef{




×







676



                        APIGroup: "rbac.authorization.k8s.io",




×







677



                        Kind:     "ClusterRole",




×







678



                        Name:     hcoName,




×







679



                },




×







680



                Subjects: []rbacv1.Subject{




×







681



                        {




×







682



                                Kind:      "ServiceAccount",




×







683



                                Name:      hcoName,




×







684



                                Namespace: namespace,




×







685



                        },




×







686



                },




×







687



        }




×







688



}




×







689












690



func packageErrors(pkg *loader.Package, filterKinds ...packages.ErrorKind) error {




×







691



        toSkip := make(map[packages.ErrorKind]struct{})




×







692



        for _, errKind := range filterKinds {




×







693



                toSkip[errKind] = struct{}{}




×







694



        }




×







695



        var outErr error




×







696



        packages.Visit([]*packages.Package{pkg.Package}, nil, func(pkgRaw *packages.Package) {




×







697



                for _, err := range pkgRaw.Errors {




×







698



                        if _, skip := toSkip[err.Kind]; skip {




×







699



                                continue




×







700



                        }










701



                        outErr = err




×







702



                }










703



        })










704



        return outErr




×







705



}










706












707



const objectType = "object"










708












709



func GetOperatorCRD(relPath string) *extv1.CustomResourceDefinition {




×







710



        pkgs, err := loader.LoadRoots(relPath)




×







711



        if err != nil {




×







712



                panic(err)




×







713



        }










714



        reg := &markers.Registry{}




×







715



        panicOnError(crdmarkers.Register(reg))




×







716






×







717



        parser := &crdgen.Parser{




×







718



                Collector:                  &markers.Collector{Registry: reg},




×







719



                Checker:                    &loader.TypeChecker{},




×







720



                GenerateEmbeddedObjectMeta: true,




×







721



        }




×







722






×







723



        crdgen.AddKnownTypes(parser)




×







724



        if len(pkgs) == 0 {




×







725



                panic("Failed identifying packages")




×







726



        }










727



        for _, p := range pkgs {




×







728



                parser.NeedPackage(p)




×







729



        }




×







730



        groupKind := schema.GroupKind{Kind: util.HyperConvergedKind, Group: util.APIVersionGroup}




×







731



        parser.NeedCRDFor(groupKind, nil)




×







732



        for _, p := range pkgs {




×







733



                err = packageErrors(p, packages.TypeError)




×







734



                if err != nil {




×







735



                        panic(err)




×







736



                }










737



        }










738



        c := parser.CustomResourceDefinitions[groupKind]




×







739



        // enforce validation of CR name to prevent multiple CRs




×







740



        for _, v := range c.Spec.Versions {




×







741



                v.Schema.OpenAPIV3Schema.Properties["metadata"] = extv1.JSONSchemaProps{




×







742



                        Type: objectType,




×







743



                        Properties: map[string]extv1.JSONSchemaProps{




×







744



                                "name": {




×







745



                                        Type:    "string",




×







746



                                        Pattern: hcov1beta1.HyperConvergedName,




×







747



                                },




×







748



                        },




×







749



                }




×







750



        }




×







751



        return &c




×







752



}










753












754



func GetOperatorCR() *hcov1beta1.HyperConverged {




10✔





755



        defaultScheme := runtime.NewScheme()




10✔





756



        _ = hcov1beta1.AddToScheme(defaultScheme)




10✔





757



        _ = hcov1beta1.RegisterDefaults(defaultScheme)




10✔





758



        defaultHco := &hcov1beta1.HyperConverged{




10✔





759



                TypeMeta: metav1.TypeMeta{




10✔





760



                        APIVersion: util.APIVersion,




10✔





761



                        Kind:       util.HyperConvergedKind,




10✔





762



                },




10✔





763



                ObjectMeta: metav1.ObjectMeta{




10✔





764



                        Name: crName,




10✔





765



                }}




10✔





766



        defaultScheme.Default(defaultHco)




10✔





767



        return defaultHco




10✔





768



}




10✔





769












770



// GetInstallStrategyBase returns the basics of an HCO InstallStrategy










771



func GetInstallStrategyBase(params *DeploymentOperatorParams) *csvv1alpha1.StrategyDetailsDeployment {




×







772



        return &csvv1alpha1.StrategyDetailsDeployment{




×







773






×







774



                DeploymentSpecs: []csvv1alpha1.StrategyDeploymentSpec{




×







775



                        {




×







776



                                Name:  hcoDeploymentName,




×







777



                                Spec:  GetDeploymentSpecOperator(params),




×







778



                                Label: getLabels(hcoName, params.HcoKvIoVersion),




×







779



                        },




×







780



                        {




×







781



                                Name:  hcoWhDeploymentName,




×







782



                                Spec:  GetDeploymentSpecWebhook(params.Namespace, params.WebhookImage, params.ImagePullPolicy, params.HcoKvIoVersion, params.Env),




×







783



                                Label: getLabels(hcoNameWebhook, params.HcoKvIoVersion),




×







784



                        },




×







785



                        {




×







786



                                Name:  cliDownloadsName,




×







787



                                Spec:  GetDeploymentSpecCliDownloads(params),




×







788



                                Label: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







789



                        },




×







790



                },




×







791



                Permissions: []csvv1alpha1.StrategyDeploymentPermissions{},




×







792



                ClusterPermissions: []csvv1alpha1.StrategyDeploymentPermissions{




×







793



                        {




×







794



                                ServiceAccountName: hcoName,




×







795



                                Rules:              GetClusterPermissions(),




×







796



                        },




×







797



                        {




×







798



                                ServiceAccountName: cliDownloadsName,




×







799



                                Rules:              []rbacv1.PolicyRule{},




×







800



                        },




×







801



                },




×







802



        }




×







803



}




×







804












805



type CSVBaseParams struct {










806



        Name            string










807



        Namespace       string










808



        DisplayName     string










809



        MetaDescription string










810



        Description     string










811



        Image           string










812



        Replaces        string










813



        Version         semver.Version










814



        CrdDisplay      string










815



}










816












817



// GetCSVBase returns a base HCO CSV without an InstallStrategy










818



func GetCSVBase(params *CSVBaseParams) *csvv1alpha1.ClusterServiceVersion {




×







819



        almExamples, _ := json.Marshal(




×







820



                map[string]interface{}{




×







821



                        "apiVersion": util.APIVersion,




×







822



                        "kind":       util.HyperConvergedKind,




×







823



                        "metadata": map[string]interface{}{




×







824



                                "name":      packageName,




×







825



                                "namespace": params.Namespace,




×







826



                                "annotations": map[string]string{




×







827



                                        "deployOVS": "false",




×







828



                                },




×







829



                        },




×







830



                        "spec": map[string]interface{}{},




×







831



                })




×







832






×







833



        // Explicitly fail on unvalidated (for any reason) requests:




×







834



        // this can make removing HCO CR harder if HCO webhook is not able




×







835



        // to really validate the requests.




×







836



        // In that case the user can only directly remove the




×







837



        // ValidatingWebhookConfiguration object first (eventually bypassing the OLM if needed).




×







838



        // so failurePolicy = admissionregistrationv1.Fail




×







839






×







840



        validatingWebhook := csvv1alpha1.WebhookDescription{




×







841



                GenerateName:            util.HcoValidatingWebhook,




×







842



                Type:                    csvv1alpha1.ValidatingAdmissionWebhook,




×







843



                DeploymentName:          hcoWhDeploymentName,




×







844



                ContainerPort:           util.WebhookPort,




×







845



                AdmissionReviewVersions: stringListToSlice("v1beta1", "v1"),




×







846



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNone),




×







847



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







848



                TimeoutSeconds:          ptr.To[int32](10),




×







849



                Rules: []admissionregistrationv1.RuleWithOperations{




×







850



                        {




×







851



                                Operations: []admissionregistrationv1.OperationType{




×







852



                                        admissionregistrationv1.Create,




×







853



                                        admissionregistrationv1.Delete,




×







854



                                        admissionregistrationv1.Update,




×







855



                                },




×







856



                                Rule: admissionregistrationv1.Rule{




×







857



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







858



                                        APIVersions: stringListToSlice(util.APIVersionAlpha, util.APIVersionBeta),




×







859



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







860



                                },




×







861



                        },




×







862



                },




×







863



                WebhookPath: ptr.To(util.HCOWebhookPath),




×







864



        }




×







865






×







866



        mutatingNamespaceWebhook := csvv1alpha1.WebhookDescription{




×







867



                GenerateName:            util.HcoMutatingWebhookNS,




×







868



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







869



                DeploymentName:          hcoWhDeploymentName,




×







870



                ContainerPort:           util.WebhookPort,




×







871



                AdmissionReviewVersions: stringListToSlice("v1beta1", "v1"),




×







872



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







873



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







874



                TimeoutSeconds:          ptr.To[int32](10),




×







875



                ObjectSelector: &metav1.LabelSelector{




×







876



                        MatchLabels: map[string]string{util.KubernetesMetadataName: params.Namespace},




×







877



                },




×







878



                Rules: []admissionregistrationv1.RuleWithOperations{




×







879



                        {




×







880



                                Operations: []admissionregistrationv1.OperationType{




×







881



                                        admissionregistrationv1.Delete,




×







882



                                },




×







883



                                Rule: admissionregistrationv1.Rule{




×







884



                                        APIGroups:   []string{""},




×







885



                                        APIVersions: stringListToSlice("v1"),




×







886



                                        Resources:   stringListToSlice("namespaces"),




×







887



                                },




×







888



                        },




×







889



                },




×







890



                WebhookPath: ptr.To(util.HCONSWebhookPath),




×







891



        }




×







892






×







893



        mutatingHyperConvergedWebhook := csvv1alpha1.WebhookDescription{




×







894



                GenerateName:            util.HcoMutatingWebhookHyperConverged,




×







895



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







896



                DeploymentName:          hcoWhDeploymentName,




×







897



                ContainerPort:           util.WebhookPort,




×







898



                AdmissionReviewVersions: stringListToSlice("v1beta1", "v1"),




×







899



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







900



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







901



                TimeoutSeconds:          ptr.To[int32](10),




×







902



                Rules: []admissionregistrationv1.RuleWithOperations{




×







903



                        {




×







904



                                Operations: []admissionregistrationv1.OperationType{




×







905



                                        admissionregistrationv1.Create,




×







906



                                        admissionregistrationv1.Update,




×







907



                                },




×







908



                                Rule: admissionregistrationv1.Rule{




×







909



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







910



                                        APIVersions: stringListToSlice(util.APIVersionAlpha, util.APIVersionBeta),




×







911



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







912



                                },




×







913



                        },




×







914



                },




×







915



                WebhookPath: ptr.To(util.HCOMutatingWebhookPath),




×







916



        }




×







917






×







918



        return &csvv1alpha1.ClusterServiceVersion{




×







919



                TypeMeta: metav1.TypeMeta{




×







920



                        APIVersion: "operators.coreos.com/v1alpha1",




×







921



                        Kind:       "ClusterServiceVersion",




×







922



                },




×







923



                ObjectMeta: metav1.ObjectMeta{




×







924



                        Name:      fmt.Sprintf("%v.v%v", params.Name, params.Version.String()),




×







925



                        Namespace: params.Namespace,




×







926



                        Annotations: map[string]string{




×







927



                                "alm-examples":                   string(almExamples),




×







928



                                "capabilities":                   "Deep Insights",




×







929



                                "certified":                      "false",




×







930



                                "categories":                     "OpenShift Optional",




×







931



                                "containerImage":                 params.Image,




×







932



                                DisableOperandDeletionAnnotation: "true",




×







933



                                "createdAt":                      time.Now().Format("2006-01-02 15:04:05"),




×







934



                                "description":                    params.MetaDescription,




×







935



                                "repository":                     "https://github.com/kubevirt/hyperconverged-cluster-operator",




×







936



                                "support":                        "false",




×







937



                                "operatorframework.io/suggested-namespace":         params.Namespace,




×







938



                                "operatorframework.io/initialization-resource":     string(almExamples),




×







939



                                "operators.openshift.io/infrastructure-features":   `["disconnected","proxy-aware"]`, // TODO: deprecated, remove once all the tools support "features.operators.openshift.io/*"




×







940



                                "features.operators.openshift.io/disconnected":     "true",




×







941



                                "features.operators.openshift.io/fips-compliant":   "false",




×







942



                                "features.operators.openshift.io/proxy-aware":      "true",




×







943



                                "features.operators.openshift.io/cnf":              "false",




×







944



                                "features.operators.openshift.io/cni":              "true",




×







945



                                "features.operators.openshift.io/csi":              "true",




×







946



                                "features.operators.openshift.io/tls-profiles":     "true",




×







947



                                "features.operators.openshift.io/token-auth-aws":   "false",




×







948



                                "features.operators.openshift.io/token-auth-azure": "false",




×







949



                                "features.operators.openshift.io/token-auth-gcp":   "false",




×







950



                                "openshift.io/required-scc":                        "restricted-v2",




×







951



                        },




×







952



                },




×







953



                Spec: csvv1alpha1.ClusterServiceVersionSpec{




×







954



                        DisplayName: params.DisplayName,




×







955



                        Description: params.Description,




×







956



                        Keywords:    stringListToSlice("KubeVirt", "Virtualization"),




×







957



                        Version:     csvVersion.OperatorVersion{Version: params.Version},




×







958



                        Replaces:    params.Replaces,




×







959



                        Maintainers: []csvv1alpha1.Maintainer{




×







960



                                {




×







961



                                        Name:  kubevirtProjectName,




×







962



                                        Email: "kubevirt-dev@googlegroups.com",




×







963



                                },




×







964



                        },




×







965



                        Maturity: "alpha",




×







966



                        Provider: csvv1alpha1.AppLink{




×







967



                                Name: kubevirtProjectName,




×







968



                                // https://github.com/operator-framework/operator-courier/issues/173




×







969



                                // URL:  "https://kubevirt.io",




×







970



                        },




×







971



                        Links: []csvv1alpha1.AppLink{




×







972



                                {




×







973



                                        Name: kubevirtProjectName,




×







974



                                        URL:  "https://kubevirt.io",




×







975



                                },




×







976



                                {




×







977



                                        Name: "Source Code",




×







978



                                        URL:  "https://github.com/kubevirt/hyperconverged-cluster-operator",




×







979



                                },




×







980



                        },




×







981



                        Icon: []csvv1alpha1.Icon{




×







982



                                {




×







983



                                        MediaType: "image/svg+xml",




×







984



                                        Data:      "<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 704 707"><defs/><g fill="none" fill-rule="evenodd"><path d="M88.33 140.89l.38-.4-.38.4zM74.18 167.72c.96-3.3 2.87-6.58 5.74-9.87-2.87 3.3-4.78 6.58-5.74 9.87zM227.52 690.71c-2.94 0-6.62 0-9.56-.99 3.67 0 6.62.99 9.56.99z"/><path fill="#00AAB2" fill-rule="nonzero" d="M606.84 136.94L371.29 20.54l-2.3-1.18a18.5 18.5 0 00-4.96-1.58c-1.53-.4-3.06-.79-4.6-.79-2.29-.39-4.96-.39-7.26-.39-4.97 0-9.56 0-14.53.79-1.53.4-3.06.4-4.97.79L97.12 135.36a34.91 34.91 0 00-8.03 5.13l-.38.4 121.98 253.3-91.77-193.33H273.8l61.94 117.97-21.41 41.04-.77.4-62.7-119.95H182.4l107.83 235.95 15.3-30c4.96-9.46 16.44-13.4 26-8.28a20.33 20.33 0 018.02 26.83l-27.9 54.06-21.42 41.03 62.7 129.81L412.22 569c-6.12 8.68-18.36 10.65-26.77 4.34-7.65-5.53-9.94-16.18-5.74-24.47l13.77-28.4c5.35-9.47 16.83-12.63 26-7.1 8.03 4.73 11.47 14.99 8.41 24.06l27.92-56.81c-6.12 8.68-18.36 10.65-26.77 3.94a19.93 19.93 0 01-5.73-24.46l27.53-56.42c4.59-9.87 16.06-13.81 25.62-8.68a19.65 19.65 0 018.41 26.43l-6.88 13.81 35.18-71.81c-6.12 9.08-17.98 11.44-26.39 5.13a19.78 19.78 0 01-6.5-24.86l27.15-56.42c4.59-9.86 16.06-13.81 25.62-8.68 9.56 4.73 13.38 16.57 8.41 26.44l-15.3 31.95 43.6-88.77c-5.36 9.47-16.83 13.02-26 7.5a20.03 20.03 0 01-9.18-13.03h-22.94c-10.71 0-19.12-8.68-19.12-19.72 0-11.05 8.41-19.73 19.12-19.73h79.91l-19.12 39.06 47.04-95.88a40.82 40.82 0 00-4.6-3.94 41.85 41.85 0 00-8.02-5.53zM405.7 344.1l-28.68 55.63c-4.97 9.47-16.44 13.42-26 8.29-9.56-5.13-13-16.97-8.03-26.83l28.67-55.64c4.98-9.47 16.45-13.41 26-8.28 9.57 5.13 13 17.36 8.04 26.83zm58.88-115.22l-28.68 56.03c-4.97 9.47-16.44 13.42-26 8.29a20.33 20.33 0 01-8.03-26.83l33.65-66.29h12.24c3.06 0 6.12.8 8.8 2.37a19.62 19.62 0 018.02 26.43z"/><path fill="#FFF" fill-rule="nonzero" d="M89.1 140.5a91.05 91.05 0 018.02-5.14L332.67 18.18c1.53-.4 3.06-.8 4.59-.8 4.97-.78 9.94-.78 14.91-.78 2.3 0 4.97 0 7.27.4 1.53.39 3.44.39 4.97.78 1.53.4 3.44.8 4.97 1.58l2.3 1.19 235.54 116.4a41.85 41.85 0 018.03 5.52 40.82 40.82 0 014.59 3.94l7.27-14.6c-3.83-3.15-8.03-6.31-12.62-8.68h-.77L378.18 6.34a54.3 54.3 0 00-26-5.52c-7.65-.4-15.3.4-22.95 1.97l-1.53.4-1.53.78L90.62 121.16a66.99 66.99 0 00-8.79 5.52l6.88 14.2.38-.39zM705.5 425.37l-.39-1.58-58.89-260.41v-1.19c-3.44-11.44-10.32-22.1-19.5-29.59l-7.26 14.6c4.2 4.34 8.03 9.47 10.32 15a22.74 22.74 0 011.53 4.73l58.5 260.41a92 92 0 01.39 10.26c0 3.15-.77 5.92-1.15 9.07 0 .8-.38 1.58-.38 2.37a56.23 56.23 0 01-7.65 16.97l-70.36 89.96-92.53 117.97c-6.12 8.68-15.68 14.2-26 15.78-3.06.4-6.5.8-9.56.8H352.94l58.88 15.78h70.75c20.26 0 37.09-8.29 47.8-22.89l162.89-207.93.38-.4.38-.4c9.56-14.6 13.77-31.95 11.47-49.31zM222.93 690.12c-1.53 0-3.44-.4-4.97-.4-2.3-.4-4.2-.79-6.5-1.57l-3.44-1.19c-2.3-.79-4.6-1.97-6.5-2.76a60.01 60.01 0 01-9.18-5.92c-1.91-1.58-3.83-3.16-5.36-4.73l-54.3-69.45-108.2-138.88a53.42 53.42 0 01-8.8-23.28c-.38-1.58-.38-3.16-.38-4.74 0-3.55 0-6.7.76-10.25l58.12-262a25.64 25.64 0 012.3-7.1c2.67-6.7 6.88-12.23 12.23-16.96l-6.88-14.2a57.53 57.53 0 00-22.56 34.71l-58.12 262v.79c-3.06 17.75 1.14 35.5 11.09 50.1l.38.4.38.4L175.51 683.4l.39.79.76.4a69.82 69.82 0 0045.5 21.3h130.78v-15.78H222.93z"/><path fill="#FFF" fill-rule="nonzero" d="M352.94 690.12v15.78h58.88z"/><path fill="#00797F" fill-rule="nonzero" d="M289.85 561.1l-79.16-166.5L88.33 140.88a41.68 41.68 0 00-12.24 16.96l-2.29 7.1-57.74 262c-.76 3.55-.76 6.7-.76 10.25 0 1.58 0 3.16.38 5.13a57.43 57.43 0 008.8 23.28L133.06 604.5l54.3 68.65c1.53 1.58 3.44 3.16 5.35 4.74a37.08 37.08 0 009.18 5.92c2.3 1.18 4.2 1.97 6.5 2.76l3.44 1.18c1.91.79 4.2 1.18 6.5 1.58 1.53.4 3.44.4 4.97.4h130.01L290.99 559.9l-1.14 1.19z"/><path d="M15.3 437.2c0-3.55 0-6.7 1.9-10.25"/><path fill="#00797F" fill-rule="nonzero" d="M196.93 683.41c-3.42-3.29-6.83-6.58-9.56-9.86 2.73 3.28 6.14 6.57 9.56 9.86z"/><path d="M202.28 687.75a68.7 68.7 0 01-9.56-9.86M187.37 673.15l-54.3-69.05M217 689.92l-8.6-2.96"/><path fill="#00797F" fill-rule="nonzero" d="M211.46 691.1c-3.38-1.97-6.75-4.93-9.56-6.9 2.8 1.97 6.18 4.93 9.56 6.9z"/><path fill="#3ACCC5" fill-rule="nonzero" d="M570.13 247.42l-43.6 88.78-11.84 24.46a8.68 8.68 0 01-1.15 1.97l-35.18 71.42-20.65 42.61c-.38.79-1.15 1.97-1.53 2.76l-27.91 57.21c0 .4 0 .4-.39.8l-13.76 28.4c-.38.79-1.15 1.97-1.53 2.76l-59.27 120.74h129.63c3.06 0 6.5-.4 9.56-.79a39.8 39.8 0 0026-15.78l92.54-117.98 70.35-89.96a52.2 52.2 0 007.65-16.96c.38-.8.38-1.58.38-2.37a36.9 36.9 0 001.15-9.08c0-3.55 0-6.7-.38-10.25l-58.5-259.63c-.39-1.57-1.15-3.15-1.54-4.73-2.29-5.52-6.11-10.65-10.32-15l-47.03 95.49-2.68 5.13z"/><path d="M692.3 437.2c0 3.43-1.91 6.44-2.87 9.87M692.68 448.65c-1.9 3.45-3.82 6.9-6.69 9.86M492.12 689.33a39.8 39.8 0 0026-15.78l92.54-117.98M690.58 426.95c.96 3.55.96 6.7.96 10.25"/><path fill="#FFF" fill-rule="nonzero" d="M397.68 317.26c-9.18-5.13-21.03-1.58-26 8.28L343 381.18c-4.97 9.47-1.53 21.7 8.03 26.83 9.17 5.13 21.03 1.57 26-8.29l28.68-55.63c4.97-9.47 1.14-21.7-8.03-26.83zM419.09 511.38a19.03 19.03 0 00-25.62 8.68l-13.77 28.41c-4.58 9.86-.76 21.7 8.8 26.44 8.41 4.34 18.35 1.57 23.7-5.92l15.68-31.96c4.21-9.47.39-20.91-8.79-25.65zM427.88 537.82c0-.4 0-.4.39-.8L412.59 569a6.41 6.41 0 001.53-2.76l13.76-28.41z"/><path fill="#FFF" fill-rule="nonzero" d="M311.64 519.27l27.91-54.05c4.98-9.47 1.53-21.7-8.03-26.83-9.17-5.13-21.03-1.58-26 8.28l-15.3 29.99L182.4 240.32h68.44l62.71 119.94.77-.4 21.03-40.63-61.95-118.37H118.54L210.3 394.2l79.92 165.71 21.41-40.64z"/><path fill="#FFF" fill-rule="nonzero" d="M290.23 560.31l-79.54-165.72 79.16 166.51zM591.54 203.23h-79.91c-10.71 0-19.12 8.68-19.12 19.73 0 11.04 8.41 19.72 19.12 19.72h22.94c2.3 10.66 12.62 17.37 22.94 15a19.5 19.5 0 0012.62-9.47l2.68-5.53 18.73-39.45zM576.82 242.29l-6.69 9.86.96-.7zM541.83 304.63c4.98-9.86 1.15-21.7-8.4-26.44-9.57-4.73-21.04-1.18-25.63 8.69v.39l-27.15 56.42c-4.59 9.87-.76 21.7 8.8 26.44 8.41 4.34 18.73 1.58 24.09-6.71l13-26.83 15.3-31.96z"/><path fill="#FFF" fill-rule="nonzero" d="M526.54 336.59l-13 26.83c.38-.79.76-1.58 1.15-1.97l11.85-24.86zM484.86 421.03c4.59-9.87.76-21.7-8.41-26.44-9.18-4.73-21.03-.79-25.62 8.68l-27.15 56.42c-4.59 9.87-.77 21.7 8.8 26.44 8.4 4.34 18.35 1.58 23.7-5.92l22.18-45.37 6.5-13.81z"/><path fill="#FFF" fill-rule="nonzero" d="M478.36 434.84l-22.18 45.37c.77-.79 1.15-1.97 1.53-2.76l20.65-42.61zM456.56 202.44a17.34 17.34 0 00-8.8-2.37h-11.85l-33.64 66.29a20.15 20.15 0 004.97 27.62c8.8 6.31 20.64 3.94 26.76-5.13.77-1.19 1.53-2.37 1.91-3.95l28.68-55.63c4.97-9.86 1.53-21.7-8.03-26.83.39 0 0 0 0 0z"/></g></svg>",




×







985



                                },




×







986



                        },




×







987



                        Labels: map[string]string{




×







988



                                "alm-owner-kubevirt": packageName,




×







989



                                "operated-by":        packageName,




×







990



                        },




×







991



                        Selector: &metav1.LabelSelector{




×







992



                                MatchLabels: map[string]string{




×







993



                                        "alm-owner-kubevirt": packageName,




×







994



                                        "operated-by":        packageName,




×







995



                                },




×







996



                        },




×







997



                        InstallModes: []csvv1alpha1.InstallMode{




×







998



                                {




×







999



                                        Type:      csvv1alpha1.InstallModeTypeOwnNamespace,




×







1000



                                        Supported: false,




×







1001



                                },




×







1002



                                {




×







1003



                                        Type:      csvv1alpha1.InstallModeTypeSingleNamespace,




×







1004



                                        Supported: false,




×







1005



                                },




×







1006



                                {




×







1007



                                        Type:      csvv1alpha1.InstallModeTypeMultiNamespace,




×







1008



                                        Supported: false,




×







1009



                                },




×







1010



                                {




×







1011



                                        Type:      csvv1alpha1.InstallModeTypeAllNamespaces,




×







1012



                                        Supported: true,




×







1013



                                },




×







1014



                        },




×







1015



                        // Skip this in favor of having a separate function to get




×







1016



                        // the actual StrategyDetailsDeployment when merging CSVs




×







1017



                        InstallStrategy: csvv1alpha1.NamedInstallStrategy{},




×







1018



                        WebhookDefinitions: []csvv1alpha1.WebhookDescription{




×







1019



                                validatingWebhook,




×







1020



                                mutatingNamespaceWebhook,




×







1021



                                mutatingHyperConvergedWebhook,




×







1022



                        },




×







1023



                        CustomResourceDefinitions: csvv1alpha1.CustomResourceDefinitions{




×







1024



                                Owned: []csvv1alpha1.CRDDescription{




×







1025



                                        {




×







1026



                                                Name:        "hyperconvergeds.hco.kubevirt.io",




×







1027



                                                Version:     util.CurrentAPIVersion,




×







1028



                                                Kind:        util.HyperConvergedKind,




×







1029



                                                DisplayName: params.CrdDisplay + " Deployment",




×







1030



                                                Description: "Represents the deployment of " + params.CrdDisplay,




×







1031



                                                // TODO: move this to annotations on hyperconverged_types.go once kubebuilder




×







1032



                                                // properly supports SpecDescriptors as the operator-sdk already does




×







1033



                                                SpecDescriptors: []csvv1alpha1.SpecDescriptor{




×







1034



                                                        {




×







1035



                                                                DisplayName: "Infra components node affinity",




×







1036



                                                                Description: "nodeAffinity describes node affinity scheduling rules for the infra pods.",




×







1037



                                                                Path:        "infra.nodePlacement.affinity.nodeAffinity",




×







1038



                                                                XDescriptors: stringListToSlice(




×







1039



                                                                        "urn:alm:descriptor:com.tectonic.ui:nodeAffinity",




×







1040



                                                                ),




×







1041



                                                        },




×







1042



                                                        {




×







1043



                                                                DisplayName: "Infra components pod affinity",




×







1044



                                                                Description: "podAffinity describes pod affinity scheduling rules for the infra pods.",




×







1045



                                                                Path:        "infra.nodePlacement.affinity.podAffinity",




×







1046



                                                                XDescriptors: stringListToSlice(




×







1047



                                                                        "urn:alm:descriptor:com.tectonic.ui:podAffinity",




×







1048



                                                                ),




×







1049



                                                        },




×







1050



                                                        {




×







1051



                                                                DisplayName: "Infra components pod anti-affinity",




×







1052



                                                                Description: "podAntiAffinity describes pod anti affinity scheduling rules for the infra pods.",




×







1053



                                                                Path:        "infra.nodePlacement.affinity.podAntiAffinity",




×







1054



                                                                XDescriptors: stringListToSlice(




×







1055



                                                                        "urn:alm:descriptor:com.tectonic.ui:podAntiAffinity",




×







1056



                                                                ),




×







1057



                                                        },




×







1058



                                                        {




×







1059



                                                                DisplayName: "Workloads components node affinity",




×







1060



                                                                Description: "nodeAffinity describes node affinity scheduling rules for the workloads pods.",




×







1061



                                                                Path:        "workloads.nodePlacement.affinity.nodeAffinity",




×







1062



                                                                XDescriptors: stringListToSlice(




×







1063



                                                                        "urn:alm:descriptor:com.tectonic.ui:nodeAffinity",




×







1064



                                                                ),




×







1065



                                                        },




×







1066



                                                        {




×







1067



                                                                DisplayName: "Workloads components pod affinity",




×







1068



                                                                Description: "podAffinity describes pod affinity scheduling rules for the workloads pods.",




×







1069



                                                                Path:        "workloads.nodePlacement.affinity.podAffinity",




×







1070



                                                                XDescriptors: stringListToSlice(




×







1071



                                                                        "urn:alm:descriptor:com.tectonic.ui:podAffinity",




×







1072



                                                                ),




×







1073



                                                        },




×







1074



                                                        {




×







1075



                                                                DisplayName: "Workloads components pod anti-affinity",




×







1076



                                                                Description: "podAntiAffinity describes pod anti affinity scheduling rules for the workloads pods.",




×







1077



                                                                Path:        "workloads.nodePlacement.affinity.podAntiAffinity",




×







1078



                                                                XDescriptors: stringListToSlice(




×







1079



                                                                        "urn:alm:descriptor:com.tectonic.ui:podAntiAffinity",




×







1080



                                                                ),




×







1081



                                                        },




×







1082



                                                        {




×







1083



                                                                DisplayName: "HIDDEN FIELDS - operator version",




×







1084



                                                                Description: "HIDDEN FIELDS - operator version.",




×







1085



                                                                Path:        "version",




×







1086



                                                                XDescriptors: stringListToSlice(




×







1087



                                                                        "urn:alm:descriptor:com.tectonic.ui:hidden",




×







1088



                                                                ),




×







1089



                                                        },




×







1090



                                                },




×







1091



                                                StatusDescriptors: []csvv1alpha1.StatusDescriptor{},




×







1092



                                        },




×







1093



                                },




×







1094



                                Required: []csvv1alpha1.CRDDescription{},




×







1095



                        },




×







1096



                },




×







1097



        }




×







1098



}




×







1099












1100



func InjectVolumesForWebHookCerts(deploy *appsv1.Deployment) {




×







1101



        // check if there is already a volume for api certificates




×







1102



        for _, vol := range deploy.Spec.Template.Spec.Volumes {




×







1103



                if vol.Name == certVolume {




×







1104



                        return




×







1105



                }




×







1106



        }










1107












1108



        volume := corev1.Volume{




×







1109



                Name: certVolume,




×







1110



                VolumeSource: corev1.VolumeSource{




×







1111



                        Secret: &corev1.SecretVolumeSource{




×







1112



                                SecretName:  deploy.Name + "-service-cert",




×







1113



                                DefaultMode: ptr.To[int32](420),




×







1114



                                Items: []corev1.KeyToPath{




×







1115



                                        {




×







1116



                                                Key:  "tls.crt",




×







1117



                                                Path: util.WebhookCertName,




×







1118



                                        },




×







1119



                                        {




×







1120



                                                Key:  "tls.key",




×







1121



                                                Path: util.WebhookKeyName,




×







1122



                                        },




×







1123



                                },




×







1124



                        },




×







1125



                },




×







1126



        }




×







1127



        deploy.Spec.Template.Spec.Volumes = append(deploy.Spec.Template.Spec.Volumes, volume)




×







1128






×







1129



        for index, container := range deploy.Spec.Template.Spec.Containers {




×







1130



                deploy.Spec.Template.Spec.Containers[index].VolumeMounts = append(container.VolumeMounts,




×







1131



                        corev1.VolumeMount{




×







1132



                                Name:      certVolume,




×







1133



                                MountPath: util.DefaultWebhookCertDir,




×







1134



                        })




×







1135



        }




×







1136



}










1137












1138



func getReadinessProbe(endpoint string, port int32) *corev1.Probe {




×







1139



        return &corev1.Probe{




×







1140



                ProbeHandler: corev1.ProbeHandler{




×







1141



                        HTTPGet: &corev1.HTTPGetAction{




×







1142



                                Path: endpoint,




×







1143



                                Port: intstr.IntOrString{




×







1144



                                        Type:   intstr.Int,




×







1145



                                        IntVal: port,




×







1146



                                },




×







1147



                                Scheme: corev1.URISchemeHTTP,




×







1148



                        },




×







1149



                },




×







1150



                InitialDelaySeconds: 5,




×







1151



                PeriodSeconds:       5,




×







1152



                FailureThreshold:    1,




×







1153



        }




×







1154



}




×







1155












1156



func getLivenessProbe(endpoint string, port int32) *corev1.Probe {




×







1157



        return &corev1.Probe{




×







1158



                ProbeHandler: corev1.ProbeHandler{




×







1159



                        HTTPGet: &corev1.HTTPGetAction{




×







1160



                                Path: endpoint,




×







1161



                                Port: intstr.IntOrString{




×







1162



                                        Type:   intstr.Int,




×







1163



                                        IntVal: port,




×







1164



                                },




×







1165



                                Scheme: corev1.URISchemeHTTP,




×







1166



                        },




×







1167



                },




×







1168



                InitialDelaySeconds: 30,




×







1169



                PeriodSeconds:       5,




×







1170



                FailureThreshold:    1,




×







1171



        }




×







1172



}




×







1173












1174



func getMetricsPort() corev1.ContainerPort {




×







1175



        return corev1.ContainerPort{




×







1176



                Name:          util.MetricsPortName,




×







1177



                ContainerPort: util.MetricsPort,




×







1178



                Protocol:      corev1.ProtocolTCP,




×







1179



        }




×







1180



}




×







1181












1182



func stringListToSlice(words ...string) []string {




×







1183



        return words




×







1184



}




×







1185












1186



func panicOnError(err error) {




×







1187



        if err != nil {




×







1188



                panic(err)




×







1189



        }










1190



}
























    

  • 

    •