kubevirt / hyperconverged-cluster-operator / 13113994127

coverage: 71.921% (-0.01%) from 71.931%

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

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









3



import (










4



        "encoding/json"










5



        "fmt"










6



        "strconv"










7



        "time"










8












9



        "k8s.io/utils/ptr"










10












11



        "github.com/blang/semver/v4"










12



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










13



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










14



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










15



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










16



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










17



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










18



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










19



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










20



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










21



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










22



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










23



        "k8s.io/apimachinery/pkg/runtime"










24



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










25



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










26



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










27



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










28



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










29



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










30












31



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










32



        kvapi "kubevirt.io/api/core"










33



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










34



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










35



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










36












37



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










38



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










39



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










40



)










41












42



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










43












44



const (










45



        crName              = util.HyperConvergedName










46



        packageName         = util.HyperConvergedName










47



        hcoName             = "hyperconverged-cluster-operator"










48



        hcoNameWebhook      = "hyperconverged-cluster-webhook"










49



        hcoDeploymentName   = "hco-operator"










50



        hcoWhDeploymentName = "hco-webhook"










51



        certVolume          = "apiservice-cert"










52












53



        cliDownloadsName = "hyperconverged-cluster-cli-download"










54












55



        kubevirtProjectName = "KubeVirt project"










56



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










57



)










58












59



var deploymentType = metav1.TypeMeta{










60



        APIVersion: "apps/v1",










61



        Kind:       "Deployment",










62



}










63












64



type DeploymentOperatorParams struct {










65



        Namespace              string










66



        Image                  string










67



        WebhookImage           string










68



        CliDownloadsImage      string










69



        KVUIPluginImage        string










70



        KVUIProxyImage         string










71



        ImagePullPolicy        string










72



        ConversionContainer    string










73



        VmwareContainer        string










74



        VirtIOWinContainer     string










75



        Smbios                 string










76



        Machinetype            string










77



        Amd64MachineType       string










78



        Arm64MachineType       string










79



        HcoKvIoVersion         string










80



        KubevirtVersion        string










81



        KvVirtLancherOsVersion string










82



        CdiVersion             string










83



        CnaoVersion            string










84



        SspVersion             string










85



        HppoVersion            string










86



        MtqVersion             string










87



        AaqVersion             string










88



        PrimaryUDNImage        string










89



        Env                    []corev1.EnvVar










90



}










91












92



func GetDeploymentOperator(params *DeploymentOperatorParams) appsv1.Deployment {




×







93



        return appsv1.Deployment{




×







94



                TypeMeta: deploymentType,




×







95



                ObjectMeta: metav1.ObjectMeta{




×







96



                        Name: hcoName,




×







97



                        Labels: map[string]string{




×







98



                                "name": hcoName,




×







99



                        },




×







100



                },




×







101



                Spec: GetDeploymentSpecOperator(params),




×







102



        }




×







103



}




×







104












105



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




×







106



        deploy := appsv1.Deployment{




×







107



                TypeMeta: deploymentType,




×







108



                ObjectMeta: metav1.ObjectMeta{




×







109



                        Name: hcoNameWebhook,




×







110



                        Labels: map[string]string{




×







111



                                "name": hcoNameWebhook,




×







112



                        },




×







113



                },




×







114



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




×







115



        }




×







116






×







117



        InjectVolumesForWebHookCerts(&deploy)




×







118



        return deploy




×







119



}




×







120












121



func GetDeploymentCliDownloads(params *DeploymentOperatorParams) appsv1.Deployment {




×







122



        return appsv1.Deployment{




×







123



                TypeMeta: deploymentType,




×







124



                ObjectMeta: metav1.ObjectMeta{




×







125



                        Name: cliDownloadsName,




×







126



                        Labels: map[string]string{




×







127



                                "name": cliDownloadsName,




×







128



                        },




×







129



                },




×







130



                Spec: GetDeploymentSpecCliDownloads(params),




×







131



        }




×







132



}




×







133












134



func GetServiceWebhook() v1.Service {




×







135



        return v1.Service{




×







136



                TypeMeta: metav1.TypeMeta{




×







137



                        APIVersion: "v1",




×







138



                        Kind:       "Service",




×







139



                },




×







140



                ObjectMeta: metav1.ObjectMeta{




×







141



                        Name: hcoNameWebhook + "-service",




×







142



                },




×







143



                Spec: v1.ServiceSpec{




×







144



                        Selector: map[string]string{




×







145



                                "name": hcoNameWebhook,




×







146



                        },




×







147



                        Ports: []v1.ServicePort{




×







148



                                {




×







149



                                        Name:       strconv.Itoa(util.WebhookPort),




×







150



                                        Port:       util.WebhookPort,




×







151



                                        Protocol:   corev1.ProtocolTCP,




×







152



                                        TargetPort: intstr.FromInt32(util.WebhookPort),




×







153



                                },




×







154



                        },




×







155



                        Type: corev1.ServiceTypeClusterIP,




×







156



                },




×







157



        }




×







158



}




×







159












160



func GetDeploymentSpecOperator(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







161



        envs := buildEnvVars(params)




×







162






×







163



        return appsv1.DeploymentSpec{




×







164



                Replicas: int32Ptr(1),




×







165



                Selector: &metav1.LabelSelector{




×







166



                        MatchLabels: map[string]string{




×







167



                                "name": hcoName,




×







168



                        },




×







169



                },




×







170



                Strategy: appsv1.DeploymentStrategy{




×







171



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







172



                },




×







173



                Template: corev1.PodTemplateSpec{




×







174



                        ObjectMeta: metav1.ObjectMeta{




×







175



                                Labels: getLabels(hcoName, params.HcoKvIoVersion),




×







176



                        },




×







177



                        Spec: corev1.PodSpec{




×







178



                                ServiceAccountName: hcoName,




×







179



                                SecurityContext:    GetStdPodSecurityContext(),




×







180



                                Containers: []corev1.Container{




×







181



                                        {




×







182



                                                Name:            hcoName,




×







183



                                                Image:           params.Image,




×







184



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







185



                                                Command:         stringListToSlice(hcoName),




×







186



                                                ReadinessProbe:  getReadinessProbe(),




×







187



                                                LivenessProbe:   getLivenessProbe(),




×







188



                                                Env:             envs,




×







189



                                                Resources: v1.ResourceRequirements{




×







190



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




×







191



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




×







192



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




×







193



                                                        },




×







194



                                                },




×







195



                                                SecurityContext: GetStdContainerSecurityContext(),




×







196



                                        },




×







197



                                },




×







198



                                PriorityClassName: "system-cluster-critical",




×







199



                        },




×







200



                },




×







201



        }




×







202



}




×







203












204



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




×







205



        envs := append([]corev1.EnvVar{




×







206



                {




×







207



                        // deprecated: left here for CI test.




×







208



                        Name:  util.OperatorWebhookModeEnv,




×







209



                        Value: "false",




×







210



                },




×







211



                {




×







212



                        Name:  util.ContainerAppName,




×







213



                        Value: util.ContainerOperatorApp,




×







214



                },




×







215



                {




×







216



                        Name:  "KVM_EMULATION",




×







217



                        Value: "",




×







218



                },




×







219



                {




×







220



                        Name:  "OPERATOR_IMAGE",




×







221



                        Value: params.Image,




×







222



                },




×







223



                {




×







224



                        Name:  "OPERATOR_NAME",




×







225



                        Value: hcoName,




×







226



                },




×







227



                {




×







228



                        Name:  "OPERATOR_NAMESPACE",




×







229



                        Value: params.Namespace,




×







230



                },




×







231



                {




×







232



                        Name: "POD_NAME",




×







233



                        ValueFrom: &corev1.EnvVarSource{




×







234



                                FieldRef: &corev1.ObjectFieldSelector{




×







235



                                        FieldPath: "metadata.name",




×







236



                                },




×







237



                        },




×







238



                },




×







239



                {




×







240



                        Name:  "VIRTIOWIN_CONTAINER",




×







241



                        Value: params.VirtIOWinContainer,




×







242



                },




×







243



                {




×







244



                        Name:  "SMBIOS",




×







245



                        Value: params.Smbios,




×







246



                },




×







247



                {




×







248



                        Name:  "MACHINETYPE",




×







249



                        Value: params.Machinetype,




×







250



                },




×







251



                {




×







252



                        Name:  "AMD64_MACHINETYPE",




×







253



                        Value: params.Amd64MachineType,




×







254



                },




×







255



                {




×







256



                        Name:  "ARM64_MACHINETYPE",




×







257



                        Value: params.Arm64MachineType,




×







258



                },




×







259



                {




×







260



                        Name:  util.HcoKvIoVersionName,




×







261



                        Value: params.HcoKvIoVersion,




×







262



                },




×







263



                {




×







264



                        Name:  util.KubevirtVersionEnvV,




×







265



                        Value: params.KubevirtVersion,




×







266



                },




×







267



                {




×







268



                        Name:  util.CdiVersionEnvV,




×







269



                        Value: params.CdiVersion,




×







270



                },




×







271



                {




×







272



                        Name:  util.CnaoVersionEnvV,




×







273



                        Value: params.CnaoVersion,




×







274



                },




×







275



                {




×







276



                        Name:  util.SspVersionEnvV,




×







277



                        Value: params.SspVersion,




×







278



                },




×







279



                {




×







280



                        Name:  util.HppoVersionEnvV,




×







281



                        Value: params.HppoVersion,




×







282



                },




×







283



                {




×







284



                        Name:  util.AaqVersionEnvV,




×







285



                        Value: params.AaqVersion,




×







286



                },




×







287



                {




×







288



                        Name:  util.KVUIPluginImageEnvV,




×







289



                        Value: params.KVUIPluginImage,




×







290



                },




×







291



                {




×







292



                        Name:  util.KVUIProxyImageEnvV,




×







293



                        Value: params.KVUIProxyImage,




×







294



                },




×







295



                {




×







296



                        Name:  util.PrimaryUDNImageEnvV,




×







297



                        Value: params.PrimaryUDNImage,




×







298



                },




×







299



        }, params.Env...)




×







300






×







301



        if params.KvVirtLancherOsVersion != "" {




×







302



                envs = append(envs, corev1.EnvVar{




×







303



                        Name:  util.KvVirtLauncherOSVersionEnvV,




×







304



                        Value: params.KvVirtLancherOsVersion,




×







305



                })




×







306



        }




×







307












308



        return envs




×







309



}










310












311



func GetDeploymentSpecCliDownloads(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







312



        return appsv1.DeploymentSpec{




×







313



                Replicas: int32Ptr(1),




×







314



                Selector: &metav1.LabelSelector{




×







315



                        MatchLabels: map[string]string{




×







316



                                "name": cliDownloadsName,




×







317



                        },




×







318



                },




×







319



                Strategy: appsv1.DeploymentStrategy{




×







320



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







321



                },




×







322



                Template: corev1.PodTemplateSpec{




×







323



                        ObjectMeta: metav1.ObjectMeta{




×







324



                                Labels: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







325



                        },




×







326



                        Spec: corev1.PodSpec{




×







327



                                SecurityContext: GetStdPodSecurityContext(),




×







328



                                Containers: []corev1.Container{




×







329



                                        {




×







330



                                                Name:            "server",




×







331



                                                Image:           params.CliDownloadsImage,




×







332



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







333



                                                Resources: v1.ResourceRequirements{




×







334



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




×







335



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




×







336



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




×







337



                                                        },




×







338



                                                },




×







339



                                                Ports: []v1.ContainerPort{




×







340



                                                        {




×







341



                                                                Protocol:      v1.ProtocolTCP,




×







342



                                                                ContainerPort: int32(8080),




×







343



                                                        },




×







344



                                                },




×







345



                                                SecurityContext: GetStdContainerSecurityContext(),




×







346



                                        },




×







347



                                },




×







348



                                PriorityClassName: "system-cluster-critical",




×







349



                        },




×







350



                },




×







351



        }




×







352



}




×







353












354



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




×







355



        return map[string]string{




×







356



                "name":                    name,




×







357



                hcoutil.AppLabelVersion:   hcoKvIoVersion,




×







358



                hcoutil.AppLabelPartOf:    hcoutil.HyperConvergedCluster,




×







359



                hcoutil.AppLabelComponent: string(hcoutil.AppComponentDeployment),




×







360



        }




×







361



}




×







362












363



func GetStdPodSecurityContext() *v1.PodSecurityContext {




1✔





364



        return &v1.PodSecurityContext{




1✔





365



                RunAsNonRoot: ptr.To(true),




1✔





366



                SeccompProfile: &v1.SeccompProfile{




1✔





367



                        Type: corev1.SeccompProfileTypeRuntimeDefault,




1✔





368



                },




1✔





369



        }




1✔





370



}




1✔





371












372



func GetStdContainerSecurityContext() *v1.SecurityContext {




1✔





373



        return &v1.SecurityContext{




1✔





374



                AllowPrivilegeEscalation: ptr.To(false),




1✔





375



                Capabilities: &v1.Capabilities{




1✔





376



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




1✔





377



                },




1✔





378



        }




1✔





379



}




1✔





380












381



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










382



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










383



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










384



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










385



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










386



// delete request on HCO CR.










387



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










388



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










389



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










390



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










391



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










392



// webhook one.










393



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




×







394



        return appsv1.DeploymentSpec{




×







395



                Replicas: int32Ptr(1),




×







396



                Selector: &metav1.LabelSelector{




×







397



                        MatchLabels: map[string]string{




×







398



                                "name": hcoNameWebhook,




×







399



                        },




×







400



                },




×







401



                Strategy: appsv1.DeploymentStrategy{




×







402



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







403



                },




×







404



                Template: corev1.PodTemplateSpec{




×







405



                        ObjectMeta: metav1.ObjectMeta{




×







406



                                Labels: getLabels(hcoNameWebhook, hcoKvIoVersion),




×







407



                        },




×







408



                        Spec: corev1.PodSpec{




×







409



                                ServiceAccountName: hcoName,




×







410



                                SecurityContext:    GetStdPodSecurityContext(),




×







411



                                Containers: []corev1.Container{




×







412



                                        {




×







413



                                                Name:            hcoNameWebhook,




×







414



                                                Image:           image,




×







415



                                                ImagePullPolicy: corev1.PullPolicy(imagePullPolicy),




×







416



                                                Command:         stringListToSlice(hcoNameWebhook),




×







417



                                                ReadinessProbe:  getReadinessProbe(),




×







418



                                                LivenessProbe:   getLivenessProbe(),




×







419



                                                Env: append([]corev1.EnvVar{




×







420



                                                        {




×







421



                                                                // deprecated: left here for CI test.




×







422



                                                                Name:  util.OperatorWebhookModeEnv,




×







423



                                                                Value: "true",




×







424



                                                        },




×







425



                                                        {




×







426



                                                                Name:  util.ContainerAppName,




×







427



                                                                Value: util.ContainerWebhookApp,




×







428



                                                        },




×







429



                                                        {




×







430



                                                                Name:  "OPERATOR_IMAGE",




×







431



                                                                Value: image,




×







432



                                                        },




×







433



                                                        {




×







434



                                                                Name:  "OPERATOR_NAME",




×







435



                                                                Value: hcoNameWebhook,




×







436



                                                        },




×







437



                                                        {




×







438



                                                                Name:  "OPERATOR_NAMESPACE",




×







439



                                                                Value: namespace,




×







440



                                                        },




×







441



                                                        {




×







442



                                                                Name: "POD_NAME",




×







443



                                                                ValueFrom: &corev1.EnvVarSource{




×







444



                                                                        FieldRef: &corev1.ObjectFieldSelector{




×







445



                                                                                FieldPath: "metadata.name",




×







446



                                                                        },




×







447



                                                                },




×







448



                                                        },




×







449



                                                }, env...),




×







450



                                                Resources: v1.ResourceRequirements{




×







451



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




×







452



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




×







453



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




×







454



                                                        },




×







455



                                                },




×







456



                                                SecurityContext: GetStdContainerSecurityContext(),




×







457



                                        },




×







458



                                },




×







459



                                PriorityClassName: "system-node-critical",




×







460



                        },




×







461



                },




×







462



        }




×







463



}




×







464












465



func GetClusterRole() rbacv1.ClusterRole {




×







466



        return rbacv1.ClusterRole{




×







467



                TypeMeta: metav1.TypeMeta{




×







468



                        APIVersion: rbacVersionV1,




×







469



                        Kind:       "ClusterRole",




×







470



                },




×







471



                ObjectMeta: metav1.ObjectMeta{




×







472



                        Name: hcoName,




×







473



                        Labels: map[string]string{




×







474



                                "name": hcoName,




×







475



                        },




×







476



                },




×







477



                Rules: GetClusterPermissions(),




×







478



        }




×







479



}




×







480












481



var (










482



        emptyAPIGroup = []string{""}










483



)










484












485



func GetClusterPermissions() []rbacv1.PolicyRule {




×







486



        const configOpenshiftIO = "config.openshift.io"




×







487



        const operatorOpenshiftIO = "operator.openshift.io"




×







488



        return []rbacv1.PolicyRule{




×







489



                {




×







490



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







491



                        Resources: stringListToSlice("hyperconvergeds"),




×







492



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




×







493



                },




×







494



                {




×







495



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







496



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




×







497



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




×







498



                },




×







499



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




×







500



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




×







501



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




×







502



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




×







503



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




×







504



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




×







505



                {




×







506



                        APIGroups: emptyAPIGroup,




×







507



                        Resources: stringListToSlice("events"),




×







508



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




×







509



                },




×







510



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




×







511



                {




×







512



                        APIGroups: emptyAPIGroup,




×







513



                        Resources: stringListToSlice("pods"),




×







514



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




×







515



                },




×







516



                {




×







517



                        APIGroups: emptyAPIGroup,




×







518



                        Resources: stringListToSlice("nodes"),




×







519



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




×







520



                },




×







521



                {




×







522



                        APIGroups: emptyAPIGroup,




×







523



                        Resources: stringListToSlice("endpoints"),




×







524



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




×







525



                },




×







526



                {




×







527



                        APIGroups: emptyAPIGroup,




×







528



                        Resources: stringListToSlice("namespaces"),




×







529



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




×







530



                },




×







531



                {




×







532



                        APIGroups: stringListToSlice("apps"),




×







533



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




×







534



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




×







535



                },




×







536



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




×







537



                {




×







538



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




×







539



                        Resources: stringListToSlice("customresourcedefinitions"),




×







540



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




×







541



                },




×







542



                {




×







543



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




×







544



                        Resources: stringListToSlice("customresourcedefinitions/status"),




×







545



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




×







546



                },




×







547



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




×







548



                {




×







549



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




×







550



                        Resources: stringListToSlice("clusterserviceversions"),




×







551



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




×







552



                },




×







553



                {




×







554



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




×







555



                        Resources: stringListToSlice("priorityclasses"),




×







556



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




×







557



                },




×







558



                {




×







559



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




×







560



                        Resources: stringListToSlice("validatingwebhookconfigurations"),




×







561



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




×







562



                },




×







563



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




×







564



                {




×







565



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







566



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




×







567



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




×







568



                },




×







569



                {




×







570



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







571



                        Resources: stringListToSlice("apiservers"),




×







572



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




×







573



                },




×







574



                {




×







575



                        APIGroups: stringListToSlice(operatorOpenshiftIO),




×







576



                        Resources: stringListToSlice("kubedeschedulers"),




×







577



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




×







578



                },




×







579



                {




×







580



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







581



                        Resources: stringListToSlice("dnses"),




×







582



                        Verbs:     stringListToSlice("get"),




×







583



                },




×







584



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




×







585



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




×







586



                {




×







587



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




×







588



                        Resources: stringListToSlice("operatorconditions"),




×







589



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




×







590



                },




×







591



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




×







592



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




×







593



                {




×







594



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




×







595



                        Resources: stringListToSlice("consoles"),




×







596



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




×







597



                },




×







598



                {




×







599



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




×







600



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




×







601



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




×







602



                },




×







603



        }




×







604



}




×







605












606



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




×







607



        return rbacv1.PolicyRule{




×







608



                APIGroups: stringListToSlice(apiGroup),




×







609



                Resources: resources,




×







610



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




×







611



        }




×







612



}




×







613












614



func GetServiceAccount(namespace string) v1.ServiceAccount {




×







615



        return v1.ServiceAccount{




×







616



                TypeMeta: metav1.TypeMeta{




×







617



                        APIVersion: "v1",




×







618



                        Kind:       "ServiceAccount",




×







619



                },




×







620



                ObjectMeta: metav1.ObjectMeta{




×







621



                        Name:      hcoName,




×







622



                        Namespace: namespace,




×







623



                        Labels: map[string]string{




×







624



                                "name": hcoName,




×







625



                        },




×







626



                },




×







627



        }




×







628



}




×







629












630



func GetClusterRoleBinding(namespace string) rbacv1.ClusterRoleBinding {




×







631



        return rbacv1.ClusterRoleBinding{




×







632



                TypeMeta: metav1.TypeMeta{




×







633



                        APIVersion: rbacVersionV1,




×







634



                        Kind:       "ClusterRoleBinding",




×







635



                },




×







636



                ObjectMeta: metav1.ObjectMeta{




×







637



                        Name: hcoName,




×







638



                        Labels: map[string]string{




×







639



                                "name": hcoName,




×







640



                        },




×







641



                },




×







642



                RoleRef: rbacv1.RoleRef{




×







643



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




×







644



                        Kind:     "ClusterRole",




×







645



                        Name:     hcoName,




×







646



                },




×







647



                Subjects: []rbacv1.Subject{




×







648



                        {




×







649



                                Kind:      "ServiceAccount",




×







650



                                Name:      hcoName,




×







651



                                Namespace: namespace,




×







652



                        },




×







653



                },




×







654



        }




×







655



}




×







656












657



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




×







658



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




×







659



        for _, errKind := range filterKinds {




×







660



                toSkip[errKind] = struct{}{}




×







661



        }




×







662



        var outErr error




×







663



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




×







664



                for _, err := range pkgRaw.Errors {




×







665



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




×







666



                                continue




×







667



                        }










668



                        outErr = err




×







669



                }










670



        })










671



        return outErr




×







672



}










673












674



const objectType = "object"










675












676



func GetOperatorCRD(relPath string) *extv1.CustomResourceDefinition {




×







677



        pkgs, err := loader.LoadRoots(relPath)




×







678



        if err != nil {




×







679



                panic(err)




×







680



        }










681



        reg := &markers.Registry{}




×







682



        panicOnError(crdmarkers.Register(reg))




×







683






×







684



        parser := &crdgen.Parser{




×







685



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




×







686



                Checker:                    &loader.TypeChecker{},




×







687



                GenerateEmbeddedObjectMeta: true,




×







688



        }




×







689






×







690



        crdgen.AddKnownTypes(parser)




×







691



        if len(pkgs) == 0 {




×







692



                panic("Failed identifying packages")




×







693



        }










694



        for _, p := range pkgs {




×







695



                parser.NeedPackage(p)




×







696



        }




×







697



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




×







698



        parser.NeedCRDFor(groupKind, nil)




×







699



        for _, p := range pkgs {




×







700



                err = packageErrors(p, packages.TypeError)




×







701



                if err != nil {




×







702



                        panic(err)




×







703



                }










704



        }










705



        c := parser.CustomResourceDefinitions[groupKind]




×







706



        // enforce validation of CR name to prevent multiple CRs




×







707



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




×







708



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




×







709



                        Type: objectType,




×







710



                        Properties: map[string]extv1.JSONSchemaProps{




×







711



                                "name": {




×







712



                                        Type:    "string",




×







713



                                        Pattern: hcov1beta1.HyperConvergedName,




×







714



                                },




×







715



                        },




×







716



                }




×







717



        }




×







718



        return &c




×







719



}










720












721



func GetOperatorCR() *hcov1beta1.HyperConverged {




1✔





722



        defaultScheme := runtime.NewScheme()




1✔





723



        _ = hcov1beta1.AddToScheme(defaultScheme)




1✔





724



        _ = hcov1beta1.RegisterDefaults(defaultScheme)




1✔





725



        defaultHco := &hcov1beta1.HyperConverged{




1✔





726



                TypeMeta: metav1.TypeMeta{




1✔





727



                        APIVersion: util.APIVersion,




1✔





728



                        Kind:       util.HyperConvergedKind,




1✔





729



                },




1✔





730



                ObjectMeta: metav1.ObjectMeta{




1✔





731



                        Name: crName,




1✔





732



                }}




1✔





733



        defaultScheme.Default(defaultHco)




1✔





734



        return defaultHco




1✔





735



}




1✔





736












737



// GetInstallStrategyBase returns the basics of an HCO InstallStrategy










738



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




×







739



        return &csvv1alpha1.StrategyDetailsDeployment{




×







740






×







741



                DeploymentSpecs: []csvv1alpha1.StrategyDeploymentSpec{




×







742



                        {




×







743



                                Name:  hcoDeploymentName,




×







744



                                Spec:  GetDeploymentSpecOperator(params),




×







745



                                Label: getLabels(hcoName, params.HcoKvIoVersion),




×







746



                        },




×







747



                        {




×







748



                                Name:  hcoWhDeploymentName,




×







749



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




×







750



                                Label: getLabels(hcoNameWebhook, params.HcoKvIoVersion),




×







751



                        },




×







752



                        {




×







753



                                Name:  cliDownloadsName,




×







754



                                Spec:  GetDeploymentSpecCliDownloads(params),




×







755



                                Label: getLabels(cliDownloadsName, params.HcoKvIoVersion),




×







756



                        },




×







757



                },




×







758



                Permissions: []csvv1alpha1.StrategyDeploymentPermissions{},




×







759



                ClusterPermissions: []csvv1alpha1.StrategyDeploymentPermissions{




×







760



                        {




×







761



                                ServiceAccountName: hcoName,




×







762



                                Rules:              GetClusterPermissions(),




×







763



                        },




×







764



                },




×







765



        }




×







766



}




×







767












768



type CSVBaseParams struct {










769



        Name            string










770



        Namespace       string










771



        DisplayName     string










772



        MetaDescription string










773



        Description     string










774



        Image           string










775



        Replaces        string










776



        Version         semver.Version










777



        CrdDisplay      string










778



}










779












780



// GetCSVBase returns a base HCO CSV without an InstallStrategy










781



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




×







782



        almExamples, _ := json.Marshal(




×







783



                map[string]interface{}{




×







784



                        "apiVersion": util.APIVersion,




×







785



                        "kind":       util.HyperConvergedKind,




×







786



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




×







787



                                "name":      packageName,




×







788



                                "namespace": params.Namespace,




×







789



                                "annotations": map[string]string{




×







790



                                        "deployOVS": "false",




×







791



                                },




×







792



                        },




×







793



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




×







794



                })




×







795






×







796



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




×







797



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




×







798



        // to really validate the requests.




×







799



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




×







800



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




×







801



        // so failurePolicy = admissionregistrationv1.Fail




×







802






×







803



        validatingWebhook := csvv1alpha1.WebhookDescription{




×







804



                GenerateName:            util.HcoValidatingWebhook,




×







805



                Type:                    csvv1alpha1.ValidatingAdmissionWebhook,




×







806



                DeploymentName:          hcoWhDeploymentName,




×







807



                ContainerPort:           util.WebhookPort,




×







808



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




×







809



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNone),




×







810



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







811



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




×







812



                Rules: []admissionregistrationv1.RuleWithOperations{




×







813



                        {




×







814



                                Operations: []admissionregistrationv1.OperationType{




×







815



                                        admissionregistrationv1.Create,




×







816



                                        admissionregistrationv1.Delete,




×







817



                                        admissionregistrationv1.Update,




×







818



                                },




×







819



                                Rule: admissionregistrationv1.Rule{




×







820



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







821



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




×







822



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







823



                                },




×







824



                        },




×







825



                },




×







826



                WebhookPath: ptr.To(util.HCOWebhookPath),




×







827



        }




×







828






×







829



        mutatingNamespaceWebhook := csvv1alpha1.WebhookDescription{




×







830



                GenerateName:            util.HcoMutatingWebhookNS,




×







831



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







832



                DeploymentName:          hcoWhDeploymentName,




×







833



                ContainerPort:           util.WebhookPort,




×







834



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




×







835



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







836



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







837



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




×







838



                ObjectSelector: &metav1.LabelSelector{




×







839



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




×







840



                },




×







841



                Rules: []admissionregistrationv1.RuleWithOperations{




×







842



                        {




×







843



                                Operations: []admissionregistrationv1.OperationType{




×







844



                                        admissionregistrationv1.Delete,




×







845



                                },




×







846



                                Rule: admissionregistrationv1.Rule{




×







847



                                        APIGroups:   []string{""},




×







848



                                        APIVersions: stringListToSlice("v1"),




×







849



                                        Resources:   stringListToSlice("namespaces"),




×







850



                                },




×







851



                        },




×







852



                },




×







853



                WebhookPath: ptr.To(util.HCONSWebhookPath),




×







854



        }




×







855






×







856



        mutatingHyperConvergedWebhook := csvv1alpha1.WebhookDescription{




×







857



                GenerateName:            util.HcoMutatingWebhookHyperConverged,




×







858



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







859



                DeploymentName:          hcoWhDeploymentName,




×







860



                ContainerPort:           util.WebhookPort,




×







861



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




×







862



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







863



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







864



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




×







865



                Rules: []admissionregistrationv1.RuleWithOperations{




×







866



                        {




×







867



                                Operations: []admissionregistrationv1.OperationType{




×







868



                                        admissionregistrationv1.Create,




×







869



                                        admissionregistrationv1.Update,




×







870



                                },




×







871



                                Rule: admissionregistrationv1.Rule{




×







872



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







873



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




×







874



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







875



                                },




×







876



                        },




×







877



                },




×







878



                WebhookPath: ptr.To(util.HCOMutatingWebhookPath),




×







879



        }




×







880






×







881



        return &csvv1alpha1.ClusterServiceVersion{




×







882



                TypeMeta: metav1.TypeMeta{




×







883



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




×







884



                        Kind:       "ClusterServiceVersion",




×







885



                },




×







886



                ObjectMeta: metav1.ObjectMeta{




×







887



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




×







888



                        Namespace: params.Namespace,




×







889



                        Annotations: map[string]string{




×







890



                                "alm-examples":                   string(almExamples),




×







891



                                "capabilities":                   "Deep Insights",




×







892



                                "certified":                      "false",




×







893



                                "categories":                     "OpenShift Optional",




×







894



                                "containerImage":                 params.Image,




×







895



                                DisableOperandDeletionAnnotation: "true",




×







896



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




×







897



                                "description":                    params.MetaDescription,




×







898



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




×







899



                                "support":                        "false",




×







900



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




×







901



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




×







902



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




×







903



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




×







904



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




×







905



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




×







906



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




×







907



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




×







908



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




×







909



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




×







910



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




×







911



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




×







912



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




×








NEW


913



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




×







914



                        },




×







915



                },




×







916



                Spec: csvv1alpha1.ClusterServiceVersionSpec{




×







917



                        DisplayName: params.DisplayName,




×







918



                        Description: params.Description,




×







919



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




×







920



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




×







921



                        Replaces:    params.Replaces,




×







922



                        Maintainers: []csvv1alpha1.Maintainer{




×







923



                                {




×







924



                                        Name:  kubevirtProjectName,




×







925



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




×







926



                                },




×







927



                        },




×







928



                        Maturity: "alpha",




×







929



                        Provider: csvv1alpha1.AppLink{




×







930



                                Name: kubevirtProjectName,




×







931



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




×







932



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




×







933



                        },




×







934



                        Links: []csvv1alpha1.AppLink{




×







935



                                {




×







936



                                        Name: kubevirtProjectName,




×







937



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




×







938



                                },




×







939



                                {




×







940



                                        Name: "Source Code",




×







941



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




×







942



                                },




×







943



                        },




×







944



                        Icon: []csvv1alpha1.Icon{




×







945



                                {




×







946



                                        MediaType: "image/svg+xml",




×







947



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




×







948



                                },




×







949



                        },




×







950



                        Labels: map[string]string{




×







951



                                "alm-owner-kubevirt": packageName,




×







952



                                "operated-by":        packageName,




×







953



                        },




×







954



                        Selector: &metav1.LabelSelector{




×







955



                                MatchLabels: map[string]string{




×







956



                                        "alm-owner-kubevirt": packageName,




×







957



                                        "operated-by":        packageName,




×







958



                                },




×







959



                        },




×







960



                        InstallModes: []csvv1alpha1.InstallMode{




×







961



                                {




×







962



                                        Type:      csvv1alpha1.InstallModeTypeOwnNamespace,




×







963



                                        Supported: false,




×







964



                                },




×







965



                                {




×







966



                                        Type:      csvv1alpha1.InstallModeTypeSingleNamespace,




×







967



                                        Supported: false,




×







968



                                },




×







969



                                {




×







970



                                        Type:      csvv1alpha1.InstallModeTypeMultiNamespace,




×







971



                                        Supported: false,




×







972



                                },




×







973



                                {




×







974



                                        Type:      csvv1alpha1.InstallModeTypeAllNamespaces,




×







975



                                        Supported: true,




×







976



                                },




×







977



                        },




×







978



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




×







979



                        // the actual StrategyDetailsDeployment when merging CSVs




×







980



                        InstallStrategy: csvv1alpha1.NamedInstallStrategy{},




×







981



                        WebhookDefinitions: []csvv1alpha1.WebhookDescription{




×







982



                                validatingWebhook,




×







983



                                mutatingNamespaceWebhook,




×







984



                                mutatingHyperConvergedWebhook,




×







985



                        },




×







986



                        CustomResourceDefinitions: csvv1alpha1.CustomResourceDefinitions{




×







987



                                Owned: []csvv1alpha1.CRDDescription{




×







988



                                        {




×







989



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




×







990



                                                Version:     util.CurrentAPIVersion,




×







991



                                                Kind:        util.HyperConvergedKind,




×







992



                                                DisplayName: params.CrdDisplay + " Deployment",




×







993



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




×







994



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




×







995



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




×







996



                                                SpecDescriptors: []csvv1alpha1.SpecDescriptor{




×







997



                                                        {




×







998



                                                                DisplayName: "Infra components node affinity",




×







999



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




×







1000



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




×







1001



                                                                XDescriptors: stringListToSlice(




×







1002



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




×







1003



                                                                ),




×







1004



                                                        },




×







1005



                                                        {




×







1006



                                                                DisplayName: "Infra components pod affinity",




×







1007



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




×







1008



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




×







1009



                                                                XDescriptors: stringListToSlice(




×







1010



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




×







1011



                                                                ),




×







1012



                                                        },




×







1013



                                                        {




×







1014



                                                                DisplayName: "Infra components pod anti-affinity",




×







1015



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




×







1016



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




×







1017



                                                                XDescriptors: stringListToSlice(




×







1018



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




×







1019



                                                                ),




×







1020



                                                        },




×







1021



                                                        {




×







1022



                                                                DisplayName: "Workloads components node affinity",




×







1023



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




×







1024



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




×







1025



                                                                XDescriptors: stringListToSlice(




×







1026



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




×







1027



                                                                ),




×







1028



                                                        },




×







1029



                                                        {




×







1030



                                                                DisplayName: "Workloads components pod affinity",




×







1031



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




×







1032



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




×







1033



                                                                XDescriptors: stringListToSlice(




×







1034



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




×







1035



                                                                ),




×







1036



                                                        },




×







1037



                                                        {




×







1038



                                                                DisplayName: "Workloads components pod anti-affinity",




×







1039



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




×







1040



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




×







1041



                                                                XDescriptors: stringListToSlice(




×







1042



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




×







1043



                                                                ),




×







1044



                                                        },




×







1045



                                                        {




×







1046



                                                                DisplayName: "HIDDEN FIELDS - operator version",




×







1047



                                                                Description: "HIDDEN FIELDS - operator version.",




×







1048



                                                                Path:        "version",




×







1049



                                                                XDescriptors: stringListToSlice(




×







1050



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




×







1051



                                                                ),




×







1052



                                                        },




×







1053



                                                },




×







1054



                                                StatusDescriptors: []csvv1alpha1.StatusDescriptor{},




×







1055



                                        },




×







1056



                                },




×







1057



                                Required: []csvv1alpha1.CRDDescription{},




×







1058



                        },




×







1059



                },




×







1060



        }




×







1061



}




×







1062












1063



func InjectVolumesForWebHookCerts(deploy *appsv1.Deployment) {




×







1064



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




×







1065



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




×







1066



                if vol.Name == certVolume {




×







1067



                        return




×







1068



                }




×







1069



        }










1070












1071



        volume := v1.Volume{




×







1072



                Name: certVolume,




×







1073



                VolumeSource: corev1.VolumeSource{




×







1074



                        Secret: &corev1.SecretVolumeSource{




×







1075



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




×







1076



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




×







1077



                                Items: []corev1.KeyToPath{




×







1078



                                        {




×







1079



                                                Key:  "tls.crt",




×







1080



                                                Path: hcoutil.WebhookCertName,




×







1081



                                        },




×







1082



                                        {




×







1083



                                                Key:  "tls.key",




×







1084



                                                Path: hcoutil.WebhookKeyName,




×







1085



                                        },




×







1086



                                },




×







1087



                        },




×







1088



                },




×







1089



        }




×







1090



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




×







1091






×







1092



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




×







1093



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




×







1094



                        corev1.VolumeMount{




×







1095



                                Name:      certVolume,




×







1096



                                MountPath: hcoutil.DefaultWebhookCertDir,




×







1097



                        })




×







1098



        }




×







1099



}










1100












1101



func getReadinessProbe() *corev1.Probe {




×







1102



        return &corev1.Probe{




×







1103



                ProbeHandler: corev1.ProbeHandler{




×







1104



                        HTTPGet: &corev1.HTTPGetAction{




×







1105



                                Path: hcoutil.ReadinessEndpointName,




×







1106



                                Port: intstr.IntOrString{




×







1107



                                        Type:   intstr.Int,




×







1108



                                        IntVal: hcoutil.HealthProbePort,




×







1109



                                },




×







1110



                                Scheme: corev1.URISchemeHTTP,




×







1111



                        },




×







1112



                },




×







1113



                InitialDelaySeconds: 5,




×







1114



                PeriodSeconds:       5,




×







1115



                FailureThreshold:    1,




×







1116



        }




×







1117



}




×







1118












1119



func getLivenessProbe() *corev1.Probe {




×







1120



        return &corev1.Probe{




×







1121



                ProbeHandler: corev1.ProbeHandler{




×







1122



                        HTTPGet: &corev1.HTTPGetAction{




×







1123



                                Path: hcoutil.LivenessEndpointName,




×







1124



                                Port: intstr.IntOrString{




×







1125



                                        Type:   intstr.Int,




×







1126



                                        IntVal: hcoutil.HealthProbePort,




×







1127



                                },




×







1128



                                Scheme: corev1.URISchemeHTTP,




×







1129



                        },




×







1130



                },




×







1131



                InitialDelaySeconds: 30,




×







1132



                PeriodSeconds:       5,




×







1133



                FailureThreshold:    1,




×







1134



        }




×







1135



}




×







1136












1137



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




×







1138



        return words




×







1139



}




×







1140












1141



func int32Ptr(i int32) *int32 {




×







1142



        return &i




×







1143



}




×







1144












1145



func panicOnError(err error) {




×







1146



        if err != nil {




×







1147



                panic(err)




×







1148



        }










1149



}
























    

  • 

    •