vnfs/DAaaS/collectd-operator/cmd/manager/main.go

   1 package main
   2
   3 import (
   4         "context"
   5         "flag"
   6         "fmt"
   7         "os"
   8         "runtime"
   9
  10         // Import all Kubernetes client auth plugins (e.g. Azure, GCP, OIDC, etc.)
  11         _ "k8s.io/client-go/plugin/pkg/client/auth"
  12
  13         "demo/vnfs/DAaaS/collectd-operator/pkg/apis"
  14         "demo/vnfs/DAaaS/collectd-operator/pkg/controller"
  15
  16         "github.com/operator-framework/operator-sdk/pkg/k8sutil"
  17         "github.com/operator-framework/operator-sdk/pkg/leader"
  18         "github.com/operator-framework/operator-sdk/pkg/log/zap"
  19         "github.com/operator-framework/operator-sdk/pkg/metrics"
  20         "github.com/operator-framework/operator-sdk/pkg/restmapper"
  21         sdkVersion "github.com/operator-framework/operator-sdk/version"
  22         "github.com/spf13/pflag"
  23         "sigs.k8s.io/controller-runtime/pkg/client/config"
  24         "sigs.k8s.io/controller-runtime/pkg/manager"
  25         logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
  26         "sigs.k8s.io/controller-runtime/pkg/runtime/signals"
  27 )
  28
  29 // Change below variables to serve metrics on different host or port.
  30 var (
  31         metricsHost       = "0.0.0.0"
  32         metricsPort int32 = 8383
  33 )
  34 var log = logf.Log.WithName("cmd")
  35
  36 func printVersion() {
  37         log.Info(fmt.Sprintf("Go Version: %s", runtime.Version()))
  38         log.Info(fmt.Sprintf("Go OS/Arch: %s/%s", runtime.GOOS, runtime.GOARCH))
  39         log.Info(fmt.Sprintf("Version of operator-sdk: %v", sdkVersion.Version))
  40 }
  41
  42 func main() {
  43         // Add the zap logger flag set to the CLI. The flag set must
  44         // be added before calling pflag.Parse().
  45         pflag.CommandLine.AddFlagSet(zap.FlagSet())
  46
  47         // Add flags registered by imported packages (e.g. glog and
  48         // controller-runtime)
  49         pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
  50
  51         pflag.Parse()
  52
  53         // Use a zap logr.Logger implementation. If none of the zap
  54         // flags are configured (or if the zap flag set is not being
  55         // used), this defaults to a production zap logger.
  56         //
  57         // The logger instantiated here can be changed to any logger
  58         // implementing the logr.Logger interface. This logger will
  59         // be propagated through the whole operator, generating
  60         // uniform and structured logs.
  61         logf.SetLogger(zap.Logger())
  62
  63         printVersion()
  64
  65         namespace, err := k8sutil.GetWatchNamespace()
  66         if err != nil {
  67                 log.Error(err, "Failed to get watch namespace")
  68                 os.Exit(1)
  69         }
  70
  71         // Get a config to talk to the apiserver
  72         cfg, err := config.GetConfig()
  73         if err != nil {
  74                 log.Error(err, "")
  75                 os.Exit(1)
  76         }
  77
  78         ctx := context.TODO()
  79
  80         // Become the leader before proceeding
  81         err = leader.Become(ctx, "collectd-operator-lock")
  82         if err != nil {
  83                 log.Error(err, "")
  84                 os.Exit(1)
  85         }
  86
  87         // Create a new Cmd to provide shared dependencies and start components
  88         mgr, err := manager.New(cfg, manager.Options{
  89                 Namespace:          namespace,
  90                 MapperProvider:     restmapper.NewDynamicRESTMapper,
  91                 MetricsBindAddress: fmt.Sprintf("%s:%d", metricsHost, metricsPort),
  92         })
  93         if err != nil {
  94                 log.Error(err, "")
  95                 os.Exit(1)
  96         }
  97
  98         log.Info("Registering Components.")
  99
 100         // Setup Scheme for all resources
 101         if err := apis.AddToScheme(mgr.GetScheme()); err != nil {
 102                 log.Error(err, "")
 103                 os.Exit(1)
 104         }
 105
 106         // Setup all Controllers
 107         if err := controller.AddToManager(mgr); err != nil {
 108                 log.Error(err, "")
 109                 os.Exit(1)
 110         }
 111
 112         // Create Service object to expose the metrics port.
 113         _, err = metrics.ExposeMetricsPort(ctx, metricsPort)
 114         if err != nil {
 115                 log.Info(err.Error())
 116         }
 117
 118         log.Info("Starting the Cmd.")
 119
 120         // Start the Cmd
 121         if err := mgr.Start(signals.SetupSignalHandler()); err != nil {
 122                 log.Error(err, "Manager exited non-zero")
 123                 os.Exit(1)
 124         }
 125 }