kubevirt / hyperconverged-cluster-operator / 13135756026

coverage: 72.123% (+0.2%) from 71.962%
13135756026

Pull #3281

github

nunnatsa 
add e2e test for customized DL link

Signed-off-by: Nahshon Unna-Tsameret <nunnatsa@redhat.com>
Pull Request #3281: Allow customizing the CLI download link

199 of 277 new or added lines in 11 files covered. (71.84%)

2 existing lines in 1 file now uncovered.

6261 of 8681 relevant lines covered (72.12%)

0.79 hits per line

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

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









3



import (










4



        "encoding/json"










5



        "fmt"










6



        "strconv"










7



        "time"










8












9



        "k8s.io/utils/ptr"










10












11



        "github.com/blang/semver/v4"










12



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










13



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










14



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










15



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










16



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










17



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










18



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










19



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










20



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










21



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










22



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










23



        "k8s.io/apimachinery/pkg/runtime"










24



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










25



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










26



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










27



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










28



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










29



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










30












31



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










32



        kvapi "kubevirt.io/api/core"










33



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










34



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










35



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










36












37



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










38



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










39



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










40



)










41












42



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










43












44



const (










45



        crName              = util.HyperConvergedName










46



        packageName         = util.HyperConvergedName










47



        hcoName             = "hyperconverged-cluster-operator"










48



        hcoNameWebhook      = "hyperconverged-cluster-webhook"










49



        hcoDeploymentName   = "hco-operator"










50



        hcoWhDeploymentName = "hco-webhook"










51



        certVolume          = "apiservice-cert"










52












53



        cliDownloadsName = "hyperconverged-cluster-cli-download"










54












55



        kubevirtProjectName = "KubeVirt project"










56



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










57



)










58












59



var deploymentType = metav1.TypeMeta{










60



        APIVersion: "apps/v1",










61



        Kind:       "Deployment",










62



}










63












64



type DeploymentOperatorParams struct {










65



        Namespace              string










66



        Image                  string










67



        WebhookImage           string










68



        CliDownloadsImage      string










69



        KVUIPluginImage        string










70



        KVUIProxyImage         string










71



        ImagePullPolicy        string










72



        ConversionContainer    string










73



        VmwareContainer        string










74



        VirtIOWinContainer     string










75



        Smbios                 string










76



        Machinetype            string










77



        Amd64MachineType       string










78



        Arm64MachineType       string










79



        HcoKvIoVersion         string










80



        KubevirtVersion        string










81



        KvVirtLancherOsVersion string










82



        CdiVersion             string










83



        CnaoVersion            string










84



        SspVersion             string










85



        HppoVersion            string










86



        MtqVersion             string










87



        AaqVersion             string










88



        PrimaryUDNImage        string










89



        Env                    []corev1.EnvVar










90



}










91












92



func GetDeploymentOperator(params *DeploymentOperatorParams) appsv1.Deployment {




×







93



        return appsv1.Deployment{




×







94



                TypeMeta: deploymentType,




×







95



                ObjectMeta: metav1.ObjectMeta{




×







96



                        Name: hcoName,




×







97



                        Labels: map[string]string{




×







98



                                "name": hcoName,




×







99



                        },




×







100



                },




×







101



                Spec: GetDeploymentSpecOperator(params),




×







102



        }




×







103



}




×







104












105



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




×







106



        deploy := appsv1.Deployment{




×







107



                TypeMeta: deploymentType,




×







108



                ObjectMeta: metav1.ObjectMeta{




×







109



                        Name: hcoNameWebhook,




×







110



                        Labels: map[string]string{




×







111



                                "name": hcoNameWebhook,




×







112



                        },




×







113



                },




×







114



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




×







115



        }




×







116






×







117



        InjectVolumesForWebHookCerts(&deploy)




×







118



        return deploy




×







119



}




×







120












121



func GetDeploymentCliDownloads(params *DeploymentOperatorParams) appsv1.Deployment {




×







122



        return appsv1.Deployment{




×







123



                TypeMeta: deploymentType,




×







124



                ObjectMeta: metav1.ObjectMeta{




×







125



                        Name: cliDownloadsName,




×







126



                        Labels: map[string]string{




×







127



                                "name": cliDownloadsName,




×







128



                        },




×







129



                },




×







130



                Spec: GetDeploymentSpecCliDownloads(params),




×







131



        }




×







132



}




×







133












134



func GetServiceWebhook() v1.Service {




×







135



        return v1.Service{




×







136



                TypeMeta: metav1.TypeMeta{




×







137



                        APIVersion: "v1",




×







138



                        Kind:       "Service",




×







139



                },




×







140



                ObjectMeta: metav1.ObjectMeta{




×







141



                        Name: hcoNameWebhook + "-service",




×







142



                },




×







143



                Spec: v1.ServiceSpec{




×







144



                        Selector: map[string]string{




×







145



                                "name": hcoNameWebhook,




×







146



                        },




×







147



                        Ports: []v1.ServicePort{




×







148



                                {




×







149



                                        Name:       strconv.Itoa(util.WebhookPort),




×







150



                                        Port:       util.WebhookPort,




×







151



                                        Protocol:   corev1.ProtocolTCP,




×







152



                                        TargetPort: intstr.FromInt32(util.WebhookPort),




×







153



                                },




×







154



                        },




×







155



                        Type: corev1.ServiceTypeClusterIP,




×







156



                },




×







157



        }




×







158



}




×







159












160



func GetDeploymentSpecOperator(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







161



        envs := buildEnvVars(params)




×







162






×







163



        return appsv1.DeploymentSpec{




×







164



                Replicas: int32Ptr(1),




×







165



                Selector: &metav1.LabelSelector{




×







166



                        MatchLabels: map[string]string{




×







167



                                "name": hcoName,




×







168



                        },




×







169



                },




×







170



                Strategy: appsv1.DeploymentStrategy{




×







171



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







172



                },




×







173



                Template: corev1.PodTemplateSpec{




×







174



                        ObjectMeta: metav1.ObjectMeta{




×







175



                                Labels: getLabels(hcoName, params.HcoKvIoVersion),




×







176



                        },




×







177



                        Spec: corev1.PodSpec{




×







178



                                ServiceAccountName: hcoName,




×







179



                                SecurityContext:    GetStdPodSecurityContext(),




×







180



                                Containers: []corev1.Container{




×







181



                                        {




×







182



                                                Name:            hcoName,




×







183



                                                Image:           params.Image,




×







184



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







185



                                                Command:         stringListToSlice(hcoName),




×







186



                                                ReadinessProbe:  getReadinessProbe(),




×







187



                                                LivenessProbe:   getLivenessProbe(),




×







188



                                                Env:             envs,




×







189



                                                Resources: v1.ResourceRequirements{




×







190



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




×







191



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




×







192



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




×







193



                                                        },




×







194



                                                },




×







195



                                                SecurityContext: GetStdContainerSecurityContext(),




×







196



                                        },




×







197



                                },




×







198



                                PriorityClassName: "system-cluster-critical",




×







199



                        },




×







200



                },




×







201



        }




×







202



}




×







203












204



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




×







205



        envs := append([]corev1.EnvVar{




×







206



                {




×







207



                        // deprecated: left here for CI test.




×







208



                        Name:  util.OperatorWebhookModeEnv,




×







209



                        Value: "false",




×







210



                },




×







211



                {




×







212



                        Name:  util.ContainerAppName,




×







213



                        Value: util.ContainerOperatorApp,




×







214



                },




×







215



                {




×







216



                        Name:  "KVM_EMULATION",




×







217



                        Value: "",




×







218



                },




×







219



                {




×







220



                        Name:  "OPERATOR_IMAGE",




×







221



                        Value: params.Image,




×







222



                },




×







223



                {




×







224



                        Name:  "OPERATOR_NAME",




×







225



                        Value: hcoName,




×







226



                },




×







227



                {




×







228



                        Name:  "OPERATOR_NAMESPACE",




×







229



                        Value: params.Namespace,




×







230



                },




×







231



                {




×







232



                        Name: "POD_NAME",




×







233



                        ValueFrom: &corev1.EnvVarSource{




×







234



                                FieldRef: &corev1.ObjectFieldSelector{




×







235



                                        FieldPath: "metadata.name",




×







236



                                },




×







237



                        },




×







238



                },




×







239



                {




×







240



                        Name:  "VIRTIOWIN_CONTAINER",




×







241



                        Value: params.VirtIOWinContainer,




×







242



                },




×







243



                {




×







244



                        Name:  "SMBIOS",




×







245



                        Value: params.Smbios,




×







246



                },




×







247



                {




×







248



                        Name:  "MACHINETYPE",




×







249



                        Value: params.Machinetype,




×







250



                },




×







251



                {




×







252



                        Name:  "AMD64_MACHINETYPE",




×







253



                        Value: params.Amd64MachineType,




×







254



                },




×







255



                {




×







256



                        Name:  "ARM64_MACHINETYPE",




×







257



                        Value: params.Arm64MachineType,




×







258



                },




×







259



                {




×







260



                        Name:  util.HcoKvIoVersionName,




×







261



                        Value: params.HcoKvIoVersion,




×







262



                },




×







263



                {




×







264



                        Name:  util.KubevirtVersionEnvV,




×







265



                        Value: params.KubevirtVersion,




×







266



                },




×







267



                {




×







268



                        Name:  util.CdiVersionEnvV,




×







269



                        Value: params.CdiVersion,




×







270



                },




×







271



                {




×







272



                        Name:  util.CnaoVersionEnvV,




×







273



                        Value: params.CnaoVersion,




×







274



                },




×







275



                {




×







276



                        Name:  util.SspVersionEnvV,




×







277



                        Value: params.SspVersion,




×







278



                },




×







279



                {




×







280



                        Name:  util.HppoVersionEnvV,




×







281



                        Value: params.HppoVersion,




×







282



                },




×







283



                {




×







284



                        Name:  util.AaqVersionEnvV,




×







285



                        Value: params.AaqVersion,




×







286



                },




×







287



                {




×







288



                        Name:  util.KVUIPluginImageEnvV,




×







289



                        Value: params.KVUIPluginImage,




×







290



                },




×







291



                {




×







292



                        Name:  util.KVUIProxyImageEnvV,




×







293



                        Value: params.KVUIProxyImage,




×







294



                },




×







295



                {




×







296



                        Name:  util.PrimaryUDNImageEnvV,




×







297



                        Value: params.PrimaryUDNImage,




×







298



                },




×







299



        }, params.Env...)




×







300






×







301



        if params.KvVirtLancherOsVersion != "" {




×







302



                envs = append(envs, corev1.EnvVar{




×







303



                        Name:  util.KvVirtLauncherOSVersionEnvV,




×







304



                        Value: params.KvVirtLancherOsVersion,




×







305



                })




×







306



        }




×







307












308



        return envs




×







309



}










310












311



func GetDeploymentSpecCliDownloads(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







312



        return appsv1.DeploymentSpec{




×







313



                Replicas: int32Ptr(1),




×







314



                Selector: &metav1.LabelSelector{




×







315



                        MatchLabels: map[string]string{




×







316



                                "name": cliDownloadsName,




×







317



                        },




×







318



                },




×







319



                Strategy: appsv1.DeploymentStrategy{




×







320



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







321



                },




×







322



                Template: corev1.PodTemplateSpec{




×







323



                        ObjectMeta: metav1.ObjectMeta{




×







324



                                Labels: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







325



                        },




×







326



                        Spec: corev1.PodSpec{




×







327



                                SecurityContext: GetStdPodSecurityContext(),




×







328



                                Containers: []corev1.Container{




×







329



                                        {




×







330



                                                Name:            "server",




×







331



                                                Image:           params.CliDownloadsImage,




×







332



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







333



                                                Resources: v1.ResourceRequirements{




×







334



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




×







335



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




×







336



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




×







337



                                                        },




×







338



                                                },




×







339



                                                Ports: []v1.ContainerPort{




×







340



                                                        {




×







341



                                                                Protocol:      v1.ProtocolTCP,




×







342



                                                                ContainerPort: int32(8080),




×







343



                                                        },




×







344



                                                },




×







345



                                                SecurityContext: GetStdContainerSecurityContext(),




×







346



                                        },




×







347



                                },




×







348



                                PriorityClassName: "system-cluster-critical",




×







349



                        },




×







350



                },




×







351



        }




×







352



}




×







353












354



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




×







355



        return map[string]string{




×







356



                "name":                    name,




×







357



                hcoutil.AppLabelVersion:   hcoKvIoVersion,




×







358



                hcoutil.AppLabelPartOf:    hcoutil.HyperConvergedCluster,




×







359



                hcoutil.AppLabelComponent: string(hcoutil.AppComponentDeployment),




×







360



        }




×







361



}




×







362












363



func GetStdPodSecurityContext() *v1.PodSecurityContext {




1✔





364



        return &v1.PodSecurityContext{




1✔





365



                RunAsNonRoot: ptr.To(true),




1✔





366



                SeccompProfile: &v1.SeccompProfile{




1✔





367



                        Type: corev1.SeccompProfileTypeRuntimeDefault,




1✔





368



                },




1✔





369



        }




1✔





370



}




1✔





371












372



func GetStdContainerSecurityContext() *v1.SecurityContext {




1✔





373



        return &v1.SecurityContext{




1✔





374



                AllowPrivilegeEscalation: ptr.To(false),




1✔





375



                Capabilities: &v1.Capabilities{




1✔





376



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




1✔





377



                },




1✔





378



        }




1✔





379



}




1✔





380












381



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










382



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










383



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










384



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










385



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










386



// delete request on HCO CR.










387



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










388



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










389



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










390



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










391



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










392



// webhook one.










393



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




×







394



        return appsv1.DeploymentSpec{




×







395



                Replicas: int32Ptr(1),




×







396



                Selector: &metav1.LabelSelector{




×







397



                        MatchLabels: map[string]string{




×







398



                                "name": hcoNameWebhook,




×







399



                        },




×







400



                },




×







401



                Strategy: appsv1.DeploymentStrategy{




×







402



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







403



                },




×







404



                Template: corev1.PodTemplateSpec{




×







405



                        ObjectMeta: metav1.ObjectMeta{




×







406



                                Labels: getLabels(hcoNameWebhook, hcoKvIoVersion),




×







407



                        },




×







408



                        Spec: corev1.PodSpec{




×







409



                                ServiceAccountName: hcoName,




×







410



                                SecurityContext:    GetStdPodSecurityContext(),




×







411



                                Containers: []corev1.Container{




×







412



                                        {




×







413



                                                Name:            hcoNameWebhook,




×







414



                                                Image:           image,




×







415



                                                ImagePullPolicy: corev1.PullPolicy(imagePullPolicy),




×







416



                                                Command:         stringListToSlice(hcoNameWebhook),




×







417



                                                ReadinessProbe:  getReadinessProbe(),




×







418



                                                LivenessProbe:   getLivenessProbe(),




×







419



                                                Env: append([]corev1.EnvVar{




×







420



                                                        {




×







421



                                                                // deprecated: left here for CI test.




×







422



                                                                Name:  util.OperatorWebhookModeEnv,




×







423



                                                                Value: "true",




×







424



                                                        },




×







425



                                                        {




×







426



                                                                Name:  util.ContainerAppName,




×







427



                                                                Value: util.ContainerWebhookApp,




×







428



                                                        },




×







429



                                                        {




×







430



                                                                Name:  "OPERATOR_IMAGE",




×







431



                                                                Value: image,




×







432



                                                        },




×







433



                                                        {




×







434



                                                                Name:  "OPERATOR_NAME",




×







435



                                                                Value: hcoNameWebhook,




×







436



                                                        },




×







437



                                                        {




×







438



                                                                Name:  "OPERATOR_NAMESPACE",




×







439



                                                                Value: namespace,




×







440



                                                        },




×







441



                                                        {




×







442



                                                                Name: "POD_NAME",




×







443



                                                                ValueFrom: &corev1.EnvVarSource{




×







444



                                                                        FieldRef: &corev1.ObjectFieldSelector{




×







445



                                                                                FieldPath: "metadata.name",




×







446



                                                                        },




×







447



                                                                },




×







448



                                                        },




×







449



                                                }, env...),




×







450



                                                Resources: v1.ResourceRequirements{




×







451



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




×







452



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




×







453



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




×







454



                                                        },




×







455



                                                },




×







456



                                                SecurityContext: GetStdContainerSecurityContext(),




×







457



                                        },




×







458



                                },




×







459



                                PriorityClassName: "system-node-critical",




×







460



                        },




×







461



                },




×







462



        }




×







463



}




×







464












465



func GetClusterRole() rbacv1.ClusterRole {




×







466



        return rbacv1.ClusterRole{




×







467



                TypeMeta: metav1.TypeMeta{




×







468



                        APIVersion: rbacVersionV1,




×







469



                        Kind:       "ClusterRole",




×







470



                },




×







471



                ObjectMeta: metav1.ObjectMeta{




×







472



                        Name: hcoName,




×







473



                        Labels: map[string]string{




×







474



                                "name": hcoName,




×







475



                        },




×







476



                },




×







477



                Rules: GetClusterPermissions(),




×







478



        }




×







479



}




×







480












481



var (










482



        emptyAPIGroup = []string{""}










483



)










484












485



func GetClusterPermissions() []rbacv1.PolicyRule {




×







486



        const configOpenshiftIO = "config.openshift.io"




×







487



        const operatorOpenshiftIO = "operator.openshift.io"




×







488



        return []rbacv1.PolicyRule{




×







489



                {




×







490



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







491



                        Resources: stringListToSlice("hyperconvergeds"),




×







492



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




×







493



                },




×







494



                {




×







495



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







496



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




×







497



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




×







498



                },




×







499



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




×







500



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




×







501



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




×







502



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




×







503



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




×







504



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




×







505



                {




×







506



                        APIGroups: emptyAPIGroup,




×







507



                        Resources: stringListToSlice("events"),




×







508



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




×







509



                },




×







510



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




×







511



                {




×







512



                        APIGroups: emptyAPIGroup,




×







513



                        Resources: stringListToSlice("pods"),




×







514



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




×







515



                },




×







516



                {




×







517



                        APIGroups: emptyAPIGroup,




×







518



                        Resources: stringListToSlice("nodes"),




×







519



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




×







520



                },




×







521



                {




×







522



                        APIGroups: emptyAPIGroup,




×







523



                        Resources: stringListToSlice("endpoints"),




×







524



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




×







525



                },




×







526



                {




×







527



                        APIGroups: emptyAPIGroup,




×







528



                        Resources: stringListToSlice("namespaces"),




×







529



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




×







530



                },




×







531



                {




×







532



                        APIGroups: stringListToSlice("apps"),




×







533



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




×







534



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




×







535



                },




×







536



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




×







537



                {




×







538



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




×







539



                        Resources: stringListToSlice("customresourcedefinitions"),




×







540



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




×







541



                },




×







542



                {




×







543



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




×







544



                        Resources: stringListToSlice("customresourcedefinitions/status"),




×







545



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




×







546



                },




×







547



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




×







548



                {




×







549



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




×







550



                        Resources: stringListToSlice("clusterserviceversions"),




×







551



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




×







552



                },




×







553



                {




×







554



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




×







555



                        Resources: stringListToSlice("priorityclasses"),




×







556



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




×







557



                },




×







558



                {




×







559



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




×







560



                        Resources: stringListToSlice("validatingwebhookconfigurations"),




×







561



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




×







562



                },




×







563



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




×







564



                {




×







565



                        APIGroups: stringListToSlice(configOpenshiftIO),




×








NEW


566



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




×







567



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




×







568



                },




×








NEW


569



                {




×








NEW


570



                        APIGroups: stringListToSlice(configOpenshiftIO),




×








NEW


571



                        Resources: stringListToSlice("ingresses"),




×








NEW


572



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




×








NEW


573



                },




×








NEW


574



                {




×








NEW


575



                        APIGroups: stringListToSlice(configOpenshiftIO),




×








NEW


576



                        Resources: stringListToSlice("ingresses/status"),




×








NEW


577



                        Verbs:     stringListToSlice("update"),




×








NEW


578



                },




×







579



                {




×







580



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







581



                        Resources: stringListToSlice("apiservers"),




×







582



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




×







583



                },




×







584



                {




×







585



                        APIGroups: stringListToSlice(operatorOpenshiftIO),




×







586



                        Resources: stringListToSlice("kubedeschedulers"),




×







587



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




×







588



                },




×







589



                {




×







590



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







591



                        Resources: stringListToSlice("dnses"),




×







592



                        Verbs:     stringListToSlice("get"),




×







593



                },




×







594



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




×







595



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




×








NEW


596



                {




×








NEW


597



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




×








NEW


598



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




×








NEW


599



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




×








NEW


600



                },




×







601



                {




×







602



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




×







603



                        Resources: stringListToSlice("operatorconditions"),




×







604



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




×







605



                },




×







606



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




×







607



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




×







608



                {




×







609



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




×







610



                        Resources: stringListToSlice("consoles"),




×







611



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




×







612



                },




×







613



                {




×







614



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




×







615



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




×







616



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




×







617



                },




×







618



        }




×







619



}




×







620












621



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




×







622



        return rbacv1.PolicyRule{




×







623



                APIGroups: stringListToSlice(apiGroup),




×







624



                Resources: resources,




×







625



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




×







626



        }




×







627



}




×







628












629



func GetServiceAccount(namespace string) v1.ServiceAccount {




×







630



        return v1.ServiceAccount{




×







631



                TypeMeta: metav1.TypeMeta{




×







632



                        APIVersion: "v1",




×







633



                        Kind:       "ServiceAccount",




×







634



                },




×







635



                ObjectMeta: metav1.ObjectMeta{




×







636



                        Name:      hcoName,




×







637



                        Namespace: namespace,




×







638



                        Labels: map[string]string{




×







639



                                "name": hcoName,




×







640



                        },




×







641



                },




×







642



        }




×







643



}




×







644












645



func GetClusterRoleBinding(namespace string) rbacv1.ClusterRoleBinding {




×







646



        return rbacv1.ClusterRoleBinding{




×







647



                TypeMeta: metav1.TypeMeta{




×







648



                        APIVersion: rbacVersionV1,




×







649



                        Kind:       "ClusterRoleBinding",




×







650



                },




×







651



                ObjectMeta: metav1.ObjectMeta{




×







652



                        Name: hcoName,




×







653



                        Labels: map[string]string{




×







654



                                "name": hcoName,




×







655



                        },




×







656



                },




×







657



                RoleRef: rbacv1.RoleRef{




×







658



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




×







659



                        Kind:     "ClusterRole",




×







660



                        Name:     hcoName,




×







661



                },




×







662



                Subjects: []rbacv1.Subject{




×







663



                        {




×







664



                                Kind:      "ServiceAccount",




×







665



                                Name:      hcoName,




×







666



                                Namespace: namespace,




×







667



                        },




×







668



                },




×







669



        }




×







670



}




×







671












672



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




×







673



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




×







674



        for _, errKind := range filterKinds {




×







675



                toSkip[errKind] = struct{}{}




×







676



        }




×







677



        var outErr error




×







678



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




×







679



                for _, err := range pkgRaw.Errors {




×







680



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




×







681



                                continue




×







682



                        }










683



                        outErr = err




×







684



                }










685



        })










686



        return outErr




×







687



}










688












689



const objectType = "object"










690












691



func GetOperatorCRD(relPath string) *extv1.CustomResourceDefinition {




×







692



        pkgs, err := loader.LoadRoots(relPath)




×







693



        if err != nil {




×







694



                panic(err)




×







695



        }










696



        reg := &markers.Registry{}




×







697



        panicOnError(crdmarkers.Register(reg))




×







698






×







699



        parser := &crdgen.Parser{




×







700



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




×







701



                Checker:                    &loader.TypeChecker{},




×







702



                GenerateEmbeddedObjectMeta: true,




×







703



        }




×







704






×







705



        crdgen.AddKnownTypes(parser)




×







706



        if len(pkgs) == 0 {




×







707



                panic("Failed identifying packages")




×







708



        }










709



        for _, p := range pkgs {




×







710



                parser.NeedPackage(p)




×







711



        }




×







712



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




×







713



        parser.NeedCRDFor(groupKind, nil)




×







714



        for _, p := range pkgs {




×







715



                err = packageErrors(p, packages.TypeError)




×







716



                if err != nil {




×







717



                        panic(err)




×







718



                }










719



        }










720



        c := parser.CustomResourceDefinitions[groupKind]




×







721



        // enforce validation of CR name to prevent multiple CRs




×







722



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




×







723



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




×







724



                        Type: objectType,




×







725



                        Properties: map[string]extv1.JSONSchemaProps{




×







726



                                "name": {




×







727



                                        Type:    "string",




×







728



                                        Pattern: hcov1beta1.HyperConvergedName,




×







729



                                },




×







730



                        },




×







731



                }




×







732



        }




×







733



        return &c




×







734



}










735












736



func GetOperatorCR() *hcov1beta1.HyperConverged {




1✔





737



        defaultScheme := runtime.NewScheme()




1✔





738



        _ = hcov1beta1.AddToScheme(defaultScheme)




1✔





739



        _ = hcov1beta1.RegisterDefaults(defaultScheme)




1✔





740



        defaultHco := &hcov1beta1.HyperConverged{




1✔





741



                TypeMeta: metav1.TypeMeta{




1✔





742



                        APIVersion: util.APIVersion,




1✔





743



                        Kind:       util.HyperConvergedKind,




1✔





744



                },




1✔





745



                ObjectMeta: metav1.ObjectMeta{




1✔





746



                        Name: crName,




1✔





747



                }}




1✔





748



        defaultScheme.Default(defaultHco)




1✔





749



        return defaultHco




1✔





750



}




1✔





751












752



// GetInstallStrategyBase returns the basics of an HCO InstallStrategy










753



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




×







754



        return &csvv1alpha1.StrategyDetailsDeployment{




×







755






×







756



                DeploymentSpecs: []csvv1alpha1.StrategyDeploymentSpec{




×







757



                        {




×







758



                                Name:  hcoDeploymentName,




×







759



                                Spec:  GetDeploymentSpecOperator(params),




×







760



                                Label: getLabels(hcoName, params.HcoKvIoVersion),




×







761



                        },




×







762



                        {




×







763



                                Name:  hcoWhDeploymentName,




×







764



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




×







765



                                Label: getLabels(hcoNameWebhook, params.HcoKvIoVersion),




×







766



                        },




×







767



                        {




×







768



                                Name:  cliDownloadsName,




×







769



                                Spec:  GetDeploymentSpecCliDownloads(params),




×







770



                                Label: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







771



                        },




×







772



                },




×







773



                Permissions: []csvv1alpha1.StrategyDeploymentPermissions{},




×







774



                ClusterPermissions: []csvv1alpha1.StrategyDeploymentPermissions{




×







775



                        {




×







776



                                ServiceAccountName: hcoName,




×







777



                                Rules:              GetClusterPermissions(),




×







778



                        },




×







779



                },




×







780



        }




×







781



}




×







782












783



type CSVBaseParams struct {










784



        Name            string










785



        Namespace       string










786



        DisplayName     string










787



        MetaDescription string










788



        Description     string










789



        Image           string










790



        Replaces        string










791



        Version         semver.Version










792



        CrdDisplay      string










793



}










794












795



// GetCSVBase returns a base HCO CSV without an InstallStrategy










796



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




×







797



        almExamples, _ := json.Marshal(




×







798



                map[string]interface{}{




×







799



                        "apiVersion": util.APIVersion,




×







800



                        "kind":       util.HyperConvergedKind,




×







801



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




×







802



                                "name":      packageName,




×







803



                                "namespace": params.Namespace,




×







804



                                "annotations": map[string]string{




×







805



                                        "deployOVS": "false",




×







806



                                },




×







807



                        },




×







808



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




×







809



                })




×







810






×







811



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




×







812



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




×







813



        // to really validate the requests.




×







814



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




×







815



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




×







816



        // so failurePolicy = admissionregistrationv1.Fail




×







817






×







818



        validatingWebhook := csvv1alpha1.WebhookDescription{




×







819



                GenerateName:            util.HcoValidatingWebhook,




×







820



                Type:                    csvv1alpha1.ValidatingAdmissionWebhook,




×







821



                DeploymentName:          hcoWhDeploymentName,




×







822



                ContainerPort:           util.WebhookPort,




×







823



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




×







824



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNone),




×







825



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







826



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




×







827



                Rules: []admissionregistrationv1.RuleWithOperations{




×







828



                        {




×







829



                                Operations: []admissionregistrationv1.OperationType{




×







830



                                        admissionregistrationv1.Create,




×







831



                                        admissionregistrationv1.Delete,




×







832



                                        admissionregistrationv1.Update,




×







833



                                },




×







834



                                Rule: admissionregistrationv1.Rule{




×







835



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







836



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




×







837



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







838



                                },




×







839



                        },




×







840



                },




×







841



                WebhookPath: ptr.To(util.HCOWebhookPath),




×







842



        }




×







843






×







844



        mutatingNamespaceWebhook := csvv1alpha1.WebhookDescription{




×







845



                GenerateName:            util.HcoMutatingWebhookNS,




×







846



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







847



                DeploymentName:          hcoWhDeploymentName,




×







848



                ContainerPort:           util.WebhookPort,




×







849



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




×







850



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







851



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







852



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




×







853



                ObjectSelector: &metav1.LabelSelector{




×







854



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




×







855



                },




×







856



                Rules: []admissionregistrationv1.RuleWithOperations{




×







857



                        {




×







858



                                Operations: []admissionregistrationv1.OperationType{




×







859



                                        admissionregistrationv1.Delete,




×







860



                                },




×







861



                                Rule: admissionregistrationv1.Rule{




×







862



                                        APIGroups:   []string{""},




×







863



                                        APIVersions: stringListToSlice("v1"),




×







864



                                        Resources:   stringListToSlice("namespaces"),




×







865



                                },




×







866



                        },




×







867



                },




×







868



                WebhookPath: ptr.To(util.HCONSWebhookPath),




×







869



        }




×







870






×







871



        mutatingHyperConvergedWebhook := csvv1alpha1.WebhookDescription{




×







872



                GenerateName:            util.HcoMutatingWebhookHyperConverged,




×







873



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







874



                DeploymentName:          hcoWhDeploymentName,




×







875



                ContainerPort:           util.WebhookPort,




×







876



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




×







877



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







878



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







879



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




×







880



                Rules: []admissionregistrationv1.RuleWithOperations{




×







881



                        {




×







882



                                Operations: []admissionregistrationv1.OperationType{




×







883



                                        admissionregistrationv1.Create,




×







884



                                        admissionregistrationv1.Update,




×







885



                                },




×







886



                                Rule: admissionregistrationv1.Rule{




×







887



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







888



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




×







889



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







890



                                },




×







891



                        },




×







892



                },




×







893



                WebhookPath: ptr.To(util.HCOMutatingWebhookPath),




×







894



        }




×







895






×







896



        return &csvv1alpha1.ClusterServiceVersion{




×







897



                TypeMeta: metav1.TypeMeta{




×







898



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




×







899



                        Kind:       "ClusterServiceVersion",




×







900



                },




×







901



                ObjectMeta: metav1.ObjectMeta{




×







902



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




×







903



                        Namespace: params.Namespace,




×







904



                        Annotations: map[string]string{




×







905



                                "alm-examples":                   string(almExamples),




×







906



                                "capabilities":                   "Deep Insights",




×







907



                                "certified":                      "false",




×







908



                                "categories":                     "OpenShift Optional",




×







909



                                "containerImage":                 params.Image,




×







910



                                DisableOperandDeletionAnnotation: "true",




×







911



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




×







912



                                "description":                    params.MetaDescription,




×







913



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




×







914



                                "support":                        "false",




×







915



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




×







916



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




×







917



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




×







918



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




×







919



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




×







920



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




×







921



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




×







922



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




×







923



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




×







924



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




×







925



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




×







926



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




×







927



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




×







928



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




×







929



                        },




×







930



                },




×







931



                Spec: csvv1alpha1.ClusterServiceVersionSpec{




×







932



                        DisplayName: params.DisplayName,




×







933



                        Description: params.Description,




×







934



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




×







935



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




×







936



                        Replaces:    params.Replaces,




×







937



                        Maintainers: []csvv1alpha1.Maintainer{




×







938



                                {




×







939



                                        Name:  kubevirtProjectName,




×







940



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




×







941



                                },




×







942



                        },




×







943



                        Maturity: "alpha",




×







944



                        Provider: csvv1alpha1.AppLink{




×







945



                                Name: kubevirtProjectName,




×







946



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




×







947



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




×







948



                        },




×







949



                        Links: []csvv1alpha1.AppLink{




×







950



                                {




×







951



                                        Name: kubevirtProjectName,




×







952



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




×







953



                                },




×







954



                                {




×







955



                                        Name: "Source Code",




×







956



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




×







957



                                },




×







958



                        },




×







959



                        Icon: []csvv1alpha1.Icon{




×







960



                                {




×







961



                                        MediaType: "image/svg+xml",




×







962



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




×







963



                                },




×







964



                        },




×







965



                        Labels: map[string]string{




×







966



                                "alm-owner-kubevirt": packageName,




×







967



                                "operated-by":        packageName,




×







968



                        },




×







969



                        Selector: &metav1.LabelSelector{




×







970



                                MatchLabels: map[string]string{




×







971



                                        "alm-owner-kubevirt": packageName,




×







972



                                        "operated-by":        packageName,




×







973



                                },




×







974



                        },




×







975



                        InstallModes: []csvv1alpha1.InstallMode{




×







976



                                {




×







977



                                        Type:      csvv1alpha1.InstallModeTypeOwnNamespace,




×







978



                                        Supported: false,




×







979



                                },




×







980



                                {




×







981



                                        Type:      csvv1alpha1.InstallModeTypeSingleNamespace,




×







982



                                        Supported: false,




×







983



                                },




×







984



                                {




×







985



                                        Type:      csvv1alpha1.InstallModeTypeMultiNamespace,




×







986



                                        Supported: false,




×







987



                                },




×







988



                                {




×







989



                                        Type:      csvv1alpha1.InstallModeTypeAllNamespaces,




×







990



                                        Supported: true,




×







991



                                },




×







992



                        },




×







993



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




×







994



                        // the actual StrategyDetailsDeployment when merging CSVs




×







995



                        InstallStrategy: csvv1alpha1.NamedInstallStrategy{},




×







996



                        WebhookDefinitions: []csvv1alpha1.WebhookDescription{




×







997



                                validatingWebhook,




×







998



                                mutatingNamespaceWebhook,




×







999



                                mutatingHyperConvergedWebhook,




×







1000



                        },




×







1001



                        CustomResourceDefinitions: csvv1alpha1.CustomResourceDefinitions{




×







1002



                                Owned: []csvv1alpha1.CRDDescription{




×







1003



                                        {




×







1004



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




×







1005



                                                Version:     util.CurrentAPIVersion,




×







1006



                                                Kind:        util.HyperConvergedKind,




×







1007



                                                DisplayName: params.CrdDisplay + " Deployment",




×







1008



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




×







1009



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




×







1010



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




×







1011



                                                SpecDescriptors: []csvv1alpha1.SpecDescriptor{




×







1012



                                                        {




×







1013



                                                                DisplayName: "Infra components node affinity",




×







1014



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




×







1015



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




×







1016



                                                                XDescriptors: stringListToSlice(




×







1017



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




×







1018



                                                                ),




×







1019



                                                        },




×







1020



                                                        {




×







1021



                                                                DisplayName: "Infra components pod affinity",




×







1022



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




×







1023



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




×







1024



                                                                XDescriptors: stringListToSlice(




×







1025



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




×







1026



                                                                ),




×







1027



                                                        },




×







1028



                                                        {




×







1029



                                                                DisplayName: "Infra components pod anti-affinity",




×







1030



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




×







1031



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




×







1032



                                                                XDescriptors: stringListToSlice(




×







1033



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




×







1034



                                                                ),




×







1035



                                                        },




×







1036



                                                        {




×







1037



                                                                DisplayName: "Workloads components node affinity",




×







1038



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




×







1039



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




×







1040



                                                                XDescriptors: stringListToSlice(




×







1041



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




×







1042



                                                                ),




×







1043



                                                        },




×







1044



                                                        {




×







1045



                                                                DisplayName: "Workloads components pod affinity",




×







1046



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




×







1047



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




×







1048



                                                                XDescriptors: stringListToSlice(




×







1049



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




×







1050



                                                                ),




×







1051



                                                        },




×







1052



                                                        {




×







1053



                                                                DisplayName: "Workloads components pod anti-affinity",




×







1054



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




×







1055



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




×







1056



                                                                XDescriptors: stringListToSlice(




×







1057



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




×







1058



                                                                ),




×







1059



                                                        },




×







1060



                                                        {




×







1061



                                                                DisplayName: "HIDDEN FIELDS - operator version",




×







1062



                                                                Description: "HIDDEN FIELDS - operator version.",




×







1063



                                                                Path:        "version",




×







1064



                                                                XDescriptors: stringListToSlice(




×







1065



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




×







1066



                                                                ),




×







1067



                                                        },




×







1068



                                                },




×







1069



                                                StatusDescriptors: []csvv1alpha1.StatusDescriptor{},




×







1070



                                        },




×







1071



                                },




×







1072



                                Required: []csvv1alpha1.CRDDescription{},




×







1073



                        },




×







1074



                },




×







1075



        }




×







1076



}




×







1077












1078



func InjectVolumesForWebHookCerts(deploy *appsv1.Deployment) {




×







1079



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




×







1080



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




×







1081



                if vol.Name == certVolume {




×







1082



                        return




×







1083



                }




×







1084



        }










1085












1086



        volume := v1.Volume{




×







1087



                Name: certVolume,




×







1088



                VolumeSource: corev1.VolumeSource{




×







1089



                        Secret: &corev1.SecretVolumeSource{




×







1090



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




×







1091



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




×







1092



                                Items: []corev1.KeyToPath{




×







1093



                                        {




×







1094



                                                Key:  "tls.crt",




×







1095



                                                Path: hcoutil.WebhookCertName,




×







1096



                                        },




×







1097



                                        {




×







1098



                                                Key:  "tls.key",




×







1099



                                                Path: hcoutil.WebhookKeyName,




×







1100



                                        },




×







1101



                                },




×







1102



                        },




×







1103



                },




×







1104



        }




×







1105



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




×







1106






×







1107



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




×







1108



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




×







1109



                        corev1.VolumeMount{




×







1110



                                Name:      certVolume,




×







1111



                                MountPath: hcoutil.DefaultWebhookCertDir,




×







1112



                        })




×







1113



        }




×







1114



}










1115












1116



func getReadinessProbe() *corev1.Probe {




×







1117



        return &corev1.Probe{




×







1118



                ProbeHandler: corev1.ProbeHandler{




×







1119



                        HTTPGet: &corev1.HTTPGetAction{




×







1120



                                Path: hcoutil.ReadinessEndpointName,




×







1121



                                Port: intstr.IntOrString{




×







1122



                                        Type:   intstr.Int,




×







1123



                                        IntVal: hcoutil.HealthProbePort,




×







1124



                                },




×







1125



                                Scheme: corev1.URISchemeHTTP,




×







1126



                        },




×







1127



                },




×







1128



                InitialDelaySeconds: 5,




×







1129



                PeriodSeconds:       5,




×







1130



                FailureThreshold:    1,




×







1131



        }




×







1132



}




×







1133












1134



func getLivenessProbe() *corev1.Probe {




×







1135



        return &corev1.Probe{




×







1136



                ProbeHandler: corev1.ProbeHandler{




×







1137



                        HTTPGet: &corev1.HTTPGetAction{




×







1138



                                Path: hcoutil.LivenessEndpointName,




×







1139



                                Port: intstr.IntOrString{




×







1140



                                        Type:   intstr.Int,




×







1141



                                        IntVal: hcoutil.HealthProbePort,




×







1142



                                },




×







1143



                                Scheme: corev1.URISchemeHTTP,




×







1144



                        },




×







1145



                },




×







1146



                InitialDelaySeconds: 30,




×







1147



                PeriodSeconds:       5,




×







1148



                FailureThreshold:    1,




×







1149



        }




×







1150



}




×







1151












1152



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




×







1153



        return words




×







1154



}




×







1155












1156



func int32Ptr(i int32) *int32 {




×







1157



        return &i




×







1158



}




×







1159












1160



func panicOnError(err error) {




×







1161



        if err != nil {




×







1162



                panic(err)




×







1163



        }










1164



}
























    

  • 

    •