main.go

/*
Copyright 2020 Eric Ace.

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 (
	"flag"
	"os"
	"runtime/pprof"
	"strings"

	"github.com/aceeric/nuxeo-operator/controllers/nuxeo"
	"k8s.io/apimachinery/pkg/runtime"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/cache"
	"sigs.k8s.io/controller-runtime/pkg/log/zap"

	nuxeov1alpha1 "github.com/aceeric/nuxeo-operator/api/v1alpha1"
	// +kubebuilder:scaffold:imports
)

var (
	scheme     = runtime.NewScheme()
	setupLog   = ctrl.Log.WithName("setup")
	cpuProfile string
	version    string
)

func init() {
	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
	utilruntime.Must(nuxeov1alpha1.AddToScheme(scheme))
	// +kubebuilder:scaffold:scheme
}

func main() {
	var metricsAddr string
	var enableLeaderElection bool
	flag.StringVar(&metricsAddr, "metrics-addr", ":8080", "The address the metric endpoint binds to.")
	flag.BoolVar(&enableLeaderElection, "enable-leader-election", false,
		"Enable leader election for controller manager. "+
			"Enabling this will ensure there is only one active controller manager.")
	flag.StringVar(&cpuProfile, "cpu-profile", "", "Write CPU profile to file")
	flag.Parse()

	ctrl.SetLogger(zap.New(zap.UseDevMode(false)))

	if cpuProfile != "" {
		if f, err := os.Create(cpuProfile); err != nil {
			setupLog.Error(err, "can't open/create profile file: "+cpuProfile)
			os.Exit(1)
		} else if err := pprof.StartCPUProfile(f); err != nil {
			setupLog.Error(err, "failed to start profiler")
			os.Exit(1)
		}
		defer pprof.StopCPUProfile()
	}

	options := ctrl.Options{
		Scheme:             scheme,
		MetricsBindAddress: metricsAddr,
		Port:               9443,
		LeaderElection:     enableLeaderElection,
		LeaderElectionID:   "c4f5e369.appzygy.net",
	}

	watchNamespace := getWatchNamespace()
	if strings.Contains(watchNamespace, ",") {
		options.NewCache = cache.MultiNamespacedCacheBuilder(strings.Split(watchNamespace, ","))
	} else if watchNamespace != "" {
		options.Namespace = watchNamespace
	} // no initialization of options.Namespace means watch all

	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), options)
	if err != nil {
		setupLog.Error(err, "unable to start manager")
		os.Exit(1)
	}
	if err = (&nuxeo.NuxeoReconciler{
		Client: mgr.GetClient(),
		Log:    ctrl.Log.WithName("controllers").WithName("nuxeo-operator"),
		Scheme: mgr.GetScheme(),
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "nuxeo-operator")
		os.Exit(1)
	}
	if watchNamespace == "" {
		setupLog.Info("nuxeo operator version " + version + " is watching all namespaces")
	} else {
		setupLog.Info("nuxeo operator version " + version + " is watching namespace(s): " + watchNamespace)
	}
	// +kubebuilder:scaffold:builder
	setupLog.Info("starting manager")
	if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
		setupLog.Error(err, "problem running manager")
		os.Exit(1)
	}
}

// getWatchNamespace returns the Namespace(s) the operator is configured to watch via the WATCH_NAMESPACE
// env var. If the env var is not present, then the empty string is returned which means watch all
func getWatchNamespace() string {
	const watchNamespaceEnvVar = "WATCH_NAMESPACE"
	ns, found := os.LookupEnv(watchNamespaceEnvVar)
	if !found {
		return ""
	}
	return ns
}