From 8c40743111ad25adb2ad957d40d5b22856640ce0 Mon Sep 17 00:00:00 2001 From: John Hunkins Date: Wed, 24 Feb 2021 21:03:50 -0600 Subject: [PATCH 1/5] Expand validation to annotations - Add validation function for well known case sensitive annotation names - Use new validation function in CSV and OperatorGroups - Add minimal OperatorGroup validator calling new function - Add / update unit tests and test data - update usage readme Signed-off-by: John Hunkins --- README.md | 2 +- .../v1alpha1/clusterserviceversion_types.go | 1 + pkg/validation/internal/annotations.go | 53 ++++ pkg/validation/internal/csv.go | 2 + pkg/validation/internal/csv_test.go | 12 + pkg/validation/internal/operatorgroup.go | 35 +++ pkg/validation/internal/operatorgroup_test.go | 47 +++ .../testdata/badAnnotationNames.csv.yaml | 295 ++++++++++++++++++ .../testdata/badAnnotationNames.og.yaml | 16 + .../internal/testdata/correct.og.yaml | 16 + pkg/validation/validation.go | 4 + 11 files changed, 482 insertions(+), 1 deletion(-) create mode 100644 pkg/validation/internal/annotations.go create mode 100644 pkg/validation/internal/operatorgroup.go create mode 100644 pkg/validation/internal/operatorgroup_test.go create mode 100644 pkg/validation/internal/testdata/badAnnotationNames.csv.yaml create mode 100644 pkg/validation/internal/testdata/badAnnotationNames.og.yaml create mode 100644 pkg/validation/internal/testdata/correct.og.yaml diff --git a/README.md b/README.md index 918a388c4..1bb16974d 100644 --- a/README.md +++ b/README.md @@ -17,4 +17,4 @@ You can install the `operator-verify` tool from source using: To verify your ClusterServiceVersion yaml, -`$ operator-verify verify /path/to/filename.yaml` \ No newline at end of file +`$ operator-verify manifests /path/to/filename.yaml` \ No newline at end of file diff --git a/pkg/operators/v1alpha1/clusterserviceversion_types.go b/pkg/operators/v1alpha1/clusterserviceversion_types.go index 3bcb83586..ea30478de 100644 --- a/pkg/operators/v1alpha1/clusterserviceversion_types.go +++ b/pkg/operators/v1alpha1/clusterserviceversion_types.go @@ -22,6 +22,7 @@ const ( ClusterServiceVersionKind = "ClusterServiceVersion" OperatorGroupNamespaceAnnotationKey = "olm.operatorNamespace" InstallStrategyNameDeployment = "deployment" + SkipRangeAnnotationKey = "olm.skipRange" ) // InstallModeType is a supported type of install mode for CSV installation diff --git a/pkg/validation/internal/annotations.go b/pkg/validation/internal/annotations.go new file mode 100644 index 000000000..95ee22a2c --- /dev/null +++ b/pkg/validation/internal/annotations.go @@ -0,0 +1,53 @@ +package internal + +import ( + "fmt" + "strings" + + v1 "github.com/operator-framework/api/pkg/operators/v1" + "github.com/operator-framework/api/pkg/operators/v1alpha1" + "github.com/operator-framework/api/pkg/validation/errors" +) + +// CaseSensitiveAnnotationKeySet is a set of annotation keys that are case sensitive +// and can be used for validation purposes. The key is always lowercase and the value +// contains the expected case sensitive string. This may not be an exhaustive list. +var CaseSensitiveAnnotationKeySet = map[string]string{ + + strings.ToLower(v1.OperatorGroupAnnotationKey): v1.OperatorGroupAnnotationKey, + strings.ToLower(v1.OperatorGroupNamespaceAnnotationKey): v1.OperatorGroupNamespaceAnnotationKey, + strings.ToLower(v1.OperatorGroupTargetsAnnotationKey): v1.OperatorGroupTargetsAnnotationKey, + strings.ToLower(v1.OperatorGroupProvidedAPIsAnnotationKey): v1.OperatorGroupProvidedAPIsAnnotationKey, + strings.ToLower(v1alpha1.SkipRangeAnnotationKey): v1alpha1.SkipRangeAnnotationKey, +} + +/* +ValidateAnnotationNames will check annotation keys to ensure they are using +proper case. Uses CaseSensitiveAnnotationKeySet as a source for keys +which are known to be case sensitive. This function can be used anywhere +annotations need to be checked for case sensitivity. + +Arguments + +• annotations: annotations map usually obtained from ObjectMeta.GetAnnotations() + +• value: is the field or file that caused an error or warning + +Returns + +• errs: Any errors that may have been detected with the annotation keys provided +*/ +func ValidateAnnotationNames(annotations map[string]string, value interface{}) (errs []errors.Error) { + // for every annotation provided + for annotationKey := range annotations { + // check the case sensitive key set for a matching lowercase annotation + if knownCaseSensitiveKey, ok := CaseSensitiveAnnotationKeySet[strings.ToLower(annotationKey)]; ok { + // we have a case-insensitive match... now check to see if the case is really correct + if annotationKey != knownCaseSensitiveKey { + // annotation key supplied is invalid due to bad case. + errs = append(errs, errors.ErrFailedValidation(fmt.Sprintf("provided annotation %s uses wrong case and should be %s instead", annotationKey, knownCaseSensitiveKey), value)) + } + } + } + return errs +} diff --git a/pkg/validation/internal/csv.go b/pkg/validation/internal/csv.go index a17144fa3..4b99c7b9b 100644 --- a/pkg/validation/internal/csv.go +++ b/pkg/validation/internal/csv.go @@ -46,6 +46,8 @@ func validateCSV(csv *v1alpha1.ClusterServiceVersion) errors.ManifestResult { result.Add(validateInstallModes(csv)...) // check missing optional/mandatory fields. result.Add(checkFields(*csv)...) + // validate case sensitive annotation names + result.Add(ValidateAnnotationNames(csv.GetAnnotations(), csv.GetName())...) return result } diff --git a/pkg/validation/internal/csv_test.go b/pkg/validation/internal/csv_test.go index 61fc8485e..51693e902 100644 --- a/pkg/validation/internal/csv_test.go +++ b/pkg/validation/internal/csv_test.go @@ -49,6 +49,18 @@ func TestValidateCSV(t *testing.T) { }, filepath.Join("testdata", "incorrect.csv.with.conversion.webhook.yaml"), }, + { + validatorFuncTest{ + description: "invalid annotation name for csv", + wantErr: true, + errors: []errors.Error{ + errors.ErrFailedValidation("provided annotation olm.skiprange uses wrong case and should be olm.skipRange instead", "etcdoperator.v0.9.0"), + errors.ErrFailedValidation("provided annotation olm.operatorgroup uses wrong case and should be olm.operatorGroup instead", "etcdoperator.v0.9.0"), + errors.ErrFailedValidation("provided annotation olm.operatornamespace uses wrong case and should be olm.operatorNamespace instead", "etcdoperator.v0.9.0"), + }, + }, + filepath.Join("testdata", "badAnnotationNames.csv.yaml"), + }, } for _, c := range cases { b, err := ioutil.ReadFile(c.csvPath) diff --git a/pkg/validation/internal/operatorgroup.go b/pkg/validation/internal/operatorgroup.go new file mode 100644 index 000000000..6f2be6009 --- /dev/null +++ b/pkg/validation/internal/operatorgroup.go @@ -0,0 +1,35 @@ +package internal + +import ( + operatorsv1 "github.com/operator-framework/api/pkg/operators/v1" + operatorsv1alpha2 "github.com/operator-framework/api/pkg/operators/v1alpha2" + "github.com/operator-framework/api/pkg/validation/errors" + interfaces "github.com/operator-framework/api/pkg/validation/interfaces" +) + +// OperatorGroupValidator is a validator for OperatorGroup +var OperatorGroupValidator interfaces.Validator = interfaces.ValidatorFunc(validateOperatorGroups) + +func validateOperatorGroups(objs ...interface{}) (results []errors.ManifestResult) { + for _, obj := range objs { + switch v := obj.(type) { + case *operatorsv1.OperatorGroup: + results = append(results, validateOperatorGroupV1(v)) + case *operatorsv1alpha2.OperatorGroup: + results = append(results, validateOperatorGroupV1Alpha2(v)) + } + } + return results +} + +func validateOperatorGroupV1Alpha2(operatorGroup *operatorsv1alpha2.OperatorGroup) (result errors.ManifestResult) { + // validate case sensitive annotation names + result.Add(ValidateAnnotationNames(operatorGroup.GetAnnotations(), operatorGroup.GetName())...) + return result +} + +func validateOperatorGroupV1(operatorGroup *operatorsv1.OperatorGroup) (result errors.ManifestResult) { + // validate case sensitive annotation names + result.Add(ValidateAnnotationNames(operatorGroup.GetAnnotations(), operatorGroup.GetName())...) + return result +} diff --git a/pkg/validation/internal/operatorgroup_test.go b/pkg/validation/internal/operatorgroup_test.go new file mode 100644 index 000000000..00daa7be2 --- /dev/null +++ b/pkg/validation/internal/operatorgroup_test.go @@ -0,0 +1,47 @@ +package internal + +import ( + "io/ioutil" + "path/filepath" + "testing" + + "github.com/ghodss/yaml" + operatorsv1 "github.com/operator-framework/api/pkg/operators/v1" + "github.com/operator-framework/api/pkg/validation/errors" +) + +func TestValidateOperatorGroup(t *testing.T) { + cases := []struct { + validatorFuncTest + operatorGroupPath string + }{ + { + validatorFuncTest{ + description: "successfully validated", + }, + filepath.Join("testdata", "correct.og.yaml"), + }, + { + validatorFuncTest{ + description: "invalid annotation name for operator group", + wantErr: true, + errors: []errors.Error{ + errors.ErrFailedValidation("provided annotation olm.providedapis uses wrong case and should be olm.providedAPIs instead", "nginx-hbvsw"), + }, + }, + filepath.Join("testdata", "badAnnotationNames.og.yaml"), + }, + } + for _, c := range cases { + b, err := ioutil.ReadFile(c.operatorGroupPath) + if err != nil { + t.Fatalf("Error reading OperatorGroup path %s: %v", c.operatorGroupPath, err) + } + og := operatorsv1.OperatorGroup{} + if err = yaml.Unmarshal(b, &og); err != nil { + t.Fatalf("Error unmarshalling OperatorGroup at path %s: %v", c.operatorGroupPath, err) + } + result := validateOperatorGroupV1(&og) + c.check(t, result) + } +} diff --git a/pkg/validation/internal/testdata/badAnnotationNames.csv.yaml b/pkg/validation/internal/testdata/badAnnotationNames.csv.yaml new file mode 100644 index 000000000..af2c3e74f --- /dev/null +++ b/pkg/validation/internal/testdata/badAnnotationNames.csv.yaml @@ -0,0 +1,295 @@ +#! validate-crd: deploy/chart/templates/0000_30_02-clusterserviceversion.crd.yaml +#! parse-kind: ClusterServiceVersion +apiVersion: operators.coreos.com/v1alpha1 +kind: ClusterServiceVersion +metadata: + name: etcdoperator.v0.9.0 + namespace: placeholder + annotations: + olm.operatorgroup: global-operators + olm.operatornamespace: openshift-operators + olm.skiprange: '>=4.1.0 <4.1.2' + capabilities: Full Lifecycle + tectonic-visibility: ocs + alm-examples: '[{"apiVersion":"etcd.database.coreos.com/v1beta2","kind":"EtcdCluster","metadata":{"name":"example","namespace":"default"},"spec":{"size":3,"version":"3.2.13"}},{"apiVersion":"etcd.database.coreos.com/v1beta2","kind":"EtcdRestore","metadata":{"name":"example-etcd-cluster"},"spec":{"etcdCluster":{"name":"example-etcd-cluster"},"backupStorageType":"S3","s3":{"path":"","awsSecret":""}}},{"apiVersion":"etcd.database.coreos.com/v1beta2","kind":"EtcdBackup","metadata":{"name":"example-etcd-cluster-backup"},"spec":{"etcdEndpoints":[""],"storageType":"S3","s3":{"path":"","awsSecret":""}}}]' + description: etcd is a distributed key value store providing a reliable way to store data across a cluster of machines. +spec: + displayName: etcd + description: | + etcd is a distributed key value store that provides a reliable way to store data across a cluster of machines. It’s open-source and available on GitHub. etcd gracefully handles leader elections during network partitions and will tolerate machine failure, including the leader. Your applications can read and write data into etcd. + A simple use-case is to store database connection details or feature flags within etcd as key value pairs. These values can be watched, allowing your app to reconfigure itself when they change. Advanced uses take advantage of the consistency guarantees to implement database leader elections or do distributed locking across a cluster of workers. + + _The etcd Open Cloud Service is Public Alpha. The goal before Beta is to fully implement backup features._ + + ### Reading and writing to etcd + + Communicate with etcd though its command line utility `etcdctl` or with the API using the automatically generated Kubernetes Service. + + [Read the complete guide to using the etcd Open Cloud Service](https://coreos.com/tectonic/docs/latest/alm/etcd-ocs.html) + + ### Supported Features + + + **High availability** + + + Multiple instances of etcd are networked together and secured. Individual failures or networking issues are transparently handled to keep your cluster up and running. + + + **Automated updates** + + + Rolling out a new etcd version works like all Kubernetes rolling updates. Simply declare the desired version, and the etcd service starts a safe rolling update to the new version automatically. + + + **Backups included** + + + Coming soon, the ability to schedule backups to happen on or off cluster. + keywords: ['etcd', 'key value', 'database', 'coreos', 'open source'] + version: 0.9.0 + maturity: alpha + maintainers: + - name: CoreOS, Inc + email: support@coreos.com + + provider: + name: CoreOS, Inc + labels: + alm-owner-etcd: etcdoperator + operated-by: etcdoperator + selector: + matchLabels: + alm-owner-etcd: etcdoperator + operated-by: etcdoperator + links: + - name: Blog + url: https://coreos.com/etcd + - name: Documentation + url: https://coreos.com/operators/etcd/docs/latest/ + - name: etcd Operator Source Code + url: https://github.com/coreos/etcd-operator + + icon: + - base64data: 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 + mediatype: image/png + installModes: + - type: OwnNamespace + supported: true + - type: SingleNamespace + supported: true + - type: MultiNamespace + supported: false + - type: AllNamespaces + supported: true + install: + strategy: deployment + spec: + permissions: + - serviceAccountName: etcd-operator + rules: + - apiGroups: + - etcd.database.coreos.com + resources: + - etcdclusters + - etcdbackups + - etcdrestores + verbs: + - "*" + - apiGroups: + - "" + resources: + - pods + - services + - endpoints + - persistentvolumeclaims + - events + verbs: + - "*" + - apiGroups: + - apps + resources: + - deployments + verbs: + - "*" + - apiGroups: + - "" + resources: + - secrets + verbs: + - get + deployments: + - name: etcd-operator + spec: + replicas: 1 + selector: + matchLabels: + name: etcd-operator-alm-owned + template: + metadata: + name: etcd-operator-alm-owned + labels: + name: etcd-operator-alm-owned + spec: + serviceAccountName: etcd-operator + containers: + - name: etcd-operator + command: + - etcd-operator + - --create-crd=false + image: quay.io/coreos/etcd-operator@sha256:db563baa8194fcfe39d1df744ed70024b0f1f9e9b55b5923c2f3a413c44dc6b8 + env: + - name: MY_POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: MY_POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + - name: etcd-backup-operator + image: quay.io/coreos/etcd-operator@sha256:db563baa8194fcfe39d1df744ed70024b0f1f9e9b55b5923c2f3a413c44dc6b8 + command: + - etcd-backup-operator + - --create-crd=false + env: + - name: MY_POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: MY_POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + - name: etcd-restore-operator + image: quay.io/coreos/etcd-operator@sha256:db563baa8194fcfe39d1df744ed70024b0f1f9e9b55b5923c2f3a413c44dc6b8 + command: + - etcd-restore-operator + - --create-crd=false + env: + - name: MY_POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: MY_POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + customresourcedefinitions: + owned: + - name: etcdclusters.etcd.database.coreos.com + version: v1beta2 + kind: EtcdCluster + displayName: etcd Cluster + description: Represents a cluster of etcd nodes. + resources: + - kind: Service + version: v1 + - kind: Pod + version: v1 + specDescriptors: + - description: The desired number of member Pods for the etcd cluster. + displayName: Size + path: size + x-descriptors: + - 'urn:alm:descriptor:com.tectonic.ui:podCount' + - description: Limits describes the minimum/maximum amount of compute resources required/allowed + displayName: Resource Requirements + path: pod.resources + x-descriptors: + - 'urn:alm:descriptor:com.tectonic.ui:resourceRequirements' + statusDescriptors: + - description: The status of each of the member Pods for the etcd cluster. + displayName: Member Status + path: members + x-descriptors: + - 'urn:alm:descriptor:com.tectonic.ui:podStatuses' + - description: The service at which the running etcd cluster can be accessed. + displayName: Service + path: serviceName + x-descriptors: + - 'urn:alm:descriptor:io.kubernetes:Service' + - description: The current size of the etcd cluster. + displayName: Cluster Size + path: size + - description: The current version of the etcd cluster. + displayName: Current Version + path: currentVersion + - description: 'The target version of the etcd cluster, after upgrading.' + displayName: Target Version + path: targetVersion + - description: The current status of the etcd cluster. + displayName: Status + path: phase + x-descriptors: + - 'urn:alm:descriptor:io.kubernetes.phase' + - description: Explanation for the current status of the cluster. + displayName: Status Details + path: reason + x-descriptors: + - 'urn:alm:descriptor:io.kubernetes.phase:reason' + - name: etcdbackups.etcd.database.coreos.com + version: v1beta2 + kind: EtcdBackup + displayName: etcd Backup + description: Represents the intent to backup an etcd cluster. + specDescriptors: + - description: Specifies the endpoints of an etcd cluster. + displayName: etcd Endpoint(s) + path: etcdEndpoints + x-descriptors: + - 'urn:alm:descriptor:etcd:endpoint' + - description: The full AWS S3 path where the backup is saved. + displayName: S3 Path + path: s3.path + x-descriptors: + - 'urn:alm:descriptor:aws:s3:path' + - description: The name of the secret object that stores the AWS credential and config files. + displayName: AWS Secret + path: s3.awsSecret + x-descriptors: + - 'urn:alm:descriptor:io.kubernetes:Secret' + statusDescriptors: + - description: Indicates if the backup was successful. + displayName: Succeeded + path: succeeded + x-descriptors: + - 'urn:alm:descriptor:text' + - description: Indicates the reason for any backup related failures. + displayName: Reason + path: reason + x-descriptors: + - 'urn:alm:descriptor:io.kubernetes.phase:reason' + - name: etcdrestores.etcd.database.coreos.com + version: v1beta2 + kind: EtcdRestore + displayName: etcd Restore + description: Represents the intent to restore an etcd cluster from a backup. + specDescriptors: + - description: References the EtcdCluster which should be restored, + displayName: etcd Cluster + path: etcdCluster.name + x-descriptors: + - 'urn:alm:descriptor:io.kubernetes:EtcdCluster' + - 'urn:alm:descriptor:text' + - description: The full AWS S3 path where the backup is saved. + displayName: S3 Path + path: s3.path + x-descriptors: + - 'urn:alm:descriptor:aws:s3:path' + - description: The name of the secret object that stores the AWS credential and config files. + displayName: AWS Secret + path: s3.awsSecret + x-descriptors: + - 'urn:alm:descriptor:io.kubernetes:Secret' + statusDescriptors: + - description: Indicates if the restore was successful. + displayName: Succeeded + path: succeeded + x-descriptors: + - 'urn:alm:descriptor:text' + - description: Indicates the reason for any restore related failures. + displayName: Reason + path: reason + x-descriptors: + - 'urn:alm:descriptor:io.kubernetes.phase:reason' \ No newline at end of file diff --git a/pkg/validation/internal/testdata/badAnnotationNames.og.yaml b/pkg/validation/internal/testdata/badAnnotationNames.og.yaml new file mode 100644 index 000000000..aa3d948f4 --- /dev/null +++ b/pkg/validation/internal/testdata/badAnnotationNames.og.yaml @@ -0,0 +1,16 @@ +apiVersion: operators.coreos.com/v1 +kind: OperatorGroup +metadata: + annotations: + olm.providedapis: NginxIngressController.v1alpha1.k8s.nginx.org + creationTimestamp: "2021-02-25T23:47:13Z" + generateName: nginx- + generation: 1 + name: nginx-hbvsw + namespace: nginx + resourceVersion: "58637752" + selfLink: /apis/operators.coreos.com/v1/namespaces/nginx/operatorgroups/nginx-hbvsw + uid: 81a05c50-aea3-4959-9e86-b1ad8b74e899 +spec: + targetNamespaces: + - nginx \ No newline at end of file diff --git a/pkg/validation/internal/testdata/correct.og.yaml b/pkg/validation/internal/testdata/correct.og.yaml new file mode 100644 index 000000000..5c2020c45 --- /dev/null +++ b/pkg/validation/internal/testdata/correct.og.yaml @@ -0,0 +1,16 @@ +apiVersion: operators.coreos.com/v1 +kind: OperatorGroup +metadata: + annotations: + olm.providedAPIs: NginxIngressController.v1alpha1.k8s.nginx.org + creationTimestamp: "2021-02-25T23:47:13Z" + generateName: nginx- + generation: 1 + name: nginx-hbvsw + namespace: nginx + resourceVersion: "58637752" + selfLink: /apis/operators.coreos.com/v1/namespaces/nginx/operatorgroups/nginx-hbvsw + uid: 81a05c50-aea3-4959-9e86-b1ad8b74e899 +spec: + targetNamespaces: + - nginx \ No newline at end of file diff --git a/pkg/validation/validation.go b/pkg/validation/validation.go index 30f782404..f33a7af47 100644 --- a/pkg/validation/validation.go +++ b/pkg/validation/validation.go @@ -35,6 +35,9 @@ var OperatorHubValidator = internal.OperatorHubValidator // Object validation is optional and not a default-level validation. var ObjectValidator = internal.ObjectValidator +// OperatorGroupValidator implements Validator to validate OperatorGroup manifests +var OperatorGroupValidator = internal.OperatorGroupValidator + // AllValidators implements Validator to validate all Operator manifest types. var AllValidators = interfaces.Validators{ PackageManifestValidator, @@ -43,6 +46,7 @@ var AllValidators = interfaces.Validators{ BundleValidator, OperatorHubValidator, ObjectValidator, + OperatorGroupValidator, } var DefaultBundleValidators = interfaces.Validators{ From c744762e22629571fbea63e7a360c889d270f0cb Mon Sep 17 00:00:00 2001 From: Vu Dinh Date: Mon, 10 May 2021 13:53:19 -0400 Subject: [PATCH 2/5] Add conditions array to OperatorCondition's spec The conditions array in the spec is now available for operator to create/update as the operator progresses through installation process. As the spec is updated, the object generation will be incremented and it can be used for tracking object changes. Signed-off-by: Vu Dinh --- ...erators.coreos.com_operatorconditions.yaml | 42 +++++++++++++++++++ pkg/operators/v1/operatorcondition_types.go | 1 + 2 files changed, 43 insertions(+) diff --git a/crds/operators.coreos.com_operatorconditions.yaml b/crds/operators.coreos.com_operatorconditions.yaml index 1a5ddea3e..38090c842 100644 --- a/crds/operators.coreos.com_operatorconditions.yaml +++ b/crds/operators.coreos.com_operatorconditions.yaml @@ -84,6 +84,48 @@ spec: type: string maxLength: 316 pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ + conditions: + type: array + items: + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + type: object + required: + - message + - reason + - status + - type + properties: + lastTransitionTime: + description: lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + type: string + format: date-time + message: + description: message is a human readable message indicating details about the transition. This may be an empty string. + type: string + maxLength: 32768 + observedGeneration: + description: observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. + type: integer + format: int64 + minimum: 0 + reason: + description: reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty. + type: string + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ + status: + description: status of the condition, one of True, False, Unknown. + type: string + enum: + - "True" + - "False" + - Unknown + type: + description: type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt) + type: string + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ serviceAccounts: type: array items: diff --git a/pkg/operators/v1/operatorcondition_types.go b/pkg/operators/v1/operatorcondition_types.go index 33fe196fd..8c183d351 100644 --- a/pkg/operators/v1/operatorcondition_types.go +++ b/pkg/operators/v1/operatorcondition_types.go @@ -14,6 +14,7 @@ type OperatorConditionSpec struct { ServiceAccounts []string `json:"serviceAccounts,omitempty"` Deployments []string `json:"deployments,omitempty"` Overrides []metav1.Condition `json:"overrides,omitempty"` + Conditions []metav1.Condition `json:"conditions,omitempty"` } // OperatorConditionStatus allows an operator to convey information its state to OLM. The status may trail the actual From 3d47b942c81b4f6f3aaf2a5646a462c82ff1fa92 Mon Sep 17 00:00:00 2001 From: Vu Dinh Date: Tue, 25 May 2021 03:31:56 -0400 Subject: [PATCH 3/5] Add OperatorCondition v2 with spec.conditions array Signed-off-by: Vu Dinh --- ...erators.coreos.com_operatorconditions.yaml | 119 ++++++++++++++ pkg/operators/v1/operatorcondition_types.go | 2 - pkg/operators/v2/doc.go | 4 + pkg/operators/v2/groupversion_info.go | 28 ++++ pkg/operators/v2/operatorcondition_types.go | 51 ++++++ pkg/operators/v2/zz_generated.deepcopy.go | 145 ++++++++++++++++++ 6 files changed, 347 insertions(+), 2 deletions(-) create mode 100644 pkg/operators/v2/doc.go create mode 100644 pkg/operators/v2/groupversion_info.go create mode 100644 pkg/operators/v2/operatorcondition_types.go create mode 100644 pkg/operators/v2/zz_generated.deepcopy.go diff --git a/crds/operators.coreos.com_operatorconditions.yaml b/crds/operators.coreos.com_operatorconditions.yaml index 38090c842..66d0aa654 100644 --- a/crds/operators.coreos.com_operatorconditions.yaml +++ b/crds/operators.coreos.com_operatorconditions.yaml @@ -19,6 +19,125 @@ spec: scope: Namespaced versions: - name: v1 + schema: + openAPIV3Schema: + description: OperatorCondition is a Custom Resource of type `OperatorCondition` which is used to convey information to OLM about the state of an operator. + type: object + required: + - metadata + properties: + apiVersion: + description: 'APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources' + type: string + kind: + description: 'Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds' + type: string + metadata: + type: object + spec: + description: OperatorConditionSpec allows a cluster admin to convey information about the state of an operator to OLM, potentially overriding state reported by the operator. + type: object + properties: + deployments: + type: array + items: + type: string + overrides: + type: array + items: + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + type: object + required: + - message + - reason + - status + - type + properties: + lastTransitionTime: + description: lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + type: string + format: date-time + message: + description: message is a human readable message indicating details about the transition. This may be an empty string. + type: string + maxLength: 32768 + observedGeneration: + description: observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. + type: integer + format: int64 + minimum: 0 + reason: + description: reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty. + type: string + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ + status: + description: status of the condition, one of True, False, Unknown. + type: string + enum: + - "True" + - "False" + - Unknown + type: + description: type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt) + type: string + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ + serviceAccounts: + type: array + items: + type: string + status: + description: OperatorConditionStatus allows an operator to convey information its state to OLM. The status may trail the actual state of a system. + type: object + properties: + conditions: + type: array + items: + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" + type: object + required: + - lastTransitionTime + - message + - reason + - status + - type + properties: + lastTransitionTime: + description: lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + type: string + format: date-time + message: + description: message is a human readable message indicating details about the transition. This may be an empty string. + type: string + maxLength: 32768 + observedGeneration: + description: observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. + type: integer + format: int64 + minimum: 0 + reason: + description: reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty. + type: string + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ + status: + description: status of the condition, one of True, False, Unknown. + type: string + enum: + - "True" + - "False" + - Unknown + type: + description: type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt) + type: string + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ + served: false + storage: false + - name: v2 schema: openAPIV3Schema: description: OperatorCondition is a Custom Resource of type `OperatorCondition` which is used to convey information to OLM about the state of an operator. diff --git a/pkg/operators/v1/operatorcondition_types.go b/pkg/operators/v1/operatorcondition_types.go index 8c183d351..8647b227e 100644 --- a/pkg/operators/v1/operatorcondition_types.go +++ b/pkg/operators/v1/operatorcondition_types.go @@ -14,7 +14,6 @@ type OperatorConditionSpec struct { ServiceAccounts []string `json:"serviceAccounts,omitempty"` Deployments []string `json:"deployments,omitempty"` Overrides []metav1.Condition `json:"overrides,omitempty"` - Conditions []metav1.Condition `json:"conditions,omitempty"` } // OperatorConditionStatus allows an operator to convey information its state to OLM. The status may trail the actual @@ -25,7 +24,6 @@ type OperatorConditionStatus struct { // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // +genclient -// +kubebuilder:storageversion // +kubebuilder:resource:shortName=condition,categories=olm // +kubebuilder:subresource:status // OperatorCondition is a Custom Resource of type `OperatorCondition` which is used to convey information to OLM about the state of an operator. diff --git a/pkg/operators/v2/doc.go b/pkg/operators/v2/doc.go new file mode 100644 index 000000000..f85f79242 --- /dev/null +++ b/pkg/operators/v2/doc.go @@ -0,0 +1,4 @@ +// +groupName=operators.coreos.com + +// Package v2 contains resources types for version v2 of the operators.coreos.com API group. +package v2 diff --git a/pkg/operators/v2/groupversion_info.go b/pkg/operators/v2/groupversion_info.go new file mode 100644 index 000000000..2d2d923d1 --- /dev/null +++ b/pkg/operators/v2/groupversion_info.go @@ -0,0 +1,28 @@ +// +kubebuilder:object:generate=true + +// Package v2 contains API Schema definitions for the operator v2 API group. +package v2 + +import ( + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/controller-runtime/pkg/scheme" +) + +var ( + // GroupVersion is group version used to register these objects. + GroupVersion = schema.GroupVersion{Group: "operators.coreos.com", Version: "v2"} + + // SchemeGroupVersion is required for compatibility with client generation. + SchemeGroupVersion = GroupVersion + + // SchemeBuilder is used to add go types to the GroupVersionKind scheme. + SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion} + + // AddToScheme adds the types in this group-version to the given scheme. + AddToScheme = SchemeBuilder.AddToScheme +) + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return GroupVersion.WithResource(resource).GroupResource() +} diff --git a/pkg/operators/v2/operatorcondition_types.go b/pkg/operators/v2/operatorcondition_types.go new file mode 100644 index 000000000..681ee308d --- /dev/null +++ b/pkg/operators/v2/operatorcondition_types.go @@ -0,0 +1,51 @@ +package v2 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +const ( + // Upgradeable indicates that the operator is upgradeable + Upgradeable string = "Upgradeable" +) + +// OperatorConditionSpec allows an operator to report state to OLM and provides +// cluster admin with the ability to manually override state reported by the operator. +type OperatorConditionSpec struct { + ServiceAccounts []string `json:"serviceAccounts,omitempty"` + Deployments []string `json:"deployments,omitempty"` + Overrides []metav1.Condition `json:"overrides,omitempty"` + Conditions []metav1.Condition `json:"conditions,omitempty"` +} + +// OperatorConditionStatus allows OLM to convey which conditions have been observed. +type OperatorConditionStatus struct { + Conditions []metav1.Condition `json:"conditions,omitempty"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +genclient +// +kubebuilder:storageversion +// +kubebuilder:resource:shortName=condition,categories=olm +// +kubebuilder:subresource:status +// OperatorCondition is a Custom Resource of type `OperatorCondition` which is used to convey information to OLM about the state of an operator. +type OperatorCondition struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata"` + + Spec OperatorConditionSpec `json:"spec,omitempty"` + Status OperatorConditionStatus `json:"status,omitempty"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// OperatorConditionList represents a list of Conditions. +type OperatorConditionList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata"` + + Items []OperatorCondition `json:"items"` +} + +func init() { + SchemeBuilder.Register(&OperatorCondition{}, &OperatorConditionList{}) +} diff --git a/pkg/operators/v2/zz_generated.deepcopy.go b/pkg/operators/v2/zz_generated.deepcopy.go new file mode 100644 index 000000000..2d6f393bb --- /dev/null +++ b/pkg/operators/v2/zz_generated.deepcopy.go @@ -0,0 +1,145 @@ +// +build !ignore_autogenerated + +/* + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by controller-gen. DO NOT EDIT. + +package v2 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OperatorCondition) DeepCopyInto(out *OperatorCondition) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorCondition. +func (in *OperatorCondition) DeepCopy() *OperatorCondition { + if in == nil { + return nil + } + out := new(OperatorCondition) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *OperatorCondition) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OperatorConditionList) DeepCopyInto(out *OperatorConditionList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]OperatorCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConditionList. +func (in *OperatorConditionList) DeepCopy() *OperatorConditionList { + if in == nil { + return nil + } + out := new(OperatorConditionList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *OperatorConditionList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OperatorConditionSpec) DeepCopyInto(out *OperatorConditionSpec) { + *out = *in + if in.ServiceAccounts != nil { + in, out := &in.ServiceAccounts, &out.ServiceAccounts + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.Deployments != nil { + in, out := &in.Deployments, &out.Deployments + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.Overrides != nil { + in, out := &in.Overrides, &out.Overrides + *out = make([]metav1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]metav1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConditionSpec. +func (in *OperatorConditionSpec) DeepCopy() *OperatorConditionSpec { + if in == nil { + return nil + } + out := new(OperatorConditionSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OperatorConditionStatus) DeepCopyInto(out *OperatorConditionStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]metav1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConditionStatus. +func (in *OperatorConditionStatus) DeepCopy() *OperatorConditionStatus { + if in == nil { + return nil + } + out := new(OperatorConditionStatus) + in.DeepCopyInto(out) + return out +} From 0920c684fbfd003f809dd84be16347b2fc59e303 Mon Sep 17 00:00:00 2001 From: Vu Dinh Date: Wed, 26 May 2021 15:29:33 -0400 Subject: [PATCH 4/5] Add ConditionType to v2 api Signed-off-by: Vu Dinh --- pkg/operators/v2/operatorcondition_types.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pkg/operators/v2/operatorcondition_types.go b/pkg/operators/v2/operatorcondition_types.go index 681ee308d..ef1c56de6 100644 --- a/pkg/operators/v2/operatorcondition_types.go +++ b/pkg/operators/v2/operatorcondition_types.go @@ -9,6 +9,9 @@ const ( Upgradeable string = "Upgradeable" ) +// ConditionType codifies a condition's type. +type ConditionType string + // OperatorConditionSpec allows an operator to report state to OLM and provides // cluster admin with the ability to manually override state reported by the operator. type OperatorConditionSpec struct { From 477b971a973210d39617d68965b662d6e1420754 Mon Sep 17 00:00:00 2001 From: Vu Dinh Date: Thu, 3 Jun 2021 11:36:23 -0400 Subject: [PATCH 5/5] Regen go-bindata for crd changes for OperatorCondition Signed-off-by: Vu Dinh --- ...erators.coreos.com_operatorconditions.yaml | 21 +++++++++++-------- crds/zz_defs.go | 16 +++++++------- pkg/operators/v2/zz_generated.deepcopy.go | 8 +++---- 3 files changed, 24 insertions(+), 21 deletions(-) diff --git a/crds/operators.coreos.com_operatorconditions.yaml b/crds/operators.coreos.com_operatorconditions.yaml index 66d0aa654..237d0fbed 100644 --- a/crds/operators.coreos.com_operatorconditions.yaml +++ b/crds/operators.coreos.com_operatorconditions.yaml @@ -135,8 +135,10 @@ spec: type: string maxLength: 316 pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ - served: false + served: true storage: false + subresources: + status: {} - name: v2 schema: openAPIV3Schema: @@ -154,19 +156,16 @@ spec: metadata: type: object spec: - description: OperatorConditionSpec allows a cluster admin to convey information about the state of an operator to OLM, potentially overriding state reported by the operator. + description: OperatorConditionSpec allows an operator to report state to OLM and provides cluster admin with the ability to manually override state reported by the operator. type: object properties: - deployments: - type: array - items: - type: string - overrides: + conditions: type: array items: description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: + - lastTransitionTime - message - reason - status @@ -203,7 +202,11 @@ spec: type: string maxLength: 316 pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ - conditions: + deployments: + type: array + items: + type: string + overrides: type: array items: description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" @@ -250,7 +253,7 @@ spec: items: type: string status: - description: OperatorConditionStatus allows an operator to convey information its state to OLM. The status may trail the actual state of a system. + description: OperatorConditionStatus allows OLM to convey which conditions have been observed. type: object properties: conditions: diff --git a/crds/zz_defs.go b/crds/zz_defs.go index 45e3cf0ce..87fac13f9 100644 --- a/crds/zz_defs.go +++ b/crds/zz_defs.go @@ -99,7 +99,7 @@ func operatorsCoreosCom_catalogsourcesYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "operators.coreos.com_catalogsources.yaml", size: 7725, mode: os.FileMode(420), modTime: time.Unix(1614008464, 0)} + info := bindataFileInfo{name: "operators.coreos.com_catalogsources.yaml", size: 7725, mode: os.FileMode(420), modTime: time.Unix(1622734315, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -119,7 +119,7 @@ func operatorsCoreosCom_clusterserviceversionsYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "operators.coreos.com_clusterserviceversions.yaml", size: 459349, mode: os.FileMode(420), modTime: time.Unix(1614008465, 0)} + info := bindataFileInfo{name: "operators.coreos.com_clusterserviceversions.yaml", size: 462335, mode: os.FileMode(420), modTime: time.Unix(1622734316, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -139,12 +139,12 @@ func operatorsCoreosCom_installplansYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "operators.coreos.com_installplans.yaml", size: 13615, mode: os.FileMode(420), modTime: time.Unix(1614008465, 0)} + info := bindataFileInfo{name: "operators.coreos.com_installplans.yaml", size: 14077, mode: os.FileMode(420), modTime: time.Unix(1622734318, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _operatorsCoreosCom_operatorconditionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x58\x5f\x6f\x1b\x37\x12\x7f\xf7\xa7\x18\xe8\x0e\x88\x9d\x93\x56\x71\x5a\xe4\xda\x05\x82\x20\x48\x2f\x87\x20\x49\x1b\xc4\xbe\x3e\x9c\xe5\xbb\xcc\x92\xa3\x15\xeb\x5d\x72\xcb\x3f\xb2\xd5\xa2\xdf\xfd\x30\xe4\xae\x76\x65\xfd\x89\x81\xe4\xfa\xa4\x7d\x89\x45\x0e\x87\xc3\x99\xf9\xfd\x66\x26\xd8\xa8\x9f\xc9\x3a\x65\x74\x0e\xd8\x28\xba\xf3\xa4\xf9\x97\xcb\x6e\xbe\x73\x99\x32\xd3\xe5\xf9\xc9\x8d\xd2\x32\x87\x57\xc1\x79\x53\x7f\x24\x67\x82\x15\xf4\x03\xcd\x95\x56\x5e\x19\x7d\x52\x93\x47\x89\x1e\xf3\x13\x00\xd4\xda\x78\xe4\x65\xc7\x3f\x01\x84\xd1\xde\x9a\xaa\x22\x3b\x29\x49\x67\x37\xa1\xa0\x22\xa8\x4a\x92\x8d\xca\xbb\xab\x97\x4f\xb2\x6f\xb3\xf3\x13\x00\x61\x29\x1e\xbf\x54\x35\x39\x8f\x75\x93\x83\x0e\x55\x75\x02\xa0\xb1\xa6\x1c\x4c\x43\x16\xbd\xb1\xc2\x68\x19\xaf\x77\x59\xb7\xe4\x32\x61\x2c\x19\xfe\xa7\x3e\x71\x0d\x09\xb6\xa0\xb4\x26\x34\xfd\xb1\x0d\x99\xa4\xb3\x33\x14\x3d\x95\xc6\xaa\xee\x37\xc0\x04\x4c\x55\xc7\xbf\x93\x03\x7e\x6a\x75\xbc\xea\xae\x8e\x7b\x95\x72\xfe\xed\xee\xfd\x77\xca\xf9\x28\xd3\x54\xc1\x62\xb5\xcb\xf8\xb8\xed\x16\xc6\xfa\x1f\x7b\x53\xf8\x6a\xb1\x71\x89\x53\xba\x0c\x15\xda\x1d\x2a\x4e\x00\x9c\x30\x0d\xe5\x10\x35\x34\x28\x48\x9e\x00\xb4\x9e\x6d\x35\x4e\x5a\xef\x2d\xcf\xdb\x0b\x9c\x58\x50\x8d\xdd\x75\xc0\x6a\xf5\xcb\x0f\x6f\x7e\xfe\xe6\xe2\xde\x06\x80\x24\x27\xac\x6a\x7c\x8c\xd3\xd6\x1b\x41\x39\xc0\x36\x37\xa0\x4b\x0e\x30\x73\xf0\xab\x86\xe0\xd3\x96\xfc\x27\xb8\x5d\x28\xb1\xe0\x63\xc1\x91\x04\x6f\xf8\xa9\x4b\x5a\x81\xd2\x73\x63\xeb\x18\x7c\x5e\xfd\xe9\xdd\x7b\xc0\xc2\x04\x0f\x7e\x41\xe0\x3c\xfa\xa8\x16\xf5\xda\x05\xd9\xc0\x48\xbe\x2d\x07\x53\xfc\x42\xc2\x0f\x96\x2d\xfd\x1a\x94\x25\x39\x7c\x0f\x7b\xa3\x4b\xd9\xc1\x72\x63\x59\xaf\x1f\xc4\x3f\x7d\x03\x80\x6c\xac\xdf\x73\xcc\x23\xf6\x5e\x92\x03\xc9\xd8\x20\x17\x0d\x6f\xe3\x40\xb2\x75\x79\x74\xcd\x42\x39\xb0\xd4\x58\x72\xa4\x13\x5a\xba\xa7\xc5\x07\x64\x70\x41\x96\x0f\x72\x66\x84\x4a\x26\x0f\x59\x0f\x96\x84\x29\xb5\xfa\x6d\xad\xcd\xb1\xa7\xf8\x9a\x0a\x3d\x39\x0f\x4a\x7b\xb2\x1a\x2b\x58\x62\x15\x68\x0c\xa8\x25\xd4\xb8\x02\x4b\xac\x17\x82\x1e\x68\x88\x22\x2e\x83\xf7\xc6\x52\x74\x7e\x0e\x0b\xef\x1b\x97\x4f\xa7\xa5\xf2\x1d\xfc\x85\xa9\xeb\xa0\x95\x5f\x4d\x23\x92\x55\x11\x18\x45\x53\x49\x4b\xaa\xa6\x4e\x95\x13\xb4\x62\xa1\x3c\x09\x1f\x2c\x4d\xb1\x51\x93\x68\xac\x4e\xd0\xac\xe5\x5f\x6c\x9b\x13\xee\xd1\x3d\xf7\xa5\x90\x39\x6f\x95\x2e\x37\xb6\x22\xda\x0e\xfa\x9a\xf1\x96\x12\x2f\x1d\x4f\x6f\xe9\x5d\xca\x4b\xec\x95\x8f\xff\xb8\xb8\x84\xce\x80\xe4\xf6\xe4\xe1\x5e\xd4\xf5\xce\x66\x47\x29\x3d\x27\x9b\x24\xe7\xd6\xd4\x51\x0b\x69\xd9\x18\xa5\x53\x22\x8a\x4a\x91\xf6\xe0\x42\x51\x2b\xef\x62\x82\x91\xf3\x1c\x87\x0c\x5e\x45\xf6\x83\x82\x20\x34\x12\x3d\xc9\x0c\xde\x68\x78\x85\x35\x55\xaf\xd0\xd1\xff\xdd\xd5\xec\x51\x37\x61\xf7\x3d\xdc\xd9\x43\xf2\xde\x3e\xb0\x05\x28\x80\x8e\x58\xf7\x46\x67\x0b\xf2\x17\x0d\x09\xc0\xaa\x32\xb7\x1c\x31\x51\x05\xe7\xc9\x02\xca\x5a\xe9\x3d\xf0\x3f\x8c\xfb\x96\x1d\xc6\xd0\x18\xcf\xaf\xc7\xaa\x5a\x81\x59\x92\xb5\x4a\x72\xe4\xd3\x19\x4b\x8d\xb1\x9e\x24\x14\xab\xa8\x69\x17\x6b\x1c\x7c\xe8\x7e\x4a\x48\x4f\x6e\x2a\xb3\xaa\x39\x83\xb6\x37\x3b\xad\x68\x2d\xae\x76\xec\x2a\x4f\xf5\xce\x63\x07\x02\xc5\x5f\xfb\xc8\x5d\xf6\x7c\xc1\x95\x1b\xd1\x1b\xf5\xcc\xce\x59\x88\x4a\x3b\x90\xe4\x51\x55\x0e\xe6\xc6\x82\xd1\x04\xc8\x39\xe0\x13\x93\x11\x88\x60\x6d\x84\x44\x17\xaa\x88\x9e\x97\x1f\xde\xac\xcb\x41\x06\x93\xc9\x04\x2e\x79\xd9\x79\x1b\x84\x67\xec\x32\x55\x69\x49\x32\x6a\x95\xca\x46\x7e\x72\xac\x9c\x63\x1d\x9f\x01\x98\x92\x60\xae\xa8\x92\xd0\xa0\x5f\x40\xc6\xb7\x04\x2e\xdf\xeb\xf2\x0f\xf0\xda\x58\xa0\x3b\xac\x9b\x8a\xc6\xa9\xee\xbc\x36\xe6\x22\x0a\xb6\x17\xfe\x1e\x1f\x3a\x9d\xc2\xc7\x35\xee\x53\x52\x14\x8e\xec\x32\xf5\x2b\x31\xcb\x60\x6e\xcc\x23\xb7\xf9\xa6\xac\x3b\xfc\x56\x9b\x5b\xbd\xcb\x84\x78\x27\x5a\xca\x61\x36\x7a\xb9\x44\x55\x61\x51\xd1\x6c\x34\x86\xd9\xe8\x83\x35\xa5\x25\xc7\x05\x9c\x17\x98\x90\x67\xa3\x1f\xa8\xb4\x28\x49\xce\x46\x9d\xea\xbf\x35\xe8\xc5\xe2\x3d\xd9\x92\xde\xd2\xea\x79\x54\xb8\xb1\x75\xe1\x2d\x37\x28\xab\xe7\x35\xcb\xac\xf7\xb8\xfb\xb8\x5c\x35\xf4\xbc\xc6\x66\x63\xf1\x3d\x36\x1b\x8a\xd6\x61\x75\x70\x75\xcd\xa0\x5f\x9e\x67\x7d\xa8\x3f\xfd\xe2\x8c\xce\x67\xa3\xfe\x4d\x63\x53\x73\xca\x34\x7e\x35\x1b\xc1\x86\x05\xf9\x6c\x14\x6d\xe8\xd6\x3b\xa3\xf3\xd9\x88\x6f\xe3\x65\x6b\xbc\x29\xc2\x3c\x9f\x8d\x8a\x95\x27\x37\x3e\x1f\x5b\x6a\xc6\xdc\x82\x3c\xef\x6f\x98\x8d\x3e\xc1\x4c\x77\x46\x1b\xbf\x20\x9b\x22\xed\xe0\x8f\xd1\x01\x6c\xec\x84\x6a\xfa\x76\x97\xfb\xfe\xe3\xc2\xef\x1c\x96\xb4\x77\xdf\x12\xba\xb6\xe7\xda\xb5\x9d\x42\xbf\x77\x9b\x0d\xdc\xb9\x79\x88\x49\xd2\x57\xa1\xf3\x97\x16\xb5\x53\x5d\xf7\xbb\x4f\xf2\x1e\x60\xb7\x0f\x32\xba\x52\x4f\xe0\x3c\x78\x5e\x88\x30\x5d\x07\xdb\xaf\xa5\x19\x7d\x5c\xe5\x18\xd4\xe9\x69\xcc\xad\xa8\x63\x30\xb2\x16\xb1\xa9\x05\x29\x08\x6e\x17\xa4\xa3\xaa\xa0\x25\xd9\x6a\xc5\x5c\xdb\x6b\x15\x0b\xd4\x25\x97\x3c\x78\xc3\x14\x80\x11\xe4\x5c\x0e\x6f\x18\x35\x63\x3e\xa8\x21\xb8\xae\x34\x47\xbb\xd6\x1a\x99\x2d\x12\xca\x5b\x35\xb1\xba\x0b\x41\x8d\x67\x28\xdd\xe7\xec\xfe\x3b\x48\x97\xdd\x97\x0a\x4b\x0e\x5c\x93\x27\x7c\xf1\x1e\xc9\x36\x39\x1e\xe8\xf8\x56\x3a\xf5\x21\x8b\x50\xa3\xe6\xec\x91\x6c\x6f\xbf\xa7\xa5\x12\x18\xfb\x91\x8e\x44\xfb\xda\xd6\xc7\xa1\x75\x35\x37\x20\x05\x31\xfd\x45\xe0\xb5\xcf\xfa\xc2\xc7\xd7\x78\xf7\x8e\x74\xe9\x17\x39\x7c\xf3\xf4\xef\xcf\xbe\xdb\x23\x98\x98\x90\xe4\x3f\x49\x73\x9d\xdc\xd1\xee\xee\x71\xc3\xf6\xc1\x41\x73\x15\xdf\x99\x75\x3d\x46\x56\xf6\x32\x31\x43\x36\xf3\xf2\x16\x1d\x38\xf2\x50\x20\x0f\x06\xa1\x61\xbf\x30\xb5\x2b\xed\x3c\x6a\x41\x63\x50\xf3\xdd\xca\xd4\x9a\xb1\xab\x15\x9c\x3f\x1d\x43\xd1\xba\x78\x9b\xab\xaf\xee\xae\xb3\x1d\x26\x2b\x07\xdf\x8f\xef\xd9\xc3\xdd\x62\x88\x65\x8e\x13\x07\x6e\x95\x5f\x70\x33\x19\x6b\x5f\xdb\x76\xef\xa8\x7d\xb4\xb6\xf7\x73\x81\xe3\x0a\x58\x92\xfd\x6c\xda\x2a\xed\x9f\x7d\xbb\x3f\xbe\x4a\xab\x3a\xd4\x39\x3c\xd9\x23\x92\x28\xed\x81\xd1\x4c\xc2\x7d\xe9\x47\xa6\xae\xd2\x62\xcd\x9d\x99\x00\x25\xb9\xe1\x9a\x2b\xb2\xc3\xd4\xe6\x47\xb7\x07\xb9\x98\x6f\x78\xf1\x91\x6b\x79\x68\x90\xec\x1f\xac\x91\x41\x70\xcb\x6d\xe6\xb1\x9f\x54\x73\x25\x86\x04\xc5\x7d\x6c\x44\x43\x9a\xa4\x80\xee\xd8\xe9\xeb\x99\x25\x8d\x35\x84\x5a\xe9\xd2\xb5\x57\x72\xc3\xce\x04\x92\x4a\xec\xed\x82\x62\x3d\x89\x13\x58\x7b\xc6\x46\xab\x9c\x92\x64\x49\x02\x42\x19\xd0\xa2\xf6\x44\x92\xe9\x87\x21\xd8\xca\x0e\x28\x0f\xfb\xee\xbd\x43\x63\x82\x6a\x22\x2b\x36\xb1\xed\xf8\x23\x62\xbf\x1e\x54\xcf\x9f\x3c\x3d\x18\xf2\xb5\xdc\x5e\xa1\x06\x3d\xcf\x82\x39\xfc\xe7\xea\xe5\xe4\xdf\x38\xf9\xed\xfa\xb4\xfd\xe3\xc9\xe4\xfb\xff\x8e\xf3\xeb\xc7\x83\x9f\xd7\x67\x2f\xfe\xba\x47\x53\x42\xd0\x03\xd3\xa7\x2d\x22\x5d\x67\xd8\x45\x74\x1c\x2b\x8c\x99\xc3\xa5\xe5\xa9\xf4\x35\x56\x8e\xc6\xf0\x2f\x1d\x4b\xc3\x17\x3a\x8d\x74\xa8\xf7\x5b\xc7\x55\x79\xc4\xb7\xee\xee\x28\xd6\x22\xd1\xa4\xc3\x32\xad\xb9\x7b\x64\xa2\xad\x0f\x73\x52\xec\xc9\xcc\x7c\xc8\x34\x83\x29\x11\x22\xe3\x71\x1f\x9a\xb5\x3d\x6d\x26\x4c\x3d\x1d\x4c\x91\xdc\x4c\xbf\x47\xbd\x82\x9e\xd6\x52\x07\x7a\x3f\xd3\x1d\x8f\x47\x80\xc2\x1a\xe7\xd6\x63\xb0\x83\x4a\xdd\x10\xac\xdb\xd4\x44\x96\x05\x09\x8c\xdd\xb7\x2d\x94\xb7\x68\x57\xbd\x75\x0e\x04\xea\x38\xd4\x3a\x9a\x87\x0a\x4e\x1d\x11\x64\xda\x48\xda\x66\xd7\xb3\xc4\xa1\x58\xa8\x4a\xf9\x15\xb3\xa4\x24\x61\xf4\xbc\x52\x6d\xd3\x5f\xf3\x50\x86\xda\x27\xb8\x59\x2a\xe9\x0e\x94\x87\x9a\x1b\x49\x72\x2c\x72\x2a\xb5\x3b\x3f\x7f\xfa\xcd\x45\x28\xa4\xa9\x51\xe9\xd7\xb5\x9f\x9e\xbd\x38\xfd\x35\x60\xc5\xcc\x23\x7f\xc4\x9a\x5e\xd7\xfe\xec\xeb\x95\xc5\xf3\x67\x0f\x40\xd1\xe9\x55\xc2\xca\xf5\xe9\xd5\xa4\xfd\xeb\x71\xb7\x74\xf6\xe2\x74\x96\x1d\xdc\x3f\x7b\xcc\x6f\x18\x20\xf0\xfa\x6a\xd2\xc3\x2f\xbb\x7e\x7c\xf6\x62\xb0\x77\xb6\x0d\x46\xae\x58\x4a\xd0\x4b\x21\x4c\xf8\xd3\x66\xce\xdd\xd8\xff\xcc\xb4\x9f\x28\xa0\x9b\xf7\x37\xc7\xf6\x1d\xb3\xbe\xf2\xae\x2d\x9f\x69\xac\x4f\x99\xd1\x12\x09\x13\xac\xb7\xa8\xaa\x94\x56\xc2\x07\xac\x06\xff\x27\x00\x6e\xe5\x3c\xd5\x5f\x69\xa4\xef\xd3\xf8\x38\x5e\x1f\xc7\xeb\xe3\x78\xbd\xf5\x7d\x7e\xbc\xde\x1e\x46\x8f\x93\xf8\x71\x12\xef\xbf\xe3\x24\x7e\x9c\xc4\x8f\x93\xf8\x83\xa2\x79\x9c\xc4\x8f\x93\xf8\xe6\x77\x9c\xc4\x5b\x99\xe3\x24\x7e\x9c\xc4\xff\xec\x49\x3c\xd5\xa9\x1c\xbc\x0d\x5d\xd3\xe2\xbc\xb1\xdc\xa4\x6c\xac\x85\x62\x1d\xde\x3e\x09\x5b\xe4\xc2\xef\x7f\x9c\xfc\x2f\x00\x00\xff\xff\x90\x7b\x4c\xbd\x70\x25\x00\x00") +var _operatorsCoreosCom_operatorconditionsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5b\x5f\x6f\xdb\x38\x12\x7f\xcf\xa7\x18\xf8\x0e\x68\xd2\xb3\xe5\xa6\x5d\xf4\x76\x0d\x14\x45\xd1\xbd\x1e\x8a\x36\xdb\xa2\xc9\xed\xc3\xc5\xb9\xeb\x48\x1c\xcb\xdc\x4a\xa4\x96\xa4\x9c\x78\x17\xfb\xdd\x0f\x43\x4a\x96\x1c\xcb\x4e\x0e\xed\x15\x7b\x0b\xf2\x25\x36\x39\x1a\x0e\xe7\xff\x8f\x91\xb1\x92\x3f\x92\xb1\x52\xab\x19\x60\x25\xe9\xc6\x91\xe2\x6f\x36\xf9\xf4\xad\x4d\xa4\x9e\xae\x4e\x8f\x3e\x49\x25\x66\xf0\xb2\xb6\x4e\x97\x1f\xc8\xea\xda\x64\xf4\x3d\x2d\xa4\x92\x4e\x6a\x75\x54\x92\x43\x81\x0e\x67\x47\x00\xa8\x94\x76\xc8\xd3\x96\xbf\x02\x64\x5a\x39\xa3\x8b\x82\xcc\x24\x27\x95\x7c\xaa\x53\x4a\x6b\x59\x08\x32\x9e\x79\xbb\xf5\xea\x51\xf2\x4d\x72\x7a\x04\x90\x19\xf2\x8f\x5f\xc8\x92\xac\xc3\xb2\x9a\x81\xaa\x8b\xe2\x08\x40\x61\x49\x33\xd0\x15\x19\x74\xda\x64\x5a\x09\xbf\xbd\x4d\xda\x29\x9b\x64\xda\x90\xe6\x3f\xe5\x91\xad\x28\x63\x09\x72\xa3\xeb\xaa\x7b\x6c\x8b\x26\xf0\x6c\x05\x45\x47\xb9\x36\xb2\xfd\x0e\x30\x01\x5d\x94\xfe\x73\x50\xc0\xbb\x86\xc7\xcb\x76\x6b\xbf\x56\x48\xeb\xde\x0c\xaf\xbf\x95\xd6\x79\x9a\xaa\xa8\x0d\x16\x43\xc2\xfb\x65\xbb\xd4\xc6\xfd\xd0\x89\xc2\x5b\x67\x5b\x9b\x58\xa9\xf2\xba\x40\x33\xc0\xe2\x08\xc0\x66\xba\xa2\x19\x78\x0e\x15\x66\x24\x8e\x00\x1a\xcd\x36\x1c\x27\x8d\xf6\x56\xa7\xcd\x06\x36\x5b\x52\x89\xed\x76\xc0\x6c\xd5\x8b\xf7\xaf\x7f\x7c\x72\x7e\x6b\x01\x40\x90\xcd\x8c\xac\x9c\xb7\xd3\xce\x19\x41\x5a\xc0\xc6\x37\xa0\x75\x0e\xd0\x0b\x70\xeb\x8a\xe0\xe3\x0e\xfd\x47\xb8\x5e\xca\x6c\xc9\x8f\xd5\x96\x04\x38\xcd\x47\x5d\xd1\x1a\xa4\x5a\x68\x53\x7a\xe3\xf3\xec\xbb\xb7\x67\x80\xa9\xae\x1d\xb8\x25\x81\x75\xe8\x3c\x5b\x54\x1b\x15\x24\x3d\x21\x79\xb7\x19\xe8\xf4\x27\xca\x5c\x6f\xda\xd0\xcf\xb5\x34\x24\xfa\xe7\x61\x6d\xb4\x2e\xdb\x9b\xae\x0c\xf3\x75\x3d\xfb\x87\xd1\x0b\x90\xad\xf9\x5b\x8a\x79\xc0\xda\x0b\x74\x20\x38\x36\xc8\x7a\xc1\x1b\x3b\x90\x68\x54\xee\x55\xb3\x94\x16\x0c\x55\x86\x2c\xa9\x10\x2d\xed\xd1\xfc\x01\x12\x38\x27\xc3\x0f\xb2\x67\xd4\x85\x08\x1a\x32\x0e\x0c\x65\x3a\x57\xf2\x97\x0d\x37\xcb\x9a\xe2\x6d\x0a\x74\x64\x1d\x48\xe5\xc8\x28\x2c\x60\x85\x45\x4d\x63\x40\x25\xa0\xc4\x35\x18\x62\xbe\x50\xab\x1e\x07\x4f\x62\x13\x38\xd3\x86\xbc\xf2\x67\xb0\x74\xae\xb2\xb3\xe9\x34\x97\xae\x0d\xff\x4c\x97\x65\xad\xa4\x5b\x4f\x7d\x24\xcb\xb4\xe6\x28\x9a\x0a\x5a\x51\x31\xb5\x32\x9f\xa0\xc9\x96\xd2\x51\xe6\x6a\x43\x53\xac\xe4\xc4\x0b\xab\x42\x68\x96\xe2\x4f\xa6\xf1\x09\xfb\xe0\x96\xfa\x82\xc9\xac\x33\x52\xe5\x5b\x4b\x3e\xda\x0e\xea\x9a\xe3\x2d\x38\x5e\x78\x3c\x9c\xa5\x53\x29\x4f\xb1\x56\x3e\xfc\xed\xfc\x02\x5a\x01\x82\xda\x83\x86\x3b\x52\xdb\x29\x9b\x15\x25\xd5\x82\x4c\xa0\x5c\x18\x5d\x7a\x2e\xa4\x44\xa5\xa5\x0a\x8e\x98\x15\x92\x94\x03\x5b\xa7\xa5\x74\xd6\x3b\x18\x59\xc7\x76\x48\xe0\xa5\xcf\x7e\x90\x12\xd4\x95\x40\x47\x22\x81\xd7\x0a\x5e\x62\x49\xc5\x4b\xb4\xf4\x3f\x57\x35\x6b\xd4\x4e\x58\x7d\xf7\x57\x76\x3f\x79\xef\x3e\xb0\x13\x50\x00\x6d\x62\xdd\x6b\x9d\x9d\x90\x3f\xaf\x28\x03\x2c\x0a\x7d\xcd\x16\xcb\x8a\xda\x3a\x32\x80\xa2\x94\x6a\x4f\xf8\x1f\x8e\xfb\x26\x3b\x8c\xa1\xd2\x8e\x4f\x8f\x45\xb1\x06\xbd\x22\x63\xa4\x60\xcb\x87\x67\x0c\x55\xda\x38\x12\x90\xae\x3d\xa7\xa1\xac\x71\xf0\xa0\xfb\x53\x42\x38\x72\x55\xe8\x75\xc9\x1e\xb4\xbb\xd8\x72\x45\x63\x70\x3d\xb0\x2a\x1d\x95\x83\x8f\x1d\x30\x14\x8f\xe6\x90\x43\xf2\x7c\xc6\x96\x5b\xd6\x1b\x75\x99\x9d\xbd\x10\xa5\xb2\x20\xc8\xa1\x2c\x2c\x2c\xb4\x01\xad\x08\x90\x7d\xc0\x85\x4c\x46\x90\xd5\xc6\xf8\x90\x68\x4d\xe5\xa3\xe7\xc5\xfb\xd7\x9b\x72\x90\xc0\x64\x32\x81\x0b\x9e\xb6\xce\xd4\x99\xe3\xd8\xe5\x54\xa5\x04\x09\xcf\x55\x48\xe3\xf3\x93\x65\xe6\x6c\x6b\x7f\x0c\xc0\xe0\x04\x0b\x49\x85\x80\x0a\xdd\x12\x12\xde\xa5\xe6\xf2\xbd\x29\xff\x00\xaf\xb4\x01\xba\xc1\xb2\x2a\x68\x1c\xea\xce\x2b\xad\xcf\x3d\x61\xb3\xe1\xaf\xfe\xa0\xd3\x29\x7c\xd8\xc4\x7d\x70\x8a\xd4\x92\x59\x85\x7e\xc5\x7b\x19\x2c\xb4\x7e\x60\xb7\xcf\x94\xb4\x0f\xbf\x51\xfa\x5a\x0d\x89\xe0\xf7\x44\x43\x33\x98\x8f\x5e\xac\x50\x16\x98\x16\x34\x1f\x8d\x61\x3e\x7a\x6f\x74\x6e\xc8\x72\x01\xe7\x09\x4e\xc8\xf3\xd1\xf7\x94\x1b\x14\x24\xe6\xa3\x96\xf5\x5f\x2a\x74\xd9\xf2\x8c\x4c\x4e\x6f\x68\xfd\xcc\x33\xdc\x5a\x3a\x77\x86\x1b\x94\xf5\xb3\x92\x69\x36\x6b\xdc\x7d\x5c\xac\x2b\x7a\x56\x62\xb5\x35\x79\x86\xd5\x16\xa3\x8d\x59\x2d\x5c\x5e\x71\xd0\xaf\x4e\x93\xce\xd4\x1f\x7f\xb2\x5a\xcd\xe6\xa3\xee\x4c\x63\x5d\xb2\xcb\x54\x6e\x3d\x1f\xc1\x96\x04\xb3\xf9\xc8\xcb\xd0\xce\xb7\x42\xcf\xe6\x23\xde\x8d\xa7\x8d\x76\x3a\xad\x17\xb3\xf9\x28\x5d\x3b\xb2\xe3\xd3\xb1\xa1\x6a\xcc\x2d\xc8\xb3\x6e\x87\xf9\xe8\x23\xcc\x55\x2b\xb4\x76\x4b\x32\xc1\xd2\x16\x7e\x1b\x1d\x88\x8d\xc1\x50\x0d\x63\xb8\xdc\x77\x83\x0b\xbf\xb5\x98\xd3\xde\x75\x43\x68\x9b\x9e\x6b\x68\x39\x98\x7e\xef\x32\x0b\x38\xb8\x78\x28\x93\x84\x51\xa0\x75\x17\x06\x95\x95\x6d\xf7\xbb\x8f\xf2\x56\xc0\xee\x3e\xc8\xd1\x15\x7a\x02\xeb\xc0\xf1\x84\x0f\xd3\x8d\xb1\xdd\x86\x9a\xa3\x8f\xab\x1c\x07\x75\x38\x1a\xe7\x56\x54\xde\x18\x49\x13\xb1\xa1\x05\x49\x09\xae\x97\xa4\x3c\xab\x5a\x09\x32\xc5\x9a\x73\x6d\xc7\x35\x5b\xa2\xca\xb9\xe4\xc1\x6b\x4e\x01\xe8\x83\x9c\xcb\xe1\x27\x8e\x9a\x31\x3f\xa8\xa0\xb6\x6d\x69\xf6\x72\x6d\x38\x72\xb6\x08\x51\xde\xb0\xf1\xd5\x3d\xcb\xa8\x72\x1c\x4a\xb7\x73\x76\x37\x0e\xa6\xcb\x76\x84\xc2\x32\x03\xae\xc9\x13\xde\x78\x0f\x65\xe3\x1c\xf7\x54\x7c\x43\x1d\xfa\x90\x65\x5d\xa2\x62\xef\x11\x2c\x6f\xb7\xa6\x84\xcc\xd0\xf7\x23\x6d\x12\xed\x6a\x5b\x67\x87\x46\xd5\xdc\x80\xa4\xc4\xe9\xcf\x07\x5e\x73\xac\xcf\x3c\x7c\x89\x37\x6f\x49\xe5\x6e\x39\x83\x27\x8f\xff\xfa\xf4\xdb\x3d\x84\x21\x13\x92\xf8\x3b\x29\xae\x93\x03\xed\xee\x1e\x35\xec\x3e\xd8\x6b\xae\xfc\x39\x93\xb6\xc7\x48\xf2\x8e\xc6\x7b\xc8\xb6\x5f\x5e\xa3\x05\x4b\x0e\x52\x64\x60\x50\x57\xac\x17\x4e\xed\x52\x59\x87\x2a\xa3\x31\xc8\xc5\x30\x33\xb9\xc9\xd8\xc5\x1a\x4e\x1f\x8f\x21\x6d\x54\xbc\x9b\xab\x2f\x6f\xae\x92\x01\x91\xa5\x85\xef\xc6\xb7\xe4\xe1\x6e\xb1\xf6\x65\x8e\x1d\x07\xae\xa5\x5b\x72\x33\xe9\x6b\x5f\xd3\x76\x0f\xd4\x3e\xda\xc8\x7b\x97\xe1\xb8\x02\xe6\x64\xee\x74\x5b\xa9\xdc\xd3\x6f\xf6\xdb\x57\x2a\x59\xd6\xe5\x0c\x1e\xed\x21\x09\x29\xed\x9e\xd6\x0c\xc4\x5d\xe9\x47\x4e\x5d\xb9\xc1\x92\x3b\xb3\x0c\xa4\xe0\x86\x6b\x21\xc9\xf4\x5d\x9b\x0f\xdd\x3c\xc8\xc5\x7c\x4b\x8b\x0f\x6c\x93\x87\x7a\xce\xfe\xde\x68\x51\x67\xdc\x72\xeb\x85\xef\x27\xe5\x42\x66\xfd\x04\xc5\x7d\xac\x8f\x86\x80\xa4\x80\x6e\x58\xe9\x1b\xcc\x12\x60\x0d\xa1\x92\x2a\xb7\xcd\x96\xdc\xb0\x73\x02\x09\x25\xf6\x7a\x49\xbe\x9e\x78\x04\xd6\x3c\x63\xbc\x54\x56\x0a\x32\x24\x00\x21\xaf\xd1\xa0\x72\x44\x82\xd3\x0f\x87\x60\x43\xdb\x4b\x79\xd8\x75\xef\x6d\x34\x86\x50\x0d\xc9\x8a\x45\x6c\x3a\x7e\x1f\xb1\x5f\x2e\x54\x4f\x1f\x3d\x3e\x68\xf2\x0d\xdd\x5e\xa2\x0a\x1d\x63\xc1\x19\xfc\xeb\xf2\xc5\xe4\x9f\x38\xf9\xe5\xea\xb8\xf9\xf0\x68\xf2\xdd\xbf\xc7\xb3\xab\x87\xbd\xaf\x57\x27\xcf\xff\xbc\x87\x53\x88\xa0\x7b\xba\x4f\x53\x44\xda\xce\xb0\xb5\xe8\xd8\x57\x18\xbd\x80\x0b\xc3\xa8\xf4\x15\x16\x96\xc6\xf0\x0f\xe5\x4b\xc3\x67\x2a\x8d\x54\x5d\xee\x97\x8e\xab\xf2\x88\x77\x1d\xee\x28\x36\x24\x5e\xa4\xc3\x34\x8d\xb8\x7b\x68\xbc\xac\xf7\x53\x92\xef\xc9\xf4\xa2\x9f\x69\x7a\x28\x11\x7c\xc6\xe3\x3e\x34\x69\x7a\xda\x24\xd3\xe5\xb4\x87\x22\xb9\x99\x3e\x43\xb5\x86\x2e\xad\x85\x0e\xf4\xb6\xa7\x5b\x86\x47\x80\x99\xd1\xd6\x6e\x60\xb0\x85\x42\x7e\x22\xd8\xb4\xa9\x21\x59\xa6\x94\xa1\xef\xbe\x4d\x2a\x9d\x41\xb3\xee\xa4\xb3\x90\xa1\xf2\xa0\xd6\xd2\xa2\x2e\xe0\xd8\x12\x41\xa2\xb4\xa0\xdd\xec\x7a\x12\x72\x28\xa6\xb2\x90\x6e\xcd\x59\x52\x50\xa6\xd5\xa2\x90\x4d\xd3\x5f\x32\x28\x43\xe5\x42\xb8\x19\xca\xe9\x06\xa4\x83\x92\x1b\x49\xb2\x4c\x72\x2c\x94\x3d\x3d\x7d\xfc\xe4\xbc\x4e\x85\x2e\x51\xaa\x57\xa5\x9b\x9e\x3c\x3f\xfe\xb9\xc6\x82\x33\x8f\xf8\x01\x4b\x7a\x55\xba\x93\x2f\x57\x16\x4f\x9f\xde\x23\x8a\x8e\x2f\x43\xac\x5c\x1d\x5f\x4e\x9a\x4f\x0f\xdb\xa9\x93\xe7\xc7\xf3\xe4\xe0\xfa\xc9\x43\x3e\x43\x2f\x02\xaf\x2e\x27\x5d\xf8\x25\x57\x0f\x4f\x9e\xf7\xd6\x4e\x76\x83\x91\x2b\x96\xcc\xe8\x45\x96\xe9\xfa\xab\x61\xce\xe1\xd8\xbf\x03\xed\x87\x14\xd0\xe2\xfd\x6d\xd8\x3e\x80\xf5\xa5\xb3\x4d\xf9\x0c\xb0\x3e\x78\x46\x93\x48\x38\xc1\x3a\x83\xb2\x08\x6e\x95\xb9\x1a\x8b\xde\x9d\x00\xd8\xb5\x75\x54\x7e\x21\x48\xdf\xb9\x71\x84\xd7\x11\x5e\x47\x78\xbd\x33\xee\x86\xd7\xbb\x60\x34\x22\xf1\x88\xc4\xbb\x11\x91\x78\x44\xe2\x11\x89\xdf\xcb\x9a\x11\x89\x47\x24\xbe\x3d\x22\x12\x6f\x68\x22\x12\x8f\x48\xfc\x6b\x23\xf1\x50\xa7\x66\xe0\x4c\xdd\x36\x2d\xd6\x69\xc3\x4d\x0a\x2c\xd8\x65\xdb\xc9\x3a\xdd\xd8\xb7\xf3\xc2\x26\x74\xe1\xd7\xdf\xb6\x5f\xc7\x79\x1c\x5f\xc7\x89\xaf\xe3\xc4\xd7\x71\xe2\xeb\x38\xed\xf8\xda\xaf\xe3\x6c\x5f\xcf\x85\x77\x66\xb6\xae\xe3\xbc\xcf\x56\x46\xaf\xa4\x20\x7b\xeb\xe5\x1d\xdf\x87\xdf\xaa\x32\x25\xaa\xba\xff\x42\x0e\x7d\x9d\xd7\x71\xe2\xdd\x5d\xbc\xbb\x8b\x77\x77\xf1\xee\x2e\xde\xdd\xc5\xbb\xbb\x78\x77\x17\xef\xee\xba\x11\xef\xee\xe2\xdd\xdd\x3e\x93\xc7\xbb\xbb\x76\xc4\xbb\xbb\x78\x77\x37\x60\x8a\x3f\xc6\xdd\x5d\xdf\x83\xe2\xaf\x36\x22\x34\x8d\xd0\xf4\xff\x0c\x9a\x46\xbc\x19\xf1\x66\xc4\x9b\x03\x23\xe2\xcd\x88\x37\x23\xde\x8c\x78\x73\x67\x44\xbc\xd9\xd0\x44\xbc\x19\xf1\x66\xfc\xd5\xc6\x7f\xf9\xab\x8d\x77\x6f\xcf\x7a\x6f\x82\x84\x37\x44\x7a\x9e\xb5\xc4\x15\x41\x4a\xa4\x36\x6d\x44\xfc\x2f\x6e\x84\xca\x11\x2a\xff\x1e\xa0\x72\xfc\x2f\x6e\x44\xd5\x11\x55\xef\x19\x11\x55\x47\x54\x1d\x51\x75\x44\xd5\x11\x55\x1f\x22\x89\xa8\x3a\xa2\xea\xa1\xf1\x3b\xfe\x05\x46\x7f\xee\xae\x1f\x60\xfc\x27\x00\x00\xff\xff\x5f\xed\xc4\x6b\xf2\x56\x00\x00") func operatorsCoreosCom_operatorconditionsYamlBytes() ([]byte, error) { return bindataRead( @@ -159,7 +159,7 @@ func operatorsCoreosCom_operatorconditionsYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "operators.coreos.com_operatorconditions.yaml", size: 9584, mode: os.FileMode(420), modTime: time.Unix(1614008465, 0)} + info := bindataFileInfo{name: "operators.coreos.com_operatorconditions.yaml", size: 22258, mode: os.FileMode(420), modTime: time.Unix(1622734319, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -179,7 +179,7 @@ func operatorsCoreosCom_operatorgroupsYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "operators.coreos.com_operatorgroups.yaml", size: 14332, mode: os.FileMode(420), modTime: time.Unix(1614008466, 0)} + info := bindataFileInfo{name: "operators.coreos.com_operatorgroups.yaml", size: 14332, mode: os.FileMode(420), modTime: time.Unix(1622734321, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -199,7 +199,7 @@ func operatorsCoreosCom_operatorsYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "operators.coreos.com_operators.yaml", size: 8472, mode: os.FileMode(420), modTime: time.Unix(1614008466, 0)} + info := bindataFileInfo{name: "operators.coreos.com_operators.yaml", size: 8472, mode: os.FileMode(420), modTime: time.Unix(1622734322, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -219,7 +219,7 @@ func operatorsCoreosCom_subscriptionsYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "operators.coreos.com_subscriptions.yaml", size: 107523, mode: os.FileMode(420), modTime: time.Unix(1614008466, 0)} + info := bindataFileInfo{name: "operators.coreos.com_subscriptions.yaml", size: 107523, mode: os.FileMode(420), modTime: time.Unix(1622734324, 0)} a := &asset{bytes: bytes, info: info} return a, nil } diff --git a/pkg/operators/v2/zz_generated.deepcopy.go b/pkg/operators/v2/zz_generated.deepcopy.go index 2d6f393bb..06fbb625a 100644 --- a/pkg/operators/v2/zz_generated.deepcopy.go +++ b/pkg/operators/v2/zz_generated.deepcopy.go @@ -20,7 +20,7 @@ limitations under the License. package v2 import ( - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1" runtime "k8s.io/apimachinery/pkg/runtime" ) @@ -98,14 +98,14 @@ func (in *OperatorConditionSpec) DeepCopyInto(out *OperatorConditionSpec) { } if in.Overrides != nil { in, out := &in.Overrides, &out.Overrides - *out = make([]metav1.Condition, len(*in)) + *out = make([]v1.Condition, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) } } if in.Conditions != nil { in, out := &in.Conditions, &out.Conditions - *out = make([]metav1.Condition, len(*in)) + *out = make([]v1.Condition, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) } @@ -127,7 +127,7 @@ func (in *OperatorConditionStatus) DeepCopyInto(out *OperatorConditionStatus) { *out = *in if in.Conditions != nil { in, out := &in.Conditions, &out.Conditions - *out = make([]metav1.Condition, len(*in)) + *out = make([]v1.Condition, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) }