kubevirt / hyperconverged-cluster-operator / 16339590247

coverage: 75.103% (-0.02%) from 75.124%
16339590247

Pull #3601

github

web-flow 
Merge bcff6906b into cb8d4dd66
Pull Request #3601: network,passt: Deploy Passt required objects

391 of 521 new or added lines in 10 files covered. (75.05%)

97 existing lines in 2 files now uncovered.

6908 of 9198 relevant lines covered (75.1%)

1.77 hits per line

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

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









3



import (










4



        "encoding/json"










5



        "fmt"










6



        "strconv"










7



        "time"










8












9



        "github.com/blang/semver/v4"










10



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










11



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










12



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










13



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










14



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










15



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










16



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










17



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










18



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










19



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










20



        "k8s.io/apimachinery/pkg/runtime"










21



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










22



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










23



        "k8s.io/utils/ptr"










24



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










25



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










26



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










27



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










28












29



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










30



        kvapi "kubevirt.io/api/core"










31



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










32



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










33



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










34












35



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










36



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










37



)










38












39



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










40












41



const (










42



        crName              = util.HyperConvergedName










43



        packageName         = util.HyperConvergedName










44



        hcoName             = "hyperconverged-cluster-operator"










45



        hcoNameWebhook      = "hyperconverged-cluster-webhook"










46



        hcoDeploymentName   = "hco-operator"










47



        hcoWhDeploymentName = "hco-webhook"










48



        certVolume          = "apiservice-cert"










49












50



        cliDownloadsName = "hyperconverged-cluster-cli-download"










51












52



        kubevirtProjectName = "KubeVirt project"










53



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










54












55



        // labels to apply network policies:










56



        allowEgressToDNSAndAPIServerLabel  = "hco.kubevirt.io/allow-access-cluster-services"










57



        allowIngressToMetricsEndpointLabel = "hco.kubevirt.io/allow-prometheus-access"










58



)










59












60



var deploymentType = metav1.TypeMeta{










61



        APIVersion: "apps/v1",










62



        Kind:       "Deployment",










63



}










64












65



type DeploymentOperatorParams struct {










66



        Namespace              string










67



        Image                  string










68



        WebhookImage           string










69



        CliDownloadsImage      string










70



        KVUIPluginImage        string










71



        KVUIProxyImage         string










72



        PasstImage             string










73



        PasstCNIImage          string










74



        ImagePullPolicy        string










75



        ConversionContainer    string










76



        VmwareContainer        string










77



        VirtIOWinContainer     string










78



        Smbios                 string










79



        Machinetype            string










80



        Amd64MachineType       string










81



        Arm64MachineType       string










82



        HcoKvIoVersion         string










83



        KubevirtVersion        string










84



        KvVirtLancherOsVersion string










85



        CdiVersion             string










86



        CnaoVersion            string










87



        SspVersion             string










88



        HppoVersion            string










89



        MtqVersion             string










90



        AaqVersion             string










91



        Env                    []corev1.EnvVar










92



        AddNetworkPolicyLabels bool










93



}










94












95



func GetDeploymentOperator(params *DeploymentOperatorParams) appsv1.Deployment {




×







96



        return appsv1.Deployment{




×







97



                TypeMeta: deploymentType,




×







98



                ObjectMeta: metav1.ObjectMeta{




×







99



                        Name: hcoName,




×







100



                        Labels: map[string]string{




×







101



                                "name": hcoName,




×







102



                        },




×







103



                },




×







104



                Spec: GetDeploymentSpecOperator(params),




×







105



        }




×








UNCOV

106



}




×







107












108



func GetDeploymentWebhook(params *DeploymentOperatorParams) appsv1.Deployment {




×







109



        deploy := appsv1.Deployment{




×







110



                TypeMeta: deploymentType,




×







111



                ObjectMeta: metav1.ObjectMeta{




×







112



                        Name: hcoNameWebhook,




×







113



                        Labels: map[string]string{




×







114



                                "name": hcoNameWebhook,




×







115



                        },




×







116



                },




×







117



                Spec: GetDeploymentSpecWebhook(params),




×







118



        }




×







119






×







120



        InjectVolumesForWebHookCerts(&deploy)




×







121



        return deploy




×








UNCOV

122



}




×







123












124



func GetDeploymentCliDownloads(params *DeploymentOperatorParams) appsv1.Deployment {




×







125



        return appsv1.Deployment{




×







126



                TypeMeta: deploymentType,




×







127



                ObjectMeta: metav1.ObjectMeta{




×







128



                        Name: cliDownloadsName,




×







129



                        Labels: map[string]string{




×







130



                                "name": cliDownloadsName,




×







131



                        },




×







132



                },




×







133



                Spec: GetDeploymentSpecCliDownloads(params),




×







134



        }




×








UNCOV

135



}




×







136












137



func GetServiceWebhook() corev1.Service {




×







138



        return corev1.Service{




×







139



                TypeMeta: metav1.TypeMeta{




×







140



                        APIVersion: "v1",




×







141



                        Kind:       "Service",




×







142



                },




×







143



                ObjectMeta: metav1.ObjectMeta{




×







144



                        Name: hcoNameWebhook + "-service",




×







145



                },




×







146



                Spec: corev1.ServiceSpec{




×







147



                        Selector: map[string]string{




×







148



                                "name": hcoNameWebhook,




×







149



                        },




×







150



                        Ports: []corev1.ServicePort{




×







151



                                {




×







152



                                        Name:       strconv.Itoa(util.WebhookPort),




×







153



                                        Port:       util.WebhookPort,




×







154



                                        Protocol:   corev1.ProtocolTCP,




×







155



                                        TargetPort: intstr.FromInt32(util.WebhookPort),




×







156



                                },




×







157



                        },




×







158



                        Type: corev1.ServiceTypeClusterIP,




×







159



                },




×







160



        }




×








UNCOV

161



}




×







162












163



func GetDeploymentSpecOperator(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







164



        envs := buildEnvVars(params)




×







165






×







166



        return appsv1.DeploymentSpec{




×







167



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




×







168



                Selector: &metav1.LabelSelector{




×







169



                        MatchLabels: map[string]string{




×







170



                                "name": hcoName,




×







171



                        },




×







172



                },




×







173



                Strategy: appsv1.DeploymentStrategy{




×







174



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







175



                },




×







176



                Template: corev1.PodTemplateSpec{




×







177



                        ObjectMeta: metav1.ObjectMeta{




×







178



                                Labels: getLabelsWithNetworkPolicies(hcoName, params),




×







179



                        },




×







180



                        Spec: corev1.PodSpec{




×







181



                                ServiceAccountName: hcoName,




×







182



                                SecurityContext:    GetStdPodSecurityContext(),




×







183



                                Containers: []corev1.Container{




×







184



                                        {




×







185



                                                Name:            hcoName,




×







186



                                                Image:           params.Image,




×







187



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







188



                                                Command:         stringListToSlice(hcoName),




×







189



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




×







190



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




×







191



                                                Env:             envs,




×







192



                                                Resources: corev1.ResourceRequirements{




×







193



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




×







194



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




×







195



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




×







196



                                                        },




×







197



                                                },




×







198



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







199



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







200



                                                Ports: []corev1.ContainerPort{




×







201



                                                        getMetricsPort(),




×







202



                                                },




×







203



                                        },




×







204



                                },




×







205



                                PriorityClassName: "system-cluster-critical",




×







206



                        },




×







207



                },




×







208



        }




×








UNCOV

209



}




×







210












211



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




×







212



        envs := append([]corev1.EnvVar{




×







213



                {




×







214



                        // deprecated: left here for CI test.




×







215



                        Name:  util.OperatorWebhookModeEnv,




×







216



                        Value: "false",




×







217



                },




×







218



                {




×







219



                        Name:  util.ContainerAppName,




×







220



                        Value: util.ContainerOperatorApp,




×







221



                },




×







222



                {




×







223



                        Name:  "KVM_EMULATION",




×







224



                        Value: "",




×







225



                },




×







226



                {




×







227



                        Name:  "OPERATOR_IMAGE",




×







228



                        Value: params.Image,




×







229



                },




×







230



                {




×







231



                        Name:  "OPERATOR_NAME",




×







232



                        Value: hcoName,




×







233



                },




×







234



                {




×







235



                        Name:  "OPERATOR_NAMESPACE",




×







236



                        Value: params.Namespace,




×







237



                },




×







238



                {




×







239



                        Name: "POD_NAME",




×







240



                        ValueFrom: &corev1.EnvVarSource{




×







241



                                FieldRef: &corev1.ObjectFieldSelector{




×







242



                                        FieldPath: "metadata.name",




×







243



                                },




×







244



                        },




×







245



                },




×







246



                {




×







247



                        Name:  "VIRTIOWIN_CONTAINER",




×







248



                        Value: params.VirtIOWinContainer,




×







249



                },




×







250



                {




×







251



                        Name:  "SMBIOS",




×







252



                        Value: params.Smbios,




×







253



                },




×







254



                {




×







255



                        Name:  "MACHINETYPE",




×







256



                        Value: params.Machinetype,




×







257



                },




×







258



                {




×







259



                        Name:  "AMD64_MACHINETYPE",




×







260



                        Value: params.Amd64MachineType,




×







261



                },




×







262



                {




×







263



                        Name:  "ARM64_MACHINETYPE",




×







264



                        Value: params.Arm64MachineType,




×







265



                },




×







266



                {




×







267



                        Name:  util.HcoKvIoVersionName,




×







268



                        Value: params.HcoKvIoVersion,




×







269



                },




×







270



                {




×







271



                        Name:  util.KubevirtVersionEnvV,




×







272



                        Value: params.KubevirtVersion,




×







273



                },




×







274



                {




×







275



                        Name:  util.CdiVersionEnvV,




×







276



                        Value: params.CdiVersion,




×







277



                },




×







278



                {




×







279



                        Name:  util.CnaoVersionEnvV,




×







280



                        Value: params.CnaoVersion,




×







281



                },




×







282



                {




×







283



                        Name:  util.SspVersionEnvV,




×







284



                        Value: params.SspVersion,




×







285



                },




×







286



                {




×







287



                        Name:  util.HppoVersionEnvV,




×







288



                        Value: params.HppoVersion,




×







289



                },




×







290



                {




×







291



                        Name:  util.AaqVersionEnvV,




×







292



                        Value: params.AaqVersion,




×







293



                },




×







294



                {




×







295



                        Name:  util.KVUIPluginImageEnvV,




×







296



                        Value: params.KVUIPluginImage,




×







297



                },




×







298



                {




×







299



                        Name:  util.KVUIProxyImageEnvV,




×







300



                        Value: params.KVUIProxyImage,




×







301



                },




×








NEW


302



                {




×








NEW


303



                        Name:  util.PasstImageEnvV,




×








NEW


304



                        Value: params.PasstImage,




×








NEW


305



                },




×








NEW


306



                {




×








NEW


307



                        Name:  util.PasstCNIImageEnvV,




×








NEW


308



                        Value: params.PasstCNIImage,




×








NEW


309



                },




×







310



        }, params.Env...)




×







311






×







312



        if params.KvVirtLancherOsVersion != "" {




×








UNCOV

313



                envs = append(envs, corev1.EnvVar{




×







314



                        Name:  util.KvVirtLauncherOSVersionEnvV,




×








UNCOV

315



                        Value: params.KvVirtLancherOsVersion,




×








UNCOV

316



                })




×







317



        }




×







318












319



        return envs




×







320



}










321












322



func GetDeploymentSpecCliDownloads(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







323



        return appsv1.DeploymentSpec{




×







324



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




×







325



                Selector: &metav1.LabelSelector{




×







326



                        MatchLabels: map[string]string{




×







327



                                "name": cliDownloadsName,




×







328



                        },




×







329



                },




×







330



                Strategy: appsv1.DeploymentStrategy{




×







331



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







332



                },




×







333



                Template: corev1.PodTemplateSpec{




×







334



                        ObjectMeta: metav1.ObjectMeta{




×







335



                                Labels: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







336



                        },




×







337



                        Spec: corev1.PodSpec{




×







338



                                ServiceAccountName:           cliDownloadsName,




×







339



                                AutomountServiceAccountToken: ptr.To(false),




×







340



                                SecurityContext:              GetStdPodSecurityContext(),




×







341



                                Containers: []corev1.Container{




×







342



                                        {




×







343



                                                Name:            "server",




×







344



                                                Image:           params.CliDownloadsImage,




×







345



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







346



                                                Resources: corev1.ResourceRequirements{




×







347



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




×







348



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




×







349



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




×







350



                                                        },




×







351



                                                },




×







352



                                                Ports: []corev1.ContainerPort{




×







353



                                                        {




×







354



                                                                Protocol:      corev1.ProtocolTCP,




×







355



                                                                ContainerPort: util.CliDownloadsServerPort,




×







356



                                                        },




×







357



                                                },




×







358



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







359



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




×







360



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




×







361



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







362



                                        },




×







363



                                },




×








UNCOV

364



                                PriorityClassName: "system-cluster-critical",




×







365



                        },




×







366



                },




×







367



        }




×







368



}




×







369












370



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




×







371



        return map[string]string{




×







372



                "name":                 name,




×








UNCOV

373



                util.AppLabelVersion:   hcoKvIoVersion,




×







374



                util.AppLabelPartOf:    util.HyperConvergedCluster,




×







375



                util.AppLabelComponent: string(util.AppComponentDeployment),




×







376



        }




×







377



}




×







378












379



func getLabelsWithNetworkPolicies(deploymentName string, params *DeploymentOperatorParams) map[string]string {




×








UNCOV

380



        labels := getLabels(deploymentName, params.HcoKvIoVersion)




×







381



        if params.AddNetworkPolicyLabels {




×








UNCOV

382



                labels[allowEgressToDNSAndAPIServerLabel] = "true"




×








UNCOV

383



                labels[allowIngressToMetricsEndpointLabel] = "true"




×








UNCOV

384



        }




×







385













UNCOV

386



        return labels




×







387



}










388












389



func GetStdPodSecurityContext() *corev1.PodSecurityContext {




3✔





390



        return &corev1.PodSecurityContext{




3✔





391



                RunAsNonRoot: ptr.To(true),




3✔





392



                SeccompProfile: &corev1.SeccompProfile{




3✔





393



                        Type: corev1.SeccompProfileTypeRuntimeDefault,




3✔





394



                },




3✔





395



        }




3✔





396



}




3✔





397












398



func GetStdContainerSecurityContext() *corev1.SecurityContext {




3✔





399



        return &corev1.SecurityContext{




3✔





400



                AllowPrivilegeEscalation: ptr.To(false),




3✔





401



                Capabilities: &corev1.Capabilities{




3✔





402



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




3✔





403



                },




3✔





404



        }




3✔





405



}




3✔





406












407



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










408



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










409



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










410



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










411



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










412



// delete request on HCO CR.










413



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










414



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










415



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










416



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










417



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










418



// webhook one.










419



func GetDeploymentSpecWebhook(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







420



        return appsv1.DeploymentSpec{




×







421



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




×







422



                Selector: &metav1.LabelSelector{




×







423



                        MatchLabels: map[string]string{




×







424



                                "name": hcoNameWebhook,




×







425



                        },




×







426



                },




×







427



                Strategy: appsv1.DeploymentStrategy{




×







428



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







429



                },




×







430



                Template: corev1.PodTemplateSpec{




×







431



                        ObjectMeta: metav1.ObjectMeta{




×







432



                                Labels: getLabelsWithNetworkPolicies(hcoNameWebhook, params),




×







433



                        },




×







434



                        Spec: corev1.PodSpec{




×







435



                                ServiceAccountName: hcoName,




×







436



                                SecurityContext:    GetStdPodSecurityContext(),




×







437



                                Containers: []corev1.Container{




×







438



                                        {




×







439



                                                Name:            hcoNameWebhook,




×







440



                                                Image:           params.WebhookImage,




×







441



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







442



                                                Command:         stringListToSlice(hcoNameWebhook),




×







443



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




×







444



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




×







445



                                                Env: append([]corev1.EnvVar{




×







446



                                                        {




×







447



                                                                // deprecated: left here for CI test.




×







448



                                                                Name:  util.OperatorWebhookModeEnv,




×







449



                                                                Value: "true",




×







450



                                                        },




×







451



                                                        {




×







452



                                                                Name:  util.ContainerAppName,




×







453



                                                                Value: util.ContainerWebhookApp,




×







454



                                                        },




×







455



                                                        {




×







456



                                                                Name:  "OPERATOR_IMAGE",




×







457



                                                                Value: params.WebhookImage,




×







458



                                                        },




×







459



                                                        {




×







460



                                                                Name:  "OPERATOR_NAME",




×







461



                                                                Value: hcoNameWebhook,




×







462



                                                        },




×







463



                                                        {




×







464



                                                                Name:  "OPERATOR_NAMESPACE",




×







465



                                                                Value: params.Namespace,




×







466



                                                        },




×







467



                                                        {




×







468



                                                                Name: "POD_NAME",




×







469



                                                                ValueFrom: &corev1.EnvVarSource{




×







470



                                                                        FieldRef: &corev1.ObjectFieldSelector{




×







471



                                                                                FieldPath: "metadata.name",




×







472



                                                                        },




×







473



                                                                },




×







474



                                                        },




×







475



                                                }, params.Env...),




×







476



                                                Resources: corev1.ResourceRequirements{




×







477



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




×







478



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




×







479



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




×







480



                                                        },




×







481



                                                },




×







482



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







483



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







484



                                                Ports: []corev1.ContainerPort{




×







485



                                                        getWebhookPort(),




×







486



                                                        getMetricsPort(),




×







487



                                                },




×







488



                                        },




×







489



                                },




×








UNCOV

490



                                PriorityClassName: "system-node-critical",




×







491



                        },




×







492



                },




×







493



        }




×







494



}




×







495












496



func GetClusterRole() rbacv1.ClusterRole {




×







497



        return rbacv1.ClusterRole{




×







498



                TypeMeta: metav1.TypeMeta{




×







499



                        APIVersion: rbacVersionV1,




×







500



                        Kind:       "ClusterRole",




×







501



                },




×







502



                ObjectMeta: metav1.ObjectMeta{




×







503



                        Name: hcoName,




×







504



                        Labels: map[string]string{




×







505



                                "name": hcoName,




×








UNCOV

506



                        },




×








UNCOV

507



                },




×








UNCOV

508



                Rules: GetClusterPermissions(),




×








UNCOV

509



        }




×








UNCOV

510



}




×







511












512



var (










513



        emptyAPIGroup = []string{""}










514



)










515












516



func GetClusterPermissions() []rbacv1.PolicyRule {




×







517



        const configOpenshiftIO = "config.openshift.io"




×







518



        const operatorOpenshiftIO = "operator.openshift.io"




×







519



        return []rbacv1.PolicyRule{




×







520



                {




×







521



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







522



                        Resources: stringListToSlice("hyperconvergeds"),




×







523



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




×







524



                },




×







525



                {




×







526



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







527



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




×







528



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




×







529



                },




×







530



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




×







531



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




×







532



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




×







533



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




×







534



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




×







535



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




×







536



                {




×







537



                        APIGroups: emptyAPIGroup,




×







538



                        Resources: stringListToSlice("events"),




×







539



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




×







540



                },




×







541



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




×







542



                {




×







543



                        APIGroups: emptyAPIGroup,




×







544



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




×







545



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




×







546



                },




×







547



                {




×







548



                        APIGroups: emptyAPIGroup,




×







549



                        Resources: stringListToSlice("secrets"),




×







550



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




×







551



                },




×







552



                {




×







553



                        APIGroups: emptyAPIGroup,




×







554



                        Resources: stringListToSlice("endpoints"),




×







555



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




×







556



                },




×







557



                {




×







558



                        APIGroups: emptyAPIGroup,




×







559



                        Resources: stringListToSlice("namespaces"),




×







560



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




×







561



                },




×







562



                {




×







563



                        APIGroups: stringListToSlice("apps"),




×







564



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




×







565



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




×







566



                },




×







567



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




×







568



                {




×







569



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




×







570



                        Resources: stringListToSlice("customresourcedefinitions"),




×







571



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




×







572



                },




×







573



                {




×







574



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




×







575



                        Resources: stringListToSlice("customresourcedefinitions/status"),




×







576



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




×







577



                },




×







578



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




×







579



                {




×







580



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




×







581



                        Resources: stringListToSlice("clusterserviceversions"),




×







582



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




×







583



                },




×







584



                {




×







585



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




×







586



                        Resources: stringListToSlice("priorityclasses"),




×







587



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




×







588



                },




×







589



                {




×







590



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




×







591



                        Resources: stringListToSlice("validatingwebhookconfigurations"),




×







592



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




×







593



                },




×







594



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




×







595



                {




×







596



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







597



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




×







598



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




×







599



                },




×







600



                {




×







601



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







602



                        Resources: stringListToSlice("ingresses"),




×







603



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




×







604



                },




×







605



                {




×







606



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







607



                        Resources: stringListToSlice("ingresses/status"),




×







608



                        Verbs:     stringListToSlice("update"),




×







609



                },




×







610



                {




×







611



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







612



                        Resources: stringListToSlice("apiservers"),




×







613



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




×







614



                },




×







615



                {




×







616



                        APIGroups: stringListToSlice(operatorOpenshiftIO),




×







617



                        Resources: stringListToSlice("kubedeschedulers"),




×







618



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




×







619



                },




×







620



                {




×







621



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







622



                        Resources: stringListToSlice("dnses"),




×







623



                        Verbs:     stringListToSlice("get"),




×







624



                },




×







625



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




×







626



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




×







627



                {




×







628



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




×







629



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




×







630



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




×







631



                },




×







632



                {




×







633



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




×







634



                        Resources: stringListToSlice("operatorconditions"),




×







635



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




×







636



                },




×







637



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




×







638



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




×







639



                {




×







640



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




×







641



                        Resources: stringListToSlice("consoles"),




×







642



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




×







643



                },




×







644



                {




×







645



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




×








UNCOV

646



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




×







647



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




×







648



                },




×








NEW


649



                {




×








NEW


650



                        APIGroups: stringListToSlice(""),




×








NEW


651



                        Resources: stringListToSlice("serviceaccounts"),




×








NEW


652



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




×








NEW


653



                },




×








NEW


654



                {




×








NEW


655



                        APIGroups: stringListToSlice("apps"),




×








NEW


656



                        Resources: stringListToSlice("daemonsets"),




×








NEW


657



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




×








NEW


658



                },




×








NEW


659



                {




×








NEW


660



                        APIGroups: stringListToSlice("k8s.cni.cncf.io"),




×








NEW


661



                        Resources: stringListToSlice("network-attachment-definitions"),




×








NEW


662



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




×








NEW


663



                },




×








NEW


664



                {




×








NEW


665



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




×








NEW


666



                        Resources: stringListToSlice("securitycontextconstraints"),




×








NEW


667



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




×








NEW


668



                },




×








UNCOV

669



        }




×







670



}




×







671












672



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




×








UNCOV

673



        return rbacv1.PolicyRule{




×







674



                APIGroups: stringListToSlice(apiGroup),




×







675



                Resources: resources,




×







676



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




×








UNCOV

677



        }




×







678



}




×







679












680



func GetServiceAccount(namespace string) corev1.ServiceAccount {




×







681



        return createServiceAccount(namespace, hcoName)




×







682



}




×







683












684



func GetCLIDownloadServiceAccount(namespace string) corev1.ServiceAccount {




×







685



        return createServiceAccount(namespace, cliDownloadsName)




×







686



}




×







687












688



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




×







689



        return corev1.ServiceAccount{




×







690



                TypeMeta: metav1.TypeMeta{




×







691



                        APIVersion: "v1",




×







692



                        Kind:       "ServiceAccount",




×








UNCOV

693



                },




×







694



                ObjectMeta: metav1.ObjectMeta{




×







695



                        Name:      name,




×







696



                        Namespace: namespace,




×







697



                        Labels: map[string]string{




×







698



                                "name": name,




×







699



                        },




×







700



                },




×







701



        }




×







702



}




×







703












704



func GetClusterRoleBinding(namespace string) rbacv1.ClusterRoleBinding {




×







705



        return rbacv1.ClusterRoleBinding{




×







706



                TypeMeta: metav1.TypeMeta{




×







707



                        APIVersion: rbacVersionV1,




×







708



                        Kind:       "ClusterRoleBinding",




×







709



                },




×







710



                ObjectMeta: metav1.ObjectMeta{




×







711



                        Name: hcoName,




×







712



                        Labels: map[string]string{




×







713



                                "name": hcoName,




×







714



                        },




×







715



                },




×







716



                RoleRef: rbacv1.RoleRef{




×







717



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




×







718



                        Kind:     "ClusterRole",




×







719



                        Name:     hcoName,




×








UNCOV

720



                },




×







721



                Subjects: []rbacv1.Subject{




×







722



                        {




×







723



                                Kind:      "ServiceAccount",




×







724



                                Name:      hcoName,




×







725



                                Namespace: namespace,




×







726



                        },




×







727



                },




×







728



        }




×







729



}




×







730













UNCOV

731



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




×







732



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




×








UNCOV

733



        for _, errKind := range filterKinds {




×








UNCOV

734



                toSkip[errKind] = struct{}{}




×







735



        }




×








UNCOV

736



        var outErr error




×








UNCOV

737



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




×








UNCOV

738



                for _, err := range pkgRaw.Errors {




×








UNCOV

739



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




×







740



                                continue




×







741



                        }










742



                        outErr = err




×







743



                }










744



        })










745



        return outErr




×







746



}










747












748



const objectType = "object"










749












750



func GetOperatorCRD(relPath string) *extv1.CustomResourceDefinition {




×







751



        pkgs, err := loader.LoadRoots(relPath)




×







752



        if err != nil {




×







753



                panic(err)




×







754



        }










755



        reg := &markers.Registry{}




×







756



        panicOnError(crdmarkers.Register(reg))




×








UNCOV

757






×







758



        parser := &crdgen.Parser{




×







759



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




×







760



                Checker:                    &loader.TypeChecker{},




×







761



                GenerateEmbeddedObjectMeta: true,




×







762



        }




×







763






×







764



        crdgen.AddKnownTypes(parser)




×







765



        if len(pkgs) == 0 {




×







766



                panic("Failed identifying packages")




×







767



        }











UNCOV

768



        for _, p := range pkgs {




×







769



                parser.NeedPackage(p)




×







770



        }




×







771



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




×







772



        parser.NeedCRDFor(groupKind, nil)




×







773



        for _, p := range pkgs {




×







774



                err = packageErrors(p, packages.TypeError)




×







775



                if err != nil {




×







776



                        panic(err)




×







777



                }










778



        }










779



        c := parser.CustomResourceDefinitions[groupKind]




×







780



        // enforce validation of CR name to prevent multiple CRs




×







781



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




×







782



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




×








UNCOV

783



                        Type: objectType,




×








UNCOV

784



                        Properties: map[string]extv1.JSONSchemaProps{




×








UNCOV

785



                                "name": {




×








UNCOV

786



                                        Type:    "string",




×








UNCOV

787



                                        Pattern: hcov1beta1.HyperConvergedName,




×








UNCOV

788



                                },




×








UNCOV

789



                        },




×








UNCOV

790



                }




×








UNCOV

791



        }




×








UNCOV

792



        return &c




×







793



}










794












795



func GetOperatorCR() *hcov1beta1.HyperConverged {




11✔





796



        defaultScheme := runtime.NewScheme()




11✔





797



        _ = hcov1beta1.AddToScheme(defaultScheme)




11✔





798



        _ = hcov1beta1.RegisterDefaults(defaultScheme)




11✔





799



        defaultHco := &hcov1beta1.HyperConverged{




11✔





800



                TypeMeta: metav1.TypeMeta{




11✔





801



                        APIVersion: util.APIVersion,




11✔





802



                        Kind:       util.HyperConvergedKind,




11✔





803



                },




11✔





804



                ObjectMeta: metav1.ObjectMeta{




11✔





805



                        Name: crName,




11✔





806



                }}




11✔





807



        defaultScheme.Default(defaultHco)




11✔





808



        return defaultHco




11✔





809



}




11✔





810












811



// GetInstallStrategyBase returns the basics of an HCO InstallStrategy










812



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




×







813



        return &csvv1alpha1.StrategyDetailsDeployment{




×







814






×







815



                DeploymentSpecs: []csvv1alpha1.StrategyDeploymentSpec{




×







816



                        {




×







817



                                Name:  hcoDeploymentName,




×







818



                                Spec:  GetDeploymentSpecOperator(params),




×







819



                                Label: getLabels(hcoName, params.HcoKvIoVersion),




×







820



                        },




×







821



                        {




×







822



                                Name:  hcoWhDeploymentName,




×







823



                                Spec:  GetDeploymentSpecWebhook(params),




×







824



                                Label: getLabels(hcoNameWebhook, params.HcoKvIoVersion),




×







825



                        },




×







826



                        {




×







827



                                Name:  cliDownloadsName,




×







828



                                Spec:  GetDeploymentSpecCliDownloads(params),




×







829



                                Label: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







830



                        },




×







831



                },




×







832



                Permissions: []csvv1alpha1.StrategyDeploymentPermissions{},




×







833



                ClusterPermissions: []csvv1alpha1.StrategyDeploymentPermissions{




×







834



                        {




×








UNCOV

835



                                ServiceAccountName: hcoName,




×








UNCOV

836



                                Rules:              GetClusterPermissions(),




×








UNCOV

837



                        },




×








UNCOV

838



                        {




×








UNCOV

839



                                ServiceAccountName: cliDownloadsName,




×








UNCOV

840



                                Rules:              []rbacv1.PolicyRule{},




×








UNCOV

841



                        },




×








UNCOV

842



                },




×








UNCOV

843



        }




×








UNCOV

844



}




×







845












846



type CSVBaseParams struct {










847



        Name            string










848



        Namespace       string










849



        DisplayName     string










850



        MetaDescription string










851



        Description     string










852



        Image           string










853



        Replaces        string










854



        Version         semver.Version










855



        CrdDisplay      string










856



}










857












858



// GetCSVBase returns a base HCO CSV without an InstallStrategy










859



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




×







860



        almExamples, _ := json.Marshal(




×







861



                map[string]interface{}{




×







862



                        "apiVersion": util.APIVersion,




×







863



                        "kind":       util.HyperConvergedKind,




×







864



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




×







865



                                "name":      packageName,




×







866



                                "namespace": params.Namespace,




×







867



                                "annotations": map[string]string{




×







868



                                        "deployOVS": "false",




×







869



                                },




×







870



                        },




×







871



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




×







872



                })




×







873






×







874



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




×







875



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




×







876



        // to really validate the requests.




×







877



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




×







878



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




×







879



        // so failurePolicy = admissionregistrationv1.Fail




×







880






×







881



        validatingWebhook := csvv1alpha1.WebhookDescription{




×







882



                GenerateName:            util.HcoValidatingWebhook,




×







883



                Type:                    csvv1alpha1.ValidatingAdmissionWebhook,




×







884



                DeploymentName:          hcoWhDeploymentName,




×







885



                ContainerPort:           util.WebhookPort,




×







886



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




×







887



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNone),




×







888



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







889



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




×







890



                Rules: []admissionregistrationv1.RuleWithOperations{




×







891



                        {




×







892



                                Operations: []admissionregistrationv1.OperationType{




×







893



                                        admissionregistrationv1.Create,




×







894



                                        admissionregistrationv1.Delete,




×







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.HCOWebhookPath),




×







905



        }




×







906






×







907



        mutatingNamespaceWebhook := csvv1alpha1.WebhookDescription{




×







908



                GenerateName:            util.HcoMutatingWebhookNS,




×







909



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







910



                DeploymentName:          hcoWhDeploymentName,




×







911



                ContainerPort:           util.WebhookPort,




×







912



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




×







913



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







914



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







915



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




×







916



                ObjectSelector: &metav1.LabelSelector{




×







917



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




×







918



                },




×







919



                Rules: []admissionregistrationv1.RuleWithOperations{




×







920



                        {




×







921



                                Operations: []admissionregistrationv1.OperationType{




×







922



                                        admissionregistrationv1.Delete,




×







923



                                },




×







924



                                Rule: admissionregistrationv1.Rule{




×







925



                                        APIGroups:   []string{""},




×







926



                                        APIVersions: stringListToSlice("v1"),




×







927



                                        Resources:   stringListToSlice("namespaces"),




×







928



                                },




×







929



                        },




×







930



                },




×







931



                WebhookPath: ptr.To(util.HCONSWebhookPath),




×







932



        }




×







933






×







934



        mutatingHyperConvergedWebhook := csvv1alpha1.WebhookDescription{




×







935



                GenerateName:            util.HcoMutatingWebhookHyperConverged,




×







936



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







937



                DeploymentName:          hcoWhDeploymentName,




×







938



                ContainerPort:           util.WebhookPort,




×







939



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




×







940



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







941



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







942



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




×







943



                Rules: []admissionregistrationv1.RuleWithOperations{




×







944



                        {




×







945



                                Operations: []admissionregistrationv1.OperationType{




×







946



                                        admissionregistrationv1.Create,




×







947



                                        admissionregistrationv1.Update,




×







948



                                },




×







949



                                Rule: admissionregistrationv1.Rule{




×







950



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







951



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




×







952



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







953



                                },




×







954



                        },




×







955



                },




×







956



                WebhookPath: ptr.To(util.HCOMutatingWebhookPath),




×







957



        }




×







958






×







959



        return &csvv1alpha1.ClusterServiceVersion{




×







960



                TypeMeta: metav1.TypeMeta{




×







961



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




×







962



                        Kind:       "ClusterServiceVersion",




×







963



                },




×







964



                ObjectMeta: metav1.ObjectMeta{




×







965



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




×







966



                        Namespace: params.Namespace,




×







967



                        Annotations: map[string]string{




×







968



                                "alm-examples":                   string(almExamples),




×







969



                                "capabilities":                   "Deep Insights",




×







970



                                "certified":                      "false",




×







971



                                "categories":                     "OpenShift Optional",




×







972



                                "containerImage":                 params.Image,




×







973



                                DisableOperandDeletionAnnotation: "true",




×







974



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




×







975



                                "description":                    params.MetaDescription,




×







976



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




×







977



                                "support":                        "false",




×







978



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




×







979



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




×







980



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




×







981



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




×







982



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




×







983



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




×







984



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




×







985



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




×







986



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




×







987



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




×







988



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




×







989



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




×







990



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




×







991



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




×







992



                        },




×







993



                },




×







994



                Spec: csvv1alpha1.ClusterServiceVersionSpec{




×







995



                        DisplayName: params.DisplayName,




×







996



                        Description: params.Description,




×







997



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




×







998



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




×







999



                        Replaces:    params.Replaces,




×







1000



                        Maintainers: []csvv1alpha1.Maintainer{




×







1001



                                {




×







1002



                                        Name:  kubevirtProjectName,




×







1003



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




×







1004



                                },




×







1005



                        },




×







1006



                        Maturity: "alpha",




×







1007



                        Provider: csvv1alpha1.AppLink{




×







1008



                                Name: kubevirtProjectName,




×







1009



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




×







1010



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




×







1011



                        },




×







1012



                        Links: []csvv1alpha1.AppLink{




×







1013



                                {




×







1014



                                        Name: kubevirtProjectName,




×







1015



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




×







1016



                                },




×







1017



                                {




×







1018



                                        Name: "Source Code",




×







1019



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




×







1020



                                },




×







1021



                        },




×







1022



                        Icon: []csvv1alpha1.Icon{




×







1023



                                {




×







1024



                                        MediaType: "image/svg+xml",




×







1025



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




×







1026



                                },




×







1027



                        },




×







1028



                        Labels: map[string]string{




×







1029



                                "alm-owner-kubevirt": packageName,




×







1030



                                "operated-by":        packageName,




×







1031



                        },




×







1032



                        Selector: &metav1.LabelSelector{




×







1033



                                MatchLabels: map[string]string{




×







1034



                                        "alm-owner-kubevirt": packageName,




×







1035



                                        "operated-by":        packageName,




×







1036



                                },




×







1037



                        },




×







1038



                        InstallModes: []csvv1alpha1.InstallMode{




×







1039



                                {




×







1040



                                        Type:      csvv1alpha1.InstallModeTypeOwnNamespace,




×







1041



                                        Supported: false,




×







1042



                                },




×







1043



                                {




×







1044



                                        Type:      csvv1alpha1.InstallModeTypeSingleNamespace,




×







1045



                                        Supported: false,




×







1046



                                },




×







1047



                                {




×







1048



                                        Type:      csvv1alpha1.InstallModeTypeMultiNamespace,




×







1049



                                        Supported: false,




×







1050



                                },




×







1051



                                {




×







1052



                                        Type:      csvv1alpha1.InstallModeTypeAllNamespaces,




×







1053



                                        Supported: true,




×







1054



                                },




×







1055



                        },




×







1056



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




×







1057



                        // the actual StrategyDetailsDeployment when merging CSVs




×







1058



                        InstallStrategy: csvv1alpha1.NamedInstallStrategy{},




×







1059



                        WebhookDefinitions: []csvv1alpha1.WebhookDescription{




×







1060



                                validatingWebhook,




×







1061



                                mutatingNamespaceWebhook,




×







1062



                                mutatingHyperConvergedWebhook,




×







1063



                        },




×







1064



                        CustomResourceDefinitions: csvv1alpha1.CustomResourceDefinitions{




×







1065



                                Owned: []csvv1alpha1.CRDDescription{




×







1066



                                        {




×







1067



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




×







1068



                                                Version:     util.CurrentAPIVersion,




×







1069



                                                Kind:        util.HyperConvergedKind,




×







1070



                                                DisplayName: params.CrdDisplay + " Deployment",




×







1071



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




×







1072



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




×







1073



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




×







1074



                                                SpecDescriptors: []csvv1alpha1.SpecDescriptor{




×







1075



                                                        {




×







1076



                                                                DisplayName: "Infra components node affinity",




×







1077



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




×







1078



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




×







1079



                                                                XDescriptors: stringListToSlice(




×







1080



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




×







1081



                                                                ),




×







1082



                                                        },




×







1083



                                                        {




×







1084



                                                                DisplayName: "Infra components pod affinity",




×







1085



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




×







1086



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




×







1087



                                                                XDescriptors: stringListToSlice(




×







1088



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




×







1089



                                                                ),




×







1090



                                                        },




×







1091



                                                        {




×







1092



                                                                DisplayName: "Infra components pod anti-affinity",




×







1093



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




×







1094



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




×







1095



                                                                XDescriptors: stringListToSlice(




×







1096



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




×







1097



                                                                ),




×







1098



                                                        },




×







1099



                                                        {




×







1100



                                                                DisplayName: "Workloads components node affinity",




×







1101



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




×







1102



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




×







1103



                                                                XDescriptors: stringListToSlice(




×







1104



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




×







1105



                                                                ),




×







1106



                                                        },




×







1107



                                                        {




×







1108



                                                                DisplayName: "Workloads components pod affinity",




×







1109



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




×







1110



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




×







1111



                                                                XDescriptors: stringListToSlice(




×







1112



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




×







1113



                                                                ),




×







1114



                                                        },




×







1115



                                                        {




×







1116



                                                                DisplayName: "Workloads components pod anti-affinity",




×







1117



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




×







1118



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




×







1119



                                                                XDescriptors: stringListToSlice(




×







1120



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




×







1121



                                                                ),




×







1122



                                                        },




×







1123



                                                        {




×







1124



                                                                DisplayName: "HIDDEN FIELDS - operator version",




×







1125



                                                                Description: "HIDDEN FIELDS - operator version.",




×







1126



                                                                Path:        "version",




×







1127



                                                                XDescriptors: stringListToSlice(




×







1128



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




×







1129



                                                                ),




×








UNCOV

1130



                                                        },




×







1131



                                                },




×







1132



                                                StatusDescriptors: []csvv1alpha1.StatusDescriptor{},




×







1133



                                        },




×







1134



                                },




×







1135



                                Required: []csvv1alpha1.CRDDescription{},




×







1136



                        },




×








UNCOV

1137



                },




×








UNCOV

1138



        }




×







1139



}




×







1140












1141



func InjectVolumesForWebHookCerts(deploy *appsv1.Deployment) {




×







1142



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




×







1143



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




×







1144



                if vol.Name == certVolume {




×







1145



                        return




×







1146



                }




×







1147



        }










1148












1149



        volume := corev1.Volume{




×







1150



                Name: certVolume,




×







1151



                VolumeSource: corev1.VolumeSource{




×







1152



                        Secret: &corev1.SecretVolumeSource{




×







1153



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




×







1154



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




×







1155



                                Items: []corev1.KeyToPath{




×







1156



                                        {




×







1157



                                                Key:  "tls.crt",




×







1158



                                                Path: util.WebhookCertName,




×







1159



                                        },




×







1160



                                        {




×







1161



                                                Key:  "tls.key",




×







1162



                                                Path: util.WebhookKeyName,




×







1163



                                        },




×







1164



                                },




×







1165



                        },




×







1166



                },




×








UNCOV

1167



        }




×








UNCOV

1168



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




×







1169






×







1170



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




×







1171



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




×







1172



                        corev1.VolumeMount{




×







1173



                                Name:      certVolume,




×







1174



                                MountPath: util.DefaultWebhookCertDir,




×







1175



                        })




×







1176



        }




×







1177



}










1178












1179



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




×







1180



        return &corev1.Probe{




×







1181



                ProbeHandler: corev1.ProbeHandler{




×







1182



                        HTTPGet: &corev1.HTTPGetAction{




×







1183



                                Path: endpoint,




×







1184



                                Port: intstr.IntOrString{




×







1185



                                        Type:   intstr.Int,




×








UNCOV

1186



                                        IntVal: port,




×







1187



                                },




×







1188



                                Scheme: corev1.URISchemeHTTP,




×







1189



                        },




×







1190



                },




×







1191



                InitialDelaySeconds: 5,




×







1192



                PeriodSeconds:       5,




×







1193



                FailureThreshold:    1,




×







1194



        }




×







1195



}




×







1196












1197



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




×







1198



        return &corev1.Probe{




×







1199



                ProbeHandler: corev1.ProbeHandler{




×







1200



                        HTTPGet: &corev1.HTTPGetAction{




×







1201



                                Path: endpoint,




×







1202



                                Port: intstr.IntOrString{




×







1203



                                        Type:   intstr.Int,




×








UNCOV

1204



                                        IntVal: port,




×







1205



                                },




×







1206



                                Scheme: corev1.URISchemeHTTP,




×







1207



                        },




×







1208



                },




×







1209



                InitialDelaySeconds: 30,




×







1210



                PeriodSeconds:       5,




×







1211



                FailureThreshold:    1,




×








UNCOV

1212



        }




×







1213



}




×







1214












1215



func getMetricsPort() corev1.ContainerPort {




×







1216



        return corev1.ContainerPort{




×







1217



                Name:          util.MetricsPortName,




×







1218



                ContainerPort: util.MetricsPort,




×







1219



                Protocol:      corev1.ProtocolTCP,




×








UNCOV

1220



        }




×







1221



}




×







1222












1223



func getWebhookPort() corev1.ContainerPort {




×








UNCOV

1224



        return corev1.ContainerPort{




×







1225



                Name:          util.WebhookPortName,




×







1226



                ContainerPort: util.WebhookPort,




×







1227



                Protocol:      corev1.ProtocolTCP,




×








UNCOV

1228



        }




×








UNCOV

1229



}




×







1230













UNCOV

1231



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




×








UNCOV

1232



        return words




×








UNCOV

1233



}




×







1234













UNCOV

1235



func panicOnError(err error) {




×








UNCOV

1236



        if err != nil {




×








UNCOV

1237



                panic(err)




×







1238



        }










1239



}
























    

  • 

    •