github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-22 11:21:47 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #82243 from jfbai/refactor-kubeadm-calls

Browse Source 
refactor: replace all calls to os.Exit() / CheckErr().
This commit is contained in:
Kubernetes Prow Robot 2019-09-16 06:48:52 -07:00 committed by GitHub
commit 01c046836b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 245 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cmd/kubeadm/app/cmd/alpha/BUILD
View File

@ -27,7 +27,6 @@ go_library(
"//cmd/kubeadm/app/phases/kubelet:go_default_library",
"//cmd/kubeadm/app/phases/selfhosting:go_default_library",
"//cmd/kubeadm/app/preflight:go_default_library",
"//cmd/kubeadm/app/util:go_default_library",
"//cmd/kubeadm/app/util/apiclient:go_default_library",
"//cmd/kubeadm/app/util/config:go_default_library",
"//cmd/kubeadm/app/util/kubeconfig:go_default_library",

74
cmd/kubeadm/app/cmd/alpha/certs.go
View File

@ -35,7 +35,6 @@ import (
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
"k8s.io/kubernetes/cmd/kubeadm/app/phases/certs/renewal"
"k8s.io/kubernetes/cmd/kubeadm/app/phases/copycerts"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
)
@ -93,10 +92,13 @@ func NewCmdCertificateKey() *cobra.Command {
Short: "Generate certificate keys",
Long: certificateKeyLongDesc,
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
key, err := copycerts.CreateCertificateKey()
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
fmt.Println(key)
return nil
},
}
}
@ -137,10 +139,12 @@ func getRenewSubCommands(kdir string) []*cobra.Command {
// Get a renewal manager for a generic Cluster configuration, that is used only for getting
// the list of certificates for building subcommands
rm, err := renewal.NewManager(&kubeadmapi.ClusterConfiguration{}, "")
kubeadmutil.CheckErr(err)
if err != nil {
return nil
}
cmdList := []*cobra.Command{}
funcList := []func(){}
funcList := []func() error{}
for _, handler := range rm.Certificates() {
// get the cobra.Command skeleton for this command
@ -151,11 +155,13 @@ func getRenewSubCommands(kdir string) []*cobra.Command {
}
addRenewFlags(cmd, flags)
// get the implementation of renewing this certificate
renewalFunc := func(handler *renewal.CertificateRenewHandler) func() {
return func() { renewCert(flags, kdir, handler) }
renewalFunc := func(handler *renewal.CertificateRenewHandler) func() error {
return func() error {
return renewCert(flags, kdir, handler)
}
}(handler)
// install the implementation into the command
cmd.Run = func(*cobra.Command, []string) { renewalFunc() }
cmd.RunE = func(*cobra.Command, []string) error { return renewalFunc() }
cmdList = append(cmdList, cmd)
// Collect renewal functions for `renew all`
funcList = append(funcList, renewalFunc)
@ -165,10 +171,13 @@ func getRenewSubCommands(kdir string) []*cobra.Command {
Use: "all",
Short: "Renew all available certificates",
Long: allLongDesc,
Run: func(*cobra.Command, []string) {
RunE: func(*cobra.Command, []string) error {
for _, f := range funcList {
f()
if err := f(); err != nil {
return err
}
}
return nil
},
}
addRenewFlags(allCmd, flags)
@ -186,23 +195,25 @@ func addRenewFlags(cmd *cobra.Command, flags *renewFlags) {
cmd.Flags().BoolVar(&flags.useAPI, "use-api", flags.useAPI, "Use the Kubernetes certificate API to renew certificates")
}
func renewCert(flags *renewFlags, kdir string, handler *renewal.CertificateRenewHandler) {
func renewCert(flags *renewFlags, kdir string, handler *renewal.CertificateRenewHandler) error {
internalcfg, err := configutil.LoadOrDefaultInitConfiguration(flags.cfgPath, &kubeadmapiv1beta2.InitConfiguration{}, &flags.cfg)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// Get a renewal manager for the given cluster configuration
rm, err := renewal.NewManager(&internalcfg.ClusterConfiguration, kdir)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// if the renewal operation is set to generate CSR request only
if flags.csrOnly {
// checks a path for storing CSR request is given
if flags.csrPath == "" {
kubeadmutil.CheckErr(errors.New("please provide a path where CSR request should be stored"))
return errors.New("please provide a path where CSR request should be stored")
}
err := rm.CreateRenewCSR(handler.Name, flags.csrPath)
kubeadmutil.CheckErr(err)
return
return rm.CreateRenewCSR(handler.Name, flags.csrPath)
}
// otherwise, the renewal operation has to actually renew a certificate
@ -212,21 +223,27 @@ func renewCert(flags *renewFlags, kdir string, handler *renewal.CertificateRenew
// renew using K8s certificate API
kubeConfigPath := cmdutil.GetKubeConfigPath(flags.kubeconfigPath)
client, err := kubeconfigutil.ClientSetFromFile(kubeConfigPath)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = rm.RenewUsingCSRAPI(handler.Name, client)
kubeadmutil.CheckErr(err)
if err := rm.RenewUsingCSRAPI(handler.Name, client); err != nil {
return err
}
} else {
// renew using local certificate authorities.
// this operation can't complete in case the certificate key is not provided (external CA)
renewed, err := rm.RenewUsingLocalCA(handler.Name)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
if !renewed {
fmt.Printf("Detected external %s, %s can't be renewed\n", handler.CABaseName, handler.LongName)
return
return nil
}
}
fmt.Printf("%s renewed\n", handler.LongName)
return nil
}
// newCmdCertsExpiration creates a new `cert check-expiration` command.
@ -244,13 +261,17 @@ func newCmdCertsExpiration(out io.Writer, kdir string) *cobra.Command {
Use: "check-expiration",
Short: "Check certificates expiration for a Kubernetes cluster",
Long: expirationLongDesc,
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
internalcfg, err := configutil.LoadOrDefaultInitConfiguration(flags.cfgPath, &kubeadmapiv1beta2.InitConfiguration{}, &flags.cfg)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// Get a renewal manager for the given cluster configuration
rm, err := renewal.NewManager(&internalcfg.ClusterConfiguration, kdir)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// Get all the certificate expiration info
yesNo := func(b bool) string {
@ -264,7 +285,7 @@ func newCmdCertsExpiration(out io.Writer, kdir string) *cobra.Command {
for _, handler := range rm.Certificates() {
e, err := rm.GetExpirationInfo(handler.Name)
if err != nil {
kubeadmutil.CheckErr(err)
return err
}
s := fmt.Sprintf("%s\t%s\t%s\t%-8v",
@ -277,6 +298,7 @@ func newCmdCertsExpiration(out io.Writer, kdir string) *cobra.Command {
fmt.Fprintln(w, s)
}
w.Flush()
return nil
},
}
addExpirationFlags(cmd, flags)

14
cmd/kubeadm/app/cmd/alpha/kubeconfig.go
View File

@ -26,7 +26,6 @@ import (
"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
kubeconfigphase "k8s.io/kubernetes/cmd/kubeadm/app/phases/kubeconfig"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
)
@ -76,23 +75,24 @@ func newCmdUserKubeConfig(out io.Writer) *cobra.Command {
Short: "Output a kubeconfig file for an additional user",
Long: userKubeconfigLongDesc,
Example: userKubeconfigExample,
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
if clientName == "" {
kubeadmutil.CheckErr(errors.New("missing required argument --client-name"))
return errors.New("missing required argument --client-name")
}
// This call returns the ready-to-use configuration based on the defaults populated by flags
internalcfg, err := configutil.DefaultedInitConfiguration(initCfg, clusterCfg)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// if the kubeconfig file for an additional user has to use a token, use it
if token != "" {
kubeadmutil.CheckErr(kubeconfigphase.WriteKubeConfigWithToken(out, internalcfg, clientName, token))
return
return kubeconfigphase.WriteKubeConfigWithToken(out, internalcfg, clientName, token)
}
// Otherwise, write a kubeconfig file with a generate client cert
kubeadmutil.CheckErr(kubeconfigphase.WriteKubeConfigWithClientCert(out, internalcfg, clientName, organizations))
return kubeconfigphase.WriteKubeConfigWithClientCert(out, internalcfg, clientName, organizations)
},
}

31
cmd/kubeadm/app/cmd/alpha/kubelet.go
View File

@ -27,7 +27,6 @@ import (
"k8s.io/kubernetes/cmd/kubeadm/app/constants"
kubeletphase "k8s.io/kubernetes/cmd/kubeadm/app/phases/kubelet"
"k8s.io/kubernetes/cmd/kubeadm/app/preflight"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
utilsexec "k8s.io/utils/exec"
)
@ -101,15 +100,18 @@ func newCmdKubeletConfigDownload() *cobra.Command {
Short: "Download the kubelet configuration from the cluster ConfigMap kubelet-config-1.X, where X is the minor version of the kubelet",
Long: kubeletConfigDownloadLongDesc,
Example: kubeletConfigDownloadExample,
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
kubeletVersion, err := getKubeletVersion(kubeletVersionStr)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
client, err := kubeconfigutil.ClientSetFromFile(kubeConfigFile)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = kubeletphase.DownloadConfig(client, kubeletVersion, constants.KubeletRunDirectory)
kubeadmutil.CheckErr(err)
return kubeletphase.DownloadConfig(client, kubeletVersion, constants.KubeletRunDirectory)
},
}
@ -136,23 +138,26 @@ func newCmdKubeletConfigEnableDynamic() *cobra.Command {
Short: "EXPERIMENTAL: Enable or update dynamic kubelet configuration for a Node",
Long: kubeletConfigEnableDynamicLongDesc,
Example: kubeletConfigEnableDynamicExample,
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
if len(nodeName) == 0 {
kubeadmutil.CheckErr(errors.New("the --node-name argument is required"))
return errors.New("the --node-name argument is required")
}
if len(kubeletVersionStr) == 0 {
kubeadmutil.CheckErr(errors.New("the --kubelet-version argument is required"))
return errors.New("the --kubelet-version argument is required")
}
kubeletVersion, err := version.ParseSemantic(kubeletVersionStr)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
kubeConfigFile = cmdutil.GetKubeConfigPath(kubeConfigFile)
client, err := kubeconfigutil.ClientSetFromFile(kubeConfigFile)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = kubeletphase.EnableDynamicConfigForNode(client, nodeName, kubeletVersion)
kubeadmutil.CheckErr(err)
return kubeletphase.EnableDynamicConfigForNode(client, nodeName, kubeletVersion)
},
}

25
cmd/kubeadm/app/cmd/alpha/selfhosting.go
View File

@ -36,7 +36,6 @@ import (
"k8s.io/kubernetes/cmd/kubeadm/app/constants"
"k8s.io/kubernetes/cmd/kubeadm/app/features"
"k8s.io/kubernetes/cmd/kubeadm/app/phases/selfhosting"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
"k8s.io/kubernetes/cmd/kubeadm/app/util/apiclient"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
@ -87,7 +86,7 @@ func getSelfhostingSubCommand(in io.Reader) *cobra.Command {
Short: "Convert a static Pod-hosted control plane into a self-hosted one",
Long: selfhostingLongDesc,
Example: selfhostingExample,
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
var err error
@ -97,28 +96,31 @@ func getSelfhostingSubCommand(in io.Reader) *cobra.Command {
s := bufio.NewScanner(in)
s.Scan()
err = s.Err()
kubeadmutil.CheckErr(err)
if err = s.Err(); err != nil {
return err
}
if strings.ToLower(s.Text()) != "y" {
kubeadmutil.CheckErr(errors.New("aborted pivot operation"))
return errors.New("aborted pivot operation")
}
}
fmt.Println("[pivot] pivoting cluster to self-hosted")
if cfg.FeatureGates, err = features.NewFeatureGate(&features.InitFeatureGates, featureGatesString); err != nil {
kubeadmutil.CheckErr(err)
return err
}
if err := validation.ValidateMixedArguments(cmd.Flags()); err != nil {
kubeadmutil.CheckErr(err)
return err
}
// Gets the Kubernetes client
kubeConfigFile = cmdutil.GetKubeConfigPath(kubeConfigFile)
client, err := kubeconfigutil.ClientSetFromFile(kubeConfigFile)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// KubernetesVersion is not used, but we set it explicitly to avoid the lookup
// of the version from the internet when executing LoadOrDefaultInitConfiguration
@ -126,12 +128,13 @@ func getSelfhostingSubCommand(in io.Reader) *cobra.Command {
// This call returns the ready-to-use configuration based on the configuration file that might or might not exist and the default cfg populated by flags
internalcfg, err := configutil.LoadOrDefaultInitConfiguration(cfgPath, &kubeadmapiv1beta2.InitConfiguration{}, cfg)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// Converts the Static Pod-hosted control plane into a self-hosted one
waiter := apiclient.NewKubeWaiter(client, 2*time.Minute, os.Stdout)
err = selfhosting.CreateSelfHostedControlPlane(constants.GetStaticPodDirectory(), constants.KubernetesDir, internalcfg, client, waiter, false, certsInSecrets)
kubeadmutil.CheckErr(err)
return selfhosting.CreateSelfHostedControlPlane(constants.GetStaticPodDirectory(), constants.KubernetesDir, internalcfg, client, waiter, false, certsInSecrets)
},
}

3
cmd/kubeadm/app/cmd/cmd.go
View File

@ -67,7 +67,8 @@ func NewKubeadmCommand(in io.Reader, out, err io.Writer) *cobra.Command {
You can then repeat the second step on as many other machines as you like.
`),
SilenceErrors: true,
SilenceUsage: true,
PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
if rootfsPath != "" {
if err := kubeadmutil.Chroot(rootfsPath); err != nil {

7
cmd/kubeadm/app/cmd/completion.go
View File

@ -24,8 +24,6 @@ import (
"github.com/pkg/errors"
"github.com/spf13/cobra"
"k8s.io/klog"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
)
const defaultBoilerPlate = `
@ -105,9 +103,8 @@ func NewCmdCompletion(out io.Writer, boilerPlate string) *cobra.Command {
Short: "Output shell completion code for the specified shell (bash or zsh)",
Long: completionLong,
Example: completionExample,
Run: func(cmd *cobra.Command, args []string) {
err := RunCompletion(out, boilerPlate, cmd, args)
kubeadmutil.CheckErr(err)
RunE: func(cmd *cobra.Command, args []string) error {
return RunCompletion(out, boilerPlate, cmd, args)
},
ValidArgs: GetSupportedShells(),
}

101
cmd/kubeadm/app/cmd/config.go
View File

@ -42,7 +42,6 @@ import (
"k8s.io/kubernetes/cmd/kubeadm/app/features"
"k8s.io/kubernetes/cmd/kubeadm/app/images"
"k8s.io/kubernetes/cmd/kubeadm/app/phases/uploadconfig"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
utilruntime "k8s.io/kubernetes/cmd/kubeadm/app/util/runtime"
@ -127,8 +126,8 @@ func newCmdConfigPrintActionDefaults(out io.Writer, action string, configBytesPr
Note that sensitive values like the Bootstrap Token fields are replaced with placeholder values like %q in order to pass validation but
not perform the real computation for creating a token.
`), action, action, placeholderToken),
Run: func(cmd *cobra.Command, args []string) {
runConfigPrintActionDefaults(out, componentConfigs, configBytesProc)
RunE: func(cmd *cobra.Command, args []string) error {
return runConfigPrintActionDefaults(out, componentConfigs, configBytesProc)
},
}
cmd.Flags().StringSliceVar(&componentConfigs, "component-configs", componentConfigs,
@ -136,18 +135,23 @@ func newCmdConfigPrintActionDefaults(out io.Writer, action string, configBytesPr
return cmd
}
func runConfigPrintActionDefaults(out io.Writer, componentConfigs []string, configBytesProc func() ([]byte, error)) {
func runConfigPrintActionDefaults(out io.Writer, componentConfigs []string, configBytesProc func() ([]byte, error)) error {
initialConfig, err := configBytesProc()
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
allBytes := [][]byte{initialConfig}
for _, componentConfig := range componentConfigs {
cfgBytes, err := getDefaultComponentConfigBytes(componentConfig)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
allBytes = append(allBytes, cfgBytes)
}
fmt.Fprint(out, string(bytes.Join(allBytes, []byte(constants.YAMLDocumentSeparator))))
return nil
}
func getDefaultComponentConfigBytes(apiObject string) ([]byte, error) {
@ -242,24 +246,29 @@ func NewCmdConfigMigrate(out io.Writer) *cobra.Command {
In other words, the output of this command is what kubeadm actually would read internally if you
submitted this file to "kubeadm init"
`), kubeadmapiv1beta2.SchemeGroupVersion, kubeadmapiv1beta2.SchemeGroupVersion),
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
if len(oldCfgPath) == 0 {
kubeadmutil.CheckErr(errors.New("the --old-config flag is mandatory"))
return errors.New("the --old-config flag is mandatory")
}
oldCfgBytes, err := ioutil.ReadFile(oldCfgPath)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
outputBytes, err := configutil.MigrateOldConfig(oldCfgBytes)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
if newCfgPath == "" {
fmt.Fprint(out, string(outputBytes))
} else {
if err := ioutil.WriteFile(newCfgPath, outputBytes, 0644); err != nil {
kubeadmutil.CheckErr(errors.Wrapf(err, "failed to write the new configuration to the file %q", newCfgPath))
return errors.Wrapf(err, "failed to write the new configuration to the file %q", newCfgPath)
}
}
return nil
},
}
cmd.Flags().StringVar(&oldCfgPath, "old-config", "", "Path to the kubeadm config file that is using an old API version and should be converted. This flag is mandatory.")
@ -292,13 +301,14 @@ func NewCmdConfigView(out io.Writer, kubeConfigFile *string) *cobra.Command {
The configuration is located in the %q namespace in the %q ConfigMap.
`), metav1.NamespaceSystem, constants.KubeadmConfigConfigMap),
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
klog.V(1).Infoln("[config] retrieving ClientSet from file")
client, err := kubeconfigutil.ClientSetFromFile(*kubeConfigFile)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = RunConfigView(out, client)
kubeadmutil.CheckErr(err)
return RunConfigView(out, client)
},
}
}
@ -319,23 +329,26 @@ func NewCmdConfigUploadFromFile(out io.Writer, kubeConfigFile *string) *cobra.Co
The configuration is located in the %q namespace in the %q ConfigMap.
`), metav1.NamespaceSystem, constants.KubeadmConfigConfigMap),
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
if len(cfgPath) == 0 {
kubeadmutil.CheckErr(errors.New("the --config flag is mandatory"))
return errors.New("the --config flag is mandatory")
}
klog.V(1).Infoln("[config] retrieving ClientSet from file")
client, err := kubeconfigutil.ClientSetFromFile(*kubeConfigFile)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// Default both statically and dynamically, convert to internal API type, and validate everything
internalcfg, err := configutil.LoadInitConfigurationFromFile(cfgPath)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// Upload the configuration using the file
klog.V(1).Infof("[config] uploading configuration")
err = uploadconfig.UploadConfiguration(internalcfg, client)
kubeadmutil.CheckErr(err)
return uploadconfig.UploadConfiguration(internalcfg, client)
},
}
options.AddConfigFlag(cmd.Flags(), &cfgPath)
@ -364,15 +377,17 @@ func NewCmdConfigUploadFromFlags(out io.Writer, kubeConfigFile *string) *cobra.C
The configuration is located in the %q namespace in the %q ConfigMap.
`), metav1.NamespaceSystem, constants.KubeadmConfigConfigMap),
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
var err error
klog.V(1).Infoln("[config] creating new FeatureGates")
if clusterCfg.FeatureGates, err = features.NewFeatureGate(&features.InitFeatureGates, featureGatesString); err != nil {
kubeadmutil.CheckErr(err)
return nil
}
klog.V(1).Infoln("[config] retrieving ClientSet from file")
client, err := kubeconfigutil.ClientSetFromFile(*kubeConfigFile)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// KubernetesVersion is not used, but we set it explicitly to avoid the lookup
// of the version from the internet when executing DefaultedInitConfiguration
@ -381,12 +396,13 @@ func NewCmdConfigUploadFromFlags(out io.Writer, kubeConfigFile *string) *cobra.C
// Default both statically and dynamically, convert to internal API type, and validate everything
klog.V(1).Infoln("[config] converting to internal API type")
internalcfg, err := configutil.DefaultedInitConfiguration(initCfg, clusterCfg)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// Finally, upload the configuration
klog.V(1).Infof("[config] uploading configuration")
err = uploadconfig.UploadConfiguration(internalcfg, client)
kubeadmutil.CheckErr(err)
return uploadconfig.UploadConfiguration(internalcfg, client)
},
}
AddInitConfigFlags(cmd.PersistentFlags(), initCfg)
@ -431,15 +447,20 @@ func NewCmdConfigImagesPull() *cobra.Command {
cmd := &cobra.Command{
Use: "pull",
Short: "Pull images used by kubeadm",
Run: func(_ *cobra.Command, _ []string) {
RunE: func(_ *cobra.Command, _ []string) error {
externalClusterCfg.FeatureGates, err = features.NewFeatureGate(&features.InitFeatureGates, featureGatesString)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
internalcfg, err := configutil.LoadOrDefaultInitConfiguration(cfgPath, externalInitCfg, externalClusterCfg)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
containerRuntime, err := utilruntime.NewContainerRuntime(utilsexec.New(), internalcfg.NodeRegistration.CRISocket)
kubeadmutil.CheckErr(err)
err = PullControlPlaneImages(containerRuntime, &internalcfg.ClusterConfiguration)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
return PullControlPlaneImages(containerRuntime, &internalcfg.ClusterConfiguration)
},
}
AddImagesCommonConfigFlags(cmd.PersistentFlags(), externalClusterCfg, &cfgPath, &featureGatesString)
@ -490,12 +511,18 @@ func NewCmdConfigImagesList(out io.Writer, mockK8sVersion *string) *cobra.Comman
cmd := &cobra.Command{
Use: "list",
Short: "Print a list of images kubeadm will use. The configuration file is used in case any images or image repositories are customized",
Run: func(_ *cobra.Command, _ []string) {
RunE: func(_ *cobra.Command, _ []string) error {
externalcfg.FeatureGates, err = features.NewFeatureGate(&features.InitFeatureGates, featureGatesString)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
imagesList, err := NewImagesList(cfgPath, externalcfg)
kubeadmutil.CheckErr(err)
kubeadmutil.CheckErr(imagesList.Run(out))
if err != nil {
return err
}
return imagesList.Run(out)
},
}
AddImagesCommonConfigFlags(cmd.PersistentFlags(), externalcfg, &cfgPath, &featureGatesString)

12
cmd/kubeadm/app/cmd/config_test.go
View File

@ -52,7 +52,9 @@ func TestNewCmdConfigImagesList(t *testing.T) {
var output bytes.Buffer
mockK8sVersion := dummyKubernetesVersion
images := NewCmdConfigImagesList(&output, &mockK8sVersion)
images.Run(nil, nil)
if err := images.RunE(nil, nil); err != nil {
t.Fatalf("Error from running the images command: %v", err)
}
actual := strings.Split(output.String(), "\n")
if len(actual) != defaultNumberOfImages {
t.Fatalf("Expected %v but found %v images", defaultNumberOfImages, len(actual))
@ -252,7 +254,9 @@ func TestMigrate(t *testing.T) {
if err := command.Flags().Set("new-config", newConfigPath); err != nil {
t.Fatalf("failed to set new-config flag")
}
command.Run(nil, nil)
if err := command.RunE(nil, nil); err != nil {
t.Fatalf("Error from running the migrate command: %v", err)
}
if _, err := configutil.LoadInitConfigurationFromFile(newConfigPath); err != nil {
t.Fatalf("Could not read output back into internal type: %v", err)
}
@ -347,7 +351,9 @@ func TestNewCmdConfigPrintActionDefaults(t *testing.T) {
if err := command.Flags().Set("component-configs", test.componentConfigs); err != nil {
t.Fatalf("failed to set component-configs flag")
}
command.Run(nil, nil)
if err := command.RunE(nil, nil); err != nil {
t.Fatalf("Error from running the print command: %v", err)
}
gvkmap, err := kubeadmutil.SplitYAMLDocuments(output.Bytes())
if err != nil {

15
cmd/kubeadm/app/cmd/init.go
View File

@ -41,7 +41,6 @@ import (
"k8s.io/kubernetes/cmd/kubeadm/app/features"
certsphase "k8s.io/kubernetes/cmd/kubeadm/app/phases/certs"
kubeconfigphase "k8s.io/kubernetes/cmd/kubeadm/app/phases/kubeconfig"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
"k8s.io/kubernetes/cmd/kubeadm/app/util/apiclient"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
@ -136,18 +135,20 @@ func NewCmdInit(out io.Writer, initOptions *initOptions) *cobra.Command {
cmd := &cobra.Command{
Use: "init",
Short: "Run this command in order to set up the Kubernetes control plane",
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
c, err := initRunner.InitData(args)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
data := c.(*initData)
fmt.Printf("[init] Using Kubernetes version: %s\n", data.cfg.KubernetesVersion)
err = initRunner.Run(args)
kubeadmutil.CheckErr(err)
if err := initRunner.Run(args); err != nil {
return err
}
err = showJoinCommand(data, out)
kubeadmutil.CheckErr(err)
return showJoinCommand(data, out)
},
Args: cobra.NoArgs,
}

21
cmd/kubeadm/app/cmd/join.go
View File

@ -28,7 +28,7 @@ import (
flag "github.com/spf13/pflag"
"k8s.io/apimachinery/pkg/util/sets"
clientset "k8s.io/client-go/kubernetes"
clientcmd "k8s.io/client-go/tools/clientcmd"
"k8s.io/client-go/tools/clientcmd"
clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
"k8s.io/klog"
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
@ -41,7 +41,6 @@ import (
cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
"k8s.io/kubernetes/cmd/kubeadm/app/discovery"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
)
@ -159,15 +158,18 @@ func NewCmdJoin(out io.Writer, joinOptions *joinOptions) *cobra.Command {
Use: "join [api-server-endpoint]",
Short: "Run this on any machine you wish to join an existing cluster",
Long: joinLongDescription,
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
c, err := joinRunner.InitData(args)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
data := c.(*joinData)
err = joinRunner.Run(args)
kubeadmutil.CheckErr(err)
if err := joinRunner.Run(args); err != nil {
return err
}
// if the node is hosting a new control plane instance
if data.cfg.ControlPlane != nil {
@ -181,14 +183,17 @@ func NewCmdJoin(out io.Writer, joinOptions *joinOptions) *cobra.Command {
"KubeConfigPath": kubeadmconstants.GetAdminKubeConfigPath(),
"etcdMessage": etcdMessage,
}
err = joinControPlaneDoneTemp.Execute(data.outputWriter, ctx)
kubeadmutil.CheckErr(err)
if err := joinControPlaneDoneTemp.Execute(data.outputWriter, ctx); err != nil {
return err
}
} else {
// otherwise, if the node joined as a worker node;
// outputs the join done message and exit
fmt.Fprint(data.outputWriter, joinWorkerNodeDoneMsg)
}
return nil
},
// We accept the control-plane location as an optional positional argument
Args: cobra.MaximumNArgs(1),

1
cmd/kubeadm/app/cmd/phases/init/BUILD
View File

@ -41,7 +41,6 @@ go_library(
"//cmd/kubeadm/app/phases/patchnode:go_default_library",
"//cmd/kubeadm/app/phases/uploadconfig:go_default_library",
"//cmd/kubeadm/app/preflight:go_default_library",
"//cmd/kubeadm/app/util:go_default_library",
"//cmd/kubeadm/app/util/apiclient:go_default_library",
"//cmd/kubeadm/app/util/dryrun:go_default_library",
"//cmd/kubeadm/app/util/pkiutil:go_default_library",

10
cmd/kubeadm/app/cmd/phases/init/certs.go
View File

@ -30,7 +30,6 @@ import (
cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
certsphase "k8s.io/kubernetes/cmd/kubeadm/app/phases/certs"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
"k8s.io/kubernetes/cmd/kubeadm/app/util/pkiutil"
)
@ -161,11 +160,14 @@ func getSANDescription(certSpec *certsphase.KubeadmCert) string {
defaultInternalConfig := &kubeadmapi.InitConfiguration{}
kubeadmscheme.Scheme.Default(defaultConfig)
err := kubeadmscheme.Scheme.Convert(defaultConfig, defaultInternalConfig, nil)
kubeadmutil.CheckErr(err)
if err := kubeadmscheme.Scheme.Convert(defaultConfig, defaultInternalConfig, nil); err != nil {
return ""
}
certConfig, err := certSpec.GetConfig(defaultInternalConfig)
kubeadmutil.CheckErr(err)
if err != nil {
return ""
}
if len(certConfig.AltNames.DNSNames) == 0 && len(certConfig.AltNames.IPs) == 0 {
return ""

1
cmd/kubeadm/app/cmd/phases/workflow/BUILD
View File

@ -10,7 +10,6 @@ go_library(
importpath = "k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/workflow",
visibility = ["//visibility:public"],
deps = [
"//cmd/kubeadm/app/util:go_default_library",
"//vendor/github.com/pkg/errors:go_default_library",
"//vendor/github.com/spf13/cobra:go_default_library",
"//vendor/github.com/spf13/pflag:go_default_library",

8
cmd/kubeadm/app/cmd/phases/workflow/runner.go
View File

@ -23,8 +23,6 @@ import (
"github.com/pkg/errors"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
"k8s.io/kubernetes/cmd/kubeadm/app/util"
)
// phaseSeparator defines the separator to be used when concatenating nested
@ -337,17 +335,17 @@ func (e *Runner) BindToCommand(cmd *cobra.Command) {
Long: p.Long,
Example: p.Example,
Aliases: p.Aliases,
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
// if the phase has subphases, print the help and exits
if len(p.Phases) > 0 {
cmd.Help()
return
return nil
}
// overrides the command triggering the Runner using the phaseCmd
e.runCmd = cmd
e.Options.FilterPhases = []string{phaseSelector}
util.CheckErr(e.Run(args))
return e.Run(args)
},
}

13
cmd/kubeadm/app/cmd/reset.go
View File

@ -34,7 +34,6 @@ import (
"k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/workflow"
cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
utilruntime "k8s.io/kubernetes/cmd/kubeadm/app/util/runtime"
)
@ -103,7 +102,6 @@ func newResetData(cmd *cobra.Command, options *resetOptions, in io.Reader, out i
if err != nil {
return nil, err
}
kubeadmutil.CheckErr(err)
if cfg != nil {
// Also set the union of pre-flight errors to InitConfiguration, to provide a consistent view of the runtime configuration:
cfg.NodeRegistration.IgnorePreflightErrors = ignorePreflightErrorsSet.List()
@ -166,12 +164,16 @@ func NewCmdReset(in io.Reader, out io.Writer, resetOptions *resetOptions) *cobra
cmd := &cobra.Command{
Use: "reset",
Short: "Performs a best effort revert of changes made to this host by 'kubeadm init' or 'kubeadm join'",
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
c, err := resetRunner.InitData(args)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = resetRunner.Run(args)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
// Then clean contents from the stateful kubelet, etcd and cni directories
data := c.(*resetData)
@ -179,6 +181,7 @@ func NewCmdReset(in io.Reader, out io.Writer, resetOptions *resetOptions) *cobra
// Output help text instructing user how to remove iptables rules
fmt.Print(iptablesCleanupInstructions)
return nil
},
}

45
cmd/kubeadm/app/cmd/token.go
View File

@ -43,7 +43,6 @@ import (
cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
tokenphase "k8s.io/kubernetes/cmd/kubeadm/app/phases/bootstraptoken/node"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
"k8s.io/kubernetes/cmd/kubeadm/app/util/apiclient"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
@ -108,24 +107,27 @@ func NewCmdToken(out io.Writer, errW io.Writer) *cobra.Command {
This should be a securely generated random token of the form "[a-z0-9]{6}.[a-z0-9]{16}".
If no [token] is given, kubeadm will generate a random token instead.
`),
Run: func(tokenCmd *cobra.Command, args []string) {
RunE: func(tokenCmd *cobra.Command, args []string) error {
if len(args) > 0 {
bto.TokenStr = args[0]
}
klog.V(1).Infoln("[token] validating mixed arguments")
err := validation.ValidateMixedArguments(tokenCmd.Flags())
kubeadmutil.CheckErr(err)
if err := validation.ValidateMixedArguments(tokenCmd.Flags()); err != nil {
return err
}
err = bto.ApplyTo(cfg)
kubeadmutil.CheckErr(err)
if err := bto.ApplyTo(cfg); err != nil {
return err
}
klog.V(1).Infoln("[token] getting Clientsets from kubeconfig file")
kubeConfigFile = cmdutil.GetKubeConfigPath(kubeConfigFile)
client, err := getClientset(kubeConfigFile, dryRun)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = RunCreateToken(out, client, cfgPath, cfg, printJoinCommand, kubeConfigFile)
kubeadmutil.CheckErr(err)
return RunCreateToken(out, client, cfgPath, cfg, printJoinCommand, kubeConfigFile)
},
}
@ -146,13 +148,14 @@ func NewCmdToken(out io.Writer, errW io.Writer) *cobra.Command {
Long: dedent.Dedent(`
This command will list all bootstrap tokens for you.
`),
Run: func(tokenCmd *cobra.Command, args []string) {
RunE: func(tokenCmd *cobra.Command, args []string) error {
kubeConfigFile = cmdutil.GetKubeConfigPath(kubeConfigFile)
client, err := getClientset(kubeConfigFile, dryRun)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = RunListTokens(out, errW, client)
kubeadmutil.CheckErr(err)
return RunListTokens(out, errW, client)
},
}
tokenCmd.AddCommand(listCmd)
@ -167,16 +170,17 @@ func NewCmdToken(out io.Writer, errW io.Writer) *cobra.Command {
The [token-value] is the full Token of the form "[a-z0-9]{6}.[a-z0-9]{16}" or the
Token ID of the form "[a-z0-9]{6}" to delete.
`),
Run: func(tokenCmd *cobra.Command, args []string) {
RunE: func(tokenCmd *cobra.Command, args []string) error {
if len(args) < 1 {
kubeadmutil.CheckErr(errors.Errorf("missing subcommand; 'token delete' is missing token of form %q", bootstrapapi.BootstrapTokenIDPattern))
return errors.Errorf("missing subcommand; 'token delete' is missing token of form %q", bootstrapapi.BootstrapTokenIDPattern)
}
kubeConfigFile = cmdutil.GetKubeConfigPath(kubeConfigFile)
client, err := getClientset(kubeConfigFile, dryRun)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = RunDeleteTokens(out, client, args)
kubeadmutil.CheckErr(err)
return RunDeleteTokens(out, client, args)
},
}
tokenCmd.AddCommand(deleteCmd)
@ -200,9 +204,8 @@ func NewCmdTokenGenerate(out io.Writer) *cobra.Command {
You can also use "kubeadm init" without specifying a token and it will
generate and print one for you.
`),
Run: func(cmd *cobra.Command, args []string) {
err := RunGenerateToken(out)
kubeadmutil.CheckErr(err)
RunE: func(cmd *cobra.Command, args []string) error {
return RunGenerateToken(out)
},
}
}

9
cmd/kubeadm/app/cmd/upgrade/apply.go
View File

@ -73,12 +73,13 @@ func NewCmdApply(apf *applyPlanFlags) *cobra.Command {
Use: "apply [version]",
DisableFlagsInUseLine: true,
Short: "Upgrade your Kubernetes cluster to the specified version",
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
userVersion, err := getK8sVersionFromUserInput(flags.applyPlanFlags, args, true)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = runApply(flags, userVersion)
kubeadmutil.CheckErr(err)
return runApply(flags, userVersion)
},
}

4
cmd/kubeadm/app/cmd/upgrade/diff.go
View File

@ -65,9 +65,9 @@ func NewCmdDiff(out io.Writer) *cobra.Command {
cmd := &cobra.Command{
Use: "diff [version]",
Short: "Show what differences would be applied to existing static pod manifests. See also: kubeadm upgrade apply --dry-run",
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
// TODO: Run preflight checks for diff to check that the manifests already exist.
kubeadmutil.CheckErr(runDiff(flags, args))
return runDiff(flags, args)
},
}

13
cmd/kubeadm/app/cmd/upgrade/node.go
View File

@ -30,7 +30,6 @@ import (
"k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/workflow"
"k8s.io/kubernetes/cmd/kubeadm/app/constants"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
)
@ -70,9 +69,8 @@ func NewCmdNode() *cobra.Command {
cmd := &cobra.Command{
Use: "node",
Short: "Upgrade commands for a node in the cluster",
Run: func(cmd *cobra.Command, args []string) {
err := nodeRunner.Run(args)
kubeadmutil.CheckErr(err)
RunE: func(cmd *cobra.Command, args []string) error {
return nodeRunner.Run(args)
},
Args: cobra.NoArgs,
}
@ -207,16 +205,15 @@ func NewCmdUpgradeNodeConfig() *cobra.Command {
Use: "config",
Short: "Download the kubelet configuration from the cluster ConfigMap kubelet-config-1.X, where X is the minor version of the kubelet",
Deprecated: "use \"kubeadm upgrade node\" instead",
Run: func(cmd *cobra.Command, args []string) {
RunE: func(cmd *cobra.Command, args []string) error {
// This is required for preserving the old behavior of `kubeadm upgrade node config`.
// The new implementation exposed as a phase under `kubeadm upgrade node` infers the target
// kubelet config version from the kubeadm-config ConfigMap
if len(nodeOptions.kubeletVersion) == 0 {
kubeadmutil.CheckErr(errors.New("the --kubelet-version argument is required"))
return errors.New("the --kubelet-version argument is required")
}
err := nodeRunner.Run(args)
kubeadmutil.CheckErr(err)
return nodeRunner.Run(args)
},
}

10
cmd/kubeadm/app/cmd/upgrade/plan.go
View File

@ -30,7 +30,6 @@ import (
"k8s.io/klog"
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
"k8s.io/kubernetes/cmd/kubeadm/app/phases/upgrade"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
etcdutil "k8s.io/kubernetes/cmd/kubeadm/app/util/etcd"
)
@ -47,12 +46,13 @@ func NewCmdPlan(apf *applyPlanFlags) *cobra.Command {
cmd := &cobra.Command{
Use: "plan [version] [flags]",
Short: "Check which versions are available to upgrade to and validate whether your current cluster is upgradeable. To skip the internet check, pass in the optional [version] parameter",
Run: func(_ *cobra.Command, args []string) {
RunE: func(_ *cobra.Command, args []string) error {
userVersion, err := getK8sVersionFromUserInput(flags.applyPlanFlags, args, false)
kubeadmutil.CheckErr(err)
if err != nil {
return err
}
err = runPlan(flags, userVersion)
kubeadmutil.CheckErr(err)
return runPlan(flags, userVersion)
},
}

6
cmd/kubeadm/app/cmd/version.go
View File

@ -27,7 +27,6 @@ import (
"sigs.k8s.io/yaml"
apimachineryversion "k8s.io/apimachinery/pkg/version"
kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
"k8s.io/kubernetes/cmd/kubeadm/app/version"
)
@ -41,9 +40,8 @@ func NewCmdVersion(out io.Writer) *cobra.Command {
cmd := &cobra.Command{
Use: "version",
Short: "Print the version of kubeadm",
Run: func(cmd *cobra.Command, args []string) {
err := RunVersion(out, cmd)
kubeadmutil.CheckErr(err)
RunE: func(cmd *cobra.Command, args []string) error {
return RunVersion(out, cmd)
},
}
cmd.Flags().StringP("output", "o", "", "Output format; available options are 'yaml', 'json' and 'short'")