diff --git a/go.mod b/go.mod index 08f1c4a872ca..11daadf2a077 100644 --- a/go.mod +++ b/go.mod @@ -27,7 +27,7 @@ require ( github.com/openshift/api v0.0.0-20240410141538-3c0461467316 github.com/openshift/apiserver-library-go v0.0.0-20240313131158-facc40cc7688 github.com/openshift/build-machinery-go v0.0.0-20231128094528-1e9b1b0595c8 - github.com/openshift/client-go v0.0.0-20240405120947-c67c8325cdd8 + github.com/openshift/client-go v0.0.0-20240408153607-64bd6feb83ae github.com/openshift/cluster-network-operator v0.0.0-20240111190956-90754aa19843 github.com/openshift/library-go v0.0.0-20240422143640-fad649cbbd63 github.com/pborman/uuid v1.2.0 diff --git a/go.sum b/go.sum index 13d82b195773..460d56e9a933 100644 --- a/go.sum +++ b/go.sum @@ -640,8 +640,8 @@ github.com/openshift/apiserver-library-go v0.0.0-20240313131158-facc40cc7688 h1: github.com/openshift/apiserver-library-go v0.0.0-20240313131158-facc40cc7688/go.mod h1:a6meSr6htNKfmmZ8ixLmnim/JL7NkgW7rX7J2vczMp4= github.com/openshift/build-machinery-go v0.0.0-20231128094528-1e9b1b0595c8 h1:cu3YUMVGsKIyFyJGO3F6BZKGYQZpCKxAv9cBPgQAca8= github.com/openshift/build-machinery-go v0.0.0-20231128094528-1e9b1b0595c8/go.mod h1:b1BuldmJlbA/xYtdZvKi+7j5YGB44qJUJDZ9zwiNCfE= -github.com/openshift/client-go v0.0.0-20240405120947-c67c8325cdd8 h1:HGfbllzRcrJBSiwzNjBCs7sExLUxC5/1evnvlNGB0Cg= -github.com/openshift/client-go v0.0.0-20240405120947-c67c8325cdd8/go.mod h1:+VvvaMSTUhOt+rBq7NwRLSNxq06hTeRCBqm0j0PQEq8= +github.com/openshift/client-go v0.0.0-20240408153607-64bd6feb83ae h1:WzEMf853apLG0ZgkfmKvYXBKBqhzx7nalP306yQP1ck= +github.com/openshift/client-go v0.0.0-20240408153607-64bd6feb83ae/go.mod h1:YOfx7b9ieudQJImuo95BcVzifosCrCGBErbO/w/njBU= github.com/openshift/cluster-network-operator v0.0.0-20240111190956-90754aa19843 h1:gnesIcAzYdKHsUuKlHT9U36bWJ/8xBDkyjY/mRkdCBU= github.com/openshift/cluster-network-operator v0.0.0-20240111190956-90754aa19843/go.mod h1:chX1Hl5mlarhOVgqSrG8lbYoxUjO8x9+eALxBhGOLxM= github.com/openshift/kubernetes v1.29.0-rc.1.0.20240506170719-681e46bbc98c h1:2h/ozrlnzboGMjaO+IZMI91Cf1HhLT/Ba+QaRcOqzGo= diff --git a/test/extended/networking/network_diagnostics.go b/test/extended/networking/network_diagnostics.go new file mode 100644 index 000000000000..47adb6db009c --- /dev/null +++ b/test/extended/networking/network_diagnostics.go @@ -0,0 +1,297 @@ +package networking + +import ( + "context" + "time" + + g "github.com/onsi/ginkgo/v2" + o "github.com/onsi/gomega" + configv1 "github.com/openshift/api/config/v1" + v1 "github.com/openshift/api/operator/v1" + applyconfigv1 "github.com/openshift/client-go/config/applyconfigurations/config/v1" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/kubernetes/test/e2e/framework" + + exutil "github.com/openshift/origin/test/extended/util" +) + +const ( + namespace = "openshift-network-diagnostics" + clusterConfig = "cluster" + condition = "NetworkDiagnosticsAvailable" + fieldManager = "network-diagnostics-e2e" +) + +// This is [Serial] because it modifies the cluster/network.config.openshift.io object in each test. +var _ = g.Describe("[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial]", g.Ordered, func() { + defer g.GinkgoRecover() + oc := exutil.NewCLIWithoutNamespace("network-diagnostics") + + g.BeforeAll(func(ctx context.Context) { + // Reset and take ownership of the network diagnostics config + patch := []byte(`{"spec":{"networkDiagnostics":null}}`) + _, err := oc.AdminConfigClient().ConfigV1().Networks().Patch(ctx, clusterConfig, types.MergePatchType, patch, metav1.PatchOptions{FieldManager: fieldManager}) + o.Expect(err).NotTo(o.HaveOccurred()) + }) + + g.AfterEach(func(ctx context.Context) { + // Reset network diagnostics config, this will remove changes made by the fieldManager + netConfigApply := applyconfigv1.Network(clusterConfig).WithSpec( + applyconfigv1.NetworkSpec().WithNetworkDiagnostics(nil), + ) + _, err := oc.AdminConfigClient().ConfigV1().Networks().Apply(ctx, netConfigApply, + metav1.ApplyOptions{FieldManager: fieldManager, Force: true}) + o.Expect(err).NotTo(o.HaveOccurred()) + }) + + g.It("Should be enabled by default", func(ctx context.Context) { + o.Eventually(func() bool { + g.By("running one network-check-source pod") + srcPods, err := oc.AdminKubeClient().CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{ + LabelSelector: "app=network-check-source"}) + if err != nil { + framework.Logf("Error getting pods in %s namespace: %v", namespace, err) + return false + } + if len(srcPods.Items) != 1 { + framework.Logf("Invalid amount of source pods: %d", len(srcPods.Items)) + return false + } + + g.By("running a network-check-target pod on every node") + targetPods, err := oc.AdminKubeClient().CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{ + LabelSelector: "app=network-check-target"}) + if err != nil { + framework.Logf("Error getting pods in %s namespace: %v", namespace, err) + return false + } + nodes, err := oc.AdminKubeClient().CoreV1().Nodes().List(ctx, metav1.ListOptions{}) + if err != nil { + framework.Logf("Error getting nodes: %v", err) + return false + } + if len(targetPods.Items) != len(nodes.Items) { + framework.Logf("Invalid amount of destination pods want:%d, got: %d", len(nodes.Items), len(targetPods.Items)) + return false + } + + cfg, err := oc.AdminConfigClient().ConfigV1().Networks().Get(ctx, clusterConfig, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting cluster config: %v", err) + return false + } + return meta.IsStatusConditionTrue(cfg.Status.Conditions, condition) + }, 3*time.Minute, 5*time.Second).Should(o.BeTrue()) + }) + + g.It("Should remove all network diagnostics pods when disabled", func(ctx context.Context) { + netConfigApply := applyconfigv1.Network(clusterConfig).WithSpec( + applyconfigv1.NetworkSpec().WithNetworkDiagnostics( + applyconfigv1.NetworkDiagnostics().WithMode(configv1.NetworkDiagnosticsDisabled), + ), + ) + _, err := oc.AdminConfigClient().ConfigV1().Networks().Apply(ctx, netConfigApply, + metav1.ApplyOptions{FieldManager: fieldManager, Force: true}) + o.Expect(err).NotTo(o.HaveOccurred()) + + o.Eventually(func() bool { + pods, err := oc.AdminKubeClient().CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{}) + if err != nil { + framework.Logf("Error getting pods in %s namespace: %v", namespace, err) + return false + } + if len(pods.Items) != 0 { + return false + } + + cfg, err := oc.AdminConfigClient().ConfigV1().Networks().Get(ctx, clusterConfig, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting cluster config: %v", err) + return false + } + return meta.IsStatusConditionFalse(cfg.Status.Conditions, condition) + }, 3*time.Minute, 5*time.Second).Should(o.BeTrue()) + }) + + g.It("Should move the source diagnostics pods based on the new selector and tolerations", func(ctx context.Context) { + // Intentionally omit setting the mode to ensure that the diagnostics are enabled when it is unset + netConfigApply := applyconfigv1.Network(clusterConfig).WithSpec( + applyconfigv1.NetworkSpec().WithNetworkDiagnostics( + applyconfigv1.NetworkDiagnostics(). + WithSourcePlacement( + applyconfigv1.NetworkDiagnosticsSourcePlacement(). + WithNodeSelector(map[string]string{"node-role.kubernetes.io/master": ""}). + WithTolerations(corev1.Toleration{ + Operator: corev1.TolerationOpExists, + }), + ).WithTargetPlacement(nil), + ), + ) + _, err := oc.AdminConfigClient().ConfigV1().Networks().Apply(ctx, netConfigApply, + metav1.ApplyOptions{FieldManager: fieldManager, Force: true}) + o.Expect(err).NotTo(o.HaveOccurred()) + o.Eventually(func() bool { + pods, err := oc.AdminKubeClient().CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{ + LabelSelector: "app=network-check-source"}) + if err != nil { + framework.Logf("Error getting pods in %s namespace: %v", namespace, err) + return false + } + if len(pods.Items) == 0 { + framework.Logf("No diagnostics pods found") + return false + } + for _, pod := range pods.Items { + if pod.Spec.NodeName == "" { + framework.Logf("Diagnostics pod %s is not scheduled to any node", pod.Name) + return false + } + node, err := oc.AdminKubeClient().CoreV1().Nodes().Get(ctx, pod.Spec.NodeName, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting node %s: %v", pod.Spec.NodeName, err) + return false + } + if _, ok := node.Labels["node-role.kubernetes.io/master"]; !ok { + framework.Logf("Diagnostics pod %s is not scheduled to a master node", pod.Name) + return false + } + } + cfg, err := oc.AdminConfigClient().ConfigV1().Networks().Get(ctx, clusterConfig, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting cluster config: %v", err) + return false + } + return meta.IsStatusConditionTrue(cfg.Status.Conditions, condition) + }, 3*time.Minute, 5*time.Second).Should(o.BeTrue()) + }) + + g.It("Should move the target diagnostics pods based on the new selector and tolerations", func(ctx context.Context) { + netConfigApply := applyconfigv1.Network(clusterConfig).WithSpec( + applyconfigv1.NetworkSpec().WithNetworkDiagnostics( + applyconfigv1.NetworkDiagnostics(). + WithMode(configv1.NetworkDiagnosticsAll). + WithTargetPlacement( + applyconfigv1.NetworkDiagnosticsTargetPlacement(). + WithNodeSelector(map[string]string{"node-role.kubernetes.io/master": ""}). + WithTolerations(corev1.Toleration{ + Operator: corev1.TolerationOpExists, + Key: "node-role.kubernetes.io/master", + Effect: corev1.TaintEffectNoSchedule, + }), + ), + ), + ) + _, err := oc.AdminConfigClient().ConfigV1().Networks().Apply(ctx, netConfigApply, + metav1.ApplyOptions{FieldManager: fieldManager, Force: true}) + o.Expect(err).NotTo(o.HaveOccurred()) + o.Eventually(func() bool { + pods, err := oc.AdminKubeClient().CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{ + LabelSelector: "app=network-check-target"}) + if err != nil { + framework.Logf("Error getting pods in %s namespace: %v", namespace, err) + return false + } + if len(pods.Items) == 0 { + framework.Logf("No diagnostics pods found") + return false + } + for _, pod := range pods.Items { + if pod.Spec.NodeName == "" { + framework.Logf("Diagnostics pod %s is not scheduled to any node", pod.Name) + return false + } + node, err := oc.AdminKubeClient().CoreV1().Nodes().Get(ctx, pod.Spec.NodeName, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting node %s: %v", pod.Spec.NodeName, err) + return false + } + if _, ok := node.Labels["node-role.kubernetes.io/master"]; !ok { + framework.Logf("Diagnostics pod %s is not scheduled to a master node", pod.Name) + return false + } + } + cfg, err := oc.AdminConfigClient().ConfigV1().Networks().Get(ctx, clusterConfig, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting cluster config: %v", err) + return false + } + return meta.IsStatusConditionTrue(cfg.Status.Conditions, condition) + }, 3*time.Minute, 5*time.Second).Should(o.BeTrue()) + }) + + g.It("Should function without any target pods", func(ctx context.Context) { + netConfigApply := applyconfigv1.Network(clusterConfig).WithSpec( + applyconfigv1.NetworkSpec().WithNetworkDiagnostics( + applyconfigv1.NetworkDiagnostics(). + WithMode(configv1.NetworkDiagnosticsAll). + WithTargetPlacement( + applyconfigv1.NetworkDiagnosticsTargetPlacement(). + WithNodeSelector(map[string]string{"alien": ""}), + ), + ), + ) + _, err := oc.AdminConfigClient().ConfigV1().Networks().Apply(ctx, netConfigApply, + metav1.ApplyOptions{FieldManager: fieldManager, Force: true}) + o.Expect(err).NotTo(o.HaveOccurred()) + o.Eventually(func() bool { + pods, err := oc.AdminKubeClient().CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{ + LabelSelector: "app=network-check-target"}) + if err != nil { + framework.Logf("Error getting pods in %s namespace: %v", namespace, err) + return false + } + if len(pods.Items) != 0 { + framework.Logf("Target diagnostics pods found") + return false + } + cfg, err := oc.AdminConfigClient().ConfigV1().Networks().Get(ctx, clusterConfig, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting cluster config: %v", err) + return false + } + return meta.IsStatusConditionTrue(cfg.Status.Conditions, condition) + }, 3*time.Minute, 5*time.Second).Should(o.BeTrue()) + }) + + g.It("Should set the condition to false if there are no nodes able to host the source pods", func(ctx context.Context) { + netConfigApply := applyconfigv1.Network(clusterConfig).WithSpec( + applyconfigv1.NetworkSpec().WithNetworkDiagnostics( + applyconfigv1.NetworkDiagnostics(). + WithMode(configv1.NetworkDiagnosticsAll). + WithSourcePlacement( + applyconfigv1.NetworkDiagnosticsSourcePlacement(). + WithNodeSelector(map[string]string{"alien": ""}), + ), + ), + ) + _, err := oc.AdminConfigClient().ConfigV1().Networks().Apply(ctx, netConfigApply, + metav1.ApplyOptions{FieldManager: fieldManager, Force: true}) + o.Expect(err).NotTo(o.HaveOccurred()) + + o.Eventually(func() bool { + // Should not affect the Progressing condition of network.operator + oper, err := oc.AdminOperatorClient().OperatorV1().Networks().Get(ctx, clusterConfig, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting cluster operator: %v", err) + return false + } + for _, operCondition := range oper.Status.Conditions { + if operCondition.Type == "Progressing" && operCondition.Status != v1.ConditionFalse { + framework.Logf("Invalid progressing condition: %v", operCondition) + return false + } + } + + cfg, err := oc.AdminConfigClient().ConfigV1().Networks().Get(ctx, clusterConfig, metav1.GetOptions{}) + if err != nil { + framework.Logf("Error getting cluster config: %v", err) + return false + } + return meta.IsStatusConditionFalse(cfg.Status.Conditions, condition) + }, 3*time.Minute, 5*time.Second).Should(o.BeTrue()) + }) + +}) diff --git a/test/extended/util/annotate/generated/zz_generated.annotations.go b/test/extended/util/annotate/generated/zz_generated.annotations.go index 69aa4828e5bb..581f57b82f8e 100644 --- a/test/extended/util/annotate/generated/zz_generated.annotations.go +++ b/test/extended/util/annotate/generated/zz_generated.annotations.go @@ -1437,6 +1437,18 @@ var Annotations = map[string]string{ "[sig-network][Feature:vlan] should create pingable pods with vlan interface on an in-container master [apigroup:k8s.cni.cncf.io]": " [Suite:openshift/conformance/parallel]", + "[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should be enabled by default": " [Suite:openshift/conformance/serial]", + + "[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should function without any target pods": " [Suite:openshift/conformance/serial]", + + "[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should move the source diagnostics pods based on the new selector and tolerations": " [Suite:openshift/conformance/serial]", + + "[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should move the target diagnostics pods based on the new selector and tolerations": " [Suite:openshift/conformance/serial]", + + "[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should remove all network diagnostics pods when disabled": " [Suite:openshift/conformance/serial]", + + "[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should set the condition to false if there are no nodes able to host the source pods": " [Suite:openshift/conformance/serial]", + "[sig-network][endpoints] admission [apigroup:config.openshift.io] blocks manual creation of EndpointSlices pointing to the cluster or service network": " [Suite:openshift/conformance/parallel]", "[sig-network][endpoints] admission [apigroup:config.openshift.io] blocks manual creation of Endpoints pointing to the cluster or service network": " [Suite:openshift/conformance/parallel]", diff --git a/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnostics.go b/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnostics.go new file mode 100644 index 000000000000..93866293e3bd --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnostics.go @@ -0,0 +1,45 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/config/v1" +) + +// NetworkDiagnosticsApplyConfiguration represents an declarative configuration of the NetworkDiagnostics type for use +// with apply. +type NetworkDiagnosticsApplyConfiguration struct { + Mode *v1.NetworkDiagnosticsMode `json:"mode,omitempty"` + SourcePlacement *NetworkDiagnosticsSourcePlacementApplyConfiguration `json:"sourcePlacement,omitempty"` + TargetPlacement *NetworkDiagnosticsTargetPlacementApplyConfiguration `json:"targetPlacement,omitempty"` +} + +// NetworkDiagnosticsApplyConfiguration constructs an declarative configuration of the NetworkDiagnostics type for use with +// apply. +func NetworkDiagnostics() *NetworkDiagnosticsApplyConfiguration { + return &NetworkDiagnosticsApplyConfiguration{} +} + +// WithMode sets the Mode field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Mode field is set to the value of the last call. +func (b *NetworkDiagnosticsApplyConfiguration) WithMode(value v1.NetworkDiagnosticsMode) *NetworkDiagnosticsApplyConfiguration { + b.Mode = &value + return b +} + +// WithSourcePlacement sets the SourcePlacement field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the SourcePlacement field is set to the value of the last call. +func (b *NetworkDiagnosticsApplyConfiguration) WithSourcePlacement(value *NetworkDiagnosticsSourcePlacementApplyConfiguration) *NetworkDiagnosticsApplyConfiguration { + b.SourcePlacement = value + return b +} + +// WithTargetPlacement sets the TargetPlacement field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the TargetPlacement field is set to the value of the last call. +func (b *NetworkDiagnosticsApplyConfiguration) WithTargetPlacement(value *NetworkDiagnosticsTargetPlacementApplyConfiguration) *NetworkDiagnosticsApplyConfiguration { + b.TargetPlacement = value + return b +} diff --git a/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnosticssourceplacement.go b/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnosticssourceplacement.go new file mode 100644 index 000000000000..efe6bbd494d1 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnosticssourceplacement.go @@ -0,0 +1,44 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "k8s.io/api/core/v1" +) + +// NetworkDiagnosticsSourcePlacementApplyConfiguration represents an declarative configuration of the NetworkDiagnosticsSourcePlacement type for use +// with apply. +type NetworkDiagnosticsSourcePlacementApplyConfiguration struct { + NodeSelector map[string]string `json:"nodeSelector,omitempty"` + Tolerations []v1.Toleration `json:"tolerations,omitempty"` +} + +// NetworkDiagnosticsSourcePlacementApplyConfiguration constructs an declarative configuration of the NetworkDiagnosticsSourcePlacement type for use with +// apply. +func NetworkDiagnosticsSourcePlacement() *NetworkDiagnosticsSourcePlacementApplyConfiguration { + return &NetworkDiagnosticsSourcePlacementApplyConfiguration{} +} + +// WithNodeSelector puts the entries into the NodeSelector field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the NodeSelector field, +// overwriting an existing map entries in NodeSelector field with the same key. +func (b *NetworkDiagnosticsSourcePlacementApplyConfiguration) WithNodeSelector(entries map[string]string) *NetworkDiagnosticsSourcePlacementApplyConfiguration { + if b.NodeSelector == nil && len(entries) > 0 { + b.NodeSelector = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.NodeSelector[k] = v + } + return b +} + +// WithTolerations adds the given value to the Tolerations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Tolerations field. +func (b *NetworkDiagnosticsSourcePlacementApplyConfiguration) WithTolerations(values ...v1.Toleration) *NetworkDiagnosticsSourcePlacementApplyConfiguration { + for i := range values { + b.Tolerations = append(b.Tolerations, values[i]) + } + return b +} diff --git a/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnosticstargetplacement.go b/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnosticstargetplacement.go new file mode 100644 index 000000000000..c1ce2d8e9dc2 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkdiagnosticstargetplacement.go @@ -0,0 +1,44 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "k8s.io/api/core/v1" +) + +// NetworkDiagnosticsTargetPlacementApplyConfiguration represents an declarative configuration of the NetworkDiagnosticsTargetPlacement type for use +// with apply. +type NetworkDiagnosticsTargetPlacementApplyConfiguration struct { + NodeSelector map[string]string `json:"nodeSelector,omitempty"` + Tolerations []v1.Toleration `json:"tolerations,omitempty"` +} + +// NetworkDiagnosticsTargetPlacementApplyConfiguration constructs an declarative configuration of the NetworkDiagnosticsTargetPlacement type for use with +// apply. +func NetworkDiagnosticsTargetPlacement() *NetworkDiagnosticsTargetPlacementApplyConfiguration { + return &NetworkDiagnosticsTargetPlacementApplyConfiguration{} +} + +// WithNodeSelector puts the entries into the NodeSelector field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the NodeSelector field, +// overwriting an existing map entries in NodeSelector field with the same key. +func (b *NetworkDiagnosticsTargetPlacementApplyConfiguration) WithNodeSelector(entries map[string]string) *NetworkDiagnosticsTargetPlacementApplyConfiguration { + if b.NodeSelector == nil && len(entries) > 0 { + b.NodeSelector = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.NodeSelector[k] = v + } + return b +} + +// WithTolerations adds the given value to the Tolerations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Tolerations field. +func (b *NetworkDiagnosticsTargetPlacementApplyConfiguration) WithTolerations(values ...v1.Toleration) *NetworkDiagnosticsTargetPlacementApplyConfiguration { + for i := range values { + b.Tolerations = append(b.Tolerations, values[i]) + } + return b +} diff --git a/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkspec.go b/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkspec.go index c74dc4d0c00d..5d218d02c28a 100644 --- a/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkspec.go +++ b/vendor/github.com/openshift/client-go/config/applyconfigurations/config/v1/networkspec.go @@ -10,6 +10,7 @@ type NetworkSpecApplyConfiguration struct { NetworkType *string `json:"networkType,omitempty"` ExternalIP *ExternalIPConfigApplyConfiguration `json:"externalIP,omitempty"` ServiceNodePortRange *string `json:"serviceNodePortRange,omitempty"` + NetworkDiagnostics *NetworkDiagnosticsApplyConfiguration `json:"networkDiagnostics,omitempty"` } // NetworkSpecApplyConfiguration constructs an declarative configuration of the NetworkSpec type for use with @@ -64,3 +65,11 @@ func (b *NetworkSpecApplyConfiguration) WithServiceNodePortRange(value string) * b.ServiceNodePortRange = &value return b } + +// WithNetworkDiagnostics sets the NetworkDiagnostics field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the NetworkDiagnostics field is set to the value of the last call. +func (b *NetworkSpecApplyConfiguration) WithNetworkDiagnostics(value *NetworkDiagnosticsApplyConfiguration) *NetworkSpecApplyConfiguration { + b.NetworkDiagnostics = value + return b +} diff --git a/vendor/github.com/openshift/client-go/config/applyconfigurations/internal/internal.go b/vendor/github.com/openshift/client-go/config/applyconfigurations/internal/internal.go index 64d6d2ae7cbe..28f42faf92b8 100644 --- a/vendor/github.com/openshift/client-go/config/applyconfigurations/internal/internal.go +++ b/vendor/github.com/openshift/client-go/config/applyconfigurations/internal/internal.go @@ -2022,6 +2022,49 @@ var schemaYAML = typed.YAMLObject(`types: type: namedType: com.github.openshift.api.config.v1.NetworkStatus default: {} +- name: com.github.openshift.api.config.v1.NetworkDiagnostics + map: + fields: + - name: mode + type: + scalar: string + default: "" + - name: sourcePlacement + type: + namedType: com.github.openshift.api.config.v1.NetworkDiagnosticsSourcePlacement + default: {} + - name: targetPlacement + type: + namedType: com.github.openshift.api.config.v1.NetworkDiagnosticsTargetPlacement + default: {} +- name: com.github.openshift.api.config.v1.NetworkDiagnosticsSourcePlacement + map: + fields: + - name: nodeSelector + type: + map: + elementType: + scalar: string + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Toleration + elementRelationship: atomic +- name: com.github.openshift.api.config.v1.NetworkDiagnosticsTargetPlacement + map: + fields: + - name: nodeSelector + type: + map: + elementType: + scalar: string + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Toleration + elementRelationship: atomic - name: com.github.openshift.api.config.v1.NetworkMigration map: fields: @@ -2043,6 +2086,10 @@ var schemaYAML = typed.YAMLObject(`types: - name: externalIP type: namedType: com.github.openshift.api.config.v1.ExternalIPConfig + - name: networkDiagnostics + type: + namedType: com.github.openshift.api.config.v1.NetworkDiagnostics + default: {} - name: networkType type: scalar: string diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/internal/internal.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/internal/internal.go index ff80444b717a..feda430acebd 100644 --- a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/internal/internal.go +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/internal/internal.go @@ -73,6 +73,59 @@ var schemaYAML = typed.YAMLObject(`types: elementType: namedType: __untyped_deduced_ elementRelationship: separable +- name: com.github.openshift.api.machineconfiguration.v1alpha1.BuildInputs + map: + fields: + - name: baseImagePullSecret + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.ImageSecretObjectReference + default: {} + - name: baseOSExtensionsImagePullspec + type: + scalar: string + - name: baseOSImagePullspec + type: + scalar: string + - name: containerFile + type: + list: + elementType: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSContainerfile + elementRelationship: associative + keys: + - containerfileArch + - name: imageBuilder + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSImageBuilder + - name: releaseVersion + type: + scalar: string + - name: renderedImagePushSecret + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.ImageSecretObjectReference + default: {} + - name: renderedImagePushspec + type: + scalar: string + default: "" +- name: com.github.openshift.api.machineconfiguration.v1alpha1.BuildOutputs + map: + fields: + - name: currentImagePullSecret + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.ImageSecretObjectReference + default: {} + unions: + - fields: + - fieldName: currentImagePullSecret + discriminatorValue: CurrentImagePullSecret +- name: com.github.openshift.api.machineconfiguration.v1alpha1.ImageSecretObjectReference + map: + fields: + - name: name + type: + scalar: string + default: "" - name: com.github.openshift.api.machineconfiguration.v1alpha1.MCOObjectReference map: fields: @@ -197,6 +250,197 @@ var schemaYAML = typed.YAMLObject(`types: type: scalar: string default: "" +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineConfigPoolReference + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSBuild + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSBuildSpec + default: {} + - name: status + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSBuildStatus + default: {} +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSBuildSpec + map: + fields: + - name: configGeneration + type: + scalar: numeric + default: 0 + - name: desiredConfig + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.RenderedMachineConfigReference + default: {} + - name: machineOSConfig + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSConfigReference + default: {} + - name: renderedImagePushspec + type: + scalar: string + default: "" + - name: version + type: + scalar: numeric + default: 0 +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSBuildStatus + map: + fields: + - name: buildEnd + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: buildStart + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: builderReference + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSBuilderReference + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: finalImagePullspec + type: + scalar: string + - name: relatedObjects + type: + list: + elementType: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.ObjectReference + elementRelationship: atomic +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSBuilderReference + map: + fields: + - name: buildPod + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.ObjectReference + - name: imageBuilderType + type: + scalar: string + default: "" + unions: + - discriminator: imageBuilderType + fields: + - fieldName: buildPod + discriminatorValue: PodImageBuilder +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSConfig + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSConfigSpec + default: {} + - name: status + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSConfigStatus + default: {} +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSConfigReference + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSConfigSpec + map: + fields: + - name: buildInputs + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.BuildInputs + default: {} + - name: buildOutputs + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.BuildOutputs + default: {} + - name: machineConfigPool + type: + namedType: com.github.openshift.api.machineconfiguration.v1alpha1.MachineConfigPoolReference + default: {} +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSConfigStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: currentImagePullspec + type: + scalar: string + - name: observedGeneration + type: + scalar: numeric +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSContainerfile + map: + fields: + - name: containerfileArch + type: + scalar: string + default: "" + - name: content + type: + scalar: string + default: "" +- name: com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSImageBuilder + map: + fields: + - name: imageBuilderType + type: + scalar: string + default: "" +- name: com.github.openshift.api.machineconfiguration.v1alpha1.ObjectReference + map: + fields: + - name: group + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + - name: resource + type: + scalar: string + default: "" - name: com.github.openshift.api.machineconfiguration.v1alpha1.PinnedImageRef map: fields: @@ -247,6 +491,13 @@ var schemaYAML = typed.YAMLObject(`types: elementRelationship: associative keys: - type +- name: com.github.openshift.api.machineconfiguration.v1alpha1.RenderedMachineConfigReference + map: + fields: + - name: name + type: + scalar: string + default: "" - name: io.k8s.apimachinery.pkg.apis.meta.v1.Condition map: fields: diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/buildinputs.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/buildinputs.go new file mode 100644 index 000000000000..b51e0240ef0a --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/buildinputs.go @@ -0,0 +1,91 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// BuildInputsApplyConfiguration represents an declarative configuration of the BuildInputs type for use +// with apply. +type BuildInputsApplyConfiguration struct { + BaseOSExtensionsImagePullspec *string `json:"baseOSExtensionsImagePullspec,omitempty"` + BaseOSImagePullspec *string `json:"baseOSImagePullspec,omitempty"` + BaseImagePullSecret *ImageSecretObjectReferenceApplyConfiguration `json:"baseImagePullSecret,omitempty"` + ImageBuilder *MachineOSImageBuilderApplyConfiguration `json:"imageBuilder,omitempty"` + RenderedImagePushSecret *ImageSecretObjectReferenceApplyConfiguration `json:"renderedImagePushSecret,omitempty"` + RenderedImagePushspec *string `json:"renderedImagePushspec,omitempty"` + ReleaseVersion *string `json:"releaseVersion,omitempty"` + Containerfile []MachineOSContainerfileApplyConfiguration `json:"containerFile,omitempty"` +} + +// BuildInputsApplyConfiguration constructs an declarative configuration of the BuildInputs type for use with +// apply. +func BuildInputs() *BuildInputsApplyConfiguration { + return &BuildInputsApplyConfiguration{} +} + +// WithBaseOSExtensionsImagePullspec sets the BaseOSExtensionsImagePullspec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the BaseOSExtensionsImagePullspec field is set to the value of the last call. +func (b *BuildInputsApplyConfiguration) WithBaseOSExtensionsImagePullspec(value string) *BuildInputsApplyConfiguration { + b.BaseOSExtensionsImagePullspec = &value + return b +} + +// WithBaseOSImagePullspec sets the BaseOSImagePullspec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the BaseOSImagePullspec field is set to the value of the last call. +func (b *BuildInputsApplyConfiguration) WithBaseOSImagePullspec(value string) *BuildInputsApplyConfiguration { + b.BaseOSImagePullspec = &value + return b +} + +// WithBaseImagePullSecret sets the BaseImagePullSecret field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the BaseImagePullSecret field is set to the value of the last call. +func (b *BuildInputsApplyConfiguration) WithBaseImagePullSecret(value *ImageSecretObjectReferenceApplyConfiguration) *BuildInputsApplyConfiguration { + b.BaseImagePullSecret = value + return b +} + +// WithImageBuilder sets the ImageBuilder field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ImageBuilder field is set to the value of the last call. +func (b *BuildInputsApplyConfiguration) WithImageBuilder(value *MachineOSImageBuilderApplyConfiguration) *BuildInputsApplyConfiguration { + b.ImageBuilder = value + return b +} + +// WithRenderedImagePushSecret sets the RenderedImagePushSecret field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the RenderedImagePushSecret field is set to the value of the last call. +func (b *BuildInputsApplyConfiguration) WithRenderedImagePushSecret(value *ImageSecretObjectReferenceApplyConfiguration) *BuildInputsApplyConfiguration { + b.RenderedImagePushSecret = value + return b +} + +// WithRenderedImagePushspec sets the RenderedImagePushspec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the RenderedImagePushspec field is set to the value of the last call. +func (b *BuildInputsApplyConfiguration) WithRenderedImagePushspec(value string) *BuildInputsApplyConfiguration { + b.RenderedImagePushspec = &value + return b +} + +// WithReleaseVersion sets the ReleaseVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ReleaseVersion field is set to the value of the last call. +func (b *BuildInputsApplyConfiguration) WithReleaseVersion(value string) *BuildInputsApplyConfiguration { + b.ReleaseVersion = &value + return b +} + +// WithContainerfile adds the given value to the Containerfile field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Containerfile field. +func (b *BuildInputsApplyConfiguration) WithContainerfile(values ...*MachineOSContainerfileApplyConfiguration) *BuildInputsApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithContainerfile") + } + b.Containerfile = append(b.Containerfile, *values[i]) + } + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/buildoutputs.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/buildoutputs.go new file mode 100644 index 000000000000..803414dd6845 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/buildoutputs.go @@ -0,0 +1,23 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// BuildOutputsApplyConfiguration represents an declarative configuration of the BuildOutputs type for use +// with apply. +type BuildOutputsApplyConfiguration struct { + CurrentImagePullSecret *ImageSecretObjectReferenceApplyConfiguration `json:"currentImagePullSecret,omitempty"` +} + +// BuildOutputsApplyConfiguration constructs an declarative configuration of the BuildOutputs type for use with +// apply. +func BuildOutputs() *BuildOutputsApplyConfiguration { + return &BuildOutputsApplyConfiguration{} +} + +// WithCurrentImagePullSecret sets the CurrentImagePullSecret field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CurrentImagePullSecret field is set to the value of the last call. +func (b *BuildOutputsApplyConfiguration) WithCurrentImagePullSecret(value *ImageSecretObjectReferenceApplyConfiguration) *BuildOutputsApplyConfiguration { + b.CurrentImagePullSecret = value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/imagesecretobjectreference.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/imagesecretobjectreference.go new file mode 100644 index 000000000000..b154075b586d --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/imagesecretobjectreference.go @@ -0,0 +1,23 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// ImageSecretObjectReferenceApplyConfiguration represents an declarative configuration of the ImageSecretObjectReference type for use +// with apply. +type ImageSecretObjectReferenceApplyConfiguration struct { + Name *string `json:"name,omitempty"` +} + +// ImageSecretObjectReferenceApplyConfiguration constructs an declarative configuration of the ImageSecretObjectReference type for use with +// apply. +func ImageSecretObjectReference() *ImageSecretObjectReferenceApplyConfiguration { + return &ImageSecretObjectReferenceApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *ImageSecretObjectReferenceApplyConfiguration) WithName(value string) *ImageSecretObjectReferenceApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineconfigpoolreference.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineconfigpoolreference.go new file mode 100644 index 000000000000..e99c5e53e9ba --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineconfigpoolreference.go @@ -0,0 +1,23 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// MachineConfigPoolReferenceApplyConfiguration represents an declarative configuration of the MachineConfigPoolReference type for use +// with apply. +type MachineConfigPoolReferenceApplyConfiguration struct { + Name *string `json:"name,omitempty"` +} + +// MachineConfigPoolReferenceApplyConfiguration constructs an declarative configuration of the MachineConfigPoolReference type for use with +// apply. +func MachineConfigPoolReference() *MachineConfigPoolReferenceApplyConfiguration { + return &MachineConfigPoolReferenceApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *MachineConfigPoolReferenceApplyConfiguration) WithName(value string) *MachineConfigPoolReferenceApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuild.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuild.go new file mode 100644 index 000000000000..66f9fe478e67 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuild.go @@ -0,0 +1,240 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + machineconfigurationv1alpha1 "github.com/openshift/api/machineconfiguration/v1alpha1" + internal "github.com/openshift/client-go/machineconfiguration/applyconfigurations/internal" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + managedfields "k8s.io/apimachinery/pkg/util/managedfields" + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// MachineOSBuildApplyConfiguration represents an declarative configuration of the MachineOSBuild type for use +// with apply. +type MachineOSBuildApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *MachineOSBuildSpecApplyConfiguration `json:"spec,omitempty"` + Status *MachineOSBuildStatusApplyConfiguration `json:"status,omitempty"` +} + +// MachineOSBuild constructs an declarative configuration of the MachineOSBuild type for use with +// apply. +func MachineOSBuild(name string) *MachineOSBuildApplyConfiguration { + b := &MachineOSBuildApplyConfiguration{} + b.WithName(name) + b.WithKind("MachineOSBuild") + b.WithAPIVersion("machineconfiguration.openshift.io/v1alpha1") + return b +} + +// ExtractMachineOSBuild extracts the applied configuration owned by fieldManager from +// machineOSBuild. If no managedFields are found in machineOSBuild for fieldManager, a +// MachineOSBuildApplyConfiguration is returned with only the Name, Namespace (if applicable), +// APIVersion and Kind populated. It is possible that no managed fields were found for because other +// field managers have taken ownership of all the fields previously owned by fieldManager, or because +// the fieldManager never owned fields any fields. +// machineOSBuild must be a unmodified MachineOSBuild API object that was retrieved from the Kubernetes API. +// ExtractMachineOSBuild provides a way to perform a extract/modify-in-place/apply workflow. +// Note that an extracted apply configuration will contain fewer fields than what the fieldManager previously +// applied if another fieldManager has updated or force applied any of the previously applied fields. +// Experimental! +func ExtractMachineOSBuild(machineOSBuild *machineconfigurationv1alpha1.MachineOSBuild, fieldManager string) (*MachineOSBuildApplyConfiguration, error) { + return extractMachineOSBuild(machineOSBuild, fieldManager, "") +} + +// ExtractMachineOSBuildStatus is the same as ExtractMachineOSBuild except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractMachineOSBuildStatus(machineOSBuild *machineconfigurationv1alpha1.MachineOSBuild, fieldManager string) (*MachineOSBuildApplyConfiguration, error) { + return extractMachineOSBuild(machineOSBuild, fieldManager, "status") +} + +func extractMachineOSBuild(machineOSBuild *machineconfigurationv1alpha1.MachineOSBuild, fieldManager string, subresource string) (*MachineOSBuildApplyConfiguration, error) { + b := &MachineOSBuildApplyConfiguration{} + err := managedfields.ExtractInto(machineOSBuild, internal.Parser().Type("com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSBuild"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(machineOSBuild.Name) + + b.WithKind("MachineOSBuild") + b.WithAPIVersion("machineconfiguration.openshift.io/v1alpha1") + return b, nil +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithKind(value string) *MachineOSBuildApplyConfiguration { + b.Kind = &value + return b +} + +// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the APIVersion field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithAPIVersion(value string) *MachineOSBuildApplyConfiguration { + b.APIVersion = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithName(value string) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Name = &value + return b +} + +// WithGenerateName sets the GenerateName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GenerateName field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithGenerateName(value string) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.GenerateName = &value + return b +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithNamespace(value string) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Namespace = &value + return b +} + +// WithUID sets the UID field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the UID field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithUID(value types.UID) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.UID = &value + return b +} + +// WithResourceVersion sets the ResourceVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResourceVersion field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithResourceVersion(value string) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ResourceVersion = &value + return b +} + +// WithGeneration sets the Generation field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Generation field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithGeneration(value int64) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Generation = &value + return b +} + +// WithCreationTimestamp sets the CreationTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CreationTimestamp field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithCreationTimestamp(value metav1.Time) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.CreationTimestamp = &value + return b +} + +// WithDeletionTimestamp sets the DeletionTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionTimestamp field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionTimestamp = &value + return b +} + +// WithDeletionGracePeriodSeconds sets the DeletionGracePeriodSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionGracePeriodSeconds field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionGracePeriodSeconds = &value + return b +} + +// WithLabels puts the entries into the Labels field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Labels field, +// overwriting an existing map entries in Labels field with the same key. +func (b *MachineOSBuildApplyConfiguration) WithLabels(entries map[string]string) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Labels == nil && len(entries) > 0 { + b.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Labels[k] = v + } + return b +} + +// WithAnnotations puts the entries into the Annotations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Annotations field, +// overwriting an existing map entries in Annotations field with the same key. +func (b *MachineOSBuildApplyConfiguration) WithAnnotations(entries map[string]string) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Annotations == nil && len(entries) > 0 { + b.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Annotations[k] = v + } + return b +} + +// WithOwnerReferences adds the given value to the OwnerReferences field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the OwnerReferences field. +func (b *MachineOSBuildApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.OwnerReferences = append(b.OwnerReferences, *values[i]) + } + return b +} + +// WithFinalizers adds the given value to the Finalizers field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Finalizers field. +func (b *MachineOSBuildApplyConfiguration) WithFinalizers(values ...string) *MachineOSBuildApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.Finalizers = append(b.Finalizers, values[i]) + } + return b +} + +func (b *MachineOSBuildApplyConfiguration) ensureObjectMetaApplyConfigurationExists() { + if b.ObjectMetaApplyConfiguration == nil { + b.ObjectMetaApplyConfiguration = &v1.ObjectMetaApplyConfiguration{} + } +} + +// WithSpec sets the Spec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Spec field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithSpec(value *MachineOSBuildSpecApplyConfiguration) *MachineOSBuildApplyConfiguration { + b.Spec = value + return b +} + +// WithStatus sets the Status field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Status field is set to the value of the last call. +func (b *MachineOSBuildApplyConfiguration) WithStatus(value *MachineOSBuildStatusApplyConfiguration) *MachineOSBuildApplyConfiguration { + b.Status = value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuilderreference.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuilderreference.go new file mode 100644 index 000000000000..c90bf8eb9575 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuilderreference.go @@ -0,0 +1,36 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/openshift/api/machineconfiguration/v1alpha1" +) + +// MachineOSBuilderReferenceApplyConfiguration represents an declarative configuration of the MachineOSBuilderReference type for use +// with apply. +type MachineOSBuilderReferenceApplyConfiguration struct { + ImageBuilderType *v1alpha1.MachineOSImageBuilderType `json:"imageBuilderType,omitempty"` + PodImageBuilder *ObjectReferenceApplyConfiguration `json:"buildPod,omitempty"` +} + +// MachineOSBuilderReferenceApplyConfiguration constructs an declarative configuration of the MachineOSBuilderReference type for use with +// apply. +func MachineOSBuilderReference() *MachineOSBuilderReferenceApplyConfiguration { + return &MachineOSBuilderReferenceApplyConfiguration{} +} + +// WithImageBuilderType sets the ImageBuilderType field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ImageBuilderType field is set to the value of the last call. +func (b *MachineOSBuilderReferenceApplyConfiguration) WithImageBuilderType(value v1alpha1.MachineOSImageBuilderType) *MachineOSBuilderReferenceApplyConfiguration { + b.ImageBuilderType = &value + return b +} + +// WithPodImageBuilder sets the PodImageBuilder field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the PodImageBuilder field is set to the value of the last call. +func (b *MachineOSBuilderReferenceApplyConfiguration) WithPodImageBuilder(value *ObjectReferenceApplyConfiguration) *MachineOSBuilderReferenceApplyConfiguration { + b.PodImageBuilder = value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuildspec.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuildspec.go new file mode 100644 index 000000000000..bb1658b66690 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuildspec.go @@ -0,0 +1,59 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// MachineOSBuildSpecApplyConfiguration represents an declarative configuration of the MachineOSBuildSpec type for use +// with apply. +type MachineOSBuildSpecApplyConfiguration struct { + ConfigGeneration *int64 `json:"configGeneration,omitempty"` + DesiredConfig *RenderedMachineConfigReferenceApplyConfiguration `json:"desiredConfig,omitempty"` + MachineOSConfig *MachineOSConfigReferenceApplyConfiguration `json:"machineOSConfig,omitempty"` + Version *int64 `json:"version,omitempty"` + RenderedImagePushspec *string `json:"renderedImagePushspec,omitempty"` +} + +// MachineOSBuildSpecApplyConfiguration constructs an declarative configuration of the MachineOSBuildSpec type for use with +// apply. +func MachineOSBuildSpec() *MachineOSBuildSpecApplyConfiguration { + return &MachineOSBuildSpecApplyConfiguration{} +} + +// WithConfigGeneration sets the ConfigGeneration field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ConfigGeneration field is set to the value of the last call. +func (b *MachineOSBuildSpecApplyConfiguration) WithConfigGeneration(value int64) *MachineOSBuildSpecApplyConfiguration { + b.ConfigGeneration = &value + return b +} + +// WithDesiredConfig sets the DesiredConfig field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DesiredConfig field is set to the value of the last call. +func (b *MachineOSBuildSpecApplyConfiguration) WithDesiredConfig(value *RenderedMachineConfigReferenceApplyConfiguration) *MachineOSBuildSpecApplyConfiguration { + b.DesiredConfig = value + return b +} + +// WithMachineOSConfig sets the MachineOSConfig field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the MachineOSConfig field is set to the value of the last call. +func (b *MachineOSBuildSpecApplyConfiguration) WithMachineOSConfig(value *MachineOSConfigReferenceApplyConfiguration) *MachineOSBuildSpecApplyConfiguration { + b.MachineOSConfig = value + return b +} + +// WithVersion sets the Version field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Version field is set to the value of the last call. +func (b *MachineOSBuildSpecApplyConfiguration) WithVersion(value int64) *MachineOSBuildSpecApplyConfiguration { + b.Version = &value + return b +} + +// WithRenderedImagePushspec sets the RenderedImagePushspec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the RenderedImagePushspec field is set to the value of the last call. +func (b *MachineOSBuildSpecApplyConfiguration) WithRenderedImagePushspec(value string) *MachineOSBuildSpecApplyConfiguration { + b.RenderedImagePushspec = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuildstatus.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuildstatus.go new file mode 100644 index 000000000000..7542783e5bd0 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosbuildstatus.go @@ -0,0 +1,79 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// MachineOSBuildStatusApplyConfiguration represents an declarative configuration of the MachineOSBuildStatus type for use +// with apply. +type MachineOSBuildStatusApplyConfiguration struct { + Conditions []v1.Condition `json:"conditions,omitempty"` + BuilderReference *MachineOSBuilderReferenceApplyConfiguration `json:"builderReference,omitempty"` + RelatedObjects []ObjectReferenceApplyConfiguration `json:"relatedObjects,omitempty"` + BuildStart *v1.Time `json:"buildStart,omitempty"` + BuildEnd *v1.Time `json:"buildEnd,omitempty"` + FinalImagePushspec *string `json:"finalImagePullspec,omitempty"` +} + +// MachineOSBuildStatusApplyConfiguration constructs an declarative configuration of the MachineOSBuildStatus type for use with +// apply. +func MachineOSBuildStatus() *MachineOSBuildStatusApplyConfiguration { + return &MachineOSBuildStatusApplyConfiguration{} +} + +// WithConditions adds the given value to the Conditions field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Conditions field. +func (b *MachineOSBuildStatusApplyConfiguration) WithConditions(values ...v1.Condition) *MachineOSBuildStatusApplyConfiguration { + for i := range values { + b.Conditions = append(b.Conditions, values[i]) + } + return b +} + +// WithBuilderReference sets the BuilderReference field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the BuilderReference field is set to the value of the last call. +func (b *MachineOSBuildStatusApplyConfiguration) WithBuilderReference(value *MachineOSBuilderReferenceApplyConfiguration) *MachineOSBuildStatusApplyConfiguration { + b.BuilderReference = value + return b +} + +// WithRelatedObjects adds the given value to the RelatedObjects field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the RelatedObjects field. +func (b *MachineOSBuildStatusApplyConfiguration) WithRelatedObjects(values ...*ObjectReferenceApplyConfiguration) *MachineOSBuildStatusApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithRelatedObjects") + } + b.RelatedObjects = append(b.RelatedObjects, *values[i]) + } + return b +} + +// WithBuildStart sets the BuildStart field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the BuildStart field is set to the value of the last call. +func (b *MachineOSBuildStatusApplyConfiguration) WithBuildStart(value v1.Time) *MachineOSBuildStatusApplyConfiguration { + b.BuildStart = &value + return b +} + +// WithBuildEnd sets the BuildEnd field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the BuildEnd field is set to the value of the last call. +func (b *MachineOSBuildStatusApplyConfiguration) WithBuildEnd(value v1.Time) *MachineOSBuildStatusApplyConfiguration { + b.BuildEnd = &value + return b +} + +// WithFinalImagePushspec sets the FinalImagePushspec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the FinalImagePushspec field is set to the value of the last call. +func (b *MachineOSBuildStatusApplyConfiguration) WithFinalImagePushspec(value string) *MachineOSBuildStatusApplyConfiguration { + b.FinalImagePushspec = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfig.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfig.go new file mode 100644 index 000000000000..3b42e6e8859e --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfig.go @@ -0,0 +1,240 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + machineconfigurationv1alpha1 "github.com/openshift/api/machineconfiguration/v1alpha1" + internal "github.com/openshift/client-go/machineconfiguration/applyconfigurations/internal" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + managedfields "k8s.io/apimachinery/pkg/util/managedfields" + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// MachineOSConfigApplyConfiguration represents an declarative configuration of the MachineOSConfig type for use +// with apply. +type MachineOSConfigApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *MachineOSConfigSpecApplyConfiguration `json:"spec,omitempty"` + Status *MachineOSConfigStatusApplyConfiguration `json:"status,omitempty"` +} + +// MachineOSConfig constructs an declarative configuration of the MachineOSConfig type for use with +// apply. +func MachineOSConfig(name string) *MachineOSConfigApplyConfiguration { + b := &MachineOSConfigApplyConfiguration{} + b.WithName(name) + b.WithKind("MachineOSConfig") + b.WithAPIVersion("machineconfiguration.openshift.io/v1alpha1") + return b +} + +// ExtractMachineOSConfig extracts the applied configuration owned by fieldManager from +// machineOSConfig. If no managedFields are found in machineOSConfig for fieldManager, a +// MachineOSConfigApplyConfiguration is returned with only the Name, Namespace (if applicable), +// APIVersion and Kind populated. It is possible that no managed fields were found for because other +// field managers have taken ownership of all the fields previously owned by fieldManager, or because +// the fieldManager never owned fields any fields. +// machineOSConfig must be a unmodified MachineOSConfig API object that was retrieved from the Kubernetes API. +// ExtractMachineOSConfig provides a way to perform a extract/modify-in-place/apply workflow. +// Note that an extracted apply configuration will contain fewer fields than what the fieldManager previously +// applied if another fieldManager has updated or force applied any of the previously applied fields. +// Experimental! +func ExtractMachineOSConfig(machineOSConfig *machineconfigurationv1alpha1.MachineOSConfig, fieldManager string) (*MachineOSConfigApplyConfiguration, error) { + return extractMachineOSConfig(machineOSConfig, fieldManager, "") +} + +// ExtractMachineOSConfigStatus is the same as ExtractMachineOSConfig except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractMachineOSConfigStatus(machineOSConfig *machineconfigurationv1alpha1.MachineOSConfig, fieldManager string) (*MachineOSConfigApplyConfiguration, error) { + return extractMachineOSConfig(machineOSConfig, fieldManager, "status") +} + +func extractMachineOSConfig(machineOSConfig *machineconfigurationv1alpha1.MachineOSConfig, fieldManager string, subresource string) (*MachineOSConfigApplyConfiguration, error) { + b := &MachineOSConfigApplyConfiguration{} + err := managedfields.ExtractInto(machineOSConfig, internal.Parser().Type("com.github.openshift.api.machineconfiguration.v1alpha1.MachineOSConfig"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(machineOSConfig.Name) + + b.WithKind("MachineOSConfig") + b.WithAPIVersion("machineconfiguration.openshift.io/v1alpha1") + return b, nil +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithKind(value string) *MachineOSConfigApplyConfiguration { + b.Kind = &value + return b +} + +// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the APIVersion field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithAPIVersion(value string) *MachineOSConfigApplyConfiguration { + b.APIVersion = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithName(value string) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Name = &value + return b +} + +// WithGenerateName sets the GenerateName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GenerateName field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithGenerateName(value string) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.GenerateName = &value + return b +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithNamespace(value string) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Namespace = &value + return b +} + +// WithUID sets the UID field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the UID field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithUID(value types.UID) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.UID = &value + return b +} + +// WithResourceVersion sets the ResourceVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResourceVersion field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithResourceVersion(value string) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ResourceVersion = &value + return b +} + +// WithGeneration sets the Generation field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Generation field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithGeneration(value int64) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Generation = &value + return b +} + +// WithCreationTimestamp sets the CreationTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CreationTimestamp field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithCreationTimestamp(value metav1.Time) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.CreationTimestamp = &value + return b +} + +// WithDeletionTimestamp sets the DeletionTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionTimestamp field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionTimestamp = &value + return b +} + +// WithDeletionGracePeriodSeconds sets the DeletionGracePeriodSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionGracePeriodSeconds field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionGracePeriodSeconds = &value + return b +} + +// WithLabels puts the entries into the Labels field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Labels field, +// overwriting an existing map entries in Labels field with the same key. +func (b *MachineOSConfigApplyConfiguration) WithLabels(entries map[string]string) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Labels == nil && len(entries) > 0 { + b.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Labels[k] = v + } + return b +} + +// WithAnnotations puts the entries into the Annotations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Annotations field, +// overwriting an existing map entries in Annotations field with the same key. +func (b *MachineOSConfigApplyConfiguration) WithAnnotations(entries map[string]string) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Annotations == nil && len(entries) > 0 { + b.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Annotations[k] = v + } + return b +} + +// WithOwnerReferences adds the given value to the OwnerReferences field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the OwnerReferences field. +func (b *MachineOSConfigApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.OwnerReferences = append(b.OwnerReferences, *values[i]) + } + return b +} + +// WithFinalizers adds the given value to the Finalizers field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Finalizers field. +func (b *MachineOSConfigApplyConfiguration) WithFinalizers(values ...string) *MachineOSConfigApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.Finalizers = append(b.Finalizers, values[i]) + } + return b +} + +func (b *MachineOSConfigApplyConfiguration) ensureObjectMetaApplyConfigurationExists() { + if b.ObjectMetaApplyConfiguration == nil { + b.ObjectMetaApplyConfiguration = &v1.ObjectMetaApplyConfiguration{} + } +} + +// WithSpec sets the Spec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Spec field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithSpec(value *MachineOSConfigSpecApplyConfiguration) *MachineOSConfigApplyConfiguration { + b.Spec = value + return b +} + +// WithStatus sets the Status field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Status field is set to the value of the last call. +func (b *MachineOSConfigApplyConfiguration) WithStatus(value *MachineOSConfigStatusApplyConfiguration) *MachineOSConfigApplyConfiguration { + b.Status = value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigreference.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigreference.go new file mode 100644 index 000000000000..13faab9c7cd3 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigreference.go @@ -0,0 +1,23 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// MachineOSConfigReferenceApplyConfiguration represents an declarative configuration of the MachineOSConfigReference type for use +// with apply. +type MachineOSConfigReferenceApplyConfiguration struct { + Name *string `json:"name,omitempty"` +} + +// MachineOSConfigReferenceApplyConfiguration constructs an declarative configuration of the MachineOSConfigReference type for use with +// apply. +func MachineOSConfigReference() *MachineOSConfigReferenceApplyConfiguration { + return &MachineOSConfigReferenceApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *MachineOSConfigReferenceApplyConfiguration) WithName(value string) *MachineOSConfigReferenceApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigspec.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigspec.go new file mode 100644 index 000000000000..625e30b1de02 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigspec.go @@ -0,0 +1,41 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// MachineOSConfigSpecApplyConfiguration represents an declarative configuration of the MachineOSConfigSpec type for use +// with apply. +type MachineOSConfigSpecApplyConfiguration struct { + MachineConfigPool *MachineConfigPoolReferenceApplyConfiguration `json:"machineConfigPool,omitempty"` + BuildInputs *BuildInputsApplyConfiguration `json:"buildInputs,omitempty"` + BuildOutputs *BuildOutputsApplyConfiguration `json:"buildOutputs,omitempty"` +} + +// MachineOSConfigSpecApplyConfiguration constructs an declarative configuration of the MachineOSConfigSpec type for use with +// apply. +func MachineOSConfigSpec() *MachineOSConfigSpecApplyConfiguration { + return &MachineOSConfigSpecApplyConfiguration{} +} + +// WithMachineConfigPool sets the MachineConfigPool field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the MachineConfigPool field is set to the value of the last call. +func (b *MachineOSConfigSpecApplyConfiguration) WithMachineConfigPool(value *MachineConfigPoolReferenceApplyConfiguration) *MachineOSConfigSpecApplyConfiguration { + b.MachineConfigPool = value + return b +} + +// WithBuildInputs sets the BuildInputs field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the BuildInputs field is set to the value of the last call. +func (b *MachineOSConfigSpecApplyConfiguration) WithBuildInputs(value *BuildInputsApplyConfiguration) *MachineOSConfigSpecApplyConfiguration { + b.BuildInputs = value + return b +} + +// WithBuildOutputs sets the BuildOutputs field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the BuildOutputs field is set to the value of the last call. +func (b *MachineOSConfigSpecApplyConfiguration) WithBuildOutputs(value *BuildOutputsApplyConfiguration) *MachineOSConfigSpecApplyConfiguration { + b.BuildOutputs = value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigstatus.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigstatus.go new file mode 100644 index 000000000000..c9f3e568c84b --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosconfigstatus.go @@ -0,0 +1,47 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// MachineOSConfigStatusApplyConfiguration represents an declarative configuration of the MachineOSConfigStatus type for use +// with apply. +type MachineOSConfigStatusApplyConfiguration struct { + Conditions []v1.Condition `json:"conditions,omitempty"` + ObservedGeneration *int64 `json:"observedGeneration,omitempty"` + CurrentImagePullspec *string `json:"currentImagePullspec,omitempty"` +} + +// MachineOSConfigStatusApplyConfiguration constructs an declarative configuration of the MachineOSConfigStatus type for use with +// apply. +func MachineOSConfigStatus() *MachineOSConfigStatusApplyConfiguration { + return &MachineOSConfigStatusApplyConfiguration{} +} + +// WithConditions adds the given value to the Conditions field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Conditions field. +func (b *MachineOSConfigStatusApplyConfiguration) WithConditions(values ...v1.Condition) *MachineOSConfigStatusApplyConfiguration { + for i := range values { + b.Conditions = append(b.Conditions, values[i]) + } + return b +} + +// WithObservedGeneration sets the ObservedGeneration field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ObservedGeneration field is set to the value of the last call. +func (b *MachineOSConfigStatusApplyConfiguration) WithObservedGeneration(value int64) *MachineOSConfigStatusApplyConfiguration { + b.ObservedGeneration = &value + return b +} + +// WithCurrentImagePullspec sets the CurrentImagePullspec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CurrentImagePullspec field is set to the value of the last call. +func (b *MachineOSConfigStatusApplyConfiguration) WithCurrentImagePullspec(value string) *MachineOSConfigStatusApplyConfiguration { + b.CurrentImagePullspec = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineoscontainerfile.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineoscontainerfile.go new file mode 100644 index 000000000000..efe0feeddf07 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineoscontainerfile.go @@ -0,0 +1,36 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/openshift/api/machineconfiguration/v1alpha1" +) + +// MachineOSContainerfileApplyConfiguration represents an declarative configuration of the MachineOSContainerfile type for use +// with apply. +type MachineOSContainerfileApplyConfiguration struct { + ContainerfileArch *v1alpha1.ContainerfileArch `json:"containerfileArch,omitempty"` + Content *string `json:"content,omitempty"` +} + +// MachineOSContainerfileApplyConfiguration constructs an declarative configuration of the MachineOSContainerfile type for use with +// apply. +func MachineOSContainerfile() *MachineOSContainerfileApplyConfiguration { + return &MachineOSContainerfileApplyConfiguration{} +} + +// WithContainerfileArch sets the ContainerfileArch field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ContainerfileArch field is set to the value of the last call. +func (b *MachineOSContainerfileApplyConfiguration) WithContainerfileArch(value v1alpha1.ContainerfileArch) *MachineOSContainerfileApplyConfiguration { + b.ContainerfileArch = &value + return b +} + +// WithContent sets the Content field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Content field is set to the value of the last call. +func (b *MachineOSContainerfileApplyConfiguration) WithContent(value string) *MachineOSContainerfileApplyConfiguration { + b.Content = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosimagebuilder.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosimagebuilder.go new file mode 100644 index 000000000000..932adf4623c5 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/machineosimagebuilder.go @@ -0,0 +1,27 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/openshift/api/machineconfiguration/v1alpha1" +) + +// MachineOSImageBuilderApplyConfiguration represents an declarative configuration of the MachineOSImageBuilder type for use +// with apply. +type MachineOSImageBuilderApplyConfiguration struct { + ImageBuilderType *v1alpha1.MachineOSImageBuilderType `json:"imageBuilderType,omitempty"` +} + +// MachineOSImageBuilderApplyConfiguration constructs an declarative configuration of the MachineOSImageBuilder type for use with +// apply. +func MachineOSImageBuilder() *MachineOSImageBuilderApplyConfiguration { + return &MachineOSImageBuilderApplyConfiguration{} +} + +// WithImageBuilderType sets the ImageBuilderType field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ImageBuilderType field is set to the value of the last call. +func (b *MachineOSImageBuilderApplyConfiguration) WithImageBuilderType(value v1alpha1.MachineOSImageBuilderType) *MachineOSImageBuilderApplyConfiguration { + b.ImageBuilderType = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/objectreference.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/objectreference.go new file mode 100644 index 000000000000..c11e8c5008d7 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/objectreference.go @@ -0,0 +1,50 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// ObjectReferenceApplyConfiguration represents an declarative configuration of the ObjectReference type for use +// with apply. +type ObjectReferenceApplyConfiguration struct { + Group *string `json:"group,omitempty"` + Resource *string `json:"resource,omitempty"` + Namespace *string `json:"namespace,omitempty"` + Name *string `json:"name,omitempty"` +} + +// ObjectReferenceApplyConfiguration constructs an declarative configuration of the ObjectReference type for use with +// apply. +func ObjectReference() *ObjectReferenceApplyConfiguration { + return &ObjectReferenceApplyConfiguration{} +} + +// WithGroup sets the Group field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Group field is set to the value of the last call. +func (b *ObjectReferenceApplyConfiguration) WithGroup(value string) *ObjectReferenceApplyConfiguration { + b.Group = &value + return b +} + +// WithResource sets the Resource field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Resource field is set to the value of the last call. +func (b *ObjectReferenceApplyConfiguration) WithResource(value string) *ObjectReferenceApplyConfiguration { + b.Resource = &value + return b +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *ObjectReferenceApplyConfiguration) WithNamespace(value string) *ObjectReferenceApplyConfiguration { + b.Namespace = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *ObjectReferenceApplyConfiguration) WithName(value string) *ObjectReferenceApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/renderedmachineconfigreference.go b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/renderedmachineconfigreference.go new file mode 100644 index 000000000000..c83eb2f1e4d0 --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1/renderedmachineconfigreference.go @@ -0,0 +1,23 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// RenderedMachineConfigReferenceApplyConfiguration represents an declarative configuration of the RenderedMachineConfigReference type for use +// with apply. +type RenderedMachineConfigReferenceApplyConfiguration struct { + Name *string `json:"name,omitempty"` +} + +// RenderedMachineConfigReferenceApplyConfiguration constructs an declarative configuration of the RenderedMachineConfigReference type for use with +// apply. +func RenderedMachineConfigReference() *RenderedMachineConfigReferenceApplyConfiguration { + return &RenderedMachineConfigReferenceApplyConfiguration{} +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *RenderedMachineConfigReferenceApplyConfiguration) WithName(value string) *RenderedMachineConfigReferenceApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/generated_expansion.go b/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/generated_expansion.go index f73dfece1fa0..7fa949aeee71 100644 --- a/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/generated_expansion.go +++ b/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/generated_expansion.go @@ -4,4 +4,8 @@ package v1alpha1 type MachineConfigNodeExpansion interface{} +type MachineOSBuildExpansion interface{} + +type MachineOSConfigExpansion interface{} + type PinnedImageSetExpansion interface{} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineconfiguration_client.go b/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineconfiguration_client.go index 866d96b95dbf..2266053dcbda 100644 --- a/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineconfiguration_client.go +++ b/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineconfiguration_client.go @@ -13,6 +13,8 @@ import ( type MachineconfigurationV1alpha1Interface interface { RESTClient() rest.Interface MachineConfigNodesGetter + MachineOSBuildsGetter + MachineOSConfigsGetter PinnedImageSetsGetter } @@ -25,6 +27,14 @@ func (c *MachineconfigurationV1alpha1Client) MachineConfigNodes() MachineConfigN return newMachineConfigNodes(c) } +func (c *MachineconfigurationV1alpha1Client) MachineOSBuilds() MachineOSBuildInterface { + return newMachineOSBuilds(c) +} + +func (c *MachineconfigurationV1alpha1Client) MachineOSConfigs() MachineOSConfigInterface { + return newMachineOSConfigs(c) +} + func (c *MachineconfigurationV1alpha1Client) PinnedImageSets() PinnedImageSetInterface { return newPinnedImageSets(c) } diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineosbuild.go b/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineosbuild.go new file mode 100644 index 000000000000..34c6cfdaee2d --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineosbuild.go @@ -0,0 +1,227 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + json "encoding/json" + "fmt" + "time" + + v1alpha1 "github.com/openshift/api/machineconfiguration/v1alpha1" + machineconfigurationv1alpha1 "github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1" + scheme "github.com/openshift/client-go/machineconfiguration/clientset/versioned/scheme" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// MachineOSBuildsGetter has a method to return a MachineOSBuildInterface. +// A group's client should implement this interface. +type MachineOSBuildsGetter interface { + MachineOSBuilds() MachineOSBuildInterface +} + +// MachineOSBuildInterface has methods to work with MachineOSBuild resources. +type MachineOSBuildInterface interface { + Create(ctx context.Context, machineOSBuild *v1alpha1.MachineOSBuild, opts v1.CreateOptions) (*v1alpha1.MachineOSBuild, error) + Update(ctx context.Context, machineOSBuild *v1alpha1.MachineOSBuild, opts v1.UpdateOptions) (*v1alpha1.MachineOSBuild, error) + UpdateStatus(ctx context.Context, machineOSBuild *v1alpha1.MachineOSBuild, opts v1.UpdateOptions) (*v1alpha1.MachineOSBuild, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.MachineOSBuild, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.MachineOSBuildList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.MachineOSBuild, err error) + Apply(ctx context.Context, machineOSBuild *machineconfigurationv1alpha1.MachineOSBuildApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.MachineOSBuild, err error) + ApplyStatus(ctx context.Context, machineOSBuild *machineconfigurationv1alpha1.MachineOSBuildApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.MachineOSBuild, err error) + MachineOSBuildExpansion +} + +// machineOSBuilds implements MachineOSBuildInterface +type machineOSBuilds struct { + client rest.Interface +} + +// newMachineOSBuilds returns a MachineOSBuilds +func newMachineOSBuilds(c *MachineconfigurationV1alpha1Client) *machineOSBuilds { + return &machineOSBuilds{ + client: c.RESTClient(), + } +} + +// Get takes name of the machineOSBuild, and returns the corresponding machineOSBuild object, and an error if there is any. +func (c *machineOSBuilds) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.MachineOSBuild, err error) { + result = &v1alpha1.MachineOSBuild{} + err = c.client.Get(). + Resource("machineosbuilds"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of MachineOSBuilds that match those selectors. +func (c *machineOSBuilds) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.MachineOSBuildList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.MachineOSBuildList{} + err = c.client.Get(). + Resource("machineosbuilds"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested machineOSBuilds. +func (c *machineOSBuilds) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Resource("machineosbuilds"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a machineOSBuild and creates it. Returns the server's representation of the machineOSBuild, and an error, if there is any. +func (c *machineOSBuilds) Create(ctx context.Context, machineOSBuild *v1alpha1.MachineOSBuild, opts v1.CreateOptions) (result *v1alpha1.MachineOSBuild, err error) { + result = &v1alpha1.MachineOSBuild{} + err = c.client.Post(). + Resource("machineosbuilds"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(machineOSBuild). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a machineOSBuild and updates it. Returns the server's representation of the machineOSBuild, and an error, if there is any. +func (c *machineOSBuilds) Update(ctx context.Context, machineOSBuild *v1alpha1.MachineOSBuild, opts v1.UpdateOptions) (result *v1alpha1.MachineOSBuild, err error) { + result = &v1alpha1.MachineOSBuild{} + err = c.client.Put(). + Resource("machineosbuilds"). + Name(machineOSBuild.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(machineOSBuild). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *machineOSBuilds) UpdateStatus(ctx context.Context, machineOSBuild *v1alpha1.MachineOSBuild, opts v1.UpdateOptions) (result *v1alpha1.MachineOSBuild, err error) { + result = &v1alpha1.MachineOSBuild{} + err = c.client.Put(). + Resource("machineosbuilds"). + Name(machineOSBuild.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(machineOSBuild). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the machineOSBuild and deletes it. Returns an error if one occurs. +func (c *machineOSBuilds) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Resource("machineosbuilds"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *machineOSBuilds) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("machineosbuilds"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched machineOSBuild. +func (c *machineOSBuilds) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.MachineOSBuild, err error) { + result = &v1alpha1.MachineOSBuild{} + err = c.client.Patch(pt). + Resource("machineosbuilds"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// Apply takes the given apply declarative configuration, applies it and returns the applied machineOSBuild. +func (c *machineOSBuilds) Apply(ctx context.Context, machineOSBuild *machineconfigurationv1alpha1.MachineOSBuildApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.MachineOSBuild, err error) { + if machineOSBuild == nil { + return nil, fmt.Errorf("machineOSBuild provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(machineOSBuild) + if err != nil { + return nil, err + } + name := machineOSBuild.Name + if name == nil { + return nil, fmt.Errorf("machineOSBuild.Name must be provided to Apply") + } + result = &v1alpha1.MachineOSBuild{} + err = c.client.Patch(types.ApplyPatchType). + Resource("machineosbuilds"). + Name(*name). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// ApplyStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). +func (c *machineOSBuilds) ApplyStatus(ctx context.Context, machineOSBuild *machineconfigurationv1alpha1.MachineOSBuildApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.MachineOSBuild, err error) { + if machineOSBuild == nil { + return nil, fmt.Errorf("machineOSBuild provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(machineOSBuild) + if err != nil { + return nil, err + } + + name := machineOSBuild.Name + if name == nil { + return nil, fmt.Errorf("machineOSBuild.Name must be provided to Apply") + } + + result = &v1alpha1.MachineOSBuild{} + err = c.client.Patch(types.ApplyPatchType). + Resource("machineosbuilds"). + Name(*name). + SubResource("status"). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineosconfig.go b/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineosconfig.go new file mode 100644 index 000000000000..caef8fbb8aed --- /dev/null +++ b/vendor/github.com/openshift/client-go/machineconfiguration/clientset/versioned/typed/machineconfiguration/v1alpha1/machineosconfig.go @@ -0,0 +1,227 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + json "encoding/json" + "fmt" + "time" + + v1alpha1 "github.com/openshift/api/machineconfiguration/v1alpha1" + machineconfigurationv1alpha1 "github.com/openshift/client-go/machineconfiguration/applyconfigurations/machineconfiguration/v1alpha1" + scheme "github.com/openshift/client-go/machineconfiguration/clientset/versioned/scheme" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// MachineOSConfigsGetter has a method to return a MachineOSConfigInterface. +// A group's client should implement this interface. +type MachineOSConfigsGetter interface { + MachineOSConfigs() MachineOSConfigInterface +} + +// MachineOSConfigInterface has methods to work with MachineOSConfig resources. +type MachineOSConfigInterface interface { + Create(ctx context.Context, machineOSConfig *v1alpha1.MachineOSConfig, opts v1.CreateOptions) (*v1alpha1.MachineOSConfig, error) + Update(ctx context.Context, machineOSConfig *v1alpha1.MachineOSConfig, opts v1.UpdateOptions) (*v1alpha1.MachineOSConfig, error) + UpdateStatus(ctx context.Context, machineOSConfig *v1alpha1.MachineOSConfig, opts v1.UpdateOptions) (*v1alpha1.MachineOSConfig, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.MachineOSConfig, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.MachineOSConfigList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.MachineOSConfig, err error) + Apply(ctx context.Context, machineOSConfig *machineconfigurationv1alpha1.MachineOSConfigApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.MachineOSConfig, err error) + ApplyStatus(ctx context.Context, machineOSConfig *machineconfigurationv1alpha1.MachineOSConfigApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.MachineOSConfig, err error) + MachineOSConfigExpansion +} + +// machineOSConfigs implements MachineOSConfigInterface +type machineOSConfigs struct { + client rest.Interface +} + +// newMachineOSConfigs returns a MachineOSConfigs +func newMachineOSConfigs(c *MachineconfigurationV1alpha1Client) *machineOSConfigs { + return &machineOSConfigs{ + client: c.RESTClient(), + } +} + +// Get takes name of the machineOSConfig, and returns the corresponding machineOSConfig object, and an error if there is any. +func (c *machineOSConfigs) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.MachineOSConfig, err error) { + result = &v1alpha1.MachineOSConfig{} + err = c.client.Get(). + Resource("machineosconfigs"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of MachineOSConfigs that match those selectors. +func (c *machineOSConfigs) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.MachineOSConfigList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.MachineOSConfigList{} + err = c.client.Get(). + Resource("machineosconfigs"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested machineOSConfigs. +func (c *machineOSConfigs) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Resource("machineosconfigs"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a machineOSConfig and creates it. Returns the server's representation of the machineOSConfig, and an error, if there is any. +func (c *machineOSConfigs) Create(ctx context.Context, machineOSConfig *v1alpha1.MachineOSConfig, opts v1.CreateOptions) (result *v1alpha1.MachineOSConfig, err error) { + result = &v1alpha1.MachineOSConfig{} + err = c.client.Post(). + Resource("machineosconfigs"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(machineOSConfig). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a machineOSConfig and updates it. Returns the server's representation of the machineOSConfig, and an error, if there is any. +func (c *machineOSConfigs) Update(ctx context.Context, machineOSConfig *v1alpha1.MachineOSConfig, opts v1.UpdateOptions) (result *v1alpha1.MachineOSConfig, err error) { + result = &v1alpha1.MachineOSConfig{} + err = c.client.Put(). + Resource("machineosconfigs"). + Name(machineOSConfig.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(machineOSConfig). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *machineOSConfigs) UpdateStatus(ctx context.Context, machineOSConfig *v1alpha1.MachineOSConfig, opts v1.UpdateOptions) (result *v1alpha1.MachineOSConfig, err error) { + result = &v1alpha1.MachineOSConfig{} + err = c.client.Put(). + Resource("machineosconfigs"). + Name(machineOSConfig.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(machineOSConfig). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the machineOSConfig and deletes it. Returns an error if one occurs. +func (c *machineOSConfigs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Resource("machineosconfigs"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *machineOSConfigs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("machineosconfigs"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched machineOSConfig. +func (c *machineOSConfigs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.MachineOSConfig, err error) { + result = &v1alpha1.MachineOSConfig{} + err = c.client.Patch(pt). + Resource("machineosconfigs"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// Apply takes the given apply declarative configuration, applies it and returns the applied machineOSConfig. +func (c *machineOSConfigs) Apply(ctx context.Context, machineOSConfig *machineconfigurationv1alpha1.MachineOSConfigApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.MachineOSConfig, err error) { + if machineOSConfig == nil { + return nil, fmt.Errorf("machineOSConfig provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(machineOSConfig) + if err != nil { + return nil, err + } + name := machineOSConfig.Name + if name == nil { + return nil, fmt.Errorf("machineOSConfig.Name must be provided to Apply") + } + result = &v1alpha1.MachineOSConfig{} + err = c.client.Patch(types.ApplyPatchType). + Resource("machineosconfigs"). + Name(*name). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// ApplyStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). +func (c *machineOSConfigs) ApplyStatus(ctx context.Context, machineOSConfig *machineconfigurationv1alpha1.MachineOSConfigApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.MachineOSConfig, err error) { + if machineOSConfig == nil { + return nil, fmt.Errorf("machineOSConfig provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(machineOSConfig) + if err != nil { + return nil, err + } + + name := machineOSConfig.Name + if name == nil { + return nil, fmt.Errorf("machineOSConfig.Name must be provided to Apply") + } + + result = &v1alpha1.MachineOSConfig{} + err = c.client.Patch(types.ApplyPatchType). + Resource("machineosconfigs"). + Name(*name). + SubResource("status"). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/internal/internal.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/internal/internal.go index 3da9ce044e43..1403c9aad94b 100644 --- a/vendor/github.com/openshift/client-go/operator/applyconfigurations/internal/internal.go +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/internal/internal.go @@ -1711,6 +1711,9 @@ var schemaYAML = typed.YAMLObject(`types: - name: clientTimeout type: namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Duration + - name: connectTimeout + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Duration - name: headerBufferBytes type: scalar: numeric diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1/ingresscontrollertuningoptions.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1/ingresscontrollertuningoptions.go index be71c52c88e1..331f9585a7be 100644 --- a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1/ingresscontrollertuningoptions.go +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1/ingresscontrollertuningoptions.go @@ -17,6 +17,7 @@ type IngressControllerTuningOptionsApplyConfiguration struct { ServerTimeout *v1.Duration `json:"serverTimeout,omitempty"` ServerFinTimeout *v1.Duration `json:"serverFinTimeout,omitempty"` TunnelTimeout *v1.Duration `json:"tunnelTimeout,omitempty"` + ConnectTimeout *v1.Duration `json:"connectTimeout,omitempty"` TLSInspectDelay *v1.Duration `json:"tlsInspectDelay,omitempty"` HealthCheckInterval *v1.Duration `json:"healthCheckInterval,omitempty"` MaxConnections *int32 `json:"maxConnections,omitempty"` @@ -93,6 +94,14 @@ func (b *IngressControllerTuningOptionsApplyConfiguration) WithTunnelTimeout(val return b } +// WithConnectTimeout sets the ConnectTimeout field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ConnectTimeout field is set to the value of the last call. +func (b *IngressControllerTuningOptionsApplyConfiguration) WithConnectTimeout(value v1.Duration) *IngressControllerTuningOptionsApplyConfiguration { + b.ConnectTimeout = &value + return b +} + // WithTLSInspectDelay sets the TLSInspectDelay field in the declarative configuration to the given value // and returns the receiver, so that objects can be built by chaining "With" function invocations. // If called multiple times, the TLSInspectDelay field is set to the value of the last call. diff --git a/vendor/modules.txt b/vendor/modules.txt index ae8a6ba0192b..a2fb2ba3842f 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -874,7 +874,7 @@ github.com/openshift/build-machinery-go/make/targets/golang github.com/openshift/build-machinery-go/make/targets/openshift github.com/openshift/build-machinery-go/make/targets/openshift/operator github.com/openshift/build-machinery-go/scripts -# github.com/openshift/client-go v0.0.0-20240405120947-c67c8325cdd8 +# github.com/openshift/client-go v0.0.0-20240408153607-64bd6feb83ae ## explicit; go 1.21 github.com/openshift/client-go/apiserver/applyconfigurations/apiserver/v1 github.com/openshift/client-go/apiserver/applyconfigurations/internal diff --git a/zz_generated.manifests/test-reporting.yaml b/zz_generated.manifests/test-reporting.yaml index ca71df89a37a..cb712479189b 100644 --- a/zz_generated.manifests/test-reporting.yaml +++ b/zz_generated.manifests/test-reporting.yaml @@ -9,6 +9,20 @@ spec: tests: - testName: '[sig-arch][OCPFeatureGate:Example] should only run FeatureGated test when enabled' + - featureGate: NetworkDiagnosticsConfig + tests: + - testName: '[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should + be enabled by default' + - testName: '[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should + function without any target pods' + - testName: '[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should + move the source diagnostics pods based on the new selector and tolerations' + - testName: '[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should + move the target diagnostics pods based on the new selector and tolerations' + - testName: '[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should + remove all network diagnostics pods when disabled' + - testName: '[sig-network][OCPFeatureGate:NetworkDiagnosticsConfig][Serial] Should + set the condition to false if there are no nodes able to host the source pods' - featureGate: ValidatingAdmissionPolicy tests: - testName: '[sig-api-machinery] ValidatingAdmissionPolicy [Privileged:ClusterAdmin]