feat(windows): Create daemon for non-k8s orchestration and update enricher, cache and controller to support standalone mode

cmd/observability/utils.go

@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+package observability
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/microsoft/retina/internal/buildinfo"
+	"github.com/microsoft/retina/pkg/config"
+	"github.com/microsoft/retina/pkg/log"
+	"github.com/microsoft/retina/pkg/telemetry"
+	"go.uber.org/zap"
+	"k8s.io/client-go/rest"
+)
+
+const (
+	logFileName = "retina.log"
+)
+
+func InitializeTelemetryClient(restCfg *rest.Config, enabledPlugin []string, enableTelemetry bool, l *zap.SugaredLogger) (telemetry.Telemetry, error) {
+	if enableTelemetry {
+		if buildinfo.ApplicationInsightsID == "" {
+			panic("telemetry enabled, but ApplicationInsightsID is empty")
+		}
+		l.Info("telemetry enabled", zap.String("applicationInsightsID", buildinfo.ApplicationInsightsID))
+
+		var tel telemetry.Telemetry
+		var err error
+		if restCfg != nil {
+			tel, err = telemetry.NewAppInsightsTelemetryClient("retina-agent", map[string]string{
+				"version":   buildinfo.Version,
+				"apiserver": restCfg.Host,
+				"plugins":   strings.Join(enabledPlugin, `,`),
+			})
+		} else {
+			tel, err = telemetry.NewAppInsightsTelemetryClient("standalone-retina-agent", map[string]string{
+				"version": buildinfo.Version,
+				"plugins": strings.Join(enabledPlugin, `,`),
+			})
+		}
+		if err != nil {
+			l.Error("failed to create telemetry client", zap.Error(err))
+			return tel, fmt.Errorf("error when creating telemetry client: %w", err)
+		}
+		return tel, nil
+	}
+
+	l.Info("telemetry disabled")
+	tel := telemetry.NewNoopTelemetry()
+	return tel, nil
+}
+
+func InitializeLogger(logLevel string, enableTelemetry bool, enabledPlugin []string, dataAggregationLevel config.Level) *log.ZapLogger {
+	if buildinfo.ApplicationInsightsID != "" {
+		telemetry.InitAppInsights(buildinfo.ApplicationInsightsID, buildinfo.Version)
+		defer telemetry.ShutdownAppInsights()
+		defer telemetry.TrackPanic()
+	}
+
+	fmt.Println("init logger")
+	zl, err := log.SetupZapLogger(&log.LogOpts{
+		Level:                 logLevel,
+		File:                  false,
+		FileName:              logFileName,
+		MaxFileSizeMB:         100, //nolint:gomnd // defaults
+		MaxBackups:            3,   //nolint:gomnd // defaults
+		MaxAgeDays:            30,  //nolint:gomnd // defaults
+		ApplicationInsightsID: buildinfo.ApplicationInsightsID,
+		EnableTelemetry:       enableTelemetry,
+	},
+		zap.String("version", buildinfo.Version),
+		zap.String("plugins", strings.Join(enabledPlugin, `,`)),
+		zap.String("data aggregation level", dataAggregationLevel.String()),
+	)
+	if err != nil {
+		panic(err)
+	}
+	defer zl.Close()
+
+	return zl
+}

cmd/root.go

@@ -28,7 +28,7 @@ var (
 		RunE: func(cmd *cobra.Command, args []string) error {
 			// Do Stuff Here
 			fmt.Println("Starting Retina Agent")
-			d := standard.NewDaemon(metricsAddr, probeAddr, cfgFile, enableLeaderElection)
+			d := standard.NewDaemon(cfgFile, metricsAddr, probeAddr, enableLeaderElection)
 			if err := d.Start(); err != nil {
 				return fmt.Errorf("starting daemon: %w", err)
 			}

cmd/standalone.go

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/microsoft/retina/cmd/standalone"
+	"github.com/microsoft/retina/internal/buildinfo"
+	"github.com/spf13/cobra"
+)
+
+var standaloneCmd = &cobra.Command{
+	Use:   "standalone",
+	Short: "Start Retina without K8s control plane",
+	RunE: func(cobraCmd *cobra.Command, _ []string) error {
+		if v, _ := cobraCmd.Flags().GetBool("version"); v {
+			fmt.Printf("%s %s\n", cobraCmd.Name(), buildinfo.Version)
+		}
+		d := standalone.NewDaemon(cfgFile)
+		if err := d.Start(); err != nil {
+			return fmt.Errorf("starting standalone daemon: %w", err)
+		}
+		return nil
+	},
+}
+
+func init() {
+	standaloneCmd.Flags().AddFlagSet(rootCmd.Flags())
+	rootCmd.AddCommand(standaloneCmd)
+}

cmd/standalone/daemon.go

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+package standalone
+
+import (
+	"fmt"
+
+	"github.com/microsoft/retina/cmd/observability"
+	"github.com/microsoft/retina/pkg/enricher"
+	"github.com/microsoft/retina/pkg/metrics"
+	"go.uber.org/zap"
+	ctrl "sigs.k8s.io/controller-runtime"
+
+	"github.com/microsoft/retina/pkg/config"
+	cache "github.com/microsoft/retina/pkg/controllers/cache/standalone"
+	sc "github.com/microsoft/retina/pkg/controllers/daemon/standalone"
+	cm "github.com/microsoft/retina/pkg/managers/controllermanager"
+	sm "github.com/microsoft/retina/pkg/module/metrics/standalone"
+)
+
+type Daemon struct {
+	configFile string
+}
+
+func NewDaemon(configFile string) *Daemon {
+	return &Daemon{
+		configFile: configFile,
+	}
+}
+
+func (d *Daemon) Start() error {
+	fmt.Printf("Starting Retina daemon in standalone mode\n")
+
+	daemonCfg, err := config.GetStandaloneConfig(d.configFile)
+	if err != nil {
+		panic(err)
+	}
+	zl := observability.InitializeLogger(daemonCfg.LogLevel, daemonCfg.EnableTelemetry, daemonCfg.EnabledPlugin, daemonCfg.DataAggregationLevel)
+	mainLogger := zl.Named("main").Sugar()
+
+	// Initialize basic metrics and telemetry client
+	metrics.InitializeMetrics()
+	tel, err := observability.InitializeTelemetryClient(nil, daemonCfg.EnabledPlugin, daemonCfg.EnableTelemetry, mainLogger)
+	if err != nil {
+		return fmt.Errorf("failed to initialize telemetry client: %w", err)
+	}
+
+	// Initialize cache and run enricher
+	ctx := ctrl.SetupSignalHandler()
+	controllerCache := cache.New()
+	enrich := enricher.NewStandalone(ctx, controllerCache)
+	enrich.Run()
+
+	// Initialize metrics module
+	metricsModule := sm.InitModule(ctx, enrich)
+
+	mainLogger.Info("Initializing RetinaEndpoint controller")
+	controller, err := sc.New(daemonCfg, controllerCache, metricsModule)
+	if err != nil {
+		mainLogger.Fatal("failed to create RetinaEndpoint controller", zap.Error(err))
+	}
+	go controller.Run(ctx)
+
+	// Initialize controller manager
+	controllerMgr, err := cm.NewStandaloneControllerManager(daemonCfg, tel)
+	if err != nil {
+		mainLogger.Fatal("failed to create standalone controller manager", zap.Error(err))
+	}
+	if err := controllerMgr.Init(); err != nil {
+		mainLogger.Fatal("failed to initialize standalone controller manager", zap.Error(err))
+	}
+
+	// start heartbeat goroutine for application insights
+	go tel.Heartbeat(ctx, daemonCfg.TelemetryInterval)
+
+	// Start controller manager, which will start the http server and plugin manager
+	go controllerMgr.Start(ctx)
+	mainLogger.Info("Started controller manager")
+
+	<-ctx.Done()
+	controllerMgr.Stop()
+
+	mainLogger.Info("Network observability exiting. Till next time!")
+	return nil
+}