Merge pull request #5454 from twz123/load-nodeconfig-once

Load node configuration only once

Author: twz123

cmd/backup/backup_unix.go

@@ -26,6 +26,7 @@ import (
 	"strings"
 
 	"github.com/k0sproject/k0s/internal/pkg/dir"
+	k0sv1beta1 "github.com/k0sproject/k0s/pkg/apis/k0s/v1beta1"
 	"github.com/k0sproject/k0s/pkg/backup"
 	"github.com/k0sproject/k0s/pkg/component/status"
 	"github.com/k0sproject/k0s/pkg/config"
@@ -56,7 +57,7 @@ func NewBackupCmd() *cobra.Command {
 			if nodeConfig.Spec.Storage.Etcd.IsExternalClusterUsed() {
 				return errors.New("command 'k0s backup' does not support external etcd cluster")
 			}
-			return c.backup(savePath, cmd.OutOrStdout())
+			return c.backup(nodeConfig, savePath, cmd.OutOrStdout())
 		},
 	}
 
@@ -67,7 +68,7 @@ func NewBackupCmd() *cobra.Command {
 	return cmd
 }
 
-func (c *command) backup(savePath string, out io.Writer) error {
+func (c *command) backup(nodeConfig *k0sv1beta1.ClusterConfig, savePath string, out io.Writer) error {
 	if os.Geteuid() != 0 {
 		return errors.New("this command must be run as root!")
 	}
@@ -86,11 +87,6 @@ func (c *command) backup(savePath string, out io.Writer) error {
 	}
 	logrus.Debugf("detected role for backup operations: %v", status.Role)
 
-	nodeConfig, err := c.K0sVars.NodeConfig()
-	if err != nil {
-		return err
-	}
-
 	if strings.Contains(status.Role, "controller") {
 		mgr, err := backup.NewBackupManager()
 		if err != nil {

cmd/controller/controller.go

@@ -160,7 +160,7 @@ func (c *command) start(ctx context.Context) error {
 		return fmt.Errorf("failed to initialize dir: %w", err)
 	}
 
-	rtc, err := config.NewRuntimeConfig(c.K0sVars)
+	rtc, err := config.NewRuntimeConfig(c.K0sVars, nodeConfig)
 	if err != nil {
 		return fmt.Errorf("failed to initialize runtime config: %w", err)
 	}

cmd/reset/reset.go

@@ -76,7 +76,7 @@ func (c *command) reset() error {
 	}
 
 	// Get Cleanup Config
-	cfg, err := cleanup.NewConfig(c.Debug, c.K0sVars, c.WorkerOptions.CriSocket)
+	cfg, err := cleanup.NewConfig(c.Debug, c.K0sVars, nodeCfg.Spec.Install.SystemUsers, c.WorkerOptions.CriSocket)
 	if err != nil {
 		return fmt.Errorf("failed to configure cleanup: %w", err)
 	}

cmd/token/create.go

@@ -61,6 +61,11 @@ k0s token create --role worker --expiry 10m  //sets expiration time to 10 minute
 				return err
 			}
 
+			nodeConfig, err := opts.K0sVars.NodeConfig()
+			if err != nil {
+				return err
+			}
+
 			var bootstrapToken string
 			// we will retry every second for two minutes and then error
 			err = retry.OnError(wait.Backoff{
@@ -83,11 +88,6 @@ k0s token create --role worker --expiry 10m  //sets expiration time to 10 minute
 					return err
 				}
 
-				nodeConfig, err := opts.K0sVars.NodeConfig()
-				if err != nil {
-					return err
-				}
-
 				bootstrapToken, err = token.CreateKubeletBootstrapToken(cmd.Context(), nodeConfig.Spec.API, opts.K0sVars, createTokenRole, expiry)
 				return err
 			})

pkg/backup/manager_unix.go

@@ -164,7 +164,7 @@ func (bm *Manager) RunRestore(archivePath string, k0sVars *config.CfgVars, desir
 		return fmt.Errorf("failed to unpack backup archive `%s`: %w", archivePath, err)
 	}
 	defer os.RemoveAll(bm.tmpDir)
-	cfg, err := bm.getConfigForRestore(k0sVars)
+	cfg, err := bm.getConfigForRestore()
 	if err != nil {
 		return fmt.Errorf("failed to parse backed-up configuration file, check the backup archive: %w", err)
 	}
@@ -180,11 +180,16 @@ func (bm *Manager) RunRestore(archivePath string, k0sVars *config.CfgVars, desir
 	return nil
 }
 
-func (bm Manager) getConfigForRestore(k0sVars *config.CfgVars) (*v1beta1.ClusterConfig, error) {
+func (bm Manager) getConfigForRestore() (*v1beta1.ClusterConfig, error) {
 	configFromBackup := path.Join(bm.tmpDir, "k0s.yaml")
 	logrus.Debugf("Using k0s.yaml from: %s", configFromBackup)
 
-	cfg, err := k0sVars.NodeConfig()
+	bytes, err := os.ReadFile(configFromBackup)
+	if err != nil {
+		return nil, err
+	}
+
+	cfg, err := v1beta1.ConfigFromString(string(bytes))
 	if err != nil {
 		return nil, err
 	}

pkg/cleanup/cleanup.go

@@ -37,22 +37,15 @@ type Config struct {
 	cleanupSteps []Step
 }
 
-func NewConfig(debug bool, k0sVars *config.CfgVars, criSocketFlag string) (*Config, error) {
-	cfg, err := k0sVars.NodeConfig()
-	if err != nil {
-		logrus.Errorf("failed to get cluster setup: %v", err)
-	}
-
+func NewConfig(debug bool, k0sVars *config.CfgVars, systemUsers *k0sv1beta1.SystemUser, criSocketFlag string) (*Config, error) {
 	containers, err := newContainersStep(debug, k0sVars, criSocketFlag)
 	if err != nil {
 		return nil, err
 	}
 
 	cleanupSteps := []Step{
 		containers,
-		&users{
-			systemUsers: cfg.Spec.Install.SystemUsers,
-		},
+		&users{systemUsers: systemUsers},
 		&services{},
 		&directories{
 			dataDir:        k0sVars.DataDir,

pkg/component/controller/coredns.go

@@ -274,9 +274,8 @@ var _ manager.Reconciler = (*CoreDNS)(nil)
 
 // CoreDNS is the component implementation to manage CoreDNS
 type CoreDNS struct {
-	K0sVars    *config.CfgVars
-	NodeConfig *v1beta1.ClusterConfig
-
+	dnsAddress             string
+	clusterDomain          string
 	client                 kubernetes.Interface
 	log                    *logrus.Entry
 	manifestDir            string
@@ -298,19 +297,22 @@ type coreDNSConfig struct {
 
 // NewCoreDNS creates new instance of CoreDNS component
 func NewCoreDNS(k0sVars *config.CfgVars, clientFactory k8sutil.ClientFactoryInterface, nodeConfig *v1beta1.ClusterConfig) (*CoreDNS, error) {
-	manifestDir := path.Join(k0sVars.ManifestsDir, "coredns")
+	dnsAddress, err := nodeConfig.Spec.Network.DNSAddress()
+	if err != nil {
+		return nil, err
+	}
 
 	client, err := clientFactory.GetClient()
 	if err != nil {
 		return nil, err
 	}
-	log := logrus.WithFields(logrus.Fields{"component": "coredns"})
+
 	return &CoreDNS{
-		client:      client,
-		log:         log,
-		K0sVars:     k0sVars,
-		manifestDir: manifestDir,
-		NodeConfig:  nodeConfig,
+		dnsAddress:    dnsAddress,
+		clusterDomain: nodeConfig.Spec.Network.ClusterDomain,
+		client:        client,
+		log:           logrus.WithField("component", "coredns"),
+		manifestDir:   path.Join(k0sVars.ManifestsDir, "coredns"),
 	}, nil
 }
 
@@ -348,16 +350,6 @@ func (c *CoreDNS) Start(ctx context.Context) error {
 }
 
 func (c *CoreDNS) getConfig(ctx context.Context, clusterConfig *v1beta1.ClusterConfig) (coreDNSConfig, error) {
-	nodeConfig, err := c.K0sVars.NodeConfig()
-	if err != nil {
-		return coreDNSConfig{}, fmt.Errorf("failed to get node config: %w", err)
-	}
-
-	dns, err := nodeConfig.Spec.Network.DNSAddress()
-	if err != nil {
-		return coreDNSConfig{}, err
-	}
-
 	nodes, err := c.client.CoreV1().Nodes().List(ctx, v1.ListOptions{})
 	if err != nil {
 		return coreDNSConfig{}, err
@@ -367,8 +359,8 @@ func (c *CoreDNS) getConfig(ctx context.Context, clusterConfig *v1beta1.ClusterC
 
 	config := coreDNSConfig{
 		Replicas:      replicaCount(nodeCount),
-		ClusterDomain: nodeConfig.Spec.Network.ClusterDomain,
-		ClusterDNSIP:  dns,
+		ClusterDomain: c.clusterDomain,
+		ClusterDNSIP:  c.dnsAddress,
 		Image:         clusterConfig.Spec.Images.CoreDNS.URI(),
 		PullPolicy:    clusterConfig.Spec.Images.DefaultPullPolicy,
 	}

pkg/config/runtime.go

@@ -107,16 +107,11 @@ func ParseRuntimeConfig(content []byte) (*RuntimeConfig, error) {
 	return &config, nil
 }
 
-func NewRuntimeConfig(k0sVars *CfgVars) (*RuntimeConfig, error) {
+func NewRuntimeConfig(k0sVars *CfgVars, nodeConfig *v1beta1.ClusterConfig) (*RuntimeConfig, error) {
 	if _, err := LoadRuntimeConfig(k0sVars.RuntimeConfigPath); err == nil {
 		return nil, ErrK0sAlreadyRunning
 	}
 
-	nodeConfig, err := k0sVars.NodeConfig()
-	if err != nil {
-		return nil, fmt.Errorf("load node config: %w", err)
-	}
-
 	cfg := &RuntimeConfig{
 		ObjectMeta: metav1.ObjectMeta{
 			CreationTimestamp: metav1.Now(),

pkg/config/runtime_test.go

@@ -69,21 +69,23 @@ func TestNewRuntimeConfig(t *testing.T) {
 		DataDir:           tempDir,
 	}
 
+	// Check if the node config can be loaded properly
+	nodeConfig, err := k0sVars.NodeConfig()
+	if assert.NoError(t, err) {
+		assert.Equal(t, "10.0.0.1", nodeConfig.Spec.API.Address)
+	}
+
 	// create a new runtime config and check if it's valid
-	cfg, err := NewRuntimeConfig(k0sVars)
-	spec := cfg.Spec
-	assert.NoError(t, err)
-	assert.NotNil(t, spec)
-	assert.Same(t, k0sVars, spec.K0sVars)
-	assert.Equal(t, os.Getpid(), spec.Pid)
-	assert.NotNil(t, spec.NodeConfig)
-	nodeConfig, err := spec.K0sVars.NodeConfig()
-	assert.NoError(t, err)
-	assert.Equal(t, "10.0.0.1", nodeConfig.Spec.API.Address)
+	cfg, err := NewRuntimeConfig(k0sVars, nodeConfig)
+	if assert.NoError(t, err) && assert.NotNil(t, cfg) && assert.NotNil(t, cfg.Spec) {
+		assert.Same(t, k0sVars, cfg.Spec.K0sVars)
+		assert.Same(t, nodeConfig, cfg.Spec.NodeConfig)
+		assert.Equal(t, os.Getpid(), cfg.Spec.Pid)
+	}
 	assert.FileExists(t, rtConfigPath)
 
 	// try to create a new runtime config when one is already active and check if it returns an error
-	_, err = NewRuntimeConfig(k0sVars)
+	_, err = NewRuntimeConfig(k0sVars, nil)
 	assert.Error(t, err)
 	assert.ErrorIs(t, err, ErrK0sAlreadyRunning)
 }