diff --git a/cmd/machine-config-controller/start.go b/cmd/machine-config-controller/start.go index 769df54f7a..c5645dae96 100644 --- a/cmd/machine-config-controller/start.go +++ b/cmd/machine-config-controller/start.go @@ -116,9 +116,11 @@ func createControllers(ctx *ctrlcommon.ControllerContext) []ctrlcommon.Controlle ctx.InformerFactory.Machineconfiguration().V1().ControllerConfigs(), ctx.InformerFactory.Machineconfiguration().V1().KubeletConfigs(), ctx.ConfigInformerFactory.Config().V1().FeatureGates(), + ctx.ConfigInformerFactory.Config().V1().Nodes(), ctx.ConfigInformerFactory.Config().V1().APIServers(), ctx.ClientBuilder.KubeClientOrDie("kubelet-config-controller"), ctx.ClientBuilder.MachineConfigClientOrDie("kubelet-config-controller"), + ctx.ClientBuilder.ConfigClientOrDie("kubelet-config-controller"), ), containerruntimeconfig.New( rootOpts.templates, diff --git a/go.mod b/go.mod index 5107b11d7e..f468556ec3 100644 --- a/go.mod +++ b/go.mod @@ -25,8 +25,8 @@ require ( github.com/google/renameio v0.1.0 github.com/imdario/mergo v0.3.12 github.com/opencontainers/go-digest v1.0.0 - github.com/openshift/api v0.0.0-20220310165943-abf6417c2748 - github.com/openshift/client-go v0.0.0-20211209144617-7385dd6338e3 + github.com/openshift/api v0.0.0-20220412161459-8f38b7648620 + github.com/openshift/client-go v0.0.0-20220411091747-c100636b0bc0 github.com/openshift/library-go v0.0.0-20211220195323-eca2c467c492 github.com/openshift/runtime-utils v0.0.0-20220225175100-8dec0d84fb39 github.com/pkg/errors v0.9.1 diff --git a/go.sum b/go.sum index 694f34abdc..db7877a0fd 100644 --- a/go.sum +++ b/go.sum @@ -1057,13 +1057,15 @@ github.com/opencontainers/selinux v1.8.5/go.mod h1:HTvjPFoGMbpQsG886e3lQwnsRWtE4 github.com/opencontainers/selinux v1.9.1/go.mod h1:2i0OySw99QjzBBQByd1Gr9gSjvuho1lHsJxIJ3gGbJI= github.com/openshift/api v0.0.0-20200326160804-ecb9283fe820/go.mod h1:RKMJ5CBnljLfnej+BJ/xnOWc3kZDvJUaIAEq2oKSPtE= github.com/openshift/api v0.0.0-20211209135129-c58d9f695577/go.mod h1:DoslCwtqUpr3d/gsbq4ZlkaMEdYqKxuypsDjorcHhME= -github.com/openshift/api v0.0.0-20220310165943-abf6417c2748 h1:+LW/1gfPO3IXxgJKfdwgVAc7fdTj+rB1I8rSVGHJVFU= -github.com/openshift/api v0.0.0-20220310165943-abf6417c2748/go.mod h1:F/eU6jgr6Q2VhMu1mSpMmygxAELd7+BUxs3NHZ25jV4= +github.com/openshift/api v0.0.0-20220409151926-43bbec6227d5/go.mod h1:F/eU6jgr6Q2VhMu1mSpMmygxAELd7+BUxs3NHZ25jV4= +github.com/openshift/api v0.0.0-20220412161459-8f38b7648620 h1:eNClZcEJo3EUIMCkK2GPrXl4lrFNfyKGRFVrUEZ8JIk= +github.com/openshift/api v0.0.0-20220412161459-8f38b7648620/go.mod h1:F/eU6jgr6Q2VhMu1mSpMmygxAELd7+BUxs3NHZ25jV4= github.com/openshift/build-machinery-go v0.0.0-20200211121458-5e3d6e570160/go.mod h1:1CkcsT3aVebzRBzVTSbiKSkJMsC/CASqxesfqEMfJEc= github.com/openshift/build-machinery-go v0.0.0-20210712174854-1bb7fd1518d3/go.mod h1:b1BuldmJlbA/xYtdZvKi+7j5YGB44qJUJDZ9zwiNCfE= github.com/openshift/build-machinery-go v0.0.0-20211213093930-7e33a7eb4ce3/go.mod h1:b1BuldmJlbA/xYtdZvKi+7j5YGB44qJUJDZ9zwiNCfE= -github.com/openshift/client-go v0.0.0-20211209144617-7385dd6338e3 h1:SG1aqwleU6bGD0X4mhkTNupjVnByMYYuW4XbnCPavQU= github.com/openshift/client-go v0.0.0-20211209144617-7385dd6338e3/go.mod h1:cwhyki5lqBmrT0m8Im+9I7PGFaraOzcYPtEz93RcsGY= +github.com/openshift/client-go v0.0.0-20220411091747-c100636b0bc0 h1:dZZJT2aINho70JcEDs85fW0E+Ug9aVmeDDHdvJYnroA= +github.com/openshift/client-go v0.0.0-20220411091747-c100636b0bc0/go.mod h1:dUE4zBPh9kKaPm9e8qbMBh5RDu3zEO2jo0md4veGYaI= github.com/openshift/library-go v0.0.0-20211220195323-eca2c467c492 h1:oj/rSQqVWVj6YJUydZwLz2frrJreiyI4oa9g/YPgMsM= github.com/openshift/library-go v0.0.0-20211220195323-eca2c467c492/go.mod h1:4UQ9snU1vg53fyTpHQw3vLPiAxI8ub5xrc+y8KPQQFs= github.com/openshift/runtime-utils v0.0.0-20220225175100-8dec0d84fb39 h1:5woAtivjIZDVaRdMRDstmSBd0hHLsdYcdumLCMs0dwk= diff --git a/manifests/machineconfigcontroller/clusterrole.yaml b/manifests/machineconfigcontroller/clusterrole.yaml index b60bfb90f5..bd1ce8d872 100644 --- a/manifests/machineconfigcontroller/clusterrole.yaml +++ b/manifests/machineconfigcontroller/clusterrole.yaml @@ -13,7 +13,7 @@ rules: resources: ["configmaps", "secrets"] verbs: ["*"] - apiGroups: ["config.openshift.io"] - resources: ["images", "clusterversions", "featuregates"] + resources: ["images", "clusterversions", "featuregates", "nodes", "nodes/status"] verbs: ["*"] - apiGroups: ["config.openshift.io"] resources: ["schedulers", "apiservers", "infrastructures"] diff --git a/pkg/apis/machineconfiguration.openshift.io/v1/types.go b/pkg/apis/machineconfiguration.openshift.io/v1/types.go index 4c2cccf9ab..eb1f28ab99 100644 --- a/pkg/apis/machineconfiguration.openshift.io/v1/types.go +++ b/pkg/apis/machineconfiguration.openshift.io/v1/types.go @@ -13,6 +13,9 @@ import ( // For example: `master` or `worker` const MachineConfigRoleLabelKey = "machineconfiguration.openshift.io/role" +// KubeletConfigRoleLabelPrefix is the label that must be present in the KubeletConfig CR +const KubeletConfigRoleLabelPrefix = "pools.operator.machineconfiguration.openshift.io/" + // +genclient // +genclient:nonNamespaced // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object diff --git a/pkg/controller/bootstrap/bootstrap.go b/pkg/controller/bootstrap/bootstrap.go index 5cbb6cd009..4e50adce65 100644 --- a/pkg/controller/bootstrap/bootstrap.go +++ b/pkg/controller/bootstrap/bootstrap.go @@ -74,6 +74,7 @@ func (b *Bootstrap) Run(destDir string) error { var cconfig *mcfgv1.ControllerConfig var featureGate *apicfgv1.FeatureGate + var nodeConfig *apicfgv1.Node var kconfigs []*mcfgv1.KubeletConfig var pools []*mcfgv1.MachineConfigPool var configs []*mcfgv1.MachineConfig @@ -126,6 +127,10 @@ func (b *Bootstrap) Run(destDir string) error { if obj.GetName() == ctrlcommon.ClusterFeatureInstanceName { featureGate = obj } + case *apicfgv1.Node: + if obj.GetName() == ctrlcommon.ClusterNodeInstanceName { + nodeConfig = obj + } default: glog.Infof("skipping %q [%d] manifest because of unhandled %T", file.Name(), idx+1, obji) } @@ -156,14 +161,22 @@ func (b *Bootstrap) Run(destDir string) error { configs = append(configs, containerRuntimeConfigs...) } if featureGate != nil { - featureConfigs, err := kubeletconfig.RunFeatureGateBootstrap(b.templatesDir, featureGate, cconfig, pools) + featureConfigs, err := kubeletconfig.RunFeatureGateBootstrap(b.templatesDir, featureGate, nodeConfig, cconfig, pools) if err != nil { return err } configs = append(configs, featureConfigs...) } + + if nodeConfig != nil { + nodeConfigs, err := kubeletconfig.RunNodeConfigBootstrap(b.templatesDir, featureGate, cconfig, nodeConfig, pools) + if err != nil { + return err + } + configs = append(configs, nodeConfigs...) + } if len(kconfigs) > 0 { - kconfigs, err := kubeletconfig.RunKubeletBootstrap(b.templatesDir, kconfigs, cconfig, featureGate, pools) + kconfigs, err := kubeletconfig.RunKubeletBootstrap(b.templatesDir, kconfigs, cconfig, featureGate, nodeConfig, pools) if err != nil { return err } diff --git a/pkg/controller/common/constants.go b/pkg/controller/common/constants.go index 3a02cd7deb..aa1fa75961 100644 --- a/pkg/controller/common/constants.go +++ b/pkg/controller/common/constants.go @@ -30,4 +30,12 @@ const ( // ClusterFeatureInstanceName is a singleton name for featureGate configuration ClusterFeatureInstanceName = "cluster" + + // ClusterNodeInstanceName is a singleton name for node configuration + ClusterNodeInstanceName = "cluster" + + // MachineConfigPoolMaster is the MachineConfigPool name given to the master + MachineConfigPoolMaster = "master" + // MachineConfigPoolWorker is the MachineConfigPool name given to the worker + MachineConfigPoolWorker = "worker" ) diff --git a/pkg/controller/kubelet-config/helpers.go b/pkg/controller/kubelet-config/helpers.go index bb16bb5495..f9bc4f131e 100644 --- a/pkg/controller/kubelet-config/helpers.go +++ b/pkg/controller/kubelet-config/helpers.go @@ -5,6 +5,7 @@ import ( "context" "encoding/json" "fmt" + "reflect" "strconv" ign3types "github.com/coreos/ignition/v2/config/v3_2/types" @@ -131,6 +132,42 @@ func createNewDefaultFeatureGate() *osev1.FeatureGate { } } +func createNewDefaultNodeconfig() *osev1.Node { + return &osev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: ctrlcommon.ClusterNodeInstanceName, + }, + Spec: osev1.NodeSpec{ + CgroupMode: osev1.CgroupModeDefault, + WorkerLatencyProfile: osev1.DefaultUpdateDefaultReaction, + }, + } +} + +// updateOriginalKubeConfigwithNodeConfig updates the original Kubelet Configuration based on the Nodespecific configuration +func updateOriginalKubeConfigwithNodeConfig(node *osev1.Node, originalKubeletConfig *kubeletconfigv1beta1.KubeletConfiguration) error { + if node == nil { + return fmt.Errorf("node configuration not found, failed to update the original kubelet configuration") + } + if reflect.DeepEqual(node.Spec, osev1.NodeSpec{}) { + return fmt.Errorf("empty node resource spec found") + } + // updating the kubelet specific fields based on the Node's workerlatency profile. + // (TODO): The durations can be replaced with the defined constants in the openshift/api repository once the respective changes are merged. + switch node.Spec.WorkerLatencyProfile { + case osev1.MediumUpdateAverageReaction: + originalKubeletConfig.NodeStatusUpdateFrequency = metav1.Duration{Duration: osev1.MediumNodeStatusUpdateFrequency} + case osev1.LowUpdateSlowReaction: + originalKubeletConfig.NodeStatusUpdateFrequency = metav1.Duration{Duration: osev1.LowNodeStatusUpdateFrequency} + case osev1.DefaultUpdateDefaultReaction: + originalKubeletConfig.NodeStatusUpdateFrequency = metav1.Duration{Duration: osev1.DefaultNodeStatusUpdateFrequency} + default: + return fmt.Errorf("unknown worker latency profile type found %v, failed to update the original kubelet configuration", node.Spec.WorkerLatencyProfile) + } + // The kubelet configuration can be updated based on the cgroupmode as well here. + return nil +} + func findKubeletConfig(mc *mcfgv1.MachineConfig) (*ign3types.File, error) { ignCfg, err := ctrlcommon.ParseAndConvertConfig(mc.Spec.Config.Raw) if err != nil { @@ -227,6 +264,10 @@ func getManagedFeaturesKeyDeprecated(pool *mcfgv1.MachineConfigPool) string { return fmt.Sprintf("98-%s-%s-kubelet", pool.Name, pool.ObjectMeta.UID) } +func getManagedNodeConfigKey(pool *mcfgv1.MachineConfigPool, client mcfgclientset.Interface) (string, error) { + return ctrlcommon.GetManagedKey(pool, client, "97", "kubelet", fmt.Sprintf("97-%s-%s-kubelet", pool.Name, pool.ObjectMeta.UID)) +} + // Deprecated: use getManagedKubeletConfigKey func getManagedKubeletConfigKeyDeprecated(pool *mcfgv1.MachineConfigPool) string { return fmt.Sprintf("99-%s-%s-kubelet", pool.Name, pool.ObjectMeta.UID) diff --git a/pkg/controller/kubelet-config/kubelet_config_bootstrap.go b/pkg/controller/kubelet-config/kubelet_config_bootstrap.go index 90fe3c14fd..4c999b3bd7 100644 --- a/pkg/controller/kubelet-config/kubelet_config_bootstrap.go +++ b/pkg/controller/kubelet-config/kubelet_config_bootstrap.go @@ -13,7 +13,7 @@ import ( ) // RunKubeletBootstrap generates MachineConfig objects for mcpPools that would have been generated by syncKubeletConfig -func RunKubeletBootstrap(templateDir string, kubeletConfigs []*mcfgv1.KubeletConfig, controllerConfig *mcfgv1.ControllerConfig, features *configv1.FeatureGate, mcpPools []*mcfgv1.MachineConfigPool) ([]*mcfgv1.MachineConfig, error) { +func RunKubeletBootstrap(templateDir string, kubeletConfigs []*mcfgv1.KubeletConfig, controllerConfig *mcfgv1.ControllerConfig, features *configv1.FeatureGate, nodeConfig *configv1.Node, mcpPools []*mcfgv1.MachineConfigPool) ([]*mcfgv1.MachineConfig, error) { var res []*mcfgv1.MachineConfig managedKeyExist := make(map[string]bool) userDefinedSystemReserved := make(map[string]string) @@ -43,6 +43,13 @@ func RunKubeletBootstrap(templateDir string, kubeletConfigs []*mcfgv1.KubeletCon if err != nil { return nil, err } + // updating the originalKubeConfig based on the nodeConfig on a worker node + if role == ctrlcommon.MachineConfigPoolWorker { + if nodeConfig == nil { + nodeConfig = createNewDefaultNodeconfig() + } + updateOriginalKubeConfigwithNodeConfig(nodeConfig, originalKubeConfig) + } if kubeletConfig.Spec.TLSSecurityProfile != nil { // Inject TLS Options from Spec observedMinTLSVersion, observedCipherSuites := getSecurityProfileCiphers(kubeletConfig.Spec.TLSSecurityProfile) diff --git a/pkg/controller/kubelet-config/kubelet_config_bootstrap_test.go b/pkg/controller/kubelet-config/kubelet_config_bootstrap_test.go index c1c81223d2..8b92f828b7 100644 --- a/pkg/controller/kubelet-config/kubelet_config_bootstrap_test.go +++ b/pkg/controller/kubelet-config/kubelet_config_bootstrap_test.go @@ -74,7 +74,7 @@ func TestRunKubeletBootstrap(t *testing.T) { }, } - mcs, err := RunKubeletBootstrap("../../../templates", cfgs, cc, nil, pools) + mcs, err := RunKubeletBootstrap("../../../templates", cfgs, cc, nil, nil, pools) require.NoError(t, err) require.Len(t, mcs, len(cfgs)) diff --git a/pkg/controller/kubelet-config/kubelet_config_controller.go b/pkg/controller/kubelet-config/kubelet_config_controller.go index b6572236e8..1a77d6c18e 100644 --- a/pkg/controller/kubelet-config/kubelet_config_controller.go +++ b/pkg/controller/kubelet-config/kubelet_config_controller.go @@ -31,6 +31,7 @@ import ( kubeletconfigv1beta1 "k8s.io/kubelet/config/v1beta1" configv1 "github.com/openshift/api/config/v1" + configclientset "github.com/openshift/client-go/config/clientset/versioned" oseinformersv1 "github.com/openshift/client-go/config/informers/externalversions/config/v1" oselistersv1 "github.com/openshift/client-go/config/listers/config/v1" "github.com/openshift/library-go/pkg/crypto" @@ -75,6 +76,7 @@ type Controller struct { templatesDir string client mcfgclientset.Interface + configClient configclientset.Interface eventRecorder record.EventRecorder syncHandler func(mcp string) error @@ -92,11 +94,15 @@ type Controller struct { featLister oselistersv1.FeatureGateLister featListerSynced cache.InformerSynced + nodeConfigLister oselistersv1.NodeLister + nodeConfigListerSynced cache.InformerSynced + apiserverLister oselistersv1.APIServerLister apiserverListerSynced cache.InformerSynced - queue workqueue.RateLimitingInterface - featureQueue workqueue.RateLimitingInterface + queue workqueue.RateLimitingInterface + featureQueue workqueue.RateLimitingInterface + nodeConfigQueue workqueue.RateLimitingInterface } // New returns a new kubelet config controller @@ -106,20 +112,24 @@ func New( ccInformer mcfginformersv1.ControllerConfigInformer, mkuInformer mcfginformersv1.KubeletConfigInformer, featInformer oseinformersv1.FeatureGateInformer, + nodeConfigInformer oseinformersv1.NodeInformer, apiserverInformer oseinformersv1.APIServerInformer, kubeClient clientset.Interface, mcfgClient mcfgclientset.Interface, + configclient configclientset.Interface, ) *Controller { eventBroadcaster := record.NewBroadcaster() eventBroadcaster.StartLogging(glog.Infof) eventBroadcaster.StartRecordingToSink(&coreclientsetv1.EventSinkImpl{Interface: kubeClient.CoreV1().Events("")}) ctrl := &Controller{ - templatesDir: templatesDir, - client: mcfgClient, - eventRecorder: eventBroadcaster.NewRecorder(scheme.Scheme, corev1.EventSource{Component: "machineconfigcontroller-kubeletconfigcontroller"}), - queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "machineconfigcontroller-kubeletconfigcontroller"), - featureQueue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "machineconfigcontroller-featurecontroller"), + templatesDir: templatesDir, + client: mcfgClient, + configClient: configclient, + eventRecorder: eventBroadcaster.NewRecorder(scheme.Scheme, corev1.EventSource{Component: "machineconfigcontroller-kubeletconfigcontroller"}), + queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "machineconfigcontroller-kubeletconfigcontroller"), + featureQueue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "machineconfigcontroller-featurecontroller"), + nodeConfigQueue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "machineconfigcontroller-nodeConfigcontroller"), } mkuInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{ @@ -134,6 +144,12 @@ func New( DeleteFunc: ctrl.deleteFeature, }) + nodeConfigInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{ + AddFunc: ctrl.addNodeConfig, + UpdateFunc: ctrl.updateNodeConfig, + DeleteFunc: ctrl.deleteNodeConfig, + }) + ctrl.syncHandler = ctrl.syncKubeletConfig ctrl.enqueueKubeletConfig = ctrl.enqueue @@ -149,6 +165,9 @@ func New( ctrl.featLister = featInformer.Lister() ctrl.featListerSynced = featInformer.Informer().HasSynced + ctrl.nodeConfigLister = nodeConfigInformer.Lister() + ctrl.nodeConfigListerSynced = nodeConfigInformer.Informer().HasSynced + ctrl.apiserverLister = apiserverInformer.Lister() ctrl.apiserverListerSynced = apiserverInformer.Informer().HasSynced @@ -160,6 +179,7 @@ func (ctrl *Controller) Run(workers int, stopCh <-chan struct{}) { defer utilruntime.HandleCrash() defer ctrl.queue.ShutDown() defer ctrl.featureQueue.ShutDown() + defer ctrl.nodeConfigQueue.ShutDown() if !cache.WaitForCacheSync(stopCh, ctrl.mcpListerSynced, ctrl.mckListerSynced, ctrl.ccListerSynced, ctrl.featListerSynced, ctrl.apiserverListerSynced) { return @@ -176,6 +196,10 @@ func (ctrl *Controller) Run(workers int, stopCh <-chan struct{}) { go wait.Until(ctrl.featureWorker, time.Second, stopCh) } + for i := 0; i < workers; i++ { + go wait.Until(ctrl.nodeConfigWorker, time.Second, stopCh) + } + <-stopCh } @@ -507,6 +531,15 @@ func (ctrl *Controller) syncKubeletConfig(key string) error { return ctrl.syncStatusOnly(cfg, err) } + // Fetch the NodeConfig + nodeConfig, err := ctrl.nodeConfigLister.Get(ctrlcommon.ClusterNodeInstanceName) + if macherrors.IsNotFound(err) { + nodeConfig = createNewDefaultNodeconfig() + } else if err != nil { + err := fmt.Errorf("could not fetch Node: %v", err) + return ctrl.syncStatusOnly(cfg, err) + } + for _, pool := range mcpPools { if pool.Spec.Configuration.Name == "" { updateDelay := 5 * time.Second @@ -540,6 +573,10 @@ func (ctrl *Controller) syncKubeletConfig(key string) error { if err != nil { return ctrl.syncStatusOnly(cfg, err, "could not get original kubelet config: %v", err) } + // updating the originalKubeConfig based on the nodeConfig on a worker node + if role == ctrlcommon.MachineConfigPoolWorker { + updateOriginalKubeConfigwithNodeConfig(nodeConfig, originalKubeConfig) + } // Get the default API Server Security Profile var profile *configv1.TLSSecurityProfile diff --git a/pkg/controller/kubelet-config/kubelet_config_controller_test.go b/pkg/controller/kubelet-config/kubelet_config_controller_test.go index 95eca82c14..5d53e47e77 100644 --- a/pkg/controller/kubelet-config/kubelet_config_controller_test.go +++ b/pkg/controller/kubelet-config/kubelet_config_controller_test.go @@ -53,6 +53,7 @@ type fixture struct { mcpLister []*mcfgv1.MachineConfigPool mckLister []*mcfgv1.KubeletConfig featLister []*osev1.FeatureGate + nodeLister []*osev1.Node apiserverLister []*osev1.APIServer actions []core.Action @@ -194,14 +195,17 @@ func (f *fixture) newController() *Controller { i.Machineconfiguration().V1().ControllerConfigs(), i.Machineconfiguration().V1().KubeletConfigs(), featinformer.Config().V1().FeatureGates(), + featinformer.Config().V1().Nodes(), featinformer.Config().V1().APIServers(), k8sfake.NewSimpleClientset(), f.client, + f.oseclient, ) c.mcpListerSynced = alwaysReady c.mckListerSynced = alwaysReady c.ccListerSynced = alwaysReady c.featListerSynced = alwaysReady + c.nodeConfigListerSynced = alwaysReady c.apiserverListerSynced = alwaysReady c.eventRecorder = &record.FakeRecorder{} @@ -225,6 +229,9 @@ func (f *fixture) newController() *Controller { for _, c := range f.apiserverLister { featinformer.Config().V1().APIServers().Informer().GetIndexer().Add(c) } + for _, c := range f.nodeLister { + featinformer.Config().V1().Nodes().Informer().GetIndexer().Add(c) + } return c } @@ -237,6 +244,10 @@ func (f *fixture) runFeature(featname string) { f.runFeatureController(featname, false) } +func (f *fixture) runNode(nodename string) { + f.runNodeController(nodename, false) +} + func (f *fixture) runExpectError(mcpname string) { f.runController(mcpname, true) } @@ -267,6 +278,18 @@ func (f *fixture) runFeatureController(featname string, expectError bool) { f.validateActions() } +func (f *fixture) runNodeController(nodename string, expectError bool) { + c := f.newController() + err := c.syncNodeConfigHandler(nodename) + if !expectError && err != nil { + f.t.Errorf("error syncing node configs: %v", err) + } else if expectError && err == nil { + f.t.Error("expected error syncing node configs, got nil") + } + + f.validateActions() +} + // filterInformerActions filters list and watch actions for testing resources. // Since list and watch don't change resource state we can filter it to lower // nose level in our tests. @@ -351,6 +374,10 @@ func (f *fixture) expectGetKubeletConfigAction(config *mcfgv1.KubeletConfig) { f.actions = append(f.actions, core.NewRootGetAction(schema.GroupVersionResource{Version: "v1", Group: "machineconfiguration.openshift.io", Resource: "kubeletconfigs"}, config.Name)) } +func (f *fixture) expectCreateKubeletConfigAction(config *mcfgv1.KubeletConfig) { + f.actions = append(f.actions, core.NewRootCreateAction(schema.GroupVersionResource{Version: "v1", Group: "machineconfiguration.openshift.io", Resource: "kubeletconfigs"}, config)) +} + func (f *fixture) expectGetMachineConfigAction(config *mcfgv1.MachineConfig) { f.actions = append(f.actions, core.NewRootGetAction(schema.GroupVersionResource{Version: "v1", Group: "machineconfiguration.openshift.io", Resource: "machineconfigs"}, config.Name)) } @@ -759,6 +786,15 @@ func getKeyFromFeatureGate(gate *osev1.FeatureGate, t *testing.T) string { return key } +func getKeyFromConfigNode(node *osev1.Node, t *testing.T) string { + key, err := cache.DeletionHandlingMetaNamespaceKeyFunc(node) + if err != nil { + t.Errorf("Unexpected error getting key for Config Node %v: %v", node.Name, err) + return "" + } + return key +} + func TestCleanUpStatusConditions(t *testing.T) { type status struct { curtStatus []mcfgv1.KubeletConfigCondition diff --git a/pkg/controller/kubelet-config/kubelet_config_features.go b/pkg/controller/kubelet-config/kubelet_config_features.go index af83c31868..7820278726 100644 --- a/pkg/controller/kubelet-config/kubelet_config_features.go +++ b/pkg/controller/kubelet-config/kubelet_config_features.go @@ -80,8 +80,18 @@ func (ctrl *Controller) syncFeatureHandler(key string) error { } for _, pool := range mcpPools { + var nodeConfig *osev1.Node role := pool.Name - + if role == ctrlcommon.MachineConfigPoolWorker { + // Fetch the Node Config object + nodeConfig, err = ctrl.nodeConfigLister.Get(ctrlcommon.ClusterNodeInstanceName) + if errors.IsNotFound(err) { + nodeConfig = createNewDefaultNodeconfig() + } else if err != nil { + err := fmt.Errorf("could not fetch Node: %w", err) + return err + } + } // Get MachineConfig managedKey, err := getManagedFeaturesKey(pool, ctrl.client) if err != nil { @@ -100,7 +110,7 @@ func (ctrl *Controller) syncFeatureHandler(key string) error { } } - rawCfgIgn, err := generateKubeConfigIgnFromFeatures(cc, ctrl.templatesDir, role, features) + rawCfgIgn, err := generateKubeConfigIgnFromFeatures(cc, ctrl.templatesDir, role, features, nodeConfig) if err != nil { return err } @@ -206,11 +216,14 @@ func generateFeatureMap(features *osev1.FeatureGate, exclusions ...string) (*map return &rv, nil } -func generateKubeConfigIgnFromFeatures(cc *mcfgv1.ControllerConfig, templatesDir, role string, features *osev1.FeatureGate) ([]byte, error) { +func generateKubeConfigIgnFromFeatures(cc *mcfgv1.ControllerConfig, templatesDir, role string, features *osev1.FeatureGate, nodeConfig *osev1.Node) ([]byte, error) { originalKubeConfig, err := generateOriginalKubeletConfigWithFeatureGates(cc, templatesDir, role, features) if err != nil { return nil, err } + if nodeConfig != nil { + updateOriginalKubeConfigwithNodeConfig(nodeConfig, originalKubeConfig) + } defaultFeatures, err := generateFeatureMap(createNewDefaultFeatureGate(), openshiftOnlyFeatureGates...) if err != nil { return nil, err @@ -237,12 +250,19 @@ func generateKubeConfigIgnFromFeatures(cc *mcfgv1.ControllerConfig, templatesDir return rawCfgIgn, nil } -func RunFeatureGateBootstrap(templateDir string, features *osev1.FeatureGate, controllerConfig *mcfgv1.ControllerConfig, mcpPools []*mcfgv1.MachineConfigPool) ([]*mcfgv1.MachineConfig, error) { +func RunFeatureGateBootstrap(templateDir string, features *osev1.FeatureGate, nodeConfig *osev1.Node, controllerConfig *mcfgv1.ControllerConfig, mcpPools []*mcfgv1.MachineConfigPool) ([]*mcfgv1.MachineConfig, error) { machineConfigs := []*mcfgv1.MachineConfig{} for _, pool := range mcpPools { role := pool.Name - rawCfgIgn, err := generateKubeConfigIgnFromFeatures(controllerConfig, templateDir, role, features) + if role == ctrlcommon.MachineConfigPoolWorker { + if nodeConfig == nil { + nodeConfig = createNewDefaultNodeconfig() + } + } else { + nodeConfig = nil + } + rawCfgIgn, err := generateKubeConfigIgnFromFeatures(controllerConfig, templateDir, role, features, nodeConfig) if err != nil { return nil, err } diff --git a/pkg/controller/kubelet-config/kubelet_config_features_test.go b/pkg/controller/kubelet-config/kubelet_config_features_test.go index 80b63b2011..90f7901775 100644 --- a/pkg/controller/kubelet-config/kubelet_config_features_test.go +++ b/pkg/controller/kubelet-config/kubelet_config_features_test.go @@ -150,7 +150,7 @@ func TestBootstrapFeaturesDefault(t *testing.T) { features := createNewDefaultFeatureGate() - mcs, err := RunFeatureGateBootstrap("../../../templates", features, cc, mcps) + mcs, err := RunFeatureGateBootstrap("../../../templates", features, nil, cc, mcps) if err != nil { t.Errorf("could not run feature gate bootstrap: %v", err) } @@ -184,7 +184,7 @@ func TestBootstrapFeaturesCustomNoUpgrade(t *testing.T) { }, } - mcs, err := RunFeatureGateBootstrap("../../../templates", features, cc, mcps) + mcs, err := RunFeatureGateBootstrap("../../../templates", features, nil, cc, mcps) if err != nil { t.Errorf("could not run feature gate bootstrap: %v", err) } diff --git a/pkg/controller/kubelet-config/kubelet_config_nodes.go b/pkg/controller/kubelet-config/kubelet_config_nodes.go new file mode 100644 index 0000000000..b4fd6fbe02 --- /dev/null +++ b/pkg/controller/kubelet-config/kubelet_config_nodes.go @@ -0,0 +1,432 @@ +package kubeletconfig + +import ( + "context" + "fmt" + "reflect" + "time" + + "github.com/clarketm/json" + "github.com/golang/glog" + osev1 "github.com/openshift/api/config/v1" + mcfgv1 "github.com/openshift/machine-config-operator/pkg/apis/machineconfiguration.openshift.io/v1" + ctrlcommon "github.com/openshift/machine-config-operator/pkg/controller/common" + "github.com/openshift/machine-config-operator/pkg/version" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/util/retry" +) + +func (ctrl *Controller) nodeConfigWorker() { + for ctrl.processNextNodeConfigWorkItem() { + } +} + +func (ctrl *Controller) processNextNodeConfigWorkItem() bool { + key, quit := ctrl.nodeConfigQueue.Get() + if quit { + return false + } + defer ctrl.nodeConfigQueue.Done(key) + + err := ctrl.syncNodeConfigHandler(key.(string)) + ctrl.handleNodeConfigErr(err, key) + return true +} + +func (ctrl *Controller) handleNodeConfigErr(err error, key interface{}) { + if err == nil { + ctrl.nodeConfigQueue.Forget(key) + return + } + + if ctrl.nodeConfigQueue.NumRequeues(key) < maxRetries { + glog.V(4).Infof("Error syncing node configuration %v: %v", key, err) + ctrl.nodeConfigQueue.AddRateLimited(key) + return + } + + utilruntime.HandleError(err) + glog.V(2).Infof("Dropping node config %q out of the queue: %v", key, err) + ctrl.nodeConfigQueue.Forget(key) + ctrl.nodeConfigQueue.AddAfter(key, 1*time.Minute) +} + +// syncNodeConfigHandler syncs whenever there is a change on the nodes.config.openshift.io resource +// nodes.config.openshift.io object holds the cluster-wide information about the +// node specific features such as cgroup modes, workerlatencyprofiles, etc. +func (ctrl *Controller) syncNodeConfigHandler(key string) error { + startTime := time.Now() + glog.V(4).Infof("Started syncing nodeConfig handler %q (%v)", key, startTime) + defer func() { + glog.V(4).Infof("Finished syncing nodeConfig handler %q (%v)", key, time.Since(startTime)) + }() + + // Fetch the Feature Gates + features, err := ctrl.featLister.Get(ctrlcommon.ClusterFeatureInstanceName) + if errors.IsNotFound(err) { + glog.V(2).Infof("Using the default featuregates") + features = createNewDefaultFeatureGate() + } else if err != nil { + return err + } + // Fetch the Node + nodeConfig, err := ctrl.nodeConfigLister.Get(ctrlcommon.ClusterNodeInstanceName) + if errors.IsNotFound(err) { + glog.V(2).Infof("Node configuration %v is missing", key) + return fmt.Errorf("missing node configuration, key: %v", key) + } else if err != nil { + err := fmt.Errorf("could not fetch Node: %w", err) + return err + } + + // Fetch the controllerconfig + cc, err := ctrl.ccLister.Get(ctrlcommon.ControllerConfigName) + if err != nil { + return fmt.Errorf("could not get ControllerConfig, err: %w", err) + } + // Find all MachineConfigPools + mcpPools, err := ctrl.mcpLister.List(labels.Everything()) + if err != nil { + return err + } + + for _, pool := range mcpPools { + role := pool.Name + // the workerlatencyprofile's configuration change will be applied only on the worker nodes. + if role != ctrlcommon.MachineConfigPoolWorker { + continue + } + // Get MachineConfig + key, err := getManagedNodeConfigKey(pool, ctrl.client) + if err != nil { + return err + } + mc, err := ctrl.client.MachineconfigurationV1().MachineConfigs().Get(context.TODO(), key, metav1.GetOptions{}) + isNotFound := errors.IsNotFound(err) + if err != nil && !isNotFound { + return err + } + if isNotFound { + ignConfig := ctrlcommon.NewIgnConfig() + mc, err = ctrlcommon.MachineConfigFromIgnConfig(role, key, ignConfig) + if err != nil { + return err + } + } + // checking if the Node spec is empty and accordingly returning from here. + if reflect.DeepEqual(nodeConfig.Spec, osev1.NodeSpec{}) { + glog.V(2).Info("empty Node resource found") + ctrl.updateNodeConfigStatus(pool, nodeConfig) + return nil + } + // updating the nodeConfig status based on the machineconfigpool status + err = ctrl.updateNodeConfigStatus(pool, nodeConfig) + if err != nil { + return err + } + // restricting the sync if the nodeConfig status condition is still Progressing. + if !isReadyforUpdate(nodeConfig) { + return fmt.Errorf("unable to modify the kubelet configuration on the node, node condition status not ready") + } + originalKubeConfig, err := generateOriginalKubeletConfigWithFeatureGates(cc, ctrl.templatesDir, role, features) + if err != nil { + return err + } + // updating the kubelet configuration with the Node specific configuration. + err = updateOriginalKubeConfigwithNodeConfig(nodeConfig, originalKubeConfig) + if err != nil { + return err + } + // Encode the new config into raw JSON + cfgIgn, err := kubeletConfigToIgnFile(originalKubeConfig) + if err != nil { + return err + } + tempIgnConfig := ctrlcommon.NewIgnConfig() + tempIgnConfig.Storage.Files = append(tempIgnConfig.Storage.Files, *cfgIgn) + rawCfgIgn, err := json.Marshal(tempIgnConfig) + if err != nil { + return err + } + mc.Spec.Config.Raw = rawCfgIgn + mc.ObjectMeta.Annotations = map[string]string{ + ctrlcommon.GeneratedByControllerVersionAnnotationKey: version.Hash, + } + // Create or Update, on conflict retry + if err := retry.RetryOnConflict(updateBackoff, func() error { + var err error + if isNotFound { + _, err = ctrl.client.MachineconfigurationV1().MachineConfigs().Create(context.TODO(), mc, metav1.CreateOptions{}) + } else { + _, err = ctrl.client.MachineconfigurationV1().MachineConfigs().Update(context.TODO(), mc, metav1.UpdateOptions{}) + } + return err + }); err != nil { + return fmt.Errorf("Could not Create/Update MachineConfig, error: %w", err) + } + glog.Infof("Applied Node configuration %v on MachineConfigPool %v", key, pool.Name) + + // updating the nodeConfig status based on the machineconfigpool status + err = ctrl.updateNodeConfigStatus(pool, nodeConfig) + if err != nil { + return err + } + } + // fetch the kubeletconfigs + kcs, err := ctrl.mckLister.List(labels.Everything()) + if err != nil { + return fmt.Errorf("could not get KubeletConfigs, err: %w", err) + } + for _, kc := range kcs { + // updating the existing kubeletconfigs with the updated nodeconfig + err := ctrl.syncKubeletConfig(kc.Name) + if err != nil { + return fmt.Errorf("could not update KubeletConfig %v, err: %w", kc, err) + } + } + + return nil +} + +func (ctrl *Controller) enqueueNodeConfig(nodeConfig *osev1.Node) { + key, err := cache.DeletionHandlingMetaNamespaceKeyFunc(nodeConfig) + if err != nil { + utilruntime.HandleError(fmt.Errorf("Couldn't get key for object %#v: %w", nodeConfig, err)) + return + } + ctrl.nodeConfigQueue.Add(key) +} + +func (ctrl *Controller) updateNodeConfig(old, cur interface{}) { + oldNode, ok := old.(*osev1.Node) + if !ok { + utilruntime.HandleError(fmt.Errorf("Couldn't retrieve the old object from the Update Node Config event %#v", old)) + return + } + newNode, ok := cur.(*osev1.Node) + if !ok { + utilruntime.HandleError(fmt.Errorf("Couldn't retrieve the new object from the Update Node Config event %#v", cur)) + return + } + if newNode.Name != ctrlcommon.ClusterNodeInstanceName { + message := fmt.Sprintf("The node.config.openshift.io \"%v\" is invalid: metadata.name Invalid value: \"%v\" : must be \"%v\"", newNode.Name, newNode.Name, ctrlcommon.ClusterNodeInstanceName) + glog.V(2).Infof(message) + ctrl.updateNodeConfigDegradedStatus(newNode, message, "UpdateProhibited") + return + } + if !reflect.DeepEqual(oldNode.Spec, newNode.Spec) { + // skipping the update in case of the Worker-Latency-Profile type transition from "Default" to "LowUpdateSlowReaction" and vice-versa + // (TODO) Ideally the user request has to be honoured, the transition need to be from Default -> Medium -> Low or vice-versa. + // Restricting the request for now until this process is automated in future. + if (oldNode.Spec.WorkerLatencyProfile == osev1.DefaultUpdateDefaultReaction && newNode.Spec.WorkerLatencyProfile == osev1.LowUpdateSlowReaction) || (oldNode.Spec.WorkerLatencyProfile == osev1.LowUpdateSlowReaction && newNode.Spec.WorkerLatencyProfile == osev1.DefaultUpdateDefaultReaction) { + message := fmt.Sprintf("Skipping the Update Node event, name: %s, transition not allowed from old WorkerLatencyProfile: %s to new WorkerLatencyProfile: %s", newNode.Name, oldNode.Spec.WorkerLatencyProfile, newNode.Spec.WorkerLatencyProfile) + glog.Infof(message) + ctrl.updateNodeConfigDegradedStatus(newNode, message, "UpdateSkipped") + return + } + glog.V(4).Infof("Updating the node config resource, name: %s", newNode.Name) + ctrl.enqueueNodeConfig(newNode) + } +} + +func (ctrl *Controller) addNodeConfig(obj interface{}) { + nodeConfig, ok := obj.(*osev1.Node) + if !ok { + utilruntime.HandleError(fmt.Errorf("Couldn't retrieve the object from the Add Node Config event %#v", obj)) + return + } + if nodeConfig.Name != ctrlcommon.ClusterNodeInstanceName { + message := fmt.Sprintf("The node.config.openshift.io \"%v\" is invalid: metadata.name Invalid value: \"%v\" : must be \"%v\"", nodeConfig.Name, nodeConfig.Name, ctrlcommon.ClusterNodeInstanceName) + glog.V(2).Infof(message) + ctrl.updateNodeConfigDegradedStatus(nodeConfig, message, "UpdateProhibited") + return + } + glog.V(4).Infof("Adding the node config resource, name: %s", nodeConfig.Name) + ctrl.enqueueNodeConfig(nodeConfig) +} + +func (ctrl *Controller) deleteNodeConfig(obj interface{}) { + nodeConfig, ok := obj.(*osev1.Node) + if !ok { + tombstone, ok := obj.(cache.DeletedFinalStateUnknown) + if !ok { + utilruntime.HandleError(fmt.Errorf("Couldn't get object from tombstone %#v", obj)) + return + } + nodeConfig, ok = tombstone.Obj.(*osev1.Node) + if !ok { + utilruntime.HandleError(fmt.Errorf("Tombstone contained object that is not a NodeConfig %#v", obj)) + return + } + } + glog.V(4).Infof("Deleted node config %s and restored default config", nodeConfig.Name) +} + +// isReadyforUpdate returns a boolean based on the condition statuses present in the node config CR. +// The node config resource is considered to be not-ready if any status condition +// of any operator type is "Progressing". Otherwise, the resource is ready for the update. +func isReadyforUpdate(nodeConfig *osev1.Node) bool { + var conditionTypes = []string{ + osev1.KubeAPIServerProgressing, + osev1.KubeControllerManagerProgressing, + osev1.KubeletProgressing, + osev1.KubeAPIServerDegraded, + osev1.KubeControllerManagerDegraded, + osev1.KubeletDegraded, + } + // if the node config resource is empty, it is ready for the update + // to hold the new configuration update request. + if nodeConfig == nil { + return true + } + if len(nodeConfig.Status.WorkerLatencyProfileStatus.Conditions) > 0 { + for _, condition := range nodeConfig.Status.WorkerLatencyProfileStatus.Conditions { + for _, conditionType := range conditionTypes { + if conditionType == condition.Type { + return false + } + } + } + } + return true +} + +// updateNodeConfigDegradedStatus updates the degraded status of the node config based on the message and reason +func (ctrl *Controller) updateNodeConfigDegradedStatus(nodeConfig *osev1.Node, message, reason string) error { + if nodeConfig == nil { + return fmt.Errorf("unable to update the node config status") + } + var nodeConfigCondition metav1.Condition + + nodeConfigCondition.Type = osev1.KubeletDegraded + nodeConfigCondition.Status = metav1.ConditionUnknown + nodeConfigCondition.LastTransitionTime = metav1.Now() + nodeConfigCondition.Reason = reason + nodeConfigCondition.Message = message + return ctrl.updateMCOStatus(nodeConfig, nodeConfigCondition) +} + +// updateNodeConfigStatus updates the status of the node config object based on the machineconfigpool status +func (ctrl *Controller) updateNodeConfigStatus(pool *mcfgv1.MachineConfigPool, nodeConfig *osev1.Node) error { + if pool == nil || nodeConfig == nil { + return fmt.Errorf("unable to update the nodeConfig status, incomplete data, machineConfigpool : %v, nodeConfig: %v", pool, nodeConfig) + } + var nodeConfigCondition metav1.Condition + + nodeConfigCondition.Type = osev1.KubeletComplete + nodeConfigCondition.LastTransitionTime = metav1.Now() + nodeConfigCondition.Status = metav1.ConditionUnknown + nodeConfigCondition.Reason = "ConditionUnknown" + nodeConfigCondition.Message = "Condition Unknown" + + switch { + case mcfgv1.IsMachineConfigPoolConditionTrue(pool.Status.Conditions, mcfgv1.MachineConfigPoolRenderDegraded): + cond := mcfgv1.GetMachineConfigPoolCondition(pool.Status, mcfgv1.MachineConfigPoolRenderDegraded) + nodeConfigCondition.Type = osev1.KubeletDegraded + nodeConfigCondition.Status = metav1.ConditionStatus(cond.Status) + nodeConfigCondition.Reason = "MachineConfigPoolRenderDegraded" + nodeConfigCondition.Message = "Machine Config Pool Render Degraded" + case mcfgv1.IsMachineConfigPoolConditionTrue(pool.Status.Conditions, mcfgv1.MachineConfigPoolNodeDegraded): + cond := mcfgv1.GetMachineConfigPoolCondition(pool.Status, mcfgv1.MachineConfigPoolNodeDegraded) + nodeConfigCondition.Type = osev1.KubeletDegraded + nodeConfigCondition.Status = metav1.ConditionStatus(cond.Status) + nodeConfigCondition.Reason = "MachineConfigPoolNodeDegraded" + nodeConfigCondition.Message = "Machine Config Pool Node Degraded" + case mcfgv1.IsMachineConfigPoolConditionTrue(pool.Status.Conditions, mcfgv1.MachineConfigPoolUpdated): + cond := mcfgv1.GetMachineConfigPoolCondition(pool.Status, mcfgv1.MachineConfigPoolUpdated) + nodeConfigCondition.Type = osev1.KubeletComplete + nodeConfigCondition.Status = metav1.ConditionStatus(cond.Status) + nodeConfigCondition.Reason = "MachineConfigPoolUpdated" + nodeConfigCondition.Message = "Machine Config Pool Updated" + case mcfgv1.IsMachineConfigPoolConditionTrue(pool.Status.Conditions, mcfgv1.MachineConfigPoolUpdating): + cond := mcfgv1.GetMachineConfigPoolCondition(pool.Status, mcfgv1.MachineConfigPoolUpdating) + nodeConfigCondition.Type = osev1.KubeletProgressing + nodeConfigCondition.Status = metav1.ConditionStatus(cond.Status) + nodeConfigCondition.Reason = "MachineConfigPoolUpdating" + nodeConfigCondition.Message = fmt.Sprintf("%d (ready %d) out of %d nodes are updating to latest configuration %s", pool.Status.UpdatedMachineCount, pool.Status.ReadyMachineCount, pool.Status.MachineCount, pool.Spec.Configuration.Name) + } + return ctrl.updateMCOStatus(nodeConfig, nodeConfigCondition) +} + +// updateMCOStatus updates the MCO specific status condition present in the node config CR +func (ctrl *Controller) updateMCOStatus(nodeConfig *osev1.Node, nodeConfigCondition metav1.Condition) error { + var ( + index int + isPresent bool + ) + var kubeletConditionTypes = []string{ + osev1.KubeletProgressing, + osev1.KubeletComplete, + osev1.KubeletDegraded, + } + for index = range nodeConfig.Status.WorkerLatencyProfileStatus.Conditions { + for _, conditionType := range kubeletConditionTypes { + if nodeConfig.Status.WorkerLatencyProfileStatus.Conditions[index].Type == conditionType { + isPresent = true + break + } + } + if isPresent { + break + } + } + if isPresent { + nodeConfig.Status.WorkerLatencyProfileStatus.Conditions[index] = *nodeConfigCondition.DeepCopy() + } else { + nodeConfig.Status.WorkerLatencyProfileStatus.Conditions = append(nodeConfig.Status.WorkerLatencyProfileStatus.Conditions, nodeConfigCondition) + } + _, err := ctrl.configClient.ConfigV1().Nodes().UpdateStatus(context.TODO(), nodeConfig, metav1.UpdateOptions{}) + return err +} + +func RunNodeConfigBootstrap(templateDir string, features *osev1.FeatureGate, cconfig *mcfgv1.ControllerConfig, nodeConfig *osev1.Node, mcpPools []*mcfgv1.MachineConfigPool) ([]*mcfgv1.MachineConfig, error) { + configs := []*mcfgv1.MachineConfig{} + + for _, pool := range mcpPools { + role := pool.Name + if role != ctrlcommon.MachineConfigPoolWorker { + continue + } + // Get MachineConfig + key, err := getManagedNodeConfigKey(pool, nil) + if err != nil { + return nil, err + } + ignConfig := ctrlcommon.NewIgnConfig() + mc, err := ctrlcommon.MachineConfigFromIgnConfig(role, key, ignConfig) + if err != nil { + return nil, err + } + originalKubeConfig, err := generateOriginalKubeletConfigWithFeatureGates(cconfig, templateDir, role, features) + if err != nil { + return nil, err + } + // updating the kubelet configuration with the Node specific configuration. + err = updateOriginalKubeConfigwithNodeConfig(nodeConfig, originalKubeConfig) + if err != nil { + return nil, err + } + // Encode the new config into raw JSON + cfgIgn, err := kubeletConfigToIgnFile(originalKubeConfig) + if err != nil { + return nil, err + } + tempIgnConfig := ctrlcommon.NewIgnConfig() + tempIgnConfig.Storage.Files = append(tempIgnConfig.Storage.Files, *cfgIgn) + rawCfgIgn, err := json.Marshal(tempIgnConfig) + if err != nil { + return nil, err + } + mc.Spec.Config.Raw = rawCfgIgn + mc.ObjectMeta.Annotations = map[string]string{ + ctrlcommon.GeneratedByControllerVersionAnnotationKey: version.Hash, + } + configs = append(configs, mc) + } + + return configs, nil +} diff --git a/pkg/controller/kubelet-config/kubelet_config_nodes_test.go b/pkg/controller/kubelet-config/kubelet_config_nodes_test.go new file mode 100644 index 0000000000..b608d02d64 --- /dev/null +++ b/pkg/controller/kubelet-config/kubelet_config_nodes_test.go @@ -0,0 +1,115 @@ +package kubeletconfig + +import ( + "fmt" + "reflect" + "testing" + + ign3types "github.com/coreos/ignition/v2/config/v3_2/types" + configv1 "github.com/openshift/api/config/v1" + osev1 "github.com/openshift/api/config/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + kubeletconfigv1beta1 "k8s.io/kubelet/config/v1beta1" + + mcfgv1 "github.com/openshift/machine-config-operator/pkg/apis/machineconfiguration.openshift.io/v1" + ctrlcommon "github.com/openshift/machine-config-operator/pkg/controller/common" + "github.com/openshift/machine-config-operator/test/helpers" + "github.com/stretchr/testify/require" +) + +func TestOriginalKubeletConfigDefaultNodeConfig(t *testing.T) { + for _, platform := range []configv1.PlatformType{configv1.AWSPlatformType, configv1.NonePlatformType, "unrecognized"} { + t.Run(string(platform), func(t *testing.T) { + f := newFixture(t) + cc := newControllerConfig(ctrlcommon.ControllerConfigName, platform) + f.ccLister = append(f.ccLister, cc) + + ctrl := f.newController() + kubeletConfig, err := generateOriginalKubeletConfigIgn(cc, ctrl.templatesDir, "master", nil) + if err != nil { + t.Errorf("could not generate kubelet config from templates %v", err) + } + contents, err := ctrlcommon.DecodeIgnitionFileContents(kubeletConfig.Contents.Source, kubeletConfig.Contents.Compression) + require.NoError(t, err) + originalKubeConfig, err := decodeKubeletConfig(contents) + require.NoError(t, err) + + if reflect.DeepEqual(originalKubeConfig.NodeStatusReportFrequency, metav1.Duration{osev1.DefaultNodeStatusUpdateFrequency}) { + t.Errorf("expected the default node status update frequency to be %v, got: %v", osev1.DefaultNodeStatusUpdateFrequency, originalKubeConfig.NodeStatusReportFrequency) + } + }) + } +} + +func TestNodeConfigDefault(t *testing.T) { + for _, platform := range []configv1.PlatformType{configv1.AWSPlatformType, configv1.NonePlatformType, "unrecognized"} { + t.Run(string(platform), func(t *testing.T) { + f := newFixture(t) + f.newController() + + cc := newControllerConfig(ctrlcommon.ControllerConfigName, platform) + mcp := helpers.NewMachineConfigPool("worker", nil, helpers.WorkerSelector, "v0") + kc := newKubeletConfig("smaller-max-pods", &kubeletconfigv1beta1.KubeletConfiguration{MaxPods: 100}, metav1.AddLabelToSelector(&metav1.LabelSelector{}, "pools.operator.machineconfiguration.openshift.io/worker", "")) + kubeletConfigKey, err := getManagedKubeletConfigKey(mcp, f.client, kc) + require.NoError(t, err) + mcs := helpers.NewMachineConfig(kubeletConfigKey, map[string]string{"node-role/worker": ""}, "dummy://", []ign3types.File{{}}) + mcsDeprecated := mcs.DeepCopy() + mcsDeprecated.Name = fmt.Sprintf("97-%s-%s-kubelet", mcp.Name, mcp.ObjectMeta.UID) + + f.ccLister = append(f.ccLister, cc) + f.mcpLister = append(f.mcpLister, mcp) + + nodeConfig := createNewDefaultNodeconfig() + f.nodeLister = append(f.nodeLister, nodeConfig) + f.oseobjects = append(f.oseobjects, nodeConfig) + + f.expectGetMachineConfigAction(mcs) + f.expectGetMachineConfigAction(mcsDeprecated) + f.expectGetMachineConfigAction(mcs) + f.expectCreateMachineConfigAction(mcs) + + f.runNode(getKeyFromConfigNode(nodeConfig, t)) + }) + } +} + +func TestBootstrapNodeConfigDefault(t *testing.T) { + for _, platform := range []configv1.PlatformType{configv1.AWSPlatformType, configv1.NonePlatformType, "unrecognized"} { + t.Run(string(platform), func(t *testing.T) { + + cc := newControllerConfig(ctrlcommon.ControllerConfigName, platform) + mcp := helpers.NewMachineConfigPool("worker", nil, helpers.WorkerSelector, "v0") + mcps := []*mcfgv1.MachineConfigPool{mcp} + + features := createNewDefaultFeatureGate() + configNode := createNewDefaultNodeconfig() + + mcs, err := RunNodeConfigBootstrap("../../../templates", features, cc, configNode, mcps) + if err != nil { + t.Errorf("could not run node config bootstrap: %v", err) + } + if len(mcs) == 0 { + t.Errorf("expected a machine config generated with the default node config, got 0 machine configs") + } + }) + } +} + +func TestBootstrapNoNodeConfig(t *testing.T) { + for _, platform := range []configv1.PlatformType{configv1.AWSPlatformType, configv1.NonePlatformType, "unrecognized"} { + t.Run(string(platform), func(t *testing.T) { + + cc := newControllerConfig(ctrlcommon.ControllerConfigName, platform) + mcp := helpers.NewMachineConfigPool("worker", nil, helpers.WorkerSelector, "v0") + mcps := []*mcfgv1.MachineConfigPool{mcp} + + mcs, err := RunNodeConfigBootstrap("../../../templates", nil, cc, nil, mcps) + if err == nil { + t.Errorf("expected an error while generating the kubelet config with no node config") + } + if len(mcs) > 0 { + t.Errorf("expected no machine configs with no node config but generated %v", len(mcs)) + } + }) + } +} diff --git a/pkg/controller/node/node_controller.go b/pkg/controller/node/node_controller.go index 46b240c4be..5c4aee926e 100644 --- a/pkg/controller/node/node_controller.go +++ b/pkg/controller/node/node_controller.go @@ -65,9 +65,6 @@ const ( // schedulerCRName that we're interested in watching. schedulerCRName = "cluster" - // masterPoolName is the control plane MachineConfigPool name - masterPoolName = "master" - // kubeletCAFilePath is the expected file path for the kubelet ca kubeletCAFilePath = "/etc/kubernetes/kubelet-ca.crt" ) @@ -489,7 +486,7 @@ func (ctrl *Controller) updateNode(old, cur interface{}) { ctrl.logPoolNode(pool, curNode, "changed annotation %s = %s", anno, newValue) changed = true // For the control plane, emit events for these since they're important - if pool.Name == masterPoolName { + if pool.Name == ctrlcommon.MachineConfigPoolMaster { ctrl.eventRecorder.Eventf(pool, corev1.EventTypeNormal, "AnnotationChange", "Node %s now has %s=%s", curNode.Name, anno, newValue) } } @@ -590,7 +587,7 @@ func (ctrl *Controller) getPoolsForNode(node *corev1.Node) ([]*mcfgv1.MachineCon var master, worker *mcfgv1.MachineConfigPool var custom []*mcfgv1.MachineConfigPool for _, pool := range pools { - if pool.Name == masterPoolName { + if pool.Name == ctrlcommon.MachineConfigPoolMaster { master = pool } else if pool.Name == "worker" { worker = pool @@ -972,7 +969,7 @@ func (ctrl *Controller) filterControlPlaneCandidateNodes(pool *mcfgv1.MachineCon // updateCandidateMachines sets the desiredConfig annotation the candidate machines func (ctrl *Controller) updateCandidateMachines(pool *mcfgv1.MachineConfigPool, candidates []*corev1.Node, capacity uint) error { - if pool.Name == masterPoolName { + if pool.Name == ctrlcommon.MachineConfigPoolMaster { var err error candidates, capacity, err = ctrl.filterControlPlaneCandidateNodes(pool, candidates, capacity) if err != nil { diff --git a/test/e2e-bootstrap/bootstrap_test.go b/test/e2e-bootstrap/bootstrap_test.go index 63ec16ed34..3aa3c7dc3d 100644 --- a/test/e2e-bootstrap/bootstrap_test.go +++ b/test/e2e-bootstrap/bootstrap_test.go @@ -113,6 +113,19 @@ spec: waitForMasterMCs: []string{"99-master-ssh", "99-master-generated-registries", "98-master-generated-kubelet"}, waitForWorkerMCs: []string{"99-worker-ssh", "99-worker-generated-registries", "98-worker-generated-kubelet"}, }, + { + name: "With a node config manifest", + manifests: [][]byte{ + []byte(`apiVersion: config.openshift.io/v1 +kind: Node +metadata: + name: cluster +spec: + workerLatencyProfile: MediumUpdateAverageReaction`), + }, + waitForMasterMCs: []string{"99-master-ssh", "99-master-generated-registries"}, + waitForWorkerMCs: []string{"99-worker-ssh", "99-worker-generated-registries", "97-worker-generated-kubelet"}, + }, { name: "With a featuregate manifest and master kubelet config manifest", manifests: [][]byte{ @@ -144,6 +157,68 @@ spec: waitForMasterMCs: []string{"99-master-ssh", "99-master-generated-registries", "99-master-generated-kubelet"}, waitForWorkerMCs: []string{"99-worker-ssh", "99-worker-generated-registries"}, }, + { + name: "With a node config manifest and master kubelet config manifest", + manifests: [][]byte{ + []byte(`apiVersion: config.openshift.io/v1 +kind: Node +metadata: + name: cluster +spec: + workerLatencyProfile: MediumUpdateAverageReaction`), + []byte(`apiVersion: machineconfiguration.openshift.io/v1 +kind: KubeletConfig +metadata: + name: master-kubelet-config +spec: + machineConfigPoolSelector: + matchLabels: + pools.operator.machineconfiguration.openshift.io/master: "" + kubeletConfig: + podsPerCore: 10 + maxPods: 250 + systemReserved: + cpu: 1000m + memory: 500Mi + kubeReserved: + cpu: 1000m + memory: 500Mi +`), + }, + waitForMasterMCs: []string{"99-master-ssh", "99-master-generated-registries", "99-master-generated-kubelet"}, + waitForWorkerMCs: []string{"99-worker-ssh", "99-worker-generated-registries", "97-worker-generated-kubelet"}, + }, + { + name: "With a node config manifest and worker kubelet config manifest", + manifests: [][]byte{ + []byte(`apiVersion: config.openshift.io/v1 +kind: Node +metadata: + name: cluster +spec: + workerLatencyProfile: MediumUpdateAverageReaction`), + []byte(`apiVersion: machineconfiguration.openshift.io/v1 +kind: KubeletConfig +metadata: + name: master-kubelet-config +spec: + machineConfigPoolSelector: + matchLabels: + pools.operator.machineconfiguration.openshift.io/worker: "" + kubeletConfig: + podsPerCore: 10 + maxPods: 250 + systemReserved: + cpu: 1000m + memory: 500Mi + kubeReserved: + cpu: 1000m + memory: 500Mi +`), + }, + waitForMasterMCs: []string{"99-master-ssh", "99-master-generated-registries"}, + waitForWorkerMCs: []string{"99-worker-ssh", "99-worker-generated-registries", "99-worker-generated-kubelet"}, + }, { name: "With a worker kubelet config manifest", manifests: [][]byte{ @@ -319,9 +394,11 @@ func createControllers(ctx *ctrlcommon.ControllerContext) []ctrlcommon.Controlle ctx.InformerFactory.Machineconfiguration().V1().ControllerConfigs(), ctx.InformerFactory.Machineconfiguration().V1().KubeletConfigs(), ctx.ConfigInformerFactory.Config().V1().FeatureGates(), + ctx.ConfigInformerFactory.Config().V1().Nodes(), ctx.ConfigInformerFactory.Config().V1().APIServers(), ctx.ClientBuilder.KubeClientOrDie("kubelet-config-controller"), ctx.ClientBuilder.MachineConfigClientOrDie("kubelet-config-controller"), + ctx.ClientBuilder.ConfigClientOrDie("kubelet-config-controller"), ), containerruntimeconfig.New( templatesDir, @@ -398,6 +475,9 @@ func createObjects(t *testing.T, clientSet *framework.ClientSet, objs ...runtime case *configv1.FeatureGate: _, err := clientSet.FeatureGates().Create(ctx, tObj, metav1.CreateOptions{}) require.NoError(t, err) + case *configv1.Node: + _, err := clientSet.ConfigV1Interface.Nodes().Create(ctx, tObj, metav1.CreateOptions{}) + require.NoError(t, err) default: t.Errorf("Unknown object type %T", obj) } @@ -530,6 +610,10 @@ func checkCleanEnvironment(t *testing.T, clientSet *framework.ClientSet) { featureGateList, err := clientSet.FeatureGates().List(ctx, metav1.ListOptions{}) require.NoError(t, err) require.Len(t, featureGateList.Items, 0) + + nodeConfigList, err := clientSet.ConfigV1Interface.Nodes().List(ctx, metav1.ListOptions{}) + require.NoError(t, err) + require.Len(t, nodeConfigList.Items, 0) // ########################### // END: config.openshift.io/v1 // ########################### @@ -602,6 +686,9 @@ func cleanEnvironment(t *testing.T, clientSet *framework.ClientSet) { err = clientSet.FeatureGates().DeleteCollection(ctx, metav1.DeleteOptions{}, metav1.ListOptions{}) require.NoError(t, err) + + err = clientSet.ConfigV1Interface.Nodes().DeleteCollection(ctx, metav1.DeleteOptions{}, metav1.ListOptions{}) + require.NoError(t, err) // ########################### // END: config.openshift.io/v1 // ########################### diff --git a/test/e2e-shared-tests/helpers.go b/test/e2e-shared-tests/helpers.go index ef9d72afd1..08b7f3ca1e 100644 --- a/test/e2e-shared-tests/helpers.go +++ b/test/e2e-shared-tests/helpers.go @@ -164,7 +164,7 @@ func assertNodeReachesState(t *testing.T, cs *framework.ClientSet, target corev1 maxWait := 5 * time.Minute end, err := pollForResourceState(maxWait, func() (bool, error) { - node, err := cs.Nodes().Get(context.TODO(), target.Name, metav1.GetOptions{}) + node, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), target.Name, metav1.GetOptions{}) return stateFunc(*node), err }) diff --git a/test/e2e/mcd_test.go b/test/e2e/mcd_test.go index c52cb8cc38..392b05db82 100644 --- a/test/e2e/mcd_test.go +++ b/test/e2e/mcd_test.go @@ -167,7 +167,7 @@ func TestKernelArguments(t *testing.T) { workerMCP, err := cs.MachineConfigPools().Get(context.TODO(), "worker", metav1.GetOptions{}) require.Nil(t, err) if err := wait.Poll(2*time.Second, 5*time.Minute, func() (bool, error) { - node, err := cs.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) + node, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) require.Nil(t, err) if node.Annotations[constants.DesiredMachineConfigAnnotationKey] != workerMCP.Spec.Configuration.Name { return false, nil @@ -254,7 +254,7 @@ func TestKernelType(t *testing.T) { workerMCP, err := cs.MachineConfigPools().Get(context.TODO(), "worker", metav1.GetOptions{}) require.Nil(t, err) if err := wait.Poll(2*time.Second, 5*time.Minute, func() (bool, error) { - node, err := cs.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) + node, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) require.Nil(t, err) if node.Annotations[constants.DesiredMachineConfigAnnotationKey] != workerMCP.Spec.Configuration.Name { return false, nil @@ -364,7 +364,7 @@ func TestExtensions(t *testing.T) { workerMCP, err := cs.MachineConfigPools().Get(context.TODO(), "worker", metav1.GetOptions{}) require.Nil(t, err) if err := wait.Poll(2*time.Second, 5*time.Minute, func() (bool, error) { - node, err := cs.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) + node, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) require.Nil(t, err) if node.Annotations[constants.DesiredMachineConfigAnnotationKey] != workerMCP.Spec.Configuration.Name { return false, nil @@ -489,7 +489,7 @@ func TestNoReboot(t *testing.T) { workerMCP, err := cs.MachineConfigPools().Get(context.TODO(), "worker", metav1.GetOptions{}) require.Nil(t, err) if err := wait.Poll(2*time.Second, 5*time.Minute, func() (bool, error) { - node, err := cs.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) + node, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) require.Nil(t, err) if node.Annotations[constants.DesiredMachineConfigAnnotationKey] != workerMCP.Spec.Configuration.Name { return false, nil @@ -696,7 +696,7 @@ func TestDontDeleteRPMFiles(t *testing.T) { workerMCP, err := cs.MachineConfigPools().Get(context.TODO(), "worker", metav1.GetOptions{}) require.Nil(t, err) if err := wait.Poll(2*time.Second, 5*time.Minute, func() (bool, error) { - node, err := cs.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) + node, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) require.Nil(t, err) if node.Annotations[constants.DesiredMachineConfigAnnotationKey] != workerMCP.Spec.Configuration.Name { return false, nil @@ -767,7 +767,7 @@ func TestIgn3Cfg(t *testing.T) { workerMCP, err := cs.MachineConfigPools().Get(context.TODO(), "worker", metav1.GetOptions{}) require.Nil(t, err) if err := wait.Poll(2*time.Second, 5*time.Minute, func() (bool, error) { - node, err := cs.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) + node, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), infraNode.Name, metav1.GetOptions{}) require.Nil(t, err) if node.Annotations[constants.DesiredMachineConfigAnnotationKey] != workerMCP.Spec.Configuration.Name { return false, nil diff --git a/test/helpers/utils.go b/test/helpers/utils.go index eb0caed3d7..ac9c5054ce 100644 --- a/test/helpers/utils.go +++ b/test/helpers/utils.go @@ -203,7 +203,7 @@ func WaitForPoolComplete(t *testing.T, cs *framework.ClientSet, pool, target str func WaitForNodeConfigChange(t *testing.T, cs *framework.ClientSet, node corev1.Node, mcName string) error { startTime := time.Now() err := wait.PollImmediate(2*time.Second, 20*time.Minute, func() (bool, error) { - n, err := cs.Nodes().Get(context.TODO(), node.Name, metav1.GetOptions{}) + n, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), node.Name, metav1.GetOptions{}) if err != nil { return false, err } @@ -306,24 +306,24 @@ func LabelRandomNodeFromPool(t *testing.T, cs *framework.ClientSet, pool, label infraNodeName := infraNode.Name err = retry.RetryOnConflict(retry.DefaultBackoff, func() error { - infraNode, err := cs.Nodes().Get(context.TODO(), infraNodeName, metav1.GetOptions{}) + infraNode, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), infraNodeName, metav1.GetOptions{}) if err != nil { return err } infraNode.Labels[label] = "" - _, err = cs.Nodes().Update(context.TODO(), infraNode, metav1.UpdateOptions{}) + _, err = cs.CoreV1Interface.Nodes().Update(context.TODO(), infraNode, metav1.UpdateOptions{}) return err }) require.Nil(t, err, "unable to label worker node %s with infra: %s", infraNode.Name, err) return func() { err := retry.RetryOnConflict(retry.DefaultBackoff, func() error { - infraNode, err := cs.Nodes().Get(context.TODO(), infraNodeName, metav1.GetOptions{}) + infraNode, err := cs.CoreV1Interface.Nodes().Get(context.TODO(), infraNodeName, metav1.GetOptions{}) if err != nil { return err } delete(infraNode.Labels, label) - _, err = cs.Nodes().Update(context.TODO(), infraNode, metav1.UpdateOptions{}) + _, err = cs.CoreV1Interface.Nodes().Update(context.TODO(), infraNode, metav1.UpdateOptions{}) return err }) require.Nil(t, err, "unable to remove label from node %s: %s", infraNode.Name, err) @@ -343,7 +343,7 @@ func GetNodesByRole(cs *framework.ClientSet, role string) ([]corev1.Node, error) listOptions := metav1.ListOptions{ LabelSelector: labels.SelectorFromSet(labels.Set{fmt.Sprintf("node-role.kubernetes.io/%s", role): ""}).String(), } - nodes, err := cs.Nodes().List(context.TODO(), listOptions) + nodes, err := cs.CoreV1Interface.Nodes().List(context.TODO(), listOptions) if err != nil { return nil, err } diff --git a/vendor/github.com/openshift/api/Dockerfile.build b/vendor/github.com/openshift/api/Dockerfile.build index bd89d6cf08..960f39d9ba 100644 --- a/vendor/github.com/openshift/api/Dockerfile.build +++ b/vendor/github.com/openshift/api/Dockerfile.build @@ -3,7 +3,7 @@ FROM fedora:latest ENV GOPATH=/go ENV PATH=/go/bin:/usr/local/go/bin:$PATH -RUN dnf -y install make git unzip wget findutils +RUN dnf -y install make git unzip wget findutils gcc diffutils RUN wget https://go.dev/dl/go1.17.6.linux-amd64.tar.gz && \ rm -rf /usr/local/go && \ diff --git a/vendor/github.com/openshift/api/Makefile b/vendor/github.com/openshift/api/Makefile index f049eda2d7..3d74577a8d 100644 --- a/vendor/github.com/openshift/api/Makefile +++ b/vendor/github.com/openshift/api/Makefile @@ -66,6 +66,10 @@ update-scripts: hack/update-swagger-docs.sh .PHONY: update-scripts +verify-with-container: Dockerfile.build + $(RUNTIME) build -t $(RUNTIME_IMAGE_NAME) -f Dockerfile.build . + $(RUNTIME) run -ti --rm -v $(PWD):/go/src/github.com/openshift/api:z -w /go/src/github.com/openshift/api $(RUNTIME_IMAGE_NAME) make verify + generate-with-container: Dockerfile.build $(RUNTIME) build -t $(RUNTIME_IMAGE_NAME) -f Dockerfile.build . $(RUNTIME) run -ti --rm -v $(PWD):/go/src/github.com/openshift/api:z -w /go/src/github.com/openshift/api $(RUNTIME_IMAGE_NAME) make update diff --git a/vendor/github.com/openshift/api/README.md b/vendor/github.com/openshift/api/README.md index 330c1d27d6..fe65d98010 100644 --- a/vendor/github.com/openshift/api/README.md +++ b/vendor/github.com/openshift/api/README.md @@ -8,35 +8,6 @@ conventions](https://github.com/openshift/enhancements/blob/master/CONVENTIONS.m and then follow the instructions below to regenerate CRDs (if necessary) and submit a pull request with your new API definitions and generated files. -## pull request process - -Pull requests that change API types in this repo that have corresponding "internal" API objects in the -[openshift/origin](https://github.com/openshift/origin) repo must be paired with a pull request to -[openshift/origin](https://github.com/openshift/origin). - -To ensure the corresponding origin pull request is ready to merge as soon as the pull request to this repo is merged: -1. Base your pull request to this repo on latest [openshift/api#master](https://github.com/openshift/api/commits/master) and ensure CI is green -2. Base your pull request to openshift/origin on latest [openshift/origin#master](https://github.com/openshift/origin/commits/master) -3. In your openshift/origin pull request: - 1. Add a TMP commit that points [glide.yaml](https://github.com/openshift/origin/blob/master/glide.yaml#L39-L41) at your fork of openshift/api, and the branch of your pull request: - - ``` - - package: github.com/openshift/api - repo: https://github.com//api.git - version: "" - ``` - - 2. Update your `bump(*)` commit to include the result of running `hack/update-deps.sh`, which will pull in the changes from your openshift/api pull request - 3. Make sure CI is green on your openshift/origin pull request - 4. Get LGTM on your openshift/api pull request (for API changes) and your openshift/origin pull request (for code changes) - -Once both pull requests are ready, the openshift/api pull request can be merged. - -Then do the following with your openshift/origin pull request: -1. Drop the TMP commit (pointing glide back at openshift/api#master) -2. Rerun `hack/update-deps.sh` and update your `bump(*)` commit -3. It can then be tagged and merged by CI - ## generating CRD schemas Since Kubernetes 1.16, every CRD created in `apiextensions.k8s.io/v1` is required to have a [structural OpenAPIV3 schema](https://kubernetes.io/blog/2019/06/20/crd-structural-schema/). The schemas provide server-side validation for fields, as well as providing the descriptions for `oc explain`. Moreover, schemas ensure structural consistency of data in etcd. Without it anything can be stored in a resource which can have security implications. As we host many of our CRDs in this repo along with their corresponding Go types we also require them to have schemas. However, the following instructions apply for CRDs that are not hosted here as well. diff --git a/vendor/github.com/openshift/api/config/v1/0000_00_cluster-version-operator_01_clusterversion.crd.yaml b/vendor/github.com/openshift/api/config/v1/0000_00_cluster-version-operator_01_clusterversion.crd.yaml index ceb8b7e6d5..24f379c132 100644 --- a/vendor/github.com/openshift/api/config/v1/0000_00_cluster-version-operator_01_clusterversion.crd.yaml +++ b/vendor/github.com/openshift/api/config/v1/0000_00_cluster-version-operator_01_clusterversion.crd.yaml @@ -65,6 +65,7 @@ spec: enum: - openshift-samples - baremetal + - marketplace x-kubernetes-list-type: atomic baselineCapabilitySet: description: baselineCapabilitySet selects an initial set of optional capabilities to enable, which can be extended via additionalEnabledCapabilities. If unset, the cluster will choose a default, and the default may change over time. The current default is vCurrent. @@ -167,6 +168,7 @@ spec: enum: - openshift-samples - baremetal + - marketplace x-kubernetes-list-type: atomic knownCapabilities: description: knownCapabilities lists all the capabilities known to the current cluster. @@ -177,6 +179,7 @@ spec: enum: - openshift-samples - baremetal + - marketplace x-kubernetes-list-type: atomic conditionalUpdates: description: conditionalUpdates contains the list of updates that may be recommended for this cluster if it meets specific required conditions. Consumers interested in the set of updates that are actually recommended for this cluster should use availableUpdates. This list may be empty if no updates are recommended, if the update service is unavailable, or if an empty or invalid channel has been specified. diff --git a/vendor/github.com/openshift/api/config/v1/0000_03_config-operator_01_operatorhub.crd.yaml b/vendor/github.com/openshift/api/config/v1/0000_03_config-operator_01_operatorhub.crd.yaml index 4ba6c01cf4..e9895002f3 100644 --- a/vendor/github.com/openshift/api/config/v1/0000_03_config-operator_01_operatorhub.crd.yaml +++ b/vendor/github.com/openshift/api/config/v1/0000_03_config-operator_01_operatorhub.crd.yaml @@ -6,6 +6,7 @@ metadata: include.release.openshift.io/ibm-cloud-managed: "true" include.release.openshift.io/self-managed-high-availability: "true" include.release.openshift.io/single-node-developer: "true" + capability.openshift.io/name: "marketplace" name: operatorhubs.config.openshift.io spec: group: config.openshift.io diff --git a/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_infrastructure.crd.yaml b/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_infrastructure.crd.yaml index e91245de60..7db041fbab 100644 --- a/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_infrastructure.crd.yaml +++ b/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_infrastructure.crd.yaml @@ -92,6 +92,61 @@ spec: nutanix: description: Nutanix contains settings specific to the Nutanix infrastructure provider. type: object + required: + - prismCentral + - prismElements + properties: + prismCentral: + description: prismCentral holds the endpoint address and port to access the Nutanix Prism Central. When a cluster-wide proxy is installed, by default, this endpoint will be accessed via the proxy. Should you wish for communication with this endpoint not to be proxied, please add the endpoint to the proxy spec.noProxy list. + type: object + required: + - address + - port + properties: + address: + description: address is the endpoint address (DNS name or IP address) of the Nutanix Prism Central or Element (cluster) + type: string + maxLength: 256 + port: + description: port is the port number to access the Nutanix Prism Central or Element (cluster) + type: integer + format: int32 + maximum: 65535 + minimum: 1 + prismElements: + description: prismElements holds one or more endpoint address and port data to access the Nutanix Prism Elements (clusters) of the Nutanix Prism Central. Currently we only support one Prism Element (cluster) for an OpenShift cluster, where all the Nutanix resources (VMs, subnets, volumes, etc.) used in the OpenShift cluster are located. In the future, we may support Nutanix resources (VMs, etc.) spread over multiple Prism Elements (clusters) of the Prism Central. + type: array + items: + description: NutanixPrismElementEndpoint holds the name and endpoint data for a Prism Element (cluster) + type: object + required: + - endpoint + - name + properties: + endpoint: + description: endpoint holds the endpoint address and port data of the Prism Element (cluster). When a cluster-wide proxy is installed, by default, this endpoint will be accessed via the proxy. Should you wish for communication with this endpoint not to be proxied, please add the endpoint to the proxy spec.noProxy list. + type: object + required: + - address + - port + properties: + address: + description: address is the endpoint address (DNS name or IP address) of the Nutanix Prism Central or Element (cluster) + type: string + maxLength: 256 + port: + description: port is the port number to access the Nutanix Prism Central or Element (cluster) + type: integer + format: int32 + maximum: 65535 + minimum: 1 + name: + description: name is the name of the Prism Element (cluster). This value will correspond with the cluster field configured on other resources (eg Machines, PVCs, etc). + type: string + maxLength: 256 + x-kubernetes-list-map-keys: + - name + x-kubernetes-list-type: map openstack: description: OpenStack contains settings specific to the OpenStack infrastructure provider. type: object diff --git a/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_ingress.crd.yaml b/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_ingress.crd.yaml index 95fe8dfd99..ffc3666076 100644 --- a/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_ingress.crd.yaml +++ b/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_ingress.crd.yaml @@ -53,7 +53,7 @@ spec: hostname: description: hostname is the hostname that should be used by the route. type: string - format: hostname + pattern: ^([a-zA-Z0-9\p{S}\p{L}]((-?[a-zA-Z0-9\p{S}\p{L}]{0,62})?)|([a-zA-Z0-9\p{S}\p{L}](([a-zA-Z0-9-\p{S}\p{L}]{0,61}[a-zA-Z0-9\p{S}\p{L}])?)(\.)){1,}([a-zA-Z\p{L}]){2,63})$|^(([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})[\.]){0,}([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})$ name: description: "name is the logical name of the route to customize. \n The namespace and name of this componentRoute must match a corresponding entry in the list of status.componentRoutes if the route is to be customized." type: string @@ -226,13 +226,13 @@ spec: type: array minItems: 1 items: - description: Hostname is an alias for hostname string validation. + description: "Hostname is an alias for hostname string validation. \n The left operand of the | is the original kubebuilder hostname validation format, which is incorrect because it allows upper case letters, disallows hyphen or number in the TLD, and allows labels to start/end in non-alphanumeric characters. See https://bugzilla.redhat.com/show_bug.cgi?id=2039256. ^([a-zA-Z0-9\\p{S}\\p{L}]((-?[a-zA-Z0-9\\p{S}\\p{L}]{0,62})?)|([a-zA-Z0-9\\p{S}\\p{L}](([a-zA-Z0-9-\\p{S}\\p{L}]{0,61}[a-zA-Z0-9\\p{S}\\p{L}])?)(\\.)){1,}([a-zA-Z\\p{L}]){2,63})$ \n The right operand of the | is a new pattern that mimics the current API route admission validation on hostname, except that it allows hostnames longer than the maximum length: ^(([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})[\\.]){0,}([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})$ \n Both operand patterns are made available so that modifications on ingress spec can still happen after an invalid hostname was saved via validation by the incorrect left operand of the | operator." type: string - format: hostname + pattern: ^([a-zA-Z0-9\p{S}\p{L}]((-?[a-zA-Z0-9\p{S}\p{L}]{0,62})?)|([a-zA-Z0-9\p{S}\p{L}](([a-zA-Z0-9-\p{S}\p{L}]{0,61}[a-zA-Z0-9\p{S}\p{L}])?)(\.)){1,}([a-zA-Z\p{L}]){2,63})$|^(([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})[\.]){0,}([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})$ defaultHostname: description: defaultHostname is the hostname of this route prior to customization. type: string - format: hostname + pattern: ^([a-zA-Z0-9\p{S}\p{L}]((-?[a-zA-Z0-9\p{S}\p{L}]{0,62})?)|([a-zA-Z0-9\p{S}\p{L}](([a-zA-Z0-9-\p{S}\p{L}]{0,61}[a-zA-Z0-9\p{S}\p{L}])?)(\.)){1,}([a-zA-Z\p{L}]){2,63})$|^(([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})[\.]){0,}([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})$ name: description: "name is the logical name of the route to customize. It does not have to be the actual name of a route resource but it cannot be renamed. \n The namespace and name of this componentRoute must match a corresponding entry in the list of spec.componentRoutes if the route is to be customized." type: string @@ -268,6 +268,13 @@ spec: resource: description: resource of the referent. type: string + defaultPlacement: + description: "defaultPlacement is set at installation time to control which nodes will host the ingress router pods by default. The options are control-plane nodes or worker nodes. \n This field works by dictating how the Cluster Ingress Operator will consider unset replicas and nodePlacement fields in IngressController resources when creating the corresponding Deployments. \n See the documentation for the IngressController replicas and nodePlacement fields for more information. \n When omitted, the default value is Workers" + type: string + enum: + - ControlPlane + - Workers + - "" served: true storage: true subresources: diff --git a/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_node.crd.yaml b/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_node.crd.yaml index 67c78fec90..915961e149 100644 --- a/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_node.crd.yaml +++ b/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_node.crd.yaml @@ -14,7 +14,7 @@ spec: listKind: NodeList plural: nodes singular: node - scope: Namespaced + scope: Cluster versions: - name: v1 schema: @@ -39,9 +39,17 @@ spec: cgroupMode: description: CgroupMode determines the cgroups version on the node type: string + enum: + - v1 + - v2 + - "" workerLatencyProfile: description: WorkerLatencyProfile determins the how fast the kubelet is updating the status and corresponding reaction of the cluster type: string + enum: + - Default + - MediumUpdateAverageReaction + - LowUpdateSlowReaction status: description: status holds observed values. type: object @@ -51,40 +59,50 @@ spec: type: object properties: conditions: - description: conditions describes the state of the WorkerLatencyProfile and related components (Kubelet or Controller Manager or Kube API Server) + description: conditions describes the state of the WorkerLatencyProfile and related components (Kubelet or Controller Manager or Kube API Server) whether progressing, degraded or complete type: array items: + description: "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }" type: object required: - lastTransitionTime - - owner + - message + - reason - status - type properties: lastTransitionTime: - description: lastTransitionTime is the time of the last update to the current status property. + description: lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. type: string format: date-time message: - description: message provides additional information about the current condition. This is only to be consumed by humans. It may contain Line Feed characters (U+000A), which should be rendered as new lines. - type: string - owner: - description: Owner specifies the operator that is updating this condition + description: message is a human readable message indicating details about the transition. This may be an empty string. type: string + maxLength: 32768 + observedGeneration: + description: observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. + type: integer + format: int64 + minimum: 0 reason: - description: reason is the CamelCase reason for the condition's current status. + description: reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty. type: string + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ status: description: status of the condition, one of True, False, Unknown. type: string + enum: + - "True" + - "False" + - Unknown type: - description: type specifies the aspect reported by this condition. + description: type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt) type: string + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ served: true storage: true -status: - acceptedNames: - kind: "" - plural: "" - conditions: [] - storedVersions: [] + subresources: + status: {} diff --git a/vendor/github.com/openshift/api/config/v1/register.go b/vendor/github.com/openshift/api/config/v1/register.go index 7b15e80ed5..61302592ea 100644 --- a/vendor/github.com/openshift/api/config/v1/register.go +++ b/vendor/github.com/openshift/api/config/v1/register.go @@ -68,6 +68,10 @@ func addKnownTypes(scheme *runtime.Scheme) error { &SchedulerList{}, &ImageContentPolicy{}, &ImageContentPolicyList{}, + &ImageDigestMirrorSet{}, + &ImageDigestMirrorSetList{}, + &ImageTagMirrorSet{}, + &ImageTagMirrorSetList{}, ) metav1.AddToGroupVersion(scheme, GroupVersion) return nil diff --git a/vendor/github.com/openshift/api/config/v1/types_cluster_version.go b/vendor/github.com/openshift/api/config/v1/types_cluster_version.go index cd907699fe..52248a68ef 100644 --- a/vendor/github.com/openshift/api/config/v1/types_cluster_version.go +++ b/vendor/github.com/openshift/api/config/v1/types_cluster_version.go @@ -225,7 +225,7 @@ type UpdateHistory struct { type ClusterID string // ClusterVersionCapability enumerates optional, core cluster components. -// +kubebuilder:validation:Enum=openshift-samples;baremetal +// +kubebuilder:validation:Enum=openshift-samples;baremetal;marketplace type ClusterVersionCapability string const ( @@ -240,6 +240,11 @@ const ( // baremetal operator which is responsible for running the metal3 // deployment. ClusterVersionCapabilityBaremetal ClusterVersionCapability = "baremetal" + + // ClusterVersionCapabilityMarketplace manages the Marketplace operator which + // supplies Operator Lifecycle Manager (OLM) users with default catalogs of + // "optional" operators. + ClusterVersionCapabilityMarketplace ClusterVersionCapability = "marketplace" ) // ClusterVersionCapabilitySet defines sets of cluster version capabilities. @@ -269,10 +274,12 @@ var ClusterVersionCapabilitySets = map[ClusterVersionCapabilitySet][]ClusterVers ClusterVersionCapabilitySet4_11: { ClusterVersionCapabilityOpenShiftSamples, ClusterVersionCapabilityBaremetal, + ClusterVersionCapabilityMarketplace, }, ClusterVersionCapabilitySetCurrent: { ClusterVersionCapabilityOpenShiftSamples, ClusterVersionCapabilityBaremetal, + ClusterVersionCapabilityMarketplace, }, } diff --git a/vendor/github.com/openshift/api/config/v1/types_feature.go b/vendor/github.com/openshift/api/config/v1/types_feature.go index 52015391d6..7c34a1ef1d 100644 --- a/vendor/github.com/openshift/api/config/v1/types_feature.go +++ b/vendor/github.com/openshift/api/config/v1/types_feature.go @@ -111,7 +111,6 @@ var FeatureSets = map[FeatureSet]*FeatureGateEnabledDisabled{ Disabled: []string{}, }, TechPreviewNoUpgrade: newDefaultFeatures(). - with("CSIDriverAzureFile"). // sig-storage, fbertina, OCP specific with("CSIMigrationAWS"). // sig-storage, jsafrane, Kubernetes feature gate with("CSIMigrationGCE"). // sig-storage, fbertina, Kubernetes feature gate with("CSIMigrationAzureFile"). // sig-storage, fbertina, Kubernetes feature gate diff --git a/vendor/github.com/openshift/api/config/v1/types_image_digest_mirror_set.go b/vendor/github.com/openshift/api/config/v1/types_image_digest_mirror_set.go new file mode 100644 index 0000000000..3ac506943b --- /dev/null +++ b/vendor/github.com/openshift/api/config/v1/types_image_digest_mirror_set.go @@ -0,0 +1,126 @@ +package v1 + +import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ImageDigestMirrorSet holds cluster-wide information about how to handle registry mirror rules on using digest pull specification. +// When multiple policies are defined, the outcome of the behavior is defined on each field. +// +// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer). +// +openshift:compatibility-gen:level=1 +type ImageDigestMirrorSet struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // spec holds user settable values for configuration + // +kubebuilder:validation:Required + // +required + Spec ImageDigestMirrorSetSpec `json:"spec"` +} + +// ImageDigestMirrorSetSpec is the specification of the ImageDigestMirrorSet CRD. +type ImageDigestMirrorSetSpec struct { + // imageDigestMirrors allows images referenced by image digests in pods to be + // pulled from alternative mirrored repository locations. The image pull specification + // provided to the pod will be compared to the source locations described in imageDigestMirrors + // and the image may be pulled down from any of the mirrors in the list instead of the + // specified repository allowing administrators to choose a potentially faster mirror. + // To use mirrors to pull images using tag specification, users should configure + // a list of mirrors using "ImageTagMirrorSet" CRD. + // + // If the image pull specification matches the repository of "source" in multiple imagedigestmirrorset objects, + // only the objects which define the most specific namespace match will be used. + // For example, if there are objects using quay.io/libpod and quay.io/libpod/busybox as + // the "source", only the objects using quay.io/libpod/busybox are going to apply + // for pull specification quay.io/libpod/busybox. + // Each “source” repository is treated independently; configurations for different “source” + // repositories don’t interact. + // + // If the "mirrors" is not specified, the image will continue to be pulled from the specified + // repository in the pull spec. + // + // When multiple policies are defined for the same “source” repository, the sets of defined + // mirrors will be merged together, preserving the relative order of the mirrors, if possible. + // For example, if policy A has mirrors `a, b, c` and policy B has mirrors `c, d, e`, the + // mirrors will be used in the order `a, b, c, d, e`. If the orders of mirror entries conflict + // (e.g. `a, b` vs. `b, a`) the configuration is not rejected but the resulting order is unspecified. + // Users who want to use a specific order of mirrors, should configure them into one list of mirrors using the expected order. + // +optional + // +listType=atomic + ImageDigestMirrors []ImageDigestMirrors `json:"imageDigestMirrors"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ImageDigestMirrorSetList lists the items in the ImageDigestMirrorSet CRD. +// +// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer). +// +openshift:compatibility-gen:level=1 +type ImageDigestMirrorSetList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata"` + + Items []ImageDigestMirrorSet `json:"items"` +} + +// +kubebuilder:validation:Pattern=`^((?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])(?:(?:\.(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]))+)?(?::[0-9]+)?)(?:(?:/[a-z0-9]+(?:(?:(?:[._]|__|[-]*)[a-z0-9]+)+)?)+)?$` +type ImageMirror string + +// MirrorSourcePolicy defines the fallback policy if fails to pull image from the mirrors. +// +kubebuilder:validation:Enum=NeverContactSource;AllowContactingSource +type MirrorSourcePolicy string + +const ( + // NeverContactSource prevents image pull from the specified repository in the pull spec if the image pull from the mirror list fails. + NeverContactSource MirrorSourcePolicy = "NeverContactSource" + + // AllowContactingSource allows falling back to the specified repository in the pull spec if the image pull from the mirror list fails. + AllowContactingSource MirrorSourcePolicy = "AllowContactingSource" +) + +// ImageDigestMirrors holds cluster-wide information about how to handle mirrors in the registries config. +type ImageDigestMirrors struct { + // source matches the repository that users refer to, e.g. in image pull specifications. Setting source to a registry hostname + // e.g. docker.io. quay.io, or registry.redhat.io, will match the image pull specification of corressponding registry. + // "source" uses one of the following formats: + // host[:port] + // host[:port]/namespace[/namespace…] + // host[:port]/namespace[/namespace…]/repo + // [*.]host + // for more information about the format, see the document about the location field: + // https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table + // +required + // +kubebuilder:validation:Required + // +kubebuilder:validation:Pattern=`^\*(?:\.(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]))+$|^((?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])(?:(?:\.(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]))+)?(?::[0-9]+)?)(?:(?:/[a-z0-9]+(?:(?:(?:[._]|__|[-]*)[a-z0-9]+)+)?)+)?$` + Source string `json:"source"` + // mirrors is zero or more locations that may also contain the same images. No mirror will be configured if not specified. + // Images can be pulled from these mirrors only if they are referenced by their digests. + // The mirrored location is obtained by replacing the part of the input reference that + // matches source by the mirrors entry, e.g. for registry.redhat.io/product/repo reference, + // a (source, mirror) pair *.redhat.io, mirror.local/redhat causes a mirror.local/redhat/product/repo + // repository to be used. + // The order of mirrors in this list is treated as the user's desired priority, while source + // is by default considered lower priority than all mirrors. + // If no mirror is specified or all image pulls from the mirror list fail, the image will continue to be + // pulled from the repository in the pull spec unless explicitly prohibited by "mirrorSourcePolicy" + // Other cluster configuration, including (but not limited to) other imageDigestMirrors objects, + // may impact the exact order mirrors are contacted in, or some mirrors may be contacted + // in parallel, so this should be considered a preference rather than a guarantee of ordering. + // "mirrors" uses one of the following formats: + // host[:port] + // host[:port]/namespace[/namespace…] + // host[:port]/namespace[/namespace…]/repo + // for more information about the format, see the document about the location field: + // https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table + // +optional + // +listType=set + Mirrors []ImageMirror `json:"mirrors,omitempty"` + // mirrorSourcePolicy defines the fallback policy if fails to pull image from the mirrors. + // If unset, the image will continue to be pulled from the the repository in the pull spec. + // sourcePolicy is valid configuration only when one or more mirrors are in the mirror list. + // +optional + MirrorSourcePolicy MirrorSourcePolicy `json:"mirrorSourcePolicy,omitempty"` +} diff --git a/vendor/github.com/openshift/api/config/v1/types_image_tag_mirror_set.go b/vendor/github.com/openshift/api/config/v1/types_image_tag_mirror_set.go new file mode 100644 index 0000000000..5443705d29 --- /dev/null +++ b/vendor/github.com/openshift/api/config/v1/types_image_tag_mirror_set.go @@ -0,0 +1,113 @@ +package v1 + +import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ImageTagMirrorSet holds cluster-wide information about how to handle registry mirror rules on using tag pull specification. +// When multiple policies are defined, the outcome of the behavior is defined on each field. +// +// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer). +// +openshift:compatibility-gen:level=1 +type ImageTagMirrorSet struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // spec holds user settable values for configuration + // +kubebuilder:validation:Required + // +required + Spec ImageTagMirrorSetSpec `json:"spec"` +} + +// ImageTagMirrorSetSpec is the specification of the ImageTagMirrorSet CRD. +type ImageTagMirrorSetSpec struct { + // imageTagMirrors allows images referenced by image tags in pods to be + // pulled from alternative mirrored repository locations. The image pull specification + // provided to the pod will be compared to the source locations described in imageTagMirrors + // and the image may be pulled down from any of the mirrors in the list instead of the + // specified repository allowing administrators to choose a potentially faster mirror. + // To use mirrors to pull images using digest specification only, users should configure + // a list of mirrors using "ImageDigestMirrorSet" CRD. + // + // If the image pull specification matches the repository of "source" in multiple imagetagmirrorset objects, + // only the objects which define the most specific namespace match will be used. + // For example, if there are objects using quay.io/libpod and quay.io/libpod/busybox as + // the "source", only the objects using quay.io/libpod/busybox are going to apply + // for pull specification quay.io/libpod/busybox. + // Each “source” repository is treated independently; configurations for different “source” + // repositories don’t interact. + // + // If the "mirrors" is not specified, the image will continue to be pulled from the specified + // repository in the pull spec. + // + // When multiple policies are defined for the same “source” repository, the sets of defined + // mirrors will be merged together, preserving the relative order of the mirrors, if possible. + // For example, if policy A has mirrors `a, b, c` and policy B has mirrors `c, d, e`, the + // mirrors will be used in the order `a, b, c, d, e`. If the orders of mirror entries conflict + // (e.g. `a, b` vs. `b, a`) the configuration is not rejected but the resulting order is unspecified. + // Users who want to use a deterministic order of mirrors, should configure them into one list of mirrors using the expected order. + // +optional + // +listType=atomic + ImageTagMirrors []ImageTagMirrors `json:"imageTagMirrors"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ImageTagMirrorSetList lists the items in the ImageTagMirrorSet CRD. +// +// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer). +// +openshift:compatibility-gen:level=1 +type ImageTagMirrorSetList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata"` + + Items []ImageTagMirrorSet `json:"items"` +} + +// ImageTagMirrors holds cluster-wide information about how to handle mirrors in the registries config. +type ImageTagMirrors struct { + // source matches the repository that users refer to, e.g. in image pull specifications. Setting source to a registry hostname + // e.g. docker.io. quay.io, or registry.redhat.io, will match the image pull specification of corressponding registry. + // "source" uses one of the following formats: + // host[:port] + // host[:port]/namespace[/namespace…] + // host[:port]/namespace[/namespace…]/repo + // [*.]host + // for more information about the format, see the document about the location field: + // https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table + // +required + // +kubebuilder:validation:Required + // +kubebuilder:validation:Pattern=`^\*(?:\.(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]))+$|^((?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])(?:(?:\.(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]))+)?(?::[0-9]+)?)(?:(?:/[a-z0-9]+(?:(?:(?:[._]|__|[-]*)[a-z0-9]+)+)?)+)?$` + Source string `json:"source"` + // mirrors is zero or more locations that may also contain the same images. No mirror will be configured if not specified. + // Images can be pulled from these mirrors only if they are referenced by their tags. + // The mirrored location is obtained by replacing the part of the input reference that + // matches source by the mirrors entry, e.g. for registry.redhat.io/product/repo reference, + // a (source, mirror) pair *.redhat.io, mirror.local/redhat causes a mirror.local/redhat/product/repo + // repository to be used. + // Pulling images by tag can potentially yield different images, depending on which endpoint we pull from. + // Configuring a list of mirrors using "ImageDigestMirrorSet" CRD and forcing digest-pulls for mirrors avoids that issue. + // The order of mirrors in this list is treated as the user's desired priority, while source + // is by default considered lower priority than all mirrors. + // If no mirror is specified or all image pulls from the mirror list fail, the image will continue to be + // pulled from the repository in the pull spec unless explicitly prohibited by "mirrorSourcePolicy". + // Other cluster configuration, including (but not limited to) other imageTagMirrors objects, + // may impact the exact order mirrors are contacted in, or some mirrors may be contacted + // in parallel, so this should be considered a preference rather than a guarantee of ordering. + // "mirrors" uses one of the following formats: + // host[:port] + // host[:port]/namespace[/namespace…] + // host[:port]/namespace[/namespace…]/repo + // for more information about the format, see the document about the location field: + // https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table + // +optional + // +listType=set + Mirrors []ImageMirror `json:"mirrors,omitempty"` + // mirrorSourcePolicy defines the fallback policy if fails to pull image from the mirrors. + // If unset, the image will continue to be pulled from the repository in the pull spec. + // sourcePolicy is valid configuration only when one or more mirrors are in the mirror list. + // +optional + MirrorSourcePolicy MirrorSourcePolicy `json:"mirrorSourcePolicy,omitempty"` +} diff --git a/vendor/github.com/openshift/api/config/v1/types_infrastructure.go b/vendor/github.com/openshift/api/config/v1/types_infrastructure.go index 30e808c919..5cfa463f04 100644 --- a/vendor/github.com/openshift/api/config/v1/types_infrastructure.go +++ b/vendor/github.com/openshift/api/config/v1/types_infrastructure.go @@ -705,7 +705,54 @@ type AlibabaCloudResourceTag struct { // NutanixPlatformSpec holds the desired state of the Nutanix infrastructure provider. // This only includes fields that can be modified in the cluster. -type NutanixPlatformSpec struct{} +type NutanixPlatformSpec struct { + // prismCentral holds the endpoint address and port to access the Nutanix Prism Central. + // When a cluster-wide proxy is installed, by default, this endpoint will be accessed via the proxy. + // Should you wish for communication with this endpoint not to be proxied, please add the endpoint to the + // proxy spec.noProxy list. + // +kubebuilder:validation:Required + PrismCentral NutanixPrismEndpoint `json:"prismCentral"` + + // prismElements holds one or more endpoint address and port data to access the Nutanix + // Prism Elements (clusters) of the Nutanix Prism Central. Currently we only support one + // Prism Element (cluster) for an OpenShift cluster, where all the Nutanix resources (VMs, subnets, volumes, etc.) + // used in the OpenShift cluster are located. In the future, we may support Nutanix resources (VMs, etc.) + // spread over multiple Prism Elements (clusters) of the Prism Central. + // +kubebuilder:validation:Required + // +listType=map + // +listMapKey=name + PrismElements []NutanixPrismElementEndpoint `json:"prismElements"` +} + +// NutanixPrismEndpoint holds the endpoint address and port to access the Nutanix Prism Central or Element (cluster) +type NutanixPrismEndpoint struct { + // address is the endpoint address (DNS name or IP address) of the Nutanix Prism Central or Element (cluster) + // +kubebuilder:validation:Required + // +kubebuilder:validation:MaxLength=256 + Address string `json:"address"` + + // port is the port number to access the Nutanix Prism Central or Element (cluster) + // +kubebuilder:validation:Required + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:validation:Maximum=65535 + Port int32 `json:"port"` +} + +// NutanixPrismElementEndpoint holds the name and endpoint data for a Prism Element (cluster) +type NutanixPrismElementEndpoint struct { + // name is the name of the Prism Element (cluster). This value will correspond with + // the cluster field configured on other resources (eg Machines, PVCs, etc). + // +kubebuilder:validation:Required + // +kubebuilder:validation:MaxLength=256 + Name string `json:"name"` + + // endpoint holds the endpoint address and port data of the Prism Element (cluster). + // When a cluster-wide proxy is installed, by default, this endpoint will be accessed via the proxy. + // Should you wish for communication with this endpoint not to be proxied, please add the endpoint to the + // proxy spec.noProxy list. + // +kubebuilder:validation:Required + Endpoint NutanixPrismEndpoint `json:"endpoint"` +} // NutanixPlatformStatus holds the current status of the Nutanix infrastructure provider. type NutanixPlatformStatus struct { diff --git a/vendor/github.com/openshift/api/config/v1/types_ingress.go b/vendor/github.com/openshift/api/config/v1/types_ingress.go index 2c6bed3cb6..c7fec9c033 100644 --- a/vendor/github.com/openshift/api/config/v1/types_ingress.go +++ b/vendor/github.com/openshift/api/config/v1/types_ingress.go @@ -91,7 +91,20 @@ type IngressSpec struct { type ConsumingUser string // Hostname is an alias for hostname string validation. -// +kubebuilder:validation:Format=hostname +// +// The left operand of the | is the original kubebuilder hostname validation format, which is incorrect because it +// allows upper case letters, disallows hyphen or number in the TLD, and allows labels to start/end in non-alphanumeric +// characters. See https://bugzilla.redhat.com/show_bug.cgi?id=2039256. +// ^([a-zA-Z0-9\p{S}\p{L}]((-?[a-zA-Z0-9\p{S}\p{L}]{0,62})?)|([a-zA-Z0-9\p{S}\p{L}](([a-zA-Z0-9-\p{S}\p{L}]{0,61}[a-zA-Z0-9\p{S}\p{L}])?)(\.)){1,}([a-zA-Z\p{L}]){2,63})$ +// +// The right operand of the | is a new pattern that mimics the current API route admission validation on hostname, +// except that it allows hostnames longer than the maximum length: +// ^(([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})[\.]){0,}([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})$ +// +// Both operand patterns are made available so that modifications on ingress spec can still happen after an invalid hostname +// was saved via validation by the incorrect left operand of the | operator. +// +// +kubebuilder:validation:Pattern=`^([a-zA-Z0-9\p{S}\p{L}]((-?[a-zA-Z0-9\p{S}\p{L}]{0,62})?)|([a-zA-Z0-9\p{S}\p{L}](([a-zA-Z0-9-\p{S}\p{L}]{0,61}[a-zA-Z0-9\p{S}\p{L}])?)(\.)){1,}([a-zA-Z\p{L}]){2,63})$|^(([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})[\.]){0,}([a-z0-9][-a-z0-9]{0,61}[a-z0-9]|[a-z0-9]{1,63})$` type Hostname string type IngressStatus struct { @@ -99,6 +112,23 @@ type IngressStatus struct { // hostnames and serving certificates can be customized by the cluster-admin. // +optional ComponentRoutes []ComponentRouteStatus `json:"componentRoutes,omitempty"` + + // defaultPlacement is set at installation time to control which + // nodes will host the ingress router pods by default. The options are + // control-plane nodes or worker nodes. + // + // This field works by dictating how the Cluster Ingress Operator will + // consider unset replicas and nodePlacement fields in IngressController + // resources when creating the corresponding Deployments. + // + // See the documentation for the IngressController replicas and nodePlacement + // fields for more information. + // + // When omitted, the default value is Workers + // + // +kubebuilder:validation:Enum:="ControlPlane";"Workers";"" + // +optional + DefaultPlacement DefaultPlacement `json:"defaultPlacement"` } // ComponentRouteSpec allows for configuration of a route's hostname and serving certificate. @@ -209,3 +239,14 @@ type IngressList struct { Items []Ingress `json:"items"` } + +// DefaultPlacement defines the default placement of ingress router pods. +type DefaultPlacement string + +const ( + // "Workers" is for having router pods placed on worker nodes by default. + DefaultPlacementWorkers DefaultPlacement = "Workers" + + // "ControlPlane" is for having router pods placed on control-plane nodes by default. + DefaultPlacementControlPlane DefaultPlacement = "ControlPlane" +) diff --git a/vendor/github.com/openshift/api/config/v1/types_node.go b/vendor/github.com/openshift/api/config/v1/types_node.go index 011bdba5f3..d927bd8944 100644 --- a/vendor/github.com/openshift/api/config/v1/types_node.go +++ b/vendor/github.com/openshift/api/config/v1/types_node.go @@ -1,6 +1,10 @@ package v1 -import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +import ( + "time" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) // +genclient // +genclient:nonNamespaced @@ -10,6 +14,8 @@ import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" // // Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer). // +openshift:compatibility-gen:level=1 +// +kubebuilder:resource:path=nodes,scope=Cluster +// +kubebuilder:subresource:status type Node struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` @@ -41,6 +47,7 @@ type NodeStatus struct { WorkerLatencyProfileStatus WorkerLatencyProfileStatus `json:"workerLatencyProfileStatus,omitempty"` } +// +kubebuilder:validation:Enum=v1;v2;"" type CgroupMode string const ( @@ -50,6 +57,7 @@ const ( CgroupModeDefault CgroupMode = CgroupModeV1 ) +// +kubebuilder:validation:Enum=Default;MediumUpdateAverageReaction;LowUpdateSlowReaction type WorkerLatencyProfileType string const ( @@ -63,28 +71,60 @@ const ( DefaultUpdateDefaultReaction WorkerLatencyProfileType = "Default" ) +const ( + // DefaultNodeStatusUpdateFrequency refers to the "--node-status-update-frequency" of the kubelet in case of DefaultUpdateDefaultReaction WorkerLatencyProfile type + DefaultNodeStatusUpdateFrequency = 10 * time.Second + // DefaultNodeMonitorGracePeriod refers to the "--node-monitor-grace-period" of the Kube Controller Manager in case of DefaultUpdateDefaultReaction WorkerLatencyProfile type + DefaultNodeMonitorGracePeriod = 40 * time.Second + // DefaultNotReadyTolerationSeconds refers to the "--default-not-ready-toleration-seconds" of the Kube API Server in case of DefaultUpdateDefaultReaction WorkerLatencyProfile type + DefaultNotReadyTolerationSeconds = 300 + // DefaultUnreachableTolerationSeconds refers to the "--default-unreachable-toleration-seconds" of the Kube API Server in case of DefaultUpdateDefaultReaction WorkerLatencyProfile type + DefaultUnreachableTolerationSeconds = 300 + + // MediumNodeStatusUpdateFrequency refers to the "--node-status-update-frequency" of the kubelet in case of MediumUpdateAverageReaction WorkerLatencyProfile type + MediumNodeStatusUpdateFrequency = 20 * time.Second + // MediumNodeMonitorGracePeriod refers to the "--node-monitor-grace-period" of the Kube Controller Manager in case of MediumUpdateAverageReaction WorkerLatencyProfile type + MediumNodeMonitorGracePeriod = 2 * time.Minute + // MediumNotReadyTolerationSeconds refers to the "--default-not-ready-toleration-seconds" of the Kube API Server in case of MediumUpdateAverageReaction WorkerLatencyProfile type + MediumNotReadyTolerationSeconds = 60 + // MediumUnreachableTolerationSeconds refers to the "--default-unreachable-toleration-seconds" of the Kube API Server in case of MediumUpdateAverageReaction WorkerLatencyProfile type + MediumUnreachableTolerationSeconds = 60 + + // LowNodeStatusUpdateFrequency refers to the "--node-status-update-frequency" of the kubelet in case of LowUpdateSlowReaction WorkerLatencyProfile type + LowNodeStatusUpdateFrequency = 1 * time.Minute + // LowNodeMonitorGracePeriod refers to the "--node-monitor-grace-period" of the Kube Controller Manager in case of LowUpdateSlowReaction WorkerLatencyProfile type + LowNodeMonitorGracePeriod = 5 * time.Minute + // LowNotReadyTolerationSeconds refers to the "--default-not-ready-toleration-seconds" of the Kube API Server in case of LowUpdateSlowReaction WorkerLatencyProfile type + LowNotReadyTolerationSeconds = 60 + // LowUnreachableTolerationSeconds refers to the "--default-unreachable-toleration-seconds" of the Kube API Server in case of LowUpdateSlowReaction WorkerLatencyProfile type + LowUnreachableTolerationSeconds = 60 +) + // WorkerLatencyProfileStatus provides status information about the WorkerLatencyProfile rollout type WorkerLatencyProfileStatus struct { // conditions describes the state of the WorkerLatencyProfile and related components - // (Kubelet or Controller Manager or Kube API Server) + // (Kubelet or Controller Manager or Kube API Server) whether progressing, degraded or complete // +patchMergeKey=type // +patchStrategy=merge // +optional - Conditions []WorkerLatencyStatusCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"` + Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"` } -// WorkerLatencyStatusConditionType is an aspect of WorkerLatencyProfile state. -type WorkerLatencyStatusConditionType string - +// Different condition types to be used by KubeletOperator, Kube Controller +// Manager Operator and Kube API Server Operator const ( // Progressing indicates that the updates to component (Kubelet or Controller // Manager or Kube API Server) is actively rolling out, propagating changes to the // respective arguments. - WorkerLatencyProfileProgressing WorkerLatencyStatusConditionType = "Progressing" + KubeletProgressing = "KubeletProgressing" + KubeControllerManagerProgressing = "KubeControllerManagerProgressing" + KubeAPIServerProgressing = "KubeAPIServerProgressing" // Complete indicates whether the component (Kubelet or Controller Manager or Kube API Server) // is successfully updated the respective arguments. - WorkerLatencyProfileComplete WorkerLatencyStatusConditionType = "Complete" + KubeletComplete = "KubeletComplete" + KubeControllerManagerComplete = "KubeControllerManagerComplete" + KubeAPIServerComplete = "KubeAPIServerComplete" // Degraded indicates that the component (Kubelet or Controller Manager or Kube API Server) // does not reach the state 'Complete' over a period of time @@ -92,54 +132,11 @@ const ( // If the component enters in this state, "Default" WorkerLatencyProfileType // rollout will be initiated to restore the respective default arguments of all // components. - WorkerLatencyProfileDegraded WorkerLatencyStatusConditionType = "Degraded" + KubeletDegraded = "KubeletDegraded" + KubeControllerManagerDegraded = "KubeControllerManagerDegraded" + KubeAPIServerDegraded = "KubeAPIServerDegraded" ) -type WorkerLatencyStatusConditionOwner string - -const ( - // Machine Config Operator will update condition status by setting this as owner - MachineConfigOperator WorkerLatencyStatusConditionOwner = "MachineConfigOperator" - - // Kube Controller Manager Operator will update condition status by setting this as owner - KubeControllerManagerOperator WorkerLatencyStatusConditionOwner = "KubeControllerManagerOperator" - - // Kube API Server Operator will update condition status by setting this as owner - KubeAPIServerOperator WorkerLatencyStatusConditionOwner = "KubeAPIServerOperator" -) - -type WorkerLatencyStatusCondition struct { - // Owner specifies the operator that is updating this condition - // +kubebuilder:validation:Required - // +required - Owner WorkerLatencyStatusConditionOwner `json:"owner"` - - // type specifies the aspect reported by this condition. - // +kubebuilder:validation:Required - // +required - Type WorkerLatencyStatusConditionType `json:"type"` - - // status of the condition, one of True, False, Unknown. - // +kubebuilder:validation:Required - // +required - Status ConditionStatus `json:"status"` - - // lastTransitionTime is the time of the last update to the current status property. - // +kubebuilder:validation:Required - // +required - LastTransitionTime metav1.Time `json:"lastTransitionTime"` - - // reason is the CamelCase reason for the condition's current status. - // +optional - Reason string `json:"reason,omitempty"` - - // message provides additional information about the current condition. - // This is only to be consumed by humans. It may contain Line Feed - // characters (U+000A), which should be rendered as new lines. - // +optional - Message string `json:"message,omitempty"` -} - // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer). diff --git a/vendor/github.com/openshift/api/config/v1/zz_generated.deepcopy.go b/vendor/github.com/openshift/api/config/v1/zz_generated.deepcopy.go index 90cb33efde..d5f73e01f5 100644 --- a/vendor/github.com/openshift/api/config/v1/zz_generated.deepcopy.go +++ b/vendor/github.com/openshift/api/config/v1/zz_generated.deepcopy.go @@ -2319,6 +2319,110 @@ func (in *ImageContentPolicySpec) DeepCopy() *ImageContentPolicySpec { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageDigestMirrorSet) DeepCopyInto(out *ImageDigestMirrorSet) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageDigestMirrorSet. +func (in *ImageDigestMirrorSet) DeepCopy() *ImageDigestMirrorSet { + if in == nil { + return nil + } + out := new(ImageDigestMirrorSet) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ImageDigestMirrorSet) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageDigestMirrorSetList) DeepCopyInto(out *ImageDigestMirrorSetList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ImageDigestMirrorSet, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageDigestMirrorSetList. +func (in *ImageDigestMirrorSetList) DeepCopy() *ImageDigestMirrorSetList { + if in == nil { + return nil + } + out := new(ImageDigestMirrorSetList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ImageDigestMirrorSetList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageDigestMirrorSetSpec) DeepCopyInto(out *ImageDigestMirrorSetSpec) { + *out = *in + if in.ImageDigestMirrors != nil { + in, out := &in.ImageDigestMirrors, &out.ImageDigestMirrors + *out = make([]ImageDigestMirrors, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageDigestMirrorSetSpec. +func (in *ImageDigestMirrorSetSpec) DeepCopy() *ImageDigestMirrorSetSpec { + if in == nil { + return nil + } + out := new(ImageDigestMirrorSetSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageDigestMirrors) DeepCopyInto(out *ImageDigestMirrors) { + *out = *in + if in.Mirrors != nil { + in, out := &in.Mirrors, &out.Mirrors + *out = make([]ImageMirror, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageDigestMirrors. +func (in *ImageDigestMirrors) DeepCopy() *ImageDigestMirrors { + if in == nil { + return nil + } + out := new(ImageDigestMirrors) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ImageLabel) DeepCopyInto(out *ImageLabel) { *out = *in @@ -2417,6 +2521,110 @@ func (in *ImageStatus) DeepCopy() *ImageStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageTagMirrorSet) DeepCopyInto(out *ImageTagMirrorSet) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageTagMirrorSet. +func (in *ImageTagMirrorSet) DeepCopy() *ImageTagMirrorSet { + if in == nil { + return nil + } + out := new(ImageTagMirrorSet) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ImageTagMirrorSet) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageTagMirrorSetList) DeepCopyInto(out *ImageTagMirrorSetList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ImageTagMirrorSet, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageTagMirrorSetList. +func (in *ImageTagMirrorSetList) DeepCopy() *ImageTagMirrorSetList { + if in == nil { + return nil + } + out := new(ImageTagMirrorSetList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ImageTagMirrorSetList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageTagMirrorSetSpec) DeepCopyInto(out *ImageTagMirrorSetSpec) { + *out = *in + if in.ImageTagMirrors != nil { + in, out := &in.ImageTagMirrors, &out.ImageTagMirrors + *out = make([]ImageTagMirrors, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageTagMirrorSetSpec. +func (in *ImageTagMirrorSetSpec) DeepCopy() *ImageTagMirrorSetSpec { + if in == nil { + return nil + } + out := new(ImageTagMirrorSetSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ImageTagMirrors) DeepCopyInto(out *ImageTagMirrors) { + *out = *in + if in.Mirrors != nil { + in, out := &in.Mirrors, &out.Mirrors + *out = make([]ImageMirror, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageTagMirrors. +func (in *ImageTagMirrors) DeepCopy() *ImageTagMirrors { + if in == nil { + return nil + } + out := new(ImageTagMirrors) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Infrastructure) DeepCopyInto(out *Infrastructure) { *out = *in @@ -3142,6 +3350,12 @@ func (in *NodeStatus) DeepCopy() *NodeStatus { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *NutanixPlatformSpec) DeepCopyInto(out *NutanixPlatformSpec) { *out = *in + out.PrismCentral = in.PrismCentral + if in.PrismElements != nil { + in, out := &in.PrismElements, &out.PrismElements + *out = make([]NutanixPrismElementEndpoint, len(*in)) + copy(*out, *in) + } return } @@ -3171,6 +3385,39 @@ func (in *NutanixPlatformStatus) DeepCopy() *NutanixPlatformStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *NutanixPrismElementEndpoint) DeepCopyInto(out *NutanixPrismElementEndpoint) { + *out = *in + out.Endpoint = in.Endpoint + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NutanixPrismElementEndpoint. +func (in *NutanixPrismElementEndpoint) DeepCopy() *NutanixPrismElementEndpoint { + if in == nil { + return nil + } + out := new(NutanixPrismElementEndpoint) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *NutanixPrismEndpoint) DeepCopyInto(out *NutanixPrismEndpoint) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NutanixPrismEndpoint. +func (in *NutanixPrismEndpoint) DeepCopy() *NutanixPrismEndpoint { + if in == nil { + return nil + } + out := new(NutanixPrismEndpoint) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *OAuth) DeepCopyInto(out *OAuth) { *out = *in @@ -3659,7 +3906,7 @@ func (in *PlatformSpec) DeepCopyInto(out *PlatformSpec) { if in.Nutanix != nil { in, out := &in.Nutanix, &out.Nutanix *out = new(NutanixPlatformSpec) - **out = **in + (*in).DeepCopyInto(*out) } return } @@ -4559,7 +4806,7 @@ func (in *WorkerLatencyProfileStatus) DeepCopyInto(out *WorkerLatencyProfileStat *out = *in if in.Conditions != nil { in, out := &in.Conditions, &out.Conditions - *out = make([]WorkerLatencyStatusCondition, len(*in)) + *out = make([]metav1.Condition, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) } @@ -4576,20 +4823,3 @@ func (in *WorkerLatencyProfileStatus) DeepCopy() *WorkerLatencyProfileStatus { in.DeepCopyInto(out) return out } - -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *WorkerLatencyStatusCondition) DeepCopyInto(out *WorkerLatencyStatusCondition) { - *out = *in - in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkerLatencyStatusCondition. -func (in *WorkerLatencyStatusCondition) DeepCopy() *WorkerLatencyStatusCondition { - if in == nil { - return nil - } - out := new(WorkerLatencyStatusCondition) - in.DeepCopyInto(out) - return out -} diff --git a/vendor/github.com/openshift/api/config/v1/zz_generated.swagger_doc_generated.go b/vendor/github.com/openshift/api/config/v1/zz_generated.swagger_doc_generated.go index dac362df50..1e789e4752 100644 --- a/vendor/github.com/openshift/api/config/v1/zz_generated.swagger_doc_generated.go +++ b/vendor/github.com/openshift/api/config/v1/zz_generated.swagger_doc_generated.go @@ -904,6 +904,80 @@ func (RepositoryDigestMirrors) SwaggerDoc() map[string]string { return map_RepositoryDigestMirrors } +var map_ImageDigestMirrorSet = map[string]string{ + "": "ImageDigestMirrorSet holds cluster-wide information about how to handle registry mirror rules on using digest pull specification. When multiple policies are defined, the outcome of the behavior is defined on each field.\n\nCompatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).", + "spec": "spec holds user settable values for configuration", +} + +func (ImageDigestMirrorSet) SwaggerDoc() map[string]string { + return map_ImageDigestMirrorSet +} + +var map_ImageDigestMirrorSetList = map[string]string{ + "": "ImageDigestMirrorSetList lists the items in the ImageDigestMirrorSet CRD.\n\nCompatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).", +} + +func (ImageDigestMirrorSetList) SwaggerDoc() map[string]string { + return map_ImageDigestMirrorSetList +} + +var map_ImageDigestMirrorSetSpec = map[string]string{ + "": "ImageDigestMirrorSetSpec is the specification of the ImageDigestMirrorSet CRD.", + "imageDigestMirrors": "imageDigestMirrors allows images referenced by image digests in pods to be pulled from alternative mirrored repository locations. The image pull specification provided to the pod will be compared to the source locations described in imageDigestMirrors and the image may be pulled down from any of the mirrors in the list instead of the specified repository allowing administrators to choose a potentially faster mirror. To use mirrors to pull images using tag specification, users should configure a list of mirrors using \"ImageTagMirrorSet\" CRD.\n\nIf the image pull specification matches the repository of \"source\" in multiple imagedigestmirrorset objects, only the objects which define the most specific namespace match will be used. For example, if there are objects using quay.io/libpod and quay.io/libpod/busybox as the \"source\", only the objects using quay.io/libpod/busybox are going to apply for pull specification quay.io/libpod/busybox. Each “source” repository is treated independently; configurations for different “source” repositories don’t interact.\n\nIf the \"mirrors\" is not specified, the image will continue to be pulled from the specified repository in the pull spec.\n\nWhen multiple policies are defined for the same “source” repository, the sets of defined mirrors will be merged together, preserving the relative order of the mirrors, if possible. For example, if policy A has mirrors `a, b, c` and policy B has mirrors `c, d, e`, the mirrors will be used in the order `a, b, c, d, e`. If the orders of mirror entries conflict (e.g. `a, b` vs. `b, a`) the configuration is not rejected but the resulting order is unspecified. Users who want to use a specific order of mirrors, should configure them into one list of mirrors using the expected order.", +} + +func (ImageDigestMirrorSetSpec) SwaggerDoc() map[string]string { + return map_ImageDigestMirrorSetSpec +} + +var map_ImageDigestMirrors = map[string]string{ + "": "ImageDigestMirrors holds cluster-wide information about how to handle mirrors in the registries config.", + "source": "source matches the repository that users refer to, e.g. in image pull specifications. Setting source to a registry hostname e.g. docker.io. quay.io, or registry.redhat.io, will match the image pull specification of corressponding registry. \"source\" uses one of the following formats: host[:port] host[:port]/namespace[/namespace…] host[:port]/namespace[/namespace…]/repo [*.]host for more information about the format, see the document about the location field: https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table", + "mirrors": "mirrors is zero or more locations that may also contain the same images. No mirror will be configured if not specified. Images can be pulled from these mirrors only if they are referenced by their digests. The mirrored location is obtained by replacing the part of the input reference that matches source by the mirrors entry, e.g. for registry.redhat.io/product/repo reference, a (source, mirror) pair *.redhat.io, mirror.local/redhat causes a mirror.local/redhat/product/repo repository to be used. The order of mirrors in this list is treated as the user's desired priority, while source is by default considered lower priority than all mirrors. If no mirror is specified or all image pulls from the mirror list fail, the image will continue to be pulled from the repository in the pull spec unless explicitly prohibited by \"mirrorSourcePolicy\" Other cluster configuration, including (but not limited to) other imageDigestMirrors objects, may impact the exact order mirrors are contacted in, or some mirrors may be contacted in parallel, so this should be considered a preference rather than a guarantee of ordering. \"mirrors\" uses one of the following formats: host[:port] host[:port]/namespace[/namespace…] host[:port]/namespace[/namespace…]/repo for more information about the format, see the document about the location field: https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table", + "mirrorSourcePolicy": "mirrorSourcePolicy defines the fallback policy if fails to pull image from the mirrors. If unset, the image will continue to be pulled from the the repository in the pull spec. sourcePolicy is valid configuration only when one or more mirrors are in the mirror list.", +} + +func (ImageDigestMirrors) SwaggerDoc() map[string]string { + return map_ImageDigestMirrors +} + +var map_ImageTagMirrorSet = map[string]string{ + "": "ImageTagMirrorSet holds cluster-wide information about how to handle registry mirror rules on using tag pull specification. When multiple policies are defined, the outcome of the behavior is defined on each field.\n\nCompatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).", + "spec": "spec holds user settable values for configuration", +} + +func (ImageTagMirrorSet) SwaggerDoc() map[string]string { + return map_ImageTagMirrorSet +} + +var map_ImageTagMirrorSetList = map[string]string{ + "": "ImageTagMirrorSetList lists the items in the ImageTagMirrorSet CRD.\n\nCompatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).", +} + +func (ImageTagMirrorSetList) SwaggerDoc() map[string]string { + return map_ImageTagMirrorSetList +} + +var map_ImageTagMirrorSetSpec = map[string]string{ + "": "ImageTagMirrorSetSpec is the specification of the ImageTagMirrorSet CRD.", + "imageTagMirrors": "imageTagMirrors allows images referenced by image tags in pods to be pulled from alternative mirrored repository locations. The image pull specification provided to the pod will be compared to the source locations described in imageTagMirrors and the image may be pulled down from any of the mirrors in the list instead of the specified repository allowing administrators to choose a potentially faster mirror. To use mirrors to pull images using digest specification only, users should configure a list of mirrors using \"ImageDigestMirrorSet\" CRD.\n\nIf the image pull specification matches the repository of \"source\" in multiple imagetagmirrorset objects, only the objects which define the most specific namespace match will be used. For example, if there are objects using quay.io/libpod and quay.io/libpod/busybox as the \"source\", only the objects using quay.io/libpod/busybox are going to apply for pull specification quay.io/libpod/busybox. Each “source” repository is treated independently; configurations for different “source” repositories don’t interact.\n\nIf the \"mirrors\" is not specified, the image will continue to be pulled from the specified repository in the pull spec.\n\nWhen multiple policies are defined for the same “source” repository, the sets of defined mirrors will be merged together, preserving the relative order of the mirrors, if possible. For example, if policy A has mirrors `a, b, c` and policy B has mirrors `c, d, e`, the mirrors will be used in the order `a, b, c, d, e`. If the orders of mirror entries conflict (e.g. `a, b` vs. `b, a`) the configuration is not rejected but the resulting order is unspecified. Users who want to use a deterministic order of mirrors, should configure them into one list of mirrors using the expected order.", +} + +func (ImageTagMirrorSetSpec) SwaggerDoc() map[string]string { + return map_ImageTagMirrorSetSpec +} + +var map_ImageTagMirrors = map[string]string{ + "": "ImageTagMirrors holds cluster-wide information about how to handle mirrors in the registries config.", + "source": "source matches the repository that users refer to, e.g. in image pull specifications. Setting source to a registry hostname e.g. docker.io. quay.io, or registry.redhat.io, will match the image pull specification of corressponding registry. \"source\" uses one of the following formats: host[:port] host[:port]/namespace[/namespace…] host[:port]/namespace[/namespace…]/repo [*.]host for more information about the format, see the document about the location field: https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table", + "mirrors": "mirrors is zero or more locations that may also contain the same images. No mirror will be configured if not specified. Images can be pulled from these mirrors only if they are referenced by their tags. The mirrored location is obtained by replacing the part of the input reference that matches source by the mirrors entry, e.g. for registry.redhat.io/product/repo reference, a (source, mirror) pair *.redhat.io, mirror.local/redhat causes a mirror.local/redhat/product/repo repository to be used. Pulling images by tag can potentially yield different images, depending on which endpoint we pull from. Configuring a list of mirrors using \"ImageDigestMirrorSet\" CRD and forcing digest-pulls for mirrors avoids that issue. The order of mirrors in this list is treated as the user's desired priority, while source is by default considered lower priority than all mirrors. If no mirror is specified or all image pulls from the mirror list fail, the image will continue to be pulled from the repository in the pull spec unless explicitly prohibited by \"mirrorSourcePolicy\". Other cluster configuration, including (but not limited to) other imageTagMirrors objects, may impact the exact order mirrors are contacted in, or some mirrors may be contacted in parallel, so this should be considered a preference rather than a guarantee of ordering. \"mirrors\" uses one of the following formats: host[:port] host[:port]/namespace[/namespace…] host[:port]/namespace[/namespace…]/repo for more information about the format, see the document about the location field: https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table", + "mirrorSourcePolicy": "mirrorSourcePolicy defines the fallback policy if fails to pull image from the mirrors. If unset, the image will continue to be pulled from the repository in the pull spec. sourcePolicy is valid configuration only when one or more mirrors are in the mirror list.", +} + +func (ImageTagMirrors) SwaggerDoc() map[string]string { + return map_ImageTagMirrors +} + var map_AWSPlatformSpec = map[string]string{ "": "AWSPlatformSpec holds the desired state of the Amazon Web Services infrastructure provider. This only includes fields that can be modified in the cluster.", "serviceEndpoints": "serviceEndpoints list contains custom endpoints which will override default service endpoint of AWS Services. There must be only one ServiceEndpoint for a service.", @@ -1131,7 +1205,9 @@ func (KubevirtPlatformStatus) SwaggerDoc() map[string]string { } var map_NutanixPlatformSpec = map[string]string{ - "": "NutanixPlatformSpec holds the desired state of the Nutanix infrastructure provider. This only includes fields that can be modified in the cluster.", + "": "NutanixPlatformSpec holds the desired state of the Nutanix infrastructure provider. This only includes fields that can be modified in the cluster.", + "prismCentral": "prismCentral holds the endpoint address and port to access the Nutanix Prism Central. When a cluster-wide proxy is installed, by default, this endpoint will be accessed via the proxy. Should you wish for communication with this endpoint not to be proxied, please add the endpoint to the proxy spec.noProxy list.", + "prismElements": "prismElements holds one or more endpoint address and port data to access the Nutanix Prism Elements (clusters) of the Nutanix Prism Central. Currently we only support one Prism Element (cluster) for an OpenShift cluster, where all the Nutanix resources (VMs, subnets, volumes, etc.) used in the OpenShift cluster are located. In the future, we may support Nutanix resources (VMs, etc.) spread over multiple Prism Elements (clusters) of the Prism Central.", } func (NutanixPlatformSpec) SwaggerDoc() map[string]string { @@ -1148,6 +1224,26 @@ func (NutanixPlatformStatus) SwaggerDoc() map[string]string { return map_NutanixPlatformStatus } +var map_NutanixPrismElementEndpoint = map[string]string{ + "": "NutanixPrismElementEndpoint holds the name and endpoint data for a Prism Element (cluster)", + "name": "name is the name of the Prism Element (cluster). This value will correspond with the cluster field configured on other resources (eg Machines, PVCs, etc).", + "endpoint": "endpoint holds the endpoint address and port data of the Prism Element (cluster). When a cluster-wide proxy is installed, by default, this endpoint will be accessed via the proxy. Should you wish for communication with this endpoint not to be proxied, please add the endpoint to the proxy spec.noProxy list.", +} + +func (NutanixPrismElementEndpoint) SwaggerDoc() map[string]string { + return map_NutanixPrismElementEndpoint +} + +var map_NutanixPrismEndpoint = map[string]string{ + "": "NutanixPrismEndpoint holds the endpoint address and port to access the Nutanix Prism Central or Element (cluster)", + "address": "address is the endpoint address (DNS name or IP address) of the Nutanix Prism Central or Element (cluster)", + "port": "port is the port number to access the Nutanix Prism Central or Element (cluster)", +} + +func (NutanixPrismEndpoint) SwaggerDoc() map[string]string { + return map_NutanixPrismEndpoint +} + var map_OpenStackPlatformSpec = map[string]string{ "": "OpenStackPlatformSpec holds the desired state of the OpenStack infrastructure provider. This only includes fields that can be modified in the cluster.", } @@ -1338,7 +1434,8 @@ func (IngressSpec) SwaggerDoc() map[string]string { } var map_IngressStatus = map[string]string{ - "componentRoutes": "componentRoutes is where participating operators place the current route status for routes whose hostnames and serving certificates can be customized by the cluster-admin.", + "componentRoutes": "componentRoutes is where participating operators place the current route status for routes whose hostnames and serving certificates can be customized by the cluster-admin.", + "defaultPlacement": "defaultPlacement is set at installation time to control which nodes will host the ingress router pods by default. The options are control-plane nodes or worker nodes.\n\nThis field works by dictating how the Cluster Ingress Operator will consider unset replicas and nodePlacement fields in IngressController resources when creating the corresponding Deployments.\n\nSee the documentation for the IngressController replicas and nodePlacement fields for more information.\n\nWhen omitted, the default value is Workers", } func (IngressStatus) SwaggerDoc() map[string]string { @@ -1486,26 +1583,13 @@ func (NodeStatus) SwaggerDoc() map[string]string { var map_WorkerLatencyProfileStatus = map[string]string{ "": "WorkerLatencyProfileStatus provides status information about the WorkerLatencyProfile rollout", - "conditions": "conditions describes the state of the WorkerLatencyProfile and related components (Kubelet or Controller Manager or Kube API Server)", + "conditions": "conditions describes the state of the WorkerLatencyProfile and related components (Kubelet or Controller Manager or Kube API Server) whether progressing, degraded or complete", } func (WorkerLatencyProfileStatus) SwaggerDoc() map[string]string { return map_WorkerLatencyProfileStatus } -var map_WorkerLatencyStatusCondition = map[string]string{ - "owner": "Owner specifies the operator that is updating this condition", - "type": "type specifies the aspect reported by this condition.", - "status": "status of the condition, one of True, False, Unknown.", - "lastTransitionTime": "lastTransitionTime is the time of the last update to the current status property.", - "reason": "reason is the CamelCase reason for the condition's current status.", - "message": "message provides additional information about the current condition. This is only to be consumed by humans. It may contain Line Feed characters (U+000A), which should be rendered as new lines.", -} - -func (WorkerLatencyStatusCondition) SwaggerDoc() map[string]string { - return map_WorkerLatencyStatusCondition -} - var map_BasicAuthIdentityProvider = map[string]string{ "": "BasicAuthPasswordIdentityProvider provides identities for users authenticating using HTTP basic auth credentials", } diff --git a/vendor/github.com/openshift/api/imageregistry/v1/00_imageregistry.crd.yaml b/vendor/github.com/openshift/api/imageregistry/v1/00_imageregistry.crd.yaml index c1091da575..f91fad9476 100644 --- a/vendor/github.com/openshift/api/imageregistry/v1/00_imageregistry.crd.yaml +++ b/vendor/github.com/openshift/api/imageregistry/v1/00_imageregistry.crd.yaml @@ -1380,6 +1380,107 @@ spec: type: string type: object type: array + topologySpreadConstraints: + description: topologySpreadConstraints specify how to spread matching + pods among the given topology. + items: + description: TopologySpreadConstraint specifies how to spread matching + pods among the given topology. + properties: + labelSelector: + description: LabelSelector is used to find matching pods. Pods + that match this label selector are counted to determine the + number of pods in their corresponding topology domain. + properties: + matchExpressions: + description: matchExpressions is a list of label selector + requirements. The requirements are ANDed. + items: + description: A label selector requirement is a selector + that contains values, a key, and an operator that relates + the key and values. + properties: + key: + description: key is the label key that the selector + applies to. + type: string + operator: + description: operator represents a key's relationship + to a set of values. Valid operators are In, NotIn, + Exists and DoesNotExist. + type: string + values: + description: values is an array of string values. + If the operator is In or NotIn, the values array + must be non-empty. If the operator is Exists or + DoesNotExist, the values array must be empty. This + array is replaced during a strategic merge patch. + items: + type: string + type: array + required: + - key + - operator + type: object + type: array + matchLabels: + additionalProperties: + type: string + description: matchLabels is a map of {key,value} pairs. + A single {key,value} in the matchLabels map is equivalent + to an element of matchExpressions, whose key field is + "key", the operator is "In", and the values array contains + only "value". The requirements are ANDed. + type: object + type: object + maxSkew: + description: 'MaxSkew describes the degree to which pods may + be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, + it is the maximum permitted difference between the number + of matching pods in the target topology and the global minimum. + For example, in a 3-zone cluster, MaxSkew is set to 1, and + pods with the same labelSelector spread as 1/1/0: | zone1 + | zone2 | zone3 | | P | P | | - if MaxSkew is + 1, incoming pod can only be scheduled to zone3 to become 1/1/1; + scheduling it onto zone1(zone2) would make the ActualSkew(2-0) + on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming + pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, + it is used to give higher precedence to topologies that satisfy + it. It''s a required field. Default value is 1 and 0 is not + allowed.' + format: int32 + type: integer + topologyKey: + description: TopologyKey is the key of node labels. Nodes that + have a label with this key and identical values are considered + to be in the same topology. We consider each + as a "bucket", and try to put balanced number of pods into + each bucket. It's a required field. + type: string + whenUnsatisfiable: + description: 'WhenUnsatisfiable indicates how to deal with a + pod if it doesn''t satisfy the spread constraint. - DoNotSchedule + (default) tells the scheduler not to schedule it. - ScheduleAnyway + tells the scheduler to schedule the pod in any location, but + giving higher precedence to topologies that would help reduce + the skew. A constraint is considered "Unsatisfiable" for + an incoming pod if and only if every possible node assignment + for that pod would violate "MaxSkew" on some topology. For + example, in a 3-zone cluster, MaxSkew is set to 1, and pods + with the same labelSelector spread as 3/1/1: | zone1 | zone2 + | zone3 | | P P P | P | P | If WhenUnsatisfiable is + set to DoNotSchedule, incoming pod can only be scheduled to + zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on + zone2(zone3) satisfies MaxSkew(1). In other words, the cluster + can still be imbalanced, but scheduler won''t make it *more* + imbalanced. It''s a required field.' + type: string + required: + - maxSkew + - topologyKey + - whenUnsatisfiable + type: object + type: array unsupportedConfigOverrides: description: 'unsupportedConfigOverrides holds a sparse config that will override any previously set options. It only needs to be the diff --git a/vendor/github.com/openshift/api/imageregistry/v1/types.go b/vendor/github.com/openshift/api/imageregistry/v1/types.go index 777832af03..dd9d727cf0 100644 --- a/vendor/github.com/openshift/api/imageregistry/v1/types.go +++ b/vendor/github.com/openshift/api/imageregistry/v1/types.go @@ -107,6 +107,9 @@ type ImageRegistrySpec struct { // affinity is a group of node affinity scheduling rules for the image registry pod(s). // +optional Affinity *corev1.Affinity `json:"affinity,omitempty"` + // topologySpreadConstraints specify how to spread matching pods among the given topology. + // +optional + TopologySpreadConstraints []corev1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"` } // ImageRegistryStatus reports image registry operational status. diff --git a/vendor/github.com/openshift/api/imageregistry/v1/zz_generated.deepcopy.go b/vendor/github.com/openshift/api/imageregistry/v1/zz_generated.deepcopy.go index 2f2baafd26..af4ddc31a0 100644 --- a/vendor/github.com/openshift/api/imageregistry/v1/zz_generated.deepcopy.go +++ b/vendor/github.com/openshift/api/imageregistry/v1/zz_generated.deepcopy.go @@ -565,6 +565,13 @@ func (in *ImageRegistrySpec) DeepCopyInto(out *ImageRegistrySpec) { *out = new(corev1.Affinity) (*in).DeepCopyInto(*out) } + if in.TopologySpreadConstraints != nil { + in, out := &in.TopologySpreadConstraints, &out.TopologySpreadConstraints + *out = make([]corev1.TopologySpreadConstraint, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } return } diff --git a/vendor/github.com/openshift/api/imageregistry/v1/zz_generated.swagger_doc_generated.go b/vendor/github.com/openshift/api/imageregistry/v1/zz_generated.swagger_doc_generated.go index 95f5ddad0e..0bfc130a30 100644 --- a/vendor/github.com/openshift/api/imageregistry/v1/zz_generated.swagger_doc_generated.go +++ b/vendor/github.com/openshift/api/imageregistry/v1/zz_generated.swagger_doc_generated.go @@ -206,23 +206,24 @@ func (ImageRegistryConfigStorageSwift) SwaggerDoc() map[string]string { } var map_ImageRegistrySpec = map[string]string{ - "": "ImageRegistrySpec defines the specs for the running registry.", - "managementState": "managementState indicates whether the registry instance represented by this config instance is under operator management or not. Valid values are Managed, Unmanaged, and Removed.", - "httpSecret": "httpSecret is the value needed by the registry to secure uploads, generated by default.", - "proxy": "proxy defines the proxy to be used when calling master api, upstream registries, etc.", - "storage": "storage details for configuring registry storage, e.g. S3 bucket coordinates.", - "readOnly": "readOnly indicates whether the registry instance should reject attempts to push new images or delete existing ones.", - "disableRedirect": "disableRedirect controls whether to route all data through the Registry, rather than redirecting to the backend.", - "requests": "requests controls how many parallel requests a given registry instance will handle before queuing additional requests.", - "defaultRoute": "defaultRoute indicates whether an external facing route for the registry should be created using the default generated hostname.", - "routes": "routes defines additional external facing routes which should be created for the registry.", - "replicas": "replicas determines the number of registry instances to run.", - "logging": "logging is deprecated, use logLevel instead.", - "resources": "resources defines the resource requests+limits for the registry pod.", - "nodeSelector": "nodeSelector defines the node selection constraints for the registry pod.", - "tolerations": "tolerations defines the tolerations for the registry pod.", - "rolloutStrategy": "rolloutStrategy defines rollout strategy for the image registry deployment.", - "affinity": "affinity is a group of node affinity scheduling rules for the image registry pod(s).", + "": "ImageRegistrySpec defines the specs for the running registry.", + "managementState": "managementState indicates whether the registry instance represented by this config instance is under operator management or not. Valid values are Managed, Unmanaged, and Removed.", + "httpSecret": "httpSecret is the value needed by the registry to secure uploads, generated by default.", + "proxy": "proxy defines the proxy to be used when calling master api, upstream registries, etc.", + "storage": "storage details for configuring registry storage, e.g. S3 bucket coordinates.", + "readOnly": "readOnly indicates whether the registry instance should reject attempts to push new images or delete existing ones.", + "disableRedirect": "disableRedirect controls whether to route all data through the Registry, rather than redirecting to the backend.", + "requests": "requests controls how many parallel requests a given registry instance will handle before queuing additional requests.", + "defaultRoute": "defaultRoute indicates whether an external facing route for the registry should be created using the default generated hostname.", + "routes": "routes defines additional external facing routes which should be created for the registry.", + "replicas": "replicas determines the number of registry instances to run.", + "logging": "logging is deprecated, use logLevel instead.", + "resources": "resources defines the resource requests+limits for the registry pod.", + "nodeSelector": "nodeSelector defines the node selection constraints for the registry pod.", + "tolerations": "tolerations defines the tolerations for the registry pod.", + "rolloutStrategy": "rolloutStrategy defines rollout strategy for the image registry deployment.", + "affinity": "affinity is a group of node affinity scheduling rules for the image registry pod(s).", + "topologySpreadConstraints": "topologySpreadConstraints specify how to spread matching pods among the given topology.", } func (ImageRegistrySpec) SwaggerDoc() map[string]string { diff --git a/vendor/github.com/openshift/api/machine/v1beta1/types_awsprovider.go b/vendor/github.com/openshift/api/machine/v1beta1/types_awsprovider.go index 7d789f698e..d814f10d12 100644 --- a/vendor/github.com/openshift/api/machine/v1beta1/types_awsprovider.go +++ b/vendor/github.com/openshift/api/machine/v1beta1/types_awsprovider.go @@ -74,6 +74,11 @@ type AWSMachineProviderConfig struct { // SpotMarketOptions allows users to configure instances to be run using AWS Spot instances. // +optional SpotMarketOptions *SpotMarketOptions `json:"spotMarketOptions,omitempty"` + // MetadataServiceOptions allows users to configure instance metadata service interaction options. + // If nothing specified, default AWS IMDS settings will be applied. + // https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceMetadataOptionsRequest.html + // +optional + MetadataServiceOptions MetadataServiceOptions `json:"metadataServiceOptions,omitempty"` } // BlockDeviceMappingSpec describes a block device mapping @@ -160,6 +165,30 @@ type SpotMarketOptions struct { MaxPrice *string `json:"maxPrice,omitempty"` } +type MetadataServiceAuthentication string + +const ( + // MetadataServiceAuthenticationRequired enforces sending of a signed token header with any instance metadata retrieval (GET) requests. + // Enforces IMDSv2 usage. + MetadataServiceAuthenticationRequired = "Required" + // MetadataServiceAuthenticationOptional allows IMDSv1 usage along with IMDSv2 + MetadataServiceAuthenticationOptional = "Optional" +) + +// MetadataServiceOptions defines the options available to a user when configuring +// Instance Metadata Service (IMDS) Options. +type MetadataServiceOptions struct { + // Authentication determines whether or not the host requires the use of authentication when interacting with the metadata service. + // When using authentication, this enforces v2 interaction method (IMDSv2) with the metadata service. + // When omitted, this means the user has no opinion and the value is left to the platform to choose a good + // default, which is subject to change over time. The current default is optional. + // At this point this field represents `HttpTokens` parameter from `InstanceMetadataOptionsRequest` structure in AWS EC2 API + // https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceMetadataOptionsRequest.html + // +kubebuilder:validation:Enum=Required;Optional + // +optional + Authentication MetadataServiceAuthentication `json:"authentication,omitempty"` +} + // AWSResourceReference is a reference to a specific AWS resource by ID, ARN, or filters. // Only one of ID, ARN or Filters may be specified. Specifying more than one will result in // a validation error. @@ -296,25 +325,5 @@ type AWSMachineProviderStatus struct { // Conditions is a set of conditions associated with the Machine to indicate // errors or other status // +optional - Conditions []AWSMachineProviderCondition `json:"conditions,omitempty"` -} - -// AWSMachineProviderCondition is a condition in a AWSMachineProviderStatus. -type AWSMachineProviderCondition struct { - // Type is the type of the condition. - Type ConditionType `json:"type"` - // Status is the status of the condition. - Status corev1.ConditionStatus `json:"status"` - // LastProbeTime is the last time we probed the condition. - // +optional - LastProbeTime metav1.Time `json:"lastProbeTime,omitempty"` - // LastTransitionTime is the last time the condition transitioned from one status to another. - // +optional - LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"` - // Reason is a unique, one-word, CamelCase reason for the condition's last transition. - // +optional - Reason string `json:"reason,omitempty"` - // Message is a human-readable message indicating details about last transition. - // +optional - Message string `json:"message,omitempty"` + Conditions []metav1.Condition `json:"conditions,omitempty"` } diff --git a/vendor/github.com/openshift/api/machine/v1beta1/types_azureprovider.go b/vendor/github.com/openshift/api/machine/v1beta1/types_azureprovider.go index d326a2b841..914e73478e 100644 --- a/vendor/github.com/openshift/api/machine/v1beta1/types_azureprovider.go +++ b/vendor/github.com/openshift/api/machine/v1beta1/types_azureprovider.go @@ -143,7 +143,7 @@ type AzureMachineProviderStatus struct { // Conditions is a set of conditions associated with the Machine to indicate // errors or other status. // +optional - Conditions []AzureMachineProviderCondition `json:"conditions,omitempty"` + Conditions []metav1.Condition `json:"conditions,omitempty"` } // VMState describes the state of an Azure virtual machine. @@ -282,8 +282,26 @@ type DataDisk struct { // +optional // +kubebuilder:validation:Enum=None;ReadOnly;ReadWrite CachingType CachingTypeOption `json:"cachingType,omitempty"` + // DeletionPolicy specifies the data disk deletion policy upon Machine deletion. + // Possible values are "Delete","Detach". + // When "Delete" is used the data disk is deleted when the Machine is deleted. + // When "Detach" is used the data disk is detached from the Machine and retained when the Machine is deleted. + // +kubebuilder:validation:Enum=Delete;Detach + // +kubebuilder:validation:Required + DeletionPolicy DiskDeletionPolicyType `json:"deletionPolicy"` } +// DiskDeletionPolicyType defines the possible values for DeletionPolicy. +type DiskDeletionPolicyType string + +// These are the valid DiskDeletionPolicyType values. +const ( + // DiskDeletionPolicyTypeDelete means the DiskDeletionPolicyType is "Delete". + DiskDeletionPolicyTypeDelete DiskDeletionPolicyType = "Delete" + // DiskDeletionPolicyTypeDetach means the DiskDeletionPolicyType is "Detach". + DiskDeletionPolicyTypeDetach DiskDeletionPolicyType = "Detach" +) + // CachingTypeOption defines the different values for a CachingType. type CachingTypeOption string @@ -364,33 +382,13 @@ type SecurityProfile struct { EncryptionAtHost *bool `json:"encryptionAtHost,omitempty"` } -// AzureMachineProviderCondition is a condition in a AzureMachineProviderStatus -type AzureMachineProviderCondition struct { - // Type is the type of the condition. - Type ConditionType `json:"type"` - // Status is the status of the condition. - Status corev1.ConditionStatus `json:"status"` - // LastProbeTime is the last time we probed the condition. - // +optional - LastProbeTime metav1.Time `json:"lastProbeTime"` - // LastTransitionTime is the last time the condition transitioned from one status to another. - // +optional - LastTransitionTime metav1.Time `json:"lastTransitionTime"` - // Reason is a unique, one-word, CamelCase reason for the condition's last transition. - // +optional - Reason string `json:"reason"` - // Message is a human-readable message indicating details about last transition. - // +optional - Message string `json:"message"` -} - // AzureUltraSSDCapabilityState defines the different states of an UltraSSDCapability type AzureUltraSSDCapabilityState string // These are the valid AzureUltraSSDCapabilityState states. const ( - // "AzureUltraSSDCapabilityTrue" means the Azure UltraSSDCapability is Enabled - AzureUltraSSDCapabilityTrue AzureUltraSSDCapabilityState = "Enabled" - // "AzureUltraSSDCapabilityFalse" means the Azure UltraSSDCapability is Disabled - AzureUltraSSDCapabilityFalse AzureUltraSSDCapabilityState = "Disabled" + // "AzureUltraSSDCapabilityEnabled" means the Azure UltraSSDCapability is Enabled + AzureUltraSSDCapabilityEnabled AzureUltraSSDCapabilityState = "Enabled" + // "AzureUltraSSDCapabilityDisabled" means the Azure UltraSSDCapability is Disabled + AzureUltraSSDCapabilityDisabled AzureUltraSSDCapabilityState = "Disabled" ) diff --git a/vendor/github.com/openshift/api/machine/v1beta1/types_gcpprovider.go b/vendor/github.com/openshift/api/machine/v1beta1/types_gcpprovider.go index 4970bd7e22..6daac65eb0 100644 --- a/vendor/github.com/openshift/api/machine/v1beta1/types_gcpprovider.go +++ b/vendor/github.com/openshift/api/machine/v1beta1/types_gcpprovider.go @@ -199,25 +199,5 @@ type GCPMachineProviderStatus struct { // Conditions is a set of conditions associated with the Machine to indicate // errors or other status // +optional - Conditions []GCPMachineProviderCondition `json:"conditions,omitempty"` -} - -// GCPMachineProviderCondition is a condition in a GCPMachineProviderStatus -type GCPMachineProviderCondition struct { - // Type is the type of the condition. - Type ConditionType `json:"type"` - // Status is the status of the condition. - Status corev1.ConditionStatus `json:"status"` - // LastProbeTime is the last time we probed the condition. - // +optional - LastProbeTime metav1.Time `json:"lastProbeTime,omitempty"` - // LastTransitionTime is the last time the condition transitioned from one status to another. - // +optional - LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"` - // Reason is a unique, one-word, CamelCase reason for the condition's last transition. - // +optional - Reason string `json:"reason,omitempty"` - // Message is a human-readable message indicating details about last transition. - // +optional - Message string `json:"message,omitempty"` + Conditions []metav1.Condition `json:"conditions,omitempty"` } diff --git a/vendor/github.com/openshift/api/machine/v1beta1/types_vsphereprovider.go b/vendor/github.com/openshift/api/machine/v1beta1/types_vsphereprovider.go index 9d28632f80..2cf75675d8 100644 --- a/vendor/github.com/openshift/api/machine/v1beta1/types_vsphereprovider.go +++ b/vendor/github.com/openshift/api/machine/v1beta1/types_vsphereprovider.go @@ -114,26 +114,6 @@ type Workspace struct { ResourcePool string `gcfg:"resourcepool-path,omitempty" json:"resourcePool,omitempty"` } -// VSphereMachineProviderCondition is a condition in a VSphereMachineProviderStatus. -type VSphereMachineProviderCondition struct { - // Type is the type of the condition. - Type ConditionType `json:"type"` - // Status is the status of the condition. - Status corev1.ConditionStatus `json:"status"` - // LastProbeTime is the last time we probed the condition. - // +optional - LastProbeTime metav1.Time `json:"lastProbeTime,omitempty"` - // LastTransitionTime is the last time the condition transitioned from one status to another. - // +optional - LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"` - // Reason is a unique, one-word, CamelCase reason for the condition's last transition. - // +optional - Reason string `json:"reason,omitempty"` - // Message is a human-readable message indicating details about last transition. - // +optional - Message string `json:"message,omitempty"` -} - // VSphereMachineProviderStatus is the type that will be embedded in a Machine.Status.ProviderStatus field. // It contains VSphere-specific status information. // Compatibility level 2: Stable within a major release for a minimum of 9 months or 3 minor releases (whichever is longer). @@ -149,7 +129,7 @@ type VSphereMachineProviderStatus struct { InstanceState *string `json:"instanceState,omitempty"` // Conditions is a set of conditions associated with the Machine to indicate // errors or other status - Conditions []VSphereMachineProviderCondition `json:"conditions,omitempty"` + Conditions []metav1.Condition `json:"conditions,omitempty"` // TaskRef is a managed object reference to a Task related to the machine. // This value is set automatically at runtime and should not be set or // modified by users. diff --git a/vendor/github.com/openshift/api/machine/v1beta1/zz_generated.deepcopy.go b/vendor/github.com/openshift/api/machine/v1beta1/zz_generated.deepcopy.go index fdabf1112b..4af81f9d86 100644 --- a/vendor/github.com/openshift/api/machine/v1beta1/zz_generated.deepcopy.go +++ b/vendor/github.com/openshift/api/machine/v1beta1/zz_generated.deepcopy.go @@ -12,24 +12,6 @@ import ( intstr "k8s.io/apimachinery/pkg/util/intstr" ) -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *AWSMachineProviderCondition) DeepCopyInto(out *AWSMachineProviderCondition) { - *out = *in - in.LastProbeTime.DeepCopyInto(&out.LastProbeTime) - in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AWSMachineProviderCondition. -func (in *AWSMachineProviderCondition) DeepCopy() *AWSMachineProviderCondition { - if in == nil { - return nil - } - out := new(AWSMachineProviderCondition) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *AWSMachineProviderConfig) DeepCopyInto(out *AWSMachineProviderConfig) { *out = *in @@ -92,6 +74,7 @@ func (in *AWSMachineProviderConfig) DeepCopyInto(out *AWSMachineProviderConfig) *out = new(SpotMarketOptions) (*in).DeepCopyInto(*out) } + out.MetadataServiceOptions = in.MetadataServiceOptions return } @@ -154,7 +137,7 @@ func (in *AWSMachineProviderStatus) DeepCopyInto(out *AWSMachineProviderStatus) } if in.Conditions != nil { in, out := &in.Conditions, &out.Conditions - *out = make([]AWSMachineProviderCondition, len(*in)) + *out = make([]metav1.Condition, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) } @@ -205,24 +188,6 @@ func (in *AWSResourceReference) DeepCopy() *AWSResourceReference { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *AzureMachineProviderCondition) DeepCopyInto(out *AzureMachineProviderCondition) { - *out = *in - in.LastProbeTime.DeepCopyInto(&out.LastProbeTime) - in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AzureMachineProviderCondition. -func (in *AzureMachineProviderCondition) DeepCopy() *AzureMachineProviderCondition { - if in == nil { - return nil - } - out := new(AzureMachineProviderCondition) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *AzureMachineProviderSpec) DeepCopyInto(out *AzureMachineProviderSpec) { *out = *in @@ -317,7 +282,7 @@ func (in *AzureMachineProviderStatus) DeepCopyInto(out *AzureMachineProviderStat } if in.Conditions != nil { in, out := &in.Conditions, &out.Conditions - *out = make([]AzureMachineProviderCondition, len(*in)) + *out = make([]metav1.Condition, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) } @@ -624,24 +589,6 @@ func (in *GCPKMSKeyReference) DeepCopy() *GCPKMSKeyReference { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *GCPMachineProviderCondition) DeepCopyInto(out *GCPMachineProviderCondition) { - *out = *in - in.LastProbeTime.DeepCopyInto(&out.LastProbeTime) - in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GCPMachineProviderCondition. -func (in *GCPMachineProviderCondition) DeepCopy() *GCPMachineProviderCondition { - if in == nil { - return nil - } - out := new(GCPMachineProviderCondition) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *GCPMachineProviderSpec) DeepCopyInto(out *GCPMachineProviderSpec) { *out = *in @@ -757,7 +704,7 @@ func (in *GCPMachineProviderStatus) DeepCopyInto(out *GCPMachineProviderStatus) } if in.Conditions != nil { in, out := &in.Conditions, &out.Conditions - *out = make([]GCPMachineProviderCondition, len(*in)) + *out = make([]metav1.Condition, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) } @@ -1371,6 +1318,22 @@ func (in *MachineTemplateSpec) DeepCopy() *MachineTemplateSpec { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetadataServiceOptions) DeepCopyInto(out *MetadataServiceOptions) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetadataServiceOptions. +func (in *MetadataServiceOptions) DeepCopy() *MetadataServiceOptions { + if in == nil { + return nil + } + out := new(MetadataServiceOptions) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *NetworkDeviceSpec) DeepCopyInto(out *NetworkDeviceSpec) { *out = *in @@ -1618,24 +1581,6 @@ func (in *UnhealthyCondition) DeepCopy() *UnhealthyCondition { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *VSphereMachineProviderCondition) DeepCopyInto(out *VSphereMachineProviderCondition) { - *out = *in - in.LastProbeTime.DeepCopyInto(&out.LastProbeTime) - in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VSphereMachineProviderCondition. -func (in *VSphereMachineProviderCondition) DeepCopy() *VSphereMachineProviderCondition { - if in == nil { - return nil - } - out := new(VSphereMachineProviderCondition) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *VSphereMachineProviderSpec) DeepCopyInto(out *VSphereMachineProviderSpec) { *out = *in @@ -1694,7 +1639,7 @@ func (in *VSphereMachineProviderStatus) DeepCopyInto(out *VSphereMachineProvider } if in.Conditions != nil { in, out := &in.Conditions, &out.Conditions - *out = make([]VSphereMachineProviderCondition, len(*in)) + *out = make([]metav1.Condition, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) } diff --git a/vendor/github.com/openshift/api/machine/v1beta1/zz_generated.swagger_doc_generated.go b/vendor/github.com/openshift/api/machine/v1beta1/zz_generated.swagger_doc_generated.go index 8d3a010f01..5fff12fcbb 100644 --- a/vendor/github.com/openshift/api/machine/v1beta1/zz_generated.swagger_doc_generated.go +++ b/vendor/github.com/openshift/api/machine/v1beta1/zz_generated.swagger_doc_generated.go @@ -11,38 +11,25 @@ package v1beta1 // Those methods can be generated by using hack/update-swagger-docs.sh // AUTO-GENERATED FUNCTIONS START HERE -var map_AWSMachineProviderCondition = map[string]string{ - "": "AWSMachineProviderCondition is a condition in a AWSMachineProviderStatus.", - "type": "Type is the type of the condition.", - "status": "Status is the status of the condition.", - "lastProbeTime": "LastProbeTime is the last time we probed the condition.", - "lastTransitionTime": "LastTransitionTime is the last time the condition transitioned from one status to another.", - "reason": "Reason is a unique, one-word, CamelCase reason for the condition's last transition.", - "message": "Message is a human-readable message indicating details about last transition.", -} - -func (AWSMachineProviderCondition) SwaggerDoc() map[string]string { - return map_AWSMachineProviderCondition -} - var map_AWSMachineProviderConfig = map[string]string{ - "": "AWSMachineProviderConfig is the Schema for the awsmachineproviderconfigs API Compatibility level 2: Stable within a major release for a minimum of 9 months or 3 minor releases (whichever is longer).", - "ami": "AMI is the reference to the AMI from which to create the machine instance.", - "instanceType": "InstanceType is the type of instance to create. Example: m4.xlarge", - "tags": "Tags is the set of tags to add to apply to an instance, in addition to the ones added by default by the actuator. These tags are additive. The actuator will ensure these tags are present, but will not remove any other tags that may exist on the instance.", - "iamInstanceProfile": "IAMInstanceProfile is a reference to an IAM role to assign to the instance", - "userDataSecret": "UserDataSecret contains a local reference to a secret that contains the UserData to apply to the instance", - "credentialsSecret": "CredentialsSecret is a reference to the secret with AWS credentials. Otherwise, defaults to permissions provided by attached IAM role where the actuator is running.", - "keyName": "KeyName is the name of the KeyPair to use for SSH", - "deviceIndex": "DeviceIndex is the index of the device on the instance for the network interface attachment. Defaults to 0.", - "publicIp": "PublicIP specifies whether the instance should get a public IP. If not present, it should use the default of its subnet.", - "networkInterfaceType": "NetworkInterfaceType specifies the type of network interface to be used for the primary network interface. Valid values are \"ENA\", \"EFA\", and omitted, which means no opinion and the platform chooses a good default which may change over time. The current default value is \"ENA\". Please visit https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html to learn more about the AWS Elastic Fabric Adapter interface option.", - "securityGroups": "SecurityGroups is an array of references to security groups that should be applied to the instance.", - "subnet": "Subnet is a reference to the subnet to use for this instance", - "placement": "Placement specifies where to create the instance in AWS", - "loadBalancers": "LoadBalancers is the set of load balancers to which the new instance should be added once it is created.", - "blockDevices": "BlockDevices is the set of block device mapping associated to this instance, block device without a name will be used as a root device and only one device without a name is allowed https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html", - "spotMarketOptions": "SpotMarketOptions allows users to configure instances to be run using AWS Spot instances.", + "": "AWSMachineProviderConfig is the Schema for the awsmachineproviderconfigs API Compatibility level 2: Stable within a major release for a minimum of 9 months or 3 minor releases (whichever is longer).", + "ami": "AMI is the reference to the AMI from which to create the machine instance.", + "instanceType": "InstanceType is the type of instance to create. Example: m4.xlarge", + "tags": "Tags is the set of tags to add to apply to an instance, in addition to the ones added by default by the actuator. These tags are additive. The actuator will ensure these tags are present, but will not remove any other tags that may exist on the instance.", + "iamInstanceProfile": "IAMInstanceProfile is a reference to an IAM role to assign to the instance", + "userDataSecret": "UserDataSecret contains a local reference to a secret that contains the UserData to apply to the instance", + "credentialsSecret": "CredentialsSecret is a reference to the secret with AWS credentials. Otherwise, defaults to permissions provided by attached IAM role where the actuator is running.", + "keyName": "KeyName is the name of the KeyPair to use for SSH", + "deviceIndex": "DeviceIndex is the index of the device on the instance for the network interface attachment. Defaults to 0.", + "publicIp": "PublicIP specifies whether the instance should get a public IP. If not present, it should use the default of its subnet.", + "networkInterfaceType": "NetworkInterfaceType specifies the type of network interface to be used for the primary network interface. Valid values are \"ENA\", \"EFA\", and omitted, which means no opinion and the platform chooses a good default which may change over time. The current default value is \"ENA\". Please visit https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html to learn more about the AWS Elastic Fabric Adapter interface option.", + "securityGroups": "SecurityGroups is an array of references to security groups that should be applied to the instance.", + "subnet": "Subnet is a reference to the subnet to use for this instance", + "placement": "Placement specifies where to create the instance in AWS", + "loadBalancers": "LoadBalancers is the set of load balancers to which the new instance should be added once it is created.", + "blockDevices": "BlockDevices is the set of block device mapping associated to this instance, block device without a name will be used as a root device and only one device without a name is allowed https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html", + "spotMarketOptions": "SpotMarketOptions allows users to configure instances to be run using AWS Spot instances.", + "metadataServiceOptions": "MetadataServiceOptions allows users to configure instance metadata service interaction options. If nothing specified, default AWS IMDS settings will be applied. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceMetadataOptionsRequest.html", } func (AWSMachineProviderConfig) SwaggerDoc() map[string]string { @@ -132,6 +119,15 @@ func (LocalAWSPlacementGroupReference) SwaggerDoc() map[string]string { return map_LocalAWSPlacementGroupReference } +var map_MetadataServiceOptions = map[string]string{ + "": "MetadataServiceOptions defines the options available to a user when configuring Instance Metadata Service (IMDS) Options.", + "authentication": "Authentication determines whether or not the host requires the use of authentication when interacting with the metadata service. When using authentication, this enforces v2 interaction method (IMDSv2) with the metadata service. When omitted, this means the user has no opinion and the value is left to the platform to choose a good default, which is subject to change over time. The current default is optional. At this point this field represents `HttpTokens` parameter from `InstanceMetadataOptionsRequest` structure in AWS EC2 API https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceMetadataOptionsRequest.html", +} + +func (MetadataServiceOptions) SwaggerDoc() map[string]string { + return map_MetadataServiceOptions +} + var map_Placement = map[string]string{ "": "Placement indicates where to create the instance in AWS", "region": "Region is the region to use to create the instance", @@ -164,20 +160,6 @@ func (TagSpecification) SwaggerDoc() map[string]string { return map_TagSpecification } -var map_AzureMachineProviderCondition = map[string]string{ - "": "AzureMachineProviderCondition is a condition in a AzureMachineProviderStatus", - "type": "Type is the type of the condition.", - "status": "Status is the status of the condition.", - "lastProbeTime": "LastProbeTime is the last time we probed the condition.", - "lastTransitionTime": "LastTransitionTime is the last time the condition transitioned from one status to another.", - "reason": "Reason is a unique, one-word, CamelCase reason for the condition's last transition.", - "message": "Message is a human-readable message indicating details about last transition.", -} - -func (AzureMachineProviderCondition) SwaggerDoc() map[string]string { - return map_AzureMachineProviderCondition -} - var map_AzureMachineProviderSpec = map[string]string{ "": "AzureMachineProviderSpec is the type that will be embedded in a Machine.Spec.ProviderSpec field for an Azure virtual machine. It is used by the Azure machine actuator to create a single Machine. Required parameters such as location that are not specified by this configuration, will be defaulted by the actuator. Compatibility level 2: Stable within a major release for a minimum of 9 months or 3 minor releases (whichever is longer).", "userDataSecret": "UserDataSecret contains a local reference to a secret that contains the UserData to apply to the instance", @@ -224,12 +206,13 @@ func (AzureMachineProviderStatus) SwaggerDoc() map[string]string { } var map_DataDisk = map[string]string{ - "": "DataDisk specifies the parameters that are used to add one or more data disks to the machine. A Data Disk is a managed disk that's attached to a virtual machine to store application data. It differs from an OS Disk as it doesn't come with a pre-installed OS, and it cannot contain the boot volume. It is registered as SCSI drive and labeled with the chosen `lun`. e.g. for `lun: 0` the raw disk device will be available at `/dev/disk/azure/scsi1/lun0`.\n\nAs the Data Disk disk device is attached raw to the virtual machine, it will need to be partitioned, formatted with a filesystem and mounted, in order for it to be usable. This can be done by creating a custom userdata Secret with custom Ignition configuration to achieve the desired initialization. At this stage the previously defined `lun` is to be used as the \"device\" key for referencing the raw disk device to be initialized. Once the custom userdata Secret has been created, it can be referenced in the Machine's `.providerSpec.userDataSecret`. For further guidance and examples, please refer to the official OpenShift docs.", - "nameSuffix": "NameSuffix is the suffix to be appended to the machine name to generate the disk name. Each disk name will be in format _. NameSuffix name must start and finish with an alphanumeric character and can only contain letters, numbers, underscores, periods or hyphens. The overall disk name must not exceed 80 chars in length.", - "diskSizeGB": "DiskSizeGB is the size in GB to assign to the data disk.", - "managedDisk": "ManagedDisk specifies the Managed Disk parameters for the data disk. Empty value means no opinion and the platform chooses a default, which is subject to change over time. Currently the default is a ManagedDisk with with storageAccountType: \"Premium_LRS\" and diskEncryptionSet.id: \"Default\".", - "lun": "Lun Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM. This value is also needed for referencing the data disks devices within userdata to perform disk initialization through Ignition (e.g. partition/format/mount). The value must be between 0 and 63.", - "cachingType": "CachingType specifies the caching requirements. Empty value means no opinion and the platform chooses a default, which is subject to change over time. Currently the default is CachingTypeNone.", + "": "DataDisk specifies the parameters that are used to add one or more data disks to the machine. A Data Disk is a managed disk that's attached to a virtual machine to store application data. It differs from an OS Disk as it doesn't come with a pre-installed OS, and it cannot contain the boot volume. It is registered as SCSI drive and labeled with the chosen `lun`. e.g. for `lun: 0` the raw disk device will be available at `/dev/disk/azure/scsi1/lun0`.\n\nAs the Data Disk disk device is attached raw to the virtual machine, it will need to be partitioned, formatted with a filesystem and mounted, in order for it to be usable. This can be done by creating a custom userdata Secret with custom Ignition configuration to achieve the desired initialization. At this stage the previously defined `lun` is to be used as the \"device\" key for referencing the raw disk device to be initialized. Once the custom userdata Secret has been created, it can be referenced in the Machine's `.providerSpec.userDataSecret`. For further guidance and examples, please refer to the official OpenShift docs.", + "nameSuffix": "NameSuffix is the suffix to be appended to the machine name to generate the disk name. Each disk name will be in format _. NameSuffix name must start and finish with an alphanumeric character and can only contain letters, numbers, underscores, periods or hyphens. The overall disk name must not exceed 80 chars in length.", + "diskSizeGB": "DiskSizeGB is the size in GB to assign to the data disk.", + "managedDisk": "ManagedDisk specifies the Managed Disk parameters for the data disk. Empty value means no opinion and the platform chooses a default, which is subject to change over time. Currently the default is a ManagedDisk with with storageAccountType: \"Premium_LRS\" and diskEncryptionSet.id: \"Default\".", + "lun": "Lun Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM. This value is also needed for referencing the data disks devices within userdata to perform disk initialization through Ignition (e.g. partition/format/mount). The value must be between 0 and 63.", + "cachingType": "CachingType specifies the caching requirements. Empty value means no opinion and the platform chooses a default, which is subject to change over time. Currently the default is CachingTypeNone.", + "deletionPolicy": "DeletionPolicy specifies the data disk deletion policy upon Machine deletion. Possible values are \"Delete\",\"Detach\". When \"Delete\" is used the data disk is deleted when the Machine is deleted. When \"Detach\" is used the data disk is detached from the Machine and retained when the Machine is deleted.", } func (DataDisk) SwaggerDoc() map[string]string { @@ -365,20 +348,6 @@ func (GCPKMSKeyReference) SwaggerDoc() map[string]string { return map_GCPKMSKeyReference } -var map_GCPMachineProviderCondition = map[string]string{ - "": "GCPMachineProviderCondition is a condition in a GCPMachineProviderStatus", - "type": "Type is the type of the condition.", - "status": "Status is the status of the condition.", - "lastProbeTime": "LastProbeTime is the last time we probed the condition.", - "lastTransitionTime": "LastTransitionTime is the last time the condition transitioned from one status to another.", - "reason": "Reason is a unique, one-word, CamelCase reason for the condition's last transition.", - "message": "Message is a human-readable message indicating details about last transition.", -} - -func (GCPMachineProviderCondition) SwaggerDoc() map[string]string { - return map_GCPMachineProviderCondition -} - var map_GCPMachineProviderSpec = map[string]string{ "": "GCPMachineProviderSpec is the type that will be embedded in a Machine.Spec.ProviderSpec field for an GCP virtual machine. It is used by the GCP machine actuator to create a single Machine. Compatibility level 2: Stable within a major release for a minimum of 9 months or 3 minor releases (whichever is longer).", "userDataSecret": "UserDataSecret contains a local reference to a secret that contains the UserData to apply to the instance", @@ -687,20 +656,6 @@ func (NetworkSpec) SwaggerDoc() map[string]string { return map_NetworkSpec } -var map_VSphereMachineProviderCondition = map[string]string{ - "": "VSphereMachineProviderCondition is a condition in a VSphereMachineProviderStatus.", - "type": "Type is the type of the condition.", - "status": "Status is the status of the condition.", - "lastProbeTime": "LastProbeTime is the last time we probed the condition.", - "lastTransitionTime": "LastTransitionTime is the last time the condition transitioned from one status to another.", - "reason": "Reason is a unique, one-word, CamelCase reason for the condition's last transition.", - "message": "Message is a human-readable message indicating details about last transition.", -} - -func (VSphereMachineProviderCondition) SwaggerDoc() map[string]string { - return map_VSphereMachineProviderCondition -} - var map_VSphereMachineProviderSpec = map[string]string{ "": "VSphereMachineProviderSpec is the type that will be embedded in a Machine.Spec.ProviderSpec field for an VSphere virtual machine. It is used by the vSphere machine actuator to create a single Machine. Compatibility level 2: Stable within a major release for a minimum of 9 months or 3 minor releases (whichever is longer).", "userDataSecret": "UserDataSecret contains a local reference to a secret that contains the UserData to apply to the instance", diff --git a/vendor/github.com/openshift/api/operator/v1/0000_50_ingress-operator_00-ingresscontroller.crd.yaml b/vendor/github.com/openshift/api/operator/v1/0000_50_ingress-operator_00-ingresscontroller.crd.yaml index acb2c40587..2532678006 100644 --- a/vendor/github.com/openshift/api/operator/v1/0000_50_ingress-operator_00-ingresscontroller.crd.yaml +++ b/vendor/github.com/openshift/api/operator/v1/0000_50_ingress-operator_00-ingresscontroller.crd.yaml @@ -144,6 +144,28 @@ spec: description: hostNetwork holds parameters for the HostNetwork endpoint publishing strategy. Present only if type is HostNetwork. properties: + httpPort: + default: 80 + description: httpPort is the port on the host which should + be used to listen for HTTP requests. This field should be + set when port 80 is already in use. The value should not + coincide with the NodePort range of the cluster. When not + specified the value defaults to 80. + format: int32 + maximum: 65535 + minimum: 1 + type: integer + httpsPort: + default: 443 + description: httpsPort is the port on the host which should + be used to listen for HTTPS requests. This field should + be set when port 443 is already in use. The value should + not coincide with the NodePort range of the cluster. When + not specified the value defaults to 443. + format: int32 + maximum: 65535 + minimum: 1 + type: integer protocol: description: "protocol specifies whether the IngressController expects incoming connections to use plain TCP or whether @@ -167,6 +189,29 @@ spec: - TCP - PROXY type: string + statsPort: + default: 1936 + description: statsPort is the port on the host where the stats + from the router are published. The value should not coincide + with the NodePort range of the cluster. If an external load + balancer is configured to forward connections to this IngressController, + the load balancer should use this port for health checks. + The load balancer can send HTTP probes on this port on a + given node, with the path /healthz/ready to determine if + the ingress controller is ready to receive traffic on the + node. For proper operation the load balancer must not forward + traffic to a node until the health check reports ready. + The load balancer should also stop forwarding requests within + a maximum of 45 seconds after /healthz/ready starts reporting + not-ready. Probing every 5 to 10 seconds, with a 5-second + timeout and with a threshold of two successful or failed + requests to become healthy or unhealthy respectively, are + well-tested values. When not specified the value defaults + to 1936. + format: int32 + maximum: 65535 + minimum: 1 + type: integer type: object loadBalancer: description: loadBalancer holds parameters for the load balancer. @@ -237,12 +282,13 @@ spec: type: description: type is the underlying infrastructure provider for the load balancer. Allowed values are "AWS", "Azure", - "BareMetal", "GCP", "OpenStack", and "VSphere". + "BareMetal", "GCP", "Nutanix", "OpenStack", and "VSphere". enum: - AWS - Azure - BareMetal - GCP + - Nutanix - OpenStack - VSphere - IBM @@ -806,9 +852,14 @@ spec: properties: nodeSelector: description: "nodeSelector is the node selector applied to ingress - controller deployments. \n If unset, the default is: \n kubernetes.io/os: - linux node-role.kubernetes.io/worker: '' \n If set, the specified - selector is used and replaces the default." + controller deployments. \n If set, the specified selector is + used and replaces the default. \n If unset, the default depends + on the value of the defaultPlacement field in the cluster config.openshift.io/v1/ingresses + status. \n When defaultPlacement is Workers, the default is: + \n kubernetes.io/os: linux node-role.kubernetes.io/worker: + '' \n When defaultPlacement is ControlPlane, the default is: + \n kubernetes.io/os: linux node-role.kubernetes.io/master: + '' \n These defaults are subject to change." properties: matchExpressions: description: matchExpressions is a list of label selector @@ -896,8 +947,16 @@ spec: type: array type: object replicas: - description: replicas is the desired number of ingress controller - replicas. If unset, defaults to 2. + description: "replicas is the desired number of ingress controller + replicas. If unset, the default depends on the value of the defaultPlacement + field in the cluster config.openshift.io/v1/ingresses status. \n + The value of replicas is set based on the value of a chosen field + in the Infrastructure CR. If defaultPlacement is set to ControlPlane, + the chosen field will be controlPlaneTopology. If it is set to Workers + the chosen field will be infrastructureTopology. Replicas will then + be set to 1 or 2 based whether the chosen field's value is SingleReplica + or HighlyAvailable, respectively. \n These defaults are subject + to change." format: int32 type: integer routeAdmission: @@ -1126,6 +1185,24 @@ spec: format: int32 minimum: 4096 type: integer + healthCheckInterval: + description: "healthCheckInterval defines how long the router + waits between two consecutive health checks on its configured + backends. This value is applied globally as a default for all + routes, but may be overridden per-route by the route annotation + \"router.openshift.io/haproxy.health.check.interval\". \n Setting + this to less than 5s can cause excess traffic due to too frequent + TCP health checks and accompanying SYN packet storms. Alternatively, + setting this too high can result in increased latency, due to + backend servers that are no longer available, but haven't yet + been detected as such. \n An empty or zero healthCheckInterval + means no opinion and IngressController chooses a default, which + is subject to change over time. Currently the default healthCheckInterval + value is 5s. \n Currently the minimum allowed value is 1s and + the maximum allowed value is 2147483647ms (24.85 days). Both + are subject to change over time." + format: duration + type: string serverFinTimeout: description: "serverFinTimeout defines how long a connection will be held open while waiting for the server/backend response to @@ -1233,6 +1310,28 @@ spec: description: hostNetwork holds parameters for the HostNetwork endpoint publishing strategy. Present only if type is HostNetwork. properties: + httpPort: + default: 80 + description: httpPort is the port on the host which should + be used to listen for HTTP requests. This field should be + set when port 80 is already in use. The value should not + coincide with the NodePort range of the cluster. When not + specified the value defaults to 80. + format: int32 + maximum: 65535 + minimum: 1 + type: integer + httpsPort: + default: 443 + description: httpsPort is the port on the host which should + be used to listen for HTTPS requests. This field should + be set when port 443 is already in use. The value should + not coincide with the NodePort range of the cluster. When + not specified the value defaults to 443. + format: int32 + maximum: 65535 + minimum: 1 + type: integer protocol: description: "protocol specifies whether the IngressController expects incoming connections to use plain TCP or whether @@ -1256,6 +1355,29 @@ spec: - TCP - PROXY type: string + statsPort: + default: 1936 + description: statsPort is the port on the host where the stats + from the router are published. The value should not coincide + with the NodePort range of the cluster. If an external load + balancer is configured to forward connections to this IngressController, + the load balancer should use this port for health checks. + The load balancer can send HTTP probes on this port on a + given node, with the path /healthz/ready to determine if + the ingress controller is ready to receive traffic on the + node. For proper operation the load balancer must not forward + traffic to a node until the health check reports ready. + The load balancer should also stop forwarding requests within + a maximum of 45 seconds after /healthz/ready starts reporting + not-ready. Probing every 5 to 10 seconds, with a 5-second + timeout and with a threshold of two successful or failed + requests to become healthy or unhealthy respectively, are + well-tested values. When not specified the value defaults + to 1936. + format: int32 + maximum: 65535 + minimum: 1 + type: integer type: object loadBalancer: description: loadBalancer holds parameters for the load balancer. @@ -1326,12 +1448,13 @@ spec: type: description: type is the underlying infrastructure provider for the load balancer. Allowed values are "AWS", "Azure", - "BareMetal", "GCP", "OpenStack", and "VSphere". + "BareMetal", "GCP", "Nutanix", "OpenStack", and "VSphere". enum: - AWS - Azure - BareMetal - GCP + - Nutanix - OpenStack - VSphere - IBM @@ -1418,10 +1541,99 @@ spec: required: - type type: object + namespaceSelector: + description: namespaceSelector is the actual namespaceSelector in + use. + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. + The requirements are ANDed. + items: + description: A label selector requirement is a selector that + contains values, a key, and an operator that relates the key + and values. + properties: + key: + description: key is the label key that the selector applies + to. + type: string + operator: + description: operator represents a key's relationship to + a set of values. Valid operators are In, NotIn, Exists + and DoesNotExist. + type: string + values: + description: values is an array of string values. If the + operator is In or NotIn, the values array must be non-empty. + If the operator is Exists or DoesNotExist, the values + array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + required: + - key + - operator + type: object + type: array + matchLabels: + additionalProperties: + type: string + description: matchLabels is a map of {key,value} pairs. A single + {key,value} in the matchLabels map is equivalent to an element + of matchExpressions, whose key field is "key", the operator + is "In", and the values array contains only "value". The requirements + are ANDed. + type: object + type: object observedGeneration: description: observedGeneration is the most recent generation observed. format: int64 type: integer + routeSelector: + description: routeSelector is the actual routeSelector in use. + properties: + matchExpressions: + description: matchExpressions is a list of label selector requirements. + The requirements are ANDed. + items: + description: A label selector requirement is a selector that + contains values, a key, and an operator that relates the key + and values. + properties: + key: + description: key is the label key that the selector applies + to. + type: string + operator: + description: operator represents a key's relationship to + a set of values. Valid operators are In, NotIn, Exists + and DoesNotExist. + type: string + values: + description: values is an array of string values. If the + operator is In or NotIn, the values array must be non-empty. + If the operator is Exists or DoesNotExist, the values + array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + required: + - key + - operator + type: object + type: array + matchLabels: + additionalProperties: + type: string + description: matchLabels is a map of {key,value} pairs. A single + {key,value} in the matchLabels map is equivalent to an element + of matchExpressions, whose key field is "key", the operator + is "In", and the values array contains only "value". The requirements + are ANDed. + type: object + type: object selector: description: selector is a label selector, in string format, for ingress controller pods corresponding to the IngressController. The number diff --git a/vendor/github.com/openshift/api/operator/v1/0000_70_cluster-network-operator_01.crd.yaml b/vendor/github.com/openshift/api/operator/v1/0000_70_cluster-network-operator_01.crd.yaml index 5c088482c0..6ca60be271 100644 --- a/vendor/github.com/openshift/api/operator/v1/0000_70_cluster-network-operator_01.crd.yaml +++ b/vendor/github.com/openshift/api/operator/v1/0000_70_cluster-network-operator_01.crd.yaml @@ -200,9 +200,10 @@ spec: Kuryr prepopulate each newly created port pool with a minimum number of ports. Kuryr uses Neutron port pooling to fight the fact that it takes a significant amount of time to create - one. Instead of creating it when pod is being deployed, - Kuryr keeps a number of ports ready to be attached to pods. - By default port prepopulation is disabled. + one. It creates a number of ports when the first pod that + is configured to use the dedicated network for pods is created + in a namespace, and keeps them ready to be attached to pods. + Port prepopulation is disabled by default. type: boolean mtu: description: mtu is the MTU that Kuryr should use when creating diff --git a/vendor/github.com/openshift/api/operator/v1/0000_70_dns-operator_00.crd.yaml b/vendor/github.com/openshift/api/operator/v1/0000_70_dns-operator_00.crd.yaml index 158a99bd7a..f743eff6be 100644 --- a/vendor/github.com/openshift/api/operator/v1/0000_70_dns-operator_00.crd.yaml +++ b/vendor/github.com/openshift/api/operator/v1/0000_70_dns-operator_00.crd.yaml @@ -176,6 +176,75 @@ spec: - RoundRobin - Sequential type: string + transportConfig: + description: "transportConfig is used to configure the transport + type, server name, and optional custom CA or CA bundle + to use when forwarding DNS requests to an upstream resolver. + \n The default value is \"\" (empty) which results in + a standard cleartext connection being used when forwarding + DNS requests to an upstream resolver." + properties: + tls: + description: tls contains the additional configuration + options to use when Transport is set to "TLS". + properties: + caBundle: + description: "caBundle references a ConfigMap that + must contain either a single CA Certificate or + a CA Bundle (in the case of multiple upstreams + signed by different CAs). This allows cluster + administrators to provide their own CA or CA bundle + for validating the certificate of upstream resolvers. + \n 1. The configmap must contain a `ca-bundle.crt` + key. 2. The value must be a PEM encoded CA certificate + or CA bundle. 3. The administrator must create + this configmap in the openshift-config namespace." + properties: + name: + description: name is the metadata.name of the + referenced config map + type: string + required: + - name + type: object + serverName: + description: serverName is the upstream server to + connect to when forwarding DNS queries. This is + required when Transport is set to "TLS". ServerName + will be validated against the DNS naming conventions + in RFC 1123 and should match the TLS certificate + installed in the upstream resolver(s). + maxLength: 253 + pattern: ^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$ + type: string + required: + - serverName + type: object + transport: + description: "transport allows cluster administrators + to opt-in to using a DNS-over-TLS connection between + cluster DNS and an upstream resolver(s). Configuring + TLS as the transport at this level without configuring + a CABundle will result in the system certificates + being used to verify the serving certificate of the + upstream resolver(s). \n Possible values: \"\" (empty) + - This means no explicit choice has been made and + the platform chooses the default which is subject + to change over time. The current default is \"Cleartext\". + \"Cleartext\" - Cluster admin specified cleartext + option. This results in the same functionality as + an empty value but may be useful when a cluster admin + wants to be more explicit about the transport, or + wants to switch from \"TLS\" to \"Cleartext\" explicitly. + \"TLS\" - This indicates that DNS queries should be + sent over a TLS connection. If Transport is set to + TLS, you MUST also set ServerName." + enum: + - TLS + - Cleartext + - "" + type: string + type: object upstreams: description: "upstreams is a list of resolvers to forward name queries for subdomains of Zones. Each instance of @@ -228,6 +297,72 @@ spec: - RoundRobin - Sequential type: string + transportConfig: + description: "transportConfig is used to configure the transport + type, server name, and optional custom CA or CA bundle to use + when forwarding DNS requests to an upstream resolver. \n The + default value is \"\" (empty) which results in a standard cleartext + connection being used when forwarding DNS requests to an upstream + resolver." + properties: + tls: + description: tls contains the additional configuration options + to use when Transport is set to "TLS". + properties: + caBundle: + description: "caBundle references a ConfigMap that must + contain either a single CA Certificate or a CA Bundle + (in the case of multiple upstreams signed by different + CAs). This allows cluster administrators to provide + their own CA or CA bundle for validating the certificate + of upstream resolvers. \n 1. The configmap must contain + a `ca-bundle.crt` key. 2. The value must be a PEM encoded + CA certificate or CA bundle. 3. The administrator must + create this configmap in the openshift-config namespace." + properties: + name: + description: name is the metadata.name of the referenced + config map + type: string + required: + - name + type: object + serverName: + description: serverName is the upstream server to connect + to when forwarding DNS queries. This is required when + Transport is set to "TLS". ServerName will be validated + against the DNS naming conventions in RFC 1123 and should + match the TLS certificate installed in the upstream + resolver(s). + maxLength: 253 + pattern: ^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$ + type: string + required: + - serverName + type: object + transport: + description: "transport allows cluster administrators to opt-in + to using a DNS-over-TLS connection between cluster DNS and + an upstream resolver(s). Configuring TLS as the transport + at this level without configuring a CABundle will result + in the system certificates being used to verify the serving + certificate of the upstream resolver(s). \n Possible values: + \"\" (empty) - This means no explicit choice has been made + and the platform chooses the default which is subject to + change over time. The current default is \"Cleartext\". + \"Cleartext\" - Cluster admin specified cleartext option. + This results in the same functionality as an empty value + but may be useful when a cluster admin wants to be more + explicit about the transport, or wants to switch from \"TLS\" + to \"Cleartext\" explicitly. \"TLS\" - This indicates that + DNS queries should be sent over a TLS connection. If Transport + is set to TLS, you MUST also set ServerName." + enum: + - TLS + - Cleartext + - "" + type: string + type: object upstreams: default: - type: SystemResolvConf diff --git a/vendor/github.com/openshift/api/operator/v1/types_dns.go b/vendor/github.com/openshift/api/operator/v1/types_dns.go index c05a826cdf..086045c84e 100644 --- a/vendor/github.com/openshift/api/operator/v1/types_dns.go +++ b/vendor/github.com/openshift/api/operator/v1/types_dns.go @@ -1,6 +1,7 @@ package v1 import ( + v1 "github.com/openshift/api/config/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" corev1 "k8s.io/api/core/v1" @@ -130,6 +131,72 @@ type Server struct { ForwardPlugin ForwardPlugin `json:"forwardPlugin"` } +// DNSTransport indicates what type of connection should be used. +// +kubebuilder:validation:Enum=TLS;Cleartext;"" +type DNSTransport string + +const ( + // TLSTransport indicates that TLS should be used for the connection. + TLSTransport DNSTransport = "TLS" + + // CleartextTransport indicates that no encryption should be used for + // the connection. + CleartextTransport DNSTransport = "Cleartext" +) + +// DNSTransportConfig groups related configuration parameters used for configuring +// forwarding to upstream resolvers that support DNS-over-TLS. +// +union +type DNSTransportConfig struct { + // transport allows cluster administrators to opt-in to using a DNS-over-TLS + // connection between cluster DNS and an upstream resolver(s). Configuring + // TLS as the transport at this level without configuring a CABundle will + // result in the system certificates being used to verify the serving + // certificate of the upstream resolver(s). + // + // Possible values: + // "" (empty) - This means no explicit choice has been made and the platform chooses the default which is subject + // to change over time. The current default is "Cleartext". + // "Cleartext" - Cluster admin specified cleartext option. This results in the same functionality + // as an empty value but may be useful when a cluster admin wants to be more explicit about the transport, + // or wants to switch from "TLS" to "Cleartext" explicitly. + // "TLS" - This indicates that DNS queries should be sent over a TLS connection. If Transport is set to TLS, + // you MUST also set ServerName. + // + // +optional + // +unionDiscriminator + Transport DNSTransport `json:"transport,omitempty"` + + // tls contains the additional configuration options to use when Transport is set to "TLS". + TLS *DNSOverTLSConfig `json:"tls,omitempty"` +} + +// DNSOverTLSConfig describes optional DNSTransportConfig fields that should be captured. +type DNSOverTLSConfig struct { + // serverName is the upstream server to connect to when forwarding DNS queries. This is required when Transport is + // set to "TLS". ServerName will be validated against the DNS naming conventions in RFC 1123 and should match the + // TLS certificate installed in the upstream resolver(s). + // + // + --- + // + Inspired by the DNS1123 patterns in Kubernetes: https://github.com/kubernetes/kubernetes/blob/7c46f40bdf89a437ecdbc01df45e235b5f6d9745/staging/src/k8s.io/apimachinery/pkg/util/validation/validation.go#L178-L218 + // +kubebuilder:validation:Required + // +kubebuilder:validation:MaxLength=253 + // +kubebuilder:validation:Pattern=`^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$` + ServerName string `json:"serverName"` + + // caBundle references a ConfigMap that must contain either a single + // CA Certificate or a CA Bundle (in the case of multiple upstreams signed + // by different CAs). This allows cluster administrators to provide their + // own CA or CA bundle for validating the certificate of upstream resolvers. + // + // 1. The configmap must contain a `ca-bundle.crt` key. + // 2. The value must be a PEM encoded CA certificate or CA bundle. + // 3. The administrator must create this configmap in the openshift-config namespace. + // + // +optional + CABundle v1.ConfigMapNameReference `json:"caBundle,omitempty"` +} + // ForwardingPolicy is the policy to use when forwarding DNS requests. // +kubebuilder:validation:Enum=Random;RoundRobin;Sequential type ForwardingPolicy string @@ -170,6 +237,15 @@ type ForwardPlugin struct { // +optional // +kubebuilder:default:="Random" Policy ForwardingPolicy `json:"policy,omitempty"` + + // transportConfig is used to configure the transport type, server name, and optional custom CA or CA bundle to use + // when forwarding DNS requests to an upstream resolver. + // + // The default value is "" (empty) which results in a standard cleartext connection being used when forwarding DNS + // requests to an upstream resolver. + // + // +optional + TransportConfig DNSTransportConfig `json:"transportConfig,omitempty"` } // UpstreamResolvers defines a schema for configuring the CoreDNS forward plugin in the @@ -203,6 +279,15 @@ type UpstreamResolvers struct { // +optional // +kubebuilder:default="Sequential" Policy ForwardingPolicy `json:"policy,omitempty"` + + // transportConfig is used to configure the transport type, server name, and optional custom CA or CA bundle to use + // when forwarding DNS requests to an upstream resolver. + // + // The default value is "" (empty) which results in a standard cleartext connection being used when forwarding DNS + // requests to an upstream resolver. + // + // +optional + TransportConfig DNSTransportConfig `json:"transportConfig,omitempty"` } // Upstream can either be of type SystemResolvConf, or of type Network. diff --git a/vendor/github.com/openshift/api/operator/v1/types_ingress.go b/vendor/github.com/openshift/api/operator/v1/types_ingress.go index a50b2b78d2..ae43ec8dbc 100644 --- a/vendor/github.com/openshift/api/operator/v1/types_ingress.go +++ b/vendor/github.com/openshift/api/operator/v1/types_ingress.go @@ -76,7 +76,17 @@ type IngressControllerSpec struct { HttpErrorCodePages configv1.ConfigMapNameReference `json:"httpErrorCodePages,omitempty"` // replicas is the desired number of ingress controller replicas. If unset, - // defaults to 2. + // the default depends on the value of the defaultPlacement field in the + // cluster config.openshift.io/v1/ingresses status. + // + // The value of replicas is set based on the value of a chosen field in the + // Infrastructure CR. If defaultPlacement is set to ControlPlane, the + // chosen field will be controlPlaneTopology. If it is set to Workers the + // chosen field will be infrastructureTopology. Replicas will then be set to 1 + // or 2 based whether the chosen field's value is SingleReplica or + // HighlyAvailable, respectively. + // + // These defaults are subject to change. // // +optional Replicas *int32 `json:"replicas,omitempty"` @@ -292,12 +302,22 @@ type NodePlacement struct { // nodeSelector is the node selector applied to ingress controller // deployments. // - // If unset, the default is: + // If set, the specified selector is used and replaces the default. + // + // If unset, the default depends on the value of the defaultPlacement + // field in the cluster config.openshift.io/v1/ingresses status. + // + // When defaultPlacement is Workers, the default is: // // kubernetes.io/os: linux // node-role.kubernetes.io/worker: '' // - // If set, the specified selector is used and replaces the default. + // When defaultPlacement is ControlPlane, the default is: + // + // kubernetes.io/os: linux + // node-role.kubernetes.io/master: '' + // + // These defaults are subject to change. // // +optional NodeSelector *metav1.LabelSelector `json:"nodeSelector,omitempty"` @@ -371,8 +391,8 @@ type LoadBalancerStrategy struct { // +union type ProviderLoadBalancerParameters struct { // type is the underlying infrastructure provider for the load balancer. - // Allowed values are "AWS", "Azure", "BareMetal", "GCP", "OpenStack", - // and "VSphere". + // Allowed values are "AWS", "Azure", "BareMetal", "GCP", "Nutanix", + // "OpenStack", and "VSphere". // // +unionDiscriminator // +kubebuilder:validation:Required @@ -399,10 +419,10 @@ type ProviderLoadBalancerParameters struct { } // LoadBalancerProviderType is the underlying infrastructure provider for the -// load balancer. Allowed values are "AWS", "Azure", "BareMetal", "GCP", +// load balancer. Allowed values are "AWS", "Azure", "BareMetal", "GCP", "Nutanix", // "OpenStack", and "VSphere". // -// +kubebuilder:validation:Enum=AWS;Azure;BareMetal;GCP;OpenStack;VSphere;IBM +// +kubebuilder:validation:Enum=AWS;Azure;BareMetal;GCP;Nutanix;OpenStack;VSphere;IBM type LoadBalancerProviderType string const ( @@ -414,6 +434,7 @@ const ( IBMLoadBalancerProvider LoadBalancerProviderType = "IBM" BareMetalLoadBalancerProvider LoadBalancerProviderType = "BareMetal" AlibabaCloudLoadBalancerProvider LoadBalancerProviderType = "AlibabaCloud" + NutanixLoadBalancerProvider LoadBalancerProviderType = "Nutanix" ) // AWSLoadBalancerParameters provides configuration settings that are @@ -536,6 +557,46 @@ type HostNetworkStrategy struct { // +kubebuilder:validation:Optional // +optional Protocol IngressControllerProtocol `json:"protocol,omitempty"` + + // httpPort is the port on the host which should be used to listen for + // HTTP requests. This field should be set when port 80 is already in use. + // The value should not coincide with the NodePort range of the cluster. + // When not specified the value defaults to 80. + // +kubebuilder:validation:Optional + // +kubebuilder:validation:Maximum=65535 + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:default=80 + HTTPPort int32 `json:"httpPort"` + + // httpsPort is the port on the host which should be used to listen for + // HTTPS requests. This field should be set when port 443 is already in use. + // The value should not coincide with the NodePort range of the cluster. + // When not specified the value defaults to 443. + // +kubebuilder:validation:Optional + // +kubebuilder:validation:Maximum=65535 + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:default=443 + HTTPSPort int32 `json:"httpsPort"` + + // statsPort is the port on the host where the stats from the router are + // published. The value should not coincide with the NodePort range of the + // cluster. If an external load balancer is configured to forward connections + // to this IngressController, the load balancer should use this port for + // health checks. The load balancer can send HTTP probes on this port on a + // given node, with the path /healthz/ready to determine if the ingress + // controller is ready to receive traffic on the node. For proper operation + // the load balancer must not forward traffic to a node until the health + // check reports ready. The load balancer should also stop forwarding requests + // within a maximum of 45 seconds after /healthz/ready starts reporting + // not-ready. Probing every 5 to 10 seconds, with a 5-second timeout and with + // a threshold of two successful or failed requests to become healthy or + // unhealthy respectively, are well-tested values. When not specified the + // value defaults to 1936. + // +kubebuilder:validation:Optional + // +kubebuilder:validation:Maximum=65535 + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:default=1936 + StatsPort int32 `json:"statsPort"` } // PrivateStrategy holds parameters for the Private endpoint publishing @@ -1306,6 +1367,28 @@ type IngressControllerTuningOptions struct { // +kubebuilder:validation:Format=duration // +optional TLSInspectDelay *metav1.Duration `json:"tlsInspectDelay,omitempty"` + + // healthCheckInterval defines how long the router waits between two consecutive + // health checks on its configured backends. This value is applied globally as + // a default for all routes, but may be overridden per-route by the route annotation + // "router.openshift.io/haproxy.health.check.interval". + // + // Setting this to less than 5s can cause excess traffic due to too frequent + // TCP health checks and accompanying SYN packet storms. Alternatively, setting + // this too high can result in increased latency, due to backend servers that are no + // longer available, but haven't yet been detected as such. + // + // An empty or zero healthCheckInterval means no opinion and IngressController chooses + // a default, which is subject to change over time. + // Currently the default healthCheckInterval value is 5s. + // + // Currently the minimum allowed value is 1s and the maximum allowed value is + // 2147483647ms (24.85 days). Both are subject to change over time. + // + // +kubebuilder:validation:Optional + // +kubebuilder:validation:Format=duration + // +optional + HealthCheckInterval *metav1.Duration `json:"healthCheckInterval,omitempty"` } // HTTPEmptyRequestsPolicy indicates how HTTP connections for which no request @@ -1397,6 +1480,14 @@ type IngressControllerStatus struct { // observedGeneration is the most recent generation observed. // +optional ObservedGeneration int64 `json:"observedGeneration,omitempty"` + + // namespaceSelector is the actual namespaceSelector in use. + // +optional + NamespaceSelector *metav1.LabelSelector `json:"namespaceSelector,omitempty"` + + // routeSelector is the actual routeSelector in use. + // +optional + RouteSelector *metav1.LabelSelector `json:"routeSelector,omitempty"` } // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object diff --git a/vendor/github.com/openshift/api/operator/v1/types_network.go b/vendor/github.com/openshift/api/operator/v1/types_network.go index b3e397ab0b..e3bd64b0ea 100644 --- a/vendor/github.com/openshift/api/operator/v1/types_network.go +++ b/vendor/github.com/openshift/api/operator/v1/types_network.go @@ -343,9 +343,9 @@ type KuryrConfig struct { // enablePortPoolsPrepopulation when true will make Kuryr prepopulate each newly created port // pool with a minimum number of ports. Kuryr uses Neutron port pooling to fight the fact - // that it takes a significant amount of time to create one. Instead of creating it when - // pod is being deployed, Kuryr keeps a number of ports ready to be attached to pods. By - // default port prepopulation is disabled. + // that it takes a significant amount of time to create one. It creates a number of ports when + // the first pod that is configured to use the dedicated network for pods is created in a namespace, + // and keeps them ready to be attached to pods. Port prepopulation is disabled by default. // +optional EnablePortPoolsPrepopulation bool `json:"enablePortPoolsPrepopulation,omitempty"` diff --git a/vendor/github.com/openshift/api/operator/v1/zz_generated.deepcopy.go b/vendor/github.com/openshift/api/operator/v1/zz_generated.deepcopy.go index 23859af6d2..8b68d29533 100644 --- a/vendor/github.com/openshift/api/operator/v1/zz_generated.deepcopy.go +++ b/vendor/github.com/openshift/api/operator/v1/zz_generated.deepcopy.go @@ -918,6 +918,23 @@ func (in *DNSNodePlacement) DeepCopy() *DNSNodePlacement { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *DNSOverTLSConfig) DeepCopyInto(out *DNSOverTLSConfig) { + *out = *in + out.CABundle = in.CABundle + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DNSOverTLSConfig. +func (in *DNSOverTLSConfig) DeepCopy() *DNSOverTLSConfig { + if in == nil { + return nil + } + out := new(DNSOverTLSConfig) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *DNSSpec) DeepCopyInto(out *DNSSpec) { *out = *in @@ -966,6 +983,27 @@ func (in *DNSStatus) DeepCopy() *DNSStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *DNSTransportConfig) DeepCopyInto(out *DNSTransportConfig) { + *out = *in + if in.TLS != nil { + in, out := &in.TLS, &out.TLS + *out = new(DNSOverTLSConfig) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DNSTransportConfig. +func (in *DNSTransportConfig) DeepCopy() *DNSTransportConfig { + if in == nil { + return nil + } + out := new(DNSTransportConfig) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *DefaultNetworkDefinition) DeepCopyInto(out *DefaultNetworkDefinition) { *out = *in @@ -1235,6 +1273,7 @@ func (in *ForwardPlugin) DeepCopyInto(out *ForwardPlugin) { *out = make([]string, len(*in)) copy(*out, *in) } + in.TransportConfig.DeepCopyInto(&out.TransportConfig) return } @@ -1703,6 +1742,16 @@ func (in *IngressControllerStatus) DeepCopyInto(out *IngressControllerStatus) { *out = new(configv1.TLSProfileSpec) (*in).DeepCopyInto(*out) } + if in.NamespaceSelector != nil { + in, out := &in.NamespaceSelector, &out.NamespaceSelector + *out = new(metav1.LabelSelector) + (*in).DeepCopyInto(*out) + } + if in.RouteSelector != nil { + in, out := &in.RouteSelector, &out.RouteSelector + *out = new(metav1.LabelSelector) + (*in).DeepCopyInto(*out) + } return } @@ -1749,6 +1798,11 @@ func (in *IngressControllerTuningOptions) DeepCopyInto(out *IngressControllerTun *out = new(metav1.Duration) **out = **in } + if in.HealthCheckInterval != nil { + in, out := &in.HealthCheckInterval, &out.HealthCheckInterval + *out = new(metav1.Duration) + **out = **in + } return } @@ -3743,6 +3797,7 @@ func (in *UpstreamResolvers) DeepCopyInto(out *UpstreamResolvers) { *out = make([]Upstream, len(*in)) copy(*out, *in) } + in.TransportConfig.DeepCopyInto(&out.TransportConfig) return } diff --git a/vendor/github.com/openshift/api/operator/v1/zz_generated.swagger_doc_generated.go b/vendor/github.com/openshift/api/operator/v1/zz_generated.swagger_doc_generated.go index e42c685eb9..11e7d1562f 100644 --- a/vendor/github.com/openshift/api/operator/v1/zz_generated.swagger_doc_generated.go +++ b/vendor/github.com/openshift/api/operator/v1/zz_generated.swagger_doc_generated.go @@ -421,6 +421,16 @@ func (DNSNodePlacement) SwaggerDoc() map[string]string { return map_DNSNodePlacement } +var map_DNSOverTLSConfig = map[string]string{ + "": "DNSOverTLSConfig describes optional DNSTransportConfig fields that should be captured.", + "serverName": "serverName is the upstream server to connect to when forwarding DNS queries. This is required when Transport is set to \"TLS\". ServerName will be validated against the DNS naming conventions in RFC 1123 and should match the TLS certificate installed in the upstream resolver(s).", + "caBundle": "caBundle references a ConfigMap that must contain either a single CA Certificate or a CA Bundle (in the case of multiple upstreams signed by different CAs). This allows cluster administrators to provide their own CA or CA bundle for validating the certificate of upstream resolvers.\n\n1. The configmap must contain a `ca-bundle.crt` key. 2. The value must be a PEM encoded CA certificate or CA bundle. 3. The administrator must create this configmap in the openshift-config namespace.", +} + +func (DNSOverTLSConfig) SwaggerDoc() map[string]string { + return map_DNSOverTLSConfig +} + var map_DNSSpec = map[string]string{ "": "DNSSpec is the specification of the desired behavior of the DNS.", "servers": "servers is a list of DNS resolvers that provide name query delegation for one or more subdomains outside the scope of the cluster domain. If servers consists of more than one Server, longest suffix match will be used to determine the Server.\n\nFor example, if there are two Servers, one for \"foo.com\" and another for \"a.foo.com\", and the name query is for \"www.a.foo.com\", it will be routed to the Server with Zone \"a.foo.com\".\n\nIf this field is nil, no servers are created.", @@ -446,10 +456,21 @@ func (DNSStatus) SwaggerDoc() map[string]string { return map_DNSStatus } +var map_DNSTransportConfig = map[string]string{ + "": "DNSTransportConfig groups related configuration parameters used for configuring forwarding to upstream resolvers that support DNS-over-TLS.", + "transport": "transport allows cluster administrators to opt-in to using a DNS-over-TLS connection between cluster DNS and an upstream resolver(s). Configuring TLS as the transport at this level without configuring a CABundle will result in the system certificates being used to verify the serving certificate of the upstream resolver(s).\n\nPossible values: \"\" (empty) - This means no explicit choice has been made and the platform chooses the default which is subject to change over time. The current default is \"Cleartext\". \"Cleartext\" - Cluster admin specified cleartext option. This results in the same functionality as an empty value but may be useful when a cluster admin wants to be more explicit about the transport, or wants to switch from \"TLS\" to \"Cleartext\" explicitly. \"TLS\" - This indicates that DNS queries should be sent over a TLS connection. If Transport is set to TLS, you MUST also set ServerName.", + "tls": "tls contains the additional configuration options to use when Transport is set to \"TLS\".", +} + +func (DNSTransportConfig) SwaggerDoc() map[string]string { + return map_DNSTransportConfig +} + var map_ForwardPlugin = map[string]string{ - "": "ForwardPlugin defines a schema for configuring the CoreDNS forward plugin.", - "upstreams": "upstreams is a list of resolvers to forward name queries for subdomains of Zones. Each instance of CoreDNS performs health checking of Upstreams. When a healthy upstream returns an error during the exchange, another resolver is tried from Upstreams. The Upstreams are selected in the order specified in Policy. Each upstream is represented by an IP address or IP:port if the upstream listens on a port other than 53.\n\nA maximum of 15 upstreams is allowed per ForwardPlugin.", - "policy": "policy is used to determine the order in which upstream servers are selected for querying. Any one of the following values may be specified:\n\n* \"Random\" picks a random upstream server for each query. * \"RoundRobin\" picks upstream servers in a round-robin order, moving to the next server for each new query. * \"Sequential\" tries querying upstream servers in a sequential order until one responds, starting with the first server for each new query.\n\nThe default value is \"Random\"", + "": "ForwardPlugin defines a schema for configuring the CoreDNS forward plugin.", + "upstreams": "upstreams is a list of resolvers to forward name queries for subdomains of Zones. Each instance of CoreDNS performs health checking of Upstreams. When a healthy upstream returns an error during the exchange, another resolver is tried from Upstreams. The Upstreams are selected in the order specified in Policy. Each upstream is represented by an IP address or IP:port if the upstream listens on a port other than 53.\n\nA maximum of 15 upstreams is allowed per ForwardPlugin.", + "policy": "policy is used to determine the order in which upstream servers are selected for querying. Any one of the following values may be specified:\n\n* \"Random\" picks a random upstream server for each query. * \"RoundRobin\" picks upstream servers in a round-robin order, moving to the next server for each new query. * \"Sequential\" tries querying upstream servers in a sequential order until one responds, starting with the first server for each new query.\n\nThe default value is \"Random\"", + "transportConfig": "transportConfig is used to configure the transport type, server name, and optional custom CA or CA bundle to use when forwarding DNS requests to an upstream resolver.\n\nThe default value is \"\" (empty) which results in a standard cleartext connection being used when forwarding DNS requests to an upstream resolver.", } func (ForwardPlugin) SwaggerDoc() map[string]string { @@ -479,9 +500,10 @@ func (Upstream) SwaggerDoc() map[string]string { } var map_UpstreamResolvers = map[string]string{ - "": "UpstreamResolvers defines a schema for configuring the CoreDNS forward plugin in the specific case of the default (\".\") server. It defers from ForwardPlugin in the default values it accepts: * At least one upstream should be specified. * the default policy is Sequential", - "upstreams": "Upstreams is a list of resolvers to forward name queries for the \".\" domain. Each instance of CoreDNS performs health checking of Upstreams. When a healthy upstream returns an error during the exchange, another resolver is tried from Upstreams. The Upstreams are selected in the order specified in Policy.\n\nA maximum of 15 upstreams is allowed per ForwardPlugin. If no Upstreams are specified, /etc/resolv.conf is used by default", - "policy": "Policy is used to determine the order in which upstream servers are selected for querying. Any one of the following values may be specified:\n\n* \"Random\" picks a random upstream server for each query. * \"RoundRobin\" picks upstream servers in a round-robin order, moving to the next server for each new query. * \"Sequential\" tries querying upstream servers in a sequential order until one responds, starting with the first server for each new query.\n\nThe default value is \"Sequential\"", + "": "UpstreamResolvers defines a schema for configuring the CoreDNS forward plugin in the specific case of the default (\".\") server. It defers from ForwardPlugin in the default values it accepts: * At least one upstream should be specified. * the default policy is Sequential", + "upstreams": "Upstreams is a list of resolvers to forward name queries for the \".\" domain. Each instance of CoreDNS performs health checking of Upstreams. When a healthy upstream returns an error during the exchange, another resolver is tried from Upstreams. The Upstreams are selected in the order specified in Policy.\n\nA maximum of 15 upstreams is allowed per ForwardPlugin. If no Upstreams are specified, /etc/resolv.conf is used by default", + "policy": "Policy is used to determine the order in which upstream servers are selected for querying. Any one of the following values may be specified:\n\n* \"Random\" picks a random upstream server for each query. * \"RoundRobin\" picks upstream servers in a round-robin order, moving to the next server for each new query. * \"Sequential\" tries querying upstream servers in a sequential order until one responds, starting with the first server for each new query.\n\nThe default value is \"Sequential\"", + "transportConfig": "transportConfig is used to configure the transport type, server name, and optional custom CA or CA bundle to use when forwarding DNS requests to an upstream resolver.\n\nThe default value is \"\" (empty) which results in a standard cleartext connection being used when forwarding DNS requests to an upstream resolver.", } func (UpstreamResolvers) SwaggerDoc() map[string]string { @@ -596,8 +618,11 @@ func (HTTPCompressionPolicy) SwaggerDoc() map[string]string { } var map_HostNetworkStrategy = map[string]string{ - "": "HostNetworkStrategy holds parameters for the HostNetwork endpoint publishing strategy.", - "protocol": "protocol specifies whether the IngressController expects incoming connections to use plain TCP or whether the IngressController expects PROXY protocol.\n\nPROXY protocol can be used with load balancers that support it to communicate the source addresses of client connections when forwarding those connections to the IngressController. Using PROXY protocol enables the IngressController to report those source addresses instead of reporting the load balancer's address in HTTP headers and logs. Note that enabling PROXY protocol on the IngressController will cause connections to fail if you are not using a load balancer that uses PROXY protocol to forward connections to the IngressController. See http://www.haproxy.org/download/2.2/doc/proxy-protocol.txt for information about PROXY protocol.\n\nThe following values are valid for this field:\n\n* The empty string. * \"TCP\". * \"PROXY\".\n\nThe empty string specifies the default, which is TCP without PROXY protocol. Note that the default is subject to change.", + "": "HostNetworkStrategy holds parameters for the HostNetwork endpoint publishing strategy.", + "protocol": "protocol specifies whether the IngressController expects incoming connections to use plain TCP or whether the IngressController expects PROXY protocol.\n\nPROXY protocol can be used with load balancers that support it to communicate the source addresses of client connections when forwarding those connections to the IngressController. Using PROXY protocol enables the IngressController to report those source addresses instead of reporting the load balancer's address in HTTP headers and logs. Note that enabling PROXY protocol on the IngressController will cause connections to fail if you are not using a load balancer that uses PROXY protocol to forward connections to the IngressController. See http://www.haproxy.org/download/2.2/doc/proxy-protocol.txt for information about PROXY protocol.\n\nThe following values are valid for this field:\n\n* The empty string. * \"TCP\". * \"PROXY\".\n\nThe empty string specifies the default, which is TCP without PROXY protocol. Note that the default is subject to change.", + "httpPort": "httpPort is the port on the host which should be used to listen for HTTP requests. This field should be set when port 80 is already in use. The value should not coincide with the NodePort range of the cluster. When not specified the value defaults to 80.", + "httpsPort": "httpsPort is the port on the host which should be used to listen for HTTPS requests. This field should be set when port 443 is already in use. The value should not coincide with the NodePort range of the cluster. When not specified the value defaults to 443.", + "statsPort": "statsPort is the port on the host where the stats from the router are published. The value should not coincide with the NodePort range of the cluster. If an external load balancer is configured to forward connections to this IngressController, the load balancer should use this port for health checks. The load balancer can send HTTP probes on this port on a given node, with the path /healthz/ready to determine if the ingress controller is ready to receive traffic on the node. For proper operation the load balancer must not forward traffic to a node until the health check reports ready. The load balancer should also stop forwarding requests within a maximum of 45 seconds after /healthz/ready starts reporting not-ready. Probing every 5 to 10 seconds, with a 5-second timeout and with a threshold of two successful or failed requests to become healthy or unhealthy respectively, are well-tested values. When not specified the value defaults to 1936.", } func (HostNetworkStrategy) SwaggerDoc() map[string]string { @@ -696,7 +721,7 @@ var map_IngressControllerSpec = map[string]string{ "": "IngressControllerSpec is the specification of the desired behavior of the IngressController.", "domain": "domain is a DNS name serviced by the ingress controller and is used to configure multiple features:\n\n* For the LoadBalancerService endpoint publishing strategy, domain is\n used to configure DNS records. See endpointPublishingStrategy.\n\n* When using a generated default certificate, the certificate will be valid\n for domain and its subdomains. See defaultCertificate.\n\n* The value is published to individual Route statuses so that end-users\n know where to target external DNS records.\n\ndomain must be unique among all IngressControllers, and cannot be updated.\n\nIf empty, defaults to ingress.config.openshift.io/cluster .spec.domain.", "httpErrorCodePages": "httpErrorCodePages specifies a configmap with custom error pages. The administrator must create this configmap in the openshift-config namespace. This configmap should have keys in the format \"error-page-.http\", where is an HTTP error code. For example, \"error-page-503.http\" defines an error page for HTTP 503 responses. Currently only error pages for 503 and 404 responses can be customized. Each value in the configmap should be the full response, including HTTP headers. Eg- https://raw.githubusercontent.com/openshift/router/fadab45747a9b30cc3f0a4b41ad2871f95827a93/images/router/haproxy/conf/error-page-503.http If this field is empty, the ingress controller uses the default error pages.", - "replicas": "replicas is the desired number of ingress controller replicas. If unset, defaults to 2.", + "replicas": "replicas is the desired number of ingress controller replicas. If unset, the default depends on the value of the defaultPlacement field in the cluster config.openshift.io/v1/ingresses status.\n\nThe value of replicas is set based on the value of a chosen field in the Infrastructure CR. If defaultPlacement is set to ControlPlane, the chosen field will be controlPlaneTopology. If it is set to Workers the chosen field will be infrastructureTopology. Replicas will then be set to 1 or 2 based whether the chosen field's value is SingleReplica or HighlyAvailable, respectively.\n\nThese defaults are subject to change.", "endpointPublishingStrategy": "endpointPublishingStrategy is used to publish the ingress controller endpoints to other networks, enable load balancer integrations, etc.\n\nIf unset, the default is based on infrastructure.config.openshift.io/cluster .status.platform:\n\n AWS: LoadBalancerService (with External scope)\n Azure: LoadBalancerService (with External scope)\n GCP: LoadBalancerService (with External scope)\n IBMCloud: LoadBalancerService (with External scope)\n AlibabaCloud: LoadBalancerService (with External scope)\n Libvirt: HostNetwork\n\nAny other platform types (including None) default to HostNetwork.\n\nendpointPublishingStrategy cannot be updated.", "defaultCertificate": "defaultCertificate is a reference to a secret containing the default certificate served by the ingress controller. When Routes don't specify their own certificate, defaultCertificate is used.\n\nThe secret must contain the following keys and data:\n\n tls.crt: certificate file contents\n tls.key: key file contents\n\nIf unset, a wildcard certificate is automatically generated and used. The certificate is valid for the ingress controller domain (and subdomains) and the generated certificate's CA will be automatically integrated with the cluster's trust store.\n\nIf a wildcard certificate is used and shared by multiple HTTP/2 enabled routes (which implies ALPN) then clients (i.e., notably browsers) are at liberty to reuse open connections. This means a client can reuse a connection to another route and that is likely to fail. This behaviour is generally known as connection coalescing.\n\nThe in-use certificate (whether generated or user-specified) will be automatically integrated with OpenShift's built-in OAuth server.", "namespaceSelector": "namespaceSelector is used to filter the set of namespaces serviced by the ingress controller. This is useful for implementing shards.\n\nIf unset, the default is no filtering.", @@ -726,6 +751,8 @@ var map_IngressControllerStatus = map[string]string{ "conditions": "conditions is a list of conditions and their status.\n\nAvailable means the ingress controller deployment is available and servicing route and ingress resources (i.e, .status.availableReplicas equals .spec.replicas)\n\nThere are additional conditions which indicate the status of other ingress controller features and capabilities.\n\n * LoadBalancerManaged\n - True if the following conditions are met:\n * The endpoint publishing strategy requires a service load balancer.\n - False if any of those conditions are unsatisfied.\n\n * LoadBalancerReady\n - True if the following conditions are met:\n * A load balancer is managed.\n * The load balancer is ready.\n - False if any of those conditions are unsatisfied.\n\n * DNSManaged\n - True if the following conditions are met:\n * The endpoint publishing strategy and platform support DNS.\n * The ingress controller domain is set.\n * dns.config.openshift.io/cluster configures DNS zones.\n - False if any of those conditions are unsatisfied.\n\n * DNSReady\n - True if the following conditions are met:\n * DNS is managed.\n * DNS records have been successfully created.\n - False if any of those conditions are unsatisfied.", "tlsProfile": "tlsProfile is the TLS connection configuration that is in effect.", "observedGeneration": "observedGeneration is the most recent generation observed.", + "namespaceSelector": "namespaceSelector is the actual namespaceSelector in use.", + "routeSelector": "routeSelector is the actual routeSelector in use.", } func (IngressControllerStatus) SwaggerDoc() map[string]string { @@ -743,6 +770,7 @@ var map_IngressControllerTuningOptions = map[string]string{ "serverFinTimeout": "serverFinTimeout defines how long a connection will be held open while waiting for the server/backend response to the client closing the connection.\n\nIf unset, the default timeout is 1s", "tunnelTimeout": "tunnelTimeout defines how long a tunnel connection (including websockets) will be held open while the tunnel is idle.\n\nIf unset, the default timeout is 1h", "tlsInspectDelay": "tlsInspectDelay defines how long the router can hold data to find a matching route.\n\nSetting this too short can cause the router to fall back to the default certificate for edge-terminated or reencrypt routes even when a better matching certificate could be used.\n\nIf unset, the default inspect delay is 5s", + "healthCheckInterval": "healthCheckInterval defines how long the router waits between two consecutive health checks on its configured backends. This value is applied globally as a default for all routes, but may be overridden per-route by the route annotation \"router.openshift.io/haproxy.health.check.interval\".\n\nSetting this to less than 5s can cause excess traffic due to too frequent TCP health checks and accompanying SYN packet storms. Alternatively, setting this too high can result in increased latency, due to backend servers that are no longer available, but haven't yet been detected as such.\n\nAn empty or zero healthCheckInterval means no opinion and IngressController chooses a default, which is subject to change over time. Currently the default healthCheckInterval value is 5s.\n\nCurrently the minimum allowed value is 1s and the maximum allowed value is 2147483647ms (24.85 days). Both are subject to change over time.", } func (IngressControllerTuningOptions) SwaggerDoc() map[string]string { @@ -772,7 +800,7 @@ func (LoggingDestination) SwaggerDoc() map[string]string { var map_NodePlacement = map[string]string{ "": "NodePlacement describes node scheduling configuration for an ingress controller.", - "nodeSelector": "nodeSelector is the node selector applied to ingress controller deployments.\n\nIf unset, the default is:\n\n kubernetes.io/os: linux\n node-role.kubernetes.io/worker: ''\n\nIf set, the specified selector is used and replaces the default.", + "nodeSelector": "nodeSelector is the node selector applied to ingress controller deployments.\n\nIf set, the specified selector is used and replaces the default.\n\nIf unset, the default depends on the value of the defaultPlacement field in the cluster config.openshift.io/v1/ingresses status.\n\nWhen defaultPlacement is Workers, the default is:\n\n kubernetes.io/os: linux\n node-role.kubernetes.io/worker: ''\n\nWhen defaultPlacement is ControlPlane, the default is:\n\n kubernetes.io/os: linux\n node-role.kubernetes.io/master: ''\n\nThese defaults are subject to change.", "tolerations": "tolerations is a list of tolerations applied to ingress controller deployments.\n\nThe default is an empty list.\n\nSee https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/", } @@ -799,7 +827,7 @@ func (PrivateStrategy) SwaggerDoc() map[string]string { var map_ProviderLoadBalancerParameters = map[string]string{ "": "ProviderLoadBalancerParameters holds desired load balancer information specific to the underlying infrastructure provider.", - "type": "type is the underlying infrastructure provider for the load balancer. Allowed values are \"AWS\", \"Azure\", \"BareMetal\", \"GCP\", \"OpenStack\", and \"VSphere\".", + "type": "type is the underlying infrastructure provider for the load balancer. Allowed values are \"AWS\", \"Azure\", \"BareMetal\", \"GCP\", \"Nutanix\", \"OpenStack\", and \"VSphere\".", "aws": "aws provides configuration settings that are specific to AWS load balancers.\n\nIf empty, defaults will be applied. See specific aws fields for details about their defaults.", "gcp": "gcp provides configuration settings that are specific to GCP load balancers.\n\nIf empty, defaults will be applied. See specific gcp fields for details about their defaults.", } @@ -977,7 +1005,7 @@ var map_KuryrConfig = map[string]string{ "daemonProbesPort": "The port kuryr-daemon will listen for readiness and liveness requests.", "controllerProbesPort": "The port kuryr-controller will listen for readiness and liveness requests.", "openStackServiceNetwork": "openStackServiceNetwork contains the CIDR of network from which to allocate IPs for OpenStack Octavia's Amphora VMs. Please note that with Amphora driver Octavia uses two IPs from that network for each loadbalancer - one given by OpenShift and second for VRRP connections. As the first one is managed by OpenShift's and second by Neutron's IPAMs, those need to come from different pools. Therefore `openStackServiceNetwork` needs to be at least twice the size of `serviceNetwork`, and whole `serviceNetwork` must be overlapping with `openStackServiceNetwork`. cluster-network-operator will then make sure VRRP IPs are taken from the ranges inside `openStackServiceNetwork` that are not overlapping with `serviceNetwork`, effectivly preventing conflicts. If not set cluster-network-operator will use `serviceNetwork` expanded by decrementing the prefix size by 1.", - "enablePortPoolsPrepopulation": "enablePortPoolsPrepopulation when true will make Kuryr prepopulate each newly created port pool with a minimum number of ports. Kuryr uses Neutron port pooling to fight the fact that it takes a significant amount of time to create one. Instead of creating it when pod is being deployed, Kuryr keeps a number of ports ready to be attached to pods. By default port prepopulation is disabled.", + "enablePortPoolsPrepopulation": "enablePortPoolsPrepopulation when true will make Kuryr prepopulate each newly created port pool with a minimum number of ports. Kuryr uses Neutron port pooling to fight the fact that it takes a significant amount of time to create one. It creates a number of ports when the first pod that is configured to use the dedicated network for pods is created in a namespace, and keeps them ready to be attached to pods. Port prepopulation is disabled by default.", "poolMaxPorts": "poolMaxPorts sets a maximum number of free ports that are being kept in a port pool. If the number of ports exceeds this setting, free ports will get deleted. Setting 0 will disable this upper bound, effectively preventing pools from shrinking and this is the default value. For more information about port pools see enablePortPoolsPrepopulation setting.", "poolMinPorts": "poolMinPorts sets a minimum number of free ports that should be kept in a port pool. If the number of ports is lower than this setting, new ports will get created and added to pool. The default is 1. For more information about port pools see enablePortPoolsPrepopulation setting.", "poolBatchPorts": "poolBatchPorts sets a number of ports that should be created in a single batch request to extend the port pool. The default is 3. For more information about port pools see enablePortPoolsPrepopulation setting.", diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/config_client.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/config_client.go index 5792b9aa74..de4f2fa32a 100644 --- a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/config_client.go +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/config_client.go @@ -22,9 +22,12 @@ type ConfigV1Interface interface { FeatureGatesGetter ImagesGetter ImageContentPoliciesGetter + ImageDigestMirrorSetsGetter + ImageTagMirrorSetsGetter InfrastructuresGetter IngressesGetter NetworksGetter + NodesGetter OAuthsGetter OperatorHubsGetter ProjectsGetter @@ -77,6 +80,14 @@ func (c *ConfigV1Client) ImageContentPolicies() ImageContentPolicyInterface { return newImageContentPolicies(c) } +func (c *ConfigV1Client) ImageDigestMirrorSets() ImageDigestMirrorSetInterface { + return newImageDigestMirrorSets(c) +} + +func (c *ConfigV1Client) ImageTagMirrorSets() ImageTagMirrorSetInterface { + return newImageTagMirrorSets(c) +} + func (c *ConfigV1Client) Infrastructures() InfrastructureInterface { return newInfrastructures(c) } @@ -89,6 +100,10 @@ func (c *ConfigV1Client) Networks() NetworkInterface { return newNetworks(c) } +func (c *ConfigV1Client) Nodes() NodeInterface { + return newNodes(c) +} + func (c *ConfigV1Client) OAuths() OAuthInterface { return newOAuths(c) } diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_config_client.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_config_client.go index 40d153d7c0..b105e491cf 100644 --- a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_config_client.go +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_config_client.go @@ -52,6 +52,14 @@ func (c *FakeConfigV1) ImageContentPolicies() v1.ImageContentPolicyInterface { return &FakeImageContentPolicies{c} } +func (c *FakeConfigV1) ImageDigestMirrorSets() v1.ImageDigestMirrorSetInterface { + return &FakeImageDigestMirrorSets{c} +} + +func (c *FakeConfigV1) ImageTagMirrorSets() v1.ImageTagMirrorSetInterface { + return &FakeImageTagMirrorSets{c} +} + func (c *FakeConfigV1) Infrastructures() v1.InfrastructureInterface { return &FakeInfrastructures{c} } @@ -64,6 +72,10 @@ func (c *FakeConfigV1) Networks() v1.NetworkInterface { return &FakeNetworks{c} } +func (c *FakeConfigV1) Nodes() v1.NodeInterface { + return &FakeNodes{c} +} + func (c *FakeConfigV1) OAuths() v1.OAuthInterface { return &FakeOAuths{c} } diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_imagedigestmirrorset.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_imagedigestmirrorset.go new file mode 100644 index 0000000000..f99b68d103 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_imagedigestmirrorset.go @@ -0,0 +1,106 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + configv1 "github.com/openshift/api/config/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeImageDigestMirrorSets implements ImageDigestMirrorSetInterface +type FakeImageDigestMirrorSets struct { + Fake *FakeConfigV1 +} + +var imagedigestmirrorsetsResource = schema.GroupVersionResource{Group: "config.openshift.io", Version: "v1", Resource: "imagedigestmirrorsets"} + +var imagedigestmirrorsetsKind = schema.GroupVersionKind{Group: "config.openshift.io", Version: "v1", Kind: "ImageDigestMirrorSet"} + +// Get takes name of the imageDigestMirrorSet, and returns the corresponding imageDigestMirrorSet object, and an error if there is any. +func (c *FakeImageDigestMirrorSets) Get(ctx context.Context, name string, options v1.GetOptions) (result *configv1.ImageDigestMirrorSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(imagedigestmirrorsetsResource, name), &configv1.ImageDigestMirrorSet{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.ImageDigestMirrorSet), err +} + +// List takes label and field selectors, and returns the list of ImageDigestMirrorSets that match those selectors. +func (c *FakeImageDigestMirrorSets) List(ctx context.Context, opts v1.ListOptions) (result *configv1.ImageDigestMirrorSetList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(imagedigestmirrorsetsResource, imagedigestmirrorsetsKind, opts), &configv1.ImageDigestMirrorSetList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &configv1.ImageDigestMirrorSetList{ListMeta: obj.(*configv1.ImageDigestMirrorSetList).ListMeta} + for _, item := range obj.(*configv1.ImageDigestMirrorSetList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested imageDigestMirrorSets. +func (c *FakeImageDigestMirrorSets) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(imagedigestmirrorsetsResource, opts)) +} + +// Create takes the representation of a imageDigestMirrorSet and creates it. Returns the server's representation of the imageDigestMirrorSet, and an error, if there is any. +func (c *FakeImageDigestMirrorSets) Create(ctx context.Context, imageDigestMirrorSet *configv1.ImageDigestMirrorSet, opts v1.CreateOptions) (result *configv1.ImageDigestMirrorSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(imagedigestmirrorsetsResource, imageDigestMirrorSet), &configv1.ImageDigestMirrorSet{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.ImageDigestMirrorSet), err +} + +// Update takes the representation of a imageDigestMirrorSet and updates it. Returns the server's representation of the imageDigestMirrorSet, and an error, if there is any. +func (c *FakeImageDigestMirrorSets) Update(ctx context.Context, imageDigestMirrorSet *configv1.ImageDigestMirrorSet, opts v1.UpdateOptions) (result *configv1.ImageDigestMirrorSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(imagedigestmirrorsetsResource, imageDigestMirrorSet), &configv1.ImageDigestMirrorSet{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.ImageDigestMirrorSet), err +} + +// Delete takes name of the imageDigestMirrorSet and deletes it. Returns an error if one occurs. +func (c *FakeImageDigestMirrorSets) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteActionWithOptions(imagedigestmirrorsetsResource, name, opts), &configv1.ImageDigestMirrorSet{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeImageDigestMirrorSets) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(imagedigestmirrorsetsResource, listOpts) + + _, err := c.Fake.Invokes(action, &configv1.ImageDigestMirrorSetList{}) + return err +} + +// Patch applies the patch and returns the patched imageDigestMirrorSet. +func (c *FakeImageDigestMirrorSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *configv1.ImageDigestMirrorSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(imagedigestmirrorsetsResource, name, pt, data, subresources...), &configv1.ImageDigestMirrorSet{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.ImageDigestMirrorSet), err +} diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_imagetagmirrorset.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_imagetagmirrorset.go new file mode 100644 index 0000000000..1832a5db72 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_imagetagmirrorset.go @@ -0,0 +1,106 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + configv1 "github.com/openshift/api/config/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeImageTagMirrorSets implements ImageTagMirrorSetInterface +type FakeImageTagMirrorSets struct { + Fake *FakeConfigV1 +} + +var imagetagmirrorsetsResource = schema.GroupVersionResource{Group: "config.openshift.io", Version: "v1", Resource: "imagetagmirrorsets"} + +var imagetagmirrorsetsKind = schema.GroupVersionKind{Group: "config.openshift.io", Version: "v1", Kind: "ImageTagMirrorSet"} + +// Get takes name of the imageTagMirrorSet, and returns the corresponding imageTagMirrorSet object, and an error if there is any. +func (c *FakeImageTagMirrorSets) Get(ctx context.Context, name string, options v1.GetOptions) (result *configv1.ImageTagMirrorSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(imagetagmirrorsetsResource, name), &configv1.ImageTagMirrorSet{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.ImageTagMirrorSet), err +} + +// List takes label and field selectors, and returns the list of ImageTagMirrorSets that match those selectors. +func (c *FakeImageTagMirrorSets) List(ctx context.Context, opts v1.ListOptions) (result *configv1.ImageTagMirrorSetList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(imagetagmirrorsetsResource, imagetagmirrorsetsKind, opts), &configv1.ImageTagMirrorSetList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &configv1.ImageTagMirrorSetList{ListMeta: obj.(*configv1.ImageTagMirrorSetList).ListMeta} + for _, item := range obj.(*configv1.ImageTagMirrorSetList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested imageTagMirrorSets. +func (c *FakeImageTagMirrorSets) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(imagetagmirrorsetsResource, opts)) +} + +// Create takes the representation of a imageTagMirrorSet and creates it. Returns the server's representation of the imageTagMirrorSet, and an error, if there is any. +func (c *FakeImageTagMirrorSets) Create(ctx context.Context, imageTagMirrorSet *configv1.ImageTagMirrorSet, opts v1.CreateOptions) (result *configv1.ImageTagMirrorSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(imagetagmirrorsetsResource, imageTagMirrorSet), &configv1.ImageTagMirrorSet{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.ImageTagMirrorSet), err +} + +// Update takes the representation of a imageTagMirrorSet and updates it. Returns the server's representation of the imageTagMirrorSet, and an error, if there is any. +func (c *FakeImageTagMirrorSets) Update(ctx context.Context, imageTagMirrorSet *configv1.ImageTagMirrorSet, opts v1.UpdateOptions) (result *configv1.ImageTagMirrorSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(imagetagmirrorsetsResource, imageTagMirrorSet), &configv1.ImageTagMirrorSet{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.ImageTagMirrorSet), err +} + +// Delete takes name of the imageTagMirrorSet and deletes it. Returns an error if one occurs. +func (c *FakeImageTagMirrorSets) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteActionWithOptions(imagetagmirrorsetsResource, name, opts), &configv1.ImageTagMirrorSet{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeImageTagMirrorSets) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(imagetagmirrorsetsResource, listOpts) + + _, err := c.Fake.Invokes(action, &configv1.ImageTagMirrorSetList{}) + return err +} + +// Patch applies the patch and returns the patched imageTagMirrorSet. +func (c *FakeImageTagMirrorSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *configv1.ImageTagMirrorSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(imagetagmirrorsetsResource, name, pt, data, subresources...), &configv1.ImageTagMirrorSet{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.ImageTagMirrorSet), err +} diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_node.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_node.go new file mode 100644 index 0000000000..5c48bd6a97 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/fake/fake_node.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + configv1 "github.com/openshift/api/config/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeNodes implements NodeInterface +type FakeNodes struct { + Fake *FakeConfigV1 +} + +var nodesResource = schema.GroupVersionResource{Group: "config.openshift.io", Version: "v1", Resource: "nodes"} + +var nodesKind = schema.GroupVersionKind{Group: "config.openshift.io", Version: "v1", Kind: "Node"} + +// Get takes name of the node, and returns the corresponding node object, and an error if there is any. +func (c *FakeNodes) Get(ctx context.Context, name string, options v1.GetOptions) (result *configv1.Node, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(nodesResource, name), &configv1.Node{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.Node), err +} + +// List takes label and field selectors, and returns the list of Nodes that match those selectors. +func (c *FakeNodes) List(ctx context.Context, opts v1.ListOptions) (result *configv1.NodeList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(nodesResource, nodesKind, opts), &configv1.NodeList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &configv1.NodeList{ListMeta: obj.(*configv1.NodeList).ListMeta} + for _, item := range obj.(*configv1.NodeList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested nodes. +func (c *FakeNodes) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(nodesResource, opts)) +} + +// Create takes the representation of a node and creates it. Returns the server's representation of the node, and an error, if there is any. +func (c *FakeNodes) Create(ctx context.Context, node *configv1.Node, opts v1.CreateOptions) (result *configv1.Node, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(nodesResource, node), &configv1.Node{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.Node), err +} + +// Update takes the representation of a node and updates it. Returns the server's representation of the node, and an error, if there is any. +func (c *FakeNodes) Update(ctx context.Context, node *configv1.Node, opts v1.UpdateOptions) (result *configv1.Node, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(nodesResource, node), &configv1.Node{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.Node), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeNodes) UpdateStatus(ctx context.Context, node *configv1.Node, opts v1.UpdateOptions) (*configv1.Node, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(nodesResource, "status", node), &configv1.Node{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.Node), err +} + +// Delete takes name of the node and deletes it. Returns an error if one occurs. +func (c *FakeNodes) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteActionWithOptions(nodesResource, name, opts), &configv1.Node{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeNodes) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(nodesResource, listOpts) + + _, err := c.Fake.Invokes(action, &configv1.NodeList{}) + return err +} + +// Patch applies the patch and returns the patched node. +func (c *FakeNodes) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *configv1.Node, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(nodesResource, name, pt, data, subresources...), &configv1.Node{}) + if obj == nil { + return nil, err + } + return obj.(*configv1.Node), err +} diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/generated_expansion.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/generated_expansion.go index 646801584a..a56721ba9d 100644 --- a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/generated_expansion.go +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/generated_expansion.go @@ -22,12 +22,18 @@ type ImageExpansion interface{} type ImageContentPolicyExpansion interface{} +type ImageDigestMirrorSetExpansion interface{} + +type ImageTagMirrorSetExpansion interface{} + type InfrastructureExpansion interface{} type IngressExpansion interface{} type NetworkExpansion interface{} +type NodeExpansion interface{} + type OAuthExpansion interface{} type OperatorHubExpansion interface{} diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/imagedigestmirrorset.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/imagedigestmirrorset.go new file mode 100644 index 0000000000..d13aa8f3cc --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/imagedigestmirrorset.go @@ -0,0 +1,152 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + v1 "github.com/openshift/api/config/v1" + scheme "github.com/openshift/client-go/config/clientset/versioned/scheme" + metav1 "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" +) + +// ImageDigestMirrorSetsGetter has a method to return a ImageDigestMirrorSetInterface. +// A group's client should implement this interface. +type ImageDigestMirrorSetsGetter interface { + ImageDigestMirrorSets() ImageDigestMirrorSetInterface +} + +// ImageDigestMirrorSetInterface has methods to work with ImageDigestMirrorSet resources. +type ImageDigestMirrorSetInterface interface { + Create(ctx context.Context, imageDigestMirrorSet *v1.ImageDigestMirrorSet, opts metav1.CreateOptions) (*v1.ImageDigestMirrorSet, error) + Update(ctx context.Context, imageDigestMirrorSet *v1.ImageDigestMirrorSet, opts metav1.UpdateOptions) (*v1.ImageDigestMirrorSet, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ImageDigestMirrorSet, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.ImageDigestMirrorSetList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.ImageDigestMirrorSet, err error) + ImageDigestMirrorSetExpansion +} + +// imageDigestMirrorSets implements ImageDigestMirrorSetInterface +type imageDigestMirrorSets struct { + client rest.Interface +} + +// newImageDigestMirrorSets returns a ImageDigestMirrorSets +func newImageDigestMirrorSets(c *ConfigV1Client) *imageDigestMirrorSets { + return &imageDigestMirrorSets{ + client: c.RESTClient(), + } +} + +// Get takes name of the imageDigestMirrorSet, and returns the corresponding imageDigestMirrorSet object, and an error if there is any. +func (c *imageDigestMirrorSets) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.ImageDigestMirrorSet, err error) { + result = &v1.ImageDigestMirrorSet{} + err = c.client.Get(). + Resource("imagedigestmirrorsets"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of ImageDigestMirrorSets that match those selectors. +func (c *imageDigestMirrorSets) List(ctx context.Context, opts metav1.ListOptions) (result *v1.ImageDigestMirrorSetList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.ImageDigestMirrorSetList{} + err = c.client.Get(). + Resource("imagedigestmirrorsets"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested imageDigestMirrorSets. +func (c *imageDigestMirrorSets) Watch(ctx context.Context, opts metav1.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("imagedigestmirrorsets"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a imageDigestMirrorSet and creates it. Returns the server's representation of the imageDigestMirrorSet, and an error, if there is any. +func (c *imageDigestMirrorSets) Create(ctx context.Context, imageDigestMirrorSet *v1.ImageDigestMirrorSet, opts metav1.CreateOptions) (result *v1.ImageDigestMirrorSet, err error) { + result = &v1.ImageDigestMirrorSet{} + err = c.client.Post(). + Resource("imagedigestmirrorsets"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(imageDigestMirrorSet). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a imageDigestMirrorSet and updates it. Returns the server's representation of the imageDigestMirrorSet, and an error, if there is any. +func (c *imageDigestMirrorSets) Update(ctx context.Context, imageDigestMirrorSet *v1.ImageDigestMirrorSet, opts metav1.UpdateOptions) (result *v1.ImageDigestMirrorSet, err error) { + result = &v1.ImageDigestMirrorSet{} + err = c.client.Put(). + Resource("imagedigestmirrorsets"). + Name(imageDigestMirrorSet.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(imageDigestMirrorSet). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the imageDigestMirrorSet and deletes it. Returns an error if one occurs. +func (c *imageDigestMirrorSets) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Resource("imagedigestmirrorsets"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *imageDigestMirrorSets) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("imagedigestmirrorsets"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched imageDigestMirrorSet. +func (c *imageDigestMirrorSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.ImageDigestMirrorSet, err error) { + result = &v1.ImageDigestMirrorSet{} + err = c.client.Patch(pt). + Resource("imagedigestmirrorsets"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/imagetagmirrorset.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/imagetagmirrorset.go new file mode 100644 index 0000000000..bf2958d805 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/imagetagmirrorset.go @@ -0,0 +1,152 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + v1 "github.com/openshift/api/config/v1" + scheme "github.com/openshift/client-go/config/clientset/versioned/scheme" + metav1 "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" +) + +// ImageTagMirrorSetsGetter has a method to return a ImageTagMirrorSetInterface. +// A group's client should implement this interface. +type ImageTagMirrorSetsGetter interface { + ImageTagMirrorSets() ImageTagMirrorSetInterface +} + +// ImageTagMirrorSetInterface has methods to work with ImageTagMirrorSet resources. +type ImageTagMirrorSetInterface interface { + Create(ctx context.Context, imageTagMirrorSet *v1.ImageTagMirrorSet, opts metav1.CreateOptions) (*v1.ImageTagMirrorSet, error) + Update(ctx context.Context, imageTagMirrorSet *v1.ImageTagMirrorSet, opts metav1.UpdateOptions) (*v1.ImageTagMirrorSet, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ImageTagMirrorSet, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.ImageTagMirrorSetList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.ImageTagMirrorSet, err error) + ImageTagMirrorSetExpansion +} + +// imageTagMirrorSets implements ImageTagMirrorSetInterface +type imageTagMirrorSets struct { + client rest.Interface +} + +// newImageTagMirrorSets returns a ImageTagMirrorSets +func newImageTagMirrorSets(c *ConfigV1Client) *imageTagMirrorSets { + return &imageTagMirrorSets{ + client: c.RESTClient(), + } +} + +// Get takes name of the imageTagMirrorSet, and returns the corresponding imageTagMirrorSet object, and an error if there is any. +func (c *imageTagMirrorSets) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.ImageTagMirrorSet, err error) { + result = &v1.ImageTagMirrorSet{} + err = c.client.Get(). + Resource("imagetagmirrorsets"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of ImageTagMirrorSets that match those selectors. +func (c *imageTagMirrorSets) List(ctx context.Context, opts metav1.ListOptions) (result *v1.ImageTagMirrorSetList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.ImageTagMirrorSetList{} + err = c.client.Get(). + Resource("imagetagmirrorsets"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested imageTagMirrorSets. +func (c *imageTagMirrorSets) Watch(ctx context.Context, opts metav1.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("imagetagmirrorsets"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a imageTagMirrorSet and creates it. Returns the server's representation of the imageTagMirrorSet, and an error, if there is any. +func (c *imageTagMirrorSets) Create(ctx context.Context, imageTagMirrorSet *v1.ImageTagMirrorSet, opts metav1.CreateOptions) (result *v1.ImageTagMirrorSet, err error) { + result = &v1.ImageTagMirrorSet{} + err = c.client.Post(). + Resource("imagetagmirrorsets"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(imageTagMirrorSet). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a imageTagMirrorSet and updates it. Returns the server's representation of the imageTagMirrorSet, and an error, if there is any. +func (c *imageTagMirrorSets) Update(ctx context.Context, imageTagMirrorSet *v1.ImageTagMirrorSet, opts metav1.UpdateOptions) (result *v1.ImageTagMirrorSet, err error) { + result = &v1.ImageTagMirrorSet{} + err = c.client.Put(). + Resource("imagetagmirrorsets"). + Name(imageTagMirrorSet.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(imageTagMirrorSet). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the imageTagMirrorSet and deletes it. Returns an error if one occurs. +func (c *imageTagMirrorSets) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Resource("imagetagmirrorsets"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *imageTagMirrorSets) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("imagetagmirrorsets"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched imageTagMirrorSet. +func (c *imageTagMirrorSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.ImageTagMirrorSet, err error) { + result = &v1.ImageTagMirrorSet{} + err = c.client.Patch(pt). + Resource("imagetagmirrorsets"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/node.go b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/node.go new file mode 100644 index 0000000000..b277992378 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/clientset/versioned/typed/config/v1/node.go @@ -0,0 +1,168 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + v1 "github.com/openshift/api/config/v1" + scheme "github.com/openshift/client-go/config/clientset/versioned/scheme" + metav1 "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" +) + +// NodesGetter has a method to return a NodeInterface. +// A group's client should implement this interface. +type NodesGetter interface { + Nodes() NodeInterface +} + +// NodeInterface has methods to work with Node resources. +type NodeInterface interface { + Create(ctx context.Context, node *v1.Node, opts metav1.CreateOptions) (*v1.Node, error) + Update(ctx context.Context, node *v1.Node, opts metav1.UpdateOptions) (*v1.Node, error) + UpdateStatus(ctx context.Context, node *v1.Node, opts metav1.UpdateOptions) (*v1.Node, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Node, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.NodeList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Node, err error) + NodeExpansion +} + +// nodes implements NodeInterface +type nodes struct { + client rest.Interface +} + +// newNodes returns a Nodes +func newNodes(c *ConfigV1Client) *nodes { + return &nodes{ + client: c.RESTClient(), + } +} + +// Get takes name of the node, and returns the corresponding node object, and an error if there is any. +func (c *nodes) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.Node, err error) { + result = &v1.Node{} + err = c.client.Get(). + Resource("nodes"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of Nodes that match those selectors. +func (c *nodes) List(ctx context.Context, opts metav1.ListOptions) (result *v1.NodeList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.NodeList{} + err = c.client.Get(). + Resource("nodes"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested nodes. +func (c *nodes) Watch(ctx context.Context, opts metav1.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("nodes"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a node and creates it. Returns the server's representation of the node, and an error, if there is any. +func (c *nodes) Create(ctx context.Context, node *v1.Node, opts metav1.CreateOptions) (result *v1.Node, err error) { + result = &v1.Node{} + err = c.client.Post(). + Resource("nodes"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(node). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a node and updates it. Returns the server's representation of the node, and an error, if there is any. +func (c *nodes) Update(ctx context.Context, node *v1.Node, opts metav1.UpdateOptions) (result *v1.Node, err error) { + result = &v1.Node{} + err = c.client.Put(). + Resource("nodes"). + Name(node.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(node). + 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 *nodes) UpdateStatus(ctx context.Context, node *v1.Node, opts metav1.UpdateOptions) (result *v1.Node, err error) { + result = &v1.Node{} + err = c.client.Put(). + Resource("nodes"). + Name(node.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(node). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the node and deletes it. Returns an error if one occurs. +func (c *nodes) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Resource("nodes"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *nodes) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("nodes"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched node. +func (c *nodes) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Node, err error) { + result = &v1.Node{} + err = c.client.Patch(pt). + Resource("nodes"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/imagedigestmirrorset.go b/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/imagedigestmirrorset.go new file mode 100644 index 0000000000..8953cfd890 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/imagedigestmirrorset.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + configv1 "github.com/openshift/api/config/v1" + versioned "github.com/openshift/client-go/config/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/config/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/config/listers/config/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// ImageDigestMirrorSetInformer provides access to a shared informer and lister for +// ImageDigestMirrorSets. +type ImageDigestMirrorSetInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.ImageDigestMirrorSetLister +} + +type imageDigestMirrorSetInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewImageDigestMirrorSetInformer constructs a new informer for ImageDigestMirrorSet type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewImageDigestMirrorSetInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredImageDigestMirrorSetInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredImageDigestMirrorSetInformer constructs a new informer for ImageDigestMirrorSet type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredImageDigestMirrorSetInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ConfigV1().ImageDigestMirrorSets().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ConfigV1().ImageDigestMirrorSets().Watch(context.TODO(), options) + }, + }, + &configv1.ImageDigestMirrorSet{}, + resyncPeriod, + indexers, + ) +} + +func (f *imageDigestMirrorSetInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredImageDigestMirrorSetInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *imageDigestMirrorSetInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&configv1.ImageDigestMirrorSet{}, f.defaultInformer) +} + +func (f *imageDigestMirrorSetInformer) Lister() v1.ImageDigestMirrorSetLister { + return v1.NewImageDigestMirrorSetLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/imagetagmirrorset.go b/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/imagetagmirrorset.go new file mode 100644 index 0000000000..a0951a190f --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/imagetagmirrorset.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + configv1 "github.com/openshift/api/config/v1" + versioned "github.com/openshift/client-go/config/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/config/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/config/listers/config/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// ImageTagMirrorSetInformer provides access to a shared informer and lister for +// ImageTagMirrorSets. +type ImageTagMirrorSetInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.ImageTagMirrorSetLister +} + +type imageTagMirrorSetInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewImageTagMirrorSetInformer constructs a new informer for ImageTagMirrorSet type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewImageTagMirrorSetInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredImageTagMirrorSetInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredImageTagMirrorSetInformer constructs a new informer for ImageTagMirrorSet type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredImageTagMirrorSetInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ConfigV1().ImageTagMirrorSets().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ConfigV1().ImageTagMirrorSets().Watch(context.TODO(), options) + }, + }, + &configv1.ImageTagMirrorSet{}, + resyncPeriod, + indexers, + ) +} + +func (f *imageTagMirrorSetInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredImageTagMirrorSetInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *imageTagMirrorSetInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&configv1.ImageTagMirrorSet{}, f.defaultInformer) +} + +func (f *imageTagMirrorSetInformer) Lister() v1.ImageTagMirrorSetLister { + return v1.NewImageTagMirrorSetLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/interface.go b/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/interface.go index 6ee69a4811..f49b1d2287 100644 --- a/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/interface.go +++ b/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/interface.go @@ -28,12 +28,18 @@ type Interface interface { Images() ImageInformer // ImageContentPolicies returns a ImageContentPolicyInformer. ImageContentPolicies() ImageContentPolicyInformer + // ImageDigestMirrorSets returns a ImageDigestMirrorSetInformer. + ImageDigestMirrorSets() ImageDigestMirrorSetInformer + // ImageTagMirrorSets returns a ImageTagMirrorSetInformer. + ImageTagMirrorSets() ImageTagMirrorSetInformer // Infrastructures returns a InfrastructureInformer. Infrastructures() InfrastructureInformer // Ingresses returns a IngressInformer. Ingresses() IngressInformer // Networks returns a NetworkInformer. Networks() NetworkInformer + // Nodes returns a NodeInformer. + Nodes() NodeInformer // OAuths returns a OAuthInformer. OAuths() OAuthInformer // OperatorHubs returns a OperatorHubInformer. @@ -107,6 +113,16 @@ func (v *version) ImageContentPolicies() ImageContentPolicyInformer { return &imageContentPolicyInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} } +// ImageDigestMirrorSets returns a ImageDigestMirrorSetInformer. +func (v *version) ImageDigestMirrorSets() ImageDigestMirrorSetInformer { + return &imageDigestMirrorSetInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// ImageTagMirrorSets returns a ImageTagMirrorSetInformer. +func (v *version) ImageTagMirrorSets() ImageTagMirrorSetInformer { + return &imageTagMirrorSetInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + // Infrastructures returns a InfrastructureInformer. func (v *version) Infrastructures() InfrastructureInformer { return &infrastructureInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} @@ -122,6 +138,11 @@ func (v *version) Networks() NetworkInformer { return &networkInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} } +// Nodes returns a NodeInformer. +func (v *version) Nodes() NodeInformer { + return &nodeInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + // OAuths returns a OAuthInformer. func (v *version) OAuths() OAuthInformer { return &oAuthInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} diff --git a/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/node.go b/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/node.go new file mode 100644 index 0000000000..6a9f806dff --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/informers/externalversions/config/v1/node.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + configv1 "github.com/openshift/api/config/v1" + versioned "github.com/openshift/client-go/config/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/config/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/config/listers/config/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// NodeInformer provides access to a shared informer and lister for +// Nodes. +type NodeInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.NodeLister +} + +type nodeInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewNodeInformer constructs a new informer for Node type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewNodeInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredNodeInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredNodeInformer constructs a new informer for Node type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredNodeInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ConfigV1().Nodes().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ConfigV1().Nodes().Watch(context.TODO(), options) + }, + }, + &configv1.Node{}, + resyncPeriod, + indexers, + ) +} + +func (f *nodeInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredNodeInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *nodeInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&configv1.Node{}, f.defaultInformer) +} + +func (f *nodeInformer) Lister() v1.NodeLister { + return v1.NewNodeLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/config/informers/externalversions/generic.go b/vendor/github.com/openshift/client-go/config/informers/externalversions/generic.go index e804d1cde5..a9250c4084 100644 --- a/vendor/github.com/openshift/client-go/config/informers/externalversions/generic.go +++ b/vendor/github.com/openshift/client-go/config/informers/externalversions/generic.go @@ -57,12 +57,18 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().Images().Informer()}, nil case v1.SchemeGroupVersion.WithResource("imagecontentpolicies"): return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().ImageContentPolicies().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("imagedigestmirrorsets"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().ImageDigestMirrorSets().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("imagetagmirrorsets"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().ImageTagMirrorSets().Informer()}, nil case v1.SchemeGroupVersion.WithResource("infrastructures"): return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().Infrastructures().Informer()}, nil case v1.SchemeGroupVersion.WithResource("ingresses"): return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().Ingresses().Informer()}, nil case v1.SchemeGroupVersion.WithResource("networks"): return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().Networks().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("nodes"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().Nodes().Informer()}, nil case v1.SchemeGroupVersion.WithResource("oauths"): return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1().OAuths().Informer()}, nil case v1.SchemeGroupVersion.WithResource("operatorhubs"): diff --git a/vendor/github.com/openshift/client-go/config/listers/config/v1/expansion_generated.go b/vendor/github.com/openshift/client-go/config/listers/config/v1/expansion_generated.go index 1fbedb4dbb..b5d6fc088b 100644 --- a/vendor/github.com/openshift/client-go/config/listers/config/v1/expansion_generated.go +++ b/vendor/github.com/openshift/client-go/config/listers/config/v1/expansion_generated.go @@ -42,6 +42,14 @@ type ImageListerExpansion interface{} // ImageContentPolicyLister. type ImageContentPolicyListerExpansion interface{} +// ImageDigestMirrorSetListerExpansion allows custom methods to be added to +// ImageDigestMirrorSetLister. +type ImageDigestMirrorSetListerExpansion interface{} + +// ImageTagMirrorSetListerExpansion allows custom methods to be added to +// ImageTagMirrorSetLister. +type ImageTagMirrorSetListerExpansion interface{} + // InfrastructureListerExpansion allows custom methods to be added to // InfrastructureLister. type InfrastructureListerExpansion interface{} @@ -54,6 +62,10 @@ type IngressListerExpansion interface{} // NetworkLister. type NetworkListerExpansion interface{} +// NodeListerExpansion allows custom methods to be added to +// NodeLister. +type NodeListerExpansion interface{} + // OAuthListerExpansion allows custom methods to be added to // OAuthLister. type OAuthListerExpansion interface{} diff --git a/vendor/github.com/openshift/client-go/config/listers/config/v1/imagedigestmirrorset.go b/vendor/github.com/openshift/client-go/config/listers/config/v1/imagedigestmirrorset.go new file mode 100644 index 0000000000..03c0e72d2d --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/listers/config/v1/imagedigestmirrorset.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/config/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ImageDigestMirrorSetLister helps list ImageDigestMirrorSets. +// All objects returned here must be treated as read-only. +type ImageDigestMirrorSetLister interface { + // List lists all ImageDigestMirrorSets in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.ImageDigestMirrorSet, err error) + // Get retrieves the ImageDigestMirrorSet from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.ImageDigestMirrorSet, error) + ImageDigestMirrorSetListerExpansion +} + +// imageDigestMirrorSetLister implements the ImageDigestMirrorSetLister interface. +type imageDigestMirrorSetLister struct { + indexer cache.Indexer +} + +// NewImageDigestMirrorSetLister returns a new ImageDigestMirrorSetLister. +func NewImageDigestMirrorSetLister(indexer cache.Indexer) ImageDigestMirrorSetLister { + return &imageDigestMirrorSetLister{indexer: indexer} +} + +// List lists all ImageDigestMirrorSets in the indexer. +func (s *imageDigestMirrorSetLister) List(selector labels.Selector) (ret []*v1.ImageDigestMirrorSet, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.ImageDigestMirrorSet)) + }) + return ret, err +} + +// Get retrieves the ImageDigestMirrorSet from the index for a given name. +func (s *imageDigestMirrorSetLister) Get(name string) (*v1.ImageDigestMirrorSet, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("imagedigestmirrorset"), name) + } + return obj.(*v1.ImageDigestMirrorSet), nil +} diff --git a/vendor/github.com/openshift/client-go/config/listers/config/v1/imagetagmirrorset.go b/vendor/github.com/openshift/client-go/config/listers/config/v1/imagetagmirrorset.go new file mode 100644 index 0000000000..57b4431c02 --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/listers/config/v1/imagetagmirrorset.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/config/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ImageTagMirrorSetLister helps list ImageTagMirrorSets. +// All objects returned here must be treated as read-only. +type ImageTagMirrorSetLister interface { + // List lists all ImageTagMirrorSets in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.ImageTagMirrorSet, err error) + // Get retrieves the ImageTagMirrorSet from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.ImageTagMirrorSet, error) + ImageTagMirrorSetListerExpansion +} + +// imageTagMirrorSetLister implements the ImageTagMirrorSetLister interface. +type imageTagMirrorSetLister struct { + indexer cache.Indexer +} + +// NewImageTagMirrorSetLister returns a new ImageTagMirrorSetLister. +func NewImageTagMirrorSetLister(indexer cache.Indexer) ImageTagMirrorSetLister { + return &imageTagMirrorSetLister{indexer: indexer} +} + +// List lists all ImageTagMirrorSets in the indexer. +func (s *imageTagMirrorSetLister) List(selector labels.Selector) (ret []*v1.ImageTagMirrorSet, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.ImageTagMirrorSet)) + }) + return ret, err +} + +// Get retrieves the ImageTagMirrorSet from the index for a given name. +func (s *imageTagMirrorSetLister) Get(name string) (*v1.ImageTagMirrorSet, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("imagetagmirrorset"), name) + } + return obj.(*v1.ImageTagMirrorSet), nil +} diff --git a/vendor/github.com/openshift/client-go/config/listers/config/v1/node.go b/vendor/github.com/openshift/client-go/config/listers/config/v1/node.go new file mode 100644 index 0000000000..b35c27117d --- /dev/null +++ b/vendor/github.com/openshift/client-go/config/listers/config/v1/node.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/config/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// NodeLister helps list Nodes. +// All objects returned here must be treated as read-only. +type NodeLister interface { + // List lists all Nodes in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.Node, err error) + // Get retrieves the Node from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.Node, error) + NodeListerExpansion +} + +// nodeLister implements the NodeLister interface. +type nodeLister struct { + indexer cache.Indexer +} + +// NewNodeLister returns a new NodeLister. +func NewNodeLister(indexer cache.Indexer) NodeLister { + return &nodeLister{indexer: indexer} +} + +// List lists all Nodes in the indexer. +func (s *nodeLister) List(selector labels.Selector) (ret []*v1.Node, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.Node)) + }) + return ret, err +} + +// Get retrieves the Node from the index for a given name. +func (s *nodeLister) Get(name string) (*v1.Node, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("node"), name) + } + return obj.(*v1.Node), nil +} diff --git a/vendor/k8s.io/code-generator/generate-groups.sh b/vendor/k8s.io/code-generator/generate-groups.sh old mode 100755 new mode 100644 diff --git a/vendor/k8s.io/code-generator/generate-internal-groups.sh b/vendor/k8s.io/code-generator/generate-internal-groups.sh old mode 100755 new mode 100644 diff --git a/vendor/modules.txt b/vendor/modules.txt index 4b8c1ba67c..d501bd1a51 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -669,7 +669,7 @@ github.com/opencontainers/runc/libcontainer/user # github.com/opencontainers/runtime-spec v1.0.3-0.20210326190908-1c3f411f0417 => github.com/opencontainers/runtime-spec v0.1.2-0.20190408193819-a1b50f621a48 ## explicit github.com/opencontainers/runtime-spec/specs-go -# github.com/openshift/api v0.0.0-20220310165943-abf6417c2748 +# github.com/openshift/api v0.0.0-20220412161459-8f38b7648620 ## explicit; go 1.16 github.com/openshift/api github.com/openshift/api/apiserver @@ -731,7 +731,7 @@ github.com/openshift/api/template github.com/openshift/api/template/v1 github.com/openshift/api/user github.com/openshift/api/user/v1 -# github.com/openshift/client-go v0.0.0-20211209144617-7385dd6338e3 +# github.com/openshift/client-go v0.0.0-20220411091747-c100636b0bc0 ## explicit; go 1.16 github.com/openshift/client-go/build/clientset/versioned/scheme github.com/openshift/client-go/build/clientset/versioned/typed/build/v1