main.go

/*
Copyright 2021.

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 (
	"crypto/tls"
	"flag"
	"fmt"
	"os"
	"reflect"
	"strings"

	// Import all Kubernetes client auth plugins (e.g. Azure, GCP, OIDC, etc.)
	// to ensure that exec-entrypoint and run can make use of them.
	"go.uber.org/zap/zapcore"
	"k8s.io/client-go/kubernetes"
	_ "k8s.io/client-go/plugin/pkg/client/auth"

	rolloutManagerApi "github.com/argoproj-labs/argo-rollouts-manager/api/v1alpha1"
	rolloutManagerProvisioner "github.com/argoproj-labs/argo-rollouts-manager/controllers"
	argov1alpha1api "github.com/argoproj-labs/argocd-operator/api/v1alpha1"
	argov1beta1api "github.com/argoproj-labs/argocd-operator/api/v1beta1"
	argocdcommon "github.com/argoproj-labs/argocd-operator/common"
	argocdprovisioner "github.com/argoproj-labs/argocd-operator/controllers/argocd"
	"github.com/argoproj-labs/argocd-operator/controllers/argoutil"
	notificationsprovisioner "github.com/argoproj-labs/argocd-operator/controllers/notificationsconfiguration"
	"github.com/argoproj-labs/argocd-operator/pkg/cacheutils"
	cw "github.com/argoproj-labs/argocd-operator/pkg/clientwrapper"
	appsv1 "github.com/openshift/api/apps/v1"
	configv1 "github.com/openshift/api/config/v1"
	console "github.com/openshift/api/console/v1"
	oauthv1 "github.com/openshift/api/oauth/v1"
	routev1 "github.com/openshift/api/route/v1"
	templatev1 "github.com/openshift/api/template/v1"
	operatorsv1 "github.com/operator-framework/api/pkg/operators/v1"
	operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"
	monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"
	corev1 "k8s.io/api/core/v1"
	crdv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
	"k8s.io/apimachinery/pkg/labels"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/cache"
	crclient "sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/client/config"
	controllerconfig "sigs.k8s.io/controller-runtime/pkg/config"
	"sigs.k8s.io/controller-runtime/pkg/healthz"
	"sigs.k8s.io/controller-runtime/pkg/log/zap"
	"sigs.k8s.io/controller-runtime/pkg/manager"
	"sigs.k8s.io/controller-runtime/pkg/webhook"

	pipelinesv1alpha1 "github.com/redhat-developer/gitops-operator/api/v1alpha1"
	"github.com/redhat-developer/gitops-operator/common"
	"github.com/redhat-developer/gitops-operator/controllers"
	"github.com/redhat-developer/gitops-operator/controllers/argocd/openshift"
	"github.com/redhat-developer/gitops-operator/controllers/util"
	k8sruntime "k8s.io/apimachinery/pkg/runtime"
	"sigs.k8s.io/controller-runtime/pkg/metrics/filters"
	metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"
	//+kubebuilder:scaffold:imports
)

var (
	scheme   = k8sruntime.NewScheme()
	setupLog = ctrl.Log.WithName("setup")
)

func init() {
	utilruntime.Must(clientgoscheme.AddToScheme(scheme))

	utilruntime.Must(pipelinesv1alpha1.AddToScheme(scheme))
	//+kubebuilder:scaffold:scheme
}

func main() {
	var metricsAddr string
	var enableLeaderElection bool
	var probeAddr string

	var enableHTTP2 = false
	var skipControllerNameValidation = true

	var labelSelectorFlag string
	flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.")
	flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.")
	flag.StringVar(&labelSelectorFlag, "label-selector", common.StringFromEnv(argocdcommon.ArgoCDLabelSelectorKey, argocdcommon.ArgoCDDefaultLabelSelector), "The label selector is used to map to a subset of ArgoCD instances to reconcile")
	flag.BoolVar(&enableLeaderElection, "leader-elect", false,
		"Enable leader election for controller manager. "+
			"Enabling this will ensure there is only one active controller manager.")
	flag.BoolVar(&enableHTTP2, "enable-http2", enableHTTP2, "If HTTP/2 should be enabled for the metrics and webhook servers.")

	//Configure log level
	logLevelStr := strings.ToLower(os.Getenv("LOG_LEVEL"))
	logLevel := zapcore.InfoLevel
	switch logLevelStr {
	case "debug":
		logLevel = zapcore.DebugLevel
	case "info":
		logLevel = zapcore.InfoLevel
	case "warn":
		logLevel = zapcore.WarnLevel
	case "error":
		logLevel = zapcore.ErrorLevel
	case "panic":
		logLevel = zapcore.PanicLevel
	case "fatal":
		logLevel = zapcore.FatalLevel
	}

	opts := zap.Options{
		Development: true,
		Level:       logLevel,
		TimeEncoder: zapcore.RFC3339TimeEncoder,
	}
	opts.BindFlags(flag.CommandLine)
	flag.Parse()

	ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts)))

	if err := util.InspectCluster(); err != nil {
		setupLog.Error(err, "unable to inspect cluster")
	}

	disableHTTP2 := func(c *tls.Config) {
		if enableHTTP2 {
			return
		}
		c.NextProtos = []string{"http/1.1"}
	}
	webhookServerOptions := webhook.Options{
		TLSOpts: []func(config *tls.Config){disableHTTP2},
		Port:    9443,
	}
	webhookServer := webhook.NewServer(webhookServerOptions)

	metricsServerOptions := metricsserver.Options{
		BindAddress:    metricsAddr,
		TLSOpts:        []func(*tls.Config){disableHTTP2},
		FilterProvider: filters.WithAuthenticationAndAuthorization,
	}

	// Set default manager options
	options := ctrl.Options{
		Scheme:                 scheme,
		Metrics:                metricsServerOptions,
		WebhookServer:          webhookServer,
		HealthProbeBindAddress: probeAddr,
		LeaderElection:         enableLeaderElection,
		LeaderElectionID:       "2b63967d.openshift.io",
		Controller: controllerconfig.Controller{
			SkipNameValidation: &skipControllerNameValidation,
		},
	}

	// Use transformers to strip data from Secrets and ConfigMaps
	// that are not tracked by the operator to reduce memory usage.
	if strings.ToLower(os.Getenv("MEMORY_OPTIMIZATION_ENABLED")) != "false" {
		setupLog.Info("memory optimization is enabled")
		options.Cache = cache.Options{
			Scheme: scheme,
			ByObject: map[crclient.Object]cache.ByObject{
				&corev1.Secret{}:    {Transform: cacheutils.StripDataFromSecretOrConfigMapTransform()},
				&corev1.ConfigMap{}: {Transform: cacheutils.StripDataFromSecretOrConfigMapTransform()},
			},
		}
	}

	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), options)
	if err != nil {
		setupLog.Error(err, "unable to start manager")
		os.Exit(1)
	}

	var client crclient.Client
	if strings.ToLower(os.Getenv("MEMORY_OPTIMIZATION_ENABLED")) != "false" {
		liveClient, err := crclient.New(ctrl.GetConfigOrDie(), crclient.Options{Scheme: mgr.GetScheme()})
		if err != nil {
			setupLog.Error(err, "unable to create live client")
			os.Exit(1)
		}
		client = cw.NewClientWrapper(mgr.GetClient(), liveClient)
	} else {
		client = mgr.GetClient()
	}

	// Setup Scheme for OpenShift Console if available (verified by InspectCluster)
	if util.IsConsoleAPIFound() {
		registerComponentOrExit(mgr, console.AddToScheme)
	}

	// Setup Scheme for OpenShift Route if available (verified by InspectCluster)
	if util.IsRouteAPIFound() {
		registerComponentOrExit(mgr, routev1.AddToScheme)
	}

	// Setup Scheme for Prometheus Operator if available (verified by InspectCluster)
	if util.IsMonitoringAPIFound() {
		registerComponentOrExit(mgr, monitoringv1.AddToScheme)
	}

	// Setup Scheme for OLM if available (verified by InspectCluster)
	if util.IsOLMAPIFound() {
		registerComponentOrExit(mgr, operatorsv1.AddToScheme)
		registerComponentOrExit(mgr, operatorsv1alpha1.AddToScheme)
	}

	registerComponentOrExit(mgr, argov1alpha1api.AddToScheme)
	registerComponentOrExit(mgr, argov1beta1api.AddToScheme)

	// Setup Scheme for OpenShift Config if available
	var disableDefault bool
	disableDefault = strings.ToLower(os.Getenv(common.DisableDefaultInstallEnvVar)) == "true"
	if util.IsConfigAPIFound() {
		registerComponentOrExit(mgr, configv1.AddToScheme)
	} else {
		setupLog.Info("Non-OpenShift cluster detected, disabling default Argo CD instance")
		disableDefault = true
	}

	registerComponentOrExit(mgr, rolloutManagerApi.AddToScheme)

	// Setup Scheme for OpenShift Template if available (verified by InspectCluster)
	if util.IsTemplateAPIFound() {
		registerComponentOrExit(mgr, templatev1.AddToScheme)
	}

	// Setup Scheme for OpenShift Apps if available (verified by InspectCluster)
	if util.IsAppsAPIFound() {
		registerComponentOrExit(mgr, appsv1.AddToScheme)
	}

	// Setup Scheme for OpenShift OAuth if available (verified by InspectCluster)
	if util.IsOAuthAPIFound() {
		registerComponentOrExit(mgr, oauthv1.AddToScheme)
	}

	registerComponentOrExit(mgr, crdv1.AddToScheme)

	// Start webhook only if ENABLE_CONVERSION_WEBHOOK is set
	if strings.EqualFold(os.Getenv("ENABLE_CONVERSION_WEBHOOK"), "true") {
		if err = (&argov1beta1api.ArgoCD{}).SetupWebhookWithManager(mgr); err != nil {
			setupLog.Error(err, "unable to create webhook", "webhook", "ArgoCD")
			os.Exit(1)
		}
	}

	if err = (&controllers.ReconcileGitopsService{
		Client:                client,
		Scheme:                mgr.GetScheme(),
		DisableDefaultInstall: disableDefault,
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "GitopsService")
		os.Exit(1)
	}

	if util.IsRouteAPIFound() {
		if err = (&controllers.ReconcileArgoCDRoute{
			Client: client,
			Scheme: mgr.GetScheme(),
		}).SetupWithManager(mgr); err != nil {
			setupLog.Error(err, "unable to create controller", "controller", "Argo CD route")
			os.Exit(1)
		}
	} else {
		setupLog.Info("Route API not found, skipping ReconcileArgoCDRoute controller setup")
	}

	if util.IsMonitoringAPIFound() {
		if err = (&controllers.ArgoCDMetricsReconciler{
			Client: client,
			Scheme: mgr.GetScheme(),
		}).SetupWithManager(mgr); err != nil {
			setupLog.Error(err, "unable to create controller", "controller", "Argo CD metrics")
			os.Exit(1)
		}
	} else {
		setupLog.Info("Monitoring API not found, skipping Argo CD metrics controller setup")
	}

	// Check the label selector format eg. "foo=bar"
	if _, err := labels.Parse(labelSelectorFlag); err != nil {
		setupLog.Error(err, "error parsing the labelSelector '%s'.", labelSelectorFlag)
		os.Exit(1)
	}
	setupLog.Info(fmt.Sprintf("Watching label-selector \"%s\"", labelSelectorFlag))

	k8sClient, err := initK8sClient()
	if err != nil {
		setupLog.Error(err, "Failed to initialize Kubernetes client")
		os.Exit(1)
	}

	argocdprovisioner.Register(openshift.ReconcilerHook, openshift.BuilderHook)

	if err = (&argocdprovisioner.ReconcileArgoCD{
		Client:            client,
		Scheme:            mgr.GetScheme(),
		LabelSelector:     labelSelectorFlag,
		K8sClient:         k8sClient,
		LocalUsers:        argocdprovisioner.NewLocalUsersInfo(),
		FipsConfigChecker: argoutil.NewLinuxFipsConfigChecker(),
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "Argo CD")
		os.Exit(1)
	}

	isNamespaceScoped := strings.ToLower(os.Getenv(rolloutManagerProvisioner.NamespaceScopedArgoRolloutsController)) == "true"

	if isNamespaceScoped {
		setupLog.Info("Argo Rollouts manager running in namespaced-scoped mode")
	} else {
		setupLog.Info("Argo Rollouts manager running in cluster-scoped mode")
	}

	resourceLabels := map[string]string{
		argocdcommon.ArgoCDTrackedByOperatorLabel: argocdcommon.ArgoCDAppName,
	}

	if err = (&rolloutManagerProvisioner.RolloutManagerReconciler{
		Client:                                client,
		Scheme:                                mgr.GetScheme(),
		OpenShiftRoutePluginLocation:          getArgoRolloutsOpenshiftRouteTrafficManagerPath(),
		NamespaceScopedArgoRolloutsController: isNamespaceScoped,
		ResourceLabels:                        resourceLabels,
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "Argo Rollouts")
		os.Exit(1)
	}

	if err = (&notificationsprovisioner.NotificationsConfigurationReconciler{
		Client: client,
		Scheme: mgr.GetScheme(),
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "Notifications Configuration")
		os.Exit(1)
	}

	//+kubebuilder:scaffold:builder

	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
		setupLog.Error(err, "unable to set up health check")
		os.Exit(1)
	}
	if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {
		setupLog.Error(err, "unable to set up ready check")
		os.Exit(1)
	}

	setupLog.Info("starting manager")
	if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
		setupLog.Error(err, "problem running manager")
		os.Exit(1)
	}
}

// getArgoRolloutsOpenshiftRouteTrafficManagerPath returns the location of the Argo Rollouts OpenShift Route Traffic Management plugin. The location of the plugin is different based on whether we are running as part of OpenShift GitOps, or gitops-operator.
func getArgoRolloutsOpenshiftRouteTrafficManagerPath() string {

	// First, allow the user to change the plugin location via env var
	openShiftRoutePluginLocation := os.Getenv("OPENSHIFT_ROUTE_PLUGIN_LOCATION")
	if openShiftRoutePluginLocation != "" {
		return openShiftRoutePluginLocation
	}

	// Next, if we are running on an image built by CPaaS, then we can assume that the openshift-route-plugin has been installed to '/plugins/rollouts-trafficrouter-openshift/openshift-route-plugin' within the 'registry.redhat.io/openshift-gitops-1/argo-rollouts-rhel*' container image.
	// However, if we are not running an image built by CPaaS, for example, because we are running the gitops-operator upstream E2E tests, then we default to retrieving Route plugin from the upstream dependency: https://github.com/argoproj-labs/argo-rollouts-manager/blob/1f89f7a53b712f83c7051503d571ae2758fed9d6/main.go#L53

	argoRolloutsImage := os.Getenv("ARGO_ROLLOUTS_IMAGE")
	if argoRolloutsImage != "" && strings.HasPrefix(argoRolloutsImage, "registry.redhat.io/openshift-gitops") {
		openShiftRoutePluginLocation = "file:/plugins/rollouts-trafficrouter-openshift/openshift-route-plugin"
		return openShiftRoutePluginLocation
	}

	// Otherwise, if ARGO_ROLLOUTS_IMAGE is not set, or is not an OpenShift GitOps image, then we return the default from the dependency.
	return rolloutManagerProvisioner.DefaultOpenShiftRoutePluginURL

}

func registerComponentOrExit(mgr manager.Manager, f func(*k8sruntime.Scheme) error) {
	// Setup Scheme for all resources
	if err := f(mgr.GetScheme()); err != nil {
		setupLog.Error(err, "")
		os.Exit(1)
	}
	setupLog.Info(fmt.Sprintf("Component registered: %v", reflect.ValueOf(f)))
}

func initK8sClient() (*kubernetes.Clientset, error) {
	cfg, err := config.GetConfig()
	if err != nil {
		setupLog.Error(err, "unable to get k8s config")
		return nil, err
	}

	k8sClient, err := kubernetes.NewForConfig(cfg)
	if err != nil {
		setupLog.Error(err, "unable to create k8s client")
		return nil, err
	}

	return k8sClient, nil
}