kubevirt / hyperconverged-cluster-operator / 20689766013

coverage: 72.789% (-0.03%) from 72.821%

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

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









3



import (










4



        "encoding/json"










5



        "fmt"










6



        "strconv"










7



        "time"










8












9



        "github.com/blang/semver/v4"










10



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










11



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










12



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










13



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










14



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










15



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










16



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










17



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










18



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










19



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










20



        "k8s.io/apimachinery/pkg/runtime"










21



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










22



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










23



        "k8s.io/utils/ptr"










24



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










25



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










26



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










27



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










28












29



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










30



        kvapi "kubevirt.io/api/core"










31



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










32



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










33



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










34












35



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










36



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










37



)










38












39



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










40












41



const (










42



        crName              = util.HyperConvergedName










43



        packageName         = util.HyperConvergedName










44



        hcoDeploymentName   = "hco-operator"










45



        hcoWhDeploymentName = "hco-webhook"










46



        certVolume          = "apiservice-cert"










47












48



        kubevirtProjectName = "KubeVirt project"










49



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










50



)










51












52



var deploymentType = metav1.TypeMeta{










53



        APIVersion: "apps/v1",










54



        Kind:       "Deployment",










55



}










56












57



type DeploymentOperatorParams struct {










58



        Namespace              string










59



        Image                  string










60



        WebhookImage           string










61



        CliDownloadsImage      string










62



        KVUIPluginImage        string










63



        KVUIProxyImage         string










64



        PasstImage             string










65



        PasstCNIImage          string










66



        WaspAgentImage         string










67



        ImagePullPolicy        string










68



        ConversionContainer    string










69



        VmwareContainer        string










70



        VirtIOWinContainer     string










71



        Smbios                 string










72



        Machinetype            string










73



        Amd64MachineType       string










74



        Arm64MachineType       string










75



        HcoKvIoVersion         string










76



        KubevirtVersion        string










77



        KvVirtLancherOsVersion string










78



        CdiVersion             string










79



        CnaoVersion            string










80



        SspVersion             string










81



        HppoVersion            string










82



        MtqVersion             string










83



        AaqVersion             string










84



        Env                    []corev1.EnvVar










85



}










86












87



func GetDeploymentOperator(params *DeploymentOperatorParams) appsv1.Deployment {




×







88



        return appsv1.Deployment{




×







89



                TypeMeta: deploymentType,




×







90



                ObjectMeta: metav1.ObjectMeta{




×







91



                        Name: util.HCOOperatorName,




×







92



                        Labels: map[string]string{




×







93



                                "name": util.HCOOperatorName,




×







94



                        },




×







95



                },




×







96



                Spec: GetDeploymentSpecOperator(params),




×







97



        }




×







98



}




×







99












100



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




×







101



        deploy := appsv1.Deployment{




×







102



                TypeMeta: deploymentType,




×







103



                ObjectMeta: metav1.ObjectMeta{




×







104



                        Name: util.HCOWebhookName,




×







105



                        Labels: map[string]string{




×







106



                                "name": util.HCOWebhookName,




×







107



                        },




×







108



                },




×







109



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




×







110



        }




×







111






×







112



        InjectVolumesForWebHookCerts(&deploy)




×







113



        return deploy




×







114



}




×







115












116



func GetDeploymentCliDownloads(params *DeploymentOperatorParams) appsv1.Deployment {




×







117



        return appsv1.Deployment{




×







118



                TypeMeta: deploymentType,




×







119



                ObjectMeta: metav1.ObjectMeta{




×







120



                        Name: util.CLIDownloadsName,




×







121



                        Labels: map[string]string{




×







122



                                "name": util.CLIDownloadsName,




×







123



                        },




×







124



                },




×







125



                Spec: GetDeploymentSpecCliDownloads(params),




×







126



        }




×







127



}




×







128












129



func GetServiceWebhook() corev1.Service {




×







130



        return corev1.Service{




×







131



                TypeMeta: metav1.TypeMeta{




×







132



                        APIVersion: "v1",




×







133



                        Kind:       "Service",




×







134



                },




×







135



                ObjectMeta: metav1.ObjectMeta{




×







136



                        Name: util.HCOWebhookName + "-service",




×







137



                },




×







138



                Spec: corev1.ServiceSpec{




×







139



                        Selector: map[string]string{




×







140



                                "name": util.HCOWebhookName,




×







141



                        },




×







142



                        Ports: []corev1.ServicePort{




×







143



                                {




×







144



                                        Name:       strconv.Itoa(util.WebhookPort),




×







145



                                        Port:       util.WebhookPort,




×







146



                                        Protocol:   corev1.ProtocolTCP,




×







147



                                        TargetPort: intstr.FromInt32(util.WebhookPort),




×







148



                                },




×







149



                        },




×







150



                        Type: corev1.ServiceTypeClusterIP,




×







151



                },




×







152



        }




×







153



}




×







154












155



func GetDeploymentSpecOperator(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







156



        envs := buildEnvVars(params)




×







157






×







158



        return appsv1.DeploymentSpec{




×







159



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




×







160



                Selector: &metav1.LabelSelector{




×







161



                        MatchLabels: map[string]string{




×







162



                                "name": util.HCOOperatorName,




×







163



                        },




×







164



                },




×







165



                Strategy: appsv1.DeploymentStrategy{




×







166



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







167



                },




×







168



                Template: corev1.PodTemplateSpec{




×







169



                        ObjectMeta: metav1.ObjectMeta{




×







170



                                Labels: getLabels(util.HCOOperatorName, params.HcoKvIoVersion),




×







171



                        },




×







172



                        Spec: corev1.PodSpec{




×







173



                                ServiceAccountName: util.HCOOperatorName,




×







174



                                SecurityContext:    GetStdPodSecurityContext(),




×







175



                                Containers: []corev1.Container{




×







176



                                        {




×







177



                                                Name:            util.HCOOperatorName,




×







178



                                                Image:           params.Image,




×







179



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







180



                                                Command:         stringListToSlice(util.HCOOperatorName),




×







181



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




×







182



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




×







183



                                                Env:             envs,




×







184



                                                Resources: corev1.ResourceRequirements{




×







185



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




×







186



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




×







187



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




×







188



                                                        },




×







189



                                                },




×







190



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







191



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







192



                                                Ports: []corev1.ContainerPort{




×







193



                                                        getMetricsPort(),




×







194



                                                },




×







195



                                        },




×







196



                                },




×







197



                                PriorityClassName: "system-cluster-critical",




×







198



                        },




×







199



                },




×







200



        }




×







201



}




×







202












203



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




×







204



        envs := append([]corev1.EnvVar{




×







205



                {




×







206



                        // deprecated: left here for CI test.




×







207



                        Name:  util.OperatorWebhookModeEnv,




×







208



                        Value: "false",




×







209



                },




×







210



                {




×







211



                        Name:  util.ContainerAppName,




×







212



                        Value: util.ContainerOperatorApp,




×







213



                },




×







214



                {




×







215



                        Name:  "KVM_EMULATION",




×







216



                        Value: "",




×







217



                },




×







218



                {




×







219



                        Name:  "OPERATOR_IMAGE",




×







220



                        Value: params.Image,




×







221



                },




×







222



                {




×







223



                        Name:  "OPERATOR_NAME",




×







224



                        Value: util.HCOOperatorName,




×







225



                },




×







226



                {




×







227



                        Name:  "OPERATOR_NAMESPACE",




×







228



                        Value: params.Namespace,




×







229



                },




×







230



                {




×







231



                        Name: "POD_NAME",




×







232



                        ValueFrom: &corev1.EnvVarSource{




×







233



                                FieldRef: &corev1.ObjectFieldSelector{




×







234



                                        FieldPath: "metadata.name",




×







235



                                },




×







236



                        },




×







237



                },




×







238



                {




×







239



                        Name:  "VIRTIOWIN_CONTAINER",




×







240



                        Value: params.VirtIOWinContainer,




×







241



                },




×







242



                {




×







243



                        Name:  "SMBIOS",




×







244



                        Value: params.Smbios,




×







245



                },




×







246



                {




×







247



                        Name:  "MACHINETYPE",




×







248



                        Value: params.Machinetype,




×







249



                },




×







250



                {




×







251



                        Name:  "AMD64_MACHINETYPE",




×







252



                        Value: params.Amd64MachineType,




×







253



                },




×







254



                {




×







255



                        Name:  "ARM64_MACHINETYPE",




×







256



                        Value: params.Arm64MachineType,




×







257



                },




×







258



                {




×







259



                        Name:  util.HcoKvIoVersionName,




×







260



                        Value: params.HcoKvIoVersion,




×







261



                },




×







262



                {




×







263



                        Name:  util.KubevirtVersionEnvV,




×







264



                        Value: params.KubevirtVersion,




×







265



                },




×







266



                {




×







267



                        Name:  util.CdiVersionEnvV,




×







268



                        Value: params.CdiVersion,




×







269



                },




×







270



                {




×







271



                        Name:  util.CnaoVersionEnvV,




×







272



                        Value: params.CnaoVersion,




×







273



                },




×







274



                {




×







275



                        Name:  util.SspVersionEnvV,




×







276



                        Value: params.SspVersion,




×







277



                },




×







278



                {




×







279



                        Name:  util.HppoVersionEnvV,




×







280



                        Value: params.HppoVersion,




×







281



                },




×







282



                {




×







283



                        Name:  util.AaqVersionEnvV,




×







284



                        Value: params.AaqVersion,




×







285



                },




×







286



                {




×







287



                        Name:  util.KVUIPluginImageEnvV,




×







288



                        Value: params.KVUIPluginImage,




×







289



                },




×







290



                {




×







291



                        Name:  util.KVUIProxyImageEnvV,




×







292



                        Value: params.KVUIProxyImage,




×







293



                },




×







294



        }, params.Env...)




×







295






×







296



        if params.KvVirtLancherOsVersion != "" {




×







297



                envs = append(envs, corev1.EnvVar{




×







298



                        Name:  util.KvVirtLauncherOSVersionEnvV,




×







299



                        Value: params.KvVirtLancherOsVersion,




×







300



                })




×







301



        }




×







302












303



        return envs




×







304



}










305












306



func GetDeploymentSpecCliDownloads(params *DeploymentOperatorParams) appsv1.DeploymentSpec {




×







307



        return appsv1.DeploymentSpec{




×







308



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




×







309



                Selector: &metav1.LabelSelector{




×







310



                        MatchLabels: map[string]string{




×







311



                                "name": util.CLIDownloadsName,




×







312



                        },




×







313



                },




×







314



                Strategy: appsv1.DeploymentStrategy{




×







315



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







316



                },




×







317



                Template: corev1.PodTemplateSpec{




×







318



                        ObjectMeta: metav1.ObjectMeta{




×







319



                                Labels: getLabels(util.CLIDownloadsName, params.HcoKvIoVersion),




×







320



                        },




×







321



                        Spec: corev1.PodSpec{




×







322



                                ServiceAccountName:           util.CLIDownloadsName,




×







323



                                AutomountServiceAccountToken: ptr.To(false),




×







324



                                SecurityContext:              GetStdPodSecurityContext(),




×







325



                                Containers: []corev1.Container{




×







326



                                        {




×







327



                                                Name:            "server",




×







328



                                                Image:           params.CliDownloadsImage,




×







329



                                                ImagePullPolicy: corev1.PullPolicy(params.ImagePullPolicy),




×







330



                                                Resources: corev1.ResourceRequirements{




×







331



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




×







332



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




×







333



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




×







334



                                                        },




×







335



                                                },




×







336



                                                Ports: []corev1.ContainerPort{




×







337



                                                        {




×







338



                                                                Protocol:      corev1.ProtocolTCP,




×







339



                                                                ContainerPort: util.CliDownloadsServerPort,




×







340



                                                        },




×







341



                                                },




×







342



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







343



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




×







344



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




×







345



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







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



                util.AppLabelVersion:   hcoKvIoVersion,




×







358



                util.AppLabelPartOf:    util.HyperConvergedCluster,




×







359



                util.AppLabelComponent: string(util.AppComponentDeployment),




×







360



        }




×







361



}




×







362












363



func GetStdPodSecurityContext() *corev1.PodSecurityContext {




2✔





364



        return &corev1.PodSecurityContext{




2✔





365



                RunAsNonRoot: ptr.To(true),




2✔





366



                SeccompProfile: &corev1.SeccompProfile{




2✔





367



                        Type: corev1.SeccompProfileTypeRuntimeDefault,




2✔





368



                },




2✔





369



        }




2✔





370



}




2✔





371












372



func GetStdContainerSecurityContext() *corev1.SecurityContext {




2✔





373



        return &corev1.SecurityContext{




2✔





374



                AllowPrivilegeEscalation: ptr.To(false),




2✔





375



                Capabilities: &corev1.Capabilities{




2✔





376



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




2✔





377



                },




2✔





378



        }




2✔





379



}




2✔





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: ptr.To[int32](1),




×







396



                Selector: &metav1.LabelSelector{




×







397



                        MatchLabels: map[string]string{




×







398



                                "name": util.HCOWebhookName,




×







399



                        },




×







400



                },




×







401



                Strategy: appsv1.DeploymentStrategy{




×







402



                        Type: appsv1.RollingUpdateDeploymentStrategyType,




×







403



                },




×







404



                Template: corev1.PodTemplateSpec{




×







405



                        ObjectMeta: metav1.ObjectMeta{




×







406



                                Labels: getLabels(util.HCOWebhookName, hcoKvIoVersion),




×







407



                        },




×







408



                        Spec: corev1.PodSpec{




×







409



                                ServiceAccountName: util.HCOOperatorName,




×







410



                                SecurityContext:    GetStdPodSecurityContext(),




×







411



                                Containers: []corev1.Container{




×







412



                                        {




×







413



                                                Name:            util.HCOWebhookName,




×







414



                                                Image:           image,




×







415



                                                ImagePullPolicy: corev1.PullPolicy(imagePullPolicy),




×







416



                                                Command:         stringListToSlice(util.HCOWebhookName),




×







417



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




×







418



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




×







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: util.HCOWebhookName,




×







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



                                                        {




×







450



                                                                Name:  util.HcoKvIoVersionName,




×







451



                                                                Value: hcoKvIoVersion,




×







452



                                                        },




×







453



                                                }, env...),




×







454



                                                Resources: corev1.ResourceRequirements{




×







455



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




×







456



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




×







457



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




×







458



                                                        },




×







459



                                                },




×







460



                                                SecurityContext:          GetStdContainerSecurityContext(),




×







461



                                                TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,




×







462



                                                Ports: []corev1.ContainerPort{




×







463



                                                        getWebhookPort(),




×







464



                                                        getMetricsPort(),




×







465



                                                },




×







466



                                        },




×







467



                                },




×







468



                                PriorityClassName: "system-node-critical",




×







469



                        },




×







470



                },




×







471



        }




×







472



}




×







473












474



func GetClusterRole() rbacv1.ClusterRole {




×







475



        return rbacv1.ClusterRole{




×







476



                TypeMeta: metav1.TypeMeta{




×







477



                        APIVersion: rbacVersionV1,




×







478



                        Kind:       "ClusterRole",




×







479



                },




×







480



                ObjectMeta: metav1.ObjectMeta{




×







481



                        Name: util.HCOOperatorName,




×







482



                        Labels: map[string]string{




×







483



                                "name": util.HCOOperatorName,




×







484



                        },




×







485



                },




×







486



                Rules: GetClusterPermissions(),




×







487



        }




×







488



}




×







489












490



var (










491



        emptyAPIGroup = []string{""}










492



)










493












494



func GetClusterPermissions() []rbacv1.PolicyRule {




×







495



        const configOpenshiftIO = "config.openshift.io"




×







496



        const operatorOpenshiftIO = "operator.openshift.io"




×







497



        return []rbacv1.PolicyRule{




×







498



                {




×







499



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







500



                        Resources: stringListToSlice("hyperconvergeds"),




×







501



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




×







502



                },




×







503



                {




×







504



                        APIGroups: stringListToSlice(util.APIVersionGroup),




×







505



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




×







506



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




×







507



                },




×







508



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




×







509



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




×







510



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




×







511



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




×







512



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




×







513



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




×







514



                {




×







515



                        APIGroups: emptyAPIGroup,




×







516



                        Resources: stringListToSlice("events"),




×







517



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




×







518



                },




×







519



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




×







520



                {




×







521



                        APIGroups: emptyAPIGroup,




×







522



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




×







523



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




×







524



                },




×







525



                {




×







526



                        APIGroups: emptyAPIGroup,




×







527



                        Resources: stringListToSlice("secrets"),




×







528



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




×







529



                },




×







530



                {




×







531



                        APIGroups: emptyAPIGroup,




×







532



                        Resources: stringListToSlice("endpoints"),




×







533



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




×







534



                },




×







535



                {




×







536



                        APIGroups: emptyAPIGroup,




×







537



                        Resources: stringListToSlice("namespaces"),




×







538



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




×







539



                },




×







540



                {




×







541



                        APIGroups: stringListToSlice("apps"),




×







542



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




×







543



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




×







544



                },




×







545



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




×







546



                {




×







547



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




×







548



                        Resources: stringListToSlice("customresourcedefinitions"),




×







549



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




×







550



                },




×







551



                {




×







552



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




×








NEW


553



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




×







554



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




×







555



                },




×







556



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




×







557



                {




×







558



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




×







559



                        Resources: stringListToSlice("clusterserviceversions"),




×







560



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




×







561



                },




×







562



                {




×







563



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




×







564



                        Resources: stringListToSlice("priorityclasses"),




×







565



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




×







566



                },




×







567



                {




×







568



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




×







569



                        Resources: stringListToSlice("validatingwebhookconfigurations"),




×







570



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




×







571



                },




×







572



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




×







573



                {




×







574



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







575



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




×







576



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




×







577



                },




×







578



                {




×







579



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







580



                        Resources: stringListToSlice("ingresses"),




×







581



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




×







582



                },




×







583



                {




×







584



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







585



                        Resources: stringListToSlice("ingresses/status"),




×







586



                        Verbs:     stringListToSlice("update"),




×







587



                },




×







588



                {




×







589



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







590



                        Resources: stringListToSlice("apiservers"),




×







591



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




×







592



                },




×







593



                {




×







594



                        APIGroups: stringListToSlice(operatorOpenshiftIO),




×







595



                        Resources: stringListToSlice("kubedeschedulers"),




×







596



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




×







597



                },




×







598



                {




×







599



                        APIGroups: stringListToSlice(configOpenshiftIO),




×







600



                        Resources: stringListToSlice("dnses"),




×







601



                        Verbs:     stringListToSlice("get"),




×







602



                },




×







603



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




×







604



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




×







605



                {




×







606



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




×







607



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




×







608



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




×







609



                },




×







610



                {




×







611



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




×







612



                        Resources: stringListToSlice("operatorconditions"),




×







613



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




×







614



                },




×







615



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




×







616



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




×







617



                {




×







618



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




×







619



                        Resources: stringListToSlice("consoles"),




×







620



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




×







621



                },




×







622



                {




×







623



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




×







624



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




×







625



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




×







626



                },




×







627



                {




×







628



                        APIGroups: stringListToSlice(admissionregistrationv1.GroupName),




×







629



                        Resources: stringListToSlice("validatingadmissionpolicies", "validatingadmissionpolicybindings"),




×







630



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




×







631



                },




×







632



        }




×







633



}




×







634












635



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




×







636



        return rbacv1.PolicyRule{




×







637



                APIGroups: stringListToSlice(apiGroup),




×







638



                Resources: resources,




×







639



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




×







640



        }




×







641



}




×







642












643



func GetServiceAccount(namespace string) corev1.ServiceAccount {




×







644



        return createServiceAccount(namespace, util.HCOOperatorName)




×







645



}




×







646












647



func GetCLIDownloadServiceAccount(namespace string) corev1.ServiceAccount {




×







648



        return createServiceAccount(namespace, util.CLIDownloadsName)




×







649



}




×







650












651



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




×







652



        return corev1.ServiceAccount{




×







653



                TypeMeta: metav1.TypeMeta{




×







654



                        APIVersion: "v1",




×







655



                        Kind:       "ServiceAccount",




×







656



                },




×







657



                ObjectMeta: metav1.ObjectMeta{




×







658



                        Name:      name,




×







659



                        Namespace: namespace,




×







660



                        Labels: map[string]string{




×







661



                                "name": name,




×







662



                        },




×







663



                },




×







664



        }




×







665



}




×







666












667



func GetClusterRoleBinding(namespace string) rbacv1.ClusterRoleBinding {




×







668



        return rbacv1.ClusterRoleBinding{




×







669



                TypeMeta: metav1.TypeMeta{




×







670



                        APIVersion: rbacVersionV1,




×







671



                        Kind:       "ClusterRoleBinding",




×







672



                },




×







673



                ObjectMeta: metav1.ObjectMeta{




×







674



                        Name: util.HCOOperatorName,




×







675



                        Labels: map[string]string{




×







676



                                "name": util.HCOOperatorName,




×







677



                        },




×







678



                },




×







679



                RoleRef: rbacv1.RoleRef{




×







680



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




×







681



                        Kind:     "ClusterRole",




×







682



                        Name:     util.HCOOperatorName,




×







683



                },




×







684



                Subjects: []rbacv1.Subject{




×







685



                        {




×







686



                                Kind:      "ServiceAccount",




×







687



                                Name:      util.HCOOperatorName,




×







688



                                Namespace: namespace,




×







689



                        },




×







690



                },




×







691



        }




×







692



}




×







693












694



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




×







695



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




×







696



        for _, errKind := range filterKinds {




×







697



                toSkip[errKind] = struct{}{}




×







698



        }




×







699



        var outErr error




×







700



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




×







701



                for _, err := range pkgRaw.Errors {




×







702



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




×







703



                                continue




×







704



                        }










705



                        outErr = err




×







706



                }










707



        })










708



        return outErr




×







709



}










710












711



const objectType = "object"










712












713



func GetOperatorCRD(relPath string) *extv1.CustomResourceDefinition {




×







714



        pkgs, err := loader.LoadRoots(relPath)




×







715



        if err != nil {




×







716



                panic(err)




×







717



        }










718



        reg := &markers.Registry{}




×







719



        panicOnError(crdmarkers.Register(reg))




×







720






×







721



        parser := &crdgen.Parser{




×







722



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




×







723



                Checker:                    &loader.TypeChecker{},




×







724



                GenerateEmbeddedObjectMeta: true,




×







725



        }




×







726






×







727



        crdgen.AddKnownTypes(parser)




×







728



        if len(pkgs) == 0 {




×







729



                panic("Failed identifying packages")




×







730



        }










731



        for _, p := range pkgs {




×







732



                parser.NeedPackage(p)




×







733



        }




×







734



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




×







735



        parser.NeedCRDFor(groupKind, nil)




×







736



        for _, p := range pkgs {




×







737



                err = packageErrors(p, packages.TypeError)




×







738



                if err != nil {




×







739



                        panic(err)




×







740



                }










741



        }










742



        c := parser.CustomResourceDefinitions[groupKind]




×







743



        // enforce validation of CR name to prevent multiple CRs




×







744



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




×







745



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




×







746



                        Type: objectType,




×







747



                        Properties: map[string]extv1.JSONSchemaProps{




×







748



                                "name": {




×







749



                                        Type:    "string",




×







750



                                        Pattern: hcov1beta1.HyperConvergedName,




×







751



                                },




×







752



                        },




×







753



                }




×







754



        }




×







755



        return &c




×







756



}










757












758



func GetOperatorCR() *hcov1beta1.HyperConverged {




8✔





759



        defaultScheme := runtime.NewScheme()




8✔





760



        _ = hcov1beta1.AddToScheme(defaultScheme)




8✔





761



        _ = hcov1beta1.RegisterDefaults(defaultScheme)




8✔





762



        defaultHco := &hcov1beta1.HyperConverged{




8✔





763



                TypeMeta: metav1.TypeMeta{




8✔





764



                        APIVersion: util.APIVersion,




8✔





765



                        Kind:       util.HyperConvergedKind,




8✔





766



                },




8✔





767



                ObjectMeta: metav1.ObjectMeta{




8✔





768



                        Name: crName,




8✔





769



                }}




8✔





770



        defaultScheme.Default(defaultHco)




8✔





771



        return defaultHco




8✔





772



}




8✔





773












774



// GetInstallStrategyBase returns the basics of an HCO InstallStrategy










775



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




×







776



        return &csvv1alpha1.StrategyDetailsDeployment{




×







777






×







778



                DeploymentSpecs: []csvv1alpha1.StrategyDeploymentSpec{




×







779



                        {




×







780



                                Name:  hcoDeploymentName,




×







781



                                Spec:  GetDeploymentSpecOperator(params),




×







782



                                Label: getLabels(util.HCOOperatorName, params.HcoKvIoVersion),




×







783



                        },




×







784



                        {




×







785



                                Name:  hcoWhDeploymentName,




×







786



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




×







787



                                Label: getLabels(util.HCOWebhookName, params.HcoKvIoVersion),




×







788



                        },




×







789



                        {




×







790



                                Name:  util.CLIDownloadsName,




×







791



                                Spec:  GetDeploymentSpecCliDownloads(params),




×







792



                                Label: getLabels(util.CLIDownloadsName, params.HcoKvIoVersion),




×







793



                        },




×







794



                },




×







795



                Permissions: []csvv1alpha1.StrategyDeploymentPermissions{},




×







796



                ClusterPermissions: []csvv1alpha1.StrategyDeploymentPermissions{




×







797



                        {




×







798



                                ServiceAccountName: util.HCOOperatorName,




×







799



                                Rules:              GetClusterPermissions(),




×







800



                        },




×







801



                        {




×







802



                                ServiceAccountName: util.CLIDownloadsName,




×







803



                                Rules:              []rbacv1.PolicyRule{},




×







804



                        },




×







805



                },




×







806



        }




×







807



}




×







808












809



type CSVBaseParams struct {










810



        Name            string










811



        Namespace       string










812



        DisplayName     string










813



        MetaDescription string










814



        Description     string










815



        Image           string










816



        Version         semver.Version










817



        CrdDisplay      string










818



}










819












820



// GetCSVBase returns a base HCO CSV without an InstallStrategy










821



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




×







822



        almExamples, _ := json.Marshal(




×







823



                map[string]interface{}{




×







824



                        "apiVersion": util.APIVersion,




×







825



                        "kind":       util.HyperConvergedKind,




×







826



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




×







827



                                "name":      packageName,




×







828



                                "namespace": params.Namespace,




×







829



                                "annotations": map[string]string{




×







830



                                        "deployOVS": "false",




×







831



                                },




×







832



                        },




×







833



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




×







834



                })




×







835






×







836



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




×







837



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




×







838



        // to really validate the requests.




×







839



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




×







840



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




×







841



        // so failurePolicy = admissionregistrationv1.Fail




×







842






×







843



        validatingWebhook := csvv1alpha1.WebhookDescription{




×







844



                GenerateName:            util.HcoValidatingWebhook,




×







845



                Type:                    csvv1alpha1.ValidatingAdmissionWebhook,




×







846



                DeploymentName:          hcoWhDeploymentName,




×







847



                ContainerPort:           util.WebhookPort,




×







848



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




×







849



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNone),




×







850



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







851



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




×







852



                Rules: []admissionregistrationv1.RuleWithOperations{




×







853



                        {




×







854



                                Operations: []admissionregistrationv1.OperationType{




×







855



                                        admissionregistrationv1.Create,




×







856



                                        admissionregistrationv1.Delete,




×







857



                                        admissionregistrationv1.Update,




×







858



                                },




×







859



                                Rule: admissionregistrationv1.Rule{




×







860



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







861



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




×







862



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







863



                                },




×







864



                        },




×







865



                },




×







866



                WebhookPath: ptr.To(util.HCOWebhookPath),




×







867



        }




×







868






×







869



        mutatingNamespaceWebhook := csvv1alpha1.WebhookDescription{




×







870



                GenerateName:            util.HcoMutatingWebhookNS,




×







871



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







872



                DeploymentName:          hcoWhDeploymentName,




×







873



                ContainerPort:           util.WebhookPort,




×







874



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




×







875



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







876



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







877



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




×







878



                ObjectSelector: &metav1.LabelSelector{




×







879



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




×







880



                },




×







881



                Rules: []admissionregistrationv1.RuleWithOperations{




×







882



                        {




×







883



                                Operations: []admissionregistrationv1.OperationType{




×







884



                                        admissionregistrationv1.Delete,




×







885



                                },




×







886



                                Rule: admissionregistrationv1.Rule{




×







887



                                        APIGroups:   []string{""},




×







888



                                        APIVersions: stringListToSlice("v1"),




×







889



                                        Resources:   stringListToSlice("namespaces"),




×







890



                                },




×







891



                        },




×







892



                },




×







893



                WebhookPath: ptr.To(util.HCONSWebhookPath),




×







894



        }




×







895






×







896



        mutatingHyperConvergedWebhook := csvv1alpha1.WebhookDescription{




×







897



                GenerateName:            util.HcoMutatingWebhookHyperConverged,




×







898



                Type:                    csvv1alpha1.MutatingAdmissionWebhook,




×







899



                DeploymentName:          hcoWhDeploymentName,




×







900



                ContainerPort:           util.WebhookPort,




×







901



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




×







902



                SideEffects:             ptr.To(admissionregistrationv1.SideEffectClassNoneOnDryRun),




×







903



                FailurePolicy:           ptr.To(admissionregistrationv1.Fail),




×







904



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




×







905



                Rules: []admissionregistrationv1.RuleWithOperations{




×







906



                        {




×







907



                                Operations: []admissionregistrationv1.OperationType{




×







908



                                        admissionregistrationv1.Create,




×







909



                                        admissionregistrationv1.Update,




×







910



                                },




×







911



                                Rule: admissionregistrationv1.Rule{




×







912



                                        APIGroups:   stringListToSlice(util.APIVersionGroup),




×







913



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




×







914



                                        Resources:   stringListToSlice("hyperconvergeds"),




×







915



                                },




×







916



                        },




×







917



                },




×







918



                WebhookPath: ptr.To(util.HCOMutatingWebhookPath),




×







919



        }




×







920






×







921



        return &csvv1alpha1.ClusterServiceVersion{




×







922



                TypeMeta: metav1.TypeMeta{




×







923



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




×







924



                        Kind:       "ClusterServiceVersion",




×







925



                },




×







926



                ObjectMeta: metav1.ObjectMeta{




×







927



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




×







928



                        Namespace: params.Namespace,




×







929



                        Annotations: map[string]string{




×







930



                                "alm-examples":                   string(almExamples),




×







931



                                "capabilities":                   "Deep Insights",




×







932



                                "certified":                      "false",




×







933



                                "categories":                     "OpenShift Optional",




×







934



                                "containerImage":                 params.Image,




×







935



                                DisableOperandDeletionAnnotation: "true",




×







936



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




×







937



                                "description":                    params.MetaDescription,




×







938



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




×







939



                                "support":                        "false",




×







940



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




×







941



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




×







942



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




×







943



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




×







944



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




×







945



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




×







946



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




×







947



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




×







948



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




×







949



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




×







950



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




×







951



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




×







952



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




×







953



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




×







954



                        },




×







955



                },




×







956



                Spec: csvv1alpha1.ClusterServiceVersionSpec{




×







957



                        DisplayName: params.DisplayName,




×







958



                        Description: params.Description,




×







959



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




×







960



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




×







961



                        Maintainers: []csvv1alpha1.Maintainer{




×







962



                                {




×







963



                                        Name:  kubevirtProjectName,




×







964



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




×







965



                                },




×







966



                        },




×







967



                        Maturity: "alpha",




×







968



                        Provider: csvv1alpha1.AppLink{




×







969



                                Name: kubevirtProjectName,




×







970



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




×







971



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




×







972



                        },




×







973



                        Links: []csvv1alpha1.AppLink{




×







974



                                {




×







975



                                        Name: kubevirtProjectName,




×







976



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




×







977



                                },




×







978



                                {




×







979



                                        Name: "Source Code",




×







980



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




×







981



                                },




×







982



                        },




×







983



                        Icon: []csvv1alpha1.Icon{




×







984



                                {




×







985



                                        MediaType: "image/svg+xml",




×







986



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




×







987



                                },




×







988



                        },




×







989



                        Labels: map[string]string{




×







990



                                "alm-owner-kubevirt": packageName,




×







991



                                "operated-by":        packageName,




×







992



                        },




×







993



                        Selector: &metav1.LabelSelector{




×







994



                                MatchLabels: map[string]string{




×







995



                                        "alm-owner-kubevirt": packageName,




×







996



                                        "operated-by":        packageName,




×







997



                                },




×







998



                        },




×







999



                        InstallModes: []csvv1alpha1.InstallMode{




×







1000



                                {




×







1001



                                        Type:      csvv1alpha1.InstallModeTypeOwnNamespace,




×







1002



                                        Supported: false,




×







1003



                                },




×







1004



                                {




×







1005



                                        Type:      csvv1alpha1.InstallModeTypeSingleNamespace,




×







1006



                                        Supported: false,




×







1007



                                },




×







1008



                                {




×







1009



                                        Type:      csvv1alpha1.InstallModeTypeMultiNamespace,




×







1010



                                        Supported: false,




×







1011



                                },




×







1012



                                {




×







1013



                                        Type:      csvv1alpha1.InstallModeTypeAllNamespaces,




×







1014



                                        Supported: true,




×







1015



                                },




×







1016



                        },




×







1017



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




×







1018



                        // the actual StrategyDetailsDeployment when merging CSVs




×







1019



                        InstallStrategy: csvv1alpha1.NamedInstallStrategy{},




×







1020



                        WebhookDefinitions: []csvv1alpha1.WebhookDescription{




×







1021



                                validatingWebhook,




×







1022



                                mutatingNamespaceWebhook,




×







1023



                                mutatingHyperConvergedWebhook,




×







1024



                        },




×







1025



                        CustomResourceDefinitions: csvv1alpha1.CustomResourceDefinitions{




×







1026



                                Owned: []csvv1alpha1.CRDDescription{




×







1027



                                        {




×







1028



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




×







1029



                                                Version:     util.CurrentAPIVersion,




×







1030



                                                Kind:        util.HyperConvergedKind,




×







1031



                                                DisplayName: params.CrdDisplay + " Deployment",




×







1032



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




×







1033



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




×







1034



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




×







1035



                                                SpecDescriptors: []csvv1alpha1.SpecDescriptor{




×







1036



                                                        {




×







1037



                                                                DisplayName: "Infra components node affinity",




×







1038



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




×







1039



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




×







1040



                                                                XDescriptors: stringListToSlice(




×







1041



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




×







1042



                                                                ),




×







1043



                                                        },




×







1044



                                                        {




×







1045



                                                                DisplayName: "Infra components pod affinity",




×







1046



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




×







1047



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




×







1048



                                                                XDescriptors: stringListToSlice(




×







1049



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




×







1050



                                                                ),




×







1051



                                                        },




×







1052



                                                        {




×







1053



                                                                DisplayName: "Infra components pod anti-affinity",




×







1054



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




×







1055



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




×







1056



                                                                XDescriptors: stringListToSlice(




×







1057



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




×







1058



                                                                ),




×







1059



                                                        },




×







1060



                                                        {




×







1061



                                                                DisplayName: "Workloads components node affinity",




×







1062



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




×







1063



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




×







1064



                                                                XDescriptors: stringListToSlice(




×







1065



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




×







1066



                                                                ),




×







1067



                                                        },




×







1068



                                                        {




×







1069



                                                                DisplayName: "Workloads components pod affinity",




×







1070



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




×







1071



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




×







1072



                                                                XDescriptors: stringListToSlice(




×







1073



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




×







1074



                                                                ),




×







1075



                                                        },




×







1076



                                                        {




×







1077



                                                                DisplayName: "Workloads components pod anti-affinity",




×







1078



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




×







1079



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




×







1080



                                                                XDescriptors: stringListToSlice(




×







1081



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




×







1082



                                                                ),




×







1083



                                                        },




×







1084



                                                        {




×







1085



                                                                DisplayName: "HIDDEN FIELDS - operator version",




×







1086



                                                                Description: "HIDDEN FIELDS - operator version.",




×







1087



                                                                Path:        "version",




×







1088



                                                                XDescriptors: stringListToSlice(




×







1089



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




×







1090



                                                                ),




×







1091



                                                        },




×







1092



                                                },




×







1093



                                                StatusDescriptors: []csvv1alpha1.StatusDescriptor{},




×







1094



                                        },




×







1095



                                },




×







1096



                                Required: []csvv1alpha1.CRDDescription{},




×







1097



                        },




×







1098



                },




×







1099



        }




×







1100



}




×







1101












1102



func InjectVolumesForWebHookCerts(deploy *appsv1.Deployment) {




×







1103



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




×







1104



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




×







1105



                if vol.Name == certVolume {




×







1106



                        return




×







1107



                }




×







1108



        }










1109












1110



        volume := corev1.Volume{




×







1111



                Name: certVolume,




×







1112



                VolumeSource: corev1.VolumeSource{




×







1113



                        Secret: &corev1.SecretVolumeSource{




×







1114



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




×







1115



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




×







1116



                                Items: []corev1.KeyToPath{




×







1117



                                        {




×







1118



                                                Key:  "tls.crt",




×







1119



                                                Path: util.WebhookCertName,




×







1120



                                        },




×







1121



                                        {




×







1122



                                                Key:  "tls.key",




×







1123



                                                Path: util.WebhookKeyName,




×







1124



                                        },




×







1125



                                },




×







1126



                        },




×







1127



                },




×







1128



        }




×







1129



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




×







1130






×







1131



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




×







1132



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




×







1133



                        corev1.VolumeMount{




×







1134



                                Name:      certVolume,




×







1135



                                MountPath: util.DefaultWebhookCertDir,




×







1136



                        })




×







1137



        }




×







1138



}










1139












1140



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




×







1141



        return &corev1.Probe{




×







1142



                ProbeHandler: corev1.ProbeHandler{




×







1143



                        HTTPGet: &corev1.HTTPGetAction{




×







1144



                                Path: endpoint,




×







1145



                                Port: intstr.IntOrString{




×







1146



                                        Type:   intstr.Int,




×







1147



                                        IntVal: port,




×







1148



                                },




×







1149



                                Scheme: corev1.URISchemeHTTP,




×







1150



                        },




×







1151



                },




×







1152



                InitialDelaySeconds: 5,




×







1153



                PeriodSeconds:       5,




×







1154



                FailureThreshold:    1,




×







1155



        }




×







1156



}




×







1157












1158



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




×







1159



        return &corev1.Probe{




×







1160



                ProbeHandler: corev1.ProbeHandler{




×







1161



                        HTTPGet: &corev1.HTTPGetAction{




×







1162



                                Path: endpoint,




×







1163



                                Port: intstr.IntOrString{




×







1164



                                        Type:   intstr.Int,




×







1165



                                        IntVal: port,




×







1166



                                },




×







1167



                                Scheme: corev1.URISchemeHTTP,




×







1168



                        },




×







1169



                },




×







1170



                InitialDelaySeconds: 30,




×







1171



                PeriodSeconds:       5,




×







1172



                FailureThreshold:    1,




×







1173



        }




×







1174



}




×







1175












1176



func getMetricsPort() corev1.ContainerPort {




×







1177



        return corev1.ContainerPort{




×







1178



                Name:          util.MetricsPortName,




×







1179



                ContainerPort: util.MetricsPort,




×







1180



                Protocol:      corev1.ProtocolTCP,




×







1181



        }




×







1182



}




×







1183












1184



func getWebhookPort() corev1.ContainerPort {




×







1185



        return corev1.ContainerPort{




×







1186



                Name:          util.WebhookPortName,




×







1187



                ContainerPort: util.WebhookPort,




×







1188



                Protocol:      corev1.ProtocolTCP,




×







1189



        }




×







1190



}




×







1191












1192



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




×







1193



        return words




×







1194



}




×







1195












1196



func panicOnError(err error) {




×







1197



        if err != nil {




×







1198



                panic(err)




×







1199



        }










1200



}
























    

  • 

    •