kubeadm: Add 'kubeadm upgrade plan' and 'kubeadm upgrade apply' CLI commands

cmd/kubeadm/app/cmd/upgrade/apply.go

+/*
+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 upgrade
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	clientset "k8s.io/client-go/kubernetes"
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
+	cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
+	"k8s.io/kubernetes/cmd/kubeadm/app/phases/upgrade"
+	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/util/version"
+)
+
+// applyFlags holds the information about the flags that can be passed to apply
+type applyFlags struct {
+	nonInteractiveMode bool
+	force              bool
+	dryRun             bool
+	newK8sVersionStr   string
+	newK8sVersion      *version.Version
+	imagePullTimeout   time.Duration
+	parent             *cmdUpgradeFlags
+}
+
+// SessionIsInteractive returns true if the session is of an interactive type (the default, can be opted out of with -y, -f or --dry-run)
+func (f *applyFlags) SessionIsInteractive() bool {
+	return !f.nonInteractiveMode
+}
+
+// NewCmdApply returns the cobra command for `kubeadm upgrade apply`
+func NewCmdApply(parentFlags *cmdUpgradeFlags) *cobra.Command {
+	flags := &applyFlags{
+		parent:           parentFlags,
+		imagePullTimeout: 15 * time.Minute,
+	}
+
+	cmd := &cobra.Command{
+		Use:   "apply [version]",
+		Short: "Upgrade your Kubernetes cluster to the specified version",
+		Run: func(cmd *cobra.Command, args []string) {
+			// Ensure the user is root
+			err := runPreflightChecks(flags.parent.skipPreFlight)
+			kubeadmutil.CheckErr(err)
+
+			err = cmdutil.ValidateExactArgNumber(args, []string{"version"})
+			kubeadmutil.CheckErr(err)
+
+			// It's safe to use args[0] here as the slice has been validated above
+			flags.newK8sVersionStr = args[0]
+
+			// Default the flags dynamically, based on each others' value
+			err = SetImplicitFlags(flags)
+			kubeadmutil.CheckErr(err)
+
+			err = RunApply(flags)
+			kubeadmutil.CheckErr(err)
+		},
+	}
+
+	// Specify the valid flags specific for apply
+	cmd.Flags().BoolVarP(&flags.nonInteractiveMode, "yes", "y", flags.nonInteractiveMode, "Perform the upgrade and do not prompt for confirmation (non-interactive mode).")
+	cmd.Flags().BoolVarP(&flags.force, "force", "f", flags.force, "Force upgrading although some requirements might not be met. This also implies non-interactive mode.")
+	cmd.Flags().BoolVar(&flags.dryRun, "dry-run", flags.dryRun, "Do not change any state, just output what actions would be applied.")
+	cmd.Flags().DurationVar(&flags.imagePullTimeout, "image-pull-timeout", flags.imagePullTimeout, "The maximum amount of time to wait for the control plane pods to be downloaded.")
+
+	return cmd
+}
+
+// RunApply takes care of the actual upgrade functionality
+// It does the following things:
+// - Checks if the cluster is healthy
+// - Gets the configuration from the kubeadm-config ConfigMap in the cluster
+// - Enforces all version skew policies
+// - Asks the user if they really want to upgrade
+// - Makes sure the control plane images are available locally on the master(s)
+// - Upgrades the control plane components
+// - Applies the other resources that'd be created with kubeadm init as well, like
+//   - Creating the RBAC rules for the Bootstrap Tokens and the cluster-info ConfigMap
+//   - Applying new kube-dns and kube-proxy manifests
+//   - Uploads the newly used configuration to the cluster ConfigMap
+func RunApply(flags *applyFlags) error {
+
+	// Start with the basics, verify that the cluster is healthy and get the configuration from the cluster (using the ConfigMap)
+	upgradeVars, err := enforceRequirements(flags.parent.kubeConfigPath, flags.parent.cfgPath, flags.parent.printConfig)
+	if err != nil {
+		return err
+	}
+
+	// Set the upgraded version on the external config object now
+	upgradeVars.cfg.KubernetesVersion = flags.newK8sVersionStr
+
+	// Grab the external, versioned configuration and convert it to the internal type for usage here later
+	internalcfg := &kubeadmapi.MasterConfiguration{}
+	api.Scheme.Convert(upgradeVars.cfg, internalcfg, nil)
+
+	// Enforce the version skew policies
+	if err := EnforceVersionPolicies(flags, upgradeVars.versionGetter); err != nil {
+		return fmt.Errorf("[upgrade/version] FATAL: %v", err)
+	}
+
+	// If the current session is interactive, ask the user whether they really want to upgrade
+	if flags.SessionIsInteractive() {
+		if err := InteractivelyConfirmUpgrade("Are you sure you want to proceed with the upgrade?"); err != nil {
+			return err
+		}
+	}
+
+	// TODO: Implement a prepulling mechanism here
+
+	// Now; perform the upgrade procedure
+	if err := PerformControlPlaneUpgrade(flags, upgradeVars.client, internalcfg); err != nil {
+		return fmt.Errorf("[upgrade/apply] FATAL: %v", err)
+	}
+
+	// Upgrade RBAC rules and addons. Optionally, if needed, perform some extra task for a specific version
+	if err := upgrade.PerformPostUpgradeTasks(upgradeVars.client, internalcfg, flags.newK8sVersion); err != nil {
+		return fmt.Errorf("[upgrade/postupgrade] FATAL: %v", err)
+	}
+
+	fmt.Println("")
+	fmt.Printf("[upgrade/successful] SUCCESS! Your cluster was upgraded to %q. Enjoy!\n", flags.newK8sVersionStr)
+	fmt.Println("")
+	fmt.Println("[upgrade/kubelet] Now that your control plane is upgraded, please proceed with upgrading your kubelets in turn.")
+
+	return nil
+}
+
+// SetImplicitFlags handles dynamically defaulting flags based on each other's value
+func SetImplicitFlags(flags *applyFlags) error {
+	// If we are in dry-run or force mode; we should automatically execute this command non-interactively
+	if flags.dryRun || flags.force {
+		flags.nonInteractiveMode = true
+	}
+
+	k8sVer, err := version.ParseSemantic(flags.newK8sVersionStr)
+	if err != nil {
+		return fmt.Errorf("couldn't parse version %q as a semantic version", flags.newK8sVersionStr)
+	}
+	flags.newK8sVersion = k8sVer
+
+	// Automatically add the "v" prefix to the string representation in case it doesn't exist
+	if !strings.HasPrefix(flags.newK8sVersionStr, "v") {
+		flags.newK8sVersionStr = fmt.Sprintf("v%s", flags.newK8sVersionStr)
+	}
+
+	return nil
+}
+
+// EnforceVersionPolicies makes sure that the version the user specified is valid to upgrade to
+// There are both fatal and skippable (with --force) errors
+func EnforceVersionPolicies(flags *applyFlags, versionGetter upgrade.VersionGetter) error {
+	fmt.Printf("[upgrade/version] You have chosen to upgrade to version %q\n", flags.newK8sVersionStr)
+
+	versionSkewErrs := upgrade.EnforceVersionPolicies(versionGetter, flags.newK8sVersionStr, flags.newK8sVersion, flags.parent.allowExperimentalUpgrades, flags.parent.allowRCUpgrades)
+	if versionSkewErrs != nil {
+
+		if len(versionSkewErrs.Mandatory) > 0 {
+			return fmt.Errorf("The --version argument is invalid due to these fatal errors: %v", versionSkewErrs.Mandatory)
+		}
+
+		if len(versionSkewErrs.Skippable) > 0 {
+			// Return the error if the user hasn't specified the --force flag
+			if !flags.force {
+				return fmt.Errorf("The --version argument is invalid due to these errors: %v. Can be bypassed if you pass the --force flag", versionSkewErrs.Mandatory)
+			}
+			// Soft errors found, but --force was specified
+			fmt.Printf("[upgrade/version] Found %d potential version compatibility errors but skipping since the --force flag is set: %v\n", len(versionSkewErrs.Skippable), versionSkewErrs.Skippable)
+		}
+	}
+	return nil
+}
+
+// PerformControlPlaneUpgrade actually performs the upgrade procedure for the cluster of your type (self-hosted or static-pod-hosted)
+func PerformControlPlaneUpgrade(flags *applyFlags, client clientset.Interface, internalcfg *kubeadmapi.MasterConfiguration) error {
+
+	// Check if the cluster is self-hosted and act accordingly
+	if upgrade.IsControlPlaneSelfHosted(client) {
+		fmt.Printf("[upgrade/apply] Upgrading your Self-Hosted control plane to version %q...\n", flags.newK8sVersionStr)
+
+		// Upgrade a self-hosted cluster
+		// TODO(luxas): Implement this later when we have the new upgrade strategy
+		return fmt.Errorf("not implemented")
+	}
+
+	// OK, the cluster is hosted using static pods. Upgrade a static-pod hosted cluster
+	fmt.Printf("[upgrade/apply] Upgrading your Static Pod-hosted control plane to version %q...\n", flags.newK8sVersionStr)
+
+	if err := upgrade.PerformStaticPodControlPlaneUpgrade(client, internalcfg, flags.newK8sVersion); err != nil {
+		return err
+	}
+	return nil
+}

cmd/kubeadm/app/cmd/upgrade/common.go

+/*
+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 upgrade
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/ghodss/yaml"
+
+	clientset "k8s.io/client-go/kubernetes"
+	kubeadmapiext "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha1"
+	"k8s.io/kubernetes/cmd/kubeadm/app/phases/upgrade"
+	"k8s.io/kubernetes/cmd/kubeadm/app/preflight"
+	kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
+)
+
+// upgradeVariables holds variables needed for performing an upgrade or planning to do so
+// TODO - Restructure or rename upgradeVariables
+type upgradeVariables struct {
+	client        clientset.Interface
+	cfg           *kubeadmapiext.MasterConfiguration
+	versionGetter upgrade.VersionGetter
+}
+
+// enforceRequirements verifies that it's okay to upgrade and then returns the variables needed for the rest of the procedure
+func enforceRequirements(kubeConfigPath, cfgPath string, printConfig bool) (*upgradeVariables, error) {
+	client, err := kubeconfigutil.ClientSetFromFile(kubeConfigPath)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't create a Kubernetes client from file %q: %v", kubeConfigPath, err)
+	}
+
+	// Run healthchecks against the cluster
+	if err := upgrade.CheckClusterHealth(client); err != nil {
+		return nil, fmt.Errorf("[upgrade/health] FATAL: %v", err)
+	}
+
+	// Fetch the configuration from a file or ConfigMap and validate it
+	cfg, err := upgrade.FetchConfiguration(client, os.Stdout, cfgPath)
+	if err != nil {
+		return nil, fmt.Errorf("[upgrade/config] FATAL: %v", err)
+	}
+
+	// If the user told us to print this information out; do it!
+	if printConfig {
+		printConfiguration(cfg, os.Stdout)
+	}
+
+	return &upgradeVariables{
+		client: client,
+		cfg:    cfg,
+		// Use a real version getter interface that queries the API server, the kubeadm client and the Kubernetes CI system for latest versions
+		versionGetter: upgrade.NewKubeVersionGetter(client, os.Stdout),
+	}, nil
+}
+
+// printConfiguration prints the external version of the API to yaml
+func printConfiguration(cfg *kubeadmapiext.MasterConfiguration, w io.Writer) {
+	// Short-circuit if cfg is nil, so we can safely get the value of the pointer below
+	if cfg == nil {
+		return
+	}
+
+	cfgYaml, err := yaml.Marshal(*cfg)
+	if err == nil {
+		fmt.Fprintln(w, "[upgrade/config] Configuration used:")
+
+		scanner := bufio.NewScanner(bytes.NewReader(cfgYaml))
+		for scanner.Scan() {
+			fmt.Fprintf(w, "\t%s\n", scanner.Text())
+		}
+	}
+}
+
+// runPreflightChecks runs the root preflight check
+func runPreflightChecks(skipPreFlight bool) error {
+	if skipPreFlight {
+		fmt.Println("[preflight] Skipping pre-flight checks")
+		return nil
+	}
+
+	fmt.Println("[preflight] Running pre-flight checks")
+	return preflight.RunRootCheckOnly()
+}
+
+// InteractivelyConfirmUpgrade asks the user whether they _really_ want to upgrade.
+func InteractivelyConfirmUpgrade(question string) error {
+
+	fmt.Printf("[upgrade/confirm] %s [y/N]: ", question)
+
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("couldn't read from standard input: %v", err)
+	}
+	answer := scanner.Text()
+	if strings.ToLower(answer) == "y" || strings.ToLower(answer) == "yes" {
+		return nil
+	}
+
+	return fmt.Errorf("won't proceed; the user didn't answer (Y|y) in order to continue")
+}

cmd/kubeadm/app/cmd/upgrade/plan.go

+/*
+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 upgrade
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sort"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/kubernetes/cmd/kubeadm/app/phases/upgrade"
+	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
+)
+
+// NewCmdPlan returns the cobra command for `kubeadm upgrade plan`
+func NewCmdPlan(parentFlags *cmdUpgradeFlags) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "plan",
+		Short: "Check which versions are available to upgrade to and validate whether your current cluster is upgradeable",
+		Run: func(_ *cobra.Command, _ []string) {
+			// Ensure the user is root
+			err := runPreflightChecks(parentFlags.skipPreFlight)
+			kubeadmutil.CheckErr(err)
+
+			err = RunPlan(parentFlags)
+			kubeadmutil.CheckErr(err)
+		},
+	}
+
+	return cmd
+}
+
+// RunPlan takes care of outputting available versions to upgrade to for the user
+func RunPlan(parentFlags *cmdUpgradeFlags) error {
+
+	// Start with the basics, verify that the cluster is healthy, build a client and a versionGetter.
+	upgradeVars, err := enforceRequirements(parentFlags.kubeConfigPath, parentFlags.cfgPath, parentFlags.printConfig)
+	if err != nil {
+		return err
+	}
+
+	// Compute which upgrade possibilities there are
+	availUpgrades, err := upgrade.GetAvailableUpgrades(upgradeVars.versionGetter, parentFlags.allowExperimentalUpgrades, parentFlags.allowRCUpgrades)
+	if err != nil {
+		return err
+	}
+
+	// Tell the user which upgrades are available
+	printAvailableUpgrades(availUpgrades, os.Stdout)
+	return nil
+}
+
+// printAvailableUpgrades prints a UX-friendly overview of what versions are available to upgrade to
+// TODO look into columnize or some other formatter when time permits instead of using the tabwriter
+func printAvailableUpgrades(upgrades []upgrade.Upgrade, w io.Writer) {
+
+	// Return quickly if no upgrades can be made
+	if len(upgrades) == 0 {
+		fmt.Fprintln(w, "Awesome, you're up-to-date! Enjoy!")
+		return
+	}
+	// The tab writer writes to the "real" writer w
+	tabw := tabwriter.NewWriter(w, 10, 4, 3, ' ', 0)
+
+	// Loop through the upgrade possibilities and output text to the command line
+	for _, upgrade := range upgrades {
+
+		if upgrade.CanUpgradeKubelets() {
+			fmt.Fprintln(w, "Components that must be upgraded manually after you've upgraded the control plane with 'kubeadm upgrade apply':")
+			fmt.Fprintln(tabw, "COMPONENT\tCURRENT\tAVAILABLE")
+			firstPrinted := false
+
+			// The map is of the form <old-version>:<node-count>. Here all the keys are put into a slice and sorted
+			// in order to always get the right order. Then the map value is extracted separately
+			for _, oldVersion := range sortedSliceFromStringIntMap(upgrade.Before.KubeletVersions) {
+				nodeCount := upgrade.Before.KubeletVersions[oldVersion]
+				if !firstPrinted {
+					// Output the Kubelet header only on the first version pair
+					fmt.Fprintf(tabw, "Kubelet\t%d x %s\t%s\n", nodeCount, oldVersion, upgrade.After.KubeVersion)
+					firstPrinted = true
+					continue
+				}
+				fmt.Fprintf(tabw, "\t\t%d x %s\t%s\n", nodeCount, oldVersion, upgrade.After.KubeVersion)
+			}
+			// We should flush the writer here at this stage; as the columns will now be of the right size, adjusted to the above content
+			tabw.Flush()
+			fmt.Fprintln(w, "")
+		}
+
+		fmt.Fprintf(w, "Upgrade to the latest %s:\n", upgrade.Description)
+		fmt.Fprintln(w, "")
+		fmt.Fprintln(tabw, "COMPONENT\tCURRENT\tAVAILABLE")
+		fmt.Fprintf(tabw, "API Server\t%s\t%s\n", upgrade.Before.KubeVersion, upgrade.After.KubeVersion)
+		fmt.Fprintf(tabw, "Controller Manager\t%s\t%s\n", upgrade.Before.KubeVersion, upgrade.After.KubeVersion)
+		fmt.Fprintf(tabw, "Scheduler\t%s\t%s\n", upgrade.Before.KubeVersion, upgrade.After.KubeVersion)
+		fmt.Fprintf(tabw, "Kube Proxy\t%s\t%s\n", upgrade.Before.KubeVersion, upgrade.After.KubeVersion)
+		fmt.Fprintf(tabw, "Kube DNS\t%s\t%s\n", upgrade.Before.DNSVersion, upgrade.After.DNSVersion)
+
+		// The tabwriter should be flushed at this stage as we have now put in all the required content for this time. This is required for the tabs' size to be correct.
+		tabw.Flush()
+		fmt.Fprintln(w, "")
+		fmt.Fprintln(w, "You can now apply the upgrade by executing the following command:")
+		fmt.Fprintln(w, "")
+		fmt.Fprintf(w, "\tkubeadm upgrade apply %s\n", upgrade.After.KubeVersion)
+		fmt.Fprintln(w, "")
+
+		if upgrade.Before.KubeadmVersion != upgrade.After.KubeadmVersion {
+			fmt.Fprintf(w, "Note: Before you do can perform this upgrade, you have to update kubeadm to %s\n", upgrade.After.KubeadmVersion)
+			fmt.Fprintln(w, "")
+		}
+
+		fmt.Fprintln(w, "_____________________________________________________________________")
+		fmt.Fprintln(w, "")
+	}
+}
+
+// sortedSliceFromStringIntMap returns a slice of the keys in the map sorted alphabetically
+func sortedSliceFromStringIntMap(strMap map[string]uint16) []string {
+	strSlice := []string{}
+	for k := range strMap {
+		strSlice = append(strSlice, k)
+	}
+	sort.Strings(strSlice)
+	return strSlice
+}

cmd/kubeadm/app/cmd/upgrade/upgrade.go

+/*
+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 upgrade
+
+import (
+	"io"
+
+	"github.com/spf13/cobra"
+	cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
+)
+
+// cmdUpgradeFlags holds the values for the common flags in `kubeadm upgrade`
+type cmdUpgradeFlags struct {
+	kubeConfigPath            string
+	cfgPath                   string
+	allowExperimentalUpgrades bool
+	allowRCUpgrades           bool
+	printConfig               bool
+	skipPreFlight             bool
+}
+
+// NewCmdUpgrade returns the cobra command for `kubeadm upgrade`
+func NewCmdUpgrade(out io.Writer) *cobra.Command {
+	flags := &cmdUpgradeFlags{
+		kubeConfigPath:            "/etc/kubernetes/admin.conf",
+		cfgPath:                   "",
+		allowExperimentalUpgrades: false,
+		allowRCUpgrades:           false,
+		printConfig:               false,
+		skipPreFlight:             false,
+	}
+
+	cmd := &cobra.Command{
+		Use:   "upgrade",
+		Short: "Upgrade your cluster smoothly to a newer version with this command.",
+		RunE:  cmdutil.SubCmdRunE("upgrade"),
+	}
+
+	cmd.PersistentFlags().StringVar(&flags.kubeConfigPath, "kubeconfig", flags.kubeConfigPath, "The KubeConfig file to use for talking to the cluster.")
+	cmd.PersistentFlags().StringVar(&flags.cfgPath, "config", flags.cfgPath, "Path to kubeadm config file (WARNING: Usage of a configuration file is experimental).")
+	cmd.PersistentFlags().BoolVar(&flags.allowExperimentalUpgrades, "allow-experimental-upgrades", flags.allowExperimentalUpgrades, "Show unstable versions of Kubernetes as an upgrade alternative and allow upgrading to an alpha/beta/release candidate versions of Kubernetes.")
+	cmd.PersistentFlags().BoolVar(&flags.allowRCUpgrades, "allow-release-candidate-upgrades", flags.allowRCUpgrades, "Show release candidate versions of Kubernetes as an upgrade alternative and allow upgrading to a release candidate versions of Kubernetes.")
+	cmd.PersistentFlags().BoolVar(&flags.printConfig, "print-config", flags.printConfig, "Whether the configuration file that will be used in the upgrade should be printed or not.")
+	cmd.PersistentFlags().BoolVar(&flags.skipPreFlight, "skip-preflight-checks", flags.skipPreFlight, "Skip preflight checks normally run before modifying the system")
+
+	cmd.AddCommand(NewCmdApply(flags))
+	cmd.AddCommand(NewCmdPlan(flags))
+
+	return cmd
+}

cmd/kubeadm/app/phases/upgrade/compute.go

+/*
+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 upgrade
+
+import (
+	"fmt"
+)
+
+// Upgrade defines an upgrade possibility to upgrade from a current version to a new one
+type Upgrade struct {
+	Description string
+	Before      ClusterState
+	After       ClusterState
+}
+
+// CanUpgradeKubelets returns whether an upgrade of any kubelet in the cluster is possible
+func (u *Upgrade) CanUpgradeKubelets() bool {
+	// If there are multiple different versions now, an upgrade is possible (even if only for a subset of the nodes)
+	if len(u.Before.KubeletVersions) > 1 {
+		return true
+	}
+	// Don't report something available for upgrade if we don't know the current state
+	if len(u.Before.KubeletVersions) == 0 {
+		return false
+	}
+
+	// if the same version number existed both before and after, we don't have to upgrade it
+	_, sameVersionFound := u.Before.KubeletVersions[u.After.KubeVersion]
+	return !sameVersionFound
+}
+
+// ClusterState describes the state of certain versions for a cluster
+type ClusterState struct {
+	// KubeVersion describes the version of the Kubernetes API Server, Controller Manager, Scheduler and Proxy.
+	KubeVersion string
+	// DNSVersion describes the version of the kube-dns images used and manifest version
+	DNSVersion string
+	// KubeadmVersion describes the version of the kubeadm CLI
+	KubeadmVersion string
+	// KubeletVersions is a map with a version number linked to the amount of kubelets running that version in the cluster
+	KubeletVersions map[string]uint16
+}
+
+// GetAvailableUpgrades fetches all versions from the specified VersionGetter and computes which
+// kinds of upgrades can be performed
+func GetAvailableUpgrades(_ VersionGetter, _, _ bool) ([]Upgrade, error) {
+	fmt.Println("[upgrade] Fetching available versions to upgrade to:")
+	return []Upgrade{}, nil
+}

cmd/kubeadm/app/phases/upgrade/configuration.go

+/*
+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 upgrade
+
+import (
+	"fmt"
+	"io"
+
+	clientset "k8s.io/client-go/kubernetes"
+	kubeadmapiext "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha1"
+	"k8s.io/kubernetes/pkg/api"
+)
+
+// FetchConfiguration fetches configuration required for upgrading your cluster from a file (which has precedence) or a ConfigMap in the cluster
+func FetchConfiguration(_ clientset.Interface, _ io.Writer, _ string) (*kubeadmapiext.MasterConfiguration, error) {
+	fmt.Println("[upgrade/config] Making sure the configuration is correct:")
+
+	cfg := &kubeadmapiext.MasterConfiguration{}
+	api.Scheme.Default(cfg)
+
+	return cfg, nil
+}

cmd/kubeadm/app/phases/upgrade/health.go

+/*
+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 upgrade
+
+import (
+	clientset "k8s.io/client-go/kubernetes"
+)
+
+// CheckClusterHealth makes sure:
+// - the API /healthz endpoint is healthy
+// - all Nodes are Ready
+// - (if self-hosted) that there are DaemonSets with at least one Pod for all control plane components
+// - (if static pod-hosted) that all required Static Pod manifests exist on disk
+func CheckClusterHealth(_ clientset.Interface) error {
+	return nil
+}
+
+// IsControlPlaneSelfHosted returns whether the control plane is self hosted or not
+func IsControlPlaneSelfHosted(_ clientset.Interface) bool {
+	// No-op for now
+	return false
+}

cmd/kubeadm/app/phases/upgrade/policy.go

+/*
+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 upgrade
+
+import (
+	"k8s.io/kubernetes/pkg/util/version"
+)
+
+// VersionSkewPolicyErrors describes version skew errors that might be seen during the validation process in EnforceVersionPolicies
+type VersionSkewPolicyErrors struct {
+	Mandatory []error
+	Skippable []error
+}
+
+// EnforceVersionPolicies enforces that the proposed new version is compatible with all the different version skew policies
+func EnforceVersionPolicies(_ VersionGetter, _ string, _ *version.Version, _, _ bool) *VersionSkewPolicyErrors {
+	// No-op now and return no skew errors
+	return nil
+}

cmd/kubeadm/app/phases/upgrade/postupgrade.go

+/*
+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 upgrade
+
+import (
+	clientset "k8s.io/client-go/kubernetes"
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
+	"k8s.io/kubernetes/pkg/util/version"
+)
+
+// PerformPostUpgradeTasks runs nearly the same functions as 'kubeadm init' would do
+// Note that the markmaster phase is left out, not needed, and no token is created as that doesn't belong to the upgrade
+func PerformPostUpgradeTasks(_ clientset.Interface, _ *kubeadmapi.MasterConfiguration, _ *version.Version) error {
+	// No-op; don't do anything here yet
+	return nil
+}

cmd/kubeadm/app/phases/upgrade/staticpods.go

+/*
+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 upgrade
+
+import (
+	clientset "k8s.io/client-go/kubernetes"
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
+	"k8s.io/kubernetes/pkg/util/version"
+)
+
+// PerformStaticPodControlPlaneUpgrade upgrades a static pod-hosted control plane
+func PerformStaticPodControlPlaneUpgrade(_ clientset.Interface, _ *kubeadmapi.MasterConfiguration, _ *version.Version) error {
+	// No-op for now; doesn't do anything yet
+	return nil
+}

cmd/kubeadm/app/phases/upgrade/versiongetter.go

+/*
+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 upgrade
+
+import (
+	"fmt"
+	"io"
+
+	clientset "k8s.io/client-go/kubernetes"
+	versionutil "k8s.io/kubernetes/pkg/util/version"
+)
+
+// VersionGetter defines an interface for fetching different versions.
+// Easy to implement a fake variant of this interface for unit testing
+type VersionGetter interface {
+	// ClusterVersion should return the version of the cluster i.e. the API Server version
+	ClusterVersion() (string, *versionutil.Version, error)
+	// KubeadmVersion should return the version of the kubeadm CLI
+	KubeadmVersion() (string, *versionutil.Version, error)
+	// VersionFromCILabel should resolve CI labels like `latest`, `stable`, `stable-1.8`, etc. to real versions
+	VersionFromCILabel(string, string) (string, *versionutil.Version, error)
+	// KubeletVersions should return a map with a version and a number that describes how many kubelets there are for that version
+	KubeletVersions() (map[string]uint16, error)
+}
+
+// KubeVersionGetter handles the version-fetching mechanism from external sources
+type KubeVersionGetter struct {
+	client clientset.Interface
+	w      io.Writer
+}
+
+// Make sure KubeVersionGetter implements the VersionGetter interface
+var _ VersionGetter = &KubeVersionGetter{}
+
+// NewKubeVersionGetter returns a new instance of KubeVersionGetter
+func NewKubeVersionGetter(client clientset.Interface, writer io.Writer) *KubeVersionGetter {
+	return &KubeVersionGetter{
+		client: client,
+		w:      writer,
+	}
+}
+
+// ClusterVersion gets API server version
+func (g *KubeVersionGetter) ClusterVersion() (string, *versionutil.Version, error) {
+	fmt.Fprintf(g.w, "[upgrade/versions] Cluster version: ")
+	fmt.Fprintln(g.w, "v1.7.0")
+
+	return "v1.7.0", versionutil.MustParseSemantic("v1.7.0"), nil
+}
+
+// KubeadmVersion gets kubeadm version
+func (g *KubeVersionGetter) KubeadmVersion() (string, *versionutil.Version, error) {
+	fmt.Fprintf(g.w, "[upgrade/versions] kubeadm version: %s\n", "v1.8.0")
+
+	return "v1.8.0", versionutil.MustParseSemantic("v1.8.0"), nil
+}
+
+// VersionFromCILabel resolves different labels like "stable" to action semver versions using the Kubernetes CI uploads to GCS
+func (g *KubeVersionGetter) VersionFromCILabel(_, _ string) (string, *versionutil.Version, error) {
+	return "v1.8.1", versionutil.MustParseSemantic("v1.8.0"), nil
+}
+
+// KubeletVersions gets the versions of the kubelets in the cluster
+func (g *KubeVersionGetter) KubeletVersions() (map[string]uint16, error) {
+	// This tells kubeadm that there are two nodes in the cluster; both on the v1.7.1 version currently
+	return map[string]uint16{
+		"v1.7.1": 2,
+	}, nil
+}