diff --git a/apis/apiextensions/v1/zz_generated.die.go b/apis/apiextensions/v1/zz_generated.die.go index 92a3315..e3c9631 100644 --- a/apis/apiextensions/v1/zz_generated.die.go +++ b/apis/apiextensions/v1/zz_generated.die.go @@ -330,7 +330,7 @@ func (d *CustomResourceDefinitionSpecDie) Conversion(v *apiextensionsv1.CustomRe }) } -// preserveUnknownFields indicates that object fields which are not specified in the OpenAPI schema should be preserved when persisting to storage. apiVersion, kind, metadata and known fields inside metadata are always preserved. This field is deprecated in favor of setting `x-preserve-unknown-fields` to true in `spec.versions[*].schema.openAPIV3Schema`. See https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/#pruning-versus-preserving-unknown-fields for details. +// preserveUnknownFields indicates that object fields which are not specified in the OpenAPI schema should be preserved when persisting to storage. apiVersion, kind, metadata and known fields inside metadata are always preserved. This field is deprecated in favor of setting `x-preserve-unknown-fields` to true in `spec.versions[*].schema.openAPIV3Schema`. See https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#field-pruning for details. func (d *CustomResourceDefinitionSpecDie) PreserveUnknownFields(v bool) *CustomResourceDefinitionSpecDie { return d.DieStamp(func(r *apiextensionsv1.CustomResourceDefinitionSpec) { r.PreserveUnknownFields = v diff --git a/apis/apiserver/flowcontrol/v1beta1/zz_generated.die.go b/apis/apiserver/flowcontrol/v1beta1/zz_generated.die.go index 96aa2f6..5be560a 100644 --- a/apis/apiserver/flowcontrol/v1beta1/zz_generated.die.go +++ b/apis/apiserver/flowcontrol/v1beta1/zz_generated.die.go @@ -1690,6 +1690,26 @@ func (d *LimitedPriorityLevelConfigurationDie) LimitResponse(v flowcontrolv1beta }) } +// `lendablePercent` prescribes the fraction of the level's NominalCL that can be borrowed by other priority levels. The value of this field must be between 0 and 100, inclusive, and it defaults to 0. The number of seats that other levels can borrow from this level, known as this level's LendableConcurrencyLimit (LendableCL), is defined as follows. +// +// LendableCL(i) = round( NominalCL(i) * lendablePercent(i)/100.0 ) +func (d *LimitedPriorityLevelConfigurationDie) LendablePercent(v *int32) *LimitedPriorityLevelConfigurationDie { + return d.DieStamp(func(r *flowcontrolv1beta1.LimitedPriorityLevelConfiguration) { + r.LendablePercent = v + }) +} + +// `borrowingLimitPercent`, if present, configures a limit on how many seats this priority level can borrow from other priority levels. The limit is known as this level's BorrowingConcurrencyLimit (BorrowingCL) and is a limit on the total number of seats that this level may borrow at any one time. This field holds the ratio of that limit to the level's nominal concurrency limit. When this field is non-nil, it must hold a non-negative integer and the limit is calculated as follows. +// +// BorrowingCL(i) = round( NominalCL(i) * borrowingLimitPercent(i)/100.0 ) +// +// The value of this field can be more than 100, implying that this priority level can borrow a number of seats that is greater than its own nominal concurrency limit (NominalCL). When this field is left `nil`, the limit is effectively infinite. +func (d *LimitedPriorityLevelConfigurationDie) BorrowingLimitPercent(v *int32) *LimitedPriorityLevelConfigurationDie { + return d.DieStamp(func(r *flowcontrolv1beta1.LimitedPriorityLevelConfiguration) { + r.BorrowingLimitPercent = v + }) +} + var LimitResponseBlank = (&LimitResponseDie{}).DieFeed(flowcontrolv1beta1.LimitResponse{}) type LimitResponseDie struct { diff --git a/apis/apps/v1/statefulset.go b/apis/apps/v1/statefulset.go index 48fffd0..9df5869 100644 --- a/apis/apps/v1/statefulset.go +++ b/apis/apps/v1/statefulset.go @@ -70,6 +70,14 @@ func (d *StatefulSetSpecDie) PersistentVolumeClaimRetentionPolicyDie(fn func(d * }) } +func (d *StatefulSetSpecDie) OrdinalsDie(fn func(d *StatefulSetOrdinalsDie)) *StatefulSetSpecDie { + return d.DieStamp(func(r *appsv1.StatefulSetSpec) { + d := StatefulSetOrdinalsBlank.DieImmutable(false).DieFeedPtr(r.Ordinals) + fn(d) + r.Ordinals = d.DieReleasePtr() + }) +} + // +die type _ = appsv1.StatefulSetUpdateStrategy @@ -95,6 +103,9 @@ type _ = appsv1.RollingUpdateStatefulSetStrategy // +die type _ = appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy +// +die +type _ = appsv1.StatefulSetOrdinals + // +die type _ = appsv1.StatefulSetStatus diff --git a/apis/apps/v1/zz_generated.die.go b/apis/apps/v1/zz_generated.die.go index 46903da..6b750e9 100644 --- a/apis/apps/v1/zz_generated.die.go +++ b/apis/apps/v1/zz_generated.die.go @@ -1933,7 +1933,7 @@ func (d *ReplicaSetStatusDie) DeepCopy() *ReplicaSetStatusDie { } } -// Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller +// Replicas is the most recently observed number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller func (d *ReplicaSetStatusDie) Replicas(v int32) *ReplicaSetStatusDie { return d.DieStamp(func(r *appsv1.ReplicaSetStatus) { r.Replicas = v @@ -2253,7 +2253,7 @@ func (d *StatefulSetSpecDie) Selector(v *apismetav1.LabelSelector) *StatefulSetS }) } -// template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet. +// template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet. Each pod will be named with the format -. For example, a pod in a StatefulSet named "web" with index number "3" would be named "web-3". func (d *StatefulSetSpecDie) Template(v corev1.PodTemplateSpec) *StatefulSetSpecDie { return d.DieStamp(func(r *appsv1.StatefulSetSpec) { r.Template = v @@ -2309,6 +2309,13 @@ func (d *StatefulSetSpecDie) PersistentVolumeClaimRetentionPolicy(v *appsv1.Stat }) } +// ordinals controls the numbering of replica indices in a StatefulSet. The default ordinals behavior assigns a "0" index to the first replica and increments the index by one for each additional replica requested. Using the ordinals field requires the StatefulSetStartOrdinal feature gate to be enabled, which is alpha. +func (d *StatefulSetSpecDie) Ordinals(v *appsv1.StatefulSetOrdinals) *StatefulSetSpecDie { + return d.DieStamp(func(r *appsv1.StatefulSetSpec) { + r.Ordinals = v + }) +} + var StatefulSetUpdateStrategyBlank = (&StatefulSetUpdateStrategyDie{}).DieFeed(appsv1.StatefulSetUpdateStrategy{}) type StatefulSetUpdateStrategyDie struct { @@ -2617,6 +2624,97 @@ func (d *StatefulSetPersistentVolumeClaimRetentionPolicyDie) WhenScaled(v appsv1 }) } +var StatefulSetOrdinalsBlank = (&StatefulSetOrdinalsDie{}).DieFeed(appsv1.StatefulSetOrdinals{}) + +type StatefulSetOrdinalsDie struct { + mutable bool + r appsv1.StatefulSetOrdinals +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *StatefulSetOrdinalsDie) DieImmutable(immutable bool) *StatefulSetOrdinalsDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *StatefulSetOrdinalsDie) DieFeed(r appsv1.StatefulSetOrdinals) *StatefulSetOrdinalsDie { + if d.mutable { + d.r = r + return d + } + return &StatefulSetOrdinalsDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *StatefulSetOrdinalsDie) DieFeedPtr(r *appsv1.StatefulSetOrdinals) *StatefulSetOrdinalsDie { + if r == nil { + r = &appsv1.StatefulSetOrdinals{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *StatefulSetOrdinalsDie) DieFeedRawExtension(raw runtime.RawExtension) *StatefulSetOrdinalsDie { + b, _ := json.Marshal(raw) + r := appsv1.StatefulSetOrdinals{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *StatefulSetOrdinalsDie) DieRelease() appsv1.StatefulSetOrdinals { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *StatefulSetOrdinalsDie) DieReleasePtr() *appsv1.StatefulSetOrdinals { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *StatefulSetOrdinalsDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *StatefulSetOrdinalsDie) DieStamp(fn func(r *appsv1.StatefulSetOrdinals)) *StatefulSetOrdinalsDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *StatefulSetOrdinalsDie) DeepCopy() *StatefulSetOrdinalsDie { + r := *d.r.DeepCopy() + return &StatefulSetOrdinalsDie{ + mutable: d.mutable, + r: r, + } +} + +// start is the number representing the first replica's index. It may be used to number replicas from an alternate index (eg: 1-indexed) over the default 0-indexed names, or to orchestrate progressive movement of replicas from one StatefulSet to another. If set, replica indices will be in the range: [.spec.ordinals.start, .spec.ordinals.start + .spec.replicas). If unset, defaults to 0. Replica indices will be in the range: [0, .spec.replicas). +func (d *StatefulSetOrdinalsDie) Start(v int32) *StatefulSetOrdinalsDie { + return d.DieStamp(func(r *appsv1.StatefulSetOrdinals) { + r.Start = v + }) +} + var StatefulSetStatusBlank = (&StatefulSetStatusDie{}).DieFeed(appsv1.StatefulSetStatus{}) type StatefulSetStatusDie struct { diff --git a/apis/apps/v1/zz_generated.die_test.go b/apis/apps/v1/zz_generated.die_test.go index 0585226..7706d0a 100644 --- a/apis/apps/v1/zz_generated.die_test.go +++ b/apis/apps/v1/zz_generated.die_test.go @@ -197,6 +197,15 @@ func TestStatefulSetPersistentVolumeClaimRetentionPolicyDie_MissingMethods(t *te } } +func TestStatefulSetOrdinalsDie_MissingMethods(t *testingx.T) { + die := StatefulSetOrdinalsBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for StatefulSetOrdinalsDie: %s", diff.List()) + } +} + func TestStatefulSetStatusDie_MissingMethods(t *testingx.T) { die := StatefulSetStatusBlank ignore := []string{} diff --git a/apis/autoscaling/v1/zz_generated.die.go b/apis/autoscaling/v1/zz_generated.die.go index 47b5228..dde086c 100644 --- a/apis/autoscaling/v1/zz_generated.die.go +++ b/apis/autoscaling/v1/zz_generated.die.go @@ -408,7 +408,7 @@ func (d *CrossVersionObjectReferenceDie) DeepCopy() *CrossVersionObjectReference } } -// Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" +// Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds func (d *CrossVersionObjectReferenceDie) Kind(v string) *CrossVersionObjectReferenceDie { return d.DieStamp(func(r *autoscalingv1.CrossVersionObjectReference) { r.Kind = v diff --git a/apis/batch/v1/zz_generated.die.go b/apis/batch/v1/zz_generated.die.go index 1f1f36e..18e5219 100644 --- a/apis/batch/v1/zz_generated.die.go +++ b/apis/batch/v1/zz_generated.die.go @@ -1344,7 +1344,7 @@ func (d *JobStatusDie) CompletedIndexes(v string) *JobStatusDie { // // The job controller creates pods with a finalizer. When a pod terminates (succeeded or failed), the controller does three steps to account for it in the job status: (1) Add the pod UID to the arrays in this field. (2) Remove the pod finalizer. (3) Remove the pod UID from the arrays while increasing the corresponding counter. // -// This field is beta-level. The job controller only makes use of this field when the feature gate JobTrackingWithFinalizers is enabled (enabled by default). Old jobs might not be tracked using this field, in which case the field remains null. +// Old jobs might not be tracked using this field, in which case the field remains null. func (d *JobStatusDie) UncountedTerminatedPods(v *batchv1.UncountedTerminatedPods) *JobStatusDie { return d.DieStamp(func(r *batchv1.JobStatus) { r.UncountedTerminatedPods = v diff --git a/apis/core/v1/common.go b/apis/core/v1/common.go index e014a86..9001c3a 100644 --- a/apis/core/v1/common.go +++ b/apis/core/v1/common.go @@ -29,6 +29,9 @@ type _ = corev1.LocalObjectReference // +die type _ = corev1.TypedLocalObjectReference +// +die +type _ = corev1.TypedObjectReference + // +die type _ = corev1.SecretReference diff --git a/apis/core/v1/container.go b/apis/core/v1/container.go index 2c263a5..3fad750 100644 --- a/apis/core/v1/container.go +++ b/apis/core/v1/container.go @@ -288,6 +288,18 @@ func (d *ResourceRequirementsDie) AddRequestString(name corev1.ResourceName, qua return d.AddRequest(name, resource.MustParse(quantity)) } +func (d *ResourceRequirementsDie) ClaimsDie(claims ...*ResourceClaimDie) *ResourceRequirementsDie { + return d.DieStamp(func(r *corev1.ResourceRequirements) { + r.Claims = make([]corev1.ResourceClaim, len(claims)) + for i := range claims { + r.Claims[i] = claims[i].DieRelease() + } + }) +} + +// +die +type _ = corev1.ResourceClaim + // +die type _ = corev1.VolumeMount diff --git a/apis/core/v1/persistantvolumeclaim.go b/apis/core/v1/persistantvolumeclaim.go index f8ecb37..cf2de2a 100644 --- a/apis/core/v1/persistantvolumeclaim.go +++ b/apis/core/v1/persistantvolumeclaim.go @@ -52,9 +52,9 @@ func (d *PersistentVolumeClaimSpecDie) DataSourceDie(fn func(d *TypedLocalObject }) } -func (d *PersistentVolumeClaimSpecDie) DataSourceRefDie(fn func(d *TypedLocalObjectReferenceDie)) *PersistentVolumeClaimSpecDie { +func (d *PersistentVolumeClaimSpecDie) DataSourceRefDie(fn func(d *TypedObjectReferenceDie)) *PersistentVolumeClaimSpecDie { return d.DieStamp(func(r *corev1.PersistentVolumeClaimSpec) { - d := TypedLocalObjectReferenceBlank.DieImmutable(false).DieFeedPtr(r.DataSourceRef) + d := TypedObjectReferenceBlank.DieImmutable(false).DieFeedPtr(r.DataSourceRef) fn(d) r.DataSourceRef = d.DieReleasePtr() }) diff --git a/apis/core/v1/pod.go b/apis/core/v1/pod.go index 70fb8c8..de7c0e2 100644 --- a/apis/core/v1/pod.go +++ b/apis/core/v1/pod.go @@ -168,6 +168,41 @@ func (d *PodSpecDie) OSDie(fn func(d *PodOSDie)) *PodSpecDie { }) } +func (d *PodSpecDie) SchedulingGatesDie(gates ...*PodSchedulingGateDie) *PodSpecDie { + return d.DieStamp(func(r *corev1.PodSpec) { + r.SchedulingGates = make([]corev1.PodSchedulingGate, len(gates)) + for i := range gates { + r.SchedulingGates[i] = gates[i].DieRelease() + } + }) +} + +func (d *PodSpecDie) ResourceClaimsDie(gates ...*PodResourceClaimDie) *PodSpecDie { + return d.DieStamp(func(r *corev1.PodSpec) { + r.ResourceClaims = make([]corev1.PodResourceClaim, len(gates)) + for i := range gates { + r.ResourceClaims[i] = gates[i].DieRelease() + } + }) +} + +// +die +type _ = corev1.PodSchedulingGate + +// +die +type _ = corev1.PodResourceClaim + +func (d *PodResourceClaimDie) SourceDie(fn func(d *ClaimSourceDie)) *PodResourceClaimDie { + return d.DieStamp(func(r *corev1.PodResourceClaim) { + d := ClaimSourceBlank.DieImmutable(false).DieFeed(r.Source) + fn(d) + r.Source = d.DieRelease() + }) +} + +// +die +type _ = corev1.ClaimSource + // +die type _ = corev1.PodSecurityContext diff --git a/apis/core/v1/zz_generated.die.go b/apis/core/v1/zz_generated.die.go index abd2fc3..9096a52 100644 --- a/apis/core/v1/zz_generated.die.go +++ b/apis/core/v1/zz_generated.die.go @@ -519,6 +519,118 @@ func (d *TypedLocalObjectReferenceDie) Name(v string) *TypedLocalObjectReference }) } +var TypedObjectReferenceBlank = (&TypedObjectReferenceDie{}).DieFeed(corev1.TypedObjectReference{}) + +type TypedObjectReferenceDie struct { + mutable bool + r corev1.TypedObjectReference +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *TypedObjectReferenceDie) DieImmutable(immutable bool) *TypedObjectReferenceDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *TypedObjectReferenceDie) DieFeed(r corev1.TypedObjectReference) *TypedObjectReferenceDie { + if d.mutable { + d.r = r + return d + } + return &TypedObjectReferenceDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *TypedObjectReferenceDie) DieFeedPtr(r *corev1.TypedObjectReference) *TypedObjectReferenceDie { + if r == nil { + r = &corev1.TypedObjectReference{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *TypedObjectReferenceDie) DieFeedRawExtension(raw runtime.RawExtension) *TypedObjectReferenceDie { + b, _ := json.Marshal(raw) + r := corev1.TypedObjectReference{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *TypedObjectReferenceDie) DieRelease() corev1.TypedObjectReference { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *TypedObjectReferenceDie) DieReleasePtr() *corev1.TypedObjectReference { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *TypedObjectReferenceDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *TypedObjectReferenceDie) DieStamp(fn func(r *corev1.TypedObjectReference)) *TypedObjectReferenceDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *TypedObjectReferenceDie) DeepCopy() *TypedObjectReferenceDie { + r := *d.r.DeepCopy() + return &TypedObjectReferenceDie{ + mutable: d.mutable, + r: r, + } +} + +// APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. +func (d *TypedObjectReferenceDie) APIGroup(v *string) *TypedObjectReferenceDie { + return d.DieStamp(func(r *corev1.TypedObjectReference) { + r.APIGroup = v + }) +} + +// Kind is the type of resource being referenced +func (d *TypedObjectReferenceDie) Kind(v string) *TypedObjectReferenceDie { + return d.DieStamp(func(r *corev1.TypedObjectReference) { + r.Kind = v + }) +} + +// Name is the name of resource being referenced +func (d *TypedObjectReferenceDie) Name(v string) *TypedObjectReferenceDie { + return d.DieStamp(func(r *corev1.TypedObjectReference) { + r.Name = v + }) +} + +// Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled. +func (d *TypedObjectReferenceDie) Namespace(v *string) *TypedObjectReferenceDie { + return d.DieStamp(func(r *corev1.TypedObjectReference) { + r.Namespace = v + }) +} + var SecretReferenceBlank = (&SecretReferenceDie{}).DieFeed(corev1.SecretReference{}) type SecretReferenceDie struct { @@ -2502,6 +2614,108 @@ func (d *ResourceRequirementsDie) Requests(v corev1.ResourceList) *ResourceRequi }) } +// Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. +// +// This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. +// +// This field is immutable. +func (d *ResourceRequirementsDie) Claims(v ...corev1.ResourceClaim) *ResourceRequirementsDie { + return d.DieStamp(func(r *corev1.ResourceRequirements) { + r.Claims = v + }) +} + +var ResourceClaimBlank = (&ResourceClaimDie{}).DieFeed(corev1.ResourceClaim{}) + +type ResourceClaimDie struct { + mutable bool + r corev1.ResourceClaim +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *ResourceClaimDie) DieImmutable(immutable bool) *ResourceClaimDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *ResourceClaimDie) DieFeed(r corev1.ResourceClaim) *ResourceClaimDie { + if d.mutable { + d.r = r + return d + } + return &ResourceClaimDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *ResourceClaimDie) DieFeedPtr(r *corev1.ResourceClaim) *ResourceClaimDie { + if r == nil { + r = &corev1.ResourceClaim{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *ResourceClaimDie) DieFeedRawExtension(raw runtime.RawExtension) *ResourceClaimDie { + b, _ := json.Marshal(raw) + r := corev1.ResourceClaim{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *ResourceClaimDie) DieRelease() corev1.ResourceClaim { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *ResourceClaimDie) DieReleasePtr() *corev1.ResourceClaim { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *ResourceClaimDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *ResourceClaimDie) DieStamp(fn func(r *corev1.ResourceClaim)) *ResourceClaimDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *ResourceClaimDie) DeepCopy() *ResourceClaimDie { + r := *d.r.DeepCopy() + return &ResourceClaimDie{ + mutable: d.mutable, + r: r, + } +} + +// Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container. +func (d *ResourceClaimDie) Name(v string) *ResourceClaimDie { + return d.DieStamp(func(r *corev1.ResourceClaim) { + r.Name = v + }) +} + var VolumeMountBlank = (&VolumeMountDie{}).DieFeed(corev1.VolumeMount{}) type VolumeMountDie struct { @@ -6840,7 +7054,7 @@ func (d *NodeSpecDie) Taints(v ...corev1.Taint) *NodeSpecDie { }) } -// Deprecated: Previously used to specify the source of the node's configuration for the DynamicKubeletConfig feature. This feature is removed from Kubelets as of 1.24 and will be fully removed in 1.26. +// Deprecated: Previously used to specify the source of the node's configuration for the DynamicKubeletConfig feature. This feature is removed. func (d *NodeSpecDie) ConfigSource(v *corev1.NodeConfigSource) *NodeSpecDie { return d.DieStamp(func(r *corev1.NodeSpec) { r.ConfigSource = v @@ -7288,7 +7502,7 @@ func (d *NodeStatusDie) Conditions(v ...corev1.NodeCondition) *NodeStatusDie { }) } -// List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/concepts/nodes/node/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See http://pr.k8s.io/79391 for an example. +// List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/concepts/nodes/node/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See https://pr.k8s.io/79391 for an example. func (d *NodeStatusDie) Addresses(v ...corev1.NodeAddress) *NodeStatusDie { return d.DieStamp(func(r *corev1.NodeStatus) { r.Addresses = v @@ -10609,15 +10823,15 @@ func (d *PersistentVolumeClaimSpecDie) VolumeMode(v *corev1.PersistentVolumeMode }) } -// dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field. +// dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource. func (d *PersistentVolumeClaimSpecDie) DataSource(v *corev1.TypedLocalObjectReference) *PersistentVolumeClaimSpecDie { return d.DieStamp(func(r *corev1.PersistentVolumeClaimSpec) { r.DataSource = v }) } -// dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. -func (d *PersistentVolumeClaimSpecDie) DataSourceRef(v *corev1.TypedLocalObjectReference) *PersistentVolumeClaimSpecDie { +// dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn't specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn't set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While dataSource ignores disallowed values (dropping them), dataSourceRef preserves all values, and generates an error if a disallowed value is specified. * While dataSource only allows local objects, dataSourceRef allows objects in any namespaces. (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled. +func (d *PersistentVolumeClaimSpecDie) DataSourceRef(v *corev1.TypedObjectReference) *PersistentVolumeClaimSpecDie { return d.DieStamp(func(r *corev1.PersistentVolumeClaimSpec) { r.DataSourceRef = v }) @@ -11374,6 +11588,319 @@ func (d *PodSpecDie) HostUsers(v *bool) *PodSpecDie { }) } +// SchedulingGates is an opaque list of values that if specified will block scheduling the pod. More info: https://git.k8s.io/enhancements/keps/sig-scheduling/3521-pod-scheduling-readiness. +// +// This is an alpha-level feature enabled by PodSchedulingReadiness feature gate. +func (d *PodSpecDie) SchedulingGates(v ...corev1.PodSchedulingGate) *PodSpecDie { + return d.DieStamp(func(r *corev1.PodSpec) { + r.SchedulingGates = v + }) +} + +// ResourceClaims defines which ResourceClaims must be allocated and reserved before the Pod is allowed to start. The resources will be made available to those containers which consume them by name. +// +// This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. +// +// This field is immutable. +func (d *PodSpecDie) ResourceClaims(v ...corev1.PodResourceClaim) *PodSpecDie { + return d.DieStamp(func(r *corev1.PodSpec) { + r.ResourceClaims = v + }) +} + +var PodSchedulingGateBlank = (&PodSchedulingGateDie{}).DieFeed(corev1.PodSchedulingGate{}) + +type PodSchedulingGateDie struct { + mutable bool + r corev1.PodSchedulingGate +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *PodSchedulingGateDie) DieImmutable(immutable bool) *PodSchedulingGateDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *PodSchedulingGateDie) DieFeed(r corev1.PodSchedulingGate) *PodSchedulingGateDie { + if d.mutable { + d.r = r + return d + } + return &PodSchedulingGateDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *PodSchedulingGateDie) DieFeedPtr(r *corev1.PodSchedulingGate) *PodSchedulingGateDie { + if r == nil { + r = &corev1.PodSchedulingGate{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *PodSchedulingGateDie) DieFeedRawExtension(raw runtime.RawExtension) *PodSchedulingGateDie { + b, _ := json.Marshal(raw) + r := corev1.PodSchedulingGate{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *PodSchedulingGateDie) DieRelease() corev1.PodSchedulingGate { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *PodSchedulingGateDie) DieReleasePtr() *corev1.PodSchedulingGate { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *PodSchedulingGateDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *PodSchedulingGateDie) DieStamp(fn func(r *corev1.PodSchedulingGate)) *PodSchedulingGateDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *PodSchedulingGateDie) DeepCopy() *PodSchedulingGateDie { + r := *d.r.DeepCopy() + return &PodSchedulingGateDie{ + mutable: d.mutable, + r: r, + } +} + +// Name of the scheduling gate. Each scheduling gate must have a unique name field. +func (d *PodSchedulingGateDie) Name(v string) *PodSchedulingGateDie { + return d.DieStamp(func(r *corev1.PodSchedulingGate) { + r.Name = v + }) +} + +var PodResourceClaimBlank = (&PodResourceClaimDie{}).DieFeed(corev1.PodResourceClaim{}) + +type PodResourceClaimDie struct { + mutable bool + r corev1.PodResourceClaim +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *PodResourceClaimDie) DieImmutable(immutable bool) *PodResourceClaimDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *PodResourceClaimDie) DieFeed(r corev1.PodResourceClaim) *PodResourceClaimDie { + if d.mutable { + d.r = r + return d + } + return &PodResourceClaimDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *PodResourceClaimDie) DieFeedPtr(r *corev1.PodResourceClaim) *PodResourceClaimDie { + if r == nil { + r = &corev1.PodResourceClaim{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *PodResourceClaimDie) DieFeedRawExtension(raw runtime.RawExtension) *PodResourceClaimDie { + b, _ := json.Marshal(raw) + r := corev1.PodResourceClaim{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *PodResourceClaimDie) DieRelease() corev1.PodResourceClaim { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *PodResourceClaimDie) DieReleasePtr() *corev1.PodResourceClaim { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *PodResourceClaimDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *PodResourceClaimDie) DieStamp(fn func(r *corev1.PodResourceClaim)) *PodResourceClaimDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *PodResourceClaimDie) DeepCopy() *PodResourceClaimDie { + r := *d.r.DeepCopy() + return &PodResourceClaimDie{ + mutable: d.mutable, + r: r, + } +} + +// Name uniquely identifies this resource claim inside the pod. This must be a DNS_LABEL. +func (d *PodResourceClaimDie) Name(v string) *PodResourceClaimDie { + return d.DieStamp(func(r *corev1.PodResourceClaim) { + r.Name = v + }) +} + +// Source describes where to find the ResourceClaim. +func (d *PodResourceClaimDie) Source(v corev1.ClaimSource) *PodResourceClaimDie { + return d.DieStamp(func(r *corev1.PodResourceClaim) { + r.Source = v + }) +} + +var ClaimSourceBlank = (&ClaimSourceDie{}).DieFeed(corev1.ClaimSource{}) + +type ClaimSourceDie struct { + mutable bool + r corev1.ClaimSource +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *ClaimSourceDie) DieImmutable(immutable bool) *ClaimSourceDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *ClaimSourceDie) DieFeed(r corev1.ClaimSource) *ClaimSourceDie { + if d.mutable { + d.r = r + return d + } + return &ClaimSourceDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *ClaimSourceDie) DieFeedPtr(r *corev1.ClaimSource) *ClaimSourceDie { + if r == nil { + r = &corev1.ClaimSource{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *ClaimSourceDie) DieFeedRawExtension(raw runtime.RawExtension) *ClaimSourceDie { + b, _ := json.Marshal(raw) + r := corev1.ClaimSource{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *ClaimSourceDie) DieRelease() corev1.ClaimSource { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *ClaimSourceDie) DieReleasePtr() *corev1.ClaimSource { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *ClaimSourceDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *ClaimSourceDie) DieStamp(fn func(r *corev1.ClaimSource)) *ClaimSourceDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *ClaimSourceDie) DeepCopy() *ClaimSourceDie { + r := *d.r.DeepCopy() + return &ClaimSourceDie{ + mutable: d.mutable, + r: r, + } +} + +// ResourceClaimName is the name of a ResourceClaim object in the same namespace as this pod. +func (d *ClaimSourceDie) ResourceClaimName(v *string) *ClaimSourceDie { + return d.DieStamp(func(r *corev1.ClaimSource) { + r.ResourceClaimName = v + }) +} + +// ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this pod. +// +// The template will be used to create a new ResourceClaim, which will be bound to this pod. When this pod is deleted, the ResourceClaim will also be deleted. The name of the ResourceClaim will be -, where is the PodResourceClaim.Name. Pod validation will reject the pod if the concatenated name is not valid for a ResourceClaim (e.g. too long). +// +// An existing ResourceClaim with that name that is not owned by the pod will not be used for the pod to avoid using an unrelated resource by mistake. Scheduling and pod startup are then blocked until the unrelated ResourceClaim is removed. +// +// This field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim. +func (d *ClaimSourceDie) ResourceClaimTemplateName(v *string) *ClaimSourceDie { + return d.DieStamp(func(r *corev1.ClaimSource) { + r.ResourceClaimTemplateName = v + }) +} + var PodSecurityContextBlank = (&PodSecurityContextDie{}).DieFeed(corev1.PodSecurityContext{}) type PodSecurityContextDie struct { @@ -11493,7 +12020,7 @@ func (d *PodSecurityContextDie) RunAsNonRoot(v *bool) *PodSecurityContextDie { }) } -// A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows. +// A list of groups applied to the first process run in each container, in addition to the container's primary GID, the fsGroup (if specified), and group memberships defined in the container image for the uid of the container process. If unspecified, no additional groups are added to any container. Note that group memberships defined in the container image for the uid of the container process are still effective, even if they are not included in this list. Note that this field cannot be set when spec.os.name is windows. func (d *PodSecurityContextDie) SupplementalGroups(v ...int64) *PodSecurityContextDie { return d.DieStamp(func(r *corev1.PodSecurityContext) { r.SupplementalGroups = v @@ -12265,7 +12792,7 @@ func (d *TopologySpreadConstraintDie) MinDomains(v *int32) *TopologySpreadConstr // NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. // -// If this value is nil, the behavior is equivalent to the Honor policy. This is a alpha-level feature enabled by the NodeInclusionPolicyInPodTopologySpread feature flag. +// If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag. func (d *TopologySpreadConstraintDie) NodeAffinityPolicy(v *corev1.NodeInclusionPolicy) *TopologySpreadConstraintDie { return d.DieStamp(func(r *corev1.TopologySpreadConstraint) { r.NodeAffinityPolicy = v @@ -12274,7 +12801,7 @@ func (d *TopologySpreadConstraintDie) NodeAffinityPolicy(v *corev1.NodeInclusion // NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. // -// If this value is nil, the behavior is equivalent to the Ignore policy. This is a alpha-level feature enabled by the NodeInclusionPolicyInPodTopologySpread feature flag. +// If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag. func (d *TopologySpreadConstraintDie) NodeTaintsPolicy(v *corev1.NodeInclusionPolicy) *TopologySpreadConstraintDie { return d.DieStamp(func(r *corev1.TopologySpreadConstraint) { r.NodeTaintsPolicy = v @@ -13187,7 +13714,7 @@ func (d *ReplicationControllerStatusDie) DeepCopy() *ReplicationControllerStatus } } -// Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller +// Replicas is the most recently observed number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller func (d *ReplicationControllerStatusDie) Replicas(v int32) *ReplicationControllerStatusDie { return d.DieStamp(func(r *corev1.ReplicationControllerStatus) { r.Replicas = v diff --git a/apis/core/v1/zz_generated.die_test.go b/apis/core/v1/zz_generated.die_test.go index ccf52bc..79caa5a 100644 --- a/apis/core/v1/zz_generated.die_test.go +++ b/apis/core/v1/zz_generated.die_test.go @@ -62,6 +62,15 @@ func TestTypedLocalObjectReferenceDie_MissingMethods(t *testingx.T) { } } +func TestTypedObjectReferenceDie_MissingMethods(t *testingx.T) { + die := TypedObjectReferenceBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for TypedObjectReferenceDie: %s", diff.List()) + } +} + func TestSecretReferenceDie_MissingMethods(t *testingx.T) { die := SecretReferenceBlank ignore := []string{} @@ -215,6 +224,15 @@ func TestResourceRequirementsDie_MissingMethods(t *testingx.T) { } } +func TestResourceClaimDie_MissingMethods(t *testingx.T) { + die := ResourceClaimBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for ResourceClaimDie: %s", diff.List()) + } +} + func TestVolumeMountDie_MissingMethods(t *testingx.T) { die := VolumeMountBlank ignore := []string{} @@ -854,6 +872,33 @@ func TestPodSpecDie_MissingMethods(t *testingx.T) { } } +func TestPodSchedulingGateDie_MissingMethods(t *testingx.T) { + die := PodSchedulingGateBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for PodSchedulingGateDie: %s", diff.List()) + } +} + +func TestPodResourceClaimDie_MissingMethods(t *testingx.T) { + die := PodResourceClaimBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for PodResourceClaimDie: %s", diff.List()) + } +} + +func TestClaimSourceDie_MissingMethods(t *testingx.T) { + die := ClaimSourceBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for ClaimSourceDie: %s", diff.List()) + } +} + func TestPodSecurityContextDie_MissingMethods(t *testingx.T) { die := PodSecurityContextBlank ignore := []string{} diff --git a/apis/networking/v1/ingress.go b/apis/networking/v1/ingress.go index 646d541..c10ff27 100644 --- a/apis/networking/v1/ingress.go +++ b/apis/networking/v1/ingress.go @@ -126,10 +126,37 @@ func (d *HTTPIngressPathDie) BackendDie(fn func(d *IngressBackendDie)) *HTTPIngr // +die type IngressStatus = networkingv1.IngressStatus -func (d *IngressStatusDie) LoadBalancerDie(fn func(d *diecorev1.LoadBalancerStatusDie)) *IngressStatusDie { +func (d *IngressStatusDie) LoadBalancerDie(fn func(d *IngressLoadBalancerStatusDie)) *IngressStatusDie { return d.DieStamp(func(r *networkingv1.IngressStatus) { - d := diecorev1.LoadBalancerStatusBlank.DieImmutable(false).DieFeed(r.LoadBalancer) + d := IngressLoadBalancerStatusBlank.DieImmutable(false).DieFeed(r.LoadBalancer) fn(d) r.LoadBalancer = d.DieRelease() }) } + +// +die +type IngressLoadBalancerStatus = networkingv1.IngressLoadBalancerStatus + +func (d *IngressLoadBalancerStatusDie) IngressDie(ingress ...*IngressLoadBalancerIngressDie) *IngressLoadBalancerStatusDie { + return d.DieStamp(func(r *networkingv1.IngressLoadBalancerStatus) { + r.Ingress = make([]networkingv1.IngressLoadBalancerIngress, len(ingress)) + for i := range ingress { + r.Ingress[i] = ingress[i].DieRelease() + } + }) +} + +// +die +type IngressLoadBalancerIngress = networkingv1.IngressLoadBalancerIngress + +func (d *IngressLoadBalancerIngressDie) PortsDie(ports ...*IngressPortStatusDie) *IngressLoadBalancerIngressDie { + return d.DieStamp(func(r *networkingv1.IngressLoadBalancerIngress) { + r.Ports = make([]networkingv1.IngressPortStatus, len(ports)) + for i := range ports { + r.Ports[i] = ports[i].DieRelease() + } + }) +} + +// +die +type IngressPortStatus = networkingv1.IngressPortStatus diff --git a/apis/networking/v1/zz_generated.die.go b/apis/networking/v1/zz_generated.die.go index a2bbb90..a0104ca 100644 --- a/apis/networking/v1/zz_generated.die.go +++ b/apis/networking/v1/zz_generated.die.go @@ -1099,12 +1099,313 @@ func (d *IngressStatusDie) DeepCopy() *IngressStatusDie { } // LoadBalancer contains the current status of the load-balancer. -func (d *IngressStatusDie) LoadBalancer(v corev1.LoadBalancerStatus) *IngressStatusDie { +func (d *IngressStatusDie) LoadBalancer(v networkingv1.IngressLoadBalancerStatus) *IngressStatusDie { return d.DieStamp(func(r *networkingv1.IngressStatus) { r.LoadBalancer = v }) } +var IngressLoadBalancerStatusBlank = (&IngressLoadBalancerStatusDie{}).DieFeed(networkingv1.IngressLoadBalancerStatus{}) + +type IngressLoadBalancerStatusDie struct { + mutable bool + r networkingv1.IngressLoadBalancerStatus +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *IngressLoadBalancerStatusDie) DieImmutable(immutable bool) *IngressLoadBalancerStatusDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *IngressLoadBalancerStatusDie) DieFeed(r networkingv1.IngressLoadBalancerStatus) *IngressLoadBalancerStatusDie { + if d.mutable { + d.r = r + return d + } + return &IngressLoadBalancerStatusDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *IngressLoadBalancerStatusDie) DieFeedPtr(r *networkingv1.IngressLoadBalancerStatus) *IngressLoadBalancerStatusDie { + if r == nil { + r = &networkingv1.IngressLoadBalancerStatus{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *IngressLoadBalancerStatusDie) DieFeedRawExtension(raw runtime.RawExtension) *IngressLoadBalancerStatusDie { + b, _ := json.Marshal(raw) + r := networkingv1.IngressLoadBalancerStatus{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *IngressLoadBalancerStatusDie) DieRelease() networkingv1.IngressLoadBalancerStatus { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *IngressLoadBalancerStatusDie) DieReleasePtr() *networkingv1.IngressLoadBalancerStatus { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *IngressLoadBalancerStatusDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *IngressLoadBalancerStatusDie) DieStamp(fn func(r *networkingv1.IngressLoadBalancerStatus)) *IngressLoadBalancerStatusDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *IngressLoadBalancerStatusDie) DeepCopy() *IngressLoadBalancerStatusDie { + r := *d.r.DeepCopy() + return &IngressLoadBalancerStatusDie{ + mutable: d.mutable, + r: r, + } +} + +// Ingress is a list containing ingress points for the load-balancer. +func (d *IngressLoadBalancerStatusDie) Ingress(v ...networkingv1.IngressLoadBalancerIngress) *IngressLoadBalancerStatusDie { + return d.DieStamp(func(r *networkingv1.IngressLoadBalancerStatus) { + r.Ingress = v + }) +} + +var IngressLoadBalancerIngressBlank = (&IngressLoadBalancerIngressDie{}).DieFeed(networkingv1.IngressLoadBalancerIngress{}) + +type IngressLoadBalancerIngressDie struct { + mutable bool + r networkingv1.IngressLoadBalancerIngress +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *IngressLoadBalancerIngressDie) DieImmutable(immutable bool) *IngressLoadBalancerIngressDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *IngressLoadBalancerIngressDie) DieFeed(r networkingv1.IngressLoadBalancerIngress) *IngressLoadBalancerIngressDie { + if d.mutable { + d.r = r + return d + } + return &IngressLoadBalancerIngressDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *IngressLoadBalancerIngressDie) DieFeedPtr(r *networkingv1.IngressLoadBalancerIngress) *IngressLoadBalancerIngressDie { + if r == nil { + r = &networkingv1.IngressLoadBalancerIngress{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *IngressLoadBalancerIngressDie) DieFeedRawExtension(raw runtime.RawExtension) *IngressLoadBalancerIngressDie { + b, _ := json.Marshal(raw) + r := networkingv1.IngressLoadBalancerIngress{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *IngressLoadBalancerIngressDie) DieRelease() networkingv1.IngressLoadBalancerIngress { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *IngressLoadBalancerIngressDie) DieReleasePtr() *networkingv1.IngressLoadBalancerIngress { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *IngressLoadBalancerIngressDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *IngressLoadBalancerIngressDie) DieStamp(fn func(r *networkingv1.IngressLoadBalancerIngress)) *IngressLoadBalancerIngressDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *IngressLoadBalancerIngressDie) DeepCopy() *IngressLoadBalancerIngressDie { + r := *d.r.DeepCopy() + return &IngressLoadBalancerIngressDie{ + mutable: d.mutable, + r: r, + } +} + +// IP is set for load-balancer ingress points that are IP based. +func (d *IngressLoadBalancerIngressDie) IP(v string) *IngressLoadBalancerIngressDie { + return d.DieStamp(func(r *networkingv1.IngressLoadBalancerIngress) { + r.IP = v + }) +} + +// Hostname is set for load-balancer ingress points that are DNS based. +func (d *IngressLoadBalancerIngressDie) Hostname(v string) *IngressLoadBalancerIngressDie { + return d.DieStamp(func(r *networkingv1.IngressLoadBalancerIngress) { + r.Hostname = v + }) +} + +// Ports provides information about the ports exposed by this LoadBalancer. +func (d *IngressLoadBalancerIngressDie) Ports(v ...networkingv1.IngressPortStatus) *IngressLoadBalancerIngressDie { + return d.DieStamp(func(r *networkingv1.IngressLoadBalancerIngress) { + r.Ports = v + }) +} + +var IngressPortStatusBlank = (&IngressPortStatusDie{}).DieFeed(networkingv1.IngressPortStatus{}) + +type IngressPortStatusDie struct { + mutable bool + r networkingv1.IngressPortStatus +} + +// DieImmutable returns a new die for the current die's state that is either mutable (`false`) or immutable (`true`). +func (d *IngressPortStatusDie) DieImmutable(immutable bool) *IngressPortStatusDie { + if d.mutable == !immutable { + return d + } + d = d.DeepCopy() + d.mutable = !immutable + return d +} + +// DieFeed returns a new die with the provided resource. +func (d *IngressPortStatusDie) DieFeed(r networkingv1.IngressPortStatus) *IngressPortStatusDie { + if d.mutable { + d.r = r + return d + } + return &IngressPortStatusDie{ + mutable: d.mutable, + r: r, + } +} + +// DieFeedPtr returns a new die with the provided resource pointer. If the resource is nil, the empty value is used instead. +func (d *IngressPortStatusDie) DieFeedPtr(r *networkingv1.IngressPortStatus) *IngressPortStatusDie { + if r == nil { + r = &networkingv1.IngressPortStatus{} + } + return d.DieFeed(*r) +} + +// DieFeedRawExtension returns the resource managed by the die as an raw extension. +func (d *IngressPortStatusDie) DieFeedRawExtension(raw runtime.RawExtension) *IngressPortStatusDie { + b, _ := json.Marshal(raw) + r := networkingv1.IngressPortStatus{} + _ = json.Unmarshal(b, &r) + return d.DieFeed(r) +} + +// DieRelease returns the resource managed by the die. +func (d *IngressPortStatusDie) DieRelease() networkingv1.IngressPortStatus { + if d.mutable { + return d.r + } + return *d.r.DeepCopy() +} + +// DieReleasePtr returns a pointer to the resource managed by the die. +func (d *IngressPortStatusDie) DieReleasePtr() *networkingv1.IngressPortStatus { + r := d.DieRelease() + return &r +} + +// DieReleaseRawExtension returns the resource managed by the die as an raw extension. +func (d *IngressPortStatusDie) DieReleaseRawExtension() runtime.RawExtension { + r := d.DieReleasePtr() + b, _ := json.Marshal(r) + raw := runtime.RawExtension{} + _ = json.Unmarshal(b, &raw) + return raw +} + +// DieStamp returns a new die with the resource passed to the callback function. The resource is mutable. +func (d *IngressPortStatusDie) DieStamp(fn func(r *networkingv1.IngressPortStatus)) *IngressPortStatusDie { + r := d.DieRelease() + fn(&r) + return d.DieFeed(r) +} + +// DeepCopy returns a new die with equivalent state. Useful for snapshotting a mutable die. +func (d *IngressPortStatusDie) DeepCopy() *IngressPortStatusDie { + r := *d.r.DeepCopy() + return &IngressPortStatusDie{ + mutable: d.mutable, + r: r, + } +} + +// Port is the port number of the ingress port. +func (d *IngressPortStatusDie) Port(v int32) *IngressPortStatusDie { + return d.DieStamp(func(r *networkingv1.IngressPortStatus) { + r.Port = v + }) +} + +// Protocol is the protocol of the ingress port. The supported values are: "TCP", "UDP", "SCTP" +func (d *IngressPortStatusDie) Protocol(v corev1.Protocol) *IngressPortStatusDie { + return d.DieStamp(func(r *networkingv1.IngressPortStatus) { + r.Protocol = v + }) +} + +// Error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use CamelCase names - cloud provider specific error values must have names that comply with the format foo.example.com/CamelCase. --- The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt) +func (d *IngressPortStatusDie) Error(v *string) *IngressPortStatusDie { + return d.DieStamp(func(r *networkingv1.IngressPortStatus) { + r.Error = v + }) +} + var IngressClassBlank = (&IngressClassDie{}).DieFeed(networkingv1.IngressClass{}) type IngressClassDie struct { @@ -2286,14 +2587,14 @@ func (d *IPBlockDie) DeepCopy() *IPBlockDie { } } -// CIDR is a string representing the IP Block Valid examples are "192.168.1.1/24" or "2001:db9::/64" +// CIDR is a string representing the IP Block Valid examples are "192.168.1.0/24" or "2001:db8::/64" func (d *IPBlockDie) CIDR(v string) *IPBlockDie { return d.DieStamp(func(r *networkingv1.IPBlock) { r.CIDR = v }) } -// Except is a slice of CIDRs that should not be included within an IP Block Valid examples are "192.168.1.1/24" or "2001:db9::/64" Except values will be rejected if they are outside the CIDR range +// Except is a slice of CIDRs that should not be included within an IP Block Valid examples are "192.168.1.0/24" or "2001:db8::/64" Except values will be rejected if they are outside the CIDR range func (d *IPBlockDie) Except(v ...string) *IPBlockDie { return d.DieStamp(func(r *networkingv1.IPBlock) { r.Except = v diff --git a/apis/networking/v1/zz_generated.die_test.go b/apis/networking/v1/zz_generated.die_test.go index eb7138e..c0638d6 100644 --- a/apis/networking/v1/zz_generated.die_test.go +++ b/apis/networking/v1/zz_generated.die_test.go @@ -116,6 +116,33 @@ func TestIngressStatusDie_MissingMethods(t *testingx.T) { } } +func TestIngressLoadBalancerStatusDie_MissingMethods(t *testingx.T) { + die := IngressLoadBalancerStatusBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for IngressLoadBalancerStatusDie: %s", diff.List()) + } +} + +func TestIngressLoadBalancerIngressDie_MissingMethods(t *testingx.T) { + die := IngressLoadBalancerIngressBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for IngressLoadBalancerIngressDie: %s", diff.List()) + } +} + +func TestIngressPortStatusDie_MissingMethods(t *testingx.T) { + die := IngressPortStatusBlank + ignore := []string{} + diff := testing.DieFieldDiff(die).Delete(ignore...) + if diff.Len() != 0 { + t.Errorf("found missing fields for IngressPortStatusDie: %s", diff.List()) + } +} + func TestIngressClassDie_MissingMethods(t *testingx.T) { die := IngressClassBlank ignore := []string{"TypeMeta", "ObjectMeta"} diff --git a/apis/policy/v1/zz_generated.die.go b/apis/policy/v1/zz_generated.die.go index 4c351a4..4f00d85 100644 --- a/apis/policy/v1/zz_generated.die.go +++ b/apis/policy/v1/zz_generated.die.go @@ -346,6 +346,23 @@ func (d *PodDisruptionBudgetSpecDie) MaxUnavailableString(s string) *PodDisrupti }) } +// UnhealthyPodEvictionPolicy defines the criteria for when unhealthy pods should be considered for eviction. Current implementation considers healthy pods, as pods that have status.conditions item with type="Ready",status="True". +// +// Valid policies are IfHealthyBudget and AlwaysAllow. If no policy is specified, the default behavior will be used, which corresponds to the IfHealthyBudget policy. +// +// IfHealthyBudget policy means that running pods (status.phase="Running"), but not yet healthy can be evicted only if the guarded application is not disrupted (status.currentHealthy is at least equal to status.desiredHealthy). Healthy pods will be subject to the PDB for eviction. +// +// AlwaysAllow policy means that all running pods (status.phase="Running"), but not yet healthy are considered disrupted and can be evicted regardless of whether the criteria in a PDB is met. This means perspective running pods of a disrupted application might not get a chance to become healthy. Healthy pods will be subject to the PDB for eviction. +// +// Additional policies may be added in the future. Clients making eviction decisions should disallow eviction of unhealthy pods if they encounter an unrecognized policy in this field. +// +// This field is alpha-level. The eviction API uses this field when the feature gate PDBUnhealthyPodEvictionPolicy is enabled (disabled by default). +func (d *PodDisruptionBudgetSpecDie) UnhealthyPodEvictionPolicy(v *policyv1.UnhealthyPodEvictionPolicyType) *PodDisruptionBudgetSpecDie { + return d.DieStamp(func(r *policyv1.PodDisruptionBudgetSpec) { + r.UnhealthyPodEvictionPolicy = v + }) +} + var PodDisruptionBudgetStatusBlank = (&PodDisruptionBudgetStatusDie{}).DieFeed(policyv1.PodDisruptionBudgetStatus{}) type PodDisruptionBudgetStatusDie struct { diff --git a/diegen/go.mod b/diegen/go.mod index 50c5a9a..059e579 100644 --- a/diegen/go.mod +++ b/diegen/go.mod @@ -3,15 +3,15 @@ module dies.dev/diegen go 1.19 require ( - k8s.io/apimachinery v0.25.4 + k8s.io/apimachinery v0.26.0 sigs.k8s.io/controller-tools v0.8.0 ) require ( - github.com/google/go-cmp v0.5.9 // indirect - golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect - golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f // indirect - golang.org/x/tools v0.1.12 // indirect + github.com/fsnotify/fsnotify v1.6.0 // indirect + golang.org/x/mod v0.6.0 // indirect + golang.org/x/sys v0.3.0 // indirect + golang.org/x/tools v0.2.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect sigs.k8s.io/yaml v1.3.0 // indirect ) diff --git a/diegen/go.sum b/diegen/go.sum index 0d06d67..49e41f8 100644 --- a/diegen/go.sum +++ b/diegen/go.sum @@ -1,28 +1,29 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= +github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= -github.com/onsi/gomega v1.20.1 h1:PA/3qinGoukvymdIDV8pii6tiZgC8kbmJO6Z5+b002Q= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b h1:PxfKdU9lEEDYjdIzOtC4qFWgkU2rGHdKlKowJSMN9h0= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f h1:v4INt8xihDGvnrfjMDVXGxw9wrfxYyCjk0KbXjhR55s= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= -golang.org/x/tools v0.1.12 h1:VveCTK38A2rkS8ZqFY25HIDFscX5X9OoEhJd3quQmXU= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +github.com/onsi/gomega v1.23.0 h1:/oxKu9c2HVap+F3PfKort2Hw5DEU+HGlW8n+tguWsys= +golang.org/x/mod v0.6.0 h1:b9gGHsz9/HhJ3HF5DHQytPpuwocVTChQJK3AvoLRD5I= +golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI= +golang.org/x/net v0.3.1-0.20221206200815-1e63c2f08a10 h1:Frnccbp+ok2GkUS2tC84yAq/U9Vg+0sIO7aRL3T4Xnc= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ= +golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM= +golang.org/x/tools v0.2.0 h1:G6AHpWxTMGY1KyEYoAQ5WTtIekUUvDNjan3ugu60JvE= +golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -k8s.io/apimachinery v0.25.4 h1:CtXsuaitMESSu339tfhVXhQrPET+EiWnIY1rcurKnAc= +k8s.io/apimachinery v0.26.0 h1:1feANjElT7MvPqp0JT6F3Ss6TWDwmcjLypwoPpEf7zg= +k8s.io/apimachinery v0.26.0/go.mod h1:tnPmbONNJ7ByJNz9+n9kMjNP8ON+1qoAIIC70lztu74= sigs.k8s.io/controller-tools v0.8.0 h1:uUkfTGEwrguqYYfcI2RRGUnC8mYdCFDqfwPKUcNJh1o= sigs.k8s.io/controller-tools v0.8.0/go.mod h1:qE2DXhVOiEq5ijmINcFbqi9GZrrUjzB1TuJU0xa6eoY= sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= diff --git a/go.mod b/go.mod index 1f77236..c7037af 100644 --- a/go.mod +++ b/go.mod @@ -4,11 +4,11 @@ go 1.19 require ( github.com/google/go-cmp v0.5.9 - k8s.io/api v0.25.4 - k8s.io/apiextensions-apiserver v0.25.4 - k8s.io/apimachinery v0.25.4 - k8s.io/kube-aggregator v0.25.4 - k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed + k8s.io/api v0.26.0 + k8s.io/apiextensions-apiserver v0.26.0 + k8s.io/apimachinery v0.26.0 + k8s.io/kube-aggregator v0.26.0 + k8s.io/utils v0.0.0-20221107191617-1a15be271d1d ) require ( @@ -18,12 +18,11 @@ require ( github.com/json-iterator/go v1.1.12 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect - golang.org/x/net v0.0.0-20220722155237-a158d28d115b // indirect - golang.org/x/text v0.3.7 // indirect + golang.org/x/net v0.3.1-0.20221206200815-1e63c2f08a10 // indirect + golang.org/x/text v0.5.0 // indirect gopkg.in/inf.v0 v0.9.1 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect - k8s.io/klog/v2 v2.70.1 // indirect + k8s.io/klog/v2 v2.80.1 // indirect sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 // indirect sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect - sigs.k8s.io/yaml v1.3.0 // indirect ) diff --git a/go.sum b/go.sum index 8a64ecf..709c25e 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,6 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0= github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= @@ -25,7 +24,6 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= @@ -41,8 +39,8 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b h1:PxfKdU9lEEDYjdIzOtC4qFWgkU2rGHdKlKowJSMN9h0= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.3.1-0.20221206200815-1e63c2f08a10 h1:Frnccbp+ok2GkUS2tC84yAq/U9Vg+0sIO7aRL3T4Xnc= +golang.org/x/net v0.3.1-0.20221206200815-1e63c2f08a10/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -51,8 +49,8 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM= +golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= @@ -69,22 +67,20 @@ gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -k8s.io/api v0.25.4 h1:3YO8J4RtmG7elEgaWMb4HgmpS2CfY1QlaOz9nwB+ZSs= -k8s.io/api v0.25.4/go.mod h1:IG2+RzyPQLllQxnhzD8KQNEu4c4YvyDTpSMztf4A0OQ= -k8s.io/apiextensions-apiserver v0.25.4 h1:7hu9pF+xikxQuQZ7/30z/qxIPZc2J1lFElPtr7f+B6U= -k8s.io/apiextensions-apiserver v0.25.4/go.mod h1:bkSGki5YBoZWdn5pWtNIdGvDrrsRWlmnvl9a+tAw5vQ= -k8s.io/apimachinery v0.25.4 h1:CtXsuaitMESSu339tfhVXhQrPET+EiWnIY1rcurKnAc= -k8s.io/apimachinery v0.25.4/go.mod h1:jaF9C/iPNM1FuLl7Zuy5b9v+n35HGSh6AQ4HYRkCqwo= -k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE= -k8s.io/klog/v2 v2.70.1 h1:7aaoSdahviPmR+XkS7FyxlkkXs6tHISSG03RxleQAVQ= -k8s.io/klog/v2 v2.70.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= -k8s.io/kube-aggregator v0.25.4 h1:QIeTa29I2a0VOFwZtpquz/bkNPk+dnUiDPbI/Vq7MbI= -k8s.io/kube-aggregator v0.25.4/go.mod h1:PH65mLSQoUld53w0VkdYcsIGh7wjJGZ5DyfoARronz0= -k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed h1:jAne/RjBTyawwAy0utX5eqigAwz/lQhTmy+Hr/Cpue4= -k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= +k8s.io/api v0.26.0 h1:IpPlZnxBpV1xl7TGk/X6lFtpgjgntCg8PJ+qrPHAC7I= +k8s.io/api v0.26.0/go.mod h1:k6HDTaIFC8yn1i6pSClSqIwLABIcLV9l5Q4EcngKnQg= +k8s.io/apiextensions-apiserver v0.26.0 h1:Gy93Xo1eg2ZIkNX/8vy5xviVSxwQulsnUdQ00nEdpDo= +k8s.io/apiextensions-apiserver v0.26.0/go.mod h1:7ez0LTiyW5nq3vADtK6C3kMESxadD51Bh6uz3JOlqWQ= +k8s.io/apimachinery v0.26.0 h1:1feANjElT7MvPqp0JT6F3Ss6TWDwmcjLypwoPpEf7zg= +k8s.io/apimachinery v0.26.0/go.mod h1:tnPmbONNJ7ByJNz9+n9kMjNP8ON+1qoAIIC70lztu74= +k8s.io/klog/v2 v2.80.1 h1:atnLQ121W371wYYFawwYx1aEY2eUfs4l3J72wtgAwV4= +k8s.io/klog/v2 v2.80.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= +k8s.io/kube-aggregator v0.26.0 h1:XF/Q5FwdLmCsK1RKGFNWfIo/b+r63sXOu+KKcaIFa/M= +k8s.io/kube-aggregator v0.26.0/go.mod h1:QUGAvubVFZ43JiT2gMm6f15FvFkyJcZeDcV1nIbmfgk= +k8s.io/utils v0.0.0-20221107191617-1a15be271d1d h1:0Smp/HP1OH4Rvhe+4B8nWGERtlqAGSftbSbbmm45oFs= +k8s.io/utils v0.0.0-20221107191617-1a15be271d1d/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 h1:iXTIw73aPyC+oRdyqqvVJuloN1p0AC/kzH07hu3NE+k= sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0= sigs.k8s.io/structured-merge-diff/v4 v4.2.3 h1:PRbqxJClWWYMNV1dhaG4NsibJbArud9kFxnAMREiWFE= sigs.k8s.io/structured-merge-diff/v4 v4.2.3/go.mod h1:qjx8mGObPmV2aSZepjQjbmb2ihdVs8cGKBraizNC69E= sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= -sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= diff --git a/go.work.sum b/go.work.sum index e29d91a..5aa0df6 100644 --- a/go.work.sum +++ b/go.work.sum @@ -50,12 +50,15 @@ github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vv github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/ginkgo/v2 v2.1.6 h1:Fx2POJZfKRQcM1pH49qSZiYeu319wji004qX+GDovrU= github.com/onsi/ginkgo/v2 v2.1.6/go.mod h1:MEH45j8TBi6u9BMogfbp0stKC5cdGjumZj5Y7AG4VIk= +github.com/onsi/ginkgo/v2 v2.4.0/go.mod h1:iHkDK1fKGcBoEHT5W7YBq4RFWaQulw+caOMkAt4OrFo= github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= github.com/onsi/gomega v1.20.1/go.mod h1:DtrZpjmvpn2mPm4YWQa0/ALMDj9v4YxLgojwPeREyVo= +github.com/onsi/gomega v1.23.0/go.mod h1:Z/NWtiqwBrwUt4/2loMmHL63EDLnYHmVbuBpDr2vQAg= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/spf13/cobra v1.2.1 h1:+KmjbUw1hriSNMF55oPrkZcb27aECyrj8V2ytv7kWDw= github.com/spf13/cobra v1.4.0 h1:y+wJpx64xcgO1V+RcnwW0LEHxTKRi2ZDPSBjWnrg88Q= +github.com/spf13/cobra v1.6.0 h1:42a0n6jwCot1pUmomAp4T7DeMD+20LFv4Q54pxLf2LI= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= @@ -67,15 +70,21 @@ github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5t golang.org/x/crypto v0.0.0-20220214200702-86341886e292 h1:f+lwQ+GtmgoY+A2YaQxlSOnDjXcQ7ZRLWOHbC6HtRqE= golang.org/x/crypto v0.0.0-20220315160706-3147a52a75dd h1:XcWmESyNjXJMLahc3mqVQJcgSTDxFxhETVlfk9uGc38= golang.org/x/crypto v0.0.0-20220315160706-3147a52a75dd/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= +golang.org/x/net v0.3.1-0.20221206200815-1e63c2f08a10 h1:Frnccbp+ok2GkUS2tC84yAq/U9Vg+0sIO7aRL3T4Xnc= +golang.org/x/net v0.3.1-0.20221206200815-1e63c2f08a10/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -83,6 +92,14 @@ golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ= +golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA= +golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM= +golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= @@ -90,6 +107,8 @@ golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBn golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.10 h1:QjFRCZxdOhBJ/UNgnBZLbNV13DlbnK0quyivTnXJM20= golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -113,6 +132,7 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw= google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= @@ -122,14 +142,20 @@ gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= k8s.io/api v0.25.0/go.mod h1:ttceV1GyV1i1rnmvzT3BST08N6nGt+dudGrquzVQWPk= -k8s.io/apiextensions-apiserver v0.25.4 h1:7hu9pF+xikxQuQZ7/30z/qxIPZc2J1lFElPtr7f+B6U= -k8s.io/apiextensions-apiserver v0.25.4/go.mod h1:bkSGki5YBoZWdn5pWtNIdGvDrrsRWlmnvl9a+tAw5vQ= +k8s.io/api v0.26.0 h1:IpPlZnxBpV1xl7TGk/X6lFtpgjgntCg8PJ+qrPHAC7I= +k8s.io/api v0.26.0/go.mod h1:k6HDTaIFC8yn1i6pSClSqIwLABIcLV9l5Q4EcngKnQg= +k8s.io/apiextensions-apiserver v0.26.0 h1:Gy93Xo1eg2ZIkNX/8vy5xviVSxwQulsnUdQ00nEdpDo= +k8s.io/apiextensions-apiserver v0.26.0/go.mod h1:7ez0LTiyW5nq3vADtK6C3kMESxadD51Bh6uz3JOlqWQ= k8s.io/apimachinery v0.24.0-beta.0/go.mod h1:82Bi4sCzVBdpYjyI4jY6aHX+YCUchUIrZrXKedjd2UM= k8s.io/apimachinery v0.24.1/go.mod h1:82Bi4sCzVBdpYjyI4jY6aHX+YCUchUIrZrXKedjd2UM= k8s.io/apimachinery v0.24.2/go.mod h1:82Bi4sCzVBdpYjyI4jY6aHX+YCUchUIrZrXKedjd2UM= k8s.io/apimachinery v0.25.1/go.mod h1:hqqA1X0bsgsxI6dXsJ4HnNTBOmJNxyPp8dw3u2fSHwA= k8s.io/apimachinery v0.25.2/go.mod h1:hqqA1X0bsgsxI6dXsJ4HnNTBOmJNxyPp8dw3u2fSHwA= -k8s.io/kube-aggregator v0.25.4 h1:QIeTa29I2a0VOFwZtpquz/bkNPk+dnUiDPbI/Vq7MbI= -k8s.io/kube-aggregator v0.25.4/go.mod h1:PH65mLSQoUld53w0VkdYcsIGh7wjJGZ5DyfoARronz0= +k8s.io/apimachinery v0.25.4/go.mod h1:jaF9C/iPNM1FuLl7Zuy5b9v+n35HGSh6AQ4HYRkCqwo= +k8s.io/apimachinery v0.26.0 h1:1feANjElT7MvPqp0JT6F3Ss6TWDwmcjLypwoPpEf7zg= +k8s.io/apimachinery v0.26.0/go.mod h1:tnPmbONNJ7ByJNz9+n9kMjNP8ON+1qoAIIC70lztu74= +k8s.io/kube-aggregator v0.26.0 h1:XF/Q5FwdLmCsK1RKGFNWfIo/b+r63sXOu+KKcaIFa/M= +k8s.io/kube-aggregator v0.26.0/go.mod h1:QUGAvubVFZ43JiT2gMm6f15FvFkyJcZeDcV1nIbmfgk= k8s.io/kube-openapi v0.0.0-20220803162953-67bda5d908f1/go.mod h1:C/N6wCaBHeBHkHUesQOQy2/MZqGgMAFPqGsGQLdbZBU= +k8s.io/kube-openapi v0.0.0-20221012153701-172d655c2280/go.mod h1:+Axhij7bCpeqhklhUTe3xmOn6bWxolyZEeyaFpjGtl4= sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=