kubevirt / hyperconverged-cluster-operator / 14350314198

coverage: 72.262%. First build
14350314198

Pull #3386

github

web-flow 
Merge 5292e1051 into 9ffa79842
Pull Request #3386: Set terminationMessagePolicy=FallbackToLogsOnError

1 of 9 new or added lines in 2 files covered. (11.11%)

6531 of 9038 relevant lines covered (72.26%)

0.95 hits per line

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

3.07
/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/v1beta2"










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



        ImagePullPolicy        string










69



        ConversionContainer    string










70



        VmwareContainer        string










71



        VirtIOWinContainer     string










72



        Smbios                 string










73



        Machinetype            string










74



        Amd64MachineType       string










75



        Arm64MachineType       string










76



        HcoKvIoVersion         string










77



        KubevirtVersion        string










78



        KvVirtLancherOsVersion string










79



        CdiVersion             string










80



        CnaoVersion            string










81



        SspVersion             string










82



        HppoVersion            string










83



        MtqVersion             string










84



        AaqVersion             string










85



        Env                    []corev1.EnvVar










86



}










87












88



func GetDeploymentOperator(params *DeploymentOperatorParams) appsv1.Deployment {




×







89



        return appsv1.Deployment{




×







90



                TypeMeta: deploymentType,




×







91



                ObjectMeta: metav1.ObjectMeta{




×







92



                        Name: hcoName,




×







93



                        Labels: map[string]string{




×







94



                                "name": hcoName,




×







95



                        },




×







96



                },




×







97



                Spec: GetDeploymentSpecOperator(params),




×







98



        }




×







99



}




×







100












101



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




×







102



        deploy := appsv1.Deployment{




×







103



                TypeMeta: deploymentType,




×







104



                ObjectMeta: metav1.ObjectMeta{




×







105



                        Name: hcoNameWebhook,




×







106



                        Labels: map[string]string{




×







107



                                "name": hcoNameWebhook,




×







108



                        },




×







109



                },




×







110



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




×







111



        }




×







112






×







113



        InjectVolumesForWebHookCerts(&deploy)




×







114



        return deploy




×







115



}




×







116












117



func GetDeploymentCliDownloads(params *DeploymentOperatorParams) appsv1.Deployment {




×







118



        return appsv1.Deployment{




×







119



                TypeMeta: deploymentType,




×







120



                ObjectMeta: metav1.ObjectMeta{




×







121



                        Name: cliDownloadsName,




×







122



                        Labels: map[string]string{




×







123



                                "name": cliDownloadsName,




×







124



                        },




×







125



                },




×







126



                Spec: GetDeploymentSpecCliDownloads(params),




×







127



        }




×







128



}




×







129












130



func GetServiceWebhook() corev1.Service {




×







131



        return corev1.Service{




×







132



                TypeMeta: metav1.TypeMeta{




×







133



                        APIVersion: "v1",




×







134



                        Kind:       "Service",




×







135



                },




×







136



                ObjectMeta: metav1.ObjectMeta{




×







137



                        Name: hcoNameWebhook + "-service",




×







138



                },




×







139



                Spec: corev1.ServiceSpec{




×







140



                        Selector: map[string]string{




×







141



                                "name": hcoNameWebhook,




×







142



                        },




×







143



                        Ports: []corev1.ServicePort{




×







144



                                {




×







145



                                        Name:       strconv.Itoa(util.WebhookPort),




×







146



                                        Port:       util.WebhookPort,




×







147



                                        Protocol:   corev1.ProtocolTCP,




×







148



                                        TargetPort: intstr.FromInt32(util.WebhookPort),




×







149



                                },




×







150



                        },




×







151



                        Type: corev1.ServiceTypeClusterIP,




×







152



                },




×







153



        }




×







154



}




×







155












156



func GetDeploymentSpecOperator(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







157



        envs := buildEnvVars(params)




×







158






×







159



        return appsv1.DeploymentSpec{




×







160



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




×







161



                Selector: &metav1.LabelSelector{




×







162



                        MatchLabels: map[string]string{




×







163



                                "name": hcoName,




×







164



                        },




×







165



                },




×







166



                Strategy: appsv1.DeploymentStrategy{




×







167



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







168



                },




×







169



                Template: corev1.PodTemplateSpec{




×







170



                        ObjectMeta: metav1.ObjectMeta{




×







171



                                Labels: getLabels(hcoName, params.HcoKvIoVersion),




×







172



                        },




×







173



                        Spec: corev1.PodSpec{




×







174



                                ServiceAccountName: hcoName,




×







175



                                SecurityContext:    GetStdPodSecurityContext(),




×







176



                                Containers: []corev1.Container{




×







177



                                        {




×







178



                                                Name:            hcoName,




×







179



                                                Image:           params.Image,




×







180



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







181



                                                Command:         stringListToSlice(hcoName),




×







182



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




×







183



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




×







184



                                                Env:             envs,




×







185



                                                Resources: corev1.ResourceRequirements{




×







186



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




×







187



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




×







188



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




×







189



                                                        },




×







190



                                                },




×








NEW


191



                                                SecurityContext:          GetStdContainerSecurityContext(),




×








NEW


192



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







193



                                        },




×







194



                                },




×







195



                                PriorityClassName: "system-cluster-critical",




×







196



                        },




×







197



                },




×







198



        }




×







199



}




×







200












201



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




×







202



        envs := append([]corev1.EnvVar{




×







203



                {




×







204



                        // deprecated: left here for CI test.




×







205



                        Name:  util.OperatorWebhookModeEnv,




×







206



                        Value: "false",




×







207



                },




×







208



                {




×







209



                        Name:  util.ContainerAppName,




×







210



                        Value: util.ContainerOperatorApp,




×







211



                },




×







212



                {




×







213



                        Name:  "KVM_EMULATION",




×







214



                        Value: "",




×







215



                },




×







216



                {




×







217



                        Name:  "OPERATOR_IMAGE",




×







218



                        Value: params.Image,




×







219



                },




×







220



                {




×







221



                        Name:  "OPERATOR_NAME",




×







222



                        Value: hcoName,




×







223



                },




×







224



                {




×







225



                        Name:  "OPERATOR_NAMESPACE",




×







226



                        Value: params.Namespace,




×







227



                },




×







228



                {




×







229



                        Name: "POD_NAME",




×







230



                        ValueFrom: &corev1.EnvVarSource{




×







231



                                FieldRef: &corev1.ObjectFieldSelector{




×







232



                                        FieldPath: "metadata.name",




×







233



                                },




×







234



                        },




×







235



                },




×







236



                {




×







237



                        Name:  "VIRTIOWIN_CONTAINER",




×







238



                        Value: params.VirtIOWinContainer,




×







239



                },




×







240



                {




×







241



                        Name:  "SMBIOS",




×







242



                        Value: params.Smbios,




×







243



                },




×







244



                {




×







245



                        Name:  "MACHINETYPE",




×







246



                        Value: params.Machinetype,




×







247



                },




×







248



                {




×







249



                        Name:  "AMD64_MACHINETYPE",




×







250



                        Value: params.Amd64MachineType,




×







251



                },




×







252



                {




×







253



                        Name:  "ARM64_MACHINETYPE",




×







254



                        Value: params.Arm64MachineType,




×







255



                },




×







256



                {




×







257



                        Name:  util.HcoKvIoVersionName,




×







258



                        Value: params.HcoKvIoVersion,




×







259



                },




×







260



                {




×







261



                        Name:  util.KubevirtVersionEnvV,




×







262



                        Value: params.KubevirtVersion,




×







263



                },




×







264



                {




×







265



                        Name:  util.CdiVersionEnvV,




×







266



                        Value: params.CdiVersion,




×







267



                },




×







268



                {




×







269



                        Name:  util.CnaoVersionEnvV,




×







270



                        Value: params.CnaoVersion,




×







271



                },




×







272



                {




×







273



                        Name:  util.SspVersionEnvV,




×







274



                        Value: params.SspVersion,




×







275



                },




×







276



                {




×







277



                        Name:  util.HppoVersionEnvV,




×







278



                        Value: params.HppoVersion,




×







279



                },




×







280



                {




×







281



                        Name:  util.AaqVersionEnvV,




×







282



                        Value: params.AaqVersion,




×







283



                },




×







284



                {




×







285



                        Name:  util.KVUIPluginImageEnvV,




×







286



                        Value: params.KVUIPluginImage,




×







287



                },




×







288



                {




×







289



                        Name:  util.KVUIProxyImageEnvV,




×







290



                        Value: params.KVUIProxyImage,




×







291



                },




×







292



        }, params.Env...)




×







293






×







294



        if params.KvVirtLancherOsVersion != "" {




×







295



                envs = append(envs, corev1.EnvVar{




×







296



                        Name:  util.KvVirtLauncherOSVersionEnvV,




×







297



                        Value: params.KvVirtLancherOsVersion,




×







298



                })




×







299



        }




×







300












301



        return envs




×







302



}










303












304



func GetDeploymentSpecCliDownloads(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







305



        return appsv1.DeploymentSpec{




×







306



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




×







307



                Selector: &metav1.LabelSelector{




×







308



                        MatchLabels: map[string]string{




×







309



                                "name": cliDownloadsName,




×







310



                        },




×







311



                },




×







312



                Strategy: appsv1.DeploymentStrategy{




×







313



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







314



                },




×







315



                Template: corev1.PodTemplateSpec{




×







316



                        ObjectMeta: metav1.ObjectMeta{




×







317



                                Labels: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







318



                        },




×







319



                        Spec: corev1.PodSpec{




×







320



                                ServiceAccountName:           cliDownloadsName,




×







321



                                AutomountServiceAccountToken: ptr.To(false),




×







322



                                SecurityContext:              GetStdPodSecurityContext(),




×







323



                                Containers: []corev1.Container{




×







324



                                        {




×







325



                                                Name:            "server",




×







326



                                                Image:           params.CliDownloadsImage,




×







327



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







328



                                                Resources: corev1.ResourceRequirements{




×







329



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




×







330



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




×







331



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




×







332



                                                        },




×







333



                                                },




×







334



                                                Ports: []corev1.ContainerPort{




×







335



                                                        {




×







336



                                                                Protocol:      corev1.ProtocolTCP,




×







337



                                                                ContainerPort: int32(8080),




×







338



                                                        },




×







339



                                                },




×








NEW


340



                                                SecurityContext:          GetStdContainerSecurityContext(),




×








NEW


341



                                                ReadinessProbe:           getReadinessProbe("/health", 8080),




×








NEW


342



                                                LivenessProbe:            getLivenessProbe("/health", 8080),




×








NEW


343



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







344



                                        },




×







345



                                },




×







346



                                PriorityClassName: "system-cluster-critical",




×







347



                        },




×







348



                },




×







349



        }




×







350



}




×







351












352



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




×







353



        return map[string]string{




×







354



                "name":                 name,




×







355



                util.AppLabelVersion:   hcoKvIoVersion,




×







356



                util.AppLabelPartOf:    util.HyperConvergedCluster,




×







357



                util.AppLabelComponent: string(util.AppComponentDeployment),




×







358



        }




×







359



}




×







360












361



func GetStdPodSecurityContext() *corev1.PodSecurityContext {




2✔





362



        return &corev1.PodSecurityContext{




2✔





363



                RunAsNonRoot: ptr.To(true),




2✔





364



                SeccompProfile: &corev1.SeccompProfile{




2✔





365



                        Type: corev1.SeccompProfileTypeRuntimeDefault,




2✔





366



                },




2✔





367



        }




2✔





368



}




2✔





369












370



func GetStdContainerSecurityContext() *corev1.SecurityContext {




2✔





371



        return &corev1.SecurityContext{




2✔





372



                AllowPrivilegeEscalation: ptr.To(false),




2✔





373



                Capabilities: &corev1.Capabilities{




2✔





374



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




2✔





375



                },




2✔





376



        }




2✔





377



}




2✔





378












379



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










380



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










381



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










382



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










383



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










384



// delete request on HCO CR.










385



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










386



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










387



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










388



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










389



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










390



// webhook one.










391



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




×







392



        return appsv1.DeploymentSpec{




×







393



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




×







394



                Selector: &metav1.LabelSelector{




×







395



                        MatchLabels: map[string]string{




×







396



                                "name": hcoNameWebhook,




×







397



                        },




×







398



                },




×







399



                Strategy: appsv1.DeploymentStrategy{




×







400



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







401



                },




×







402



                Template: corev1.PodTemplateSpec{




×







403



                        ObjectMeta: metav1.ObjectMeta{




×







404



                                Labels: getLabels(hcoNameWebhook, hcoKvIoVersion),




×







405



                        },




×







406



                        Spec: corev1.PodSpec{




×







407



                                ServiceAccountName: hcoName,




×







408



                                SecurityContext:    GetStdPodSecurityContext(),




×







409



                                Containers: []corev1.Container{




×







410



                                        {




×







411



                                                Name:            hcoNameWebhook,




×







412



                                                Image:           image,




×







413



                                                ImagePullPolicy: corev1.PullPolicy(imagePullPolicy),




×







414



                                                Command:         stringListToSlice(hcoNameWebhook),




×







415



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




×







416



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




×







417



                                                Env: append([]corev1.EnvVar{




×







418



                                                        {




×







419



                                                                // deprecated: left here for CI test.




×







420



                                                                Name:  util.OperatorWebhookModeEnv,




×







421



                                                                Value: "true",




×







422



                                                        },




×







423



                                                        {




×







424



                                                                Name:  util.ContainerAppName,




×







425



                                                                Value: util.ContainerWebhookApp,




×







426



                                                        },




×







427



                                                        {




×







428



                                                                Name:  "OPERATOR_IMAGE",




×







429



                                                                Value: image,




×







430



                                                        },




×







431



                                                        {




×







432



                                                                Name:  "OPERATOR_NAME",




×







433



                                                                Value: hcoNameWebhook,




×







434



                                                        },




×







435



                                                        {




×







436



                                                                Name:  "OPERATOR_NAMESPACE",




×







437



                                                                Value: namespace,




×







438



                                                        },




×







439



                                                        {




×







440



                                                                Name: "POD_NAME",




×







441



                                                                ValueFrom: &corev1.EnvVarSource{




×







442



                                                                        FieldRef: &corev1.ObjectFieldSelector{




×







443



                                                                                FieldPath: "metadata.name",




×







444



                                                                        },




×







445



                                                                },




×







446



                                                        },




×







447



                                                }, env...),




×







448



                                                Resources: corev1.ResourceRequirements{




×







449



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




×







450



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




×







451



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




×







452



                                                        },




×







453



                                                },




×








NEW


454



                                                SecurityContext:          GetStdContainerSecurityContext(),




×








NEW


455



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







456



                                        },




×







457



                                },




×







458



                                PriorityClassName: "system-node-critical",




×







459



                        },




×







460



                },




×







461



        }




×







462



}




×







463












464



func GetClusterRole() rbacv1.ClusterRole {




×







465



        return rbacv1.ClusterRole{




×







466



                TypeMeta: metav1.TypeMeta{




×







467



                        APIVersion: rbacVersionV1,




×







468



                        Kind:       "ClusterRole",




×







469



                },




×







470



                ObjectMeta: metav1.ObjectMeta{




×







471



                        Name: hcoName,




×







472



                        Labels: map[string]string{




×







473



                                "name": hcoName,




×







474



                        },




×







475



                },




×







476



                Rules: GetClusterPermissions(),




×







477



        }




×







478



}




×







479












480



var (










481



        emptyAPIGroup = []string{""}










482



)










483












484



func GetClusterPermissions() []rbacv1.PolicyRule {




×







485



        const configOpenshiftIO = "config.openshift.io"




×







486



        const operatorOpenshiftIO = "operator.openshift.io"




×







487



        return []rbacv1.PolicyRule{




×







488



                {




×







489



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







490



                        Resources: stringListToSlice("hyperconvergeds"),




×







491



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




×







492



                },




×







493



                {




×







494



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







495



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




×







496



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




×







497



                },




×







498



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




×







499



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




×







500



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




×







501



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




×







502



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




×







503



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




×







504



                {




×







505



                        APIGroups: emptyAPIGroup,




×







506



                        Resources: stringListToSlice("events"),




×







507



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




×







508



                },




×







509



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




×







510



                {




×







511



                        APIGroups: emptyAPIGroup,




×







512



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




×







513



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




×







514



                },




×







515



                {




×







516



                        APIGroups: emptyAPIGroup,




×







517



                        Resources: stringListToSlice("secrets"),




×







518



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




×







519



                },




×







520



                {




×







521



                        APIGroups: emptyAPIGroup,




×







522



                        Resources: stringListToSlice("endpoints"),




×







523



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




×







524



                },




×







525



                {




×







526



                        APIGroups: emptyAPIGroup,




×







527



                        Resources: stringListToSlice("namespaces"),




×







528



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




×







529



                },




×







530



                {




×







531



                        APIGroups: stringListToSlice("apps"),




×







532



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




×







533



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




×







534



                },




×







535



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




×







536



                {




×







537



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




×







538



                        Resources: stringListToSlice("customresourcedefinitions"),




×







539



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




×







540



                },




×







541



                {




×







542



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




×







543



                        Resources: stringListToSlice("customresourcedefinitions/status"),




×







544



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




×







545



                },




×







546



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




×







547



                {




×







548



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




×







549



                        Resources: stringListToSlice("clusterserviceversions"),




×







550



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




×







551



                },




×







552



                {




×







553



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




×







554



                        Resources: stringListToSlice("priorityclasses"),




×







555



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




×







556



                },




×







557



                {




×







558



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




×







559



                        Resources: stringListToSlice("validatingwebhookconfigurations"),




×







560



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




×







561



                },




×







562



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




×







563



                {




×







564



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







565



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




×







566



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




×







567



                },




×







568



                {




×







569



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







570



                        Resources: stringListToSlice("ingresses"),




×







571



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




×







572



                },




×







573



                {




×







574



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







575



                        Resources: stringListToSlice("ingresses/status"),




×







576



                        Verbs:     stringListToSlice("update"),




×







577



                },




×







578



                {




×







579



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







580



                        Resources: stringListToSlice("apiservers"),




×







581



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




×







582



                },




×







583



                {




×







584



                        APIGroups: stringListToSlice(operatorOpenshiftIO),




×







585



                        Resources: stringListToSlice("kubedeschedulers"),




×







586



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




×







587



                },




×







588



                {




×







589



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







590



                        Resources: stringListToSlice("dnses"),




×







591



                        Verbs:     stringListToSlice("get"),




×







592



                },




×







593



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




×







594



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




×







595



                {




×







596



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




×







597



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




×







598



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




×







599



                },




×







600



                {




×







601



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




×







602



                        Resources: stringListToSlice("operatorconditions"),




×







603



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




×







604



                },




×







605



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




×







606



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




×







607



                {




×







608



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




×







609



                        Resources: stringListToSlice("consoles"),




×







610



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




×







611



                },




×







612



                {




×







613



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




×







614



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




×







615



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




×







616



                },




×







617



        }




×







618



}




×







619












620



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




×







621



        return rbacv1.PolicyRule{




×







622



                APIGroups: stringListToSlice(apiGroup),




×







623



                Resources: resources,




×







624



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




×







625



        }




×







626



}




×







627












628



func GetServiceAccount(namespace string) corev1.ServiceAccount {




×







629



        return createServiceAccount(namespace, hcoName)




×







630



}




×







631












632



func GetCLIDownloadServiceAccount(namespace string) corev1.ServiceAccount {




×







633



        return createServiceAccount(namespace, cliDownloadsName)




×







634



}




×







635












636



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




×







637



        return corev1.ServiceAccount{




×







638



                TypeMeta: metav1.TypeMeta{




×







639



                        APIVersion: "v1",




×







640



                        Kind:       "ServiceAccount",




×







641



                },




×







642



                ObjectMeta: metav1.ObjectMeta{




×







643



                        Name:      name,




×







644



                        Namespace: namespace,




×







645



                        Labels: map[string]string{




×







646



                                "name": name,




×







647



                        },




×







648



                },




×







649



        }




×







650



}




×







651












652



func GetClusterRoleBinding(namespace string) rbacv1.ClusterRoleBinding {




×







653



        return rbacv1.ClusterRoleBinding{




×







654



                TypeMeta: metav1.TypeMeta{




×







655



                        APIVersion: rbacVersionV1,




×







656



                        Kind:       "ClusterRoleBinding",




×







657



                },




×







658



                ObjectMeta: metav1.ObjectMeta{




×







659



                        Name: hcoName,




×







660



                        Labels: map[string]string{




×







661



                                "name": hcoName,




×







662



                        },




×







663



                },




×







664



                RoleRef: rbacv1.RoleRef{




×







665



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




×







666



                        Kind:     "ClusterRole",




×







667



                        Name:     hcoName,




×







668



                },




×







669



                Subjects: []rbacv1.Subject{




×







670



                        {




×







671



                                Kind:      "ServiceAccount",




×







672



                                Name:      hcoName,




×







673



                                Namespace: namespace,




×







674



                        },




×







675



                },




×







676



        }




×







677



}




×







678












679



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




×







680



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




×







681



        for _, errKind := range filterKinds {




×







682



                toSkip[errKind] = struct{}{}




×







683



        }




×







684



        var outErr error




×







685



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




×







686



                for _, err := range pkgRaw.Errors {




×







687



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




×







688



                                continue




×







689



                        }










690



                        outErr = err




×







691



                }










692



        })










693



        return outErr




×







694



}










695












696



const objectType = "object"










697












698



func GetOperatorCRD(relPath string) *extv1.CustomResourceDefinition {




×







699



        pkgs, err := loader.LoadRoots(relPath)




×







700



        if err != nil {




×







701



                panic(err)




×







702



        }










703



        reg := &markers.Registry{}




×







704



        panicOnError(crdmarkers.Register(reg))




×







705






×







706



        parser := &crdgen.Parser{




×







707



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




×







708



                Checker:                    &loader.TypeChecker{},




×







709



                GenerateEmbeddedObjectMeta: true,




×







710



        }




×







711






×







712



        crdgen.AddKnownTypes(parser)




×







713



        if len(pkgs) == 0 {




×







714



                panic("Failed identifying packages")




×







715



        }










716



        for _, p := range pkgs {




×







717



                parser.NeedPackage(p)




×







718



        }




×







719



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




×







720



        parser.NeedCRDFor(groupKind, nil)




×







721



        for _, p := range pkgs {




×







722



                err = packageErrors(p, packages.TypeError)




×







723



                if err != nil {




×







724



                        panic(err)




×







725



                }










726



        }










727



        c := parser.CustomResourceDefinitions[groupKind]




×







728



        // enforce validation of CR name to prevent multiple CRs




×







729



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




×







730



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




×







731



                        Type: objectType,




×







732



                        Properties: map[string]extv1.JSONSchemaProps{




×







733



                                "name": {




×







734



                                        Type:    "string",




×







735



                                        Pattern: hcov1beta1.HyperConvergedName,




×







736



                                },




×







737



                        },




×







738



                }




×







739



        }




×







740



        return &c




×







741



}










742












743



func GetOperatorCR() *hcov1beta1.HyperConverged {




8✔





744



        defaultScheme := runtime.NewScheme()




8✔





745



        _ = hcov1beta1.AddToScheme(defaultScheme)




8✔





746



        _ = hcov1beta1.RegisterDefaults(defaultScheme)




8✔





747



        defaultHco := &hcov1beta1.HyperConverged{




8✔





748



                TypeMeta: metav1.TypeMeta{




8✔





749



                        APIVersion: util.APIVersion,




8✔





750



                        Kind:       util.HyperConvergedKind,




8✔





751



                },




8✔





752



                ObjectMeta: metav1.ObjectMeta{




8✔





753



                        Name: crName,




8✔





754



                }}




8✔





755



        defaultScheme.Default(defaultHco)




8✔





756



        return defaultHco




8✔





757



}




8✔





758












759



// GetInstallStrategyBase returns the basics of an HCO InstallStrategy










760



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




×







761



        return &csvv1alpha1.StrategyDetailsDeployment{




×







762






×







763



                DeploymentSpecs: []csvv1alpha1.StrategyDeploymentSpec{




×







764



                        {




×







765



                                Name:  hcoDeploymentName,




×







766



                                Spec:  GetDeploymentSpecOperator(params),




×







767



                                Label: getLabels(hcoName, params.HcoKvIoVersion),




×







768



                        },




×







769



                        {




×







770



                                Name:  hcoWhDeploymentName,




×







771



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




×







772



                                Label: getLabels(hcoNameWebhook, params.HcoKvIoVersion),




×







773



                        },




×







774



                        {




×







775



                                Name:  cliDownloadsName,




×







776



                                Spec:  GetDeploymentSpecCliDownloads(params),




×







777



                                Label: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







778



                        },




×







779



                },




×







780



                Permissions: []csvv1alpha1.StrategyDeploymentPermissions{},




×







781



                ClusterPermissions: []csvv1alpha1.StrategyDeploymentPermissions{




×







782



                        {




×







783



                                ServiceAccountName: hcoName,




×







784



                                Rules:              GetClusterPermissions(),




×







785



                        },




×







786



                        {




×







787



                                ServiceAccountName: cliDownloadsName,




×







788



                                Rules:              []rbacv1.PolicyRule{},




×







789



                        },




×







790



                },




×







791



        }




×







792



}




×







793












794



type CSVBaseParams struct {










795



        Name            string










796



        Namespace       string










797



        DisplayName     string










798



        MetaDescription string










799



        Description     string










800



        Image           string










801



        Replaces        string










802



        Version         semver.Version










803



        CrdDisplay      string










804



}










805












806



// GetCSVBase returns a base HCO CSV without an InstallStrategy










807



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




×







808



        almExamples, _ := json.Marshal(




×







809



                map[string]interface{}{




×







810



                        "apiVersion": util.APIVersion,




×







811



                        "kind":       util.HyperConvergedKind,




×







812



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




×







813



                                "name":      packageName,




×







814



                                "namespace": params.Namespace,




×







815



                                "annotations": map[string]string{




×







816



                                        "deployOVS": "false",




×







817



                                },




×







818



                        },




×







819



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




×







820



                })




×







821






×







822



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




×







823



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




×







824



        // to really validate the requests.




×







825



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




×







826



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




×







827



        // so failurePolicy = admissionregistrationv1.Fail




×







828






×







829



        validatingWebhook := csvv1alpha1.WebhookDescription{




×







830



                GenerateName:            util.HcoValidatingWebhook,




×







831



                Type:                    csvv1alpha1.ValidatingAdmissionWebhook,




×







832



                DeploymentName:          hcoWhDeploymentName,




×







833



                ContainerPort:           util.WebhookPort,




×







834



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




×







835



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNone),




×







836



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







837



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




×







838



                Rules: []admissionregistrationv1.RuleWithOperations{




×







839



                        {




×







840



                                Operations: []admissionregistrationv1.OperationType{




×







841



                                        admissionregistrationv1.Create,




×







842



                                        admissionregistrationv1.Delete,




×







843



                                        admissionregistrationv1.Update,




×







844



                                },




×







845



                                Rule: admissionregistrationv1.Rule{




×







846



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







847



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




×







848



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







849



                                },




×







850



                        },




×







851



                },




×







852



                WebhookPath: ptr.To(util.HCOWebhookPath),




×







853



        }




×







854






×







855



        mutatingNamespaceWebhook := csvv1alpha1.WebhookDescription{




×







856



                GenerateName:            util.HcoMutatingWebhookNS,




×







857



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







858



                DeploymentName:          hcoWhDeploymentName,




×







859



                ContainerPort:           util.WebhookPort,




×







860



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




×







861



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







862



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







863



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




×







864



                ObjectSelector: &metav1.LabelSelector{




×







865



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




×







866



                },




×







867



                Rules: []admissionregistrationv1.RuleWithOperations{




×







868



                        {




×







869



                                Operations: []admissionregistrationv1.OperationType{




×







870



                                        admissionregistrationv1.Delete,




×







871



                                },




×







872



                                Rule: admissionregistrationv1.Rule{




×







873



                                        APIGroups:   []string{""},




×







874



                                        APIVersions: stringListToSlice("v1"),




×







875



                                        Resources:   stringListToSlice("namespaces"),




×







876



                                },




×







877



                        },




×







878



                },




×







879



                WebhookPath: ptr.To(util.HCONSWebhookPath),




×







880



        }




×







881






×







882



        mutatingHyperConvergedWebhook := csvv1alpha1.WebhookDescription{




×







883



                GenerateName:            util.HcoMutatingWebhookHyperConverged,




×







884



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







885



                DeploymentName:          hcoWhDeploymentName,




×







886



                ContainerPort:           util.WebhookPort,




×







887



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




×







888



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







889



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







890



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




×







891



                Rules: []admissionregistrationv1.RuleWithOperations{




×







892



                        {




×







893



                                Operations: []admissionregistrationv1.OperationType{




×







894



                                        admissionregistrationv1.Create,




×







895



                                        admissionregistrationv1.Update,




×







896



                                },




×







897



                                Rule: admissionregistrationv1.Rule{




×







898



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







899



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




×







900



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







901



                                },




×







902



                        },




×







903



                },




×







904



                WebhookPath: ptr.To(util.HCOMutatingWebhookPath),




×







905



        }




×







906






×







907



        return &csvv1alpha1.ClusterServiceVersion{




×







908



                TypeMeta: metav1.TypeMeta{




×







909



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




×







910



                        Kind:       "ClusterServiceVersion",




×







911



                },




×







912



                ObjectMeta: metav1.ObjectMeta{




×







913



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




×







914



                        Namespace: params.Namespace,




×







915



                        Annotations: map[string]string{




×







916



                                "alm-examples":                   string(almExamples),




×







917



                                "capabilities":                   "Deep Insights",




×







918



                                "certified":                      "false",




×







919



                                "categories":                     "OpenShift Optional",




×







920



                                "containerImage":                 params.Image,




×







921



                                DisableOperandDeletionAnnotation: "true",




×







922



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




×







923



                                "description":                    params.MetaDescription,




×







924



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




×







925



                                "support":                        "false",




×







926



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




×







927



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




×







928



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




×







929



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




×







930



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




×







931



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




×







932



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




×







933



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




×







934



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




×







935



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




×







936



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




×







937



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




×







938



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




×







939



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




×







940



                        },




×







941



                },




×







942



                Spec: csvv1alpha1.ClusterServiceVersionSpec{




×







943



                        DisplayName: params.DisplayName,




×







944



                        Description: params.Description,




×







945



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




×







946



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




×







947



                        Replaces:    params.Replaces,




×







948



                        Maintainers: []csvv1alpha1.Maintainer{




×







949



                                {




×







950



                                        Name:  kubevirtProjectName,




×







951



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




×







952



                                },




×







953



                        },




×







954



                        Maturity: "alpha",




×







955



                        Provider: csvv1alpha1.AppLink{




×







956



                                Name: kubevirtProjectName,




×







957



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




×







958



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




×







959



                        },




×







960



                        Links: []csvv1alpha1.AppLink{




×







961



                                {




×







962



                                        Name: kubevirtProjectName,




×







963



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




×







964



                                },




×







965



                                {




×







966



                                        Name: "Source Code",




×







967



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




×







968



                                },




×







969



                        },




×







970



                        Icon: []csvv1alpha1.Icon{




×







971



                                {




×







972



                                        MediaType: "image/svg+xml",




×







973



                                        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>",




×







974



                                },




×







975



                        },




×







976



                        Labels: map[string]string{




×







977



                                "alm-owner-kubevirt": packageName,




×







978



                                "operated-by":        packageName,




×







979



                        },




×







980



                        Selector: &metav1.LabelSelector{




×







981



                                MatchLabels: map[string]string{




×







982



                                        "alm-owner-kubevirt": packageName,




×







983



                                        "operated-by":        packageName,




×







984



                                },




×







985



                        },




×







986



                        InstallModes: []csvv1alpha1.InstallMode{




×







987



                                {




×







988



                                        Type:      csvv1alpha1.InstallModeTypeOwnNamespace,




×







989



                                        Supported: false,




×







990



                                },




×







991



                                {




×







992



                                        Type:      csvv1alpha1.InstallModeTypeSingleNamespace,




×







993



                                        Supported: false,




×







994



                                },




×







995



                                {




×







996



                                        Type:      csvv1alpha1.InstallModeTypeMultiNamespace,




×







997



                                        Supported: false,




×







998



                                },




×







999



                                {




×







1000



                                        Type:      csvv1alpha1.InstallModeTypeAllNamespaces,




×







1001



                                        Supported: true,




×







1002



                                },




×







1003



                        },




×







1004



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




×







1005



                        // the actual StrategyDetailsDeployment when merging CSVs




×







1006



                        InstallStrategy: csvv1alpha1.NamedInstallStrategy{},




×







1007



                        WebhookDefinitions: []csvv1alpha1.WebhookDescription{




×







1008



                                validatingWebhook,




×







1009



                                mutatingNamespaceWebhook,




×







1010



                                mutatingHyperConvergedWebhook,




×







1011



                        },




×







1012



                        CustomResourceDefinitions: csvv1alpha1.CustomResourceDefinitions{




×







1013



                                Owned: []csvv1alpha1.CRDDescription{




×







1014



                                        {




×







1015



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




×







1016



                                                Version:     util.CurrentAPIVersion,




×







1017



                                                Kind:        util.HyperConvergedKind,




×







1018



                                                DisplayName: params.CrdDisplay + " Deployment",




×







1019



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




×







1020



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




×







1021



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




×







1022



                                                SpecDescriptors: []csvv1alpha1.SpecDescriptor{




×







1023



                                                        {




×







1024



                                                                DisplayName: "Infra components node affinity",




×







1025



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




×







1026



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




×







1027



                                                                XDescriptors: stringListToSlice(




×







1028



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




×







1029



                                                                ),




×







1030



                                                        },




×







1031



                                                        {




×







1032



                                                                DisplayName: "Infra components pod affinity",




×







1033



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




×







1034



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




×







1035



                                                                XDescriptors: stringListToSlice(




×







1036



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




×







1037



                                                                ),




×







1038



                                                        },




×







1039



                                                        {




×







1040



                                                                DisplayName: "Infra components pod anti-affinity",




×







1041



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




×







1042



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




×







1043



                                                                XDescriptors: stringListToSlice(




×







1044



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




×







1045



                                                                ),




×







1046



                                                        },




×







1047



                                                        {




×







1048



                                                                DisplayName: "Workloads components node affinity",




×







1049



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




×







1050



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




×







1051



                                                                XDescriptors: stringListToSlice(




×







1052



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




×







1053



                                                                ),




×







1054



                                                        },




×







1055



                                                        {




×







1056



                                                                DisplayName: "Workloads components pod affinity",




×







1057



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




×







1058



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




×







1059



                                                                XDescriptors: stringListToSlice(




×







1060



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




×







1061



                                                                ),




×







1062



                                                        },




×







1063



                                                        {




×







1064



                                                                DisplayName: "Workloads components pod anti-affinity",




×







1065



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




×







1066



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




×







1067



                                                                XDescriptors: stringListToSlice(




×







1068



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




×







1069



                                                                ),




×







1070



                                                        },




×







1071



                                                        {




×







1072



                                                                DisplayName: "HIDDEN FIELDS - operator version",




×







1073



                                                                Description: "HIDDEN FIELDS - operator version.",




×







1074



                                                                Path:        "version",




×







1075



                                                                XDescriptors: stringListToSlice(




×







1076



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




×







1077



                                                                ),




×







1078



                                                        },




×







1079



                                                },




×







1080



                                                StatusDescriptors: []csvv1alpha1.StatusDescriptor{},




×







1081



                                        },




×







1082



                                },




×







1083



                                Required: []csvv1alpha1.CRDDescription{},




×







1084



                        },




×







1085



                },




×







1086



        }




×







1087



}




×







1088












1089



func InjectVolumesForWebHookCerts(deploy *appsv1.Deployment) {




×







1090



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




×







1091



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




×







1092



                if vol.Name == certVolume {




×







1093



                        return




×







1094



                }




×







1095



        }










1096












1097



        volume := corev1.Volume{




×







1098



                Name: certVolume,




×







1099



                VolumeSource: corev1.VolumeSource{




×







1100



                        Secret: &corev1.SecretVolumeSource{




×







1101



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




×







1102



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




×







1103



                                Items: []corev1.KeyToPath{




×







1104



                                        {




×







1105



                                                Key:  "tls.crt",




×







1106



                                                Path: util.WebhookCertName,




×







1107



                                        },




×







1108



                                        {




×







1109



                                                Key:  "tls.key",




×







1110



                                                Path: util.WebhookKeyName,




×







1111



                                        },




×







1112



                                },




×







1113



                        },




×







1114



                },




×







1115



        }




×







1116



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




×







1117






×







1118



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




×







1119



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




×







1120



                        corev1.VolumeMount{




×







1121



                                Name:      certVolume,




×







1122



                                MountPath: util.DefaultWebhookCertDir,




×







1123



                        })




×







1124



        }




×







1125



}










1126












1127



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




×







1128



        return &corev1.Probe{




×







1129



                ProbeHandler: corev1.ProbeHandler{




×







1130



                        HTTPGet: &corev1.HTTPGetAction{




×







1131



                                Path: endpoint,




×







1132



                                Port: intstr.IntOrString{




×







1133



                                        Type:   intstr.Int,




×







1134



                                        IntVal: port,




×







1135



                                },




×







1136



                                Scheme: corev1.URISchemeHTTP,




×







1137



                        },




×







1138



                },




×







1139



                InitialDelaySeconds: 5,




×







1140



                PeriodSeconds:       5,




×







1141



                FailureThreshold:    1,




×







1142



        }




×







1143



}




×







1144












1145



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




×







1146



        return &corev1.Probe{




×







1147



                ProbeHandler: corev1.ProbeHandler{




×







1148



                        HTTPGet: &corev1.HTTPGetAction{




×







1149



                                Path: endpoint,




×







1150



                                Port: intstr.IntOrString{




×







1151



                                        Type:   intstr.Int,




×







1152



                                        IntVal: port,




×







1153



                                },




×







1154



                                Scheme: corev1.URISchemeHTTP,




×







1155



                        },




×







1156



                },




×







1157



                InitialDelaySeconds: 30,




×







1158



                PeriodSeconds:       5,




×







1159



                FailureThreshold:    1,




×







1160



        }




×







1161



}




×







1162












1163



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




×







1164



        return words




×







1165



}




×







1166












1167



func panicOnError(err error) {




×







1168



        if err != nil {




×







1169



                panic(err)




×







1170



        }










1171



}
























    

  • 

    •