github.com/zppinho/prow@v0.0.0-20240510014325-1738badeb017/cmd/config-bootstrapper/main.go

/*
Copyright 2018 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 main

import (
	"errors"
	"flag"
	"os"
	"path/filepath"

	"github.com/sirupsen/logrus"
	"k8s.io/client-go/kubernetes"
	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp" // support gcp users in .kube/config

	"sigs.k8s.io/prow/pkg/config"
	prowflagutil "sigs.k8s.io/prow/pkg/flagutil"
	configflagutil "sigs.k8s.io/prow/pkg/flagutil/config"
	pluginsflagutil "sigs.k8s.io/prow/pkg/flagutil/plugins"
	"sigs.k8s.io/prow/pkg/github"
	_ "sigs.k8s.io/prow/pkg/hook/plugin-imports"
	"sigs.k8s.io/prow/pkg/logrusutil"
	"sigs.k8s.io/prow/pkg/plugins"
	"sigs.k8s.io/prow/pkg/plugins/updateconfig"
)

const bootstrapMode = true

type options struct {
	sourcePaths prowflagutil.Strings

	config        configflagutil.ConfigOptions
	pluginsConfig pluginsflagutil.PluginOptions

	dryRun     bool
	kubernetes prowflagutil.KubernetesOptions
}

func gatherOptions() options {
	o := options{config: configflagutil.ConfigOptions{ConfigPath: "/etc/config/config.yaml"}}
	fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)

	fs.Var(&o.sourcePaths, "source-path", "Path to root of source directory to use for config updates. Can be set multiple times.")

	fs.BoolVar(&o.dryRun, "dry-run", true, "Whether or not to make mutating API calls to GitHub.")
	o.config.AddFlags(fs)
	o.pluginsConfig.PluginConfigPathDefault = "/etc/plugins/plugins.yaml"
	o.pluginsConfig.AddFlags(fs)
	o.kubernetes.AddFlags(fs)

	fs.Parse(os.Args[1:])
	return o
}

func (o *options) Validate() error {
	if len(o.sourcePaths.Strings()) == 0 {
		return errors.New("--source-path must be provided at least once")
	}

	for _, validate := range []interface{ Validate(bool) error }{&o.kubernetes, &o.config, &o.pluginsConfig} {
		if err := validate.Validate(o.dryRun); err != nil {
			return err
		}
	}

	return nil
}

type osFileGetter struct {
	roots []string
}

// GetFile returns the content of a file from disk, searching through all known roots.
// We assume that no two roots will contain the same relative path inside of them, as such
// a configuration would be racy and unsupported in the updateconfig plugin anyway.
func (g *osFileGetter) GetFile(filename string) ([]byte, error) {
	var loadErr error
	for _, root := range g.roots {
		candidatePath := filepath.Join(root, filename)
		if _, err := os.Stat(candidatePath); err == nil {
			// we found the file under this root
			return os.ReadFile(candidatePath)
		} else if !os.IsNotExist(err) {
			// record this for later in case we can't find the file
			loadErr = err
		}
	}
	// file was found under no root
	return nil, loadErr
}

func run(sourcePaths []string, defaultNamespace string, configUpdater plugins.ConfigUpdater, client kubernetes.Interface, buildClusterCoreV1Clients map[string]corev1.CoreV1Interface) int {
	var errors int
	// act like the whole repo just got committed
	var changes []github.PullRequestChange
	var version string

	// Pretend that all files found in the sourcePaths are newly added
	// (github.PullRequestFileAdded). This is because we are running against a
	// static set of files and are not sure how these files came to be. So we
	// pretend that these files are newly added.
	for _, sourcePath := range sourcePaths {

		versionFilePath := filepath.Join(sourcePath, config.ConfigVersionFileName)
		if _, errAccess := os.Stat(versionFilePath); errAccess == nil {
			content, err := os.ReadFile(versionFilePath)
			if err != nil {
				logrus.WithError(err).Warn("failed to read versionfile")
			} else if version == "" {
				version = string(content)
			}
		}

		filepath.Walk(sourcePath, func(path string, info os.FileInfo, err error) error {
			if info.IsDir() {
				return nil
			}
			// we know path will be below sourcePaths, but we can't
			// communicate that to the filepath module. We can ignore
			// this error as we can be certain it won't occur
			if relPath, err := filepath.Rel(sourcePath, path); err == nil {
				changes = append(changes, github.PullRequestChange{
					Filename: relPath,
					Status:   github.PullRequestFileAdded,
				})
				logrus.Infof("added to mock change: %s", relPath)
			} else {
				logrus.WithError(err).Warn("unexpected error determining relative path to file")
				errors++
			}
			return nil
		})
	}

	for cm, data := range updateconfig.FilterChanges(configUpdater, changes, defaultNamespace, bootstrapMode, logrus.NewEntry(logrus.StandardLogger())) {
		logger := logrus.WithFields(logrus.Fields{"configmap": map[string]string{"name": cm.Name, "namespace": cm.Namespace, "cluster": cm.Cluster}})
		configMapClient, err := updateconfig.GetConfigMapClient(client.CoreV1(), cm.Namespace, buildClusterCoreV1Clients, cm.Cluster)
		if err != nil {
			errors++
			logrus.WithError(err).Errorf("Failed to find configMap client")
			continue
		}
		if err := updateconfig.Update(&osFileGetter{roots: sourcePaths}, configMapClient, cm.Name, cm.Namespace, data, bootstrapMode, nil, logger, version); err != nil {
			logger.WithError(err).Error("failed to update config on cluster")
			errors++
		} else {
			logger.Info("Successfully processed configmap")
		}
	}
	return errors
}

func main() {
	logrusutil.ComponentInit()

	o := gatherOptions()
	if err := o.Validate(); err != nil {
		logrus.WithError(err).Fatal("Invalid options")
	}

	configAgent, err := o.config.ConfigAgent()
	if err != nil {
		logrus.WithError(err).Fatal("Error starting config agent.")
	}

	pluginAgent, err := o.pluginsConfig.PluginAgent()
	if err != nil {
		logrus.WithError(err).Fatal("Error starting plugin configuration agent.")
	}

	client, err := o.kubernetes.InfrastructureClusterClient(o.dryRun)
	if err != nil {
		logrus.WithError(err).Fatal("Error getting Kubernetes client.")
	}

	buildClusterCoreV1Clients, err := o.kubernetes.BuildClusterCoreV1Clients(o.dryRun)
	if err != nil {
		logrus.WithError(err).Fatal("Error getting Kubernetes clients for build cluster.")
	}

	if errors := run(o.sourcePaths.Strings(), configAgent.Config().ProwJobNamespace, pluginAgent.Config().ConfigUpdater, client, buildClusterCoreV1Clients); errors > 0 {
		logrus.WithField("fail-count", errors).Fatalf("errors occurred during update")
	}
}