Merge pull request #2281 from fabriziopandini/clusterctl-upgrade-plan-apply

✨clusterctl: implement upgrade apply

Author: k8s-ci-robot

cmd/clusterctl/cmd/upgrade.go

@@ -62,11 +62,44 @@ var upgradePlanCmd = &cobra.Command{
 	},
 }
 
+type upgradeApplyOptions struct {
+	kubeconfig      string
+	managementGroup string
+	contract        string
+}
+
+var ua = &upgradeApplyOptions{}
+
+var upgradeApplyCmd = &cobra.Command{
+	Use:   "apply",
+	Short: "Applies new versions of Cluster API providers in a management cluster",
+	Long: LongDesc(`
+		The upgrade apply command applies new versions of Cluster API providers as defined by clusterctl upgrade plan.
+		
+		New version should be applied for each management groups, ensuring all the providers on the same cluster API version
+		in order to guarantee the proper functioning of the management cluster.`),
+
+	Example: Examples(`
+		# Upgrades all the providers in the capi-system/cluster-api to the latest version available which is compliant
+		# to the v1alpha3 API Version of Cluster API (contract).
+		clusterctl upgrade apply --management-group capi-system/cluster-api  --contract v1alpha3`),
+
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runUpgradeApply()
+	},
+}
+
 func init() {
 	upgradePlanCmd.Flags().StringVarP(&up.kubeconfig, "kubeconfig", "", "", "Path to the kubeconfig file to use for accessing the management cluster. If empty, default rules for kubeconfig discovery will be used")
 
 	upgradeCmd.AddCommand(upgradePlanCmd)
 
+	upgradeApplyCmd.Flags().StringVarP(&ua.kubeconfig, "kubeconfig", "", "", "Path to the kubeconfig file to use for accessing the management cluster. If empty, default rules for kubeconfig discovery will be used")
+	upgradeApplyCmd.Flags().StringVarP(&ua.managementGroup, "management-group", "", "", "The management group that should be upgraded")
+	upgradeApplyCmd.Flags().StringVarP(&ua.contract, "contract", "", "", "The API Version of Cluster API (contract) the management group should upgrade to")
+
+	upgradeCmd.AddCommand(upgradeApplyCmd)
+
 	RootCmd.AddCommand(upgradeCmd)
 }
 
@@ -114,7 +147,7 @@ func runUpgradePlan() error {
 		if upgradeAvailable {
 			fmt.Println("You can now apply the upgrade by executing the following command:")
 			fmt.Println("")
-			fmt.Println(fmt.Sprintf("   upgrade apply --management-group %s --cluster-api-version %s", plan.CoreProvider.InstanceName(), plan.Contract))
+			fmt.Println(fmt.Sprintf("   upgrade apply --management-group %s --contract %s", plan.CoreProvider.InstanceName(), plan.Contract))
 		} else {
 			fmt.Println("You are already up to date!")
 		}
@@ -146,3 +179,19 @@ func prettifyTargetVersion(version string) string {
 	}
 	return version
 }
+
+func runUpgradeApply() error {
+	c, err := client.New(cfgFile)
+	if err != nil {
+		return err
+	}
+
+	if err := c.ApplyUpgrade(client.ApplyUpgradeOptions{
+		Kubeconfig:      ua.kubeconfig,
+		ManagementGroup: ua.managementGroup,
+		Contract:        ua.contract,
+	}); err != nil {
+		return err
+	}
+	return nil
+}

cmd/clusterctl/pkg/client/client.go

@@ -120,12 +120,6 @@ type MoveOptions struct {
 	Namespace string
 }
 
-// PlanUpgradeOptions carries the options supported by upgrade plan.
-type PlanUpgradeOptions struct {
-	// Kubeconfig file to use for accessing the management cluster. If empty, default rules for kubeconfig discovery will be used.
-	Kubeconfig string
-}
-
 // Client is exposes the clusterctl high-level client library.
 type Client interface {
 	// GetProvidersConfig returns the list of providers configured for this instance of clusterctl.
@@ -152,6 +146,9 @@ type Client interface {
 	//   - Upgrade to the latest version in the the v1alpha2 series: ....
 	//   - Upgrade to the latest version in the the v1alpha3 series: ....
 	PlanUpgrade(options PlanUpgradeOptions) ([]UpgradePlan, error)
+
+	// ApplyUpgrade executes an upgrade plan.
+	ApplyUpgrade(options ApplyUpgradeOptions) error
 }
 
 // clusterctlClient implements Client.

cmd/clusterctl/pkg/client/client_test.go

@@ -46,7 +46,7 @@ func TestNewFakeClient(t *testing.T) {
 		WithFile("v1.0", "components.yaml", []byte("content"))
 
 	// create a fake cluster, eventually adding some existing runtime objects to it
-	cluster1 := newFakeCluster("cluster1").
+	cluster1 := newFakeCluster("cluster1", config1).
 		WithObjs()
 
 	// create a new fakeClient that allows to execute tests on the fake config, the fake repositories and the fake cluster.
@@ -92,6 +92,10 @@ func (f fakeClient) PlanUpgrade(options PlanUpgradeOptions) ([]UpgradePlan, erro
 	return f.internalClient.PlanUpgrade(options)
 }
 
+func (f fakeClient) ApplyUpgrade(options ApplyUpgradeOptions) error {
+	return f.internalClient.ApplyUpgrade(options)
+}
+
 // newFakeClient returns a clusterctl client that allows to execute tests on a set of fake config, fake repositories and fake clusters.
 // you can use WithCluster and WithRepository to prepare for the test case.
 func newFakeClient(configClient config.Client) *fakeClient {
@@ -143,20 +147,29 @@ func (f *fakeClient) WithRepository(repositoryClient repository.Client) *fakeCli
 // newFakeCluster returns a fakeClusterClient that
 // internally uses a FakeProxy (based on the controller-runtime FakeClient).
 // You can use WithObjs to pre-load a set of runtime objects in the cluster.
-func newFakeCluster(kubeconfig string) *fakeClusterClient {
-	configClient := newFakeConfig()
-	fakeProxy := test.NewFakeProxy()
+func newFakeCluster(kubeconfig string, configClient config.Client) *fakeClusterClient {
+	fake := &fakeClusterClient{
+		kubeconfig:   kubeconfig,
+		repositories: map[string]repository.Client{},
+	}
+
+	fake.fakeProxy = test.NewFakeProxy()
 	pollImmediateWaiter := func(interval, timeout time.Duration, condition wait.ConditionFunc) error {
 		return nil
 	}
 
-	client := cluster.New("", configClient, cluster.InjectProxy(fakeProxy), cluster.InjectPollImmediateWaiter(pollImmediateWaiter))
+	fake.internalclient = cluster.New("", configClient,
+		cluster.InjectProxy(fake.fakeProxy),
+		cluster.InjectPollImmediateWaiter(pollImmediateWaiter),
+		cluster.InjectRepositoryFactory(func(provider config.Provider, configVariablesClient config.VariablesClient, options ...repository.Option) (repository.Client, error) {
+			if _, ok := fake.repositories[provider.Name()]; !ok {
+				return nil, errors.Errorf("Repository for kubeconfig %q does not exists.", provider.Name())
+			}
+			return fake.repositories[provider.Name()], nil
+		}),
+	)
 
-	return &fakeClusterClient{
-		kubeconfig:     kubeconfig,
-		fakeProxy:      fakeProxy,
-		internalclient: client,
-	}
+	return fake
 }
 
 type fakeCertManagerClient struct {
@@ -172,6 +185,7 @@ func (p *fakeCertManagerClient) EnsureWebHook() error {
 type fakeClusterClient struct {
 	kubeconfig     string
 	fakeProxy      *test.FakeProxy
+	repositories   map[string]repository.Client
 	internalclient cluster.Client
 }
 
@@ -219,6 +233,11 @@ func (f *fakeClusterClient) WithProviderInventory(name string, providerType clus
 	return f
 }
 
+func (f *fakeClusterClient) WithRepository(repositoryClient repository.Client) *fakeClusterClient {
+	f.repositories[repositoryClient.Name()] = repositoryClient
+	return f
+}
+
 // newFakeConfig return a fake implementation of the client for low-level config library.
 // The implementation uses a FakeReader that stores configuration settings in a map; you can use
 // the WithVar or WithProvider methods to set the map values.
@@ -315,6 +334,16 @@ func (f *fakeRepositoryClient) WithDefaultVersion(version string) *fakeRepositor
 	return f
 }
 
+func (f *fakeRepositoryClient) WithVersions(version ...string) *fakeRepositoryClient {
+	f.fakeRepository.WithVersions(version...)
+	return f
+}
+
+func (f *fakeRepositoryClient) WithMetadata(version string, metadata *clusterctlv1.Metadata) *fakeRepositoryClient {
+	f.fakeRepository.WithMetadata(version, metadata)
+	return f
+}
+
 func (f *fakeRepositoryClient) WithFile(version, path string, content []byte) *fakeRepositoryClient {
 	f.fakeRepository.WithFile(version, path, content)
 	return f

cmd/clusterctl/pkg/client/cluster/client.go

@@ -114,7 +114,7 @@ func (c *clusterClient) ObjectMover() ObjectMover {
 }
 
 func (c *clusterClient) ProviderUpgrader() ProviderUpgrader {
-	return newProviderUpgrader(c.configClient, c.repositoryClientFactory, c.ProviderInventory())
+	return newProviderUpgrader(c.configClient, c.repositoryClientFactory, c.ProviderInventory(), c.ProviderComponents())
 }
 
 // Option is a configuration option supplied to New

cmd/clusterctl/pkg/client/cluster/installer.go

@@ -53,11 +53,7 @@ func (i *providerInstaller) Add(components repository.Components) error {
 func (i *providerInstaller) Install() ([]repository.Components, error) {
 	ret := make([]repository.Components, 0, len(i.installQueue))
 	for _, components := range i.installQueue {
-		if err := i.providerComponents.Create(components); err != nil {
-			return nil, err
-		}
-
-		if err := i.providerInventory.Create(components.InventoryObject()); err != nil {
+		if err := installComponentsAndUpdateInventory(components, i.providerComponents, i.providerInventory); err != nil {
 			return nil, err
 		}
 
@@ -66,6 +62,18 @@ func (i *providerInstaller) Install() ([]repository.Components, error) {
 	return ret, nil
 }
 
+func installComponentsAndUpdateInventory(components repository.Components, providerComponents ComponentsClient, providerInventory InventoryClient) error {
+	if err := providerComponents.Create(components); err != nil {
+		return err
+	}
+
+	if err := providerInventory.Create(components.InventoryObject()); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func newProviderInstaller(proxy Proxy, providerMetadata InventoryClient, providerComponents ComponentsClient) *providerInstaller {
 	return &providerInstaller{
 		proxy:              proxy,