From 31b8905da77f5faaeddacdc62a6decc3b24461b1 Mon Sep 17 00:00:00 2001 From: Mike Danese Date: Mon, 8 Feb 2016 13:33:20 -0800 Subject: [PATCH 1/2] move controller manager to compoenent config --- .../app/controllermanager.go | 38 ++-- .../app/options/options.go | 180 +++++++----------- cmd/kube-controller-manager/app/plugins.go | 27 ++- .../controllermanager/controllermanager.go | 40 ++-- contrib/mesos/pkg/node/statusupdater_test.go | 6 +- pkg/apis/componentconfig/types.go | 158 +++++++++++++++ 6 files changed, 278 insertions(+), 171 deletions(-) diff --git a/cmd/kube-controller-manager/app/controllermanager.go b/cmd/kube-controller-manager/app/controllermanager.go index 589defb07be..d427186a2c9 100644 --- a/cmd/kube-controller-manager/app/controllermanager.go +++ b/cmd/kube-controller-manager/app/controllermanager.go @@ -125,7 +125,7 @@ func Run(s *options.CMServer) error { mux.Handle("/metrics", prometheus.Handler()) server := &http.Server{ - Addr: net.JoinHostPort(s.Address.String(), strconv.Itoa(s.Port)), + Addr: net.JoinHostPort(s.Address, strconv.Itoa(s.Port)), Handler: mux, } glog.Fatal(server.ListenAndServe()) @@ -193,14 +193,16 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig glog.Fatalf("Cloud provider could not be initialized: %v", err) } + // this cidr has been validated already + _, clusterCIDR, _ := net.ParseCIDR(s.ClusterCIDR) nodeController := nodecontroller.NewNodeController(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-controller")), - s.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), + s.PodEvictionTimeout.Duration, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), - s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, &s.ClusterCIDR, s.AllocateNodeCIDRs) - nodeController.Run(s.NodeSyncPeriod) + s.NodeMonitorGracePeriod.Duration, s.NodeStartupGracePeriod.Duration, s.NodeMonitorPeriod.Duration, clusterCIDR, s.AllocateNodeCIDRs) + nodeController.Run(s.NodeSyncPeriod.Duration) serviceController := servicecontroller.New(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "service-controller")), s.ClusterName) - if err := serviceController.Run(s.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil { + if err := serviceController.Run(s.ServiceSyncPeriod.Duration, s.NodeSyncPeriod.Duration); err != nil { glog.Errorf("Failed to start service controller: %v", err) } @@ -210,8 +212,8 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig } else if routes, ok := cloud.Routes(); !ok { glog.Warning("allocate-node-cidrs is set, but cloud provider does not support routes. Will not manage routes.") } else { - routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, &s.ClusterCIDR) - routeController.Run(s.NodeSyncPeriod) + routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, clusterCIDR) + routeController.Run(s.NodeSyncPeriod.Duration) } } else { glog.Infof("allocate-node-cidrs set to %v, node controller not creating routes", s.AllocateNodeCIDRs) @@ -219,7 +221,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig go resourcequotacontroller.NewResourceQuotaController( clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "resourcequota-controller")), - controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod)).Run(s.ConcurrentResourceQuotaSyncs, wait.NeverStop) + controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod.Duration)).Run(s.ConcurrentResourceQuotaSyncs, wait.NeverStop) // If apiserver is not running we should wait for some time and fail only then. This is particularly // important when we start apiserver and controller manager at the same time. @@ -241,7 +243,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig glog.Fatalf("Failed to get supported resources from server: %v", err) } - namespaceController := namespacecontroller.NewNamespaceController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), versions, s.NamespaceSyncPeriod) + namespaceController := namespacecontroller.NewNamespaceController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), versions, s.NamespaceSyncPeriod.Duration) go namespaceController.Run(s.ConcurrentNamespaceSyncs, wait.NeverStop) groupVersion := "extensions/v1beta1" @@ -260,13 +262,13 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig metrics.DefaultHeapsterPort, ) podautoscaler.NewHorizontalController(hpaClient.Core(), hpaClient.Extensions(), hpaClient, metricsClient). - Run(s.HorizontalPodAutoscalerSyncPeriod) + Run(s.HorizontalPodAutoscalerSyncPeriod.Duration) } if containsResource(resources, "daemonsets") { glog.Infof("Starting daemon set controller") go daemon.NewDaemonSetsController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "daemon-set-controller")), ResyncPeriod(s)). - Run(s.ConcurrentDSCSyncs, wait.NeverStop) + Run(s.ConcurrentDaemonSetSyncs, wait.NeverStop) } if containsResource(resources, "jobs") { @@ -288,20 +290,20 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig } } - volumePlugins := ProbeRecyclableVolumePlugins(s.VolumeConfigFlags) - provisioner, err := NewVolumeProvisioner(cloud, s.VolumeConfigFlags) + volumePlugins := ProbeRecyclableVolumePlugins(s.VolumeConfiguration) + provisioner, err := NewVolumeProvisioner(cloud, s.VolumeConfiguration) if err != nil { glog.Fatal("A Provisioner could not be created, but one was expected. Provisioning will not work. This functionality is considered an early Alpha version.") } - pvclaimBinder := persistentvolumecontroller.NewPersistentVolumeClaimBinder(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-binder")), s.PVClaimBinderSyncPeriod) + pvclaimBinder := persistentvolumecontroller.NewPersistentVolumeClaimBinder(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-binder")), s.PVClaimBinderSyncPeriod.Duration) pvclaimBinder.Run() pvRecycler, err := persistentvolumecontroller.NewPersistentVolumeRecycler( clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-recycler")), - s.PVClaimBinderSyncPeriod, - s.VolumeConfigFlags.PersistentVolumeRecyclerMaximumRetry, - ProbeRecyclableVolumePlugins(s.VolumeConfigFlags), + s.PVClaimBinderSyncPeriod.Duration, + s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MaximumRetry, + ProbeRecyclableVolumePlugins(s.VolumeConfiguration), cloud, ) if err != nil { @@ -310,7 +312,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig pvRecycler.Run() if provisioner != nil { - pvController, err := persistentvolumecontroller.NewPersistentVolumeProvisionerController(persistentvolumecontroller.NewControllerClient(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-provisioner"))), s.PVClaimBinderSyncPeriod, volumePlugins, provisioner, cloud) + pvController, err := persistentvolumecontroller.NewPersistentVolumeProvisionerController(persistentvolumecontroller.NewControllerClient(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-provisioner"))), s.PVClaimBinderSyncPeriod.Duration, volumePlugins, provisioner, cloud) if err != nil { glog.Fatalf("Failed to start persistent volume provisioner controller: %+v", err) } diff --git a/cmd/kube-controller-manager/app/options/options.go b/cmd/kube-controller-manager/app/options/options.go index e6846ca99a3..dffa45e470a 100644 --- a/cmd/kube-controller-manager/app/options/options.go +++ b/cmd/kube-controller-manager/app/options/options.go @@ -21,9 +21,9 @@ limitations under the License. package options import ( - "net" "time" + "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/apis/componentconfig" "k8s.io/kubernetes/pkg/client/leaderelection" "k8s.io/kubernetes/pkg/master/ports" @@ -33,107 +33,55 @@ import ( // CMServer is the main context object for the controller manager. type CMServer struct { - Port int - Address net.IP - CloudProvider string - CloudConfigFile string - ConcurrentEndpointSyncs int - ConcurrentRCSyncs int - ConcurrentRSSyncs int - ConcurrentDSCSyncs int - ConcurrentJobSyncs int - ConcurrentResourceQuotaSyncs int - ConcurrentDeploymentSyncs int - ConcurrentNamespaceSyncs int - ServiceSyncPeriod time.Duration - NodeSyncPeriod time.Duration - ResourceQuotaSyncPeriod time.Duration - NamespaceSyncPeriod time.Duration - PVClaimBinderSyncPeriod time.Duration - VolumeConfigFlags VolumeConfigFlags - TerminatedPodGCThreshold int - HorizontalPodAutoscalerSyncPeriod time.Duration - DeploymentControllerSyncPeriod time.Duration - MinResyncPeriod time.Duration - RegisterRetryCount int - NodeMonitorGracePeriod time.Duration - NodeStartupGracePeriod time.Duration - NodeMonitorPeriod time.Duration - NodeStatusUpdateRetry int - PodEvictionTimeout time.Duration - DeletingPodsQps float32 - DeletingPodsBurst int - ServiceAccountKeyFile string - RootCAFile string + componentconfig.KubeControllerManagerConfiguration - ClusterName string - ClusterCIDR net.IPNet - AllocateNodeCIDRs bool - EnableProfiling bool - - Master string - Kubeconfig string - KubeAPIQPS float32 - KubeAPIBurst int - - LeaderElection componentconfig.LeaderElectionConfiguration -} - -// VolumeConfigFlags is used to bind CLI flags to variables. This top-level struct contains *all* enumerated -// CLI flags meant to configure all volume plugins. From this config, the binary will create many instances -// of volume.VolumeConfig which are then passed to the appropriate plugin. The ControllerManager binary is the only -// part of the code which knows what plugins are supported and which CLI flags correspond to each plugin. -type VolumeConfigFlags struct { - PersistentVolumeRecyclerMaximumRetry int - PersistentVolumeRecyclerMinimumTimeoutNFS int - PersistentVolumeRecyclerPodTemplateFilePathNFS string - PersistentVolumeRecyclerIncrementTimeoutNFS int - PersistentVolumeRecyclerPodTemplateFilePathHostPath string - PersistentVolumeRecyclerMinimumTimeoutHostPath int - PersistentVolumeRecyclerIncrementTimeoutHostPath int - EnableHostPathProvisioning bool + Master string + Kubeconfig string } // NewCMServer creates a new CMServer with a default config. func NewCMServer() *CMServer { s := CMServer{ - Port: ports.ControllerManagerPort, - Address: net.ParseIP("0.0.0.0"), - ConcurrentEndpointSyncs: 5, - ConcurrentRCSyncs: 5, - ConcurrentRSSyncs: 5, - ConcurrentDSCSyncs: 2, - ConcurrentJobSyncs: 5, - ConcurrentResourceQuotaSyncs: 5, - ConcurrentDeploymentSyncs: 5, - ConcurrentNamespaceSyncs: 2, - ServiceSyncPeriod: 5 * time.Minute, - NodeSyncPeriod: 10 * time.Second, - ResourceQuotaSyncPeriod: 5 * time.Minute, - NamespaceSyncPeriod: 5 * time.Minute, - PVClaimBinderSyncPeriod: 10 * time.Minute, - HorizontalPodAutoscalerSyncPeriod: 30 * time.Second, - DeploymentControllerSyncPeriod: 30 * time.Second, - MinResyncPeriod: 12 * time.Hour, - RegisterRetryCount: 10, - PodEvictionTimeout: 5 * time.Minute, - NodeMonitorGracePeriod: 40 * time.Second, - NodeStartupGracePeriod: 60 * time.Second, - NodeMonitorPeriod: 5 * time.Second, - ClusterName: "kubernetes", - TerminatedPodGCThreshold: 12500, - VolumeConfigFlags: VolumeConfigFlags{ - // default values here - PersistentVolumeRecyclerMaximumRetry: 3, - PersistentVolumeRecyclerMinimumTimeoutNFS: 300, - PersistentVolumeRecyclerIncrementTimeoutNFS: 30, - PersistentVolumeRecyclerMinimumTimeoutHostPath: 60, - PersistentVolumeRecyclerIncrementTimeoutHostPath: 30, - EnableHostPathProvisioning: false, + KubeControllerManagerConfiguration: componentconfig.KubeControllerManagerConfiguration{ + Port: ports.ControllerManagerPort, + Address: "0.0.0.0", + ConcurrentEndpointSyncs: 5, + ConcurrentRCSyncs: 5, + ConcurrentRSSyncs: 5, + ConcurrentDaemonSetSyncs: 2, + ConcurrentJobSyncs: 5, + ConcurrentResourceQuotaSyncs: 5, + ConcurrentDeploymentSyncs: 5, + ConcurrentNamespaceSyncs: 2, + ServiceSyncPeriod: unversioned.Duration{5 * time.Minute}, + NodeSyncPeriod: unversioned.Duration{10 * time.Second}, + ResourceQuotaSyncPeriod: unversioned.Duration{5 * time.Minute}, + NamespaceSyncPeriod: unversioned.Duration{5 * time.Minute}, + PVClaimBinderSyncPeriod: unversioned.Duration{10 * time.Minute}, + HorizontalPodAutoscalerSyncPeriod: unversioned.Duration{30 * time.Second}, + DeploymentControllerSyncPeriod: unversioned.Duration{30 * time.Second}, + MinResyncPeriod: unversioned.Duration{12 * time.Hour}, + RegisterRetryCount: 10, + PodEvictionTimeout: unversioned.Duration{5 * time.Minute}, + NodeMonitorGracePeriod: unversioned.Duration{40 * time.Second}, + NodeStartupGracePeriod: unversioned.Duration{60 * time.Second}, + NodeMonitorPeriod: unversioned.Duration{5 * time.Second}, + ClusterName: "kubernetes", + TerminatedPodGCThreshold: 12500, + VolumeConfiguration: componentconfig.VolumeConfiguration{ + EnableHostPathProvisioning: false, + PersistentVolumeRecyclerConfiguration: componentconfig.PersistentVolumeRecyclerConfiguration{ + MaximumRetry: 3, + MinimumTimeoutNFS: 300, + IncrementTimeoutNFS: 30, + MinimumTimeoutHostPath: 60, + IncrementTimeoutHostPath: 30, + }, + }, + KubeAPIQPS: 20.0, + KubeAPIBurst: 30, + LeaderElection: leaderelection.DefaultLeaderElectionConfiguration(), }, - KubeAPIQPS: 20.0, - KubeAPIBurst: 30, - LeaderElection: leaderelection.DefaultLeaderElectionConfiguration(), } return &s } @@ -141,7 +89,7 @@ func NewCMServer() *CMServer { // AddFlags adds flags for a specific CMServer to the specified FlagSet func (s *CMServer) AddFlags(fs *pflag.FlagSet) { fs.IntVar(&s.Port, "port", s.Port, "The port that the controller-manager's http service runs on") - fs.IPVar(&s.Address, "address", s.Address, "The IP address to serve on (set to 0.0.0.0 for all interfaces)") + fs.Var(componentconfig.IPVar{&s.Address}, "address", "The IP address to serve on (set to 0.0.0.0 for all interfaces)") fs.StringVar(&s.CloudProvider, "cloud-provider", s.CloudProvider, "The provider for cloud services. Empty string for no provider.") fs.StringVar(&s.CloudConfigFile, "cloud-config", s.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.") fs.IntVar(&s.ConcurrentEndpointSyncs, "concurrent-endpoint-syncs", s.ConcurrentEndpointSyncs, "The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load") @@ -150,42 +98,42 @@ func (s *CMServer) AddFlags(fs *pflag.FlagSet) { fs.IntVar(&s.ConcurrentResourceQuotaSyncs, "concurrent-resource-quota-syncs", s.ConcurrentResourceQuotaSyncs, "The number of resource quotas that are allowed to sync concurrently. Larger number = more responsive quota management, but more CPU (and network) load") fs.IntVar(&s.ConcurrentDeploymentSyncs, "concurrent-deployment-syncs", s.ConcurrentDeploymentSyncs, "The number of deployment objects that are allowed to sync concurrently. Larger number = more responsive deployments, but more CPU (and network) load") fs.IntVar(&s.ConcurrentNamespaceSyncs, "concurrent-namespace-syncs", s.ConcurrentNamespaceSyncs, "The number of namespace objects that are allowed to sync concurrently. Larger number = more responsive namespace termination, but more CPU (and network) load") - fs.DurationVar(&s.ServiceSyncPeriod, "service-sync-period", s.ServiceSyncPeriod, "The period for syncing services with their external load balancers") - fs.DurationVar(&s.NodeSyncPeriod, "node-sync-period", s.NodeSyncPeriod, ""+ + fs.DurationVar(&s.ServiceSyncPeriod.Duration, "service-sync-period", s.ServiceSyncPeriod.Duration, "The period for syncing services with their external load balancers") + fs.DurationVar(&s.NodeSyncPeriod.Duration, "node-sync-period", s.NodeSyncPeriod.Duration, ""+ "The period for syncing nodes from cloudprovider. Longer periods will result in "+ "fewer calls to cloud provider, but may delay addition of new nodes to cluster.") - fs.DurationVar(&s.ResourceQuotaSyncPeriod, "resource-quota-sync-period", s.ResourceQuotaSyncPeriod, "The period for syncing quota usage status in the system") - fs.DurationVar(&s.NamespaceSyncPeriod, "namespace-sync-period", s.NamespaceSyncPeriod, "The period for syncing namespace life-cycle updates") - fs.DurationVar(&s.PVClaimBinderSyncPeriod, "pvclaimbinder-sync-period", s.PVClaimBinderSyncPeriod, "The period for syncing persistent volumes and persistent volume claims") - fs.DurationVar(&s.MinResyncPeriod, "min-resync-period", s.MinResyncPeriod, "The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod") - fs.StringVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathNFS, "pv-recycler-pod-template-filepath-nfs", s.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathNFS, "The file path to a pod definition used as a template for NFS persistent volume recycling") - fs.IntVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutNFS, "pv-recycler-minimum-timeout-nfs", s.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutNFS, "The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod") - fs.IntVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutNFS, "pv-recycler-increment-timeout-nfs", s.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutNFS, "the increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod") - fs.StringVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, "pv-recycler-pod-template-filepath-hostpath", s.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, "The file path to a pod definition used as a template for HostPath persistent volume recycling. This is for development and testing only and will not work in a multi-node cluster.") - fs.IntVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutHostPath, "pv-recycler-minimum-timeout-hostpath", s.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutHostPath, "The minimum ActiveDeadlineSeconds to use for a HostPath Recycler pod. This is for development and testing only and will not work in a multi-node cluster.") - fs.IntVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutHostPath, "pv-recycler-timeout-increment-hostpath", s.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutHostPath, "the increment of time added per Gi to ActiveDeadlineSeconds for a HostPath scrubber pod. This is for development and testing only and will not work in a multi-node cluster.") - fs.BoolVar(&s.VolumeConfigFlags.EnableHostPathProvisioning, "enable-hostpath-provisioner", s.VolumeConfigFlags.EnableHostPathProvisioning, "Enable HostPath PV provisioning when running without a cloud provider. This allows testing and development of provisioning features. HostPath provisioning is not supported in any way, won't work in a multi-node cluster, and should not be used for anything other than testing or development.") + fs.DurationVar(&s.ResourceQuotaSyncPeriod.Duration, "resource-quota-sync-period", s.ResourceQuotaSyncPeriod.Duration, "The period for syncing quota usage status in the system") + fs.DurationVar(&s.NamespaceSyncPeriod.Duration, "namespace-sync-period", s.NamespaceSyncPeriod.Duration, "The period for syncing namespace life-cycle updates") + fs.DurationVar(&s.PVClaimBinderSyncPeriod.Duration, "pvclaimbinder-sync-period", s.PVClaimBinderSyncPeriod.Duration, "The period for syncing persistent volumes and persistent volume claims") + fs.DurationVar(&s.MinResyncPeriod.Duration, "min-resync-period", s.MinResyncPeriod.Duration, "The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod") + fs.StringVar(&s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathNFS, "pv-recycler-pod-template-filepath-nfs", s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathNFS, "The file path to a pod definition used as a template for NFS persistent volume recycling") + fs.IntVar(&s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS, "pv-recycler-minimum-timeout-nfs", s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS, "The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod") + fs.IntVar(&s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS, "pv-recycler-increment-timeout-nfs", s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS, "the increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod") + fs.StringVar(&s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathHostPath, "pv-recycler-pod-template-filepath-hostpath", s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathHostPath, "The file path to a pod definition used as a template for HostPath persistent volume recycling. This is for development and testing only and will not work in a multi-node cluster.") + fs.IntVar(&s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath, "pv-recycler-minimum-timeout-hostpath", s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath, "The minimum ActiveDeadlineSeconds to use for a HostPath Recycler pod. This is for development and testing only and will not work in a multi-node cluster.") + fs.IntVar(&s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath, "pv-recycler-timeout-increment-hostpath", s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath, "the increment of time added per Gi to ActiveDeadlineSeconds for a HostPath scrubber pod. This is for development and testing only and will not work in a multi-node cluster.") + fs.BoolVar(&s.VolumeConfiguration.EnableHostPathProvisioning, "enable-hostpath-provisioner", s.VolumeConfiguration.EnableHostPathProvisioning, "Enable HostPath PV provisioning when running without a cloud provider. This allows testing and development of provisioning features. HostPath provisioning is not supported in any way, won't work in a multi-node cluster, and should not be used for anything other than testing or development.") fs.IntVar(&s.TerminatedPodGCThreshold, "terminated-pod-gc-threshold", s.TerminatedPodGCThreshold, "Number of terminated pods that can exist before the terminated pod garbage collector starts deleting terminated pods. If <= 0, the terminated pod garbage collector is disabled.") - fs.DurationVar(&s.HorizontalPodAutoscalerSyncPeriod, "horizontal-pod-autoscaler-sync-period", s.HorizontalPodAutoscalerSyncPeriod, "The period for syncing the number of pods in horizontal pod autoscaler.") - fs.DurationVar(&s.DeploymentControllerSyncPeriod, "deployment-controller-sync-period", s.DeploymentControllerSyncPeriod, "Period for syncing the deployments.") - fs.DurationVar(&s.PodEvictionTimeout, "pod-eviction-timeout", s.PodEvictionTimeout, "The grace period for deleting pods on failed nodes.") + fs.DurationVar(&s.HorizontalPodAutoscalerSyncPeriod.Duration, "horizontal-pod-autoscaler-sync-period", s.HorizontalPodAutoscalerSyncPeriod.Duration, "The period for syncing the number of pods in horizontal pod autoscaler.") + fs.DurationVar(&s.DeploymentControllerSyncPeriod.Duration, "deployment-controller-sync-period", s.DeploymentControllerSyncPeriod.Duration, "Period for syncing the deployments.") + fs.DurationVar(&s.PodEvictionTimeout.Duration, "pod-eviction-timeout", s.PodEvictionTimeout.Duration, "The grace period for deleting pods on failed nodes.") fs.Float32Var(&s.DeletingPodsQps, "deleting-pods-qps", 0.1, "Number of nodes per second on which pods are deleted in case of node failure.") fs.IntVar(&s.DeletingPodsBurst, "deleting-pods-burst", 10, "Number of nodes on which pods are bursty deleted in case of node failure. For more details look into RateLimiter.") fs.IntVar(&s.RegisterRetryCount, "register-retry-count", s.RegisterRetryCount, ""+ "The number of retries for initial node registration. Retry interval equals node-sync-period.") fs.MarkDeprecated("register-retry-count", "This flag is currently no-op and will be deleted.") - fs.DurationVar(&s.NodeMonitorGracePeriod, "node-monitor-grace-period", s.NodeMonitorGracePeriod, + fs.DurationVar(&s.NodeMonitorGracePeriod.Duration, "node-monitor-grace-period", s.NodeMonitorGracePeriod.Duration, "Amount of time which we allow running Node to be unresponsive before marking it unhealty. "+ "Must be N times more than kubelet's nodeStatusUpdateFrequency, "+ "where N means number of retries allowed for kubelet to post node status.") - fs.DurationVar(&s.NodeStartupGracePeriod, "node-startup-grace-period", s.NodeStartupGracePeriod, + fs.DurationVar(&s.NodeStartupGracePeriod.Duration, "node-startup-grace-period", s.NodeStartupGracePeriod.Duration, "Amount of time which we allow starting Node to be unresponsive before marking it unhealty.") - fs.DurationVar(&s.NodeMonitorPeriod, "node-monitor-period", s.NodeMonitorPeriod, + fs.DurationVar(&s.NodeMonitorPeriod.Duration, "node-monitor-period", s.NodeMonitorPeriod.Duration, "The period for syncing NodeStatus in NodeController.") fs.StringVar(&s.ServiceAccountKeyFile, "service-account-private-key-file", s.ServiceAccountKeyFile, "Filename containing a PEM-encoded private RSA key used to sign service account tokens.") fs.BoolVar(&s.EnableProfiling, "profiling", true, "Enable profiling via web interface host:port/debug/pprof/") fs.StringVar(&s.ClusterName, "cluster-name", s.ClusterName, "The instance prefix for the cluster") - fs.IPNetVar(&s.ClusterCIDR, "cluster-cidr", s.ClusterCIDR, "CIDR Range for Pods in cluster.") + fs.StringVar(&s.ClusterCIDR, "cluster-cidr", s.ClusterCIDR, "CIDR Range for Pods in cluster.") fs.BoolVar(&s.AllocateNodeCIDRs, "allocate-node-cidrs", false, "Should CIDRs for Pods be allocated and set on the cloud provider.") fs.StringVar(&s.Master, "master", s.Master, "The address of the Kubernetes API server (overrides any value in kubeconfig)") fs.StringVar(&s.Kubeconfig, "kubeconfig", s.Kubeconfig, "Path to kubeconfig file with authorization and master location information.") diff --git a/cmd/kube-controller-manager/app/plugins.go b/cmd/kube-controller-manager/app/plugins.go index 03c7cafd7f8..e6e16699bd1 100644 --- a/cmd/kube-controller-manager/app/plugins.go +++ b/cmd/kube-controller-manager/app/plugins.go @@ -23,9 +23,8 @@ import ( "fmt" - "k8s.io/kubernetes/cmd/kube-controller-manager/app/options" - // Cloud providers + "k8s.io/kubernetes/pkg/apis/componentconfig" _ "k8s.io/kubernetes/pkg/cloudprovider/providers" // Volume plugins @@ -45,7 +44,7 @@ import ( ) // ProbeRecyclableVolumePlugins collects all persistent volume plugins into an easy to use list. -func ProbeRecyclableVolumePlugins(flags options.VolumeConfigFlags) []volume.VolumePlugin { +func ProbeRecyclableVolumePlugins(config componentconfig.VolumeConfiguration) []volume.VolumePlugin { allPlugins := []volume.VolumePlugin{} // The list of plugins to probe is decided by this binary, not @@ -53,27 +52,27 @@ func ProbeRecyclableVolumePlugins(flags options.VolumeConfigFlags) []volume.Volu // initialized later. // Each plugin can make use of VolumeConfig. The single arg to this func contains *all* enumerated - // CLI flags meant to configure volume plugins. From that single config, create an instance of volume.VolumeConfig + // options meant to configure volume plugins. From that single config, create an instance of volume.VolumeConfig // for a specific plugin and pass that instance to the plugin's ProbeVolumePlugins(config) func. // HostPath recycling is for testing and development purposes only! hostPathConfig := volume.VolumeConfig{ - RecyclerMinimumTimeout: flags.PersistentVolumeRecyclerMinimumTimeoutHostPath, - RecyclerTimeoutIncrement: flags.PersistentVolumeRecyclerIncrementTimeoutHostPath, + RecyclerMinimumTimeout: config.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath, + RecyclerTimeoutIncrement: config.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath, RecyclerPodTemplate: volume.NewPersistentVolumeRecyclerPodTemplate(), } - if err := AttemptToLoadRecycler(flags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, &hostPathConfig); err != nil { - glog.Fatalf("Could not create hostpath recycler pod from file %s: %+v", flags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, err) + if err := AttemptToLoadRecycler(config.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathHostPath, &hostPathConfig); err != nil { + glog.Fatalf("Could not create hostpath recycler pod from file %s: %+v", config.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathHostPath, err) } allPlugins = append(allPlugins, host_path.ProbeVolumePlugins(hostPathConfig)...) nfsConfig := volume.VolumeConfig{ - RecyclerMinimumTimeout: flags.PersistentVolumeRecyclerMinimumTimeoutNFS, - RecyclerTimeoutIncrement: flags.PersistentVolumeRecyclerIncrementTimeoutNFS, + RecyclerMinimumTimeout: config.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS, + RecyclerTimeoutIncrement: config.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS, RecyclerPodTemplate: volume.NewPersistentVolumeRecyclerPodTemplate(), } - if err := AttemptToLoadRecycler(flags.PersistentVolumeRecyclerPodTemplateFilePathNFS, &nfsConfig); err != nil { - glog.Fatalf("Could not create NFS recycler pod from file %s: %+v", flags.PersistentVolumeRecyclerPodTemplateFilePathNFS, err) + if err := AttemptToLoadRecycler(config.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathNFS, &nfsConfig); err != nil { + glog.Fatalf("Could not create NFS recycler pod from file %s: %+v", config.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathNFS, err) } allPlugins = append(allPlugins, nfs.ProbeVolumePlugins(nfsConfig)...) @@ -88,9 +87,9 @@ func ProbeRecyclableVolumePlugins(flags options.VolumeConfigFlags) []volume.Volu // The beta implementation of provisioning allows 1 implied provisioner per cloud, until we allow configuration of many. // We explicitly map clouds to volume plugins here which allows us to configure many later without backwards compatibility issues. // Not all cloudproviders have provisioning capability, which is the reason for the bool in the return to tell the caller to expect one or not. -func NewVolumeProvisioner(cloud cloudprovider.Interface, flags options.VolumeConfigFlags) (volume.ProvisionableVolumePlugin, error) { +func NewVolumeProvisioner(cloud cloudprovider.Interface, config componentconfig.VolumeConfiguration) (volume.ProvisionableVolumePlugin, error) { switch { - case cloud == nil && flags.EnableHostPathProvisioning: + case cloud == nil && config.EnableHostPathProvisioning: return getProvisionablePluginFromVolumePlugins(host_path.ProbeVolumePlugins(volume.VolumeConfig{})) case cloud != nil && aws.ProviderName == cloud.ProviderName(): return getProvisionablePluginFromVolumePlugins(aws_ebs.ProbeVolumePlugins()) diff --git a/contrib/mesos/pkg/controllermanager/controllermanager.go b/contrib/mesos/pkg/controllermanager/controllermanager.go index 56a00439cf0..30d766904b7 100644 --- a/contrib/mesos/pkg/controllermanager/controllermanager.go +++ b/contrib/mesos/pkg/controllermanager/controllermanager.go @@ -122,7 +122,7 @@ func (s *CMServer) Run(_ []string) error { } mux.Handle("/metrics", prometheus.Handler()) server := &http.Server{ - Addr: net.JoinHostPort(s.Address.String(), strconv.Itoa(s.Port)), + Addr: net.JoinHostPort(s.Address, strconv.Itoa(s.Port)), Handler: mux, } glog.Fatal(server.ListenAndServe()) @@ -147,20 +147,20 @@ func (s *CMServer) Run(_ []string) error { if err != nil { glog.Fatalf("Cloud provider could not be initialized: %v", err) } - + _, clusterCIDR, _ := net.ParseCIDR(s.ClusterCIDR) nodeController := nodecontroller.NewNodeController(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-controller")), - s.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), + s.PodEvictionTimeout.Duration, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), - s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, (*net.IPNet)(&s.ClusterCIDR), s.AllocateNodeCIDRs) - nodeController.Run(s.NodeSyncPeriod) + s.NodeMonitorGracePeriod.Duration, s.NodeStartupGracePeriod.Duration, s.NodeMonitorPeriod.Duration, clusterCIDR, s.AllocateNodeCIDRs) + nodeController.Run(s.NodeSyncPeriod.Duration) - nodeStatusUpdaterController := node.NewStatusUpdater(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-status-controller")), s.NodeMonitorPeriod, time.Now) + nodeStatusUpdaterController := node.NewStatusUpdater(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-status-controller")), s.NodeMonitorPeriod.Duration, time.Now) if err := nodeStatusUpdaterController.Run(wait.NeverStop); err != nil { glog.Fatalf("Failed to start node status update controller: %v", err) } serviceController := servicecontroller.New(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "service-controller")), s.ClusterName) - if err := serviceController.Run(s.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil { + if err := serviceController.Run(s.ServiceSyncPeriod.Duration, s.NodeSyncPeriod.Duration); err != nil { glog.Errorf("Failed to start service controller: %v", err) } @@ -169,12 +169,12 @@ func (s *CMServer) Run(_ []string) error { if !ok { glog.Fatal("Cloud provider must support routes if allocate-node-cidrs is set") } - routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, (*net.IPNet)(&s.ClusterCIDR)) - routeController.Run(s.NodeSyncPeriod) + routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, clusterCIDR) + routeController.Run(s.NodeSyncPeriod.Duration) } go resourcequotacontroller.NewResourceQuotaController( - clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "resource-quota-controller")), controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod)).Run(s.ConcurrentResourceQuotaSyncs, wait.NeverStop) + clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "resource-quota-controller")), controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod.Duration)).Run(s.ConcurrentResourceQuotaSyncs, wait.NeverStop) // If apiserver is not running we should wait for some time and fail only then. This is particularly // important when we start apiserver and controller manager at the same time. @@ -196,7 +196,7 @@ func (s *CMServer) Run(_ []string) error { glog.Fatalf("Failed to get supported resources from server: %v", err) } - namespaceController := namespacecontroller.NewNamespaceController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), versions, s.NamespaceSyncPeriod) + namespaceController := namespacecontroller.NewNamespaceController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), versions, s.NamespaceSyncPeriod.Duration) go namespaceController.Run(s.ConcurrentNamespaceSyncs, wait.NeverStop) groupVersion := "extensions/v1beta1" @@ -215,13 +215,13 @@ func (s *CMServer) Run(_ []string) error { metrics.DefaultHeapsterPort, ) podautoscaler.NewHorizontalController(hpaClient.Core(), hpaClient.Extensions(), hpaClient, metricsClient). - Run(s.HorizontalPodAutoscalerSyncPeriod) + Run(s.HorizontalPodAutoscalerSyncPeriod.Duration) } if containsResource(resources, "daemonsets") { glog.Infof("Starting daemon set controller") go daemon.NewDaemonSetsController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "daemon-set-controller")), s.resyncPeriod). - Run(s.ConcurrentDSCSyncs, wait.NeverStop) + Run(s.ConcurrentDaemonSetSyncs, wait.NeverStop) } if containsResource(resources, "jobs") { @@ -243,23 +243,23 @@ func (s *CMServer) Run(_ []string) error { } } - volumePlugins := kubecontrollermanager.ProbeRecyclableVolumePlugins(s.VolumeConfigFlags) - provisioner, err := kubecontrollermanager.NewVolumeProvisioner(cloud, s.VolumeConfigFlags) + volumePlugins := kubecontrollermanager.ProbeRecyclableVolumePlugins(s.VolumeConfiguration) + provisioner, err := kubecontrollermanager.NewVolumeProvisioner(cloud, s.VolumeConfiguration) if err != nil { glog.Fatal("A Provisioner could not be created, but one was expected. Provisioning will not work. This functionality is considered an early Alpha version.") } pvclaimBinder := persistentvolumecontroller.NewPersistentVolumeClaimBinder( clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-binder")), - s.PVClaimBinderSyncPeriod, + s.PVClaimBinderSyncPeriod.Duration, ) pvclaimBinder.Run() pvRecycler, err := persistentvolumecontroller.NewPersistentVolumeRecycler( clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-recycler")), - s.PVClaimBinderSyncPeriod, - s.VolumeConfigFlags.PersistentVolumeRecyclerMaximumRetry, - kubecontrollermanager.ProbeRecyclableVolumePlugins(s.VolumeConfigFlags), + s.PVClaimBinderSyncPeriod.Duration, + s.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MaximumRetry, + kubecontrollermanager.ProbeRecyclableVolumePlugins(s.VolumeConfiguration), cloud, ) if err != nil { @@ -268,7 +268,7 @@ func (s *CMServer) Run(_ []string) error { pvRecycler.Run() if provisioner != nil { - pvController, err := persistentvolumecontroller.NewPersistentVolumeProvisionerController(persistentvolumecontroller.NewControllerClient(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-controller"))), s.PVClaimBinderSyncPeriod, volumePlugins, provisioner, cloud) + pvController, err := persistentvolumecontroller.NewPersistentVolumeProvisionerController(persistentvolumecontroller.NewControllerClient(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-controller"))), s.PVClaimBinderSyncPeriod.Duration, volumePlugins, provisioner, cloud) if err != nil { glog.Fatalf("Failed to start persistent volume provisioner controller: %+v", err) } diff --git a/contrib/mesos/pkg/node/statusupdater_test.go b/contrib/mesos/pkg/node/statusupdater_test.go index aba8fca5b33..8817f2effa1 100644 --- a/contrib/mesos/pkg/node/statusupdater_test.go +++ b/contrib/mesos/pkg/node/statusupdater_test.go @@ -48,15 +48,15 @@ func Test_nodeWithUpdatedStatus(t *testing.T) { cm := cmoptions.NewCMServer() kubecfg := kubeletoptions.NewKubeletServer() - assert.True(t, kubecfg.NodeStatusUpdateFrequency.Duration*3 < cm.NodeMonitorGracePeriod) // sanity check for defaults + assert.True(t, kubecfg.NodeStatusUpdateFrequency.Duration*3 < cm.NodeMonitorGracePeriod.Duration) // sanity check for defaults n := testNode(0, api.ConditionTrue, "KubeletReady") - su := NewStatusUpdater(nil, cm.NodeMonitorPeriod, func() time.Time { return now }) + su := NewStatusUpdater(nil, cm.NodeMonitorPeriod.Duration, func() time.Time { return now }) _, updated, err := su.nodeWithUpdatedStatus(n) assert.NoError(t, err) assert.False(t, updated, "no update expected b/c kubelet updated heartbeat just now") - n = testNode(-cm.NodeMonitorGracePeriod, api.ConditionTrue, "KubeletReady") + n = testNode(-cm.NodeMonitorGracePeriod.Duration, api.ConditionTrue, "KubeletReady") n2, updated, err := su.nodeWithUpdatedStatus(n) assert.NoError(t, err) assert.True(t, updated, "update expected b/c kubelet's update is older than DefaultNodeMonitorGracePeriod") diff --git a/pkg/apis/componentconfig/types.go b/pkg/apis/componentconfig/types.go index 376ab823be7..3982ab7a6e3 100644 --- a/pkg/apis/componentconfig/types.go +++ b/pkg/apis/componentconfig/types.go @@ -356,3 +356,161 @@ type LeaderElectionConfiguration struct { // leader election is enabled. RetryPeriod unversioned.Duration `json:"retryPeriod"` } + +type KubeControllerManagerConfiguration struct { + unversioned.TypeMeta + + // port is the port that the controller-manager's http service runs on. + Port int `json:"port"` + // address is the IP address to serve on (set to 0.0.0.0 for all interfaces). + Address string `json:"address"` + // cloudProvider is the provider for cloud services. + CloudProvider string `json:"cloudProvider"` + // cloudConfigFile is the path to the cloud provider configuration file. + CloudConfigFile string `json:"cloudConfigFile"` + // concurrentEndpointSyncs is the number of endpoint syncing operations + // that will be done concurrently. Larger number = faster endpoint updating, + // but more CPU (and network) load. + ConcurrentEndpointSyncs int `json:"concurrentEndpointSyncs"` + // concurrentRSSyncs is the number of replica sets that are allowed to sync + // concurrently. Larger number = more reponsive replica management, but more + // CPU (and network) load. + ConcurrentRSSyncs int `json:"concurrentRSSyncs"` + // concurrentRCSyncs is the number of replication controllers that are + // allowed to sync concurrently. Larger number = more reponsive replica + // management, but more CPU (and network) load. + ConcurrentRCSyncs int `json:"concurrentRCSyncs"` + // concurrentResourceQuotaSyncs is the number of resource quotas that are + // allowed to sync concurrently. Larger number = more responsive quota + // management, but more CPU (and network) load. + ConcurrentResourceQuotaSyncs int `json:"concurrentResourceQuotaSyncs"` + // concurrentDeploymentSyncs is the number of deployment objects that are + // allowed to sync concurrently. Larger number = more reponsive deployments, + // but more CPU (and network) load. + ConcurrentDeploymentSyncs int `json:"concurrentDeploymentSyncs"` + // concurrentDaemonSetSyncs is the number of daemonset objects that are + // allowed to sync concurrently. Larger number = more reponsive DaemonSet, + // but more CPU (and network) load. + ConcurrentDaemonSetSyncs int `json:"concurrentDaemonSetSyncs"` + // concurrentJobSyncs is the number of job objects that are + // allowed to sync concurrently. Larger number = more reponsive jobs, + // but more CPU (and network) load. + ConcurrentJobSyncs int `json:"concurrentJobSyncs"` + // concurrentNamespaceSyncs is the number of namespace objects that are + // allowed to sync concurrently. + ConcurrentNamespaceSyncs int `json:"concurrentNamespaceSyncs"` + // serviceSyncPeriod is the period for syncing services with their external + // load balancers. + ServiceSyncPeriod unversioned.Duration `json:"serviceSyncPeriod"` + // nodeSyncPeriod is the period for syncing nodes from cloudprovider. Longer + // periods will result in fewer calls to cloud provider, but may delay addition + // of new nodes to cluster. + NodeSyncPeriod unversioned.Duration `json:"nodeSyncPeriod"` + // resourceQuotaSyncPeriod is the period for syncing quota usage status + // in the system. + ResourceQuotaSyncPeriod unversioned.Duration `json:"resourceQuotaSyncPeriod"` + // namespaceSyncPeriod is the period for syncing namespace life-cycle + // updates. + NamespaceSyncPeriod unversioned.Duration `json:"namespaceSyncPeriod"` + // pvClaimBinderSyncPeriod is the period for syncing persistent volumes + // and persistent volume claims. + PVClaimBinderSyncPeriod unversioned.Duration `json:"pvClaimBinderSyncPeriod"` + // minResyncPeriod is the resync period in reflectors; will be random between + // minResyncPeriod and 2*minResyncPeriod. + MinResyncPeriod unversioned.Duration `json:"minResyncPeriod"` + // terminatedPodGCThreshold is the number of terminated pods that can exist + // before the terminated pod garbage collector starts deleting terminated pods. + // If <= 0, the terminated pod garbage collector is disabled. + TerminatedPodGCThreshold int `json:"terminatedPodGCThreshold"` + // horizontalPodAutoscalerSyncPeriod is the period for syncing the number of + // pods in horizontal pod autoscaler. + HorizontalPodAutoscalerSyncPeriod unversioned.Duration `json:"horizontalPodAutoscalerSyncPeriod"` + // deploymentControllerSyncPeriod is the period for syncing the deployments. + DeploymentControllerSyncPeriod unversioned.Duration `json:"deploymentControllerSyncPeriod"` + // podEvictionTimeout is the grace period for deleting pods on failed nodes. + PodEvictionTimeout unversioned.Duration `json:"podEvictionTimeout"` + // deletingPodsQps is the number of nodes per second on which pods are deleted in + // case of node failure. + DeletingPodsQps float32 `json:"deletingPodsQps"` + // deletingPodsBurst is the number of nodes on which pods are bursty deleted in + // case of node failure. For more details look into RateLimiter. + DeletingPodsBurst int `json:"deletingPodsBurst"` + // nodeMontiorGracePeriod is the amount of time which we allow a running node to be + // unresponsive before marking it unhealty. Must be N times more than kubelet's + // nodeStatusUpdateFrequency, where N means number of retries allowed for kubelet + // to post node status. + NodeMonitorGracePeriod unversioned.Duration `json:"nodeMonitorGracePeriod"` + // registerRetryCount is the number of retries for initial node registration. + // Retry interval equals node-sync-period. + RegisterRetryCount int `json:"registerRetryCount"` + // nodeStartupGracePeriod is the amount of time which we allow starting a node to + // be unresponsive before marking it unhealty. + NodeStartupGracePeriod unversioned.Duration `json:"nodeStartupGracePeriod"` + // nodeMonitorPeriod is the period for syncing NodeStatus in NodeController. + NodeMonitorPeriod unversioned.Duration `json:"nodeMonitorPeriod"` + // serviceAccountKeyFile is the filename containing a PEM-encoded private RSA key + // used to sign service account tokens. + ServiceAccountKeyFile string `json:"serviceAccountKeyFile"` + // enableProfiling enables profiling via web interface host:port/debug/pprof/ + EnableProfiling bool `json:"enableProfiling"` + // clusterName is the instance prefix for the cluster. + ClusterName string `json:"clusterName"` + // clusterCIDR is CIDR Range for Pods in cluster. + ClusterCIDR string `json:"clusterCIDR"` + // allocateNodeCIDRs enables CIDRs for Pods to be allocated and set on the + // cloud provider. + AllocateNodeCIDRs bool `json:"allocateNodeCIDRs"` + // rootCAFile is the root certificate authority will be included in service + // account's token secret. This must be a valid PEM-encoded CA bundle. + RootCAFile string `json:"rootCAFile"` + // kubeAPIQPS is the QPS to use while talking with kubernetes apiserver. + KubeAPIQPS float32 `json:"kubeAPIQPS"` + // kubeAPIBurst is the burst to use while talking with kubernetes apiserver. + KubeAPIBurst int `json:"kubeAPIBurst"` + // leaderElection defines the configuration of leader election client. + LeaderElection LeaderElectionConfiguration `json:"leaderElection"` + // vloumeConfiguration holds configuration for volume related features. + VolumeConfiguration VolumeConfiguration `json:"volumeConfiguration"` +} + +// VolumeConfiguration contains *all* enumerated flags meant to configure all volume +// plugins. From this config, the controller-manager binary will create many instances of +// volume.VolumeConfig, each containing only the configuration needed for that plugin which +// are then passed to the appropriate plugin. The ControllerManager binary is the only part +// of the code which knows what plugins are supported and which flags correspond to each plugin. +type VolumeConfiguration struct { + // enableHostPathProvisioning enables HostPath PV provisioning when running without a + // cloud provider. This allows testing and development of provisioning features. HostPath + // provisioning is not supported in any way, won't work in a multi-node cluster, and + // should not be used for anything other than testing or development. + EnableHostPathProvisioning bool `json:"enableHostPathProvisioning"` + // persistentVolumeRecyclerConfiguration holds configuration for persistent volume plugins. + PersistentVolumeRecyclerConfiguration PersistentVolumeRecyclerConfiguration `json:"persitentVolumeRecyclerConfiguration"` +} + +type PersistentVolumeRecyclerConfiguration struct { + // maximumRetry is number of retries the PV recycler will execute on failure to recycle + // PV. + MaximumRetry int `json:"maximumRetry"` + // minimumTimeoutNFS is the minimum ActiveDeadlineSeconds to use for an NFS Recycler + // pod. + MinimumTimeoutNFS int `json:"minimumTimeoutNFS"` + // podTemplateFilePathNFS is the file path to a pod definition used as a template for + // NFS persistent volume recycling + PodTemplateFilePathNFS string `json:"podTemplateFilePathNFS"` + // incrementTimeoutNFS is the increment of time added per Gi to ActiveDeadlineSeconds + // for an NFS scrubber pod. + IncrementTimeoutNFS int `json:"incrementTimeoutNFS"` + // podTemplateFilePathHostPath is the file path to a pod definition used as a template for + // HostPath persistent volume recycling. This is for development and testing only and + // will not work in a multi-node cluster. + PodTemplateFilePathHostPath string `json:"podTemplateFilePathHostPath"` + // minimumTimeoutHostPath is the minimum ActiveDeadlineSeconds to use for a HostPath + // Recycler pod. This is for development and testing only and will not work in a multi-node + // cluster. + MinimumTimeoutHostPath int `json:"minimumTimeoutHostPath"` + // incrementTimeoutHostPath is the increment of time added per Gi to ActiveDeadlineSeconds + // for a HostPath scrubber pod. This is for development and testing only and will not work + // in a multi-node cluster. + IncrementTimeoutHostPath int `json:"incrementTimeoutHostPath"` +} From 33c4332b284c4618c8c8b7793219c78c6e403fab Mon Sep 17 00:00:00 2001 From: Mike Danese Date: Mon, 8 Feb 2016 13:36:12 -0800 Subject: [PATCH 2/2] autogenerated --- docs/admin/kube-controller-manager.md | 2 +- pkg/apis/componentconfig/types.generated.go | 8253 +++++++++++++++++++ 2 files changed, 8254 insertions(+), 1 deletion(-) create mode 100644 pkg/apis/componentconfig/types.generated.go diff --git a/docs/admin/kube-controller-manager.md b/docs/admin/kube-controller-manager.md index 3b346964635..4ff43178b4c 100644 --- a/docs/admin/kube-controller-manager.md +++ b/docs/admin/kube-controller-manager.md @@ -59,7 +59,7 @@ kube-controller-manager --allocate-node-cidrs[=false]: Should CIDRs for Pods be allocated and set on the cloud provider. --cloud-config="": The path to the cloud provider configuration file. Empty string for no configuration file. --cloud-provider="": The provider for cloud services. Empty string for no provider. - --cluster-cidr=: CIDR Range for Pods in cluster. + --cluster-cidr="": CIDR Range for Pods in cluster. --cluster-name="kubernetes": The instance prefix for the cluster --concurrent-deployment-syncs=5: The number of deployment objects that are allowed to sync concurrently. Larger number = more responsive deployments, but more CPU (and network) load --concurrent-endpoint-syncs=5: The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load diff --git a/pkg/apis/componentconfig/types.generated.go b/pkg/apis/componentconfig/types.generated.go new file mode 100644 index 00000000000..7249a67f48f --- /dev/null +++ b/pkg/apis/componentconfig/types.generated.go @@ -0,0 +1,8253 @@ +/* +Copyright 2015 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// ************************************************************ +// DO NOT EDIT. +// THIS FILE IS AUTO-GENERATED BY codecgen. +// ************************************************************ + +package componentconfig + +import ( + "errors" + "fmt" + codec1978 "github.com/ugorji/go/codec" + pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned" + "reflect" + "runtime" + time "time" +) + +const ( + // ----- content types ---- + codecSelferC_UTF81234 = 1 + codecSelferC_RAW1234 = 0 + // ----- value types used ---- + codecSelferValueTypeArray1234 = 10 + codecSelferValueTypeMap1234 = 9 + // ----- containerStateValues ---- + codecSelfer_containerMapKey1234 = 2 + codecSelfer_containerMapValue1234 = 3 + codecSelfer_containerMapEnd1234 = 4 + codecSelfer_containerArrayElem1234 = 6 + codecSelfer_containerArrayEnd1234 = 7 +) + +var ( + codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits()) + codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`) +) + +type codecSelfer1234 struct{} + +func init() { + if codec1978.GenVersion != 5 { + _, file, _, _ := runtime.Caller(0) + err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v", + 5, codec1978.GenVersion, file) + panic(err) + } + if false { // reference the types, but skip this branch at build/run time + var v0 pkg1_unversioned.TypeMeta + var v1 time.Duration + _, _ = v0, v1 + } +} + +func (x *KubeProxyConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [18]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + yyq2[16] = x.Kind != "" + yyq2[17] = x.APIVersion != "" + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(18) + } else { + yynn2 = 16 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.BindAddress)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("bindAddress")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.BindAddress)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym7 := z.EncBinary() + _ = yym7 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HealthzBindAddress)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("healthzBindAddress")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym8 := z.EncBinary() + _ = yym8 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HealthzBindAddress)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym10 := z.EncBinary() + _ = yym10 + if false { + } else { + r.EncodeInt(int64(x.HealthzPort)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("healthzPort")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym11 := z.EncBinary() + _ = yym11 + if false { + } else { + r.EncodeInt(int64(x.HealthzPort)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym13 := z.EncBinary() + _ = yym13 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostnameOverride)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("hostnameOverride")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym14 := z.EncBinary() + _ = yym14 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostnameOverride)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if x.IPTablesMasqueradeBit == nil { + r.EncodeNil() + } else { + yy16 := *x.IPTablesMasqueradeBit + yym17 := z.EncBinary() + _ = yym17 + if false { + } else { + r.EncodeInt(int64(yy16)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("iptablesMasqueradeBit")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.IPTablesMasqueradeBit == nil { + r.EncodeNil() + } else { + yy18 := *x.IPTablesMasqueradeBit + yym19 := z.EncBinary() + _ = yym19 + if false { + } else { + r.EncodeInt(int64(yy18)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy21 := &x.IPTablesSyncPeriod + yym22 := z.EncBinary() + _ = yym22 + if false { + } else if z.HasExtensions() && z.EncExt(yy21) { + } else if !yym22 && z.IsJSONHandle() { + z.EncJSONMarshal(yy21) + } else { + z.EncFallback(yy21) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("iptablesSyncPeriodSeconds")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy23 := &x.IPTablesSyncPeriod + yym24 := z.EncBinary() + _ = yym24 + if false { + } else if z.HasExtensions() && z.EncExt(yy23) { + } else if !yym24 && z.IsJSONHandle() { + z.EncJSONMarshal(yy23) + } else { + z.EncFallback(yy23) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym26 := z.EncBinary() + _ = yym26 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.KubeconfigPath)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeconfigPath")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym27 := z.EncBinary() + _ = yym27 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.KubeconfigPath)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym29 := z.EncBinary() + _ = yym29 + if false { + } else { + r.EncodeBool(bool(x.MasqueradeAll)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("masqueradeAll")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym30 := z.EncBinary() + _ = yym30 + if false { + } else { + r.EncodeBool(bool(x.MasqueradeAll)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym32 := z.EncBinary() + _ = yym32 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Master)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("master")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym33 := z.EncBinary() + _ = yym33 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Master)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if x.OOMScoreAdj == nil { + r.EncodeNil() + } else { + yy35 := *x.OOMScoreAdj + yym36 := z.EncBinary() + _ = yym36 + if false { + } else { + r.EncodeInt(int64(yy35)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("oomScoreAdj")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.OOMScoreAdj == nil { + r.EncodeNil() + } else { + yy37 := *x.OOMScoreAdj + yym38 := z.EncBinary() + _ = yym38 + if false { + } else { + r.EncodeInt(int64(yy37)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + x.Mode.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("mode")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + x.Mode.CodecEncodeSelf(e) + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym41 := z.EncBinary() + _ = yym41 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PortRange)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("portRange")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym42 := z.EncBinary() + _ = yym42 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PortRange)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym44 := z.EncBinary() + _ = yym44 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ResourceContainer)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeletCgroups")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym45 := z.EncBinary() + _ = yym45 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ResourceContainer)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy47 := &x.UDPIdleTimeout + yym48 := z.EncBinary() + _ = yym48 + if false { + } else if z.HasExtensions() && z.EncExt(yy47) { + } else if !yym48 && z.IsJSONHandle() { + z.EncJSONMarshal(yy47) + } else { + z.EncFallback(yy47) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("udpTimeoutMilliseconds")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy49 := &x.UDPIdleTimeout + yym50 := z.EncBinary() + _ = yym50 + if false { + } else if z.HasExtensions() && z.EncExt(yy49) { + } else if !yym50 && z.IsJSONHandle() { + z.EncJSONMarshal(yy49) + } else { + z.EncFallback(yy49) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym52 := z.EncBinary() + _ = yym52 + if false { + } else { + r.EncodeInt(int64(x.ConntrackMax)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("conntrackMax")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym53 := z.EncBinary() + _ = yym53 + if false { + } else { + r.EncodeInt(int64(x.ConntrackMax)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy55 := &x.ConntrackTCPEstablishedTimeout + yym56 := z.EncBinary() + _ = yym56 + if false { + } else if z.HasExtensions() && z.EncExt(yy55) { + } else if !yym56 && z.IsJSONHandle() { + z.EncJSONMarshal(yy55) + } else { + z.EncFallback(yy55) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("conntrackTCPEstablishedTimeout")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy57 := &x.ConntrackTCPEstablishedTimeout + yym58 := z.EncBinary() + _ = yym58 + if false { + } else if z.HasExtensions() && z.EncExt(yy57) { + } else if !yym58 && z.IsJSONHandle() { + z.EncJSONMarshal(yy57) + } else { + z.EncFallback(yy57) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2[16] { + yym60 := z.EncBinary() + _ = yym60 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq2[16] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kind")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym61 := z.EncBinary() + _ = yym61 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2[17] { + yym63 := z.EncBinary() + _ = yym63 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq2[17] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym64 := z.EncBinary() + _ = yym64 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *KubeProxyConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym65 := z.DecBinary() + _ = yym65 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct66 := r.ContainerType() + if yyct66 == codecSelferValueTypeMap1234 { + yyl66 := r.ReadMapStart() + if yyl66 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl66, d) + } + } else if yyct66 == codecSelferValueTypeArray1234 { + yyl66 := r.ReadArrayStart() + if yyl66 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl66, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *KubeProxyConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys67Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys67Slc + var yyhl67 bool = l >= 0 + for yyj67 := 0; ; yyj67++ { + if yyhl67 { + if yyj67 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys67Slc = r.DecodeBytes(yys67Slc, true, true) + yys67 := string(yys67Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys67 { + case "bindAddress": + if r.TryDecodeAsNil() { + x.BindAddress = "" + } else { + x.BindAddress = string(r.DecodeString()) + } + case "healthzBindAddress": + if r.TryDecodeAsNil() { + x.HealthzBindAddress = "" + } else { + x.HealthzBindAddress = string(r.DecodeString()) + } + case "healthzPort": + if r.TryDecodeAsNil() { + x.HealthzPort = 0 + } else { + x.HealthzPort = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "hostnameOverride": + if r.TryDecodeAsNil() { + x.HostnameOverride = "" + } else { + x.HostnameOverride = string(r.DecodeString()) + } + case "iptablesMasqueradeBit": + if r.TryDecodeAsNil() { + if x.IPTablesMasqueradeBit != nil { + x.IPTablesMasqueradeBit = nil + } + } else { + if x.IPTablesMasqueradeBit == nil { + x.IPTablesMasqueradeBit = new(int) + } + yym73 := z.DecBinary() + _ = yym73 + if false { + } else { + *((*int)(x.IPTablesMasqueradeBit)) = int(r.DecodeInt(codecSelferBitsize1234)) + } + } + case "iptablesSyncPeriodSeconds": + if r.TryDecodeAsNil() { + x.IPTablesSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv74 := &x.IPTablesSyncPeriod + yym75 := z.DecBinary() + _ = yym75 + if false { + } else if z.HasExtensions() && z.DecExt(yyv74) { + } else if !yym75 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv74) + } else { + z.DecFallback(yyv74, false) + } + } + case "kubeconfigPath": + if r.TryDecodeAsNil() { + x.KubeconfigPath = "" + } else { + x.KubeconfigPath = string(r.DecodeString()) + } + case "masqueradeAll": + if r.TryDecodeAsNil() { + x.MasqueradeAll = false + } else { + x.MasqueradeAll = bool(r.DecodeBool()) + } + case "master": + if r.TryDecodeAsNil() { + x.Master = "" + } else { + x.Master = string(r.DecodeString()) + } + case "oomScoreAdj": + if r.TryDecodeAsNil() { + if x.OOMScoreAdj != nil { + x.OOMScoreAdj = nil + } + } else { + if x.OOMScoreAdj == nil { + x.OOMScoreAdj = new(int) + } + yym80 := z.DecBinary() + _ = yym80 + if false { + } else { + *((*int)(x.OOMScoreAdj)) = int(r.DecodeInt(codecSelferBitsize1234)) + } + } + case "mode": + if r.TryDecodeAsNil() { + x.Mode = "" + } else { + x.Mode = ProxyMode(r.DecodeString()) + } + case "portRange": + if r.TryDecodeAsNil() { + x.PortRange = "" + } else { + x.PortRange = string(r.DecodeString()) + } + case "kubeletCgroups": + if r.TryDecodeAsNil() { + x.ResourceContainer = "" + } else { + x.ResourceContainer = string(r.DecodeString()) + } + case "udpTimeoutMilliseconds": + if r.TryDecodeAsNil() { + x.UDPIdleTimeout = pkg1_unversioned.Duration{} + } else { + yyv84 := &x.UDPIdleTimeout + yym85 := z.DecBinary() + _ = yym85 + if false { + } else if z.HasExtensions() && z.DecExt(yyv84) { + } else if !yym85 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv84) + } else { + z.DecFallback(yyv84, false) + } + } + case "conntrackMax": + if r.TryDecodeAsNil() { + x.ConntrackMax = 0 + } else { + x.ConntrackMax = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "conntrackTCPEstablishedTimeout": + if r.TryDecodeAsNil() { + x.ConntrackTCPEstablishedTimeout = pkg1_unversioned.Duration{} + } else { + yyv87 := &x.ConntrackTCPEstablishedTimeout + yym88 := z.DecBinary() + _ = yym88 + if false { + } else if z.HasExtensions() && z.DecExt(yyv87) { + } else if !yym88 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv87) + } else { + z.DecFallback(yyv87, false) + } + } + case "kind": + if r.TryDecodeAsNil() { + x.Kind = "" + } else { + x.Kind = string(r.DecodeString()) + } + case "apiVersion": + if r.TryDecodeAsNil() { + x.APIVersion = "" + } else { + x.APIVersion = string(r.DecodeString()) + } + default: + z.DecStructFieldNotFound(-1, yys67) + } // end switch yys67 + } // end for yyj67 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *KubeProxyConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj91 int + var yyb91 bool + var yyhl91 bool = l >= 0 + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.BindAddress = "" + } else { + x.BindAddress = string(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HealthzBindAddress = "" + } else { + x.HealthzBindAddress = string(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HealthzPort = 0 + } else { + x.HealthzPort = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HostnameOverride = "" + } else { + x.HostnameOverride = string(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + if x.IPTablesMasqueradeBit != nil { + x.IPTablesMasqueradeBit = nil + } + } else { + if x.IPTablesMasqueradeBit == nil { + x.IPTablesMasqueradeBit = new(int) + } + yym97 := z.DecBinary() + _ = yym97 + if false { + } else { + *((*int)(x.IPTablesMasqueradeBit)) = int(r.DecodeInt(codecSelferBitsize1234)) + } + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.IPTablesSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv98 := &x.IPTablesSyncPeriod + yym99 := z.DecBinary() + _ = yym99 + if false { + } else if z.HasExtensions() && z.DecExt(yyv98) { + } else if !yym99 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv98) + } else { + z.DecFallback(yyv98, false) + } + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.KubeconfigPath = "" + } else { + x.KubeconfigPath = string(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MasqueradeAll = false + } else { + x.MasqueradeAll = bool(r.DecodeBool()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Master = "" + } else { + x.Master = string(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + if x.OOMScoreAdj != nil { + x.OOMScoreAdj = nil + } + } else { + if x.OOMScoreAdj == nil { + x.OOMScoreAdj = new(int) + } + yym104 := z.DecBinary() + _ = yym104 + if false { + } else { + *((*int)(x.OOMScoreAdj)) = int(r.DecodeInt(codecSelferBitsize1234)) + } + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Mode = "" + } else { + x.Mode = ProxyMode(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PortRange = "" + } else { + x.PortRange = string(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ResourceContainer = "" + } else { + x.ResourceContainer = string(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.UDPIdleTimeout = pkg1_unversioned.Duration{} + } else { + yyv108 := &x.UDPIdleTimeout + yym109 := z.DecBinary() + _ = yym109 + if false { + } else if z.HasExtensions() && z.DecExt(yyv108) { + } else if !yym109 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv108) + } else { + z.DecFallback(yyv108, false) + } + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConntrackMax = 0 + } else { + x.ConntrackMax = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConntrackTCPEstablishedTimeout = pkg1_unversioned.Duration{} + } else { + yyv111 := &x.ConntrackTCPEstablishedTimeout + yym112 := z.DecBinary() + _ = yym112 + if false { + } else if z.HasExtensions() && z.DecExt(yyv111) { + } else if !yym112 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv111) + } else { + z.DecFallback(yyv111, false) + } + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Kind = "" + } else { + x.Kind = string(r.DecodeString()) + } + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.APIVersion = "" + } else { + x.APIVersion = string(r.DecodeString()) + } + for { + yyj91++ + if yyhl91 { + yyb91 = yyj91 > l + } else { + yyb91 = r.CheckBreak() + } + if yyb91 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj91-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x ProxyMode) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + yym115 := z.EncBinary() + _ = yym115 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x)) + } +} + +func (x *ProxyMode) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym116 := z.DecBinary() + _ = yym116 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + *((*string)(x)) = r.DecodeString() + } +} + +func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym117 := z.EncBinary() + _ = yym117 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep118 := !z.EncBinary() + yy2arr118 := z.EncBasicHandle().StructToArray + var yyq118 [76]bool + _, _, _ = yysep118, yyq118, yy2arr118 + const yyr118 bool = false + yyq118[46] = x.CloudProvider != "" + yyq118[47] = x.CloudConfigFile != "" + yyq118[48] = x.KubeletCgroups != "" + yyq118[49] = x.RuntimeCgroups != "" + yyq118[50] = x.SystemCgroups != "" + yyq118[51] = x.CgroupRoot != "" + yyq118[53] = x.RktPath != "" + yyq118[55] = x.RktStage1Image != "" + yyq118[71] = true + yyq118[72] = x.NodeIP != "" + var yynn118 int + if yyr118 || yy2arr118 { + r.EncodeArrayStart(76) + } else { + yynn118 = 66 + for _, b := range yyq118 { + if b { + yynn118++ + } + } + r.EncodeMapStart(yynn118) + yynn118 = 0 + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym120 := z.EncBinary() + _ = yym120 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Config)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("config")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym121 := z.EncBinary() + _ = yym121 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Config)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy123 := &x.SyncFrequency + yym124 := z.EncBinary() + _ = yym124 + if false { + } else if z.HasExtensions() && z.EncExt(yy123) { + } else if !yym124 && z.IsJSONHandle() { + z.EncJSONMarshal(yy123) + } else { + z.EncFallback(yy123) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("syncFrequency")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy125 := &x.SyncFrequency + yym126 := z.EncBinary() + _ = yym126 + if false { + } else if z.HasExtensions() && z.EncExt(yy125) { + } else if !yym126 && z.IsJSONHandle() { + z.EncJSONMarshal(yy125) + } else { + z.EncFallback(yy125) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy128 := &x.FileCheckFrequency + yym129 := z.EncBinary() + _ = yym129 + if false { + } else if z.HasExtensions() && z.EncExt(yy128) { + } else if !yym129 && z.IsJSONHandle() { + z.EncJSONMarshal(yy128) + } else { + z.EncFallback(yy128) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("fileCheckFrequency")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy130 := &x.FileCheckFrequency + yym131 := z.EncBinary() + _ = yym131 + if false { + } else if z.HasExtensions() && z.EncExt(yy130) { + } else if !yym131 && z.IsJSONHandle() { + z.EncJSONMarshal(yy130) + } else { + z.EncFallback(yy130) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy133 := &x.HTTPCheckFrequency + yym134 := z.EncBinary() + _ = yym134 + if false { + } else if z.HasExtensions() && z.EncExt(yy133) { + } else if !yym134 && z.IsJSONHandle() { + z.EncJSONMarshal(yy133) + } else { + z.EncFallback(yy133) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("httpCheckFrequency")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy135 := &x.HTTPCheckFrequency + yym136 := z.EncBinary() + _ = yym136 + if false { + } else if z.HasExtensions() && z.EncExt(yy135) { + } else if !yym136 && z.IsJSONHandle() { + z.EncJSONMarshal(yy135) + } else { + z.EncFallback(yy135) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym138 := z.EncBinary() + _ = yym138 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ManifestURL)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("manifestURL")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym139 := z.EncBinary() + _ = yym139 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ManifestURL)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym141 := z.EncBinary() + _ = yym141 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ManifestURLHeader)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("manifestURLHeader")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym142 := z.EncBinary() + _ = yym142 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ManifestURLHeader)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym144 := z.EncBinary() + _ = yym144 + if false { + } else { + r.EncodeBool(bool(x.EnableServer)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("enableServer")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym145 := z.EncBinary() + _ = yym145 + if false { + } else { + r.EncodeBool(bool(x.EnableServer)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym147 := z.EncBinary() + _ = yym147 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Address)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("address")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym148 := z.EncBinary() + _ = yym148 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Address)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym150 := z.EncBinary() + _ = yym150 + if false { + } else { + r.EncodeUint(uint64(x.Port)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("port")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym151 := z.EncBinary() + _ = yym151 + if false { + } else { + r.EncodeUint(uint64(x.Port)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym153 := z.EncBinary() + _ = yym153 + if false { + } else { + r.EncodeUint(uint64(x.ReadOnlyPort)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("readOnlyPort")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym154 := z.EncBinary() + _ = yym154 + if false { + } else { + r.EncodeUint(uint64(x.ReadOnlyPort)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym156 := z.EncBinary() + _ = yym156 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.TLSCertFile)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("tLSCertFile")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym157 := z.EncBinary() + _ = yym157 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.TLSCertFile)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym159 := z.EncBinary() + _ = yym159 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.TLSPrivateKeyFile)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("tLSPrivateKeyFile")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym160 := z.EncBinary() + _ = yym160 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.TLSPrivateKeyFile)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym162 := z.EncBinary() + _ = yym162 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CertDirectory)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("certDirectory")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym163 := z.EncBinary() + _ = yym163 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CertDirectory)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym165 := z.EncBinary() + _ = yym165 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostnameOverride)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("hostnameOverride")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym166 := z.EncBinary() + _ = yym166 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostnameOverride)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym168 := z.EncBinary() + _ = yym168 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PodInfraContainerImage)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("podInfraContainerImage")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym169 := z.EncBinary() + _ = yym169 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PodInfraContainerImage)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym171 := z.EncBinary() + _ = yym171 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.DockerEndpoint)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("dockerEndpoint")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym172 := z.EncBinary() + _ = yym172 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.DockerEndpoint)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym174 := z.EncBinary() + _ = yym174 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RootDirectory)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("rootDirectory")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym175 := z.EncBinary() + _ = yym175 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RootDirectory)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym177 := z.EncBinary() + _ = yym177 + if false { + } else { + r.EncodeBool(bool(x.AllowPrivileged)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("allowPrivileged")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym178 := z.EncBinary() + _ = yym178 + if false { + } else { + r.EncodeBool(bool(x.AllowPrivileged)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym180 := z.EncBinary() + _ = yym180 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostNetworkSources)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("hostNetworkSources")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym181 := z.EncBinary() + _ = yym181 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostNetworkSources)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym183 := z.EncBinary() + _ = yym183 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostPIDSources)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("hostPIDSources")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym184 := z.EncBinary() + _ = yym184 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostPIDSources)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym186 := z.EncBinary() + _ = yym186 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostIPCSources)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("hostIPCSources")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym187 := z.EncBinary() + _ = yym187 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HostIPCSources)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym189 := z.EncBinary() + _ = yym189 + if false { + } else { + r.EncodeFloat64(float64(x.RegistryPullQPS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("registryPullQPS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym190 := z.EncBinary() + _ = yym190 + if false { + } else { + r.EncodeFloat64(float64(x.RegistryPullQPS)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym192 := z.EncBinary() + _ = yym192 + if false { + } else { + r.EncodeInt(int64(x.RegistryBurst)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("registryBurst")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym193 := z.EncBinary() + _ = yym193 + if false { + } else { + r.EncodeInt(int64(x.RegistryBurst)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym195 := z.EncBinary() + _ = yym195 + if false { + } else { + r.EncodeFloat32(float32(x.EventRecordQPS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("eventRecordQPS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym196 := z.EncBinary() + _ = yym196 + if false { + } else { + r.EncodeFloat32(float32(x.EventRecordQPS)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym198 := z.EncBinary() + _ = yym198 + if false { + } else { + r.EncodeInt(int64(x.EventBurst)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("eventBurst")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym199 := z.EncBinary() + _ = yym199 + if false { + } else { + r.EncodeInt(int64(x.EventBurst)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym201 := z.EncBinary() + _ = yym201 + if false { + } else { + r.EncodeBool(bool(x.EnableDebuggingHandlers)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("enableDebuggingHandlers")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym202 := z.EncBinary() + _ = yym202 + if false { + } else { + r.EncodeBool(bool(x.EnableDebuggingHandlers)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy204 := &x.MinimumGCAge + yym205 := z.EncBinary() + _ = yym205 + if false { + } else if z.HasExtensions() && z.EncExt(yy204) { + } else if !yym205 && z.IsJSONHandle() { + z.EncJSONMarshal(yy204) + } else { + z.EncFallback(yy204) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("minimumGCAge")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy206 := &x.MinimumGCAge + yym207 := z.EncBinary() + _ = yym207 + if false { + } else if z.HasExtensions() && z.EncExt(yy206) { + } else if !yym207 && z.IsJSONHandle() { + z.EncJSONMarshal(yy206) + } else { + z.EncFallback(yy206) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym209 := z.EncBinary() + _ = yym209 + if false { + } else { + r.EncodeInt(int64(x.MaxPerPodContainerCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("maxPerPodContainerCount")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym210 := z.EncBinary() + _ = yym210 + if false { + } else { + r.EncodeInt(int64(x.MaxPerPodContainerCount)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym212 := z.EncBinary() + _ = yym212 + if false { + } else { + r.EncodeInt(int64(x.MaxContainerCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("maxContainerCount")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym213 := z.EncBinary() + _ = yym213 + if false { + } else { + r.EncodeInt(int64(x.MaxContainerCount)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym215 := z.EncBinary() + _ = yym215 + if false { + } else { + r.EncodeUint(uint64(x.CAdvisorPort)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("cAdvisorPort")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym216 := z.EncBinary() + _ = yym216 + if false { + } else { + r.EncodeUint(uint64(x.CAdvisorPort)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym218 := z.EncBinary() + _ = yym218 + if false { + } else { + r.EncodeInt(int64(x.HealthzPort)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("healthzPort")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym219 := z.EncBinary() + _ = yym219 + if false { + } else { + r.EncodeInt(int64(x.HealthzPort)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym221 := z.EncBinary() + _ = yym221 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HealthzBindAddress)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("healthzBindAddress")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym222 := z.EncBinary() + _ = yym222 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.HealthzBindAddress)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym224 := z.EncBinary() + _ = yym224 + if false { + } else { + r.EncodeInt(int64(x.OOMScoreAdj)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("oomScoreAdj")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym225 := z.EncBinary() + _ = yym225 + if false { + } else { + r.EncodeInt(int64(x.OOMScoreAdj)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym227 := z.EncBinary() + _ = yym227 + if false { + } else { + r.EncodeBool(bool(x.RegisterNode)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("registerNode")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym228 := z.EncBinary() + _ = yym228 + if false { + } else { + r.EncodeBool(bool(x.RegisterNode)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym230 := z.EncBinary() + _ = yym230 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDomain)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("clusterDomain")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym231 := z.EncBinary() + _ = yym231 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDomain)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym233 := z.EncBinary() + _ = yym233 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.MasterServiceNamespace)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("masterServiceNamespace")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym234 := z.EncBinary() + _ = yym234 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.MasterServiceNamespace)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym236 := z.EncBinary() + _ = yym236 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDNS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("clusterDNS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym237 := z.EncBinary() + _ = yym237 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDNS)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy239 := &x.StreamingConnectionIdleTimeout + yym240 := z.EncBinary() + _ = yym240 + if false { + } else if z.HasExtensions() && z.EncExt(yy239) { + } else if !yym240 && z.IsJSONHandle() { + z.EncJSONMarshal(yy239) + } else { + z.EncFallback(yy239) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("streamingConnectionIdleTimeout")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy241 := &x.StreamingConnectionIdleTimeout + yym242 := z.EncBinary() + _ = yym242 + if false { + } else if z.HasExtensions() && z.EncExt(yy241) { + } else if !yym242 && z.IsJSONHandle() { + z.EncJSONMarshal(yy241) + } else { + z.EncFallback(yy241) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy244 := &x.NodeStatusUpdateFrequency + yym245 := z.EncBinary() + _ = yym245 + if false { + } else if z.HasExtensions() && z.EncExt(yy244) { + } else if !yym245 && z.IsJSONHandle() { + z.EncJSONMarshal(yy244) + } else { + z.EncFallback(yy244) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeStatusUpdateFrequency")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy246 := &x.NodeStatusUpdateFrequency + yym247 := z.EncBinary() + _ = yym247 + if false { + } else if z.HasExtensions() && z.EncExt(yy246) { + } else if !yym247 && z.IsJSONHandle() { + z.EncJSONMarshal(yy246) + } else { + z.EncFallback(yy246) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym249 := z.EncBinary() + _ = yym249 + if false { + } else { + r.EncodeInt(int64(x.ImageGCHighThresholdPercent)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("imageGCHighThresholdPercent")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym250 := z.EncBinary() + _ = yym250 + if false { + } else { + r.EncodeInt(int64(x.ImageGCHighThresholdPercent)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym252 := z.EncBinary() + _ = yym252 + if false { + } else { + r.EncodeInt(int64(x.ImageGCLowThresholdPercent)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("imageGCLowThresholdPercent")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym253 := z.EncBinary() + _ = yym253 + if false { + } else { + r.EncodeInt(int64(x.ImageGCLowThresholdPercent)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym255 := z.EncBinary() + _ = yym255 + if false { + } else { + r.EncodeInt(int64(x.LowDiskSpaceThresholdMB)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("lowDiskSpaceThresholdMB")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym256 := z.EncBinary() + _ = yym256 + if false { + } else { + r.EncodeInt(int64(x.LowDiskSpaceThresholdMB)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy258 := &x.VolumeStatsAggPeriod + yym259 := z.EncBinary() + _ = yym259 + if false { + } else if z.HasExtensions() && z.EncExt(yy258) { + } else if !yym259 && z.IsJSONHandle() { + z.EncJSONMarshal(yy258) + } else { + z.EncFallback(yy258) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("VolumeStatsAggPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy260 := &x.VolumeStatsAggPeriod + yym261 := z.EncBinary() + _ = yym261 + if false { + } else if z.HasExtensions() && z.EncExt(yy260) { + } else if !yym261 && z.IsJSONHandle() { + z.EncJSONMarshal(yy260) + } else { + z.EncFallback(yy260) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym263 := z.EncBinary() + _ = yym263 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.NetworkPluginName)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("networkPluginName")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym264 := z.EncBinary() + _ = yym264 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.NetworkPluginName)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym266 := z.EncBinary() + _ = yym266 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.NetworkPluginDir)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("networkPluginDir")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym267 := z.EncBinary() + _ = yym267 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.NetworkPluginDir)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym269 := z.EncBinary() + _ = yym269 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.VolumePluginDir)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("volumePluginDir")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym270 := z.EncBinary() + _ = yym270 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.VolumePluginDir)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[46] { + yym272 := z.EncBinary() + _ = yym272 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CloudProvider)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[46] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("cloudProvider")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym273 := z.EncBinary() + _ = yym273 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CloudProvider)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[47] { + yym275 := z.EncBinary() + _ = yym275 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CloudConfigFile)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[47] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("cloudConfigFile")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym276 := z.EncBinary() + _ = yym276 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CloudConfigFile)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[48] { + yym278 := z.EncBinary() + _ = yym278 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.KubeletCgroups)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[48] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeletCgroups")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym279 := z.EncBinary() + _ = yym279 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.KubeletCgroups)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[49] { + yym281 := z.EncBinary() + _ = yym281 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RuntimeCgroups)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[49] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("runtimeCgroups")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym282 := z.EncBinary() + _ = yym282 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RuntimeCgroups)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[50] { + yym284 := z.EncBinary() + _ = yym284 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.SystemCgroups)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[50] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("systemContainer")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym285 := z.EncBinary() + _ = yym285 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.SystemCgroups)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[51] { + yym287 := z.EncBinary() + _ = yym287 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CgroupRoot)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[51] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("cgroupRoot")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym288 := z.EncBinary() + _ = yym288 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CgroupRoot)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym290 := z.EncBinary() + _ = yym290 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ContainerRuntime)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("containerRuntime")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym291 := z.EncBinary() + _ = yym291 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ContainerRuntime)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[53] { + yym293 := z.EncBinary() + _ = yym293 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RktPath)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[53] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("rktPath")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym294 := z.EncBinary() + _ = yym294 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RktPath)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym296 := z.EncBinary() + _ = yym296 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.LockFilePath)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("lockFilePath")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym297 := z.EncBinary() + _ = yym297 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.LockFilePath)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[55] { + yym299 := z.EncBinary() + _ = yym299 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RktStage1Image)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[55] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("rktStage1Image")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym300 := z.EncBinary() + _ = yym300 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RktStage1Image)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym302 := z.EncBinary() + _ = yym302 + if false { + } else { + r.EncodeBool(bool(x.ConfigureCBR0)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("configureCbr0")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym303 := z.EncBinary() + _ = yym303 + if false { + } else { + r.EncodeBool(bool(x.ConfigureCBR0)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym305 := z.EncBinary() + _ = yym305 + if false { + } else { + r.EncodeBool(bool(x.HairpinMode)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("configureHairpinMode")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym306 := z.EncBinary() + _ = yym306 + if false { + } else { + r.EncodeBool(bool(x.HairpinMode)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym308 := z.EncBinary() + _ = yym308 + if false { + } else { + r.EncodeInt(int64(x.MaxPods)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("maxPods")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym309 := z.EncBinary() + _ = yym309 + if false { + } else { + r.EncodeInt(int64(x.MaxPods)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym311 := z.EncBinary() + _ = yym311 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.DockerExecHandlerName)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("dockerExecHandlerName")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym312 := z.EncBinary() + _ = yym312 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.DockerExecHandlerName)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym314 := z.EncBinary() + _ = yym314 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("podCIDR")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym315 := z.EncBinary() + _ = yym315 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym317 := z.EncBinary() + _ = yym317 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ResolverConfig)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("resolvConf")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym318 := z.EncBinary() + _ = yym318 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ResolverConfig)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym320 := z.EncBinary() + _ = yym320 + if false { + } else { + r.EncodeBool(bool(x.CPUCFSQuota)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("cpuCFSQuota")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym321 := z.EncBinary() + _ = yym321 + if false { + } else { + r.EncodeBool(bool(x.CPUCFSQuota)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym323 := z.EncBinary() + _ = yym323 + if false { + } else { + r.EncodeBool(bool(x.Containerized)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("containerized")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym324 := z.EncBinary() + _ = yym324 + if false { + } else { + r.EncodeBool(bool(x.Containerized)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym326 := z.EncBinary() + _ = yym326 + if false { + } else { + r.EncodeUint(uint64(x.MaxOpenFiles)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("maxOpenFiles")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym327 := z.EncBinary() + _ = yym327 + if false { + } else { + r.EncodeUint(uint64(x.MaxOpenFiles)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym329 := z.EncBinary() + _ = yym329 + if false { + } else { + r.EncodeBool(bool(x.ReconcileCIDR)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("reconcileCIDR")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym330 := z.EncBinary() + _ = yym330 + if false { + } else { + r.EncodeBool(bool(x.ReconcileCIDR)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym332 := z.EncBinary() + _ = yym332 + if false { + } else { + r.EncodeBool(bool(x.RegisterSchedulable)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("registerSchedulable")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym333 := z.EncBinary() + _ = yym333 + if false { + } else { + r.EncodeBool(bool(x.RegisterSchedulable)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym335 := z.EncBinary() + _ = yym335 + if false { + } else { + r.EncodeFloat32(float32(x.KubeAPIQPS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym336 := z.EncBinary() + _ = yym336 + if false { + } else { + r.EncodeFloat32(float32(x.KubeAPIQPS)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym338 := z.EncBinary() + _ = yym338 + if false { + } else { + r.EncodeInt(int64(x.KubeAPIBurst)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym339 := z.EncBinary() + _ = yym339 + if false { + } else { + r.EncodeInt(int64(x.KubeAPIBurst)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym341 := z.EncBinary() + _ = yym341 + if false { + } else { + r.EncodeBool(bool(x.SerializeImagePulls)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("serializeImagePulls")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym342 := z.EncBinary() + _ = yym342 + if false { + } else { + r.EncodeBool(bool(x.SerializeImagePulls)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym344 := z.EncBinary() + _ = yym344 + if false { + } else { + r.EncodeBool(bool(x.ExperimentalFlannelOverlay)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("experimentalFlannelOverlay")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym345 := z.EncBinary() + _ = yym345 + if false { + } else { + r.EncodeBool(bool(x.ExperimentalFlannelOverlay)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[71] { + yy347 := &x.OutOfDiskTransitionFrequency + yym348 := z.EncBinary() + _ = yym348 + if false { + } else if z.HasExtensions() && z.EncExt(yy347) { + } else if !yym348 && z.IsJSONHandle() { + z.EncJSONMarshal(yy347) + } else { + z.EncFallback(yy347) + } + } else { + r.EncodeNil() + } + } else { + if yyq118[71] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("outOfDiskTransitionFrequency")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy349 := &x.OutOfDiskTransitionFrequency + yym350 := z.EncBinary() + _ = yym350 + if false { + } else if z.HasExtensions() && z.EncExt(yy349) { + } else if !yym350 && z.IsJSONHandle() { + z.EncJSONMarshal(yy349) + } else { + z.EncFallback(yy349) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq118[72] { + yym352 := z.EncBinary() + _ = yym352 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.NodeIP)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq118[72] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeIP")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym353 := z.EncBinary() + _ = yym353 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.NodeIP)) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if x.NodeLabels == nil { + r.EncodeNil() + } else { + yym355 := z.EncBinary() + _ = yym355 + if false { + } else { + z.F.EncMapStringStringV(x.NodeLabels, false, e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeLabels")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.NodeLabels == nil { + r.EncodeNil() + } else { + yym356 := z.EncBinary() + _ = yym356 + if false { + } else { + z.F.EncMapStringStringV(x.NodeLabels, false, e) + } + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym358 := z.EncBinary() + _ = yym358 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.NonMasqueradeCIDR)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nonMasqueradeCIDR")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym359 := z.EncBinary() + _ = yym359 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.NonMasqueradeCIDR)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym361 := z.EncBinary() + _ = yym361 + if false { + } else { + r.EncodeBool(bool(x.EnableCustomMetrics)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("enableCustomMetrics")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym362 := z.EncBinary() + _ = yym362 + if false { + } else { + r.EncodeBool(bool(x.EnableCustomMetrics)) + } + } + if yyr118 || yy2arr118 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *KubeletConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym363 := z.DecBinary() + _ = yym363 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct364 := r.ContainerType() + if yyct364 == codecSelferValueTypeMap1234 { + yyl364 := r.ReadMapStart() + if yyl364 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl364, d) + } + } else if yyct364 == codecSelferValueTypeArray1234 { + yyl364 := r.ReadArrayStart() + if yyl364 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl364, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys365Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys365Slc + var yyhl365 bool = l >= 0 + for yyj365 := 0; ; yyj365++ { + if yyhl365 { + if yyj365 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys365Slc = r.DecodeBytes(yys365Slc, true, true) + yys365 := string(yys365Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys365 { + case "config": + if r.TryDecodeAsNil() { + x.Config = "" + } else { + x.Config = string(r.DecodeString()) + } + case "syncFrequency": + if r.TryDecodeAsNil() { + x.SyncFrequency = pkg1_unversioned.Duration{} + } else { + yyv367 := &x.SyncFrequency + yym368 := z.DecBinary() + _ = yym368 + if false { + } else if z.HasExtensions() && z.DecExt(yyv367) { + } else if !yym368 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv367) + } else { + z.DecFallback(yyv367, false) + } + } + case "fileCheckFrequency": + if r.TryDecodeAsNil() { + x.FileCheckFrequency = pkg1_unversioned.Duration{} + } else { + yyv369 := &x.FileCheckFrequency + yym370 := z.DecBinary() + _ = yym370 + if false { + } else if z.HasExtensions() && z.DecExt(yyv369) { + } else if !yym370 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv369) + } else { + z.DecFallback(yyv369, false) + } + } + case "httpCheckFrequency": + if r.TryDecodeAsNil() { + x.HTTPCheckFrequency = pkg1_unversioned.Duration{} + } else { + yyv371 := &x.HTTPCheckFrequency + yym372 := z.DecBinary() + _ = yym372 + if false { + } else if z.HasExtensions() && z.DecExt(yyv371) { + } else if !yym372 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv371) + } else { + z.DecFallback(yyv371, false) + } + } + case "manifestURL": + if r.TryDecodeAsNil() { + x.ManifestURL = "" + } else { + x.ManifestURL = string(r.DecodeString()) + } + case "manifestURLHeader": + if r.TryDecodeAsNil() { + x.ManifestURLHeader = "" + } else { + x.ManifestURLHeader = string(r.DecodeString()) + } + case "enableServer": + if r.TryDecodeAsNil() { + x.EnableServer = false + } else { + x.EnableServer = bool(r.DecodeBool()) + } + case "address": + if r.TryDecodeAsNil() { + x.Address = "" + } else { + x.Address = string(r.DecodeString()) + } + case "port": + if r.TryDecodeAsNil() { + x.Port = 0 + } else { + x.Port = uint(r.DecodeUint(codecSelferBitsize1234)) + } + case "readOnlyPort": + if r.TryDecodeAsNil() { + x.ReadOnlyPort = 0 + } else { + x.ReadOnlyPort = uint(r.DecodeUint(codecSelferBitsize1234)) + } + case "tLSCertFile": + if r.TryDecodeAsNil() { + x.TLSCertFile = "" + } else { + x.TLSCertFile = string(r.DecodeString()) + } + case "tLSPrivateKeyFile": + if r.TryDecodeAsNil() { + x.TLSPrivateKeyFile = "" + } else { + x.TLSPrivateKeyFile = string(r.DecodeString()) + } + case "certDirectory": + if r.TryDecodeAsNil() { + x.CertDirectory = "" + } else { + x.CertDirectory = string(r.DecodeString()) + } + case "hostnameOverride": + if r.TryDecodeAsNil() { + x.HostnameOverride = "" + } else { + x.HostnameOverride = string(r.DecodeString()) + } + case "podInfraContainerImage": + if r.TryDecodeAsNil() { + x.PodInfraContainerImage = "" + } else { + x.PodInfraContainerImage = string(r.DecodeString()) + } + case "dockerEndpoint": + if r.TryDecodeAsNil() { + x.DockerEndpoint = "" + } else { + x.DockerEndpoint = string(r.DecodeString()) + } + case "rootDirectory": + if r.TryDecodeAsNil() { + x.RootDirectory = "" + } else { + x.RootDirectory = string(r.DecodeString()) + } + case "allowPrivileged": + if r.TryDecodeAsNil() { + x.AllowPrivileged = false + } else { + x.AllowPrivileged = bool(r.DecodeBool()) + } + case "hostNetworkSources": + if r.TryDecodeAsNil() { + x.HostNetworkSources = "" + } else { + x.HostNetworkSources = string(r.DecodeString()) + } + case "hostPIDSources": + if r.TryDecodeAsNil() { + x.HostPIDSources = "" + } else { + x.HostPIDSources = string(r.DecodeString()) + } + case "hostIPCSources": + if r.TryDecodeAsNil() { + x.HostIPCSources = "" + } else { + x.HostIPCSources = string(r.DecodeString()) + } + case "registryPullQPS": + if r.TryDecodeAsNil() { + x.RegistryPullQPS = 0 + } else { + x.RegistryPullQPS = float64(r.DecodeFloat(false)) + } + case "registryBurst": + if r.TryDecodeAsNil() { + x.RegistryBurst = 0 + } else { + x.RegistryBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "eventRecordQPS": + if r.TryDecodeAsNil() { + x.EventRecordQPS = 0 + } else { + x.EventRecordQPS = float32(r.DecodeFloat(true)) + } + case "eventBurst": + if r.TryDecodeAsNil() { + x.EventBurst = 0 + } else { + x.EventBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "enableDebuggingHandlers": + if r.TryDecodeAsNil() { + x.EnableDebuggingHandlers = false + } else { + x.EnableDebuggingHandlers = bool(r.DecodeBool()) + } + case "minimumGCAge": + if r.TryDecodeAsNil() { + x.MinimumGCAge = pkg1_unversioned.Duration{} + } else { + yyv395 := &x.MinimumGCAge + yym396 := z.DecBinary() + _ = yym396 + if false { + } else if z.HasExtensions() && z.DecExt(yyv395) { + } else if !yym396 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv395) + } else { + z.DecFallback(yyv395, false) + } + } + case "maxPerPodContainerCount": + if r.TryDecodeAsNil() { + x.MaxPerPodContainerCount = 0 + } else { + x.MaxPerPodContainerCount = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "maxContainerCount": + if r.TryDecodeAsNil() { + x.MaxContainerCount = 0 + } else { + x.MaxContainerCount = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "cAdvisorPort": + if r.TryDecodeAsNil() { + x.CAdvisorPort = 0 + } else { + x.CAdvisorPort = uint(r.DecodeUint(codecSelferBitsize1234)) + } + case "healthzPort": + if r.TryDecodeAsNil() { + x.HealthzPort = 0 + } else { + x.HealthzPort = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "healthzBindAddress": + if r.TryDecodeAsNil() { + x.HealthzBindAddress = "" + } else { + x.HealthzBindAddress = string(r.DecodeString()) + } + case "oomScoreAdj": + if r.TryDecodeAsNil() { + x.OOMScoreAdj = 0 + } else { + x.OOMScoreAdj = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "registerNode": + if r.TryDecodeAsNil() { + x.RegisterNode = false + } else { + x.RegisterNode = bool(r.DecodeBool()) + } + case "clusterDomain": + if r.TryDecodeAsNil() { + x.ClusterDomain = "" + } else { + x.ClusterDomain = string(r.DecodeString()) + } + case "masterServiceNamespace": + if r.TryDecodeAsNil() { + x.MasterServiceNamespace = "" + } else { + x.MasterServiceNamespace = string(r.DecodeString()) + } + case "clusterDNS": + if r.TryDecodeAsNil() { + x.ClusterDNS = "" + } else { + x.ClusterDNS = string(r.DecodeString()) + } + case "streamingConnectionIdleTimeout": + if r.TryDecodeAsNil() { + x.StreamingConnectionIdleTimeout = pkg1_unversioned.Duration{} + } else { + yyv407 := &x.StreamingConnectionIdleTimeout + yym408 := z.DecBinary() + _ = yym408 + if false { + } else if z.HasExtensions() && z.DecExt(yyv407) { + } else if !yym408 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv407) + } else { + z.DecFallback(yyv407, false) + } + } + case "nodeStatusUpdateFrequency": + if r.TryDecodeAsNil() { + x.NodeStatusUpdateFrequency = pkg1_unversioned.Duration{} + } else { + yyv409 := &x.NodeStatusUpdateFrequency + yym410 := z.DecBinary() + _ = yym410 + if false { + } else if z.HasExtensions() && z.DecExt(yyv409) { + } else if !yym410 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv409) + } else { + z.DecFallback(yyv409, false) + } + } + case "imageGCHighThresholdPercent": + if r.TryDecodeAsNil() { + x.ImageGCHighThresholdPercent = 0 + } else { + x.ImageGCHighThresholdPercent = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "imageGCLowThresholdPercent": + if r.TryDecodeAsNil() { + x.ImageGCLowThresholdPercent = 0 + } else { + x.ImageGCLowThresholdPercent = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "lowDiskSpaceThresholdMB": + if r.TryDecodeAsNil() { + x.LowDiskSpaceThresholdMB = 0 + } else { + x.LowDiskSpaceThresholdMB = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "VolumeStatsAggPeriod": + if r.TryDecodeAsNil() { + x.VolumeStatsAggPeriod = pkg1_unversioned.Duration{} + } else { + yyv414 := &x.VolumeStatsAggPeriod + yym415 := z.DecBinary() + _ = yym415 + if false { + } else if z.HasExtensions() && z.DecExt(yyv414) { + } else if !yym415 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv414) + } else { + z.DecFallback(yyv414, false) + } + } + case "networkPluginName": + if r.TryDecodeAsNil() { + x.NetworkPluginName = "" + } else { + x.NetworkPluginName = string(r.DecodeString()) + } + case "networkPluginDir": + if r.TryDecodeAsNil() { + x.NetworkPluginDir = "" + } else { + x.NetworkPluginDir = string(r.DecodeString()) + } + case "volumePluginDir": + if r.TryDecodeAsNil() { + x.VolumePluginDir = "" + } else { + x.VolumePluginDir = string(r.DecodeString()) + } + case "cloudProvider": + if r.TryDecodeAsNil() { + x.CloudProvider = "" + } else { + x.CloudProvider = string(r.DecodeString()) + } + case "cloudConfigFile": + if r.TryDecodeAsNil() { + x.CloudConfigFile = "" + } else { + x.CloudConfigFile = string(r.DecodeString()) + } + case "kubeletCgroups": + if r.TryDecodeAsNil() { + x.KubeletCgroups = "" + } else { + x.KubeletCgroups = string(r.DecodeString()) + } + case "runtimeCgroups": + if r.TryDecodeAsNil() { + x.RuntimeCgroups = "" + } else { + x.RuntimeCgroups = string(r.DecodeString()) + } + case "systemContainer": + if r.TryDecodeAsNil() { + x.SystemCgroups = "" + } else { + x.SystemCgroups = string(r.DecodeString()) + } + case "cgroupRoot": + if r.TryDecodeAsNil() { + x.CgroupRoot = "" + } else { + x.CgroupRoot = string(r.DecodeString()) + } + case "containerRuntime": + if r.TryDecodeAsNil() { + x.ContainerRuntime = "" + } else { + x.ContainerRuntime = string(r.DecodeString()) + } + case "rktPath": + if r.TryDecodeAsNil() { + x.RktPath = "" + } else { + x.RktPath = string(r.DecodeString()) + } + case "lockFilePath": + if r.TryDecodeAsNil() { + x.LockFilePath = "" + } else { + x.LockFilePath = string(r.DecodeString()) + } + case "rktStage1Image": + if r.TryDecodeAsNil() { + x.RktStage1Image = "" + } else { + x.RktStage1Image = string(r.DecodeString()) + } + case "configureCbr0": + if r.TryDecodeAsNil() { + x.ConfigureCBR0 = false + } else { + x.ConfigureCBR0 = bool(r.DecodeBool()) + } + case "configureHairpinMode": + if r.TryDecodeAsNil() { + x.HairpinMode = false + } else { + x.HairpinMode = bool(r.DecodeBool()) + } + case "maxPods": + if r.TryDecodeAsNil() { + x.MaxPods = 0 + } else { + x.MaxPods = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "dockerExecHandlerName": + if r.TryDecodeAsNil() { + x.DockerExecHandlerName = "" + } else { + x.DockerExecHandlerName = string(r.DecodeString()) + } + case "podCIDR": + if r.TryDecodeAsNil() { + x.PodCIDR = "" + } else { + x.PodCIDR = string(r.DecodeString()) + } + case "resolvConf": + if r.TryDecodeAsNil() { + x.ResolverConfig = "" + } else { + x.ResolverConfig = string(r.DecodeString()) + } + case "cpuCFSQuota": + if r.TryDecodeAsNil() { + x.CPUCFSQuota = false + } else { + x.CPUCFSQuota = bool(r.DecodeBool()) + } + case "containerized": + if r.TryDecodeAsNil() { + x.Containerized = false + } else { + x.Containerized = bool(r.DecodeBool()) + } + case "maxOpenFiles": + if r.TryDecodeAsNil() { + x.MaxOpenFiles = 0 + } else { + x.MaxOpenFiles = uint64(r.DecodeUint(64)) + } + case "reconcileCIDR": + if r.TryDecodeAsNil() { + x.ReconcileCIDR = false + } else { + x.ReconcileCIDR = bool(r.DecodeBool()) + } + case "registerSchedulable": + if r.TryDecodeAsNil() { + x.RegisterSchedulable = false + } else { + x.RegisterSchedulable = bool(r.DecodeBool()) + } + case "kubeAPIQPS": + if r.TryDecodeAsNil() { + x.KubeAPIQPS = 0 + } else { + x.KubeAPIQPS = float32(r.DecodeFloat(true)) + } + case "kubeAPIBurst": + if r.TryDecodeAsNil() { + x.KubeAPIBurst = 0 + } else { + x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "serializeImagePulls": + if r.TryDecodeAsNil() { + x.SerializeImagePulls = false + } else { + x.SerializeImagePulls = bool(r.DecodeBool()) + } + case "experimentalFlannelOverlay": + if r.TryDecodeAsNil() { + x.ExperimentalFlannelOverlay = false + } else { + x.ExperimentalFlannelOverlay = bool(r.DecodeBool()) + } + case "outOfDiskTransitionFrequency": + if r.TryDecodeAsNil() { + x.OutOfDiskTransitionFrequency = pkg1_unversioned.Duration{} + } else { + yyv444 := &x.OutOfDiskTransitionFrequency + yym445 := z.DecBinary() + _ = yym445 + if false { + } else if z.HasExtensions() && z.DecExt(yyv444) { + } else if !yym445 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv444) + } else { + z.DecFallback(yyv444, false) + } + } + case "nodeIP": + if r.TryDecodeAsNil() { + x.NodeIP = "" + } else { + x.NodeIP = string(r.DecodeString()) + } + case "nodeLabels": + if r.TryDecodeAsNil() { + x.NodeLabels = nil + } else { + yyv447 := &x.NodeLabels + yym448 := z.DecBinary() + _ = yym448 + if false { + } else { + z.F.DecMapStringStringX(yyv447, false, d) + } + } + case "nonMasqueradeCIDR": + if r.TryDecodeAsNil() { + x.NonMasqueradeCIDR = "" + } else { + x.NonMasqueradeCIDR = string(r.DecodeString()) + } + case "enableCustomMetrics": + if r.TryDecodeAsNil() { + x.EnableCustomMetrics = false + } else { + x.EnableCustomMetrics = bool(r.DecodeBool()) + } + default: + z.DecStructFieldNotFound(-1, yys365) + } // end switch yys365 + } // end for yyj365 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj451 int + var yyb451 bool + var yyhl451 bool = l >= 0 + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Config = "" + } else { + x.Config = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.SyncFrequency = pkg1_unversioned.Duration{} + } else { + yyv453 := &x.SyncFrequency + yym454 := z.DecBinary() + _ = yym454 + if false { + } else if z.HasExtensions() && z.DecExt(yyv453) { + } else if !yym454 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv453) + } else { + z.DecFallback(yyv453, false) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.FileCheckFrequency = pkg1_unversioned.Duration{} + } else { + yyv455 := &x.FileCheckFrequency + yym456 := z.DecBinary() + _ = yym456 + if false { + } else if z.HasExtensions() && z.DecExt(yyv455) { + } else if !yym456 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv455) + } else { + z.DecFallback(yyv455, false) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HTTPCheckFrequency = pkg1_unversioned.Duration{} + } else { + yyv457 := &x.HTTPCheckFrequency + yym458 := z.DecBinary() + _ = yym458 + if false { + } else if z.HasExtensions() && z.DecExt(yyv457) { + } else if !yym458 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv457) + } else { + z.DecFallback(yyv457, false) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ManifestURL = "" + } else { + x.ManifestURL = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ManifestURLHeader = "" + } else { + x.ManifestURLHeader = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.EnableServer = false + } else { + x.EnableServer = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Address = "" + } else { + x.Address = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Port = 0 + } else { + x.Port = uint(r.DecodeUint(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ReadOnlyPort = 0 + } else { + x.ReadOnlyPort = uint(r.DecodeUint(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.TLSCertFile = "" + } else { + x.TLSCertFile = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.TLSPrivateKeyFile = "" + } else { + x.TLSPrivateKeyFile = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.CertDirectory = "" + } else { + x.CertDirectory = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HostnameOverride = "" + } else { + x.HostnameOverride = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PodInfraContainerImage = "" + } else { + x.PodInfraContainerImage = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.DockerEndpoint = "" + } else { + x.DockerEndpoint = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RootDirectory = "" + } else { + x.RootDirectory = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.AllowPrivileged = false + } else { + x.AllowPrivileged = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HostNetworkSources = "" + } else { + x.HostNetworkSources = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HostPIDSources = "" + } else { + x.HostPIDSources = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HostIPCSources = "" + } else { + x.HostIPCSources = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RegistryPullQPS = 0 + } else { + x.RegistryPullQPS = float64(r.DecodeFloat(false)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RegistryBurst = 0 + } else { + x.RegistryBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.EventRecordQPS = 0 + } else { + x.EventRecordQPS = float32(r.DecodeFloat(true)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.EventBurst = 0 + } else { + x.EventBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.EnableDebuggingHandlers = false + } else { + x.EnableDebuggingHandlers = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MinimumGCAge = pkg1_unversioned.Duration{} + } else { + yyv481 := &x.MinimumGCAge + yym482 := z.DecBinary() + _ = yym482 + if false { + } else if z.HasExtensions() && z.DecExt(yyv481) { + } else if !yym482 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv481) + } else { + z.DecFallback(yyv481, false) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MaxPerPodContainerCount = 0 + } else { + x.MaxPerPodContainerCount = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MaxContainerCount = 0 + } else { + x.MaxContainerCount = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.CAdvisorPort = 0 + } else { + x.CAdvisorPort = uint(r.DecodeUint(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HealthzPort = 0 + } else { + x.HealthzPort = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HealthzBindAddress = "" + } else { + x.HealthzBindAddress = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.OOMScoreAdj = 0 + } else { + x.OOMScoreAdj = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RegisterNode = false + } else { + x.RegisterNode = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ClusterDomain = "" + } else { + x.ClusterDomain = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MasterServiceNamespace = "" + } else { + x.MasterServiceNamespace = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ClusterDNS = "" + } else { + x.ClusterDNS = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.StreamingConnectionIdleTimeout = pkg1_unversioned.Duration{} + } else { + yyv493 := &x.StreamingConnectionIdleTimeout + yym494 := z.DecBinary() + _ = yym494 + if false { + } else if z.HasExtensions() && z.DecExt(yyv493) { + } else if !yym494 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv493) + } else { + z.DecFallback(yyv493, false) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeStatusUpdateFrequency = pkg1_unversioned.Duration{} + } else { + yyv495 := &x.NodeStatusUpdateFrequency + yym496 := z.DecBinary() + _ = yym496 + if false { + } else if z.HasExtensions() && z.DecExt(yyv495) { + } else if !yym496 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv495) + } else { + z.DecFallback(yyv495, false) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ImageGCHighThresholdPercent = 0 + } else { + x.ImageGCHighThresholdPercent = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ImageGCLowThresholdPercent = 0 + } else { + x.ImageGCLowThresholdPercent = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.LowDiskSpaceThresholdMB = 0 + } else { + x.LowDiskSpaceThresholdMB = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.VolumeStatsAggPeriod = pkg1_unversioned.Duration{} + } else { + yyv500 := &x.VolumeStatsAggPeriod + yym501 := z.DecBinary() + _ = yym501 + if false { + } else if z.HasExtensions() && z.DecExt(yyv500) { + } else if !yym501 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv500) + } else { + z.DecFallback(yyv500, false) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NetworkPluginName = "" + } else { + x.NetworkPluginName = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NetworkPluginDir = "" + } else { + x.NetworkPluginDir = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.VolumePluginDir = "" + } else { + x.VolumePluginDir = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.CloudProvider = "" + } else { + x.CloudProvider = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.CloudConfigFile = "" + } else { + x.CloudConfigFile = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.KubeletCgroups = "" + } else { + x.KubeletCgroups = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RuntimeCgroups = "" + } else { + x.RuntimeCgroups = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.SystemCgroups = "" + } else { + x.SystemCgroups = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.CgroupRoot = "" + } else { + x.CgroupRoot = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ContainerRuntime = "" + } else { + x.ContainerRuntime = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RktPath = "" + } else { + x.RktPath = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.LockFilePath = "" + } else { + x.LockFilePath = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RktStage1Image = "" + } else { + x.RktStage1Image = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConfigureCBR0 = false + } else { + x.ConfigureCBR0 = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HairpinMode = false + } else { + x.HairpinMode = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MaxPods = 0 + } else { + x.MaxPods = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.DockerExecHandlerName = "" + } else { + x.DockerExecHandlerName = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PodCIDR = "" + } else { + x.PodCIDR = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ResolverConfig = "" + } else { + x.ResolverConfig = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.CPUCFSQuota = false + } else { + x.CPUCFSQuota = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Containerized = false + } else { + x.Containerized = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MaxOpenFiles = 0 + } else { + x.MaxOpenFiles = uint64(r.DecodeUint(64)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ReconcileCIDR = false + } else { + x.ReconcileCIDR = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RegisterSchedulable = false + } else { + x.RegisterSchedulable = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.KubeAPIQPS = 0 + } else { + x.KubeAPIQPS = float32(r.DecodeFloat(true)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.KubeAPIBurst = 0 + } else { + x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.SerializeImagePulls = false + } else { + x.SerializeImagePulls = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ExperimentalFlannelOverlay = false + } else { + x.ExperimentalFlannelOverlay = bool(r.DecodeBool()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.OutOfDiskTransitionFrequency = pkg1_unversioned.Duration{} + } else { + yyv530 := &x.OutOfDiskTransitionFrequency + yym531 := z.DecBinary() + _ = yym531 + if false { + } else if z.HasExtensions() && z.DecExt(yyv530) { + } else if !yym531 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv530) + } else { + z.DecFallback(yyv530, false) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeIP = "" + } else { + x.NodeIP = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeLabels = nil + } else { + yyv533 := &x.NodeLabels + yym534 := z.DecBinary() + _ = yym534 + if false { + } else { + z.F.DecMapStringStringX(yyv533, false, d) + } + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NonMasqueradeCIDR = "" + } else { + x.NonMasqueradeCIDR = string(r.DecodeString()) + } + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.EnableCustomMetrics = false + } else { + x.EnableCustomMetrics = bool(r.DecodeBool()) + } + for { + yyj451++ + if yyhl451 { + yyb451 = yyj451 > l + } else { + yyb451 = r.CheckBreak() + } + if yyb451 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj451-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym537 := z.EncBinary() + _ = yym537 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep538 := !z.EncBinary() + yy2arr538 := z.EncBasicHandle().StructToArray + var yyq538 [11]bool + _, _, _ = yysep538, yyq538, yy2arr538 + const yyr538 bool = false + yyq538[9] = x.Kind != "" + yyq538[10] = x.APIVersion != "" + var yynn538 int + if yyr538 || yy2arr538 { + r.EncodeArrayStart(11) + } else { + yynn538 = 9 + for _, b := range yyq538 { + if b { + yynn538++ + } + } + r.EncodeMapStart(yynn538) + yynn538 = 0 + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym540 := z.EncBinary() + _ = yym540 + if false { + } else { + r.EncodeInt(int64(x.Port)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("port")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym541 := z.EncBinary() + _ = yym541 + if false { + } else { + r.EncodeInt(int64(x.Port)) + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym543 := z.EncBinary() + _ = yym543 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Address)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("address")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym544 := z.EncBinary() + _ = yym544 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Address)) + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym546 := z.EncBinary() + _ = yym546 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.AlgorithmProvider)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("algorithmProvider")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym547 := z.EncBinary() + _ = yym547 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.AlgorithmProvider)) + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym549 := z.EncBinary() + _ = yym549 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PolicyConfigFile)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("policyConfigFile")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym550 := z.EncBinary() + _ = yym550 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PolicyConfigFile)) + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym552 := z.EncBinary() + _ = yym552 + if false { + } else { + r.EncodeBool(bool(x.EnableProfiling)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("enableProfiling")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym553 := z.EncBinary() + _ = yym553 + if false { + } else { + r.EncodeBool(bool(x.EnableProfiling)) + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym555 := z.EncBinary() + _ = yym555 + if false { + } else { + r.EncodeFloat32(float32(x.KubeAPIQPS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym556 := z.EncBinary() + _ = yym556 + if false { + } else { + r.EncodeFloat32(float32(x.KubeAPIQPS)) + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym558 := z.EncBinary() + _ = yym558 + if false { + } else { + r.EncodeInt(int64(x.KubeAPIBurst)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym559 := z.EncBinary() + _ = yym559 + if false { + } else { + r.EncodeInt(int64(x.KubeAPIBurst)) + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym561 := z.EncBinary() + _ = yym561 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.SchedulerName)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("schedulerName")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym562 := z.EncBinary() + _ = yym562 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.SchedulerName)) + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy564 := &x.LeaderElection + yy564.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("leaderElection")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy565 := &x.LeaderElection + yy565.CodecEncodeSelf(e) + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq538[9] { + yym567 := z.EncBinary() + _ = yym567 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq538[9] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kind")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym568 := z.EncBinary() + _ = yym568 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq538[10] { + yym570 := z.EncBinary() + _ = yym570 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq538[10] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym571 := z.EncBinary() + _ = yym571 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } + } + if yyr538 || yy2arr538 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *KubeSchedulerConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym572 := z.DecBinary() + _ = yym572 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct573 := r.ContainerType() + if yyct573 == codecSelferValueTypeMap1234 { + yyl573 := r.ReadMapStart() + if yyl573 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl573, d) + } + } else if yyct573 == codecSelferValueTypeArray1234 { + yyl573 := r.ReadArrayStart() + if yyl573 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl573, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *KubeSchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys574Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys574Slc + var yyhl574 bool = l >= 0 + for yyj574 := 0; ; yyj574++ { + if yyhl574 { + if yyj574 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys574Slc = r.DecodeBytes(yys574Slc, true, true) + yys574 := string(yys574Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys574 { + case "port": + if r.TryDecodeAsNil() { + x.Port = 0 + } else { + x.Port = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "address": + if r.TryDecodeAsNil() { + x.Address = "" + } else { + x.Address = string(r.DecodeString()) + } + case "algorithmProvider": + if r.TryDecodeAsNil() { + x.AlgorithmProvider = "" + } else { + x.AlgorithmProvider = string(r.DecodeString()) + } + case "policyConfigFile": + if r.TryDecodeAsNil() { + x.PolicyConfigFile = "" + } else { + x.PolicyConfigFile = string(r.DecodeString()) + } + case "enableProfiling": + if r.TryDecodeAsNil() { + x.EnableProfiling = false + } else { + x.EnableProfiling = bool(r.DecodeBool()) + } + case "kubeAPIQPS": + if r.TryDecodeAsNil() { + x.KubeAPIQPS = 0 + } else { + x.KubeAPIQPS = float32(r.DecodeFloat(true)) + } + case "kubeAPIBurst": + if r.TryDecodeAsNil() { + x.KubeAPIBurst = 0 + } else { + x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "schedulerName": + if r.TryDecodeAsNil() { + x.SchedulerName = "" + } else { + x.SchedulerName = string(r.DecodeString()) + } + case "leaderElection": + if r.TryDecodeAsNil() { + x.LeaderElection = LeaderElectionConfiguration{} + } else { + yyv583 := &x.LeaderElection + yyv583.CodecDecodeSelf(d) + } + case "kind": + if r.TryDecodeAsNil() { + x.Kind = "" + } else { + x.Kind = string(r.DecodeString()) + } + case "apiVersion": + if r.TryDecodeAsNil() { + x.APIVersion = "" + } else { + x.APIVersion = string(r.DecodeString()) + } + default: + z.DecStructFieldNotFound(-1, yys574) + } // end switch yys574 + } // end for yyj574 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj586 int + var yyb586 bool + var yyhl586 bool = l >= 0 + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Port = 0 + } else { + x.Port = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Address = "" + } else { + x.Address = string(r.DecodeString()) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.AlgorithmProvider = "" + } else { + x.AlgorithmProvider = string(r.DecodeString()) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PolicyConfigFile = "" + } else { + x.PolicyConfigFile = string(r.DecodeString()) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.EnableProfiling = false + } else { + x.EnableProfiling = bool(r.DecodeBool()) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.KubeAPIQPS = 0 + } else { + x.KubeAPIQPS = float32(r.DecodeFloat(true)) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.KubeAPIBurst = 0 + } else { + x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.SchedulerName = "" + } else { + x.SchedulerName = string(r.DecodeString()) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.LeaderElection = LeaderElectionConfiguration{} + } else { + yyv595 := &x.LeaderElection + yyv595.CodecDecodeSelf(d) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Kind = "" + } else { + x.Kind = string(r.DecodeString()) + } + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.APIVersion = "" + } else { + x.APIVersion = string(r.DecodeString()) + } + for { + yyj586++ + if yyhl586 { + yyb586 = yyj586 > l + } else { + yyb586 = r.CheckBreak() + } + if yyb586 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj586-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *LeaderElectionConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym598 := z.EncBinary() + _ = yym598 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep599 := !z.EncBinary() + yy2arr599 := z.EncBasicHandle().StructToArray + var yyq599 [4]bool + _, _, _ = yysep599, yyq599, yy2arr599 + const yyr599 bool = false + var yynn599 int + if yyr599 || yy2arr599 { + r.EncodeArrayStart(4) + } else { + yynn599 = 4 + for _, b := range yyq599 { + if b { + yynn599++ + } + } + r.EncodeMapStart(yynn599) + yynn599 = 0 + } + if yyr599 || yy2arr599 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym601 := z.EncBinary() + _ = yym601 + if false { + } else { + r.EncodeBool(bool(x.LeaderElect)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("leaderElect")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym602 := z.EncBinary() + _ = yym602 + if false { + } else { + r.EncodeBool(bool(x.LeaderElect)) + } + } + if yyr599 || yy2arr599 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy604 := &x.LeaseDuration + yym605 := z.EncBinary() + _ = yym605 + if false { + } else if z.HasExtensions() && z.EncExt(yy604) { + } else if !yym605 && z.IsJSONHandle() { + z.EncJSONMarshal(yy604) + } else { + z.EncFallback(yy604) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("leaseDuration")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy606 := &x.LeaseDuration + yym607 := z.EncBinary() + _ = yym607 + if false { + } else if z.HasExtensions() && z.EncExt(yy606) { + } else if !yym607 && z.IsJSONHandle() { + z.EncJSONMarshal(yy606) + } else { + z.EncFallback(yy606) + } + } + if yyr599 || yy2arr599 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy609 := &x.RenewDeadline + yym610 := z.EncBinary() + _ = yym610 + if false { + } else if z.HasExtensions() && z.EncExt(yy609) { + } else if !yym610 && z.IsJSONHandle() { + z.EncJSONMarshal(yy609) + } else { + z.EncFallback(yy609) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("renewDeadline")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy611 := &x.RenewDeadline + yym612 := z.EncBinary() + _ = yym612 + if false { + } else if z.HasExtensions() && z.EncExt(yy611) { + } else if !yym612 && z.IsJSONHandle() { + z.EncJSONMarshal(yy611) + } else { + z.EncFallback(yy611) + } + } + if yyr599 || yy2arr599 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy614 := &x.RetryPeriod + yym615 := z.EncBinary() + _ = yym615 + if false { + } else if z.HasExtensions() && z.EncExt(yy614) { + } else if !yym615 && z.IsJSONHandle() { + z.EncJSONMarshal(yy614) + } else { + z.EncFallback(yy614) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("retryPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy616 := &x.RetryPeriod + yym617 := z.EncBinary() + _ = yym617 + if false { + } else if z.HasExtensions() && z.EncExt(yy616) { + } else if !yym617 && z.IsJSONHandle() { + z.EncJSONMarshal(yy616) + } else { + z.EncFallback(yy616) + } + } + if yyr599 || yy2arr599 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *LeaderElectionConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym618 := z.DecBinary() + _ = yym618 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct619 := r.ContainerType() + if yyct619 == codecSelferValueTypeMap1234 { + yyl619 := r.ReadMapStart() + if yyl619 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl619, d) + } + } else if yyct619 == codecSelferValueTypeArray1234 { + yyl619 := r.ReadArrayStart() + if yyl619 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl619, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *LeaderElectionConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys620Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys620Slc + var yyhl620 bool = l >= 0 + for yyj620 := 0; ; yyj620++ { + if yyhl620 { + if yyj620 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys620Slc = r.DecodeBytes(yys620Slc, true, true) + yys620 := string(yys620Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys620 { + case "leaderElect": + if r.TryDecodeAsNil() { + x.LeaderElect = false + } else { + x.LeaderElect = bool(r.DecodeBool()) + } + case "leaseDuration": + if r.TryDecodeAsNil() { + x.LeaseDuration = pkg1_unversioned.Duration{} + } else { + yyv622 := &x.LeaseDuration + yym623 := z.DecBinary() + _ = yym623 + if false { + } else if z.HasExtensions() && z.DecExt(yyv622) { + } else if !yym623 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv622) + } else { + z.DecFallback(yyv622, false) + } + } + case "renewDeadline": + if r.TryDecodeAsNil() { + x.RenewDeadline = pkg1_unversioned.Duration{} + } else { + yyv624 := &x.RenewDeadline + yym625 := z.DecBinary() + _ = yym625 + if false { + } else if z.HasExtensions() && z.DecExt(yyv624) { + } else if !yym625 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv624) + } else { + z.DecFallback(yyv624, false) + } + } + case "retryPeriod": + if r.TryDecodeAsNil() { + x.RetryPeriod = pkg1_unversioned.Duration{} + } else { + yyv626 := &x.RetryPeriod + yym627 := z.DecBinary() + _ = yym627 + if false { + } else if z.HasExtensions() && z.DecExt(yyv626) { + } else if !yym627 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv626) + } else { + z.DecFallback(yyv626, false) + } + } + default: + z.DecStructFieldNotFound(-1, yys620) + } // end switch yys620 + } // end for yyj620 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *LeaderElectionConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj628 int + var yyb628 bool + var yyhl628 bool = l >= 0 + yyj628++ + if yyhl628 { + yyb628 = yyj628 > l + } else { + yyb628 = r.CheckBreak() + } + if yyb628 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.LeaderElect = false + } else { + x.LeaderElect = bool(r.DecodeBool()) + } + yyj628++ + if yyhl628 { + yyb628 = yyj628 > l + } else { + yyb628 = r.CheckBreak() + } + if yyb628 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.LeaseDuration = pkg1_unversioned.Duration{} + } else { + yyv630 := &x.LeaseDuration + yym631 := z.DecBinary() + _ = yym631 + if false { + } else if z.HasExtensions() && z.DecExt(yyv630) { + } else if !yym631 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv630) + } else { + z.DecFallback(yyv630, false) + } + } + yyj628++ + if yyhl628 { + yyb628 = yyj628 > l + } else { + yyb628 = r.CheckBreak() + } + if yyb628 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RenewDeadline = pkg1_unversioned.Duration{} + } else { + yyv632 := &x.RenewDeadline + yym633 := z.DecBinary() + _ = yym633 + if false { + } else if z.HasExtensions() && z.DecExt(yyv632) { + } else if !yym633 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv632) + } else { + z.DecFallback(yyv632, false) + } + } + yyj628++ + if yyhl628 { + yyb628 = yyj628 > l + } else { + yyb628 = r.CheckBreak() + } + if yyb628 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RetryPeriod = pkg1_unversioned.Duration{} + } else { + yyv634 := &x.RetryPeriod + yym635 := z.DecBinary() + _ = yym635 + if false { + } else if z.HasExtensions() && z.DecExt(yyv634) { + } else if !yym635 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv634) + } else { + z.DecFallback(yyv634, false) + } + } + for { + yyj628++ + if yyhl628 { + yyb628 = yyj628 > l + } else { + yyb628 = r.CheckBreak() + } + if yyb628 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj628-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym636 := z.EncBinary() + _ = yym636 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep637 := !z.EncBinary() + yy2arr637 := z.EncBasicHandle().StructToArray + var yyq637 [40]bool + _, _, _ = yysep637, yyq637, yy2arr637 + const yyr637 bool = false + yyq637[38] = x.Kind != "" + yyq637[39] = x.APIVersion != "" + var yynn637 int + if yyr637 || yy2arr637 { + r.EncodeArrayStart(40) + } else { + yynn637 = 38 + for _, b := range yyq637 { + if b { + yynn637++ + } + } + r.EncodeMapStart(yynn637) + yynn637 = 0 + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym639 := z.EncBinary() + _ = yym639 + if false { + } else { + r.EncodeInt(int64(x.Port)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("port")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym640 := z.EncBinary() + _ = yym640 + if false { + } else { + r.EncodeInt(int64(x.Port)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym642 := z.EncBinary() + _ = yym642 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Address)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("address")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym643 := z.EncBinary() + _ = yym643 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Address)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym645 := z.EncBinary() + _ = yym645 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CloudProvider)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("cloudProvider")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym646 := z.EncBinary() + _ = yym646 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CloudProvider)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym648 := z.EncBinary() + _ = yym648 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CloudConfigFile)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("cloudConfigFile")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym649 := z.EncBinary() + _ = yym649 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.CloudConfigFile)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym651 := z.EncBinary() + _ = yym651 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentEndpointSyncs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("concurrentEndpointSyncs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym652 := z.EncBinary() + _ = yym652 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentEndpointSyncs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym654 := z.EncBinary() + _ = yym654 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentRSSyncs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("concurrentRSSyncs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym655 := z.EncBinary() + _ = yym655 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentRSSyncs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym657 := z.EncBinary() + _ = yym657 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentRCSyncs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("concurrentRCSyncs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym658 := z.EncBinary() + _ = yym658 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentRCSyncs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym660 := z.EncBinary() + _ = yym660 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentResourceQuotaSyncs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("concurrentResourceQuotaSyncs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym661 := z.EncBinary() + _ = yym661 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentResourceQuotaSyncs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym663 := z.EncBinary() + _ = yym663 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentDeploymentSyncs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("concurrentDeploymentSyncs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym664 := z.EncBinary() + _ = yym664 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentDeploymentSyncs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym666 := z.EncBinary() + _ = yym666 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentDaemonSetSyncs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("concurrentDaemonSetSyncs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym667 := z.EncBinary() + _ = yym667 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentDaemonSetSyncs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym669 := z.EncBinary() + _ = yym669 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentJobSyncs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("concurrentJobSyncs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym670 := z.EncBinary() + _ = yym670 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentJobSyncs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym672 := z.EncBinary() + _ = yym672 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentNamespaceSyncs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("concurrentNamespaceSyncs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym673 := z.EncBinary() + _ = yym673 + if false { + } else { + r.EncodeInt(int64(x.ConcurrentNamespaceSyncs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy675 := &x.ServiceSyncPeriod + yym676 := z.EncBinary() + _ = yym676 + if false { + } else if z.HasExtensions() && z.EncExt(yy675) { + } else if !yym676 && z.IsJSONHandle() { + z.EncJSONMarshal(yy675) + } else { + z.EncFallback(yy675) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("serviceSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy677 := &x.ServiceSyncPeriod + yym678 := z.EncBinary() + _ = yym678 + if false { + } else if z.HasExtensions() && z.EncExt(yy677) { + } else if !yym678 && z.IsJSONHandle() { + z.EncJSONMarshal(yy677) + } else { + z.EncFallback(yy677) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy680 := &x.NodeSyncPeriod + yym681 := z.EncBinary() + _ = yym681 + if false { + } else if z.HasExtensions() && z.EncExt(yy680) { + } else if !yym681 && z.IsJSONHandle() { + z.EncJSONMarshal(yy680) + } else { + z.EncFallback(yy680) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy682 := &x.NodeSyncPeriod + yym683 := z.EncBinary() + _ = yym683 + if false { + } else if z.HasExtensions() && z.EncExt(yy682) { + } else if !yym683 && z.IsJSONHandle() { + z.EncJSONMarshal(yy682) + } else { + z.EncFallback(yy682) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy685 := &x.ResourceQuotaSyncPeriod + yym686 := z.EncBinary() + _ = yym686 + if false { + } else if z.HasExtensions() && z.EncExt(yy685) { + } else if !yym686 && z.IsJSONHandle() { + z.EncJSONMarshal(yy685) + } else { + z.EncFallback(yy685) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("resourceQuotaSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy687 := &x.ResourceQuotaSyncPeriod + yym688 := z.EncBinary() + _ = yym688 + if false { + } else if z.HasExtensions() && z.EncExt(yy687) { + } else if !yym688 && z.IsJSONHandle() { + z.EncJSONMarshal(yy687) + } else { + z.EncFallback(yy687) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy690 := &x.NamespaceSyncPeriod + yym691 := z.EncBinary() + _ = yym691 + if false { + } else if z.HasExtensions() && z.EncExt(yy690) { + } else if !yym691 && z.IsJSONHandle() { + z.EncJSONMarshal(yy690) + } else { + z.EncFallback(yy690) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("namespaceSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy692 := &x.NamespaceSyncPeriod + yym693 := z.EncBinary() + _ = yym693 + if false { + } else if z.HasExtensions() && z.EncExt(yy692) { + } else if !yym693 && z.IsJSONHandle() { + z.EncJSONMarshal(yy692) + } else { + z.EncFallback(yy692) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy695 := &x.PVClaimBinderSyncPeriod + yym696 := z.EncBinary() + _ = yym696 + if false { + } else if z.HasExtensions() && z.EncExt(yy695) { + } else if !yym696 && z.IsJSONHandle() { + z.EncJSONMarshal(yy695) + } else { + z.EncFallback(yy695) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("pvClaimBinderSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy697 := &x.PVClaimBinderSyncPeriod + yym698 := z.EncBinary() + _ = yym698 + if false { + } else if z.HasExtensions() && z.EncExt(yy697) { + } else if !yym698 && z.IsJSONHandle() { + z.EncJSONMarshal(yy697) + } else { + z.EncFallback(yy697) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy700 := &x.MinResyncPeriod + yym701 := z.EncBinary() + _ = yym701 + if false { + } else if z.HasExtensions() && z.EncExt(yy700) { + } else if !yym701 && z.IsJSONHandle() { + z.EncJSONMarshal(yy700) + } else { + z.EncFallback(yy700) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("minResyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy702 := &x.MinResyncPeriod + yym703 := z.EncBinary() + _ = yym703 + if false { + } else if z.HasExtensions() && z.EncExt(yy702) { + } else if !yym703 && z.IsJSONHandle() { + z.EncJSONMarshal(yy702) + } else { + z.EncFallback(yy702) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym705 := z.EncBinary() + _ = yym705 + if false { + } else { + r.EncodeInt(int64(x.TerminatedPodGCThreshold)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("terminatedPodGCThreshold")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym706 := z.EncBinary() + _ = yym706 + if false { + } else { + r.EncodeInt(int64(x.TerminatedPodGCThreshold)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy708 := &x.HorizontalPodAutoscalerSyncPeriod + yym709 := z.EncBinary() + _ = yym709 + if false { + } else if z.HasExtensions() && z.EncExt(yy708) { + } else if !yym709 && z.IsJSONHandle() { + z.EncJSONMarshal(yy708) + } else { + z.EncFallback(yy708) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("horizontalPodAutoscalerSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy710 := &x.HorizontalPodAutoscalerSyncPeriod + yym711 := z.EncBinary() + _ = yym711 + if false { + } else if z.HasExtensions() && z.EncExt(yy710) { + } else if !yym711 && z.IsJSONHandle() { + z.EncJSONMarshal(yy710) + } else { + z.EncFallback(yy710) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy713 := &x.DeploymentControllerSyncPeriod + yym714 := z.EncBinary() + _ = yym714 + if false { + } else if z.HasExtensions() && z.EncExt(yy713) { + } else if !yym714 && z.IsJSONHandle() { + z.EncJSONMarshal(yy713) + } else { + z.EncFallback(yy713) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("deploymentControllerSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy715 := &x.DeploymentControllerSyncPeriod + yym716 := z.EncBinary() + _ = yym716 + if false { + } else if z.HasExtensions() && z.EncExt(yy715) { + } else if !yym716 && z.IsJSONHandle() { + z.EncJSONMarshal(yy715) + } else { + z.EncFallback(yy715) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy718 := &x.PodEvictionTimeout + yym719 := z.EncBinary() + _ = yym719 + if false { + } else if z.HasExtensions() && z.EncExt(yy718) { + } else if !yym719 && z.IsJSONHandle() { + z.EncJSONMarshal(yy718) + } else { + z.EncFallback(yy718) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("podEvictionTimeout")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy720 := &x.PodEvictionTimeout + yym721 := z.EncBinary() + _ = yym721 + if false { + } else if z.HasExtensions() && z.EncExt(yy720) { + } else if !yym721 && z.IsJSONHandle() { + z.EncJSONMarshal(yy720) + } else { + z.EncFallback(yy720) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym723 := z.EncBinary() + _ = yym723 + if false { + } else { + r.EncodeFloat32(float32(x.DeletingPodsQps)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("deletingPodsQps")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym724 := z.EncBinary() + _ = yym724 + if false { + } else { + r.EncodeFloat32(float32(x.DeletingPodsQps)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym726 := z.EncBinary() + _ = yym726 + if false { + } else { + r.EncodeInt(int64(x.DeletingPodsBurst)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("deletingPodsBurst")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym727 := z.EncBinary() + _ = yym727 + if false { + } else { + r.EncodeInt(int64(x.DeletingPodsBurst)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy729 := &x.NodeMonitorGracePeriod + yym730 := z.EncBinary() + _ = yym730 + if false { + } else if z.HasExtensions() && z.EncExt(yy729) { + } else if !yym730 && z.IsJSONHandle() { + z.EncJSONMarshal(yy729) + } else { + z.EncFallback(yy729) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeMonitorGracePeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy731 := &x.NodeMonitorGracePeriod + yym732 := z.EncBinary() + _ = yym732 + if false { + } else if z.HasExtensions() && z.EncExt(yy731) { + } else if !yym732 && z.IsJSONHandle() { + z.EncJSONMarshal(yy731) + } else { + z.EncFallback(yy731) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym734 := z.EncBinary() + _ = yym734 + if false { + } else { + r.EncodeInt(int64(x.RegisterRetryCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("registerRetryCount")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym735 := z.EncBinary() + _ = yym735 + if false { + } else { + r.EncodeInt(int64(x.RegisterRetryCount)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy737 := &x.NodeStartupGracePeriod + yym738 := z.EncBinary() + _ = yym738 + if false { + } else if z.HasExtensions() && z.EncExt(yy737) { + } else if !yym738 && z.IsJSONHandle() { + z.EncJSONMarshal(yy737) + } else { + z.EncFallback(yy737) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeStartupGracePeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy739 := &x.NodeStartupGracePeriod + yym740 := z.EncBinary() + _ = yym740 + if false { + } else if z.HasExtensions() && z.EncExt(yy739) { + } else if !yym740 && z.IsJSONHandle() { + z.EncJSONMarshal(yy739) + } else { + z.EncFallback(yy739) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy742 := &x.NodeMonitorPeriod + yym743 := z.EncBinary() + _ = yym743 + if false { + } else if z.HasExtensions() && z.EncExt(yy742) { + } else if !yym743 && z.IsJSONHandle() { + z.EncJSONMarshal(yy742) + } else { + z.EncFallback(yy742) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeMonitorPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy744 := &x.NodeMonitorPeriod + yym745 := z.EncBinary() + _ = yym745 + if false { + } else if z.HasExtensions() && z.EncExt(yy744) { + } else if !yym745 && z.IsJSONHandle() { + z.EncJSONMarshal(yy744) + } else { + z.EncFallback(yy744) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym747 := z.EncBinary() + _ = yym747 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ServiceAccountKeyFile)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("serviceAccountKeyFile")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym748 := z.EncBinary() + _ = yym748 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ServiceAccountKeyFile)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym750 := z.EncBinary() + _ = yym750 + if false { + } else { + r.EncodeBool(bool(x.EnableProfiling)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("enableProfiling")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym751 := z.EncBinary() + _ = yym751 + if false { + } else { + r.EncodeBool(bool(x.EnableProfiling)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym753 := z.EncBinary() + _ = yym753 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterName)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("clusterName")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym754 := z.EncBinary() + _ = yym754 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterName)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym756 := z.EncBinary() + _ = yym756 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterCIDR)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("clusterCIDR")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym757 := z.EncBinary() + _ = yym757 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterCIDR)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym759 := z.EncBinary() + _ = yym759 + if false { + } else { + r.EncodeBool(bool(x.AllocateNodeCIDRs)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("allocateNodeCIDRs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym760 := z.EncBinary() + _ = yym760 + if false { + } else { + r.EncodeBool(bool(x.AllocateNodeCIDRs)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym762 := z.EncBinary() + _ = yym762 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RootCAFile)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("rootCAFile")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym763 := z.EncBinary() + _ = yym763 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.RootCAFile)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym765 := z.EncBinary() + _ = yym765 + if false { + } else { + r.EncodeFloat32(float32(x.KubeAPIQPS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym766 := z.EncBinary() + _ = yym766 + if false { + } else { + r.EncodeFloat32(float32(x.KubeAPIQPS)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym768 := z.EncBinary() + _ = yym768 + if false { + } else { + r.EncodeInt(int64(x.KubeAPIBurst)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym769 := z.EncBinary() + _ = yym769 + if false { + } else { + r.EncodeInt(int64(x.KubeAPIBurst)) + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy771 := &x.LeaderElection + yy771.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("leaderElection")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy772 := &x.LeaderElection + yy772.CodecEncodeSelf(e) + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy774 := &x.VolumeConfiguration + yy774.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("volumeConfiguration")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy775 := &x.VolumeConfiguration + yy775.CodecEncodeSelf(e) + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq637[38] { + yym777 := z.EncBinary() + _ = yym777 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq637[38] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kind")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym778 := z.EncBinary() + _ = yym778 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq637[39] { + yym780 := z.EncBinary() + _ = yym780 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq637[39] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym781 := z.EncBinary() + _ = yym781 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } + } + if yyr637 || yy2arr637 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *KubeControllerManagerConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym782 := z.DecBinary() + _ = yym782 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct783 := r.ContainerType() + if yyct783 == codecSelferValueTypeMap1234 { + yyl783 := r.ReadMapStart() + if yyl783 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl783, d) + } + } else if yyct783 == codecSelferValueTypeArray1234 { + yyl783 := r.ReadArrayStart() + if yyl783 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl783, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys784Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys784Slc + var yyhl784 bool = l >= 0 + for yyj784 := 0; ; yyj784++ { + if yyhl784 { + if yyj784 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys784Slc = r.DecodeBytes(yys784Slc, true, true) + yys784 := string(yys784Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys784 { + case "port": + if r.TryDecodeAsNil() { + x.Port = 0 + } else { + x.Port = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "address": + if r.TryDecodeAsNil() { + x.Address = "" + } else { + x.Address = string(r.DecodeString()) + } + case "cloudProvider": + if r.TryDecodeAsNil() { + x.CloudProvider = "" + } else { + x.CloudProvider = string(r.DecodeString()) + } + case "cloudConfigFile": + if r.TryDecodeAsNil() { + x.CloudConfigFile = "" + } else { + x.CloudConfigFile = string(r.DecodeString()) + } + case "concurrentEndpointSyncs": + if r.TryDecodeAsNil() { + x.ConcurrentEndpointSyncs = 0 + } else { + x.ConcurrentEndpointSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "concurrentRSSyncs": + if r.TryDecodeAsNil() { + x.ConcurrentRSSyncs = 0 + } else { + x.ConcurrentRSSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "concurrentRCSyncs": + if r.TryDecodeAsNil() { + x.ConcurrentRCSyncs = 0 + } else { + x.ConcurrentRCSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "concurrentResourceQuotaSyncs": + if r.TryDecodeAsNil() { + x.ConcurrentResourceQuotaSyncs = 0 + } else { + x.ConcurrentResourceQuotaSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "concurrentDeploymentSyncs": + if r.TryDecodeAsNil() { + x.ConcurrentDeploymentSyncs = 0 + } else { + x.ConcurrentDeploymentSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "concurrentDaemonSetSyncs": + if r.TryDecodeAsNil() { + x.ConcurrentDaemonSetSyncs = 0 + } else { + x.ConcurrentDaemonSetSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "concurrentJobSyncs": + if r.TryDecodeAsNil() { + x.ConcurrentJobSyncs = 0 + } else { + x.ConcurrentJobSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "concurrentNamespaceSyncs": + if r.TryDecodeAsNil() { + x.ConcurrentNamespaceSyncs = 0 + } else { + x.ConcurrentNamespaceSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "serviceSyncPeriod": + if r.TryDecodeAsNil() { + x.ServiceSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv797 := &x.ServiceSyncPeriod + yym798 := z.DecBinary() + _ = yym798 + if false { + } else if z.HasExtensions() && z.DecExt(yyv797) { + } else if !yym798 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv797) + } else { + z.DecFallback(yyv797, false) + } + } + case "nodeSyncPeriod": + if r.TryDecodeAsNil() { + x.NodeSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv799 := &x.NodeSyncPeriod + yym800 := z.DecBinary() + _ = yym800 + if false { + } else if z.HasExtensions() && z.DecExt(yyv799) { + } else if !yym800 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv799) + } else { + z.DecFallback(yyv799, false) + } + } + case "resourceQuotaSyncPeriod": + if r.TryDecodeAsNil() { + x.ResourceQuotaSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv801 := &x.ResourceQuotaSyncPeriod + yym802 := z.DecBinary() + _ = yym802 + if false { + } else if z.HasExtensions() && z.DecExt(yyv801) { + } else if !yym802 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv801) + } else { + z.DecFallback(yyv801, false) + } + } + case "namespaceSyncPeriod": + if r.TryDecodeAsNil() { + x.NamespaceSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv803 := &x.NamespaceSyncPeriod + yym804 := z.DecBinary() + _ = yym804 + if false { + } else if z.HasExtensions() && z.DecExt(yyv803) { + } else if !yym804 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv803) + } else { + z.DecFallback(yyv803, false) + } + } + case "pvClaimBinderSyncPeriod": + if r.TryDecodeAsNil() { + x.PVClaimBinderSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv805 := &x.PVClaimBinderSyncPeriod + yym806 := z.DecBinary() + _ = yym806 + if false { + } else if z.HasExtensions() && z.DecExt(yyv805) { + } else if !yym806 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv805) + } else { + z.DecFallback(yyv805, false) + } + } + case "minResyncPeriod": + if r.TryDecodeAsNil() { + x.MinResyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv807 := &x.MinResyncPeriod + yym808 := z.DecBinary() + _ = yym808 + if false { + } else if z.HasExtensions() && z.DecExt(yyv807) { + } else if !yym808 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv807) + } else { + z.DecFallback(yyv807, false) + } + } + case "terminatedPodGCThreshold": + if r.TryDecodeAsNil() { + x.TerminatedPodGCThreshold = 0 + } else { + x.TerminatedPodGCThreshold = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "horizontalPodAutoscalerSyncPeriod": + if r.TryDecodeAsNil() { + x.HorizontalPodAutoscalerSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv810 := &x.HorizontalPodAutoscalerSyncPeriod + yym811 := z.DecBinary() + _ = yym811 + if false { + } else if z.HasExtensions() && z.DecExt(yyv810) { + } else if !yym811 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv810) + } else { + z.DecFallback(yyv810, false) + } + } + case "deploymentControllerSyncPeriod": + if r.TryDecodeAsNil() { + x.DeploymentControllerSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv812 := &x.DeploymentControllerSyncPeriod + yym813 := z.DecBinary() + _ = yym813 + if false { + } else if z.HasExtensions() && z.DecExt(yyv812) { + } else if !yym813 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv812) + } else { + z.DecFallback(yyv812, false) + } + } + case "podEvictionTimeout": + if r.TryDecodeAsNil() { + x.PodEvictionTimeout = pkg1_unversioned.Duration{} + } else { + yyv814 := &x.PodEvictionTimeout + yym815 := z.DecBinary() + _ = yym815 + if false { + } else if z.HasExtensions() && z.DecExt(yyv814) { + } else if !yym815 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv814) + } else { + z.DecFallback(yyv814, false) + } + } + case "deletingPodsQps": + if r.TryDecodeAsNil() { + x.DeletingPodsQps = 0 + } else { + x.DeletingPodsQps = float32(r.DecodeFloat(true)) + } + case "deletingPodsBurst": + if r.TryDecodeAsNil() { + x.DeletingPodsBurst = 0 + } else { + x.DeletingPodsBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "nodeMonitorGracePeriod": + if r.TryDecodeAsNil() { + x.NodeMonitorGracePeriod = pkg1_unversioned.Duration{} + } else { + yyv818 := &x.NodeMonitorGracePeriod + yym819 := z.DecBinary() + _ = yym819 + if false { + } else if z.HasExtensions() && z.DecExt(yyv818) { + } else if !yym819 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv818) + } else { + z.DecFallback(yyv818, false) + } + } + case "registerRetryCount": + if r.TryDecodeAsNil() { + x.RegisterRetryCount = 0 + } else { + x.RegisterRetryCount = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "nodeStartupGracePeriod": + if r.TryDecodeAsNil() { + x.NodeStartupGracePeriod = pkg1_unversioned.Duration{} + } else { + yyv821 := &x.NodeStartupGracePeriod + yym822 := z.DecBinary() + _ = yym822 + if false { + } else if z.HasExtensions() && z.DecExt(yyv821) { + } else if !yym822 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv821) + } else { + z.DecFallback(yyv821, false) + } + } + case "nodeMonitorPeriod": + if r.TryDecodeAsNil() { + x.NodeMonitorPeriod = pkg1_unversioned.Duration{} + } else { + yyv823 := &x.NodeMonitorPeriod + yym824 := z.DecBinary() + _ = yym824 + if false { + } else if z.HasExtensions() && z.DecExt(yyv823) { + } else if !yym824 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv823) + } else { + z.DecFallback(yyv823, false) + } + } + case "serviceAccountKeyFile": + if r.TryDecodeAsNil() { + x.ServiceAccountKeyFile = "" + } else { + x.ServiceAccountKeyFile = string(r.DecodeString()) + } + case "enableProfiling": + if r.TryDecodeAsNil() { + x.EnableProfiling = false + } else { + x.EnableProfiling = bool(r.DecodeBool()) + } + case "clusterName": + if r.TryDecodeAsNil() { + x.ClusterName = "" + } else { + x.ClusterName = string(r.DecodeString()) + } + case "clusterCIDR": + if r.TryDecodeAsNil() { + x.ClusterCIDR = "" + } else { + x.ClusterCIDR = string(r.DecodeString()) + } + case "allocateNodeCIDRs": + if r.TryDecodeAsNil() { + x.AllocateNodeCIDRs = false + } else { + x.AllocateNodeCIDRs = bool(r.DecodeBool()) + } + case "rootCAFile": + if r.TryDecodeAsNil() { + x.RootCAFile = "" + } else { + x.RootCAFile = string(r.DecodeString()) + } + case "kubeAPIQPS": + if r.TryDecodeAsNil() { + x.KubeAPIQPS = 0 + } else { + x.KubeAPIQPS = float32(r.DecodeFloat(true)) + } + case "kubeAPIBurst": + if r.TryDecodeAsNil() { + x.KubeAPIBurst = 0 + } else { + x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "leaderElection": + if r.TryDecodeAsNil() { + x.LeaderElection = LeaderElectionConfiguration{} + } else { + yyv833 := &x.LeaderElection + yyv833.CodecDecodeSelf(d) + } + case "volumeConfiguration": + if r.TryDecodeAsNil() { + x.VolumeConfiguration = VolumeConfiguration{} + } else { + yyv834 := &x.VolumeConfiguration + yyv834.CodecDecodeSelf(d) + } + case "kind": + if r.TryDecodeAsNil() { + x.Kind = "" + } else { + x.Kind = string(r.DecodeString()) + } + case "apiVersion": + if r.TryDecodeAsNil() { + x.APIVersion = "" + } else { + x.APIVersion = string(r.DecodeString()) + } + default: + z.DecStructFieldNotFound(-1, yys784) + } // end switch yys784 + } // end for yyj784 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj837 int + var yyb837 bool + var yyhl837 bool = l >= 0 + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Port = 0 + } else { + x.Port = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Address = "" + } else { + x.Address = string(r.DecodeString()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.CloudProvider = "" + } else { + x.CloudProvider = string(r.DecodeString()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.CloudConfigFile = "" + } else { + x.CloudConfigFile = string(r.DecodeString()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConcurrentEndpointSyncs = 0 + } else { + x.ConcurrentEndpointSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConcurrentRSSyncs = 0 + } else { + x.ConcurrentRSSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConcurrentRCSyncs = 0 + } else { + x.ConcurrentRCSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConcurrentResourceQuotaSyncs = 0 + } else { + x.ConcurrentResourceQuotaSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConcurrentDeploymentSyncs = 0 + } else { + x.ConcurrentDeploymentSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConcurrentDaemonSetSyncs = 0 + } else { + x.ConcurrentDaemonSetSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConcurrentJobSyncs = 0 + } else { + x.ConcurrentJobSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ConcurrentNamespaceSyncs = 0 + } else { + x.ConcurrentNamespaceSyncs = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ServiceSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv850 := &x.ServiceSyncPeriod + yym851 := z.DecBinary() + _ = yym851 + if false { + } else if z.HasExtensions() && z.DecExt(yyv850) { + } else if !yym851 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv850) + } else { + z.DecFallback(yyv850, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv852 := &x.NodeSyncPeriod + yym853 := z.DecBinary() + _ = yym853 + if false { + } else if z.HasExtensions() && z.DecExt(yyv852) { + } else if !yym853 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv852) + } else { + z.DecFallback(yyv852, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ResourceQuotaSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv854 := &x.ResourceQuotaSyncPeriod + yym855 := z.DecBinary() + _ = yym855 + if false { + } else if z.HasExtensions() && z.DecExt(yyv854) { + } else if !yym855 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv854) + } else { + z.DecFallback(yyv854, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NamespaceSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv856 := &x.NamespaceSyncPeriod + yym857 := z.DecBinary() + _ = yym857 + if false { + } else if z.HasExtensions() && z.DecExt(yyv856) { + } else if !yym857 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv856) + } else { + z.DecFallback(yyv856, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PVClaimBinderSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv858 := &x.PVClaimBinderSyncPeriod + yym859 := z.DecBinary() + _ = yym859 + if false { + } else if z.HasExtensions() && z.DecExt(yyv858) { + } else if !yym859 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv858) + } else { + z.DecFallback(yyv858, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MinResyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv860 := &x.MinResyncPeriod + yym861 := z.DecBinary() + _ = yym861 + if false { + } else if z.HasExtensions() && z.DecExt(yyv860) { + } else if !yym861 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv860) + } else { + z.DecFallback(yyv860, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.TerminatedPodGCThreshold = 0 + } else { + x.TerminatedPodGCThreshold = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.HorizontalPodAutoscalerSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv863 := &x.HorizontalPodAutoscalerSyncPeriod + yym864 := z.DecBinary() + _ = yym864 + if false { + } else if z.HasExtensions() && z.DecExt(yyv863) { + } else if !yym864 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv863) + } else { + z.DecFallback(yyv863, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.DeploymentControllerSyncPeriod = pkg1_unversioned.Duration{} + } else { + yyv865 := &x.DeploymentControllerSyncPeriod + yym866 := z.DecBinary() + _ = yym866 + if false { + } else if z.HasExtensions() && z.DecExt(yyv865) { + } else if !yym866 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv865) + } else { + z.DecFallback(yyv865, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PodEvictionTimeout = pkg1_unversioned.Duration{} + } else { + yyv867 := &x.PodEvictionTimeout + yym868 := z.DecBinary() + _ = yym868 + if false { + } else if z.HasExtensions() && z.DecExt(yyv867) { + } else if !yym868 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv867) + } else { + z.DecFallback(yyv867, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.DeletingPodsQps = 0 + } else { + x.DeletingPodsQps = float32(r.DecodeFloat(true)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.DeletingPodsBurst = 0 + } else { + x.DeletingPodsBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeMonitorGracePeriod = pkg1_unversioned.Duration{} + } else { + yyv871 := &x.NodeMonitorGracePeriod + yym872 := z.DecBinary() + _ = yym872 + if false { + } else if z.HasExtensions() && z.DecExt(yyv871) { + } else if !yym872 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv871) + } else { + z.DecFallback(yyv871, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RegisterRetryCount = 0 + } else { + x.RegisterRetryCount = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeStartupGracePeriod = pkg1_unversioned.Duration{} + } else { + yyv874 := &x.NodeStartupGracePeriod + yym875 := z.DecBinary() + _ = yym875 + if false { + } else if z.HasExtensions() && z.DecExt(yyv874) { + } else if !yym875 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv874) + } else { + z.DecFallback(yyv874, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeMonitorPeriod = pkg1_unversioned.Duration{} + } else { + yyv876 := &x.NodeMonitorPeriod + yym877 := z.DecBinary() + _ = yym877 + if false { + } else if z.HasExtensions() && z.DecExt(yyv876) { + } else if !yym877 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv876) + } else { + z.DecFallback(yyv876, false) + } + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ServiceAccountKeyFile = "" + } else { + x.ServiceAccountKeyFile = string(r.DecodeString()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.EnableProfiling = false + } else { + x.EnableProfiling = bool(r.DecodeBool()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ClusterName = "" + } else { + x.ClusterName = string(r.DecodeString()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ClusterCIDR = "" + } else { + x.ClusterCIDR = string(r.DecodeString()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.AllocateNodeCIDRs = false + } else { + x.AllocateNodeCIDRs = bool(r.DecodeBool()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RootCAFile = "" + } else { + x.RootCAFile = string(r.DecodeString()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.KubeAPIQPS = 0 + } else { + x.KubeAPIQPS = float32(r.DecodeFloat(true)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.KubeAPIBurst = 0 + } else { + x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.LeaderElection = LeaderElectionConfiguration{} + } else { + yyv886 := &x.LeaderElection + yyv886.CodecDecodeSelf(d) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.VolumeConfiguration = VolumeConfiguration{} + } else { + yyv887 := &x.VolumeConfiguration + yyv887.CodecDecodeSelf(d) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Kind = "" + } else { + x.Kind = string(r.DecodeString()) + } + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.APIVersion = "" + } else { + x.APIVersion = string(r.DecodeString()) + } + for { + yyj837++ + if yyhl837 { + yyb837 = yyj837 > l + } else { + yyb837 = r.CheckBreak() + } + if yyb837 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj837-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *VolumeConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym890 := z.EncBinary() + _ = yym890 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep891 := !z.EncBinary() + yy2arr891 := z.EncBasicHandle().StructToArray + var yyq891 [2]bool + _, _, _ = yysep891, yyq891, yy2arr891 + const yyr891 bool = false + var yynn891 int + if yyr891 || yy2arr891 { + r.EncodeArrayStart(2) + } else { + yynn891 = 2 + for _, b := range yyq891 { + if b { + yynn891++ + } + } + r.EncodeMapStart(yynn891) + yynn891 = 0 + } + if yyr891 || yy2arr891 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym893 := z.EncBinary() + _ = yym893 + if false { + } else { + r.EncodeBool(bool(x.EnableHostPathProvisioning)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("enableHostPathProvisioning")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym894 := z.EncBinary() + _ = yym894 + if false { + } else { + r.EncodeBool(bool(x.EnableHostPathProvisioning)) + } + } + if yyr891 || yy2arr891 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy896 := &x.PersistentVolumeRecyclerConfiguration + yy896.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("persitentVolumeRecyclerConfiguration")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy897 := &x.PersistentVolumeRecyclerConfiguration + yy897.CodecEncodeSelf(e) + } + if yyr891 || yy2arr891 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *VolumeConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym898 := z.DecBinary() + _ = yym898 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct899 := r.ContainerType() + if yyct899 == codecSelferValueTypeMap1234 { + yyl899 := r.ReadMapStart() + if yyl899 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl899, d) + } + } else if yyct899 == codecSelferValueTypeArray1234 { + yyl899 := r.ReadArrayStart() + if yyl899 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl899, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *VolumeConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys900Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys900Slc + var yyhl900 bool = l >= 0 + for yyj900 := 0; ; yyj900++ { + if yyhl900 { + if yyj900 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys900Slc = r.DecodeBytes(yys900Slc, true, true) + yys900 := string(yys900Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys900 { + case "enableHostPathProvisioning": + if r.TryDecodeAsNil() { + x.EnableHostPathProvisioning = false + } else { + x.EnableHostPathProvisioning = bool(r.DecodeBool()) + } + case "persitentVolumeRecyclerConfiguration": + if r.TryDecodeAsNil() { + x.PersistentVolumeRecyclerConfiguration = PersistentVolumeRecyclerConfiguration{} + } else { + yyv902 := &x.PersistentVolumeRecyclerConfiguration + yyv902.CodecDecodeSelf(d) + } + default: + z.DecStructFieldNotFound(-1, yys900) + } // end switch yys900 + } // end for yyj900 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj903 int + var yyb903 bool + var yyhl903 bool = l >= 0 + yyj903++ + if yyhl903 { + yyb903 = yyj903 > l + } else { + yyb903 = r.CheckBreak() + } + if yyb903 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.EnableHostPathProvisioning = false + } else { + x.EnableHostPathProvisioning = bool(r.DecodeBool()) + } + yyj903++ + if yyhl903 { + yyb903 = yyj903 > l + } else { + yyb903 = r.CheckBreak() + } + if yyb903 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PersistentVolumeRecyclerConfiguration = PersistentVolumeRecyclerConfiguration{} + } else { + yyv905 := &x.PersistentVolumeRecyclerConfiguration + yyv905.CodecDecodeSelf(d) + } + for { + yyj903++ + if yyhl903 { + yyb903 = yyj903 > l + } else { + yyb903 = r.CheckBreak() + } + if yyb903 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj903-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym906 := z.EncBinary() + _ = yym906 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep907 := !z.EncBinary() + yy2arr907 := z.EncBasicHandle().StructToArray + var yyq907 [7]bool + _, _, _ = yysep907, yyq907, yy2arr907 + const yyr907 bool = false + var yynn907 int + if yyr907 || yy2arr907 { + r.EncodeArrayStart(7) + } else { + yynn907 = 7 + for _, b := range yyq907 { + if b { + yynn907++ + } + } + r.EncodeMapStart(yynn907) + yynn907 = 0 + } + if yyr907 || yy2arr907 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym909 := z.EncBinary() + _ = yym909 + if false { + } else { + r.EncodeInt(int64(x.MaximumRetry)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("maximumRetry")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym910 := z.EncBinary() + _ = yym910 + if false { + } else { + r.EncodeInt(int64(x.MaximumRetry)) + } + } + if yyr907 || yy2arr907 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym912 := z.EncBinary() + _ = yym912 + if false { + } else { + r.EncodeInt(int64(x.MinimumTimeoutNFS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("minimumTimeoutNFS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym913 := z.EncBinary() + _ = yym913 + if false { + } else { + r.EncodeInt(int64(x.MinimumTimeoutNFS)) + } + } + if yyr907 || yy2arr907 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym915 := z.EncBinary() + _ = yym915 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PodTemplateFilePathNFS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("podTemplateFilePathNFS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym916 := z.EncBinary() + _ = yym916 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PodTemplateFilePathNFS)) + } + } + if yyr907 || yy2arr907 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym918 := z.EncBinary() + _ = yym918 + if false { + } else { + r.EncodeInt(int64(x.IncrementTimeoutNFS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("incrementTimeoutNFS")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym919 := z.EncBinary() + _ = yym919 + if false { + } else { + r.EncodeInt(int64(x.IncrementTimeoutNFS)) + } + } + if yyr907 || yy2arr907 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym921 := z.EncBinary() + _ = yym921 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PodTemplateFilePathHostPath)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("podTemplateFilePathHostPath")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym922 := z.EncBinary() + _ = yym922 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.PodTemplateFilePathHostPath)) + } + } + if yyr907 || yy2arr907 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym924 := z.EncBinary() + _ = yym924 + if false { + } else { + r.EncodeInt(int64(x.MinimumTimeoutHostPath)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("minimumTimeoutHostPath")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym925 := z.EncBinary() + _ = yym925 + if false { + } else { + r.EncodeInt(int64(x.MinimumTimeoutHostPath)) + } + } + if yyr907 || yy2arr907 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym927 := z.EncBinary() + _ = yym927 + if false { + } else { + r.EncodeInt(int64(x.IncrementTimeoutHostPath)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("incrementTimeoutHostPath")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym928 := z.EncBinary() + _ = yym928 + if false { + } else { + r.EncodeInt(int64(x.IncrementTimeoutHostPath)) + } + } + if yyr907 || yy2arr907 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *PersistentVolumeRecyclerConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym929 := z.DecBinary() + _ = yym929 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct930 := r.ContainerType() + if yyct930 == codecSelferValueTypeMap1234 { + yyl930 := r.ReadMapStart() + if yyl930 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl930, d) + } + } else if yyct930 == codecSelferValueTypeArray1234 { + yyl930 := r.ReadArrayStart() + if yyl930 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl930, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys931Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys931Slc + var yyhl931 bool = l >= 0 + for yyj931 := 0; ; yyj931++ { + if yyhl931 { + if yyj931 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys931Slc = r.DecodeBytes(yys931Slc, true, true) + yys931 := string(yys931Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys931 { + case "maximumRetry": + if r.TryDecodeAsNil() { + x.MaximumRetry = 0 + } else { + x.MaximumRetry = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "minimumTimeoutNFS": + if r.TryDecodeAsNil() { + x.MinimumTimeoutNFS = 0 + } else { + x.MinimumTimeoutNFS = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "podTemplateFilePathNFS": + if r.TryDecodeAsNil() { + x.PodTemplateFilePathNFS = "" + } else { + x.PodTemplateFilePathNFS = string(r.DecodeString()) + } + case "incrementTimeoutNFS": + if r.TryDecodeAsNil() { + x.IncrementTimeoutNFS = 0 + } else { + x.IncrementTimeoutNFS = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "podTemplateFilePathHostPath": + if r.TryDecodeAsNil() { + x.PodTemplateFilePathHostPath = "" + } else { + x.PodTemplateFilePathHostPath = string(r.DecodeString()) + } + case "minimumTimeoutHostPath": + if r.TryDecodeAsNil() { + x.MinimumTimeoutHostPath = 0 + } else { + x.MinimumTimeoutHostPath = int(r.DecodeInt(codecSelferBitsize1234)) + } + case "incrementTimeoutHostPath": + if r.TryDecodeAsNil() { + x.IncrementTimeoutHostPath = 0 + } else { + x.IncrementTimeoutHostPath = int(r.DecodeInt(codecSelferBitsize1234)) + } + default: + z.DecStructFieldNotFound(-1, yys931) + } // end switch yys931 + } // end for yyj931 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj939 int + var yyb939 bool + var yyhl939 bool = l >= 0 + yyj939++ + if yyhl939 { + yyb939 = yyj939 > l + } else { + yyb939 = r.CheckBreak() + } + if yyb939 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MaximumRetry = 0 + } else { + x.MaximumRetry = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj939++ + if yyhl939 { + yyb939 = yyj939 > l + } else { + yyb939 = r.CheckBreak() + } + if yyb939 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MinimumTimeoutNFS = 0 + } else { + x.MinimumTimeoutNFS = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj939++ + if yyhl939 { + yyb939 = yyj939 > l + } else { + yyb939 = r.CheckBreak() + } + if yyb939 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PodTemplateFilePathNFS = "" + } else { + x.PodTemplateFilePathNFS = string(r.DecodeString()) + } + yyj939++ + if yyhl939 { + yyb939 = yyj939 > l + } else { + yyb939 = r.CheckBreak() + } + if yyb939 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.IncrementTimeoutNFS = 0 + } else { + x.IncrementTimeoutNFS = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj939++ + if yyhl939 { + yyb939 = yyj939 > l + } else { + yyb939 = r.CheckBreak() + } + if yyb939 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.PodTemplateFilePathHostPath = "" + } else { + x.PodTemplateFilePathHostPath = string(r.DecodeString()) + } + yyj939++ + if yyhl939 { + yyb939 = yyj939 > l + } else { + yyb939 = r.CheckBreak() + } + if yyb939 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.MinimumTimeoutHostPath = 0 + } else { + x.MinimumTimeoutHostPath = int(r.DecodeInt(codecSelferBitsize1234)) + } + yyj939++ + if yyhl939 { + yyb939 = yyj939 > l + } else { + yyb939 = r.CheckBreak() + } + if yyb939 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.IncrementTimeoutHostPath = 0 + } else { + x.IncrementTimeoutHostPath = int(r.DecodeInt(codecSelferBitsize1234)) + } + for { + yyj939++ + if yyhl939 { + yyb939 = yyj939 > l + } else { + yyb939 = r.CheckBreak() + } + if yyb939 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj939-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +}