diff --git a/pkg/kubelet/kubeletconfig/BUILD b/pkg/kubelet/kubeletconfig/BUILD index ba381a6fed7..d5ea255591a 100644 --- a/pkg/kubelet/kubeletconfig/BUILD +++ b/pkg/kubelet/kubeletconfig/BUILD @@ -10,7 +10,6 @@ go_library( srcs = [ "configsync.go", "controller.go", - "rollback.go", "watch.go", ], importpath = "k8s.io/kubernetes/pkg/kubelet/kubeletconfig", diff --git a/pkg/kubelet/kubeletconfig/configsync.go b/pkg/kubelet/kubeletconfig/configsync.go index 66f9eb9160e..ce6b7e38bc3 100644 --- a/pkg/kubelet/kubeletconfig/configsync.go +++ b/pkg/kubelet/kubeletconfig/configsync.go @@ -168,7 +168,7 @@ func (cc *Controller) setCurrentConfig(source checkpoint.RemoteConfigSource) (bo updated, err := cc.checkpointStore.SetCurrentUpdated(source) if err != nil { if source == nil { - return false, status.FailSyncReasonSetCurrentDefault, err + return false, status.FailSyncReasonSetCurrentLocal, err } return false, fmt.Sprintf(status.FailSyncReasonSetCurrentUIDFmt, source.UID()), err } diff --git a/pkg/kubelet/kubeletconfig/controller.go b/pkg/kubelet/kubeletconfig/controller.go index 5fe998b1960..9b959b4c94b 100644 --- a/pkg/kubelet/kubeletconfig/controller.go +++ b/pkg/kubelet/kubeletconfig/controller.go @@ -28,6 +28,8 @@ import ( "k8s.io/client-go/tools/cache" "k8s.io/kubernetes/pkg/kubelet/apis/kubeletconfig" "k8s.io/kubernetes/pkg/kubelet/apis/kubeletconfig/validation" + + "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/checkpoint" "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/checkpoint/store" "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/configfiles" "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/status" @@ -55,11 +57,8 @@ type Controller struct { // defaultConfig is the configuration to use if no initConfig is provided defaultConfig *kubeletconfig.KubeletConfiguration - // initConfig is the unmarshaled init config, this will be loaded by the Controller if an initConfigDir is provided - initConfig *kubeletconfig.KubeletConfiguration - - // initLoader is for loading the Kubelet's init configuration files from disk - initLoader configfiles.Loader + // fileLoader is for loading the Kubelet's local config files from disk + fileLoader configfiles.Loader // pendingConfigSource; write to this channel to indicate that the config source needs to be synced from the API server pendingConfigSource chan bool @@ -85,9 +84,9 @@ func NewController(defaultConfig *kubeletconfig.KubeletConfiguration, fs := utilfs.DefaultFs{} - var initLoader configfiles.Loader + var fileLoader configfiles.Loader if len(initConfigDir) > 0 { - initLoader, err = configfiles.NewFsLoader(fs, initConfigDir) + fileLoader, err = configfiles.NewFsLoader(fs, initConfigDir) if err != nil { return nil, err } @@ -104,7 +103,7 @@ func NewController(defaultConfig *kubeletconfig.KubeletConfiguration, pendingConfigSource: make(chan bool, 1), configOK: status.NewConfigOKCondition(), checkpointStore: store.NewFsStore(fs, filepath.Join(dynamicConfigDir, checkpointsDir)), - initLoader: initLoader, + fileLoader: fileLoader, }, nil } @@ -113,88 +112,72 @@ func NewController(defaultConfig *kubeletconfig.KubeletConfiguration, func (cc *Controller) Bootstrap() (*kubeletconfig.KubeletConfiguration, error) { utillog.Infof("starting controller") - // ALWAYS validate the local (default and init) configs. This makes incorrectly provisioned nodes an error. - // These must be valid because they are the foundational last-known-good configs. - utillog.Infof("validating combination of defaults and flags") - if err := validation.ValidateKubeletConfiguration(cc.defaultConfig); err != nil { - return nil, fmt.Errorf("combination of defaults and flags failed validation, error: %v", err) - } - // only attempt to load and validate the init config if the user provided a path - if cc.initLoader != nil { - utillog.Infof("loading init config") - kc, err := cc.initLoader.Load() - if err != nil { - return nil, err - } - // validate the init config - utillog.Infof("validating init config") - if err := validation.ValidateKubeletConfiguration(kc); err != nil { - return nil, fmt.Errorf("failed to validate the init config, error: %v", err) - } - cc.initConfig = kc - } - // Assert: the default and init configs are both valid + // Load and validate the local config (defaults + flags, file) + local, err := cc.loadLocalConfig() + if err != nil { + return nil, err + } // Assert: the default and init configs are both valid - // if dynamic config is disabled, skip trying to load any checkpoints because they won't exist + // if dynamic config is disabled, we just stop here if !cc.dynamicConfig { - return cc.localConfig(), nil - } + // NOTE(mtaufen): We still need to update the status. + // We expect to be able to disable dynamic config but still get a status update about the config. + // This is because the feature gate covers dynamic config AND config status reporting, while the + // --dynamic-config-dir flag just covers dynamic config. + cc.configOK.Set(status.NotDynamicLocalMessage, status.NotDynamicLocalReason, apiv1.ConditionTrue) + return local, nil + } // Assert: dynamic config is enabled - // assert: now we know that a dynamicConfigDir was provided, and we can rely on that existing - - // make sure the filesystem is set up properly + // ensure the filesystem is initialized if err := cc.initializeDynamicConfigDir(); err != nil { return nil, err } - // determine UID of the current config source - curUID := "" - if curSource, err := cc.checkpointStore.Current(); err != nil { - return nil, err - } else if curSource != nil { - curUID = curSource.UID() - } + assigned, curSource, reason, err := cc.loadAssignedConfig(local) + if err == nil { + // set the status to indicate we will use the assigned config + if curSource != nil { + cc.configOK.Set(fmt.Sprintf(status.CurRemoteMessageFmt, curSource.UID()), reason, apiv1.ConditionTrue) + } else { + cc.configOK.Set(status.CurLocalMessage, reason, apiv1.ConditionTrue) + } - // if curUID indicates the local config should be used, return the correct one of those - if len(curUID) == 0 { - return cc.localConfig(), nil - } // Assert: we will not use the local configurations, unless we roll back to lkg; curUID is non-empty + // when the trial period is over, the assigned config becomes the last-known-good + if trial, err := cc.inTrial(assigned.ConfigTrialDuration.Duration); err != nil { + utillog.Errorf("failed to check trial period for assigned config, error: %v", err) + } else if !trial { + utillog.Infof("assigned config passed trial period, will set as last-known-good") + if err := cc.graduateAssignedToLastKnownGood(); err != nil { + utillog.Errorf("failed to set last-known-good to assigned config, error: %v", err) + } + } - // TODO(mtaufen): consider re-verifying integrity and re-attempting download when a load/verify/parse/validate + return assigned, nil + } // Assert: the assigned config failed to load, parse, or validate + + // TODO(mtaufen): consider re-attempting download when a load/verify/parse/validate // error happens outside trial period, we already made it past the trial so it's probably filesystem corruption // or something else scary (unless someone is using a 0-length trial period) + // load from checkpoint - // load the current config - checkpoint, err := cc.checkpointStore.Load(curUID) + // log the reason and error details for the failure to load the assigned config + utillog.Errorf(fmt.Sprintf("%s, error: %v", reason, err)) + + // load the last-known-good config + lkg, lkgSource, err := cc.loadLastKnownGoodConfig(local) if err != nil { - // TODO(mtaufen): rollback for now, but this could reasonably be handled by re-attempting a download, - // it probably indicates some sort of corruption - return cc.lkgRollback(fmt.Sprintf(status.CurFailLoadReasonFmt, curUID), fmt.Sprintf("error: %v", err)) - } - - // parse the checkpoint into a KubeletConfiguration - cur, err := checkpoint.Parse() - if err != nil { - return cc.lkgRollback(fmt.Sprintf(status.CurFailParseReasonFmt, curUID), fmt.Sprintf("error: %v", err)) - } - - // validate current config - if err := validation.ValidateKubeletConfiguration(cur); err != nil { - return cc.lkgRollback(fmt.Sprintf(status.CurFailValidateReasonFmt, curUID), fmt.Sprintf("error: %v", err)) - } - - // when the trial period is over, the current config becomes the last-known-good - if trial, err := cc.inTrial(cur.ConfigTrialDuration.Duration); err != nil { return nil, err - } else if !trial { - if err := cc.graduateCurrentToLastKnownGood(); err != nil { - return nil, err - } } - // update the status to note that we will use the current config - cc.configOK.Set(fmt.Sprintf(status.CurRemoteMessageFmt, curUID), status.CurRemoteOKReason, apiv1.ConditionTrue) - return cur, nil + // set the status to indicate that we had to roll back to the lkg for the reason reported when we tried to load the assigned config + if lkgSource != nil { + cc.configOK.Set(fmt.Sprintf(status.LkgRemoteMessageFmt, lkgSource.UID()), reason, apiv1.ConditionFalse) + } else { + cc.configOK.Set(status.LkgLocalMessage, reason, apiv1.ConditionFalse) + } + + // return the last-known-good config + return lkg, nil } // StartSync launches the controller's sync loops if `client` is non-nil and `nodeName` is non-empty. @@ -243,6 +226,93 @@ func (cc *Controller) StartSync(client clientset.Interface, eventClient v1core.E } } +// loadLocalConfig returns the local config: either the defaults provided to the controller or +// a local config file, if the Kubelet is configured to use the local file +func (cc *Controller) loadLocalConfig() (*kubeletconfig.KubeletConfiguration, error) { + // ALWAYS validate the local configs. This makes incorrectly provisioned nodes an error. + // These must be valid because they are the default last-known-good configs. + utillog.Infof("validating combination of defaults and flags") + if err := validation.ValidateKubeletConfiguration(cc.defaultConfig); err != nil { + return nil, fmt.Errorf("combination of defaults and flags failed validation, error: %v", err) + } + // only attempt to load and validate the Kubelet config file if the user provided a path + if cc.fileLoader != nil { + utillog.Infof("loading Kubelet config file") + kc, err := cc.fileLoader.Load() + if err != nil { + return nil, err + } + // validate the Kubelet config file config + utillog.Infof("validating Kubelet config file") + if err := validation.ValidateKubeletConfiguration(kc); err != nil { + return nil, fmt.Errorf("failed to validate the Kubelet config file, error: %v", err) + } + return kc, nil + } + // if no Kubelet config file config, just return the default + return cc.defaultConfig, nil +} + +// loadAssignedConfig loads the Kubelet's currently assigned config, +// based on the setting in the local checkpoint store. +// It returns the loaded configuration, the checkpoint store's config source record, +// a clean success or failure reason that can be reported in the status, and any error that occurs. +// If the local config should be used, it will be returned. You should validate local before passing it to this function. +func (cc *Controller) loadAssignedConfig(local *kubeletconfig.KubeletConfiguration) (*kubeletconfig.KubeletConfiguration, checkpoint.RemoteConfigSource, string, error) { + src, err := cc.checkpointStore.Current() + if err != nil { + return nil, nil, fmt.Sprintf(status.CurFailLoadReasonFmt, "unknown"), err + } + // nil source is the signal to use the local config + if src == nil { + return local, src, status.CurLocalOkayReason, nil + } + curUID := src.UID() + // load from checkpoint + checkpoint, err := cc.checkpointStore.Load(curUID) + if err != nil { + return nil, src, fmt.Sprintf(status.CurFailLoadReasonFmt, curUID), err + } + cur, err := checkpoint.Parse() + if err != nil { + return nil, src, fmt.Sprintf(status.CurFailParseReasonFmt, curUID), err + } + if err := validation.ValidateKubeletConfiguration(cur); err != nil { + return nil, src, fmt.Sprintf(status.CurFailValidateReasonFmt, curUID), err + } + return cur, src, status.CurRemoteOkayReason, nil +} + +// loadLastKnownGoodConfig loads the Kubelet's last-known-good config, +// based on the setting in the local checkpoint store. +// It returns the loaded configuration, the checkpoint store's config source record, +// and any error that occurs. +// If the local config should be used, it will be returned. You should validate local before passing it to this function. +func (cc *Controller) loadLastKnownGoodConfig(local *kubeletconfig.KubeletConfiguration) (*kubeletconfig.KubeletConfiguration, checkpoint.RemoteConfigSource, error) { + src, err := cc.checkpointStore.LastKnownGood() + if err != nil { + return nil, nil, fmt.Errorf("unable to determine last-known-good config, error: %v", err) + } + // nil source is the signal to use the local config + if src == nil { + return local, src, nil + } + lkgUID := src.UID() + // load from checkpoint + checkpoint, err := cc.checkpointStore.Load(lkgUID) + if err != nil { + return nil, src, fmt.Errorf("%s, error: %v", fmt.Sprintf(status.LkgFailLoadReasonFmt, lkgUID), err) + } + lkg, err := checkpoint.Parse() + if err != nil { + return nil, src, fmt.Errorf("%s, error: %v", fmt.Sprintf(status.LkgFailParseReasonFmt, lkgUID), err) + } + if err := validation.ValidateKubeletConfiguration(lkg); err != nil { + return nil, src, fmt.Errorf("%s, error: %v", fmt.Sprintf(status.LkgFailValidateReasonFmt, lkgUID), err) + } + return lkg, src, nil +} + // initializeDynamicConfigDir makes sure that the storage layers for various controller components are set up correctly func (cc *Controller) initializeDynamicConfigDir() error { utillog.Infof("ensuring filesystem is set up correctly") @@ -250,17 +320,6 @@ func (cc *Controller) initializeDynamicConfigDir() error { return cc.checkpointStore.Initialize() } -// localConfig returns the initConfig if it is loaded, otherwise returns the defaultConfig. -// It also sets the local configOK condition to match the returned config. -func (cc *Controller) localConfig() *kubeletconfig.KubeletConfiguration { - if cc.initConfig != nil { - cc.configOK.Set(status.CurInitMessage, status.CurInitOKReason, apiv1.ConditionTrue) - return cc.initConfig - } - cc.configOK.Set(status.CurDefaultMessage, status.CurDefaultOKReason, apiv1.ConditionTrue) - return cc.defaultConfig -} - // inTrial returns true if the time elapsed since the last modification of the current config does not exceed `trialDur`, false otherwise func (cc *Controller) inTrial(trialDur time.Duration) (bool, error) { now := time.Now() @@ -274,16 +333,16 @@ func (cc *Controller) inTrial(trialDur time.Duration) (bool, error) { return false, nil } -// graduateCurrentToLastKnownGood sets the last-known-good UID on the checkpointStore +// graduateAssignedToLastKnownGood sets the last-known-good UID on the checkpointStore // to the same value as the current UID maintained by the checkpointStore -func (cc *Controller) graduateCurrentToLastKnownGood() error { +func (cc *Controller) graduateAssignedToLastKnownGood() error { curUID, err := cc.checkpointStore.Current() if err != nil { - return fmt.Errorf("could not graduate last-known-good config to current config, error: %v", err) + return err } err = cc.checkpointStore.SetLastKnownGood(curUID) if err != nil { - return fmt.Errorf("could not graduate last-known-good config to current config, error: %v", err) + return err } return nil } diff --git a/pkg/kubelet/kubeletconfig/rollback.go b/pkg/kubelet/kubeletconfig/rollback.go deleted file mode 100644 index a2789566345..00000000000 --- a/pkg/kubelet/kubeletconfig/rollback.go +++ /dev/null @@ -1,70 +0,0 @@ -/* -Copyright 2017 The Kubernetes Authors. - -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. -*/ - -package kubeletconfig - -import ( - "fmt" - - apiv1 "k8s.io/api/core/v1" - "k8s.io/kubernetes/pkg/kubelet/apis/kubeletconfig" - "k8s.io/kubernetes/pkg/kubelet/apis/kubeletconfig/validation" - "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/status" - utillog "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/util/log" -) - -// lkgRollback returns a valid last-known-good configuration, and updates the `cc.configOK` condition -// regarding the `reason` for the rollback, or returns an error if a valid last-known-good could not be produced -func (cc *Controller) lkgRollback(reason, detail string) (*kubeletconfig.KubeletConfiguration, error) { - utillog.Errorf(fmt.Sprintf("%s, %s", reason, detail)) - - lkgUID := "" - if lkgSource, err := cc.checkpointStore.LastKnownGood(); err != nil { - return nil, fmt.Errorf("unable to determine last-known-good config, error: %v", err) - } else if lkgSource != nil { - lkgUID = lkgSource.UID() - } - - // if lkgUID indicates the default should be used, return initConfig or defaultConfig - if len(lkgUID) == 0 { - if cc.initConfig != nil { - cc.configOK.Set(status.LkgInitMessage, reason, apiv1.ConditionFalse) - return cc.initConfig, nil - } - cc.configOK.Set(status.LkgDefaultMessage, reason, apiv1.ConditionFalse) - return cc.defaultConfig, nil - } - - // load - checkpoint, err := cc.checkpointStore.Load(lkgUID) - if err != nil { - return nil, fmt.Errorf("%s, error: %v", fmt.Sprintf(status.LkgFailLoadReasonFmt, lkgUID), err) - } - - // parse - lkg, err := checkpoint.Parse() - if err != nil { - return nil, fmt.Errorf("%s, error: %v", fmt.Sprintf(status.LkgFailParseReasonFmt, lkgUID), err) - } - - // validate - if err := validation.ValidateKubeletConfiguration(lkg); err != nil { - return nil, fmt.Errorf("%s, error: %v", fmt.Sprintf(status.LkgFailValidateReasonFmt, lkgUID), err) - } - - cc.configOK.Set(fmt.Sprintf(status.LkgRemoteMessageFmt, lkgUID), reason, apiv1.ConditionFalse) - return lkg, nil -} diff --git a/pkg/kubelet/kubeletconfig/status/status.go b/pkg/kubelet/kubeletconfig/status/status.go index b83e6891d78..94598cae6eb 100644 --- a/pkg/kubelet/kubeletconfig/status/status.go +++ b/pkg/kubelet/kubeletconfig/status/status.go @@ -32,28 +32,27 @@ import ( utillog "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/util/log" ) +// TODO(mtaufen): s/current/assigned, as this is more accurate e.g. if you are using lkg, you aren't currently using "current" :) const ( - // CurDefaultMessage indicates the Kubelet is using it's current config, which is the default - CurDefaultMessage = "using current (default)" - // LkgDefaultMessage indicates the Kubelet is using it's last-known-good config, which is the default - LkgDefaultMessage = "using last-known-good (default)" + // NotDynamicLocalMessage indicates that the Kubelet is using its local config - we send this when dynamic Kubelet config is disabled by omitting the --dynamic-config-dir flag + NotDynamicLocalMessage = "using local config" + // NotDynamicLocalReason indicates that the Kubelet is using its local config - we send this when dynamic Kubelet config is disabled by omitting the --dynamic-config-dir flag + NotDynamicLocalReason = "dynamic config is currently disabled by omission of --dynamic-config-dir Kubelet flag" - // CurInitMessage indicates the Kubelet is using it's current config, which is from the init config files - CurInitMessage = "using current (init)" - // LkgInitMessage indicates the Kubelet is using it's last-known-good config, which is from the init config files - LkgInitMessage = "using last-known-good (init)" + // CurLocalMessage indicates that the Kubelet is using its local config, which consists of defaults, flags, and/or local files + CurLocalMessage = "using current (local)" + // LkgLocalMessage indicates that the Kubelet is using its local config, which consists of defaults, flags, and/or local files + LkgLocalMessage = "using last-known-good (local)" - // CurRemoteMessageFmt indicates the Kubelet is usin it's current config, which is from an API source + // CurRemoteMessageFmt indicates the Kubelet is using its current config, which is from an API source CurRemoteMessageFmt = "using current (UID: %q)" - // LkgRemoteMessageFmt indicates the Kubelet is using it's last-known-good config, which is from an API source + // LkgRemoteMessageFmt indicates the Kubelet is using its last-known-good config, which is from an API source LkgRemoteMessageFmt = "using last-known-good (UID: %q)" - // CurDefaultOKReason indicates that no init config files were provided - CurDefaultOKReason = "current is set to the local default, and no init config was provided" - // CurInitOKReason indicates that init config files were provided - CurInitOKReason = "current is set to the local default, and an init config was provided" - // CurRemoteOKReason indicates that the config referenced by Node.ConfigSource is currently passing all checks - CurRemoteOKReason = "passing all checks" + // CurLocalOkayReason indicates that the Kubelet is using its local config + CurLocalOkayReason = "when the config source is nil, the Kubelet uses its local config" + // CurRemoteOkayReason indicates that the config referenced by Node.ConfigSource is currently passing all checks + CurRemoteOkayReason = "passing all checks" // CurFailLoadReasonFmt indicates that the Kubelet failed to load the current config checkpoint for an API source CurFailLoadReasonFmt = "failed to load current (UID: %q)" @@ -61,8 +60,6 @@ const ( CurFailParseReasonFmt = "failed to parse current (UID: %q)" // CurFailValidateReasonFmt indicates that the Kubelet failed to validate the current config checkpoint for an API source CurFailValidateReasonFmt = "failed to validate current (UID: %q)" - // CurFailCrashLoopReasonFmt indicates that the Kubelet experienced a crash loop while using the current config checkpoint for an API source - CurFailCrashLoopReasonFmt = "current failed trial period due to crash loop (UID: %q)" // LkgFail*ReasonFmt reasons are currently used to print errors in the Kubelet log, but do not appear in Node.Status.Conditions @@ -87,13 +84,13 @@ const ( // FailSyncReasonInformer is used when the informer fails to report the Node object FailSyncReasonInformer = "failed to read Node from informer object cache" // FailSyncReasonReset is used when we can't reset the local configuration references, e.g. due to filesystem issues - FailSyncReasonReset = "failed to reset to local (default or init) config" + FailSyncReasonReset = "failed to reset to local config" // FailSyncReasonCheckpointExistenceFmt is used when we can't determine if a checkpoint already exists, e.g. due to filesystem issues FailSyncReasonCheckpointExistenceFmt = "failed to determine whether object with UID %q was already checkpointed" // FailSyncReasonSaveCheckpointFmt is used when we can't save a checkpoint, e.g. due to filesystem issues FailSyncReasonSaveCheckpointFmt = "failed to save config checkpoint for object with UID %q" // FailSyncReasonSetCurrentDefault is used when we can't set the current config checkpoint to the local default, e.g. due to filesystem issues - FailSyncReasonSetCurrentDefault = "failed to set current config checkpoint to default" + FailSyncReasonSetCurrentLocal = "failed to set current config checkpoint to local config" // FailSyncReasonSetCurrentUIDFmt is used when we can't set the current config checkpoint to a checkpointed object, e.g. due to filesystem issues FailSyncReasonSetCurrentUIDFmt = "failed to set current config checkpoint to object with UID %q" diff --git a/test/e2e_node/dynamic_kubelet_config_test.go b/test/e2e_node/dynamic_kubelet_config_test.go index a0e9da80857..2ab9f7d8195 100644 --- a/test/e2e_node/dynamic_kubelet_config_test.go +++ b/test/e2e_node/dynamic_kubelet_config_test.go @@ -87,7 +87,7 @@ var _ = framework.KubeDescribe("DynamicKubeletConfiguration [Feature:DynamicKube Name: originalConfigMap.Name}}, expectConfigOK: &apiv1.NodeCondition{Type: apiv1.NodeConfigOK, Status: apiv1.ConditionTrue, Message: fmt.Sprintf(status.CurRemoteMessageFmt, originalConfigMap.UID), - Reason: status.CurRemoteOKReason}, + Reason: status.CurRemoteOkayReason}, expectConfig: originalKC, }, false) }) @@ -126,8 +126,8 @@ var _ = framework.KubeDescribe("DynamicKubeletConfiguration [Feature:DynamicKube {desc: "Node.Spec.ConfigSource is nil", configSource: nil, expectConfigOK: &apiv1.NodeCondition{Type: apiv1.NodeConfigOK, Status: apiv1.ConditionTrue, - Message: status.CurDefaultMessage, - Reason: status.CurDefaultOKReason}, + Message: status.CurLocalMessage, + Reason: status.CurLocalOkayReason}, expectConfig: nil, event: true, }, @@ -175,7 +175,7 @@ var _ = framework.KubeDescribe("DynamicKubeletConfiguration [Feature:DynamicKube Name: correctConfigMap.Name}}, expectConfigOK: &apiv1.NodeCondition{Type: apiv1.NodeConfigOK, Status: apiv1.ConditionTrue, Message: fmt.Sprintf(status.CurRemoteMessageFmt, correctConfigMap.UID), - Reason: status.CurRemoteOKReason}, + Reason: status.CurRemoteOkayReason}, expectConfig: correctKC, event: true, }, @@ -187,7 +187,7 @@ var _ = framework.KubeDescribe("DynamicKubeletConfiguration [Feature:DynamicKube Namespace: failParseConfigMap.Namespace, Name: failParseConfigMap.Name}}, expectConfigOK: &apiv1.NodeCondition{Type: apiv1.NodeConfigOK, Status: apiv1.ConditionFalse, - Message: status.LkgDefaultMessage, + Message: status.LkgLocalMessage, Reason: fmt.Sprintf(status.CurFailParseReasonFmt, failParseConfigMap.UID)}, expectConfig: nil, event: true, @@ -200,7 +200,7 @@ var _ = framework.KubeDescribe("DynamicKubeletConfiguration [Feature:DynamicKube Namespace: failValidateConfigMap.Namespace, Name: failValidateConfigMap.Name}}, expectConfigOK: &apiv1.NodeCondition{Type: apiv1.NodeConfigOK, Status: apiv1.ConditionFalse, - Message: status.LkgDefaultMessage, + Message: status.LkgLocalMessage, Reason: fmt.Sprintf(status.CurFailValidateReasonFmt, failValidateConfigMap.UID)}, expectConfig: nil, event: true, @@ -245,7 +245,7 @@ var _ = framework.KubeDescribe("DynamicKubeletConfiguration [Feature:DynamicKube Name: lkgConfigMap.Name}}, expectConfigOK: &apiv1.NodeCondition{Type: apiv1.NodeConfigOK, Status: apiv1.ConditionTrue, Message: fmt.Sprintf(status.CurRemoteMessageFmt, lkgConfigMap.UID), - Reason: status.CurRemoteOKReason}, + Reason: status.CurRemoteOkayReason}, expectConfig: lkgKC, event: true, }, @@ -295,10 +295,11 @@ var _ = framework.KubeDescribe("DynamicKubeletConfiguration [Feature:DynamicKube Name: cm1.Name}}, expectConfigOK: &apiv1.NodeCondition{Type: apiv1.NodeConfigOK, Status: apiv1.ConditionTrue, Message: fmt.Sprintf(status.CurRemoteMessageFmt, cm1.UID), - Reason: status.CurRemoteOKReason}, + Reason: status.CurRemoteOkayReason}, expectConfig: kc1, event: true, }, + {desc: "cm2", configSource: &apiv1.NodeConfigSource{ConfigMapRef: &apiv1.ObjectReference{ UID: cm2.UID, @@ -306,7 +307,7 @@ var _ = framework.KubeDescribe("DynamicKubeletConfiguration [Feature:DynamicKube Name: cm2.Name}}, expectConfigOK: &apiv1.NodeCondition{Type: apiv1.NodeConfigOK, Status: apiv1.ConditionTrue, Message: fmt.Sprintf(status.CurRemoteMessageFmt, cm2.UID), - Reason: status.CurRemoteOKReason}, + Reason: status.CurRemoteOkayReason}, expectConfig: kc2, event: true, },